src/v8/test/cctest/test-assembler-arm.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "v8.h"
  29
  30 #include "disassembler.h"
  31 #include "factory.h"
  32 #include "arm/simulator-arm.h"
  33 #include "arm/assembler-arm-inl.h"
  34 #include "cctest.h"
  35
  36 using namespace v8::internal;
  37
  38
  39 // Define these function prototypes to match JSEntryFunction in execution.cc.
  40 typedef Object* (*F1)(int x, int p1, int p2, int p3, int p4);
  41 typedef Object* (*F2)(int x, int y, int p2, int p3, int p4);
  42 typedef Object* (*F3)(void* p0, int p1, int p2, int p3, int p4);
  43 typedef Object* (*F4)(void* p0, void* p1, int p2, int p3, int p4);
  44
  45
  46 #define __ assm.
  47
  48 TEST(0) {
  49   CcTest::InitializeVM();
  50   Isolate* isolate = CcTest::i_isolate();
  51   HandleScope scope(isolate);
  52
  53   Assembler assm(isolate, NULL, 0);
  54
  55   __ add(r0, r0, Operand(r1));
  56   __ mov(pc, Operand(lr));
  57
  58   CodeDesc desc;
  59   assm.GetCode(&desc);
  60   Handle<Code> code = isolate->factory()->NewCode(
  61       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
  62 #ifdef DEBUG
  63   code->Print();
  64 #endif
  65   F2 f = FUNCTION_CAST<F2>(code->entry());
  66   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 3, 4, 0, 0, 0));
  67   ::printf("f() = %d\n", res);
  68   CHECK_EQ(7, res);
  69 }
  70
  71
  72 TEST(1) {
  73   CcTest::InitializeVM();
  74   Isolate* isolate = CcTest::i_isolate();
  75   HandleScope scope(isolate);
  76
  77   Assembler assm(isolate, NULL, 0);
  78   Label L, C;
  79
  80   __ mov(r1, Operand(r0));
  81   __ mov(r0, Operand::Zero());
  82   __ b(&C);
  83
  84   __ bind(&L);
  85   __ add(r0, r0, Operand(r1));
  86   __ sub(r1, r1, Operand(1));
  87
  88   __ bind(&C);
  89   __ teq(r1, Operand::Zero());
  90   __ b(ne, &L);
  91   __ mov(pc, Operand(lr));
  92
  93   CodeDesc desc;
  94   assm.GetCode(&desc);
  95   Handle<Code> code = isolate->factory()->NewCode(
  96       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
  97 #ifdef DEBUG
  98   code->Print();
  99 #endif
 100   F1 f = FUNCTION_CAST<F1>(code->entry());
 101   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 100, 0, 0, 0, 0));
 102   ::printf("f() = %d\n", res);
 103   CHECK_EQ(5050, res);
 104 }
 105
 106
 107 TEST(2) {
 108   CcTest::InitializeVM();
 109   Isolate* isolate = CcTest::i_isolate();
 110   HandleScope scope(isolate);
 111
 112   Assembler assm(isolate, NULL, 0);
 113   Label L, C;
 114
 115   __ mov(r1, Operand(r0));
 116   __ mov(r0, Operand(1));
 117   __ b(&C);
 118
 119   __ bind(&L);
 120   __ mul(r0, r1, r0);
 121   __ sub(r1, r1, Operand(1));
 122
 123   __ bind(&C);
 124   __ teq(r1, Operand::Zero());
 125   __ b(ne, &L);
 126   __ mov(pc, Operand(lr));
 127
 128   // some relocated stuff here, not executed
 129   __ RecordComment("dead code, just testing relocations");
 130   __ mov(r0, Operand(isolate->factory()->true_value()));
 131   __ RecordComment("dead code, just testing immediate operands");
 132   __ mov(r0, Operand(-1));
 133   __ mov(r0, Operand(0xFF000000));
 134   __ mov(r0, Operand(0xF0F0F0F0));
 135   __ mov(r0, Operand(0xFFF0FFFF));
 136
 137   CodeDesc desc;
 138   assm.GetCode(&desc);
 139   Handle<Code> code = isolate->factory()->NewCode(
 140       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 141 #ifdef DEBUG
 142   code->Print();
 143 #endif
 144   F1 f = FUNCTION_CAST<F1>(code->entry());
 145   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 10, 0, 0, 0, 0));
 146   ::printf("f() = %d\n", res);
 147   CHECK_EQ(3628800, res);
 148 }
 149
 150
 151 TEST(3) {
 152   CcTest::InitializeVM();
 153   Isolate* isolate = CcTest::i_isolate();
 154   HandleScope scope(isolate);
 155
 156   typedef struct {
 157     int i;
 158     char c;
 159     int16_t s;
 160   } T;
 161   T t;
 162
 163   Assembler assm(isolate, NULL, 0);
 164   Label L, C;
 165
 166   __ mov(ip, Operand(sp));
 167   __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
 168   __ sub(fp, ip, Operand(4));
 169   __ mov(r4, Operand(r0));
 170   __ ldr(r0, MemOperand(r4, OFFSET_OF(T, i)));
 171   __ mov(r2, Operand(r0, ASR, 1));
 172   __ str(r2, MemOperand(r4, OFFSET_OF(T, i)));
 173   __ ldrsb(r2, MemOperand(r4, OFFSET_OF(T, c)));
 174   __ add(r0, r2, Operand(r0));
 175   __ mov(r2, Operand(r2, LSL, 2));
 176   __ strb(r2, MemOperand(r4, OFFSET_OF(T, c)));
 177   __ ldrsh(r2, MemOperand(r4, OFFSET_OF(T, s)));
 178   __ add(r0, r2, Operand(r0));
 179   __ mov(r2, Operand(r2, ASR, 3));
 180   __ strh(r2, MemOperand(r4, OFFSET_OF(T, s)));
 181   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 182
 183   CodeDesc desc;
 184   assm.GetCode(&desc);
 185   Handle<Code> code = isolate->factory()->NewCode(
 186       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 187 #ifdef DEBUG
 188   code->Print();
 189 #endif
 190   F3 f = FUNCTION_CAST<F3>(code->entry());
 191   t.i = 100000;
 192   t.c = 10;
 193   t.s = 1000;
 194   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0));
 195   ::printf("f() = %d\n", res);
 196   CHECK_EQ(101010, res);
 197   CHECK_EQ(100000/2, t.i);
 198   CHECK_EQ(10*4, t.c);
 199   CHECK_EQ(1000/8, t.s);
 200 }
 201
 202
 203 TEST(4) {
 204   // Test the VFP floating point instructions.
 205   CcTest::InitializeVM();
 206   Isolate* isolate = CcTest::i_isolate();
 207   HandleScope scope(isolate);
 208
 209   typedef struct {
 210     double a;
 211     double b;
 212     double c;
 213     double d;
 214     double e;
 215     double f;
 216     double g;
 217     double h;
 218     int i;
 219     double j;
 220     double m;
 221     double n;
 222     float x;
 223     float y;
 224   } T;
 225   T t;
 226
 227   // Create a function that accepts &t, and loads, manipulates, and stores
 228   // the doubles and floats.
 229   Assembler assm(isolate, NULL, 0);
 230   Label L, C;
 231
 232
 233   if (CpuFeatures::IsSupported(VFP3)) {
 234     CpuFeatureScope scope(&assm, VFP3);
 235
 236     __ mov(ip, Operand(sp));
 237     __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
 238     __ sub(fp, ip, Operand(4));
 239
 240     __ mov(r4, Operand(r0));
 241     __ vldr(d6, r4, OFFSET_OF(T, a));
 242     __ vldr(d7, r4, OFFSET_OF(T, b));
 243     __ vadd(d5, d6, d7);
 244     __ vstr(d5, r4, OFFSET_OF(T, c));
 245
 246     __ vmla(d5, d6, d7);
 247     __ vmls(d5, d5, d6);
 248
 249     __ vmov(r2, r3, d5);
 250     __ vmov(d4, r2, r3);
 251     __ vstr(d4, r4, OFFSET_OF(T, b));
 252
 253     // Load t.x and t.y, switch values, and store back to the struct.
 254     __ vldr(s0, r4, OFFSET_OF(T, x));
 255     __ vldr(s31, r4, OFFSET_OF(T, y));
 256     __ vmov(s16, s0);
 257     __ vmov(s0, s31);
 258     __ vmov(s31, s16);
 259     __ vstr(s0, r4, OFFSET_OF(T, x));
 260     __ vstr(s31, r4, OFFSET_OF(T, y));
 261
 262     // Move a literal into a register that can be encoded in the instruction.
 263     __ vmov(d4, 1.0);
 264     __ vstr(d4, r4, OFFSET_OF(T, e));
 265
 266     // Move a literal into a register that requires 64 bits to encode.
 267     // 0x3ff0000010000000 = 1.000000059604644775390625
 268     __ vmov(d4, 1.000000059604644775390625);
 269     __ vstr(d4, r4, OFFSET_OF(T, d));
 270
 271     // Convert from floating point to integer.
 272     __ vmov(d4, 2.0);
 273     __ vcvt_s32_f64(s31, d4);
 274     __ vstr(s31, r4, OFFSET_OF(T, i));
 275
 276     // Convert from integer to floating point.
 277     __ mov(lr, Operand(42));
 278     __ vmov(s31, lr);
 279     __ vcvt_f64_s32(d4, s31);
 280     __ vstr(d4, r4, OFFSET_OF(T, f));
 281
 282     // Convert from fixed point to floating point.
 283     __ mov(lr, Operand(2468));
 284     __ vmov(s8, lr);
 285     __ vcvt_f64_s32(d4, 2);
 286     __ vstr(d4, r4, OFFSET_OF(T, j));
 287
 288     // Test vabs.
 289     __ vldr(d1, r4, OFFSET_OF(T, g));
 290     __ vabs(d0, d1);
 291     __ vstr(d0, r4, OFFSET_OF(T, g));
 292     __ vldr(d2, r4, OFFSET_OF(T, h));
 293     __ vabs(d0, d2);
 294     __ vstr(d0, r4, OFFSET_OF(T, h));
 295
 296     // Test vneg.
 297     __ vldr(d1, r4, OFFSET_OF(T, m));
 298     __ vneg(d0, d1);
 299     __ vstr(d0, r4, OFFSET_OF(T, m));
 300     __ vldr(d1, r4, OFFSET_OF(T, n));
 301     __ vneg(d0, d1);
 302     __ vstr(d0, r4, OFFSET_OF(T, n));
 303
 304     __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 305
 306     CodeDesc desc;
 307     assm.GetCode(&desc);
 308     Handle<Code> code = isolate->factory()->NewCode(
 309         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 310 #ifdef DEBUG
 311     code->Print();
 312 #endif
 313     F3 f = FUNCTION_CAST<F3>(code->entry());
 314     t.a = 1.5;
 315     t.b = 2.75;
 316     t.c = 17.17;
 317     t.d = 0.0;
 318     t.e = 0.0;
 319     t.f = 0.0;
 320     t.g = -2718.2818;
 321     t.h = 31415926.5;
 322     t.i = 0;
 323     t.j = 0;
 324     t.m = -2718.2818;
 325     t.n = 123.456;
 326     t.x = 4.5;
 327     t.y = 9.0;
 328     Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
 329     USE(dummy);
 330     CHECK_EQ(4.5, t.y);
 331     CHECK_EQ(9.0, t.x);
 332     CHECK_EQ(-123.456, t.n);
 333     CHECK_EQ(2718.2818, t.m);
 334     CHECK_EQ(2, t.i);
 335     CHECK_EQ(2718.2818, t.g);
 336     CHECK_EQ(31415926.5, t.h);
 337     CHECK_EQ(617.0, t.j);
 338     CHECK_EQ(42.0, t.f);
 339     CHECK_EQ(1.0, t.e);
 340     CHECK_EQ(1.000000059604644775390625, t.d);
 341     CHECK_EQ(4.25, t.c);
 342     CHECK_EQ(-4.1875, t.b);
 343     CHECK_EQ(1.5, t.a);
 344   }
 345 }
 346
 347
 348 TEST(5) {
 349   // Test the ARMv7 bitfield instructions.
 350   CcTest::InitializeVM();
 351   Isolate* isolate = CcTest::i_isolate();
 352   HandleScope scope(isolate);
 353
 354   Assembler assm(isolate, NULL, 0);
 355
 356   if (CpuFeatures::IsSupported(ARMv7)) {
 357     CpuFeatureScope scope(&assm, ARMv7);
 358     // On entry, r0 = 0xAAAAAAAA = 0b10..10101010.
 359     __ ubfx(r0, r0, 1, 12);  // 0b00..010101010101 = 0x555
 360     __ sbfx(r0, r0, 0, 5);   // 0b11..111111110101 = -11
 361     __ bfc(r0, 1, 3);        // 0b11..111111110001 = -15
 362     __ mov(r1, Operand(7));
 363     __ bfi(r0, r1, 3, 3);    // 0b11..111111111001 = -7
 364     __ mov(pc, Operand(lr));
 365
 366     CodeDesc desc;
 367     assm.GetCode(&desc);
 368     Handle<Code> code = isolate->factory()->NewCode(
 369         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 370 #ifdef DEBUG
 371     code->Print();
 372 #endif
 373     F1 f = FUNCTION_CAST<F1>(code->entry());
 374     int res = reinterpret_cast<int>(
 375                 CALL_GENERATED_CODE(f, 0xAAAAAAAA, 0, 0, 0, 0));
 376     ::printf("f() = %d\n", res);
 377     CHECK_EQ(-7, res);
 378   }
 379 }
 380
 381
 382 TEST(6) {
 383   // Test saturating instructions.
 384   CcTest::InitializeVM();
 385   Isolate* isolate = CcTest::i_isolate();
 386   HandleScope scope(isolate);
 387
 388   Assembler assm(isolate, NULL, 0);
 389
 390   if (CpuFeatures::IsSupported(ARMv7)) {
 391     CpuFeatureScope scope(&assm, ARMv7);
 392     __ usat(r1, 8, Operand(r0));           // Sat 0xFFFF to 0-255 = 0xFF.
 393     __ usat(r2, 12, Operand(r0, ASR, 9));  // Sat (0xFFFF>>9) to 0-4095 = 0x7F.
 394     __ usat(r3, 1, Operand(r0, LSL, 16));  // Sat (0xFFFF<<16) to 0-1 = 0x0.
 395     __ add(r0, r1, Operand(r2));
 396     __ add(r0, r0, Operand(r3));
 397     __ mov(pc, Operand(lr));
 398
 399     CodeDesc desc;
 400     assm.GetCode(&desc);
 401     Handle<Code> code = isolate->factory()->NewCode(
 402         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 403 #ifdef DEBUG
 404     code->Print();
 405 #endif
 406     F1 f = FUNCTION_CAST<F1>(code->entry());
 407     int res = reinterpret_cast<int>(
 408                 CALL_GENERATED_CODE(f, 0xFFFF, 0, 0, 0, 0));
 409     ::printf("f() = %d\n", res);
 410     CHECK_EQ(382, res);
 411   }
 412 }
 413
 414
 415 enum VCVTTypes {
 416   s32_f64,
 417   u32_f64
 418 };
 419
 420 static void TestRoundingMode(VCVTTypes types,
 421                              VFPRoundingMode mode,
 422                              double value,
 423                              int expected,
 424                              bool expected_exception = false) {
 425   Isolate* isolate = CcTest::i_isolate();
 426   HandleScope scope(isolate);
 427
 428   Assembler assm(isolate, NULL, 0);
 429
 430   if (CpuFeatures::IsSupported(VFP3)) {
 431     CpuFeatureScope scope(&assm, VFP3);
 432
 433     Label wrong_exception;
 434
 435     __ vmrs(r1);
 436     // Set custom FPSCR.
 437     __ bic(r2, r1, Operand(kVFPRoundingModeMask | kVFPExceptionMask));
 438     __ orr(r2, r2, Operand(mode));
 439     __ vmsr(r2);
 440
 441     // Load value, convert, and move back result to r0 if everything went well.
 442     __ vmov(d1, value);
 443     switch (types) {
 444       case s32_f64:
 445         __ vcvt_s32_f64(s0, d1, kFPSCRRounding);
 446         break;
 447
 448       case u32_f64:
 449         __ vcvt_u32_f64(s0, d1, kFPSCRRounding);
 450         break;
 451
 452       default:
 453         UNREACHABLE();
 454         break;
 455     }
 456     // Check for vfp exceptions
 457     __ vmrs(r2);
 458     __ tst(r2, Operand(kVFPExceptionMask));
 459     // Check that we behaved as expected.
 460     __ b(&wrong_exception,
 461          expected_exception ? eq : ne);
 462     // There was no exception. Retrieve the result and return.
 463     __ vmov(r0, s0);
 464     __ mov(pc, Operand(lr));
 465
 466     // The exception behaviour is not what we expected.
 467     // Load a special value and return.
 468     __ bind(&wrong_exception);
 469     __ mov(r0, Operand(11223344));
 470     __ mov(pc, Operand(lr));
 471
 472     CodeDesc desc;
 473     assm.GetCode(&desc);
 474     Handle<Code> code = isolate->factory()->NewCode(
 475         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 476 #ifdef DEBUG
 477     code->Print();
 478 #endif
 479     F1 f = FUNCTION_CAST<F1>(code->entry());
 480     int res = reinterpret_cast<int>(
 481                 CALL_GENERATED_CODE(f, 0, 0, 0, 0, 0));
 482     ::printf("res = %d\n", res);
 483     CHECK_EQ(expected, res);
 484   }
 485 }
 486
 487
 488 TEST(7) {
 489   CcTest::InitializeVM();
 490   // Test vfp rounding modes.
 491
 492   // s32_f64 (double to integer).
 493
 494   TestRoundingMode(s32_f64, RN,  0, 0);
 495   TestRoundingMode(s32_f64, RN,  0.5, 0);
 496   TestRoundingMode(s32_f64, RN, -0.5, 0);
 497   TestRoundingMode(s32_f64, RN,  1.5, 2);
 498   TestRoundingMode(s32_f64, RN, -1.5, -2);
 499   TestRoundingMode(s32_f64, RN,  123.7, 124);
 500   TestRoundingMode(s32_f64, RN, -123.7, -124);
 501   TestRoundingMode(s32_f64, RN,  123456.2,  123456);
 502   TestRoundingMode(s32_f64, RN, -123456.2, -123456);
 503   TestRoundingMode(s32_f64, RN, static_cast<double>(kMaxInt), kMaxInt);
 504   TestRoundingMode(s32_f64, RN, (kMaxInt + 0.49), kMaxInt);
 505   TestRoundingMode(s32_f64, RN, (kMaxInt + 1.0), kMaxInt, true);
 506   TestRoundingMode(s32_f64, RN, (kMaxInt + 0.5), kMaxInt, true);
 507   TestRoundingMode(s32_f64, RN, static_cast<double>(kMinInt), kMinInt);
 508   TestRoundingMode(s32_f64, RN, (kMinInt - 0.5), kMinInt);
 509   TestRoundingMode(s32_f64, RN, (kMinInt - 1.0), kMinInt, true);
 510   TestRoundingMode(s32_f64, RN, (kMinInt - 0.51), kMinInt, true);
 511
 512   TestRoundingMode(s32_f64, RM,  0, 0);
 513   TestRoundingMode(s32_f64, RM,  0.5, 0);
 514   TestRoundingMode(s32_f64, RM, -0.5, -1);
 515   TestRoundingMode(s32_f64, RM,  123.7, 123);
 516   TestRoundingMode(s32_f64, RM, -123.7, -124);
 517   TestRoundingMode(s32_f64, RM,  123456.2,  123456);
 518   TestRoundingMode(s32_f64, RM, -123456.2, -123457);
 519   TestRoundingMode(s32_f64, RM, static_cast<double>(kMaxInt), kMaxInt);
 520   TestRoundingMode(s32_f64, RM, (kMaxInt + 0.5), kMaxInt);
 521   TestRoundingMode(s32_f64, RM, (kMaxInt + 1.0), kMaxInt, true);
 522   TestRoundingMode(s32_f64, RM, static_cast<double>(kMinInt), kMinInt);
 523   TestRoundingMode(s32_f64, RM, (kMinInt - 0.5), kMinInt, true);
 524   TestRoundingMode(s32_f64, RM, (kMinInt + 0.5), kMinInt);
 525
 526   TestRoundingMode(s32_f64, RZ,  0, 0);
 527   TestRoundingMode(s32_f64, RZ,  0.5, 0);
 528   TestRoundingMode(s32_f64, RZ, -0.5, 0);
 529   TestRoundingMode(s32_f64, RZ,  123.7,  123);
 530   TestRoundingMode(s32_f64, RZ, -123.7, -123);
 531   TestRoundingMode(s32_f64, RZ,  123456.2,  123456);
 532   TestRoundingMode(s32_f64, RZ, -123456.2, -123456);
 533   TestRoundingMode(s32_f64, RZ, static_cast<double>(kMaxInt), kMaxInt);
 534   TestRoundingMode(s32_f64, RZ, (kMaxInt + 0.5), kMaxInt);
 535   TestRoundingMode(s32_f64, RZ, (kMaxInt + 1.0), kMaxInt, true);
 536   TestRoundingMode(s32_f64, RZ, static_cast<double>(kMinInt), kMinInt);
 537   TestRoundingMode(s32_f64, RZ, (kMinInt - 0.5), kMinInt);
 538   TestRoundingMode(s32_f64, RZ, (kMinInt - 1.0), kMinInt, true);
 539
 540
 541   // u32_f64 (double to integer).
 542
 543   // Negative values.
 544   TestRoundingMode(u32_f64, RN, -0.5, 0);
 545   TestRoundingMode(u32_f64, RN, -123456.7, 0, true);
 546   TestRoundingMode(u32_f64, RN, static_cast<double>(kMinInt), 0, true);
 547   TestRoundingMode(u32_f64, RN, kMinInt - 1.0, 0, true);
 548
 549   TestRoundingMode(u32_f64, RM, -0.5, 0, true);
 550   TestRoundingMode(u32_f64, RM, -123456.7, 0, true);
 551   TestRoundingMode(u32_f64, RM, static_cast<double>(kMinInt), 0, true);
 552   TestRoundingMode(u32_f64, RM, kMinInt - 1.0, 0, true);
 553
 554   TestRoundingMode(u32_f64, RZ, -0.5, 0);
 555   TestRoundingMode(u32_f64, RZ, -123456.7, 0, true);
 556   TestRoundingMode(u32_f64, RZ, static_cast<double>(kMinInt), 0, true);
 557   TestRoundingMode(u32_f64, RZ, kMinInt - 1.0, 0, true);
 558
 559   // Positive values.
 560   // kMaxInt is the maximum *signed* integer: 0x7fffffff.
 561   static const uint32_t kMaxUInt = 0xffffffffu;
 562   TestRoundingMode(u32_f64, RZ,  0, 0);
 563   TestRoundingMode(u32_f64, RZ,  0.5, 0);
 564   TestRoundingMode(u32_f64, RZ,  123.7,  123);
 565   TestRoundingMode(u32_f64, RZ,  123456.2,  123456);
 566   TestRoundingMode(u32_f64, RZ, static_cast<double>(kMaxInt), kMaxInt);
 567   TestRoundingMode(u32_f64, RZ, (kMaxInt + 0.5), kMaxInt);
 568   TestRoundingMode(u32_f64, RZ, (kMaxInt + 1.0),
 569                                 static_cast<uint32_t>(kMaxInt) + 1);
 570   TestRoundingMode(u32_f64, RZ, (kMaxUInt + 0.5), kMaxUInt);
 571   TestRoundingMode(u32_f64, RZ, (kMaxUInt + 1.0), kMaxUInt, true);
 572
 573   TestRoundingMode(u32_f64, RM,  0, 0);
 574   TestRoundingMode(u32_f64, RM,  0.5, 0);
 575   TestRoundingMode(u32_f64, RM,  123.7, 123);
 576   TestRoundingMode(u32_f64, RM,  123456.2,  123456);
 577   TestRoundingMode(u32_f64, RM, static_cast<double>(kMaxInt), kMaxInt);
 578   TestRoundingMode(u32_f64, RM, (kMaxInt + 0.5), kMaxInt);
 579   TestRoundingMode(u32_f64, RM, (kMaxInt + 1.0),
 580                                 static_cast<uint32_t>(kMaxInt) + 1);
 581   TestRoundingMode(u32_f64, RM, (kMaxUInt + 0.5), kMaxUInt);
 582   TestRoundingMode(u32_f64, RM, (kMaxUInt + 1.0), kMaxUInt, true);
 583
 584   TestRoundingMode(u32_f64, RN,  0, 0);
 585   TestRoundingMode(u32_f64, RN,  0.5, 0);
 586   TestRoundingMode(u32_f64, RN,  1.5, 2);
 587   TestRoundingMode(u32_f64, RN,  123.7, 124);
 588   TestRoundingMode(u32_f64, RN,  123456.2,  123456);
 589   TestRoundingMode(u32_f64, RN, static_cast<double>(kMaxInt), kMaxInt);
 590   TestRoundingMode(u32_f64, RN, (kMaxInt + 0.49), kMaxInt);
 591   TestRoundingMode(u32_f64, RN, (kMaxInt + 0.5),
 592                                 static_cast<uint32_t>(kMaxInt) + 1);
 593   TestRoundingMode(u32_f64, RN, (kMaxUInt + 0.49), kMaxUInt);
 594   TestRoundingMode(u32_f64, RN, (kMaxUInt + 0.5), kMaxUInt, true);
 595   TestRoundingMode(u32_f64, RN, (kMaxUInt + 1.0), kMaxUInt, true);
 596 }
 597
 598
 599 TEST(8) {
 600   // Test VFP multi load/store with ia_w.
 601   CcTest::InitializeVM();
 602   Isolate* isolate = CcTest::i_isolate();
 603   HandleScope scope(isolate);
 604
 605   typedef struct {
 606     double a;
 607     double b;
 608     double c;
 609     double d;
 610     double e;
 611     double f;
 612     double g;
 613     double h;
 614   } D;
 615   D d;
 616
 617   typedef struct {
 618     float a;
 619     float b;
 620     float c;
 621     float d;
 622     float e;
 623     float f;
 624     float g;
 625     float h;
 626   } F;
 627   F f;
 628
 629   // Create a function that uses vldm/vstm to move some double and
 630   // single precision values around in memory.
 631   Assembler assm(isolate, NULL, 0);
 632
 633   __ mov(ip, Operand(sp));
 634   __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
 635   __ sub(fp, ip, Operand(4));
 636
 637   __ add(r4, r0, Operand(OFFSET_OF(D, a)));
 638   __ vldm(ia_w, r4, d0, d3);
 639   __ vldm(ia_w, r4, d4, d7);
 640
 641   __ add(r4, r0, Operand(OFFSET_OF(D, a)));
 642   __ vstm(ia_w, r4, d6, d7);
 643   __ vstm(ia_w, r4, d0, d5);
 644
 645   __ add(r4, r1, Operand(OFFSET_OF(F, a)));
 646   __ vldm(ia_w, r4, s0, s3);
 647   __ vldm(ia_w, r4, s4, s7);
 648
 649   __ add(r4, r1, Operand(OFFSET_OF(F, a)));
 650   __ vstm(ia_w, r4, s6, s7);
 651   __ vstm(ia_w, r4, s0, s5);
 652
 653   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 654
 655   CodeDesc desc;
 656   assm.GetCode(&desc);
 657   Handle<Code> code = isolate->factory()->NewCode(
 658       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 659 #ifdef DEBUG
 660   code->Print();
 661 #endif
 662   F4 fn = FUNCTION_CAST<F4>(code->entry());
 663   d.a = 1.1;
 664   d.b = 2.2;
 665   d.c = 3.3;
 666   d.d = 4.4;
 667   d.e = 5.5;
 668   d.f = 6.6;
 669   d.g = 7.7;
 670   d.h = 8.8;
 671
 672   f.a = 1.0;
 673   f.b = 2.0;
 674   f.c = 3.0;
 675   f.d = 4.0;
 676   f.e = 5.0;
 677   f.f = 6.0;
 678   f.g = 7.0;
 679   f.h = 8.0;
 680
 681   Object* dummy = CALL_GENERATED_CODE(fn, &d, &f, 0, 0, 0);
 682   USE(dummy);
 683
 684   CHECK_EQ(7.7, d.a);
 685   CHECK_EQ(8.8, d.b);
 686   CHECK_EQ(1.1, d.c);
 687   CHECK_EQ(2.2, d.d);
 688   CHECK_EQ(3.3, d.e);
 689   CHECK_EQ(4.4, d.f);
 690   CHECK_EQ(5.5, d.g);
 691   CHECK_EQ(6.6, d.h);
 692
 693   CHECK_EQ(7.0, f.a);
 694   CHECK_EQ(8.0, f.b);
 695   CHECK_EQ(1.0, f.c);
 696   CHECK_EQ(2.0, f.d);
 697   CHECK_EQ(3.0, f.e);
 698   CHECK_EQ(4.0, f.f);
 699   CHECK_EQ(5.0, f.g);
 700   CHECK_EQ(6.0, f.h);
 701 }
 702
 703
 704 TEST(9) {
 705   // Test VFP multi load/store with ia.
 706   CcTest::InitializeVM();
 707   Isolate* isolate = CcTest::i_isolate();
 708   HandleScope scope(isolate);
 709
 710   typedef struct {
 711     double a;
 712     double b;
 713     double c;
 714     double d;
 715     double e;
 716     double f;
 717     double g;
 718     double h;
 719   } D;
 720   D d;
 721
 722   typedef struct {
 723     float a;
 724     float b;
 725     float c;
 726     float d;
 727     float e;
 728     float f;
 729     float g;
 730     float h;
 731   } F;
 732   F f;
 733
 734   // Create a function that uses vldm/vstm to move some double and
 735   // single precision values around in memory.
 736   Assembler assm(isolate, NULL, 0);
 737
 738   __ mov(ip, Operand(sp));
 739   __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
 740   __ sub(fp, ip, Operand(4));
 741
 742   __ add(r4, r0, Operand(OFFSET_OF(D, a)));
 743   __ vldm(ia, r4, d0, d3);
 744   __ add(r4, r4, Operand(4 * 8));
 745   __ vldm(ia, r4, d4, d7);
 746
 747   __ add(r4, r0, Operand(OFFSET_OF(D, a)));
 748   __ vstm(ia, r4, d6, d7);
 749   __ add(r4, r4, Operand(2 * 8));
 750   __ vstm(ia, r4, d0, d5);
 751
 752   __ add(r4, r1, Operand(OFFSET_OF(F, a)));
 753   __ vldm(ia, r4, s0, s3);
 754   __ add(r4, r4, Operand(4 * 4));
 755   __ vldm(ia, r4, s4, s7);
 756
 757   __ add(r4, r1, Operand(OFFSET_OF(F, a)));
 758   __ vstm(ia, r4, s6, s7);
 759   __ add(r4, r4, Operand(2 * 4));
 760   __ vstm(ia, r4, s0, s5);
 761
 762   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 763
 764   CodeDesc desc;
 765   assm.GetCode(&desc);
 766   Handle<Code> code = isolate->factory()->NewCode(
 767       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 768 #ifdef DEBUG
 769   code->Print();
 770 #endif
 771   F4 fn = FUNCTION_CAST<F4>(code->entry());
 772   d.a = 1.1;
 773   d.b = 2.2;
 774   d.c = 3.3;
 775   d.d = 4.4;
 776   d.e = 5.5;
 777   d.f = 6.6;
 778   d.g = 7.7;
 779   d.h = 8.8;
 780
 781   f.a = 1.0;
 782   f.b = 2.0;
 783   f.c = 3.0;
 784   f.d = 4.0;
 785   f.e = 5.0;
 786   f.f = 6.0;
 787   f.g = 7.0;
 788   f.h = 8.0;
 789
 790   Object* dummy = CALL_GENERATED_CODE(fn, &d, &f, 0, 0, 0);
 791   USE(dummy);
 792
 793   CHECK_EQ(7.7, d.a);
 794   CHECK_EQ(8.8, d.b);
 795   CHECK_EQ(1.1, d.c);
 796   CHECK_EQ(2.2, d.d);
 797   CHECK_EQ(3.3, d.e);
 798   CHECK_EQ(4.4, d.f);
 799   CHECK_EQ(5.5, d.g);
 800   CHECK_EQ(6.6, d.h);
 801
 802   CHECK_EQ(7.0, f.a);
 803   CHECK_EQ(8.0, f.b);
 804   CHECK_EQ(1.0, f.c);
 805   CHECK_EQ(2.0, f.d);
 806   CHECK_EQ(3.0, f.e);
 807   CHECK_EQ(4.0, f.f);
 808   CHECK_EQ(5.0, f.g);
 809   CHECK_EQ(6.0, f.h);
 810 }
 811
 812
 813 TEST(10) {
 814   // Test VFP multi load/store with db_w.
 815   CcTest::InitializeVM();
 816   Isolate* isolate = CcTest::i_isolate();
 817   HandleScope scope(isolate);
 818
 819   typedef struct {
 820     double a;
 821     double b;
 822     double c;
 823     double d;
 824     double e;
 825     double f;
 826     double g;
 827     double h;
 828   } D;
 829   D d;
 830
 831   typedef struct {
 832     float a;
 833     float b;
 834     float c;
 835     float d;
 836     float e;
 837     float f;
 838     float g;
 839     float h;
 840   } F;
 841   F f;
 842
 843   // Create a function that uses vldm/vstm to move some double and
 844   // single precision values around in memory.
 845   Assembler assm(isolate, NULL, 0);
 846
 847   __ mov(ip, Operand(sp));
 848   __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
 849   __ sub(fp, ip, Operand(4));
 850
 851   __ add(r4, r0, Operand(OFFSET_OF(D, h) + 8));
 852   __ vldm(db_w, r4, d4, d7);
 853   __ vldm(db_w, r4, d0, d3);
 854
 855   __ add(r4, r0, Operand(OFFSET_OF(D, h) + 8));
 856   __ vstm(db_w, r4, d0, d5);
 857   __ vstm(db_w, r4, d6, d7);
 858
 859   __ add(r4, r1, Operand(OFFSET_OF(F, h) + 4));
 860   __ vldm(db_w, r4, s4, s7);
 861   __ vldm(db_w, r4, s0, s3);
 862
 863   __ add(r4, r1, Operand(OFFSET_OF(F, h) + 4));
 864   __ vstm(db_w, r4, s0, s5);
 865   __ vstm(db_w, r4, s6, s7);
 866
 867   __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
 868
 869   CodeDesc desc;
 870   assm.GetCode(&desc);
 871   Handle<Code> code = isolate->factory()->NewCode(
 872       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 873 #ifdef DEBUG
 874   code->Print();
 875 #endif
 876   F4 fn = FUNCTION_CAST<F4>(code->entry());
 877   d.a = 1.1;
 878   d.b = 2.2;
 879   d.c = 3.3;
 880   d.d = 4.4;
 881   d.e = 5.5;
 882   d.f = 6.6;
 883   d.g = 7.7;
 884   d.h = 8.8;
 885
 886   f.a = 1.0;
 887   f.b = 2.0;
 888   f.c = 3.0;
 889   f.d = 4.0;
 890   f.e = 5.0;
 891   f.f = 6.0;
 892   f.g = 7.0;
 893   f.h = 8.0;
 894
 895   Object* dummy = CALL_GENERATED_CODE(fn, &d, &f, 0, 0, 0);
 896   USE(dummy);
 897
 898   CHECK_EQ(7.7, d.a);
 899   CHECK_EQ(8.8, d.b);
 900   CHECK_EQ(1.1, d.c);
 901   CHECK_EQ(2.2, d.d);
 902   CHECK_EQ(3.3, d.e);
 903   CHECK_EQ(4.4, d.f);
 904   CHECK_EQ(5.5, d.g);
 905   CHECK_EQ(6.6, d.h);
 906
 907   CHECK_EQ(7.0, f.a);
 908   CHECK_EQ(8.0, f.b);
 909   CHECK_EQ(1.0, f.c);
 910   CHECK_EQ(2.0, f.d);
 911   CHECK_EQ(3.0, f.e);
 912   CHECK_EQ(4.0, f.f);
 913   CHECK_EQ(5.0, f.g);
 914   CHECK_EQ(6.0, f.h);
 915 }
 916
 917
 918 TEST(11) {
 919   // Test instructions using the carry flag.
 920   CcTest::InitializeVM();
 921   Isolate* isolate = CcTest::i_isolate();
 922   HandleScope scope(isolate);
 923
 924   typedef struct {
 925     int32_t a;
 926     int32_t b;
 927     int32_t c;
 928     int32_t d;
 929   } I;
 930   I i;
 931
 932   i.a = 0xabcd0001;
 933   i.b = 0xabcd0000;
 934
 935   Assembler assm(isolate, NULL, 0);
 936
 937   // Test HeapObject untagging.
 938   __ ldr(r1, MemOperand(r0, OFFSET_OF(I, a)));
 939   __ mov(r1, Operand(r1, ASR, 1), SetCC);
 940   __ adc(r1, r1, Operand(r1), LeaveCC, cs);
 941   __ str(r1, MemOperand(r0, OFFSET_OF(I, a)));
 942
 943   __ ldr(r2, MemOperand(r0, OFFSET_OF(I, b)));
 944   __ mov(r2, Operand(r2, ASR, 1), SetCC);
 945   __ adc(r2, r2, Operand(r2), LeaveCC, cs);
 946   __ str(r2, MemOperand(r0, OFFSET_OF(I, b)));
 947
 948   // Test corner cases.
 949   __ mov(r1, Operand(0xffffffff));
 950   __ mov(r2, Operand::Zero());
 951   __ mov(r3, Operand(r1, ASR, 1), SetCC);  // Set the carry.
 952   __ adc(r3, r1, Operand(r2));
 953   __ str(r3, MemOperand(r0, OFFSET_OF(I, c)));
 954
 955   __ mov(r1, Operand(0xffffffff));
 956   __ mov(r2, Operand::Zero());
 957   __ mov(r3, Operand(r2, ASR, 1), SetCC);  // Unset the carry.
 958   __ adc(r3, r1, Operand(r2));
 959   __ str(r3, MemOperand(r0, OFFSET_OF(I, d)));
 960
 961   __ mov(pc, Operand(lr));
 962
 963   CodeDesc desc;
 964   assm.GetCode(&desc);
 965   Handle<Code> code = isolate->factory()->NewCode(
 966       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 967 #ifdef DEBUG
 968   code->Print();
 969 #endif
 970   F3 f = FUNCTION_CAST<F3>(code->entry());
 971   Object* dummy = CALL_GENERATED_CODE(f, &i, 0, 0, 0, 0);
 972   USE(dummy);
 973
 974   CHECK_EQ(0xabcd0001, i.a);
 975   CHECK_EQ(static_cast<int32_t>(0xabcd0000) >> 1, i.b);
 976   CHECK_EQ(0x00000000, i.c);
 977   CHECK_EQ(0xffffffff, i.d);
 978 }
 979
 980
 981 TEST(12) {
 982   // Test chaining of label usages within instructions (issue 1644).
 983   CcTest::InitializeVM();
 984   Isolate* isolate = CcTest::i_isolate();
 985   HandleScope scope(isolate);
 986
 987   Assembler assm(isolate, NULL, 0);
 988   Label target;
 989   __ b(eq, &target);
 990   __ b(ne, &target);
 991   __ bind(&target);
 992   __ nop();
 993 }
 994
 995
 996 TEST(13) {
 997   // Test VFP instructions using registers d16-d31.
 998   CcTest::InitializeVM();
 999   Isolate* isolate = CcTest::i_isolate();
1000   HandleScope scope(isolate);
1001
1002   if (!CpuFeatures::IsSupported(VFP32DREGS)) {
1003     return;
1004   }
1005
1006   typedef struct {
1007     double a;
1008     double b;
1009     double c;
1010     double x;
1011     double y;
1012     double z;
1013     double i;
1014     double j;
1015     double k;
1016     uint32_t low;
1017     uint32_t high;
1018   } T;
1019   T t;
1020
1021   // Create a function that accepts &t, and loads, manipulates, and stores
1022   // the doubles and floats.
1023   Assembler assm(isolate, NULL, 0);
1024   Label L, C;
1025
1026
1027   if (CpuFeatures::IsSupported(VFP3)) {
1028     CpuFeatureScope scope(&assm, VFP3);
1029
1030     __ stm(db_w, sp, r4.bit() | lr.bit());
1031
1032     // Load a, b, c into d16, d17, d18.
1033     __ mov(r4, Operand(r0));
1034     __ vldr(d16, r4, OFFSET_OF(T, a));
1035     __ vldr(d17, r4, OFFSET_OF(T, b));
1036     __ vldr(d18, r4, OFFSET_OF(T, c));
1037
1038     __ vneg(d25, d16);
1039     __ vadd(d25, d25, d17);
1040     __ vsub(d25, d25, d18);
1041     __ vmul(d25, d25, d25);
1042     __ vdiv(d25, d25, d18);
1043
1044     __ vmov(d16, d25);
1045     __ vsqrt(d17, d25);
1046     __ vneg(d17, d17);
1047     __ vabs(d17, d17);
1048     __ vmla(d18, d16, d17);
1049
1050     // Store d16, d17, d18 into a, b, c.
1051     __ mov(r4, Operand(r0));
1052     __ vstr(d16, r4, OFFSET_OF(T, a));
1053     __ vstr(d17, r4, OFFSET_OF(T, b));
1054     __ vstr(d18, r4, OFFSET_OF(T, c));
1055
1056     // Load x, y, z into d29-d31.
1057     __ add(r4, r0, Operand(OFFSET_OF(T, x)));
1058     __ vldm(ia_w, r4, d29, d31);
1059
1060     // Swap d29 and d30 via r registers.
1061     __ vmov(r1, r2, d29);
1062     __ vmov(d29, d30);
1063     __ vmov(d30, r1, r2);
1064
1065     // Convert to and from integer.
1066     __ vcvt_s32_f64(s1, d31);
1067     __ vcvt_f64_u32(d31, s1);
1068
1069     // Store d29-d31 into x, y, z.
1070     __ add(r4, r0, Operand(OFFSET_OF(T, x)));
1071     __ vstm(ia_w, r4, d29, d31);
1072
1073     // Move constants into d20, d21, d22 and store into i, j, k.
1074     __ vmov(d20, 14.7610017472335499);
1075     __ vmov(d21, 16.0);
1076     __ mov(r1, Operand(372106121));
1077     __ mov(r2, Operand(1079146608));
1078     __ vmov(d22, VmovIndexLo, r1);
1079     __ vmov(d22, VmovIndexHi, r2);
1080     __ add(r4, r0, Operand(OFFSET_OF(T, i)));
1081     __ vstm(ia_w, r4, d20, d22);
1082     // Move d22 into low and high.
1083     __ vmov(r4, VmovIndexLo, d22);
1084     __ str(r4, MemOperand(r0, OFFSET_OF(T, low)));
1085     __ vmov(r4, VmovIndexHi, d22);
1086     __ str(r4, MemOperand(r0, OFFSET_OF(T, high)));
1087
1088     __ ldm(ia_w, sp, r4.bit() | pc.bit());
1089
1090     CodeDesc desc;
1091     assm.GetCode(&desc);
1092     Handle<Code> code = isolate->factory()->NewCode(
1093         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
1094 #ifdef DEBUG
1095     code->Print();
1096 #endif
1097     F3 f = FUNCTION_CAST<F3>(code->entry());
1098     t.a = 1.5;
1099     t.b = 2.75;
1100     t.c = 17.17;
1101     t.x = 1.5;
1102     t.y = 2.75;
1103     t.z = 17.17;
1104     Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
1105     USE(dummy);
1106     CHECK_EQ(14.7610017472335499, t.a);
1107     CHECK_EQ(3.84200491244266251, t.b);
1108     CHECK_EQ(73.8818412254460241, t.c);
1109     CHECK_EQ(2.75, t.x);
1110     CHECK_EQ(1.5, t.y);
1111     CHECK_EQ(17.0, t.z);
1112     CHECK_EQ(14.7610017472335499, t.i);
1113     CHECK_EQ(16.0, t.j);
1114     CHECK_EQ(73.8818412254460241, t.k);
1115     CHECK_EQ(372106121, t.low);
1116     CHECK_EQ(1079146608, t.high);
1117   }
1118 }
1119
1120
1121 TEST(14) {
1122   // Test the VFP Canonicalized Nan mode.
1123   CcTest::InitializeVM();
1124   Isolate* isolate = CcTest::i_isolate();
1125   HandleScope scope(isolate);
1126
1127   typedef struct {
1128     double left;
1129     double right;
1130     double add_result;
1131     double sub_result;
1132     double mul_result;
1133     double div_result;
1134   } T;
1135   T t;
1136
1137   // Create a function that makes the four basic operations.
1138   Assembler assm(isolate, NULL, 0);
1139
1140   // Ensure FPSCR state (as JSEntryStub does).
1141   Label fpscr_done;
1142   __ vmrs(r1);
1143   __ tst(r1, Operand(kVFPDefaultNaNModeControlBit));
1144   __ b(ne, &fpscr_done);
1145   __ orr(r1, r1, Operand(kVFPDefaultNaNModeControlBit));
1146   __ vmsr(r1);
1147   __ bind(&fpscr_done);
1148
1149   __ vldr(d0, r0, OFFSET_OF(T, left));
1150   __ vldr(d1, r0, OFFSET_OF(T, right));
1151   __ vadd(d2, d0, d1);
1152   __ vstr(d2, r0, OFFSET_OF(T, add_result));
1153   __ vsub(d2, d0, d1);
1154   __ vstr(d2, r0, OFFSET_OF(T, sub_result));
1155   __ vmul(d2, d0, d1);
1156   __ vstr(d2, r0, OFFSET_OF(T, mul_result));
1157   __ vdiv(d2, d0, d1);
1158   __ vstr(d2, r0, OFFSET_OF(T, div_result));
1159
1160   __ mov(pc, Operand(lr));
1161
1162   CodeDesc desc;
1163   assm.GetCode(&desc);
1164   Handle<Code> code = isolate->factory()->NewCode(
1165       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
1166 #ifdef DEBUG
1167   code->Print();
1168 #endif
1169   F3 f = FUNCTION_CAST<F3>(code->entry());
1170   t.left = BitCast<double>(kHoleNanInt64);
1171   t.right = 1;
1172   t.add_result = 0;
1173   t.sub_result = 0;
1174   t.mul_result = 0;
1175   t.div_result = 0;
1176   Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
1177   USE(dummy);
1178   const uint32_t kArmNanUpper32 = 0x7ff80000;
1179   const uint32_t kArmNanLower32 = 0x00000000;
1180 #ifdef DEBUG
1181   const uint64_t kArmNanInt64 =
1182       (static_cast<uint64_t>(kArmNanUpper32) << 32) | kArmNanLower32;
1183   ASSERT(kArmNanInt64 != kHoleNanInt64);
1184 #endif
1185   // With VFP2 the sign of the canonicalized Nan is undefined. So
1186   // we remove the sign bit for the upper tests.
1187   CHECK_EQ(kArmNanUpper32, (BitCast<int64_t>(t.add_result) >> 32) & 0x7fffffff);
1188   CHECK_EQ(kArmNanLower32, BitCast<int64_t>(t.add_result) & 0xffffffffu);
1189   CHECK_EQ(kArmNanUpper32, (BitCast<int64_t>(t.sub_result) >> 32) & 0x7fffffff);
1190   CHECK_EQ(kArmNanLower32, BitCast<int64_t>(t.sub_result) & 0xffffffffu);
1191   CHECK_EQ(kArmNanUpper32, (BitCast<int64_t>(t.mul_result) >> 32) & 0x7fffffff);
1192   CHECK_EQ(kArmNanLower32, BitCast<int64_t>(t.mul_result) & 0xffffffffu);
1193   CHECK_EQ(kArmNanUpper32, (BitCast<int64_t>(t.div_result) >> 32) & 0x7fffffff);
1194   CHECK_EQ(kArmNanLower32, BitCast<int64_t>(t.div_result) & 0xffffffffu);
1195 }
1196
1197
1198 TEST(15) {
1199   // Test the Neon instructions.
1200   CcTest::InitializeVM();
1201   Isolate* isolate = CcTest::i_isolate();
1202   HandleScope scope(isolate);
1203
1204   typedef struct {
1205     uint32_t src0;
1206     uint32_t src1;
1207     uint32_t src2;
1208     uint32_t src3;
1209     uint32_t src4;
1210     uint32_t src5;
1211     uint32_t src6;
1212     uint32_t src7;
1213     uint32_t dst0;
1214     uint32_t dst1;
1215     uint32_t dst2;
1216     uint32_t dst3;
1217     uint32_t dst4;
1218     uint32_t dst5;
1219     uint32_t dst6;
1220     uint32_t dst7;
1221     uint32_t srcA0;
1222     uint32_t srcA1;
1223     uint32_t dstA0;
1224     uint32_t dstA1;
1225     uint32_t dstA2;
1226     uint32_t dstA3;
1227     uint32_t dstA4;
1228     uint32_t dstA5;
1229     uint32_t dstA6;
1230     uint32_t dstA7;
1231   } T;
1232   T t;
1233
1234   // Create a function that accepts &t, and loads, manipulates, and stores
1235   // the doubles and floats.
1236   Assembler assm(isolate, NULL, 0);
1237
1238
1239   if (CpuFeatures::IsSupported(NEON)) {
1240     CpuFeatureScope scope(&assm, NEON);
1241
1242     __ stm(db_w, sp, r4.bit() | lr.bit());
1243     // Move 32 bytes with neon.
1244     __ add(r4, r0, Operand(OFFSET_OF(T, src0)));
1245     __ vld1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(r4));
1246     __ add(r4, r0, Operand(OFFSET_OF(T, dst0)));
1247     __ vst1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(r4));
1248
1249     // Expand 8 bytes into 8 words(16 bits).
1250     __ add(r4, r0, Operand(OFFSET_OF(T, srcA0)));
1251     __ vld1(Neon8, NeonListOperand(d0), NeonMemOperand(r4));
1252     __ vmovl(NeonU8, q0, d0);
1253     __ add(r4, r0, Operand(OFFSET_OF(T, dstA0)));
1254     __ vst1(Neon8, NeonListOperand(d0, 2), NeonMemOperand(r4));
1255
1256     // The same expansion, but with different source and destination registers.
1257     __ add(r4, r0, Operand(OFFSET_OF(T, srcA0)));
1258     __ vld1(Neon8, NeonListOperand(d1), NeonMemOperand(r4));
1259     __ vmovl(NeonU8, q1, d1);
1260     __ add(r4, r0, Operand(OFFSET_OF(T, dstA4)));
1261     __ vst1(Neon8, NeonListOperand(d2, 2), NeonMemOperand(r4));
1262
1263     __ ldm(ia_w, sp, r4.bit() | pc.bit());
1264
1265     CodeDesc desc;
1266     assm.GetCode(&desc);
1267     Handle<Code> code = isolate->factory()->NewCode(
1268         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
1269 #ifdef DEBUG
1270     code->Print();
1271 #endif
1272     F3 f = FUNCTION_CAST<F3>(code->entry());
1273     t.src0 = 0x01020304;
1274     t.src1 = 0x11121314;
1275     t.src2 = 0x21222324;
1276     t.src3 = 0x31323334;
1277     t.src4 = 0x41424344;
1278     t.src5 = 0x51525354;
1279     t.src6 = 0x61626364;
1280     t.src7 = 0x71727374;
1281     t.dst0 = 0;
1282     t.dst1 = 0;
1283     t.dst2 = 0;
1284     t.dst3 = 0;
1285     t.dst4 = 0;
1286     t.dst5 = 0;
1287     t.dst6 = 0;
1288     t.dst7 = 0;
1289     t.srcA0 = 0x41424344;
1290     t.srcA1 = 0x81828384;
1291     t.dstA0 = 0;
1292     t.dstA1 = 0;
1293     t.dstA2 = 0;
1294     t.dstA3 = 0;
1295     t.dstA4 = 0;
1296     t.dstA5 = 0;
1297     t.dstA6 = 0;
1298     t.dstA7 = 0;
1299     Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
1300     USE(dummy);
1301     CHECK_EQ(0x01020304, t.dst0);
1302     CHECK_EQ(0x11121314, t.dst1);
1303     CHECK_EQ(0x21222324, t.dst2);
1304     CHECK_EQ(0x31323334, t.dst3);
1305     CHECK_EQ(0x41424344, t.dst4);
1306     CHECK_EQ(0x51525354, t.dst5);
1307     CHECK_EQ(0x61626364, t.dst6);
1308     CHECK_EQ(0x71727374, t.dst7);
1309     CHECK_EQ(0x00430044, t.dstA0);
1310     CHECK_EQ(0x00410042, t.dstA1);
1311     CHECK_EQ(0x00830084, t.dstA2);
1312     CHECK_EQ(0x00810082, t.dstA3);
1313     CHECK_EQ(0x00430044, t.dstA4);
1314     CHECK_EQ(0x00410042, t.dstA5);
1315     CHECK_EQ(0x00830084, t.dstA6);
1316     CHECK_EQ(0x00810082, t.dstA7);
1317   }
1318 }
1319
1320
1321 TEST(16) {
1322   // Test the pkh, uxtb, uxtab and uxtb16 instructions.
1323   CcTest::InitializeVM();
1324   Isolate* isolate = CcTest::i_isolate();
1325   HandleScope scope(isolate);
1326
1327   typedef struct {
1328     uint32_t src0;
1329     uint32_t src1;
1330     uint32_t src2;
1331     uint32_t dst0;
1332     uint32_t dst1;
1333     uint32_t dst2;
1334     uint32_t dst3;
1335     uint32_t dst4;
1336   } T;
1337   T t;
1338
1339   // Create a function that accepts &t, and loads, manipulates, and stores
1340   // the doubles and floats.
1341   Assembler assm(isolate, NULL, 0);
1342
1343   __ stm(db_w, sp, r4.bit() | lr.bit());
1344
1345   __ mov(r4, Operand(r0));
1346   __ ldr(r0, MemOperand(r4, OFFSET_OF(T, src0)));
1347   __ ldr(r1, MemOperand(r4, OFFSET_OF(T, src1)));
1348
1349   __ pkhbt(r2, r0, Operand(r1, LSL, 8));
1350   __ str(r2, MemOperand(r4, OFFSET_OF(T, dst0)));
1351
1352   __ pkhtb(r2, r0, Operand(r1, ASR, 8));
1353   __ str(r2, MemOperand(r4, OFFSET_OF(T, dst1)));
1354
1355   __ uxtb16(r2, Operand(r0, ROR, 8));
1356   __ str(r2, MemOperand(r4, OFFSET_OF(T, dst2)));
1357
1358   __ uxtb(r2, Operand(r0, ROR, 8));
1359   __ str(r2, MemOperand(r4, OFFSET_OF(T, dst3)));
1360
1361   __ ldr(r0, MemOperand(r4, OFFSET_OF(T, src2)));
1362   __ uxtab(r2, r0, Operand(r1, ROR, 8));
1363   __ str(r2, MemOperand(r4, OFFSET_OF(T, dst4)));
1364
1365   __ ldm(ia_w, sp, r4.bit() | pc.bit());
1366
1367   CodeDesc desc;
1368   assm.GetCode(&desc);
1369   Handle<Code> code = isolate->factory()->NewCode(
1370       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
1371 #ifdef DEBUG
1372   code->Print();
1373 #endif
1374   F3 f = FUNCTION_CAST<F3>(code->entry());
1375   t.src0 = 0x01020304;
1376   t.src1 = 0x11121314;
1377   t.src2 = 0x11121300;
1378   t.dst0 = 0;
1379   t.dst1 = 0;
1380   t.dst2 = 0;
1381   t.dst3 = 0;
1382   t.dst4 = 0;
1383   Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
1384   USE(dummy);
1385   CHECK_EQ(0x12130304, t.dst0);
1386   CHECK_EQ(0x01021213, t.dst1);
1387   CHECK_EQ(0x00010003, t.dst2);
1388   CHECK_EQ(0x00000003, t.dst3);
1389   CHECK_EQ(0x11121313, t.dst4);
1390 }
1391
1392
1393 TEST(17) {
1394   // Test generating labels at high addresses.
1395   // Should not assert.
1396   CcTest::InitializeVM();
1397   Isolate* isolate = CcTest::i_isolate();
1398   HandleScope scope(isolate);
1399
1400   // Generate a code segment that will be longer than 2^24 bytes.
1401   Assembler assm(isolate, NULL, 0);
1402   for (size_t i = 0; i < 1 << 23 ; ++i) {  // 2^23
1403     __ nop();
1404   }
1405
1406   Label target;
1407   __ b(eq, &target);
1408   __ bind(&target);
1409   __ nop();
1410 }
1411
1412
1413 #define TEST_SDIV(expected_, dividend_, divisor_) \
1414     t.dividend = dividend_; \
1415     t.divisor = divisor_; \
1416     t.result = 0; \
1417     dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0); \
1418     CHECK_EQ(expected_, t.result);
1419
1420
1421 TEST(18) {
1422   // Test the sdiv.
1423   CcTest::InitializeVM();
1424   Isolate* isolate = CcTest::i_isolate();
1425   HandleScope scope(isolate);
1426
1427   typedef struct {
1428     uint32_t dividend;
1429     uint32_t divisor;
1430     uint32_t result;
1431   } T;
1432   T t;
1433
1434   Assembler assm(isolate, NULL, 0);
1435
1436   if (CpuFeatures::IsSupported(SUDIV)) {
1437     CpuFeatureScope scope(&assm, SUDIV);
1438
1439     __ mov(r3, Operand(r0));
1440
1441     __ ldr(r0, MemOperand(r3, OFFSET_OF(T, dividend)));
1442     __ ldr(r1, MemOperand(r3, OFFSET_OF(T, divisor)));
1443
1444     __ sdiv(r2, r0, r1);
1445     __ str(r2, MemOperand(r3, OFFSET_OF(T, result)));
1446
1447   __ bx(lr);
1448
1449     CodeDesc desc;
1450     assm.GetCode(&desc);
1451     Handle<Code> code = isolate->factory()->NewCode(
1452         desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
1453 #ifdef DEBUG
1454     code->Print();
1455 #endif
1456     F3 f = FUNCTION_CAST<F3>(code->entry());
1457     Object* dummy;
1458     TEST_SDIV(1073741824, kMinInt, -2);
1459     TEST_SDIV(kMinInt, kMinInt, -1);
1460     TEST_SDIV(5, 10, 2);
1461     TEST_SDIV(3, 10, 3);
1462     TEST_SDIV(-5, 10, -2);
1463     TEST_SDIV(-3, 10, -3);
1464     TEST_SDIV(-5, -10, 2);
1465     TEST_SDIV(-3, -10, 3);
1466     TEST_SDIV(5, -10, -2);
1467     TEST_SDIV(3, -10, -3);
1468     USE(dummy);
1469   }
1470 }
1471
1472
1473 #undef TEST_SDIV
1474
1475
1476 TEST(code_relative_offset) {
1477   // Test extracting the offset of a label from the beginning of the code
1478   // in a register.
1479   CcTest::InitializeVM();
1480   Isolate* isolate = CcTest::i_isolate();
1481   HandleScope scope(isolate);
1482   // Initialize a code object that will contain the code.
1483   Handle<Object> code_object(isolate->heap()->undefined_value(), isolate);
1484
1485   Assembler assm(isolate, NULL, 0);
1486
1487   Label start, target_away, target_faraway;
1488
1489   __ stm(db_w, sp, r4.bit() | r5.bit() | lr.bit());
1490
1491   // r3 is used as the address zero, the test will crash when we load it.
1492   __ mov(r3, Operand::Zero());
1493
1494   // r5 will be a pointer to the start of the code.
1495   __ mov(r5, Operand(code_object));
1496   __ mov_label_offset(r4, &start);
1497
1498   __ mov_label_offset(r1, &target_faraway);
1499   __ str(r1, MemOperand(sp, kPointerSize, NegPreIndex));
1500
1501   __ mov_label_offset(r1, &target_away);
1502
1503   // Jump straight to 'target_away' the first time and use the relative
1504   // position the second time. This covers the case when extracting the
1505   // position of a label which is linked.
1506   __ mov(r2, Operand::Zero());
1507   __ bind(&start);
1508   __ cmp(r2, Operand::Zero());
1509   __ b(eq, &target_away);
1510   __ add(pc, r5, r1);
1511   // Emit invalid instructions to push the label between 2^8 and 2^16
1512   // instructions away. The test will crash if they are reached.
1513   for (int i = 0; i < (1 << 10); i++) {
1514     __ ldr(r3, MemOperand(r3));
1515   }
1516   __ bind(&target_away);
1517   // This will be hit twice: r0 = r0 + 5 + 5.
1518   __ add(r0, r0, Operand(5));
1519
1520   __ ldr(r1, MemOperand(sp, kPointerSize, PostIndex), ne);
1521   __ add(pc, r5, r4, LeaveCC, ne);
1522
1523   __ mov(r2, Operand(1));
1524   __ b(&start);
1525   // Emit invalid instructions to push the label between 2^16 and 2^24
1526   // instructions away. The test will crash if they are reached.
1527   for (int i = 0; i < (1 << 21); i++) {
1528     __ ldr(r3, MemOperand(r3));
1529   }
1530   __ bind(&target_faraway);
1531   // r0 = r0 + 5 + 5 + 11
1532   __ add(r0, r0, Operand(11));
1533
1534   __ ldm(ia_w, sp, r4.bit() | r5.bit() | pc.bit());
1535
1536   CodeDesc desc;
1537   assm.GetCode(&desc);
1538   Handle<Code> code = isolate->factory()->NewCode(
1539       desc, Code::ComputeFlags(Code::STUB), code_object);
1540   F1 f = FUNCTION_CAST<F1>(code->entry());
1541   int res = reinterpret_cast<int>(CALL_GENERATED_CODE(f, 21, 0, 0, 0, 0));
1542   ::printf("f() = %d\n", res);
1543   CHECK_EQ(42, res);
1544 }
1545
1546 #undef __