test/cctest/test-assembler-arm.cc - platform/external/v8 - Git at Google

 // 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 __
	// 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 __