c3e7eb19e8
Change-Id: I43f342c3552e195fe5d96b07c93be7bfef5a708a Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1713006 Reviewed-by: Junliang Yan <jyan@ca.ibm.com> Commit-Queue: Junliang Yan <jyan@ca.ibm.com> Cr-Commit-Position: refs/heads/master@{#62859}
1058 lines
29 KiB
C++
1058 lines
29 KiB
C++
// Copyright 2014 the V8 project authors. All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include "src/init/v8.h"
|
|
|
|
#include "src/codegen/macro-assembler.h"
|
|
#include "src/codegen/s390/assembler-s390-inl.h"
|
|
#include "src/diagnostics/disassembler.h"
|
|
#include "src/execution/simulator.h"
|
|
#include "src/heap/factory.h"
|
|
#include "test/cctest/cctest.h"
|
|
#include "test/common/assembler-tester.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
// Define these function prototypes to match JSEntryFunction in execution.cc.
|
|
// TODO(s390): Refine these signatures per test case.
|
|
using F1 = void*(int x, int p1, int p2, int p3, int p4);
|
|
using F2 = void*(int x, int y, int p2, int p3, int p4);
|
|
using F3 = void*(void* p0, int p1, int p2, int p3, int p4);
|
|
using F4 = void*(void* p0, void* p1, int p2, int p3, int p4);
|
|
|
|
#define __ assm.
|
|
|
|
// Simple add parameter 1 to parameter 2 and return
|
|
TEST(0) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
__ lhi(r1, Operand(3)); // test 4-byte instr
|
|
__ llilf(r2, Operand(4)); // test 6-byte instr
|
|
__ lgr(r2, r2); // test 2-byte opcode
|
|
__ ar(r2, r1); // test 2-byte instr
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F2>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(3, 4, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(7, static_cast<int>(res));
|
|
}
|
|
|
|
// Loop 100 times, adding loop counter to result
|
|
TEST(1) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
Label L, C;
|
|
|
|
#if defined(_AIX)
|
|
__ function_descriptor();
|
|
#endif
|
|
|
|
__ lr(r3, r2);
|
|
__ lhi(r2, Operand(0, RelocInfo::NONE));
|
|
__ b(&C);
|
|
|
|
__ bind(&L);
|
|
__ ar(r2, r3);
|
|
__ ahi(r3, Operand(-1 & 0xFFFF));
|
|
|
|
__ bind(&C);
|
|
__ cfi(r3, Operand(0, RelocInfo::NONE));
|
|
__ bne(&L);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(100, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(5050, static_cast<int>(res));
|
|
}
|
|
|
|
TEST(2) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
// Create a function that accepts &t, and loads, manipulates, and stores
|
|
// the doubles and floats.
|
|
Assembler assm(AssemblerOptions{});
|
|
Label L, C;
|
|
|
|
#if defined(_AIX)
|
|
__ function_descriptor();
|
|
#endif
|
|
|
|
__ lgr(r3, r2);
|
|
__ lhi(r2, Operand(1));
|
|
__ b(&C);
|
|
|
|
__ bind(&L);
|
|
__ lr(r5, r2); // Set up muliplicant in R4:R5
|
|
__ mr_z(r4, r3); // this is actually R4:R5 = R5 * R2
|
|
__ lr(r2, r5);
|
|
__ ahi(r3, Operand(-1 & 0xFFFF));
|
|
|
|
__ bind(&C);
|
|
__ cfi(r3, Operand(0, RelocInfo::NONE));
|
|
__ bne(&L);
|
|
__ b(r14);
|
|
|
|
// some relocated stuff here, not executed
|
|
__ RecordComment("dead code, just testing relocations");
|
|
__ iilf(r0, Operand(isolate->factory()->true_value()));
|
|
__ RecordComment("dead code, just testing immediate operands");
|
|
__ iilf(r0, Operand(-1));
|
|
__ iilf(r0, Operand(0xFF000000));
|
|
__ iilf(r0, Operand(0xF0F0F0F0));
|
|
__ iilf(r0, Operand(0xFFF0FFFF));
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(10, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(3628800, static_cast<int>(res));
|
|
}
|
|
|
|
TEST(3) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
__ ar(r14, r13);
|
|
__ sr(r14, r13);
|
|
__ mr_z(r14, r13);
|
|
__ dr(r14, r13);
|
|
__ or_z(r14, r13);
|
|
__ nr(r14, r13);
|
|
__ xr(r14, r13);
|
|
|
|
__ agr(r14, r13);
|
|
__ sgr(r14, r13);
|
|
__ ogr(r14, r13);
|
|
__ ngr(r14, r13);
|
|
__ xgr(r14, r13);
|
|
|
|
__ ahi(r13, Operand(123));
|
|
__ aghi(r13, Operand(123));
|
|
__ stm(r1, r2, MemOperand(r3, r0, 123));
|
|
__ slag(r1, r2, Operand(123));
|
|
__ lay(r1, MemOperand(r2, r3, -123));
|
|
__ a(r13, MemOperand(r1, r2, 123));
|
|
__ ay(r13, MemOperand(r1, r2, 123));
|
|
__ brc(Condition(14), Operand(123));
|
|
__ brc(Condition(14), Operand(-123));
|
|
__ brcl(Condition(14), Operand(123));
|
|
__ brcl(Condition(14), Operand(-123));
|
|
__ iilf(r13, Operand(123456789));
|
|
__ iihf(r13, Operand(-123456789));
|
|
__ mvc(MemOperand(r0, 123), MemOperand(r4, 567), Operand(88));
|
|
__ sll(r13, Operand(10));
|
|
|
|
v8::internal::byte* bufPos = assm.buffer_pos();
|
|
::printf("buffer position = %p", static_cast<void*>(bufPos));
|
|
::fflush(stdout);
|
|
// OS::DebugBreak();
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
USE(code);
|
|
::exit(0);
|
|
}
|
|
|
|
#if 0
|
|
TEST(4) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
Label L2, L3, L4;
|
|
|
|
__ chi(r2, Operand(10));
|
|
__ ble(&L2);
|
|
__ lr(r2, r4);
|
|
__ ar(r2, r3);
|
|
__ b(&L3);
|
|
|
|
__ bind(&L2);
|
|
__ chi(r2, Operand(5));
|
|
__ bgt(&L4);
|
|
|
|
__ lhi(r2, Operand::Zero());
|
|
__ b(&L3);
|
|
|
|
__ bind(&L4);
|
|
__ lr(r2, r3);
|
|
__ sr(r2, r4);
|
|
|
|
__ bind(&L3);
|
|
__ lgfr(r2, r3);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = isolate->factory()->NewCode(
|
|
desc, Code::STUB, Handle<Code>());
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F2>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(
|
|
f.Call(3, 4, 3, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(4, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// Test ExtractBitRange
|
|
TEST(5) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
__ mov(r2, Operand(0x12345678));
|
|
__ ExtractBitRange(r3, r2, 3, 2);
|
|
__ lgfr(r2, r3);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = isolate->factory()->NewCode(
|
|
desc, Code::STUB, Handle<Code>());
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F2>::FromCode(*code);
|
|
intptr_t res =
|
|
reinterpret_cast<intptr_t>(f.Call(3, 4, 3, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(2, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// Test JumpIfSmi
|
|
TEST(6) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label yes;
|
|
|
|
__ mov(r2, Operand(0x12345678));
|
|
__ JumpIfSmi(r2, &yes);
|
|
__ beq(&yes);
|
|
__ Load(r2, Operand::Zero());
|
|
__ b(r14);
|
|
__ bind(&yes);
|
|
__ Load(r2, Operand(1));
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = isolate->factory()->NewCode(
|
|
desc, Code::STUB, Handle<Code>());
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F2>::FromCode(*code);
|
|
intptr_t res =
|
|
reinterpret_cast<intptr_t>(f.Call(3, 4, 3, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(1, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// Test fix<->floating point conversion.
|
|
TEST(7) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label yes;
|
|
|
|
__ mov(r3, Operand(0x1234));
|
|
__ cdfbr(d1, r3);
|
|
__ ldr(d2, d1);
|
|
__ adbr(d1, d2);
|
|
__ cfdbr(Condition(0), r2, d1);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = isolate->factory()->NewCode(
|
|
desc, Code::STUB, Handle<Code>());
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F2>::FromCode(*code);
|
|
intptr_t res =
|
|
reinterpret_cast<intptr_t>(f.Call(3, 4, 3, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(0x2468, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// Test DSGR
|
|
TEST(8) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
// Zero upper bits of r3/r4
|
|
__ llihf(r3, Operand::Zero());
|
|
__ llihf(r4, Operand::Zero());
|
|
__ mov(r3, Operand(0x0002));
|
|
__ mov(r4, Operand(0x0002));
|
|
__ dsgr(r2, r4);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = isolate->factory()->NewCode(
|
|
desc, Code::STUB, Handle<Code>());
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res =
|
|
reinterpret_cast<intptr_t>(f.Call(100, 0,
|
|
0, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// Test LZDR
|
|
TEST(9) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
__ lzdr(d4);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = isolate->factory()->NewCode(
|
|
desc, Code::STUB, Handle<Code>());
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res =
|
|
reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
}
|
|
#endif
|
|
|
|
// Test msrkc and msgrkc
|
|
TEST(10) {
|
|
if (!CpuFeatures::IsSupported(MISC_INSTR_EXT2)) {
|
|
return;
|
|
}
|
|
|
|
::printf("MISC_INSTR_EXT2 is enabled.\n");
|
|
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label ok, failed;
|
|
|
|
{ // test 1: msrkc
|
|
__ lgfi(r2, Operand(3));
|
|
__ lgfi(r3, Operand(4));
|
|
__ msrkc(r1, r2, r3); // 3 * 4
|
|
__ b(static_cast<Condition>(le | overflow), &failed); // test failed.
|
|
__ chi(r1, Operand(12));
|
|
__ bne(&failed); // test failed.
|
|
|
|
__ lgfi(r2, Operand(-3));
|
|
__ lgfi(r3, Operand(4));
|
|
__ msrkc(r1, r2, r3); // -3 * 4
|
|
__ b(static_cast<Condition>(ge | overflow), &failed); // test failed.
|
|
__ chi(r1, Operand(-12));
|
|
__ bne(&failed); // test failed.
|
|
|
|
__ iilf(r2, Operand(0x80000000));
|
|
__ lgfi(r3, Operand(-1));
|
|
__ msrkc(r1, r2, r3); // INT_MIN * -1
|
|
__ b(nooverflow, &failed); // test failed.
|
|
__ cfi(r1, Operand(0x80000000));
|
|
__ bne(&failed); // test failed.
|
|
}
|
|
|
|
{ // test 1: msgrkc
|
|
__ lgfi(r2, Operand(3));
|
|
__ lgfi(r3, Operand(4));
|
|
__ msgrkc(r1, r2, r3); // 3 * 4
|
|
__ b(static_cast<Condition>(le | overflow), &failed); // test failed.
|
|
__ chi(r1, Operand(12));
|
|
__ bne(&failed); // test failed.
|
|
|
|
__ lgfi(r2, Operand(-3));
|
|
__ lgfi(r3, Operand(4));
|
|
__ msgrkc(r1, r2, r3); // -3 * 4
|
|
__ b(static_cast<Condition>(ge | overflow), &failed); // test failed.
|
|
__ chi(r1, Operand(-12));
|
|
__ bne(&failed); // test failed.
|
|
|
|
__ lgfi(r2, Operand::Zero());
|
|
__ iihf(r2, Operand(0x80000000));
|
|
__ lgfi(r3, Operand(-1));
|
|
__ msgrkc(r1, r2, r3); // INT_MIN * -1
|
|
__ b(nooverflow, &failed); // test failed.
|
|
__ cgr(r1, r2);
|
|
__ bne(&failed); // test failed.
|
|
}
|
|
|
|
__ bind(&ok);
|
|
__ lgfi(r2, Operand::Zero());
|
|
__ b(r14); // test done.
|
|
|
|
__ bind(&failed);
|
|
__ lgfi(r2, Operand(1));
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F2>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(3, 4, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// brxh
|
|
TEST(11) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label ok, failed, continue1, continue2;
|
|
// r1 - operand; r3 - inc / test val
|
|
__ lgfi(r1, Operand(1));
|
|
__ lgfi(r3, Operand(1));
|
|
__ brxh(r1, r3, &continue1);
|
|
__ b(&failed);
|
|
|
|
__ bind(&continue1);
|
|
__ lgfi(r1, Operand(-2));
|
|
__ lgfi(r3, Operand(1));
|
|
__ brxh(r1, r3, &failed);
|
|
__ brxh(r1, r3, &failed);
|
|
__ brxh(r1, r3, &failed);
|
|
__ brxh(r1, r3, &continue2);
|
|
__ b(&failed);
|
|
|
|
//r1 - operand; r4 - inc; r5 - test val
|
|
__ bind(&continue2);
|
|
__ lgfi(r1, Operand(-2));
|
|
__ lgfi(r4, Operand(1));
|
|
__ lgfi(r5, Operand(-1));
|
|
__ brxh(r1, r4, &failed);
|
|
__ brxh(r1, r4, &ok);
|
|
__ b(&failed);
|
|
|
|
__ bind(&ok);
|
|
__ lgfi(r2, Operand::Zero());
|
|
__ b(r14); // test done.
|
|
|
|
__ bind(&failed);
|
|
__ lgfi(r2, Operand(1));
|
|
__ b(r14); // test done.
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// brxhg
|
|
TEST(12) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label ok, failed, continue1, continue2;
|
|
// r1 - operand; r3 - inc / test val
|
|
__ lgfi(r1, Operand(1));
|
|
__ lgfi(r3, Operand(1));
|
|
__ brxhg(r1, r3, &continue1);
|
|
__ b(&failed);
|
|
|
|
__ bind(&continue1);
|
|
__ lgfi(r1, Operand(-2));
|
|
__ lgfi(r3, Operand(1));
|
|
__ brxhg(r1, r3, &failed);
|
|
__ brxhg(r1, r3, &failed);
|
|
__ brxhg(r1, r3, &failed);
|
|
__ brxhg(r1, r3, &continue2);
|
|
__ b(&failed);
|
|
|
|
//r1 - operand; r4 - inc; r5 - test val
|
|
__ bind(&continue2);
|
|
__ lgfi(r1, Operand(-2));
|
|
__ lgfi(r4, Operand(1));
|
|
__ lgfi(r5, Operand(-1));
|
|
__ brxhg(r1, r4, &failed);
|
|
__ brxhg(r1, r4, &ok);
|
|
__ b(&failed);
|
|
|
|
__ bind(&ok);
|
|
__ lgfi(r2, Operand::Zero());
|
|
__ b(r14); // test done.
|
|
|
|
__ bind(&failed);
|
|
__ lgfi(r2, Operand(1));
|
|
__ b(r14); // test done.
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
// vector basics
|
|
TEST(13) {
|
|
// check if the VECTOR_FACILITY is supported
|
|
if (!CpuFeatures::IsSupported(VECTOR_FACILITY)) {
|
|
return;
|
|
}
|
|
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label done, error;
|
|
|
|
// vector loads, replicate, and arithmetics
|
|
__ vrepi(d2, Operand(100), Condition(2));
|
|
__ lay(sp, MemOperand(sp, -4));
|
|
__ sty(r3, MemOperand(sp));
|
|
__ vlrep(d3, MemOperand(sp), Condition(2));
|
|
__ lay(sp, MemOperand(sp, 4));
|
|
__ vlvg(d4, r2, MemOperand(r0, 2), Condition(2));
|
|
__ vrep(d4, d4, Operand(2), Condition(2));
|
|
__ lay(sp, MemOperand(sp, -kSimd128Size));
|
|
__ vst(d4, MemOperand(sp), Condition(0));
|
|
__ va(d2, d2, d3, Condition(0), Condition(0), Condition(2));
|
|
__ vl(d3, MemOperand(sp), Condition(0));
|
|
__ lay(sp, MemOperand(sp, kSimd128Size));
|
|
__ vs(d2, d2, d3, Condition(0), Condition(0), Condition(2));
|
|
__ vml(d3, d3, d2, Condition(0), Condition(0), Condition(2));
|
|
__ lay(sp, MemOperand(sp, -4));
|
|
__ vstef(d3, MemOperand(sp), Condition(3));
|
|
__ vlef(d2, MemOperand(sp), Condition(0));
|
|
__ lay(sp, MemOperand(sp, 4));
|
|
__ vlgv(r2, d2, MemOperand(r0, 0), Condition(2));
|
|
__ cfi(r2, Operand(15000));
|
|
__ bne(&error);
|
|
__ vrepi(d2, Operand(-30), Condition(3));
|
|
__ vlc(d2, d2, Condition(0), Condition(0), Condition(3));
|
|
__ vlgv(r2, d2, MemOperand(r0, 1), Condition(3));
|
|
__ lgfi(r1, Operand(-30));
|
|
__ lcgr(r1, r1);
|
|
__ cgr(r1, r2);
|
|
__ bne(&error);
|
|
__ lgfi(r2, Operand(0));
|
|
__ b(&done);
|
|
__ bind(&error);
|
|
__ lgfi(r2, Operand(1));
|
|
__ bind(&done);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(50, 250, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
|
|
// vector sum, packs, unpacks
|
|
TEST(14) {
|
|
// check if the VECTOR_FACILITY is supported
|
|
if (!CpuFeatures::IsSupported(VECTOR_FACILITY)) {
|
|
return;
|
|
}
|
|
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label done, error;
|
|
|
|
// vector sum word and doubleword
|
|
__ vrepi(d2, Operand(100), Condition(2));
|
|
__ vsumg(d1, d2, d2, Condition(0), Condition(0), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(3));
|
|
__ cfi(r2, Operand(300));
|
|
__ bne(&error);
|
|
__ vrepi(d1, Operand(0), Condition(1));
|
|
__ vrepi(d2, Operand(75), Condition(1));
|
|
__ vsum(d1, d2, d1, Condition(0), Condition(0), Condition(1));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(2));
|
|
__ cfi(r2, Operand(150));
|
|
__ bne(&error);
|
|
// vector packs
|
|
__ vrepi(d1, Operand(200), Condition(2));
|
|
__ vpk(d1, d1, d1, Condition(0), Condition(0), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 5), Condition(1));
|
|
__ cfi(r2, Operand(200));
|
|
__ bne(&error);
|
|
__ vrepi(d2, Operand(30), Condition(1));
|
|
__ vpks(d1, d1, d2, Condition(0), Condition(1));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(0));
|
|
__ vlgv(r3, d1, MemOperand(r0, 8), Condition(0));
|
|
__ ar(r2, r3);
|
|
__ cfi(r2, Operand(157));
|
|
__ bne(&error);
|
|
__ vrepi(d1, Operand(270), Condition(1));
|
|
__ vrepi(d2, Operand(-30), Condition(1));
|
|
__ vpkls(d1, d1, d2, Condition(0), Condition(1));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(0));
|
|
__ vlgv(r3, d1, MemOperand(r0, 8), Condition(0));
|
|
__ cfi(r2, Operand(255));
|
|
__ bne(&error);
|
|
__ cfi(r3, Operand(255));
|
|
__ bne(&error);
|
|
// vector unpacks
|
|
__ vrepi(d1, Operand(50), Condition(2));
|
|
__ lgfi(r1, Operand(10));
|
|
__ lgfi(r2, Operand(20));
|
|
__ vlvg(d1, r1, MemOperand(r0, 0), Condition(2));
|
|
__ vlvg(d1, r2, MemOperand(r0, 2), Condition(2));
|
|
__ vuph(d2, d1, Condition(0), Condition(0), Condition(2));
|
|
__ vupl(d1, d1, Condition(0), Condition(0), Condition(2));
|
|
__ va(d1, d1, d2, Condition(0), Condition(0), Condition(3));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(3));
|
|
__ vlgv(r3, d1, MemOperand(r0, 1), Condition(3));
|
|
__ ar(r2, r3);
|
|
__ cfi(r2, Operand(130));
|
|
__ bne(&error);
|
|
__ vrepi(d1, Operand(-100), Condition(2));
|
|
__ vuplh(d2, d1, Condition(0), Condition(0), Condition(2));
|
|
__ vupll(d1, d1, Condition(0), Condition(0), Condition(2));
|
|
__ va(d1, d1, d1, Condition(0), Condition(0), Condition(3));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(3));
|
|
__ cfi(r2, Operand(0x1ffffff38));
|
|
__ bne(&error);
|
|
__ lgfi(r2, Operand(0));
|
|
__ b(&done);
|
|
__ bind(&error);
|
|
__ lgfi(r2, Operand(1));
|
|
__ bind(&done);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
// vector comparisons
|
|
TEST(15) {
|
|
// check if the VECTOR_FACILITY is supported
|
|
if (!CpuFeatures::IsSupported(VECTOR_FACILITY)) {
|
|
return;
|
|
}
|
|
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label done, error;
|
|
|
|
// vector max and min
|
|
__ vrepi(d2, Operand(-50), Condition(2));
|
|
__ vrepi(d3, Operand(40), Condition(2));
|
|
__ vmx(d1, d2, d3, Condition(0), Condition(0), Condition(2));
|
|
__ vlgv(r1, d1, MemOperand(r0, 0), Condition(2));
|
|
__ vmnl(d1, d2, d3, Condition(0), Condition(0), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(2));
|
|
__ cgr(r1, r2);
|
|
__ vmxl(d1, d2, d3, Condition(0), Condition(0), Condition(2));
|
|
__ vlgv(r1, d1, MemOperand(r0, 0), Condition(2));
|
|
__ vmn(d1, d2, d3, Condition(0), Condition(0), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(2));
|
|
__ cgr(r1, r2);
|
|
__ bne(&error);
|
|
// vector comparisons
|
|
__ vlr(d4, d3, Condition(0), Condition(0), Condition(0));
|
|
__ vceq(d1, d3, d4, Condition(0), Condition(2));
|
|
__ vlgv(r1, d1, MemOperand(r0, 0), Condition(2));
|
|
__ vch(d1, d2, d3, Condition(0), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(2));
|
|
__ vchl(d1, d2, d3, Condition(0), Condition(2));
|
|
__ vlgv(r3, d1, MemOperand(r0, 0), Condition(2));
|
|
__ ar(r2, r3);
|
|
__ cgr(r1, r2);
|
|
__ bne(&error);
|
|
// vector bitwise ops
|
|
__ vrepi(d2, Operand(0), Condition(2));
|
|
__ vn(d1, d2, d3, Condition(0), Condition(0), Condition(0));
|
|
__ vceq(d1, d1, d2, Condition(0), Condition(2));
|
|
__ vlgv(r1, d1, MemOperand(r0, 0), Condition(2));
|
|
__ vo(d1, d2, d3, Condition(0), Condition(0), Condition(0));
|
|
__ vx(d1, d1, d2, Condition(0), Condition(0), Condition(0));
|
|
__ vceq(d1, d1, d3, Condition(0), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(2));
|
|
__ cgr(r1, r2);
|
|
__ bne(&error);
|
|
// vector bitwise shift
|
|
__ vceq(d1, d1, d1, Condition(0), Condition(2));
|
|
__ vesra(d1, d1, MemOperand(r0, 5), Condition(2));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(2));
|
|
__ cgr(r3, r2);
|
|
__ bne(&error);
|
|
__ lgfi(r1, Operand(0xfffff895));
|
|
__ vlvg(d1, r1, MemOperand(r0, 0), Condition(3));
|
|
__ vrep(d1, d1, Operand(0), Condition(3));
|
|
__ slag(r1, r1, Operand(10));
|
|
__ vesl(d1, d1, MemOperand(r0, 10), Condition(3));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(3));
|
|
__ cgr(r1, r2);
|
|
__ bne(&error);
|
|
__ srlg(r1, r1, Operand(10));
|
|
__ vesrl(d1, d1, MemOperand(r0, 10), Condition(3));
|
|
__ vlgv(r2, d1, MemOperand(r0, 0), Condition(3));
|
|
__ cgr(r1, r2);
|
|
__ bne(&error);
|
|
__ lgfi(r2, Operand(0));
|
|
__ b(&done);
|
|
__ bind(&error);
|
|
__ lgfi(r2, Operand(1));
|
|
__ bind(&done);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
// vector select and test mask
|
|
TEST(16) {
|
|
// check if the VECTOR_FACILITY is supported
|
|
if (!CpuFeatures::IsSupported(VECTOR_FACILITY)) {
|
|
return;
|
|
}
|
|
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label done, error;
|
|
|
|
// vector select
|
|
__ vrepi(d1, Operand(0x1011), Condition(1));
|
|
__ vrepi(d2, Operand(0x4343), Condition(1));
|
|
__ vrepi(d3, Operand(0x3434), Condition(1));
|
|
__ vsel(d1, d2, d3, d1, Condition(0), Condition(0));
|
|
__ vlgv(r2, d1, MemOperand(r0, 2), Condition(1));
|
|
__ cfi(r2, Operand(0x2425));
|
|
__ bne(&error);
|
|
// vector test mask
|
|
__ vtm(d2, d1, Condition(0), Condition(0), Condition(0));
|
|
__ b(Condition(0x1), &error);
|
|
__ b(Condition(0x8), &error);
|
|
__ lgfi(r2, Operand(0));
|
|
__ b(&done);
|
|
__ bind(&error);
|
|
__ lgfi(r2, Operand(1));
|
|
__ bind(&done);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
// vector fp instructions
|
|
TEST(17) {
|
|
// check if the VECTOR_FACILITY is supported
|
|
if (!CpuFeatures::IsSupported(VECTOR_FACILITY)) {
|
|
return;
|
|
}
|
|
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label done, error;
|
|
|
|
// vector fp arithmetics
|
|
__ cdgbr(d1, r3);
|
|
__ ldr(d2, d1);
|
|
__ vfa(d1, d1, d2, Condition(0), Condition(0), Condition(3));
|
|
__ cdgbr(d3, r2);
|
|
__ vfm(d1, d1, d3, Condition(0), Condition(0), Condition(3));
|
|
__ vfs(d1, d1, d2, Condition(0), Condition(0), Condition(3));
|
|
__ vfd(d1, d1, d3, Condition(0), Condition(0), Condition(3));
|
|
__ vfsq(d1, d1, Condition(0), Condition(0), Condition(3));
|
|
__ cgdbr(Condition(4), r2, d1);
|
|
__ cgfi(r2, Operand(0x8));
|
|
__ bne(&error);
|
|
// vector fp comparisons
|
|
__ cdgbra(Condition(4), d1, r3);
|
|
__ ldr(d2, d1);
|
|
__ vfa(d1, d1, d2, Condition(0), Condition(0), Condition(3));
|
|
#ifdef VECTOR_ENHANCE_FACILITY_1
|
|
__ vfmin(d3, d1, d2, Condition(1), Condition(0), Condition(3));
|
|
__ vfmax(d4, d1, d2, Condition(1), Condition(0), Condition(3));
|
|
#else
|
|
__ vlr(d3, d2, Condition(0), Condition(0), Condition(0));
|
|
__ vlr(d4, d1, Condition(0), Condition(0), Condition(0));
|
|
#endif
|
|
__ vfch(d5, d4, d3, Condition(0), Condition(0), Condition(3));
|
|
__ vfche(d3, d3, d4, Condition(0), Condition(0), Condition(3));
|
|
__ vfce(d4, d1, d4, Condition(0), Condition(0), Condition(3));
|
|
__ va(d3, d3, d4, Condition(0), Condition(0), Condition(3));
|
|
__ vs(d3, d3, d5, Condition(0), Condition(0), Condition(3));
|
|
__ vlgv(r2, d3, MemOperand(r0, 0), Condition(3));
|
|
// vector fp sign ops
|
|
__ lgfi(r1, Operand(-0x50));
|
|
__ cdgbra(Condition(4), d1, r1);
|
|
__ vfpso(d1, d1, Condition(0), Condition(0), Condition(3));
|
|
__ vfi(d1, d1, Condition(5), Condition(0), Condition(3));
|
|
__ vlgv(r1, d1, MemOperand(r0, 0), Condition(3));
|
|
__ agr(r2, r1);
|
|
__ srlg(r2, r2, Operand(32));
|
|
__ cgfi(r2, Operand(0x40540000));
|
|
__ bne(&error);
|
|
__ lgfi(r2, Operand(0));
|
|
__ b(&done);
|
|
__ bind(&error);
|
|
__ lgfi(r2, Operand(1));
|
|
__ bind(&done);
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0x2, 0x30, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
//TMHH, TMHL
|
|
TEST(18) {
|
|
CcTest::InitializeVM();
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
HandleScope scope(isolate);
|
|
Assembler assm(AssemblerOptions{});
|
|
|
|
Label done, error;
|
|
Label continue1, continue2, continue3, continue4;
|
|
Label continue5, continue6, continue7, continue8, continue9;
|
|
|
|
// selected bits all 0
|
|
__ lgfi(r1, Operand(0));
|
|
__ tmhh(r1, Operand(1));
|
|
__ beq(&continue1); //8
|
|
__ b(&error);
|
|
|
|
__ bind(&continue1);
|
|
__ tmhl(r1, Operand(1));
|
|
__ beq(&continue2); //8
|
|
__ b(&error);
|
|
|
|
// mask = 0
|
|
__ bind(&continue2);
|
|
__ lgfi(r1, Operand(-1));
|
|
__ tmhh(r1, Operand(0));
|
|
__ beq(&continue3); //8
|
|
__ b(&error);
|
|
|
|
__ bind(&continue3);
|
|
__ tmhh(r1, Operand(0));
|
|
__ beq(&continue4); //8
|
|
__ b(&error);
|
|
|
|
// selected bits all 1
|
|
__ bind(&continue4);
|
|
__ tmhh(r1, Operand(1));
|
|
__ b(Condition(1), &continue5); //1
|
|
__ b(&error);
|
|
|
|
__ bind(&continue5);
|
|
__ tmhl(r1, Operand(1));
|
|
__ b(Condition(1), &continue6); //1
|
|
__ b(&error);
|
|
|
|
// leftmost = 1
|
|
__ bind(&continue6);
|
|
__ lgfi(r1, Operand(0xF000F000));
|
|
__ slag(r2, r1, Operand(32));
|
|
__ tmhh(r2, Operand(0xFFFF));
|
|
__ b(Condition(2), &done); //2
|
|
__ b(&error);
|
|
|
|
__ bind(&continue7);
|
|
__ tmhl(r1, Operand(0xFFFF));
|
|
__ b(Condition(2), &continue8); //2
|
|
__ b(&error);
|
|
|
|
// leftmost = 0
|
|
__ bind(&continue8);
|
|
__ lgfi(r1, Operand(0x0FF00FF0));
|
|
__ slag(r2, r1, Operand(32));
|
|
__ tmhh(r2, Operand(0xFFFF));
|
|
__ b(Condition(4), &done); //4
|
|
__ b(&error);
|
|
|
|
__ bind(&continue9);
|
|
__ tmhl(r1, Operand(0xFFFF));
|
|
__ b(Condition(4), &done); //4
|
|
__ b(&error);
|
|
|
|
__ bind(&error);
|
|
__ lgfi(r2, Operand(1));
|
|
__ b(r14);
|
|
|
|
__ bind(&done);
|
|
__ lgfi(r2, Operand::Zero());
|
|
__ b(r14);
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(isolate, &desc);
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
|
#ifdef DEBUG
|
|
code->Print();
|
|
#endif
|
|
auto f = GeneratedCode<F1>::FromCode(*code);
|
|
// f.Call(reg2, reg3, reg4, reg5, reg6) -> set the register value
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(0, 0, 0, 0, 0));
|
|
::printf("f() = %" V8PRIxPTR "\n", res);
|
|
CHECK_EQ(0, static_cast<int>(res));
|
|
}
|
|
|
|
#undef __
|
|
|
|
} // namespace internal
|
|
} // namespace v8
|