mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
393 lines
11 KiB
393 lines
11 KiB
// Copyright 2010 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 "v8.h"
|
|
|
|
#include "disassembler.h"
|
|
#include "factory.h"
|
|
#include "arm/simulator-arm.h"
|
|
#include "arm/assembler-arm-inl.h"
|
|
#include "cctest.h"
|
|
|
|
using namespace v8::internal;
|
|
|
|
|
|
// Define these function prototypes to match JSEntryFunction in execution.cc.
|
|
typedef Object* (*F1)(int x, int p1, int p2, int p3, int p4);
|
|
typedef Object* (*F2)(int x, int y, int p2, int p3, int p4);
|
|
typedef Object* (*F3)(void* p, int p1, int p2, int p3, int p4);
|
|
|
|
|
|
static v8::Persistent<v8::Context> env;
|
|
|
|
|
|
// The test framework does not accept flags on the command line, so we set them
|
|
static void InitializeVM() {
|
|
// enable generation of comments
|
|
FLAG_debug_code = true;
|
|
|
|
if (env.IsEmpty()) {
|
|
env = v8::Context::New();
|
|
}
|
|
}
|
|
|
|
|
|
#define __ assm.
|
|
|
|
TEST(0) {
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
Assembler assm(NULL, 0);
|
|
|
|
__ add(r0, r0, Operand(r1));
|
|
__ mov(pc, Operand(lr));
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F2 f = FUNCTION_CAST<F2>(Code::cast(code)->entry());
|
|
int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 3, 4, 0, 0, 0));
|
|
::printf("f() = %d\n", res);
|
|
CHECK_EQ(7, res);
|
|
}
|
|
|
|
|
|
TEST(1) {
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
Assembler assm(NULL, 0);
|
|
Label L, C;
|
|
|
|
__ mov(r1, Operand(r0));
|
|
__ mov(r0, Operand(0, RelocInfo::NONE));
|
|
__ b(&C);
|
|
|
|
__ bind(&L);
|
|
__ add(r0, r0, Operand(r1));
|
|
__ sub(r1, r1, Operand(1));
|
|
|
|
__ bind(&C);
|
|
__ teq(r1, Operand(0, RelocInfo::NONE));
|
|
__ b(ne, &L);
|
|
__ mov(pc, Operand(lr));
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
|
|
int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 100, 0, 0, 0, 0));
|
|
::printf("f() = %d\n", res);
|
|
CHECK_EQ(5050, res);
|
|
}
|
|
|
|
|
|
TEST(2) {
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
Assembler assm(NULL, 0);
|
|
Label L, C;
|
|
|
|
__ mov(r1, Operand(r0));
|
|
__ mov(r0, Operand(1));
|
|
__ b(&C);
|
|
|
|
__ bind(&L);
|
|
__ mul(r0, r1, r0);
|
|
__ sub(r1, r1, Operand(1));
|
|
|
|
__ bind(&C);
|
|
__ teq(r1, Operand(0, RelocInfo::NONE));
|
|
__ b(ne, &L);
|
|
__ mov(pc, Operand(lr));
|
|
|
|
// some relocated stuff here, not executed
|
|
__ RecordComment("dead code, just testing relocations");
|
|
__ mov(r0, Operand(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;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
|
|
int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 10, 0, 0, 0, 0));
|
|
::printf("f() = %d\n", res);
|
|
CHECK_EQ(3628800, res);
|
|
}
|
|
|
|
|
|
TEST(3) {
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
typedef struct {
|
|
int i;
|
|
char c;
|
|
int16_t s;
|
|
} T;
|
|
T t;
|
|
|
|
Assembler assm(NULL, 0);
|
|
Label L, C;
|
|
|
|
__ mov(ip, Operand(sp));
|
|
__ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
|
|
__ sub(fp, ip, Operand(4));
|
|
__ mov(r4, Operand(r0));
|
|
__ ldr(r0, MemOperand(r4, OFFSET_OF(T, i)));
|
|
__ mov(r2, Operand(r0, ASR, 1));
|
|
__ str(r2, MemOperand(r4, OFFSET_OF(T, i)));
|
|
__ ldrsb(r2, MemOperand(r4, OFFSET_OF(T, c)));
|
|
__ add(r0, r2, Operand(r0));
|
|
__ mov(r2, Operand(r2, LSL, 2));
|
|
__ strb(r2, MemOperand(r4, OFFSET_OF(T, c)));
|
|
__ ldrsh(r2, MemOperand(r4, OFFSET_OF(T, s)));
|
|
__ add(r0, r2, Operand(r0));
|
|
__ mov(r2, Operand(r2, ASR, 3));
|
|
__ strh(r2, MemOperand(r4, OFFSET_OF(T, s)));
|
|
__ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F3 f = FUNCTION_CAST<F3>(Code::cast(code)->entry());
|
|
t.i = 100000;
|
|
t.c = 10;
|
|
t.s = 1000;
|
|
int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0));
|
|
::printf("f() = %d\n", res);
|
|
CHECK_EQ(101010, res);
|
|
CHECK_EQ(100000/2, t.i);
|
|
CHECK_EQ(10*4, t.c);
|
|
CHECK_EQ(1000/8, t.s);
|
|
}
|
|
|
|
|
|
TEST(4) {
|
|
// Test the VFP floating point instructions.
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
typedef struct {
|
|
double a;
|
|
double b;
|
|
double c;
|
|
double d;
|
|
double e;
|
|
double f;
|
|
int i;
|
|
float x;
|
|
float y;
|
|
} T;
|
|
T t;
|
|
|
|
// Create a function that accepts &t, and loads, manipulates, and stores
|
|
// the doubles and floats.
|
|
Assembler assm(NULL, 0);
|
|
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));
|
|
__ vldr(d6, r4, OFFSET_OF(T, a));
|
|
__ vldr(d7, r4, OFFSET_OF(T, b));
|
|
__ vadd(d5, d6, d7);
|
|
__ vstr(d5, r4, OFFSET_OF(T, c));
|
|
|
|
__ vmov(r2, r3, d5);
|
|
__ vmov(d4, r2, r3);
|
|
__ vstr(d4, r4, OFFSET_OF(T, b));
|
|
|
|
// Load t.x and t.y, switch values, and store back to the struct.
|
|
__ vldr(s0, r4, OFFSET_OF(T, x));
|
|
__ vldr(s31, r4, OFFSET_OF(T, y));
|
|
__ vmov(s16, s0);
|
|
__ vmov(s0, s31);
|
|
__ vmov(s31, s16);
|
|
__ vstr(s0, r4, OFFSET_OF(T, x));
|
|
__ vstr(s31, r4, OFFSET_OF(T, y));
|
|
|
|
// Move a literal into a register that can be encoded in the instruction.
|
|
__ vmov(d4, 1.0);
|
|
__ vstr(d4, r4, OFFSET_OF(T, e));
|
|
|
|
// Move a literal into a register that requires 64 bits to encode.
|
|
// 0x3ff0000010000000 = 1.000000059604644775390625
|
|
__ vmov(d4, 1.000000059604644775390625);
|
|
__ vstr(d4, r4, OFFSET_OF(T, d));
|
|
|
|
// Convert from floating point to integer.
|
|
__ vmov(d4, 2.0);
|
|
__ vcvt_s32_f64(s31, d4);
|
|
__ vstr(s31, r4, OFFSET_OF(T, i));
|
|
|
|
// Convert from integer to floating point.
|
|
__ mov(lr, Operand(42));
|
|
__ vmov(s31, lr);
|
|
__ vcvt_f64_s32(d4, s31);
|
|
__ vstr(d4, r4, OFFSET_OF(T, f));
|
|
__ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F3 f = FUNCTION_CAST<F3>(Code::cast(code)->entry());
|
|
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.i = 0;
|
|
t.x = 4.5;
|
|
t.y = 9.0;
|
|
Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
|
|
USE(dummy);
|
|
CHECK_EQ(4.5, t.y);
|
|
CHECK_EQ(9.0, t.x);
|
|
CHECK_EQ(2, t.i);
|
|
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.
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
Assembler assm(NULL, 0);
|
|
|
|
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;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
|
|
int res = reinterpret_cast<int>(
|
|
CALL_GENERATED_CODE(f, 0xAAAAAAAA, 0, 0, 0, 0));
|
|
::printf("f() = %d\n", res);
|
|
CHECK_EQ(-7, res);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(6) {
|
|
// Test saturating instructions.
|
|
InitializeVM();
|
|
v8::HandleScope scope;
|
|
|
|
Assembler assm(NULL, 0);
|
|
|
|
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.
|
|
__ add(r0, r1, Operand(r2));
|
|
__ add(r0, r0, Operand(r3));
|
|
__ mov(pc, Operand(lr));
|
|
|
|
CodeDesc desc;
|
|
assm.GetCode(&desc);
|
|
Object* code = Heap::CreateCode(desc,
|
|
Code::ComputeFlags(Code::STUB),
|
|
Handle<Object>(Heap::undefined_value()));
|
|
CHECK(code->IsCode());
|
|
#ifdef DEBUG
|
|
Code::cast(code)->Print();
|
|
#endif
|
|
F1 f = FUNCTION_CAST<F1>(Code::cast(code)->entry());
|
|
int res = reinterpret_cast<int>(
|
|
CALL_GENERATED_CODE(f, 0xFFFF, 0, 0, 0, 0));
|
|
::printf("f() = %d\n", res);
|
|
CHECK_EQ(382, res);
|
|
}
|
|
}
|
|
|
|
#undef __
|
|
|