2015-01-16 07:42:00 +00:00
|
|
|
// Copyright 2012 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/v8.h"
|
|
|
|
|
2019-05-17 07:52:26 +00:00
|
|
|
#include "src/diagnostics/disassembler.h"
|
2018-04-09 19:11:22 +00:00
|
|
|
#include "src/heap/factory.h"
|
2015-01-16 07:42:00 +00:00
|
|
|
#include "src/ppc/assembler-ppc-inl.h"
|
2017-12-11 14:12:29 +00:00
|
|
|
#include "src/simulator.h"
|
2015-01-16 07:42:00 +00:00
|
|
|
#include "test/cctest/cctest.h"
|
2019-01-17 16:59:15 +00:00
|
|
|
#include "test/common/assembler-tester.h"
|
2015-01-16 07:42:00 +00:00
|
|
|
|
2017-08-31 12:34:55 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
2015-01-16 07:42:00 +00:00
|
|
|
|
2018-01-10 19:34:11 +00:00
|
|
|
// TODO(ppc): Refine these signatures per test case, they can have arbitrary
|
|
|
|
// return and argument types and arbitrary number of arguments.
|
2018-12-25 00:19:47 +00:00
|
|
|
using F_iiiii = void*(int x, int p1, int p2, int p3, int p4);
|
|
|
|
using F_piiii = void*(void* p0, int p1, int p2, int p3, int p4);
|
|
|
|
using F_ppiii = void*(void* p0, void* p1, int p2, int p3, int p4);
|
|
|
|
using F_pppii = void*(void* p0, void* p1, void* p2, int p3, int p4);
|
|
|
|
using F_ippii = void*(int p0, void* p1, void* p2, int p3, int p4);
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
#define __ assm.
|
|
|
|
|
|
|
|
// Simple add parameter 1 to parameter 2 and return
|
|
|
|
TEST(0) {
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
__ add(r3, r3, r4);
|
|
|
|
__ blr();
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2019-04-29 16:15:47 +00:00
|
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
2015-01-16 07:42:00 +00:00
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
code->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
|
|
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(3, 4, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
|
|
CHECK_EQ(7, static_cast<int>(res));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Loop 100 times, adding loop counter to result
|
|
|
|
TEST(1) {
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
Label L, C;
|
|
|
|
|
|
|
|
__ mr(r4, r3);
|
|
|
|
__ li(r3, Operand::Zero());
|
|
|
|
__ b(&C);
|
|
|
|
|
|
|
|
__ bind(&L);
|
|
|
|
__ add(r3, r3, r4);
|
|
|
|
__ subi(r4, r4, Operand(1));
|
|
|
|
|
|
|
|
__ bind(&C);
|
|
|
|
__ cmpi(r4, Operand::Zero());
|
|
|
|
__ bne(&L);
|
|
|
|
__ blr();
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2019-04-29 16:15:47 +00:00
|
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
2015-01-16 07:42:00 +00:00
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
code->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
|
|
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(100, 0, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
|
|
CHECK_EQ(5050, static_cast<int>(res));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(2) {
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
Label L, C;
|
|
|
|
|
|
|
|
__ mr(r4, r3);
|
|
|
|
__ li(r3, Operand(1));
|
|
|
|
__ b(&C);
|
|
|
|
|
|
|
|
__ bind(&L);
|
|
|
|
#if defined(V8_TARGET_ARCH_PPC64)
|
|
|
|
__ mulld(r3, r4, r3);
|
|
|
|
#else
|
|
|
|
__ mullw(r3, r4, r3);
|
|
|
|
#endif
|
|
|
|
__ subi(r4, r4, Operand(1));
|
|
|
|
|
|
|
|
__ bind(&C);
|
|
|
|
__ cmpi(r4, Operand::Zero());
|
|
|
|
__ bne(&L);
|
|
|
|
__ blr();
|
|
|
|
|
|
|
|
// some relocated stuff here, not executed
|
|
|
|
__ RecordComment("dead code, just testing relocations");
|
|
|
|
__ mov(r0, Operand(isolate->factory()->true_value()));
|
|
|
|
__ RecordComment("dead code, just testing immediate operands");
|
|
|
|
__ mov(r0, Operand(-1));
|
|
|
|
__ mov(r0, Operand(0xFF000000));
|
|
|
|
__ mov(r0, Operand(0xF0F0F0F0));
|
|
|
|
__ mov(r0, Operand(0xFFF0FFFF));
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2019-04-29 16:15:47 +00:00
|
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
2015-01-16 07:42:00 +00:00
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
code->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
|
|
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(10, 0, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
|
|
CHECK_EQ(3628800, static_cast<int>(res));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(3) {
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int i;
|
|
|
|
char c;
|
|
|
|
int16_t s;
|
|
|
|
} T;
|
|
|
|
T t;
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// build a frame
|
|
|
|
#if V8_TARGET_ARCH_PPC64
|
|
|
|
__ stdu(sp, MemOperand(sp, -32));
|
|
|
|
__ std(fp, MemOperand(sp, 24));
|
|
|
|
#else
|
|
|
|
__ stwu(sp, MemOperand(sp, -16));
|
|
|
|
__ stw(fp, MemOperand(sp, 12));
|
|
|
|
#endif
|
|
|
|
__ mr(fp, sp);
|
|
|
|
|
|
|
|
// r4 points to our struct
|
|
|
|
__ mr(r4, r3);
|
|
|
|
|
|
|
|
// modify field int i of struct
|
2015-06-17 09:06:44 +00:00
|
|
|
__ lwz(r3, MemOperand(r4, offsetof(T, i)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ srwi(r5, r3, Operand(1));
|
2015-06-17 09:06:44 +00:00
|
|
|
__ stw(r5, MemOperand(r4, offsetof(T, i)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// modify field char c of struct
|
2015-06-17 09:06:44 +00:00
|
|
|
__ lbz(r5, MemOperand(r4, offsetof(T, c)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ add(r3, r5, r3);
|
|
|
|
__ slwi(r5, r5, Operand(2));
|
2015-06-17 09:06:44 +00:00
|
|
|
__ stb(r5, MemOperand(r4, offsetof(T, c)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// modify field int16_t s of struct
|
2015-06-17 09:06:44 +00:00
|
|
|
__ lhz(r5, MemOperand(r4, offsetof(T, s)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ add(r3, r5, r3);
|
|
|
|
__ srwi(r5, r5, Operand(3));
|
2015-06-17 09:06:44 +00:00
|
|
|
__ sth(r5, MemOperand(r4, offsetof(T, s)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// restore frame
|
|
|
|
#if V8_TARGET_ARCH_PPC64
|
|
|
|
__ addi(r11, fp, Operand(32));
|
|
|
|
__ ld(fp, MemOperand(r11, -8));
|
|
|
|
#else
|
|
|
|
__ addi(r11, fp, Operand(16));
|
|
|
|
__ lwz(fp, MemOperand(r11, -4));
|
|
|
|
#endif
|
|
|
|
__ mr(sp, r11);
|
|
|
|
__ blr();
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2019-04-29 16:15:47 +00:00
|
|
|
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
|
2015-01-16 07:42:00 +00:00
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
code->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_piiii>::FromCode(*code);
|
2015-01-16 07:42:00 +00:00
|
|
|
t.i = 100000;
|
|
|
|
t.c = 10;
|
|
|
|
t.s = 1000;
|
2018-01-10 19:34:11 +00:00
|
|
|
intptr_t res = reinterpret_cast<intptr_t>(f.Call(&t, 0, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("f() = %" V8PRIdPTR "\n", res);
|
|
|
|
CHECK_EQ(101010, static_cast<int>(res));
|
|
|
|
CHECK_EQ(100000 / 2, t.i);
|
|
|
|
CHECK_EQ(10 * 4, t.c);
|
|
|
|
CHECK_EQ(1000 / 8, t.s);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
TEST(4) {
|
|
|
|
// Test the VFP floating point instructions.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
double a;
|
|
|
|
double b;
|
|
|
|
double c;
|
|
|
|
double d;
|
|
|
|
double e;
|
|
|
|
double f;
|
|
|
|
double g;
|
|
|
|
double h;
|
|
|
|
int i;
|
|
|
|
double m;
|
|
|
|
double n;
|
|
|
|
float x;
|
|
|
|
float y;
|
|
|
|
} T;
|
|
|
|
T t;
|
|
|
|
|
|
|
|
// Create a function that accepts &t, and loads, manipulates, and stores
|
|
|
|
// the doubles and floats.
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
Label L, C;
|
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(VFP3)) {
|
|
|
|
CpuFeatures::Scope scope(VFP3);
|
|
|
|
|
|
|
|
__ mov(ip, Operand(sp));
|
|
|
|
__ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
|
|
|
|
__ sub(fp, ip, Operand(4));
|
|
|
|
|
|
|
|
__ mov(r4, Operand(r0));
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vldr(d6, r4, offsetof(T, a));
|
|
|
|
__ vldr(d7, r4, offsetof(T, b));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vadd(d5, d6, d7);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d5, r4, offsetof(T, c));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
__ vmov(r2, r3, d5);
|
|
|
|
__ vmov(d4, r2, r3);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d4, r4, offsetof(T, b));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Load t.x and t.y, switch values, and store back to the struct.
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vldr(s0, r4, offsetof(T, x));
|
|
|
|
__ vldr(s31, r4, offsetof(T, y));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vmov(s16, s0);
|
|
|
|
__ vmov(s0, s31);
|
|
|
|
__ vmov(s31, s16);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(s0, r4, offsetof(T, x));
|
|
|
|
__ vstr(s31, r4, offsetof(T, y));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Move a literal into a register that can be encoded in the instruction.
|
|
|
|
__ vmov(d4, 1.0);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d4, r4, offsetof(T, e));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Move a literal into a register that requires 64 bits to encode.
|
2017-12-02 00:30:37 +00:00
|
|
|
// 0x3FF0000010000000 = 1.000000059604644775390625
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vmov(d4, 1.000000059604644775390625);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d4, r4, offsetof(T, d));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Convert from floating point to integer.
|
|
|
|
__ vmov(d4, 2.0);
|
|
|
|
__ vcvt_s32_f64(s31, d4);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(s31, r4, offsetof(T, i));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Convert from integer to floating point.
|
|
|
|
__ mov(lr, Operand(42));
|
|
|
|
__ vmov(s31, lr);
|
|
|
|
__ vcvt_f64_s32(d4, s31);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d4, r4, offsetof(T, f));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Test vabs.
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vldr(d1, r4, offsetof(T, g));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vabs(d0, d1);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d0, r4, offsetof(T, g));
|
|
|
|
__ vldr(d2, r4, offsetof(T, h));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vabs(d0, d2);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d0, r4, offsetof(T, h));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Test vneg.
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vldr(d1, r4, offsetof(T, m));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vneg(d0, d1);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d0, r4, offsetof(T, m));
|
|
|
|
__ vldr(d1, r4, offsetof(T, n));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vneg(d0, d1);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ vstr(d0, r4, offsetof(T, n));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
__ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_piiii>::FromCode(*code);
|
2015-01-16 07:42:00 +00:00
|
|
|
t.a = 1.5;
|
|
|
|
t.b = 2.75;
|
|
|
|
t.c = 17.17;
|
|
|
|
t.d = 0.0;
|
|
|
|
t.e = 0.0;
|
|
|
|
t.f = 0.0;
|
|
|
|
t.g = -2718.2818;
|
|
|
|
t.h = 31415926.5;
|
|
|
|
t.i = 0;
|
|
|
|
t.m = -2718.2818;
|
|
|
|
t.n = 123.456;
|
|
|
|
t.x = 4.5;
|
|
|
|
t.y = 9.0;
|
2018-01-10 19:34:11 +00:00
|
|
|
f.Call(&t, 0, 0, 0, 0);
|
2015-01-16 07:42:00 +00:00
|
|
|
CHECK_EQ(4.5, t.y);
|
|
|
|
CHECK_EQ(9.0, t.x);
|
|
|
|
CHECK_EQ(-123.456, t.n);
|
|
|
|
CHECK_EQ(2718.2818, t.m);
|
|
|
|
CHECK_EQ(2, t.i);
|
|
|
|
CHECK_EQ(2718.2818, t.g);
|
|
|
|
CHECK_EQ(31415926.5, t.h);
|
|
|
|
CHECK_EQ(42.0, t.f);
|
|
|
|
CHECK_EQ(1.0, t.e);
|
|
|
|
CHECK_EQ(1.000000059604644775390625, t.d);
|
|
|
|
CHECK_EQ(4.25, t.c);
|
|
|
|
CHECK_EQ(4.25, t.b);
|
|
|
|
CHECK_EQ(1.5, t.a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(5) {
|
|
|
|
// Test the ARMv7 bitfield instructions.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(ARMv7)) {
|
|
|
|
CpuFeatures::Scope scope(ARMv7);
|
|
|
|
// On entry, r0 = 0xAAAAAAAA = 0b10..10101010.
|
|
|
|
__ ubfx(r0, r0, 1, 12); // 0b00..010101010101 = 0x555
|
|
|
|
__ sbfx(r0, r0, 0, 5); // 0b11..111111110101 = -11
|
|
|
|
__ bfc(r0, 1, 3); // 0b11..111111110001 = -15
|
|
|
|
__ mov(r1, Operand(7));
|
|
|
|
__ bfi(r0, r1, 3, 3); // 0b11..111111111001 = -7
|
|
|
|
__ mov(pc, Operand(lr));
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
|
|
|
|
int res = reinterpret_cast<int>(f.Call(0xAAAAAAAA, 0, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("f() = %d\n", res);
|
|
|
|
CHECK_EQ(-7, res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(6) {
|
|
|
|
// Test saturating instructions.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(ARMv7)) {
|
|
|
|
CpuFeatures::Scope scope(ARMv7);
|
|
|
|
__ usat(r1, 8, Operand(r0)); // Sat 0xFFFF to 0-255 = 0xFF.
|
|
|
|
__ usat(r2, 12, Operand(r0, ASR, 9)); // Sat (0xFFFF>>9) to 0-4095 = 0x7F.
|
|
|
|
__ usat(r3, 1, Operand(r0, LSL, 16)); // Sat (0xFFFF<<16) to 0-1 = 0x0.
|
|
|
|
__ addi(r0, r1, Operand(r2));
|
|
|
|
__ addi(r0, r0, Operand(r3));
|
|
|
|
__ mov(pc, Operand(lr));
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
|
|
|
|
int res = reinterpret_cast<int>(f.Call(0xFFFF, 0, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("f() = %d\n", res);
|
|
|
|
CHECK_EQ(382, res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
enum VCVTTypes {
|
|
|
|
s32_f64,
|
|
|
|
u32_f64
|
|
|
|
};
|
|
|
|
|
|
|
|
static void TestRoundingMode(VCVTTypes types,
|
|
|
|
VFPRoundingMode mode,
|
|
|
|
double value,
|
|
|
|
int expected,
|
|
|
|
bool expected_exception = false) {
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(VFP3)) {
|
|
|
|
CpuFeatures::Scope scope(VFP3);
|
|
|
|
|
|
|
|
Label wrong_exception;
|
|
|
|
|
|
|
|
__ vmrs(r1);
|
|
|
|
// Set custom FPSCR.
|
|
|
|
__ bic(r2, r1, Operand(kVFPRoundingModeMask | kVFPExceptionMask));
|
|
|
|
__ orr(r2, r2, Operand(mode));
|
|
|
|
__ vmsr(r2);
|
|
|
|
|
|
|
|
// Load value, convert, and move back result to r0 if everything went well.
|
|
|
|
__ vmov(d1, value);
|
|
|
|
switch (types) {
|
|
|
|
case s32_f64:
|
|
|
|
__ vcvt_s32_f64(s0, d1, kFPSCRRounding);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case u32_f64:
|
|
|
|
__ vcvt_u32_f64(s0, d1, kFPSCRRounding);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Check for vfp exceptions
|
|
|
|
__ vmrs(r2);
|
|
|
|
__ tst(r2, Operand(kVFPExceptionMask));
|
|
|
|
// Check that we behaved as expected.
|
|
|
|
__ b(&wrong_exception,
|
|
|
|
expected_exception ? eq : ne);
|
|
|
|
// There was no exception. Retrieve the result and return.
|
|
|
|
__ vmov(r0, s0);
|
|
|
|
__ mov(pc, Operand(lr));
|
|
|
|
|
|
|
|
// The exception behaviour is not what we expected.
|
|
|
|
// Load a special value and return.
|
|
|
|
__ bind(&wrong_exception);
|
|
|
|
__ mov(r0, Operand(11223344));
|
|
|
|
__ mov(pc, Operand(lr));
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
|
|
|
|
int res = reinterpret_cast<int>(f.Call(0, 0, 0, 0, 0));
|
2015-01-16 07:42:00 +00:00
|
|
|
::printf("res = %d\n", res);
|
|
|
|
CHECK_EQ(expected, res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(7) {
|
|
|
|
// Test vfp rounding modes.
|
|
|
|
|
|
|
|
// s32_f64 (double to integer).
|
|
|
|
|
|
|
|
TestRoundingMode(s32_f64, RN, 0, 0);
|
|
|
|
TestRoundingMode(s32_f64, RN, 0.5, 0);
|
|
|
|
TestRoundingMode(s32_f64, RN, -0.5, 0);
|
|
|
|
TestRoundingMode(s32_f64, RN, 1.5, 2);
|
|
|
|
TestRoundingMode(s32_f64, RN, -1.5, -2);
|
|
|
|
TestRoundingMode(s32_f64, RN, 123.7, 124);
|
|
|
|
TestRoundingMode(s32_f64, RN, -123.7, -124);
|
|
|
|
TestRoundingMode(s32_f64, RN, 123456.2, 123456);
|
|
|
|
TestRoundingMode(s32_f64, RN, -123456.2, -123456);
|
|
|
|
TestRoundingMode(s32_f64, RN, static_cast<double>(kMaxInt), kMaxInt);
|
|
|
|
TestRoundingMode(s32_f64, RN, (kMaxInt + 0.49), kMaxInt);
|
|
|
|
TestRoundingMode(s32_f64, RN, (kMaxInt + 1.0), kMaxInt, true);
|
|
|
|
TestRoundingMode(s32_f64, RN, (kMaxInt + 0.5), kMaxInt, true);
|
|
|
|
TestRoundingMode(s32_f64, RN, static_cast<double>(kMinInt), kMinInt);
|
|
|
|
TestRoundingMode(s32_f64, RN, (kMinInt - 0.5), kMinInt);
|
|
|
|
TestRoundingMode(s32_f64, RN, (kMinInt - 1.0), kMinInt, true);
|
|
|
|
TestRoundingMode(s32_f64, RN, (kMinInt - 0.51), kMinInt, true);
|
|
|
|
|
|
|
|
TestRoundingMode(s32_f64, RM, 0, 0);
|
|
|
|
TestRoundingMode(s32_f64, RM, 0.5, 0);
|
|
|
|
TestRoundingMode(s32_f64, RM, -0.5, -1);
|
|
|
|
TestRoundingMode(s32_f64, RM, 123.7, 123);
|
|
|
|
TestRoundingMode(s32_f64, RM, -123.7, -124);
|
|
|
|
TestRoundingMode(s32_f64, RM, 123456.2, 123456);
|
|
|
|
TestRoundingMode(s32_f64, RM, -123456.2, -123457);
|
|
|
|
TestRoundingMode(s32_f64, RM, static_cast<double>(kMaxInt), kMaxInt);
|
|
|
|
TestRoundingMode(s32_f64, RM, (kMaxInt + 0.5), kMaxInt);
|
|
|
|
TestRoundingMode(s32_f64, RM, (kMaxInt + 1.0), kMaxInt, true);
|
|
|
|
TestRoundingMode(s32_f64, RM, static_cast<double>(kMinInt), kMinInt);
|
|
|
|
TestRoundingMode(s32_f64, RM, (kMinInt - 0.5), kMinInt, true);
|
|
|
|
TestRoundingMode(s32_f64, RM, (kMinInt + 0.5), kMinInt);
|
|
|
|
|
|
|
|
TestRoundingMode(s32_f64, RZ, 0, 0);
|
|
|
|
TestRoundingMode(s32_f64, RZ, 0.5, 0);
|
|
|
|
TestRoundingMode(s32_f64, RZ, -0.5, 0);
|
|
|
|
TestRoundingMode(s32_f64, RZ, 123.7, 123);
|
|
|
|
TestRoundingMode(s32_f64, RZ, -123.7, -123);
|
|
|
|
TestRoundingMode(s32_f64, RZ, 123456.2, 123456);
|
|
|
|
TestRoundingMode(s32_f64, RZ, -123456.2, -123456);
|
|
|
|
TestRoundingMode(s32_f64, RZ, static_cast<double>(kMaxInt), kMaxInt);
|
|
|
|
TestRoundingMode(s32_f64, RZ, (kMaxInt + 0.5), kMaxInt);
|
|
|
|
TestRoundingMode(s32_f64, RZ, (kMaxInt + 1.0), kMaxInt, true);
|
|
|
|
TestRoundingMode(s32_f64, RZ, static_cast<double>(kMinInt), kMinInt);
|
|
|
|
TestRoundingMode(s32_f64, RZ, (kMinInt - 0.5), kMinInt);
|
|
|
|
TestRoundingMode(s32_f64, RZ, (kMinInt - 1.0), kMinInt, true);
|
|
|
|
|
|
|
|
|
|
|
|
// u32_f64 (double to integer).
|
|
|
|
|
|
|
|
// Negative values.
|
|
|
|
TestRoundingMode(u32_f64, RN, -0.5, 0);
|
|
|
|
TestRoundingMode(u32_f64, RN, -123456.7, 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RN, static_cast<double>(kMinInt), 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RN, kMinInt - 1.0, 0, true);
|
|
|
|
|
|
|
|
TestRoundingMode(u32_f64, RM, -0.5, 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RM, -123456.7, 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RM, static_cast<double>(kMinInt), 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RM, kMinInt - 1.0, 0, true);
|
|
|
|
|
|
|
|
TestRoundingMode(u32_f64, RZ, -0.5, 0);
|
|
|
|
TestRoundingMode(u32_f64, RZ, -123456.7, 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RZ, static_cast<double>(kMinInt), 0, true);
|
|
|
|
TestRoundingMode(u32_f64, RZ, kMinInt - 1.0, 0, true);
|
|
|
|
|
|
|
|
// Positive values.
|
2017-12-02 00:30:37 +00:00
|
|
|
// kMaxInt is the maximum *signed* integer: 0x7FFFFFFF.
|
|
|
|
static const uint32_t kMaxUInt = 0xFFFFFFFFu;
|
2015-01-16 07:42:00 +00:00
|
|
|
TestRoundingMode(u32_f64, RZ, 0, 0);
|
|
|
|
TestRoundingMode(u32_f64, RZ, 0.5, 0);
|
|
|
|
TestRoundingMode(u32_f64, RZ, 123.7, 123);
|
|
|
|
TestRoundingMode(u32_f64, RZ, 123456.2, 123456);
|
|
|
|
TestRoundingMode(u32_f64, RZ, static_cast<double>(kMaxInt), kMaxInt);
|
|
|
|
TestRoundingMode(u32_f64, RZ, (kMaxInt + 0.5), kMaxInt);
|
|
|
|
TestRoundingMode(u32_f64, RZ, (kMaxInt + 1.0),
|
|
|
|
static_cast<uint32_t>(kMaxInt) + 1);
|
|
|
|
TestRoundingMode(u32_f64, RZ, (kMaxUInt + 0.5), kMaxUInt);
|
|
|
|
TestRoundingMode(u32_f64, RZ, (kMaxUInt + 1.0), kMaxUInt, true);
|
|
|
|
|
|
|
|
TestRoundingMode(u32_f64, RM, 0, 0);
|
|
|
|
TestRoundingMode(u32_f64, RM, 0.5, 0);
|
|
|
|
TestRoundingMode(u32_f64, RM, 123.7, 123);
|
|
|
|
TestRoundingMode(u32_f64, RM, 123456.2, 123456);
|
|
|
|
TestRoundingMode(u32_f64, RM, static_cast<double>(kMaxInt), kMaxInt);
|
|
|
|
TestRoundingMode(u32_f64, RM, (kMaxInt + 0.5), kMaxInt);
|
|
|
|
TestRoundingMode(u32_f64, RM, (kMaxInt + 1.0),
|
|
|
|
static_cast<uint32_t>(kMaxInt) + 1);
|
|
|
|
TestRoundingMode(u32_f64, RM, (kMaxUInt + 0.5), kMaxUInt);
|
|
|
|
TestRoundingMode(u32_f64, RM, (kMaxUInt + 1.0), kMaxUInt, true);
|
|
|
|
|
|
|
|
TestRoundingMode(u32_f64, RN, 0, 0);
|
|
|
|
TestRoundingMode(u32_f64, RN, 0.5, 0);
|
|
|
|
TestRoundingMode(u32_f64, RN, 1.5, 2);
|
|
|
|
TestRoundingMode(u32_f64, RN, 123.7, 124);
|
|
|
|
TestRoundingMode(u32_f64, RN, 123456.2, 123456);
|
|
|
|
TestRoundingMode(u32_f64, RN, static_cast<double>(kMaxInt), kMaxInt);
|
|
|
|
TestRoundingMode(u32_f64, RN, (kMaxInt + 0.49), kMaxInt);
|
|
|
|
TestRoundingMode(u32_f64, RN, (kMaxInt + 0.5),
|
|
|
|
static_cast<uint32_t>(kMaxInt) + 1);
|
|
|
|
TestRoundingMode(u32_f64, RN, (kMaxUInt + 0.49), kMaxUInt);
|
|
|
|
TestRoundingMode(u32_f64, RN, (kMaxUInt + 0.5), kMaxUInt, true);
|
|
|
|
TestRoundingMode(u32_f64, RN, (kMaxUInt + 1.0), kMaxUInt, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(8) {
|
|
|
|
// Test VFP multi load/store with ia_w.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
double a;
|
|
|
|
double b;
|
|
|
|
double c;
|
|
|
|
double d;
|
|
|
|
double e;
|
|
|
|
double f;
|
|
|
|
double g;
|
|
|
|
double h;
|
|
|
|
} D;
|
|
|
|
D d;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
float a;
|
|
|
|
float b;
|
|
|
|
float c;
|
|
|
|
float d;
|
|
|
|
float e;
|
|
|
|
float f;
|
|
|
|
float g;
|
|
|
|
float h;
|
|
|
|
} F;
|
|
|
|
F f;
|
|
|
|
|
|
|
|
// Create a function that uses vldm/vstm to move some double and
|
|
|
|
// single precision values around in memory.
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(VFP2)) {
|
|
|
|
CpuFeatures::Scope scope(VFP2);
|
|
|
|
|
|
|
|
__ mov(ip, Operand(sp));
|
|
|
|
__ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
|
|
|
|
__ sub(fp, ip, Operand(4));
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r0, Operand(offsetof(D, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vldm(ia_w, r4, d0, d3);
|
|
|
|
__ vldm(ia_w, r4, d4, d7);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r0, Operand(offsetof(D, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vstm(ia_w, r4, d6, d7);
|
|
|
|
__ vstm(ia_w, r4, d0, d5);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r1, Operand(offsetof(F, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vldm(ia_w, r4, s0, s3);
|
|
|
|
__ vldm(ia_w, r4, s4, s7);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r1, Operand(offsetof(F, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vstm(ia_w, r4, s6, s7);
|
|
|
|
__ vstm(ia_w, r4, s0, s5);
|
|
|
|
|
|
|
|
__ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto fn = GeneratedCode<F_ppiii>::FromCode(*code);
|
2015-01-16 07:42:00 +00:00
|
|
|
d.a = 1.1;
|
|
|
|
d.b = 2.2;
|
|
|
|
d.c = 3.3;
|
|
|
|
d.d = 4.4;
|
|
|
|
d.e = 5.5;
|
|
|
|
d.f = 6.6;
|
|
|
|
d.g = 7.7;
|
|
|
|
d.h = 8.8;
|
|
|
|
|
|
|
|
f.a = 1.0;
|
|
|
|
f.b = 2.0;
|
|
|
|
f.c = 3.0;
|
|
|
|
f.d = 4.0;
|
|
|
|
f.e = 5.0;
|
|
|
|
f.f = 6.0;
|
|
|
|
f.g = 7.0;
|
|
|
|
f.h = 8.0;
|
|
|
|
|
2018-01-10 19:34:11 +00:00
|
|
|
fn.Call(&d, &f, 0, 0, 0);
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
CHECK_EQ(7.7, d.a);
|
|
|
|
CHECK_EQ(8.8, d.b);
|
|
|
|
CHECK_EQ(1.1, d.c);
|
|
|
|
CHECK_EQ(2.2, d.d);
|
|
|
|
CHECK_EQ(3.3, d.e);
|
|
|
|
CHECK_EQ(4.4, d.f);
|
|
|
|
CHECK_EQ(5.5, d.g);
|
|
|
|
CHECK_EQ(6.6, d.h);
|
|
|
|
|
|
|
|
CHECK_EQ(7.0, f.a);
|
|
|
|
CHECK_EQ(8.0, f.b);
|
|
|
|
CHECK_EQ(1.0, f.c);
|
|
|
|
CHECK_EQ(2.0, f.d);
|
|
|
|
CHECK_EQ(3.0, f.e);
|
|
|
|
CHECK_EQ(4.0, f.f);
|
|
|
|
CHECK_EQ(5.0, f.g);
|
|
|
|
CHECK_EQ(6.0, f.h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(9) {
|
|
|
|
// Test VFP multi load/store with ia.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
double a;
|
|
|
|
double b;
|
|
|
|
double c;
|
|
|
|
double d;
|
|
|
|
double e;
|
|
|
|
double f;
|
|
|
|
double g;
|
|
|
|
double h;
|
|
|
|
} D;
|
|
|
|
D d;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
float a;
|
|
|
|
float b;
|
|
|
|
float c;
|
|
|
|
float d;
|
|
|
|
float e;
|
|
|
|
float f;
|
|
|
|
float g;
|
|
|
|
float h;
|
|
|
|
} F;
|
|
|
|
F f;
|
|
|
|
|
|
|
|
// Create a function that uses vldm/vstm to move some double and
|
|
|
|
// single precision values around in memory.
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(VFP2)) {
|
|
|
|
CpuFeatures::Scope scope(VFP2);
|
|
|
|
|
|
|
|
__ mov(ip, Operand(sp));
|
|
|
|
__ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
|
|
|
|
__ sub(fp, ip, Operand(4));
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r0, Operand(offsetof(D, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vldm(ia, r4, d0, d3);
|
|
|
|
__ addi(r4, r4, Operand(4 * 8));
|
|
|
|
__ vldm(ia, r4, d4, d7);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r0, Operand(offsetof(D, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vstm(ia, r4, d6, d7);
|
|
|
|
__ addi(r4, r4, Operand(2 * 8));
|
|
|
|
__ vstm(ia, r4, d0, d5);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r1, Operand(offsetof(F, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vldm(ia, r4, s0, s3);
|
|
|
|
__ addi(r4, r4, Operand(4 * 4));
|
|
|
|
__ vldm(ia, r4, s4, s7);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r1, Operand(offsetof(F, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vstm(ia, r4, s6, s7);
|
|
|
|
__ addi(r4, r4, Operand(2 * 4));
|
|
|
|
__ vstm(ia, r4, s0, s5);
|
|
|
|
|
|
|
|
__ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto fn = GeneratedCode<F_ppiii>::FromCode(*code);
|
2015-01-16 07:42:00 +00:00
|
|
|
d.a = 1.1;
|
|
|
|
d.b = 2.2;
|
|
|
|
d.c = 3.3;
|
|
|
|
d.d = 4.4;
|
|
|
|
d.e = 5.5;
|
|
|
|
d.f = 6.6;
|
|
|
|
d.g = 7.7;
|
|
|
|
d.h = 8.8;
|
|
|
|
|
|
|
|
f.a = 1.0;
|
|
|
|
f.b = 2.0;
|
|
|
|
f.c = 3.0;
|
|
|
|
f.d = 4.0;
|
|
|
|
f.e = 5.0;
|
|
|
|
f.f = 6.0;
|
|
|
|
f.g = 7.0;
|
|
|
|
f.h = 8.0;
|
|
|
|
|
2018-01-10 19:34:11 +00:00
|
|
|
fn.Call(&d, &f, 0, 0, 0);
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
CHECK_EQ(7.7, d.a);
|
|
|
|
CHECK_EQ(8.8, d.b);
|
|
|
|
CHECK_EQ(1.1, d.c);
|
|
|
|
CHECK_EQ(2.2, d.d);
|
|
|
|
CHECK_EQ(3.3, d.e);
|
|
|
|
CHECK_EQ(4.4, d.f);
|
|
|
|
CHECK_EQ(5.5, d.g);
|
|
|
|
CHECK_EQ(6.6, d.h);
|
|
|
|
|
|
|
|
CHECK_EQ(7.0, f.a);
|
|
|
|
CHECK_EQ(8.0, f.b);
|
|
|
|
CHECK_EQ(1.0, f.c);
|
|
|
|
CHECK_EQ(2.0, f.d);
|
|
|
|
CHECK_EQ(3.0, f.e);
|
|
|
|
CHECK_EQ(4.0, f.f);
|
|
|
|
CHECK_EQ(5.0, f.g);
|
|
|
|
CHECK_EQ(6.0, f.h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(10) {
|
|
|
|
// Test VFP multi load/store with db_w.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
double a;
|
|
|
|
double b;
|
|
|
|
double c;
|
|
|
|
double d;
|
|
|
|
double e;
|
|
|
|
double f;
|
|
|
|
double g;
|
|
|
|
double h;
|
|
|
|
} D;
|
|
|
|
D d;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
float a;
|
|
|
|
float b;
|
|
|
|
float c;
|
|
|
|
float d;
|
|
|
|
float e;
|
|
|
|
float f;
|
|
|
|
float g;
|
|
|
|
float h;
|
|
|
|
} F;
|
|
|
|
F f;
|
|
|
|
|
|
|
|
// Create a function that uses vldm/vstm to move some double and
|
|
|
|
// single precision values around in memory.
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
if (CpuFeatures::IsSupported(VFP2)) {
|
|
|
|
CpuFeatures::Scope scope(VFP2);
|
|
|
|
|
|
|
|
__ mov(ip, Operand(sp));
|
|
|
|
__ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
|
|
|
|
__ sub(fp, ip, Operand(4));
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r0, Operand(offsetof(D, h) + 8));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vldm(db_w, r4, d4, d7);
|
|
|
|
__ vldm(db_w, r4, d0, d3);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r0, Operand(offsetof(D, h) + 8));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vstm(db_w, r4, d0, d5);
|
|
|
|
__ vstm(db_w, r4, d6, d7);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r1, Operand(offsetof(F, h) + 4));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vldm(db_w, r4, s4, s7);
|
|
|
|
__ vldm(db_w, r4, s0, s3);
|
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ addi(r4, r1, Operand(offsetof(F, h) + 4));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ vstm(db_w, r4, s0, s5);
|
|
|
|
__ vstm(db_w, r4, s6, s7);
|
|
|
|
|
|
|
|
__ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto fn = GeneratedCode<F_ppiii>::FromCode(*code);
|
2015-01-16 07:42:00 +00:00
|
|
|
d.a = 1.1;
|
|
|
|
d.b = 2.2;
|
|
|
|
d.c = 3.3;
|
|
|
|
d.d = 4.4;
|
|
|
|
d.e = 5.5;
|
|
|
|
d.f = 6.6;
|
|
|
|
d.g = 7.7;
|
|
|
|
d.h = 8.8;
|
|
|
|
|
|
|
|
f.a = 1.0;
|
|
|
|
f.b = 2.0;
|
|
|
|
f.c = 3.0;
|
|
|
|
f.d = 4.0;
|
|
|
|
f.e = 5.0;
|
|
|
|
f.f = 6.0;
|
|
|
|
f.g = 7.0;
|
|
|
|
f.h = 8.0;
|
|
|
|
|
2018-01-10 19:34:11 +00:00
|
|
|
fn.Call(&d, &f, 0, 0, 0);
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
CHECK_EQ(7.7, d.a);
|
|
|
|
CHECK_EQ(8.8, d.b);
|
|
|
|
CHECK_EQ(1.1, d.c);
|
|
|
|
CHECK_EQ(2.2, d.d);
|
|
|
|
CHECK_EQ(3.3, d.e);
|
|
|
|
CHECK_EQ(4.4, d.f);
|
|
|
|
CHECK_EQ(5.5, d.g);
|
|
|
|
CHECK_EQ(6.6, d.h);
|
|
|
|
|
|
|
|
CHECK_EQ(7.0, f.a);
|
|
|
|
CHECK_EQ(8.0, f.b);
|
|
|
|
CHECK_EQ(1.0, f.c);
|
|
|
|
CHECK_EQ(2.0, f.d);
|
|
|
|
CHECK_EQ(3.0, f.e);
|
|
|
|
CHECK_EQ(4.0, f.f);
|
|
|
|
CHECK_EQ(5.0, f.g);
|
|
|
|
CHECK_EQ(6.0, f.h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(11) {
|
|
|
|
// Test instructions using the carry flag.
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int32_t a;
|
|
|
|
int32_t b;
|
|
|
|
int32_t c;
|
|
|
|
int32_t d;
|
|
|
|
} I;
|
|
|
|
I i;
|
|
|
|
|
2017-12-02 00:30:37 +00:00
|
|
|
i.a = 0xABCD0001;
|
|
|
|
i.b = 0xABCD0000;
|
2015-01-16 07:42:00 +00:00
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Test HeapObject untagging.
|
2015-06-17 09:06:44 +00:00
|
|
|
__ ldr(r1, MemOperand(r0, offsetof(I, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ mov(r1, Operand(r1, ASR, 1), SetCC);
|
|
|
|
__ adc(r1, r1, Operand(r1), LeaveCC, cs);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ str(r1, MemOperand(r0, offsetof(I, a)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
2015-06-17 09:06:44 +00:00
|
|
|
__ ldr(r2, MemOperand(r0, offsetof(I, b)));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ mov(r2, Operand(r2, ASR, 1), SetCC);
|
|
|
|
__ adc(r2, r2, Operand(r2), LeaveCC, cs);
|
2015-06-17 09:06:44 +00:00
|
|
|
__ str(r2, MemOperand(r0, offsetof(I, b)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
// Test corner cases.
|
2017-12-02 00:30:37 +00:00
|
|
|
__ mov(r1, Operand(0xFFFFFFFF));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ mov(r2, Operand::Zero());
|
|
|
|
__ mov(r3, Operand(r1, ASR, 1), SetCC); // Set the carry.
|
|
|
|
__ adc(r3, r1, Operand(r2));
|
2015-06-17 09:06:44 +00:00
|
|
|
__ str(r3, MemOperand(r0, offsetof(I, c)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
2017-12-02 00:30:37 +00:00
|
|
|
__ mov(r1, Operand(0xFFFFFFFF));
|
2015-01-16 07:42:00 +00:00
|
|
|
__ mov(r2, Operand::Zero());
|
|
|
|
__ mov(r3, Operand(r2, ASR, 1), SetCC); // Unset the carry.
|
|
|
|
__ adc(r3, r1, Operand(r2));
|
2015-06-17 09:06:44 +00:00
|
|
|
__ str(r3, MemOperand(r0, offsetof(I, d)));
|
2015-01-16 07:42:00 +00:00
|
|
|
|
|
|
|
__ mov(pc, Operand(lr));
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-06-08 17:41:56 +00:00
|
|
|
assm.GetCode(isolate, &desc);
|
2018-12-25 00:19:47 +00:00
|
|
|
Object code = isolate->heap()->CreateCode(
|
2015-01-16 07:42:00 +00:00
|
|
|
desc,
|
2017-09-29 14:59:24 +00:00
|
|
|
Code::STUB,
|
2015-01-16 07:42:00 +00:00
|
|
|
Handle<Code>())->ToObjectChecked();
|
|
|
|
CHECK(code->IsCode());
|
|
|
|
#ifdef DEBUG
|
2018-07-12 10:06:42 +00:00
|
|
|
Code::cast(code)->Print();
|
2015-01-16 07:42:00 +00:00
|
|
|
#endif
|
2018-01-10 19:34:11 +00:00
|
|
|
auto f = GeneratedCode<F_piiii>::FromCode(*code);
|
|
|
|
f.Call(&i, 0, 0, 0, 0);
|
2015-01-16 07:42:00 +00:00
|
|
|
|
2017-12-02 00:30:37 +00:00
|
|
|
CHECK_EQ(0xABCD0001, i.a);
|
|
|
|
CHECK_EQ(static_cast<int32_t>(0xABCD0000) >> 1, i.b);
|
2015-01-16 07:42:00 +00:00
|
|
|
CHECK_EQ(0x00000000, i.c);
|
2017-12-02 00:30:37 +00:00
|
|
|
CHECK_EQ(0xFFFFFFFF, i.d);
|
2015-01-16 07:42:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(12) {
|
|
|
|
// Test chaining of label usages within instructions (issue 1644).
|
|
|
|
CcTest::InitializeVM();
|
2015-11-23 12:38:18 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
2015-01-16 07:42:00 +00:00
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
2019-01-17 16:59:15 +00:00
|
|
|
Assembler assm(AssemblerOptions{});
|
2015-01-16 07:42:00 +00:00
|
|
|
Label target;
|
|
|
|
__ b(eq, &target);
|
|
|
|
__ b(ne, &target);
|
|
|
|
__ bind(&target);
|
|
|
|
__ nop();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#undef __
|
2017-08-31 12:34:55 +00:00
|
|
|
|
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|