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