src/v8/src/x64/macro-assembler-x64.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #if V8_TARGET_ARCH_X64
   8
   9 #include "src/bootstrapper.h"
  10 #include "src/codegen.h"
  11 #include "src/cpu-profiler.h"
  12 #include "src/x64/assembler-x64.h"
  13 #include "src/x64/macro-assembler-x64.h"
  14 #include "src/serialize.h"
  15 #include "src/debug.h"
  16 #include "src/heap.h"
  17 #include "src/isolate-inl.h"
  18
  19 namespace v8 {
  20 namespace internal {
  21
  22 MacroAssembler::MacroAssembler(Isolate* arg_isolate, void* buffer, int size)
  23     : Assembler(arg_isolate, buffer, size),
  24       generating_stub_(false),
  25       has_frame_(false),
  26       root_array_available_(true) {
  27   if (isolate() != NULL) {
  28     code_object_ = Handle<Object>(isolate()->heap()->undefined_value(),
  29                                   isolate());
  30   }
  31 }
  32
  33
  34 static const int64_t kInvalidRootRegisterDelta = -1;
  35
  36
  37 int64_t MacroAssembler::RootRegisterDelta(ExternalReference other) {
  38   if (predictable_code_size() &&
  39       (other.address() < reinterpret_cast<Address>(isolate()) ||
  40        other.address() >= reinterpret_cast<Address>(isolate() + 1))) {
  41     return kInvalidRootRegisterDelta;
  42   }
  43   Address roots_register_value = kRootRegisterBias +
  44       reinterpret_cast<Address>(isolate()->heap()->roots_array_start());
  45
  46   int64_t delta = kInvalidRootRegisterDelta;  // Bogus initialization.
  47   if (kPointerSize == kInt64Size) {
  48     delta = other.address() - roots_register_value;
  49   } else {
  50     // For x32, zero extend the address to 64-bit and calculate the delta.
  51     uint64_t o = static_cast<uint32_t>(
  52         reinterpret_cast<intptr_t>(other.address()));
  53     uint64_t r = static_cast<uint32_t>(
  54         reinterpret_cast<intptr_t>(roots_register_value));
  55     delta = o - r;
  56   }
  57   return delta;
  58 }
  59
  60
  61 Operand MacroAssembler::ExternalOperand(ExternalReference target,
  62                                         Register scratch) {
  63   if (root_array_available_ && !serializer_enabled()) {
  64     int64_t delta = RootRegisterDelta(target);
  65     if (delta != kInvalidRootRegisterDelta && is_int32(delta)) {
  66       return Operand(kRootRegister, static_cast<int32_t>(delta));
  67     }
  68   }
  69   Move(scratch, target);
  70   return Operand(scratch, 0);
  71 }
  72
  73
  74 void MacroAssembler::Load(Register destination, ExternalReference source) {
  75   if (root_array_available_ && !serializer_enabled()) {
  76     int64_t delta = RootRegisterDelta(source);
  77     if (delta != kInvalidRootRegisterDelta && is_int32(delta)) {
  78       movp(destination, Operand(kRootRegister, static_cast<int32_t>(delta)));
  79       return;
  80     }
  81   }
  82   // Safe code.
  83   if (destination.is(rax)) {
  84     load_rax(source);
  85   } else {
  86     Move(kScratchRegister, source);
  87     movp(destination, Operand(kScratchRegister, 0));
  88   }
  89 }
  90
  91
  92 void MacroAssembler::Store(ExternalReference destination, Register source) {
  93   if (root_array_available_ && !serializer_enabled()) {
  94     int64_t delta = RootRegisterDelta(destination);
  95     if (delta != kInvalidRootRegisterDelta && is_int32(delta)) {
  96       movp(Operand(kRootRegister, static_cast<int32_t>(delta)), source);
  97       return;
  98     }
  99   }
 100   // Safe code.
 101   if (source.is(rax)) {
 102     store_rax(destination);
 103   } else {
 104     Move(kScratchRegister, destination);
 105     movp(Operand(kScratchRegister, 0), source);
 106   }
 107 }
 108
 109
 110 void MacroAssembler::LoadAddress(Register destination,
 111                                  ExternalReference source) {
 112   if (root_array_available_ && !serializer_enabled()) {
 113     int64_t delta = RootRegisterDelta(source);
 114     if (delta != kInvalidRootRegisterDelta && is_int32(delta)) {
 115       leap(destination, Operand(kRootRegister, static_cast<int32_t>(delta)));
 116       return;
 117     }
 118   }
 119   // Safe code.
 120   Move(destination, source);
 121 }
 122
 123
 124 int MacroAssembler::LoadAddressSize(ExternalReference source) {
 125   if (root_array_available_ && !serializer_enabled()) {
 126     // This calculation depends on the internals of LoadAddress.
 127     // It's correctness is ensured by the asserts in the Call
 128     // instruction below.
 129     int64_t delta = RootRegisterDelta(source);
 130     if (delta != kInvalidRootRegisterDelta && is_int32(delta)) {
 131       // Operand is leap(scratch, Operand(kRootRegister, delta));
 132       // Opcodes : REX.W 8D ModRM Disp8/Disp32  - 4 or 7.
 133       int size = 4;
 134       if (!is_int8(static_cast<int32_t>(delta))) {
 135         size += 3;  // Need full four-byte displacement in lea.
 136       }
 137       return size;
 138     }
 139   }
 140   // Size of movp(destination, src);
 141   return Assembler::kMoveAddressIntoScratchRegisterInstructionLength;
 142 }
 143
 144
 145 void MacroAssembler::PushAddress(ExternalReference source) {
 146   int64_t address = reinterpret_cast<int64_t>(source.address());
 147   if (is_int32(address) && !serializer_enabled()) {
 148     if (emit_debug_code()) {
 149       Move(kScratchRegister, kZapValue, Assembler::RelocInfoNone());
 150     }
 151     Push(Immediate(static_cast<int32_t>(address)));
 152     return;
 153   }
 154   LoadAddress(kScratchRegister, source);
 155   Push(kScratchRegister);
 156 }
 157
 158
 159 void MacroAssembler::LoadRoot(Register destination, Heap::RootListIndex index) {
 160   ASSERT(root_array_available_);
 161   movp(destination, Operand(kRootRegister,
 162                             (index << kPointerSizeLog2) - kRootRegisterBias));
 163 }
 164
 165
 166 void MacroAssembler::LoadRootIndexed(Register destination,
 167                                      Register variable_offset,
 168                                      int fixed_offset) {
 169   ASSERT(root_array_available_);
 170   movp(destination,
 171        Operand(kRootRegister,
 172                variable_offset, times_pointer_size,
 173                (fixed_offset << kPointerSizeLog2) - kRootRegisterBias));
 174 }
 175
 176
 177 void MacroAssembler::StoreRoot(Register source, Heap::RootListIndex index) {
 178   ASSERT(root_array_available_);
 179   movp(Operand(kRootRegister, (index << kPointerSizeLog2) - kRootRegisterBias),
 180        source);
 181 }
 182
 183
 184 void MacroAssembler::PushRoot(Heap::RootListIndex index) {
 185   ASSERT(root_array_available_);
 186   Push(Operand(kRootRegister, (index << kPointerSizeLog2) - kRootRegisterBias));
 187 }
 188
 189
 190 void MacroAssembler::CompareRoot(Register with, Heap::RootListIndex index) {
 191   ASSERT(root_array_available_);
 192   cmpp(with, Operand(kRootRegister,
 193                      (index << kPointerSizeLog2) - kRootRegisterBias));
 194 }
 195
 196
 197 void MacroAssembler::CompareRoot(const Operand& with,
 198                                  Heap::RootListIndex index) {
 199   ASSERT(root_array_available_);
 200   ASSERT(!with.AddressUsesRegister(kScratchRegister));
 201   LoadRoot(kScratchRegister, index);
 202   cmpp(with, kScratchRegister);
 203 }
 204
 205
 206 void MacroAssembler::RememberedSetHelper(Register object,  // For debug tests.
 207                                          Register addr,
 208                                          Register scratch,
 209                                          SaveFPRegsMode save_fp,
 210                                          RememberedSetFinalAction and_then) {
 211   if (emit_debug_code()) {
 212     Label ok;
 213     JumpIfNotInNewSpace(object, scratch, &ok, Label::kNear);
 214     int3();
 215     bind(&ok);
 216   }
 217   // Load store buffer top.
 218   LoadRoot(scratch, Heap::kStoreBufferTopRootIndex);
 219   // Store pointer to buffer.
 220   movp(Operand(scratch, 0), addr);
 221   // Increment buffer top.
 222   addp(scratch, Immediate(kPointerSize));
 223   // Write back new top of buffer.
 224   StoreRoot(scratch, Heap::kStoreBufferTopRootIndex);
 225   // Call stub on end of buffer.
 226   Label done;
 227   // Check for end of buffer.
 228   testp(scratch, Immediate(StoreBuffer::kStoreBufferOverflowBit));
 229   if (and_then == kReturnAtEnd) {
 230     Label buffer_overflowed;
 231     j(not_equal, &buffer_overflowed, Label::kNear);
 232     ret(0);
 233     bind(&buffer_overflowed);
 234   } else {
 235     ASSERT(and_then == kFallThroughAtEnd);
 236     j(equal, &done, Label::kNear);
 237   }
 238   StoreBufferOverflowStub store_buffer_overflow =
 239       StoreBufferOverflowStub(isolate(), save_fp);
 240   CallStub(&store_buffer_overflow);
 241   if (and_then == kReturnAtEnd) {
 242     ret(0);
 243   } else {
 244     ASSERT(and_then == kFallThroughAtEnd);
 245     bind(&done);
 246   }
 247 }
 248
 249
 250 void MacroAssembler::InNewSpace(Register object,
 251                                 Register scratch,
 252                                 Condition cc,
 253                                 Label* branch,
 254                                 Label::Distance distance) {
 255   if (serializer_enabled()) {
 256     // Can't do arithmetic on external references if it might get serialized.
 257     // The mask isn't really an address.  We load it as an external reference in
 258     // case the size of the new space is different between the snapshot maker
 259     // and the running system.
 260     if (scratch.is(object)) {
 261       Move(kScratchRegister, ExternalReference::new_space_mask(isolate()));
 262       andp(scratch, kScratchRegister);
 263     } else {
 264       Move(scratch, ExternalReference::new_space_mask(isolate()));
 265       andp(scratch, object);
 266     }
 267     Move(kScratchRegister, ExternalReference::new_space_start(isolate()));
 268     cmpp(scratch, kScratchRegister);
 269     j(cc, branch, distance);
 270   } else {
 271     ASSERT(kPointerSize == kInt64Size
 272         ? is_int32(static_cast<int64_t>(isolate()->heap()->NewSpaceMask()))
 273         : kPointerSize == kInt32Size);
 274     intptr_t new_space_start =
 275         reinterpret_cast<intptr_t>(isolate()->heap()->NewSpaceStart());
 276     Move(kScratchRegister, reinterpret_cast<Address>(-new_space_start),
 277          Assembler::RelocInfoNone());
 278     if (scratch.is(object)) {
 279       addp(scratch, kScratchRegister);
 280     } else {
 281       leap(scratch, Operand(object, kScratchRegister, times_1, 0));
 282     }
 283     andp(scratch,
 284          Immediate(static_cast<int32_t>(isolate()->heap()->NewSpaceMask())));
 285     j(cc, branch, distance);
 286   }
 287 }
 288
 289
 290 void MacroAssembler::RecordWriteField(
 291     Register object,
 292     int offset,
 293     Register value,
 294     Register dst,
 295     SaveFPRegsMode save_fp,
 296     RememberedSetAction remembered_set_action,
 297     SmiCheck smi_check,
 298     PointersToHereCheck pointers_to_here_check_for_value) {
 299   // First, check if a write barrier is even needed. The tests below
 300   // catch stores of Smis.
 301   Label done;
 302
 303   // Skip barrier if writing a smi.
 304   if (smi_check == INLINE_SMI_CHECK) {
 305     JumpIfSmi(value, &done);
 306   }
 307
 308   // Although the object register is tagged, the offset is relative to the start
 309   // of the object, so so offset must be a multiple of kPointerSize.
 310   ASSERT(IsAligned(offset, kPointerSize));
 311
 312   leap(dst, FieldOperand(object, offset));
 313   if (emit_debug_code()) {
 314     Label ok;
 315     testb(dst, Immediate((1 << kPointerSizeLog2) - 1));
 316     j(zero, &ok, Label::kNear);
 317     int3();
 318     bind(&ok);
 319   }
 320
 321   RecordWrite(object, dst, value, save_fp, remembered_set_action,
 322               OMIT_SMI_CHECK, pointers_to_here_check_for_value);
 323
 324   bind(&done);
 325
 326   // Clobber clobbered input registers when running with the debug-code flag
 327   // turned on to provoke errors.
 328   if (emit_debug_code()) {
 329     Move(value, kZapValue, Assembler::RelocInfoNone());
 330     Move(dst, kZapValue, Assembler::RelocInfoNone());
 331   }
 332 }
 333
 334
 335 void MacroAssembler::RecordWriteArray(
 336     Register object,
 337     Register value,
 338     Register index,
 339     SaveFPRegsMode save_fp,
 340     RememberedSetAction remembered_set_action,
 341     SmiCheck smi_check,
 342     PointersToHereCheck pointers_to_here_check_for_value) {
 343   // First, check if a write barrier is even needed. The tests below
 344   // catch stores of Smis.
 345   Label done;
 346
 347   // Skip barrier if writing a smi.
 348   if (smi_check == INLINE_SMI_CHECK) {
 349     JumpIfSmi(value, &done);
 350   }
 351
 352   // Array access: calculate the destination address. Index is not a smi.
 353   Register dst = index;
 354   leap(dst, Operand(object, index, times_pointer_size,
 355                    FixedArray::kHeaderSize - kHeapObjectTag));
 356
 357   RecordWrite(object, dst, value, save_fp, remembered_set_action,
 358               OMIT_SMI_CHECK, pointers_to_here_check_for_value);
 359
 360   bind(&done);
 361
 362   // Clobber clobbered input registers when running with the debug-code flag
 363   // turned on to provoke errors.
 364   if (emit_debug_code()) {
 365     Move(value, kZapValue, Assembler::RelocInfoNone());
 366     Move(index, kZapValue, Assembler::RelocInfoNone());
 367   }
 368 }
 369
 370
 371 void MacroAssembler::RecordWriteForMap(Register object,
 372                                        Register map,
 373                                        Register dst,
 374                                        SaveFPRegsMode fp_mode) {
 375   ASSERT(!object.is(kScratchRegister));
 376   ASSERT(!object.is(map));
 377   ASSERT(!object.is(dst));
 378   ASSERT(!map.is(dst));
 379   AssertNotSmi(object);
 380
 381   if (emit_debug_code()) {
 382     Label ok;
 383     if (map.is(kScratchRegister)) pushq(map);
 384     CompareMap(map, isolate()->factory()->meta_map());
 385     if (map.is(kScratchRegister)) popq(map);
 386     j(equal, &ok, Label::kNear);
 387     int3();
 388     bind(&ok);
 389   }
 390
 391   if (!FLAG_incremental_marking) {
 392     return;
 393   }
 394
 395   if (emit_debug_code()) {
 396     Label ok;
 397     if (map.is(kScratchRegister)) pushq(map);
 398     cmpp(map, FieldOperand(object, HeapObject::kMapOffset));
 399     if (map.is(kScratchRegister)) popq(map);
 400     j(equal, &ok, Label::kNear);
 401     int3();
 402     bind(&ok);
 403   }
 404
 405   // Compute the address.
 406   leap(dst, FieldOperand(object, HeapObject::kMapOffset));
 407
 408   // Count number of write barriers in generated code.
 409   isolate()->counters()->write_barriers_static()->Increment();
 410   IncrementCounter(isolate()->counters()->write_barriers_dynamic(), 1);
 411
 412   // First, check if a write barrier is even needed. The tests below
 413   // catch stores of smis and stores into the young generation.
 414   Label done;
 415
 416   // A single check of the map's pages interesting flag suffices, since it is
 417   // only set during incremental collection, and then it's also guaranteed that
 418   // the from object's page's interesting flag is also set.  This optimization
 419   // relies on the fact that maps can never be in new space.
 420   CheckPageFlag(map,
 421                 map,  // Used as scratch.
 422                 MemoryChunk::kPointersToHereAreInterestingMask,
 423                 zero,
 424                 &done,
 425                 Label::kNear);
 426
 427   RecordWriteStub stub(isolate(), object, map, dst, OMIT_REMEMBERED_SET,
 428                        fp_mode);
 429   CallStub(&stub);
 430
 431   bind(&done);
 432
 433   // Clobber clobbered registers when running with the debug-code flag
 434   // turned on to provoke errors.
 435   if (emit_debug_code()) {
 436     Move(dst, kZapValue, Assembler::RelocInfoNone());
 437     Move(map, kZapValue, Assembler::RelocInfoNone());
 438   }
 439 }
 440
 441
 442 void MacroAssembler::RecordWrite(
 443     Register object,
 444     Register address,
 445     Register value,
 446     SaveFPRegsMode fp_mode,
 447     RememberedSetAction remembered_set_action,
 448     SmiCheck smi_check,
 449     PointersToHereCheck pointers_to_here_check_for_value) {
 450   ASSERT(!object.is(value));
 451   ASSERT(!object.is(address));
 452   ASSERT(!value.is(address));
 453   AssertNotSmi(object);
 454
 455   if (remembered_set_action == OMIT_REMEMBERED_SET &&
 456       !FLAG_incremental_marking) {
 457     return;
 458   }
 459
 460   if (emit_debug_code()) {
 461     Label ok;
 462     cmpp(value, Operand(address, 0));
 463     j(equal, &ok, Label::kNear);
 464     int3();
 465     bind(&ok);
 466   }
 467
 468   // Count number of write barriers in generated code.
 469   isolate()->counters()->write_barriers_static()->Increment();
 470   IncrementCounter(isolate()->counters()->write_barriers_dynamic(), 1);
 471
 472   // First, check if a write barrier is even needed. The tests below
 473   // catch stores of smis and stores into the young generation.
 474   Label done;
 475
 476   if (smi_check == INLINE_SMI_CHECK) {
 477     // Skip barrier if writing a smi.
 478     JumpIfSmi(value, &done);
 479   }
 480
 481   if (pointers_to_here_check_for_value != kPointersToHereAreAlwaysInteresting) {
 482     CheckPageFlag(value,
 483                   value,  // Used as scratch.
 484                   MemoryChunk::kPointersToHereAreInterestingMask,
 485                   zero,
 486                   &done,
 487                   Label::kNear);
 488   }
 489
 490   CheckPageFlag(object,
 491                 value,  // Used as scratch.
 492                 MemoryChunk::kPointersFromHereAreInterestingMask,
 493                 zero,
 494                 &done,
 495                 Label::kNear);
 496
 497   RecordWriteStub stub(isolate(), object, value, address, remembered_set_action,
 498                        fp_mode);
 499   CallStub(&stub);
 500
 501   bind(&done);
 502
 503   // Clobber clobbered registers when running with the debug-code flag
 504   // turned on to provoke errors.
 505   if (emit_debug_code()) {
 506     Move(address, kZapValue, Assembler::RelocInfoNone());
 507     Move(value, kZapValue, Assembler::RelocInfoNone());
 508   }
 509 }
 510
 511
 512 void MacroAssembler::Assert(Condition cc, BailoutReason reason) {
 513   if (emit_debug_code()) Check(cc, reason);
 514 }
 515
 516
 517 void MacroAssembler::AssertFastElements(Register elements) {
 518   if (emit_debug_code()) {
 519     Label ok;
 520     CompareRoot(FieldOperand(elements, HeapObject::kMapOffset),
 521                 Heap::kFixedArrayMapRootIndex);
 522     j(equal, &ok, Label::kNear);
 523     CompareRoot(FieldOperand(elements, HeapObject::kMapOffset),
 524                 Heap::kFixedDoubleArrayMapRootIndex);
 525     j(equal, &ok, Label::kNear);
 526     CompareRoot(FieldOperand(elements, HeapObject::kMapOffset),
 527                 Heap::kFixedCOWArrayMapRootIndex);
 528     j(equal, &ok, Label::kNear);
 529     Abort(kJSObjectWithFastElementsMapHasSlowElements);
 530     bind(&ok);
 531   }
 532 }
 533
 534
 535 void MacroAssembler::Check(Condition cc, BailoutReason reason) {
 536   Label L;
 537   j(cc, &L, Label::kNear);
 538   Abort(reason);
 539   // Control will not return here.
 540   bind(&L);
 541 }
 542
 543
 544 void MacroAssembler::CheckStackAlignment() {
 545   int frame_alignment = OS::ActivationFrameAlignment();
 546   int frame_alignment_mask = frame_alignment - 1;
 547   if (frame_alignment > kPointerSize) {
 548     ASSERT(IsPowerOf2(frame_alignment));
 549     Label alignment_as_expected;
 550     testp(rsp, Immediate(frame_alignment_mask));
 551     j(zero, &alignment_as_expected, Label::kNear);
 552     // Abort if stack is not aligned.
 553     int3();
 554     bind(&alignment_as_expected);
 555   }
 556 }
 557
 558
 559 void MacroAssembler::NegativeZeroTest(Register result,
 560                                       Register op,
 561                                       Label* then_label) {
 562   Label ok;
 563   testl(result, result);
 564   j(not_zero, &ok, Label::kNear);
 565   testl(op, op);
 566   j(sign, then_label);
 567   bind(&ok);
 568 }
 569
 570
 571 void MacroAssembler::Abort(BailoutReason reason) {
 572 #ifdef DEBUG
 573   const char* msg = GetBailoutReason(reason);
 574   if (msg != NULL) {
 575     RecordComment("Abort message: ");
 576     RecordComment(msg);
 577   }
 578
 579   if (FLAG_trap_on_abort) {
 580     int3();
 581     return;
 582   }
 583 #endif
 584
 585   Move(kScratchRegister, Smi::FromInt(static_cast<int>(reason)),
 586        Assembler::RelocInfoNone());
 587   Push(kScratchRegister);
 588
 589   if (!has_frame_) {
 590     // We don't actually want to generate a pile of code for this, so just
 591     // claim there is a stack frame, without generating one.
 592     FrameScope scope(this, StackFrame::NONE);
 593     CallRuntime(Runtime::kAbort, 1);
 594   } else {
 595     CallRuntime(Runtime::kAbort, 1);
 596   }
 597   // Control will not return here.
 598   int3();
 599 }
 600
 601
 602 void MacroAssembler::CallStub(CodeStub* stub, TypeFeedbackId ast_id) {
 603   ASSERT(AllowThisStubCall(stub));  // Calls are not allowed in some stubs
 604   Call(stub->GetCode(), RelocInfo::CODE_TARGET, ast_id);
 605 }
 606
 607
 608 void MacroAssembler::TailCallStub(CodeStub* stub) {
 609   Jump(stub->GetCode(), RelocInfo::CODE_TARGET);
 610 }
 611
 612
 613 void MacroAssembler::StubReturn(int argc) {
 614   ASSERT(argc >= 1 && generating_stub());
 615   ret((argc - 1) * kPointerSize);
 616 }
 617
 618
 619 bool MacroAssembler::AllowThisStubCall(CodeStub* stub) {
 620   return has_frame_ || !stub->SometimesSetsUpAFrame();
 621 }
 622
 623
 624 void MacroAssembler::IndexFromHash(Register hash, Register index) {
 625   // The assert checks that the constants for the maximum number of digits
 626   // for an array index cached in the hash field and the number of bits
 627   // reserved for it does not conflict.
 628   ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) <
 629          (1 << String::kArrayIndexValueBits));
 630   if (!hash.is(index)) {
 631     movl(index, hash);
 632   }
 633   DecodeFieldToSmi<String::ArrayIndexValueBits>(index);
 634 }
 635
 636
 637 void MacroAssembler::CallRuntime(const Runtime::Function* f,
 638                                  int num_arguments,
 639                                  SaveFPRegsMode save_doubles) {
 640   // If the expected number of arguments of the runtime function is
 641   // constant, we check that the actual number of arguments match the
 642   // expectation.
 643   CHECK(f->nargs < 0 || f->nargs == num_arguments);
 644
 645   // TODO(1236192): Most runtime routines don't need the number of
 646   // arguments passed in because it is constant. At some point we
 647   // should remove this need and make the runtime routine entry code
 648   // smarter.
 649   Set(rax, num_arguments);
 650   LoadAddress(rbx, ExternalReference(f, isolate()));
 651   CEntryStub ces(isolate(), f->result_size, save_doubles);
 652   CallStub(&ces);
 653 }
 654
 655
 656 void MacroAssembler::CallExternalReference(const ExternalReference& ext,
 657                                            int num_arguments) {
 658   Set(rax, num_arguments);
 659   LoadAddress(rbx, ext);
 660
 661   CEntryStub stub(isolate(), 1);
 662   CallStub(&stub);
 663 }
 664
 665
 666 void MacroAssembler::TailCallExternalReference(const ExternalReference& ext,
 667                                                int num_arguments,
 668                                                int result_size) {
 669   // ----------- S t a t e -------------
 670   //  -- rsp[0]                 : return address
 671   //  -- rsp[8]                 : argument num_arguments - 1
 672   //  ...
 673   //  -- rsp[8 * num_arguments] : argument 0 (receiver)
 674   // -----------------------------------
 675
 676   // TODO(1236192): Most runtime routines don't need the number of
 677   // arguments passed in because it is constant. At some point we
 678   // should remove this need and make the runtime routine entry code
 679   // smarter.
 680   Set(rax, num_arguments);
 681   JumpToExternalReference(ext, result_size);
 682 }
 683
 684
 685 void MacroAssembler::TailCallRuntime(Runtime::FunctionId fid,
 686                                      int num_arguments,
 687                                      int result_size) {
 688   TailCallExternalReference(ExternalReference(fid, isolate()),
 689                             num_arguments,
 690                             result_size);
 691 }
 692
 693
 694 static int Offset(ExternalReference ref0, ExternalReference ref1) {
 695   int64_t offset = (ref0.address() - ref1.address());
 696   // Check that fits into int.
 697   ASSERT(static_cast<int>(offset) == offset);
 698   return static_cast<int>(offset);
 699 }
 700
 701
 702 void MacroAssembler::PrepareCallApiFunction(int arg_stack_space) {
 703   EnterApiExitFrame(arg_stack_space);
 704 }
 705
 706
 707 void MacroAssembler::CallApiFunctionAndReturn(
 708     Register function_address,
 709     ExternalReference thunk_ref,
 710     Register thunk_last_arg,
 711     int stack_space,
 712     Operand return_value_operand,
 713     Operand* context_restore_operand) {
 714   Label prologue;
 715   Label promote_scheduled_exception;
 716   Label exception_handled;
 717   Label delete_allocated_handles;
 718   Label leave_exit_frame;
 719   Label write_back;
 720
 721   Factory* factory = isolate()->factory();
 722   ExternalReference next_address =
 723       ExternalReference::handle_scope_next_address(isolate());
 724   const int kNextOffset = 0;
 725   const int kLimitOffset = Offset(
 726       ExternalReference::handle_scope_limit_address(isolate()),
 727       next_address);
 728   const int kLevelOffset = Offset(
 729       ExternalReference::handle_scope_level_address(isolate()),
 730       next_address);
 731   ExternalReference scheduled_exception_address =
 732       ExternalReference::scheduled_exception_address(isolate());
 733
 734   ASSERT(rdx.is(function_address) || r8.is(function_address));
 735   // Allocate HandleScope in callee-save registers.
 736   Register prev_next_address_reg = r14;
 737   Register prev_limit_reg = rbx;
 738   Register base_reg = r15;
 739   Move(base_reg, next_address);
 740   movp(prev_next_address_reg, Operand(base_reg, kNextOffset));
 741   movp(prev_limit_reg, Operand(base_reg, kLimitOffset));
 742   addl(Operand(base_reg, kLevelOffset), Immediate(1));
 743
 744   if (FLAG_log_timer_events) {
 745     FrameScope frame(this, StackFrame::MANUAL);
 746     PushSafepointRegisters();
 747     PrepareCallCFunction(1);
 748     LoadAddress(arg_reg_1, ExternalReference::isolate_address(isolate()));
 749     CallCFunction(ExternalReference::log_enter_external_function(isolate()), 1);
 750     PopSafepointRegisters();
 751   }
 752
 753
 754   Label profiler_disabled;
 755   Label end_profiler_check;
 756   Move(rax, ExternalReference::is_profiling_address(isolate()));
 757   cmpb(Operand(rax, 0), Immediate(0));
 758   j(zero, &profiler_disabled);
 759
 760   // Third parameter is the address of the actual getter function.
 761   Move(thunk_last_arg, function_address);
 762   Move(rax, thunk_ref);
 763   jmp(&end_profiler_check);
 764
 765   bind(&profiler_disabled);
 766   // Call the api function!
 767   Move(rax, function_address);
 768
 769   bind(&end_profiler_check);
 770
 771   // Call the api function!
 772   call(rax);
 773
 774   if (FLAG_log_timer_events) {
 775     FrameScope frame(this, StackFrame::MANUAL);
 776     PushSafepointRegisters();
 777     PrepareCallCFunction(1);
 778     LoadAddress(arg_reg_1, ExternalReference::isolate_address(isolate()));
 779     CallCFunction(ExternalReference::log_leave_external_function(isolate()), 1);
 780     PopSafepointRegisters();
 781   }
 782
 783   // Load the value from ReturnValue
 784   movp(rax, return_value_operand);
 785   bind(&prologue);
 786
 787   // No more valid handles (the result handle was the last one). Restore
 788   // previous handle scope.
 789   subl(Operand(base_reg, kLevelOffset), Immediate(1));
 790   movp(Operand(base_reg, kNextOffset), prev_next_address_reg);
 791   cmpp(prev_limit_reg, Operand(base_reg, kLimitOffset));
 792   j(not_equal, &delete_allocated_handles);
 793   bind(&leave_exit_frame);
 794
 795   // Check if the function scheduled an exception.
 796   Move(rsi, scheduled_exception_address);
 797   Cmp(Operand(rsi, 0), factory->the_hole_value());
 798   j(not_equal, &promote_scheduled_exception);
 799   bind(&exception_handled);
 800
 801 #if ENABLE_EXTRA_CHECKS
 802   // Check if the function returned a valid JavaScript value.
 803   Label ok;
 804   Register return_value = rax;
 805   Register map = rcx;
 806
 807   JumpIfSmi(return_value, &ok, Label::kNear);
 808   movp(map, FieldOperand(return_value, HeapObject::kMapOffset));
 809
 810   CmpInstanceType(map, FIRST_NONSTRING_TYPE);
 811   j(below, &ok, Label::kNear);
 812
 813   CmpInstanceType(map, FIRST_SPEC_OBJECT_TYPE);
 814   j(above_equal, &ok, Label::kNear);
 815
 816   CompareRoot(map, Heap::kHeapNumberMapRootIndex);
 817   j(equal, &ok, Label::kNear);
 818
 819   CompareRoot(return_value, Heap::kUndefinedValueRootIndex);
 820   j(equal, &ok, Label::kNear);
 821
 822   CompareRoot(return_value, Heap::kTrueValueRootIndex);
 823   j(equal, &ok, Label::kNear);
 824
 825   CompareRoot(return_value, Heap::kFalseValueRootIndex);
 826   j(equal, &ok, Label::kNear);
 827
 828   CompareRoot(return_value, Heap::kNullValueRootIndex);
 829   j(equal, &ok, Label::kNear);
 830
 831   Abort(kAPICallReturnedInvalidObject);
 832
 833   bind(&ok);
 834 #endif
 835
 836   bool restore_context = context_restore_operand != NULL;
 837   if (restore_context) {
 838     movp(rsi, *context_restore_operand);
 839   }
 840   LeaveApiExitFrame(!restore_context);
 841   ret(stack_space * kPointerSize);
 842
 843   bind(&promote_scheduled_exception);
 844   {
 845     FrameScope frame(this, StackFrame::INTERNAL);
 846     CallRuntime(Runtime::kHiddenPromoteScheduledException, 0);
 847   }
 848   jmp(&exception_handled);
 849
 850   // HandleScope limit has changed. Delete allocated extensions.
 851   bind(&delete_allocated_handles);
 852   movp(Operand(base_reg, kLimitOffset), prev_limit_reg);
 853   movp(prev_limit_reg, rax);
 854   LoadAddress(arg_reg_1, ExternalReference::isolate_address(isolate()));
 855   LoadAddress(rax,
 856               ExternalReference::delete_handle_scope_extensions(isolate()));
 857   call(rax);
 858   movp(rax, prev_limit_reg);
 859   jmp(&leave_exit_frame);
 860 }
 861
 862
 863 void MacroAssembler::JumpToExternalReference(const ExternalReference& ext,
 864                                              int result_size) {
 865   // Set the entry point and jump to the C entry runtime stub.
 866   LoadAddress(rbx, ext);
 867   CEntryStub ces(isolate(), result_size);
 868   jmp(ces.GetCode(), RelocInfo::CODE_TARGET);
 869 }
 870
 871
 872 void MacroAssembler::InvokeBuiltin(Builtins::JavaScript id,
 873                                    InvokeFlag flag,
 874                                    const CallWrapper& call_wrapper) {
 875   // You can't call a builtin without a valid frame.
 876   ASSERT(flag == JUMP_FUNCTION || has_frame());
 877
 878   // Rely on the assertion to check that the number of provided
 879   // arguments match the expected number of arguments. Fake a
 880   // parameter count to avoid emitting code to do the check.
 881   ParameterCount expected(0);
 882   GetBuiltinEntry(rdx, id);
 883   InvokeCode(rdx, expected, expected, flag, call_wrapper);
 884 }
 885
 886
 887 void MacroAssembler::GetBuiltinFunction(Register target,
 888                                         Builtins::JavaScript id) {
 889   // Load the builtins object into target register.
 890   movp(target, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
 891   movp(target, FieldOperand(target, GlobalObject::kBuiltinsOffset));
 892   movp(target, FieldOperand(target,
 893                             JSBuiltinsObject::OffsetOfFunctionWithId(id)));
 894 }
 895
 896
 897 void MacroAssembler::GetBuiltinEntry(Register target, Builtins::JavaScript id) {
 898   ASSERT(!target.is(rdi));
 899   // Load the JavaScript builtin function from the builtins object.
 900   GetBuiltinFunction(rdi, id);
 901   movp(target, FieldOperand(rdi, JSFunction::kCodeEntryOffset));
 902 }
 903
 904
 905 #define REG(Name) { kRegister_ ## Name ## _Code }
 906
 907 static const Register saved_regs[] = {
 908   REG(rax), REG(rcx), REG(rdx), REG(rbx), REG(rbp), REG(rsi), REG(rdi), REG(r8),
 909   REG(r9), REG(r10), REG(r11)
 910 };
 911
 912 #undef REG
 913
 914 static const int kNumberOfSavedRegs = sizeof(saved_regs) / sizeof(Register);
 915
 916
 917 void MacroAssembler::PushCallerSaved(SaveFPRegsMode fp_mode,
 918                                      Register exclusion1,
 919                                      Register exclusion2,
 920                                      Register exclusion3) {
 921   // We don't allow a GC during a store buffer overflow so there is no need to
 922   // store the registers in any particular way, but we do have to store and
 923   // restore them.
 924   for (int i = 0; i < kNumberOfSavedRegs; i++) {
 925     Register reg = saved_regs[i];
 926     if (!reg.is(exclusion1) && !reg.is(exclusion2) && !reg.is(exclusion3)) {
 927       pushq(reg);
 928     }
 929   }
 930   // R12 to r15 are callee save on all platforms.
 931   if (fp_mode == kSaveFPRegs) {
 932     subp(rsp, Immediate(kSIMD128Size * XMMRegister::kMaxNumRegisters));
 933     for (int i = 0; i < XMMRegister::kMaxNumRegisters; i++) {
 934       XMMRegister reg = XMMRegister::from_code(i);
 935       movups(Operand(rsp, i * kSIMD128Size), reg);
 936     }
 937   }
 938 }
 939
 940
 941 void MacroAssembler::PopCallerSaved(SaveFPRegsMode fp_mode,
 942                                     Register exclusion1,
 943                                     Register exclusion2,
 944                                     Register exclusion3) {
 945   if (fp_mode == kSaveFPRegs) {
 946     for (int i = 0; i < XMMRegister::kMaxNumRegisters; i++) {
 947       XMMRegister reg = XMMRegister::from_code(i);
 948       movups(reg, Operand(rsp, i * kSIMD128Size));
 949     }
 950     addp(rsp, Immediate(kSIMD128Size * XMMRegister::kMaxNumRegisters));
 951   }
 952   for (int i = kNumberOfSavedRegs - 1; i >= 0; i--) {
 953     Register reg = saved_regs[i];
 954     if (!reg.is(exclusion1) && !reg.is(exclusion2) && !reg.is(exclusion3)) {
 955       popq(reg);
 956     }
 957   }
 958 }
 959
 960
 961 void MacroAssembler::Cvtlsi2sd(XMMRegister dst, Register src) {
 962   xorps(dst, dst);
 963   cvtlsi2sd(dst, src);
 964 }
 965
 966
 967 void MacroAssembler::Cvtlsi2sd(XMMRegister dst, const Operand& src) {
 968   xorps(dst, dst);
 969   cvtlsi2sd(dst, src);
 970 }
 971
 972
 973 void MacroAssembler::Load(Register dst, const Operand& src, Representation r) {
 974   ASSERT(!r.IsDouble());
 975   if (r.IsInteger8()) {
 976     movsxbq(dst, src);
 977   } else if (r.IsUInteger8()) {
 978     movzxbl(dst, src);
 979   } else if (r.IsInteger16()) {
 980     movsxwq(dst, src);
 981   } else if (r.IsUInteger16()) {
 982     movzxwl(dst, src);
 983   } else if (r.IsInteger32()) {
 984     movl(dst, src);
 985   } else {
 986     movp(dst, src);
 987   }
 988 }
 989
 990
 991 void MacroAssembler::Store(const Operand& dst, Register src, Representation r) {
 992   ASSERT(!r.IsDouble());
 993   if (r.IsInteger8() || r.IsUInteger8()) {
 994     movb(dst, src);
 995   } else if (r.IsInteger16() || r.IsUInteger16()) {
 996     movw(dst, src);
 997   } else if (r.IsInteger32()) {
 998     movl(dst, src);
 999   } else {
1000     if (r.IsHeapObject()) {
1001       AssertNotSmi(src);
1002     } else if (r.IsSmi()) {
1003       AssertSmi(src);
1004     }
1005     movp(dst, src);
1006   }
1007 }
1008
1009
1010 void MacroAssembler::Set(Register dst, int64_t x) {
1011   if (x == 0) {
1012     xorl(dst, dst);
1013   } else if (is_uint32(x)) {
1014     movl(dst, Immediate(static_cast<uint32_t>(x)));
1015   } else if (is_int32(x)) {
1016     movq(dst, Immediate(static_cast<int32_t>(x)));
1017   } else {
1018     movq(dst, x);
1019   }
1020 }
1021
1022
1023 void MacroAssembler::Set(const Operand& dst, intptr_t x) {
1024   if (kPointerSize == kInt64Size) {
1025     if (is_int32(x)) {
1026       movp(dst, Immediate(static_cast<int32_t>(x)));
1027     } else {
1028       Set(kScratchRegister, x);
1029       movp(dst, kScratchRegister);
1030     }
1031   } else {
1032     movp(dst, Immediate(static_cast<int32_t>(x)));
1033   }
1034 }
1035
1036
1037 // ----------------------------------------------------------------------------
1038 // Smi tagging, untagging and tag detection.
1039
1040 bool MacroAssembler::IsUnsafeInt(const int32_t x) {
1041   static const int kMaxBits = 17;
1042   return !is_intn(x, kMaxBits);
1043 }
1044
1045
1046 void MacroAssembler::SafeMove(Register dst, Smi* src) {
1047   ASSERT(!dst.is(kScratchRegister));
1048   if (IsUnsafeInt(src->value()) && jit_cookie() != 0) {
1049     if (SmiValuesAre32Bits()) {
1050       // JIT cookie can be converted to Smi.
1051       Move(dst, Smi::FromInt(src->value() ^ jit_cookie()));
1052       Move(kScratchRegister, Smi::FromInt(jit_cookie()));
1053       xorp(dst, kScratchRegister);
1054     } else {
1055       ASSERT(SmiValuesAre31Bits());
1056       int32_t value = static_cast<int32_t>(reinterpret_cast<intptr_t>(src));
1057       movp(dst, Immediate(value ^ jit_cookie()));
1058       xorp(dst, Immediate(jit_cookie()));
1059     }
1060   } else {
1061     Move(dst, src);
1062   }
1063 }
1064
1065
1066 void MacroAssembler::SafePush(Smi* src) {
1067   if (IsUnsafeInt(src->value()) && jit_cookie() != 0) {
1068     if (SmiValuesAre32Bits()) {
1069       // JIT cookie can be converted to Smi.
1070       Push(Smi::FromInt(src->value() ^ jit_cookie()));
1071       Move(kScratchRegister, Smi::FromInt(jit_cookie()));
1072       xorp(Operand(rsp, 0), kScratchRegister);
1073     } else {
1074       ASSERT(SmiValuesAre31Bits());
1075       int32_t value = static_cast<int32_t>(reinterpret_cast<intptr_t>(src));
1076       Push(Immediate(value ^ jit_cookie()));
1077       xorp(Operand(rsp, 0), Immediate(jit_cookie()));
1078     }
1079   } else {
1080     Push(src);
1081   }
1082 }
1083
1084
1085 Register MacroAssembler::GetSmiConstant(Smi* source) {
1086   int value = source->value();
1087   if (value == 0) {
1088     xorl(kScratchRegister, kScratchRegister);
1089     return kScratchRegister;
1090   }
1091   if (value == 1) {
1092     return kSmiConstantRegister;
1093   }
1094   LoadSmiConstant(kScratchRegister, source);
1095   return kScratchRegister;
1096 }
1097
1098
1099 void MacroAssembler::LoadSmiConstant(Register dst, Smi* source) {
1100   if (emit_debug_code()) {
1101     Move(dst, Smi::FromInt(kSmiConstantRegisterValue),
1102          Assembler::RelocInfoNone());
1103     cmpq(dst, kSmiConstantRegister);
1104     Assert(equal, kUninitializedKSmiConstantRegister);
1105   }
1106   int value = source->value();
1107   if (value == 0) {
1108     xorl(dst, dst);
1109     return;
1110   }
1111   bool negative = value < 0;
1112   unsigned int uvalue = negative ? -value : value;
1113
1114   switch (uvalue) {
1115     case 9:
1116       leap(dst,
1117            Operand(kSmiConstantRegister, kSmiConstantRegister, times_8, 0));
1118       break;
1119     case 8:
1120       xorl(dst, dst);
1121       leap(dst, Operand(dst, kSmiConstantRegister, times_8, 0));
1122       break;
1123     case 4:
1124       xorl(dst, dst);
1125       leap(dst, Operand(dst, kSmiConstantRegister, times_4, 0));
1126       break;
1127     case 5:
1128       leap(dst,
1129            Operand(kSmiConstantRegister, kSmiConstantRegister, times_4, 0));
1130       break;
1131     case 3:
1132       leap(dst,
1133            Operand(kSmiConstantRegister, kSmiConstantRegister, times_2, 0));
1134       break;
1135     case 2:
1136       leap(dst,
1137            Operand(kSmiConstantRegister, kSmiConstantRegister, times_1, 0));
1138       break;
1139     case 1:
1140       movp(dst, kSmiConstantRegister);
1141       break;
1142     case 0:
1143       UNREACHABLE();
1144       return;
1145     default:
1146       Move(dst, source, Assembler::RelocInfoNone());
1147       return;
1148   }
1149   if (negative) {
1150     negp(dst);
1151   }
1152 }
1153
1154
1155 void MacroAssembler::Integer32ToSmi(Register dst, Register src) {
1156   STATIC_ASSERT(kSmiTag == 0);
1157   if (!dst.is(src)) {
1158     movl(dst, src);
1159   }
1160   shlp(dst, Immediate(kSmiShift));
1161 }
1162
1163
1164 void MacroAssembler::Integer32ToSmiField(const Operand& dst, Register src) {
1165   if (emit_debug_code()) {
1166     testb(dst, Immediate(0x01));
1167     Label ok;
1168     j(zero, &ok, Label::kNear);
1169     Abort(kInteger32ToSmiFieldWritingToNonSmiLocation);
1170     bind(&ok);
1171   }
1172
1173   if (SmiValuesAre32Bits()) {
1174     ASSERT(kSmiShift % kBitsPerByte == 0);
1175     movl(Operand(dst, kSmiShift / kBitsPerByte), src);
1176   } else {
1177     ASSERT(SmiValuesAre31Bits());
1178     Integer32ToSmi(kScratchRegister, src);
1179     movp(dst, kScratchRegister);
1180   }
1181 }
1182
1183
1184 void MacroAssembler::Integer64PlusConstantToSmi(Register dst,
1185                                                 Register src,
1186                                                 int constant) {
1187   if (dst.is(src)) {
1188     addl(dst, Immediate(constant));
1189   } else {
1190     leal(dst, Operand(src, constant));
1191   }
1192   shlp(dst, Immediate(kSmiShift));
1193 }
1194
1195
1196 void MacroAssembler::SmiToInteger32(Register dst, Register src) {
1197   STATIC_ASSERT(kSmiTag == 0);
1198   if (!dst.is(src)) {
1199     movp(dst, src);
1200   }
1201
1202   if (SmiValuesAre32Bits()) {
1203     shrp(dst, Immediate(kSmiShift));
1204   } else {
1205     ASSERT(SmiValuesAre31Bits());
1206     sarl(dst, Immediate(kSmiShift));
1207   }
1208 }
1209
1210
1211 void MacroAssembler::SmiToInteger32(Register dst, const Operand& src) {
1212   if (SmiValuesAre32Bits()) {
1213     movl(dst, Operand(src, kSmiShift / kBitsPerByte));
1214   } else {
1215     ASSERT(SmiValuesAre31Bits());
1216     movl(dst, src);
1217     sarl(dst, Immediate(kSmiShift));
1218   }
1219 }
1220
1221
1222 void MacroAssembler::SmiToInteger64(Register dst, Register src) {
1223   STATIC_ASSERT(kSmiTag == 0);
1224   if (!dst.is(src)) {
1225     movp(dst, src);
1226   }
1227   sarp(dst, Immediate(kSmiShift));
1228   if (kPointerSize == kInt32Size) {
1229     // Sign extend to 64-bit.
1230     movsxlq(dst, dst);
1231   }
1232 }
1233
1234
1235 void MacroAssembler::SmiToInteger64(Register dst, const Operand& src) {
1236   if (SmiValuesAre32Bits()) {
1237     movsxlq(dst, Operand(src, kSmiShift / kBitsPerByte));
1238   } else {
1239     ASSERT(SmiValuesAre31Bits());
1240     movp(dst, src);
1241     SmiToInteger64(dst, dst);
1242   }
1243 }
1244
1245
1246 void MacroAssembler::SmiTest(Register src) {
1247   AssertSmi(src);
1248   testp(src, src);
1249 }
1250
1251
1252 void MacroAssembler::SmiCompare(Register smi1, Register smi2) {
1253   AssertSmi(smi1);
1254   AssertSmi(smi2);
1255   cmpp(smi1, smi2);
1256 }
1257
1258
1259 void MacroAssembler::SmiCompare(Register dst, Smi* src) {
1260   AssertSmi(dst);
1261   Cmp(dst, src);
1262 }
1263
1264
1265 void MacroAssembler::Cmp(Register dst, Smi* src) {
1266   ASSERT(!dst.is(kScratchRegister));
1267   if (src->value() == 0) {
1268     testp(dst, dst);
1269   } else {
1270     Register constant_reg = GetSmiConstant(src);
1271     cmpp(dst, constant_reg);
1272   }
1273 }
1274
1275
1276 void MacroAssembler::SmiCompare(Register dst, const Operand& src) {
1277   AssertSmi(dst);
1278   AssertSmi(src);
1279   cmpp(dst, src);
1280 }
1281
1282
1283 void MacroAssembler::SmiCompare(const Operand& dst, Register src) {
1284   AssertSmi(dst);
1285   AssertSmi(src);
1286   cmpp(dst, src);
1287 }
1288
1289
1290 void MacroAssembler::SmiCompare(const Operand& dst, Smi* src) {
1291   AssertSmi(dst);
1292   if (SmiValuesAre32Bits()) {
1293     cmpl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(src->value()));
1294   } else {
1295     ASSERT(SmiValuesAre31Bits());
1296     cmpl(dst, Immediate(src));
1297   }
1298 }
1299
1300
1301 void MacroAssembler::Cmp(const Operand& dst, Smi* src) {
1302   // The Operand cannot use the smi register.
1303   Register smi_reg = GetSmiConstant(src);
1304   ASSERT(!dst.AddressUsesRegister(smi_reg));
1305   cmpp(dst, smi_reg);
1306 }
1307
1308
1309 void MacroAssembler::SmiCompareInteger32(const Operand& dst, Register src) {
1310   if (SmiValuesAre32Bits()) {
1311     cmpl(Operand(dst, kSmiShift / kBitsPerByte), src);
1312   } else {
1313     ASSERT(SmiValuesAre31Bits());
1314     SmiToInteger32(kScratchRegister, dst);
1315     cmpl(kScratchRegister, src);
1316   }
1317 }
1318
1319
1320 void MacroAssembler::PositiveSmiTimesPowerOfTwoToInteger64(Register dst,
1321                                                            Register src,
1322                                                            int power) {
1323   ASSERT(power >= 0);
1324   ASSERT(power < 64);
1325   if (power == 0) {
1326     SmiToInteger64(dst, src);
1327     return;
1328   }
1329   if (!dst.is(src)) {
1330     movp(dst, src);
1331   }
1332   if (power < kSmiShift) {
1333     sarp(dst, Immediate(kSmiShift - power));
1334   } else if (power > kSmiShift) {
1335     shlp(dst, Immediate(power - kSmiShift));
1336   }
1337 }
1338
1339
1340 void MacroAssembler::PositiveSmiDivPowerOfTwoToInteger32(Register dst,
1341                                                          Register src,
1342                                                          int power) {
1343   ASSERT((0 <= power) && (power < 32));
1344   if (dst.is(src)) {
1345     shrp(dst, Immediate(power + kSmiShift));
1346   } else {
1347     UNIMPLEMENTED();  // Not used.
1348   }
1349 }
1350
1351
1352 void MacroAssembler::SmiOrIfSmis(Register dst, Register src1, Register src2,
1353                                  Label* on_not_smis,
1354                                  Label::Distance near_jump) {
1355   if (dst.is(src1) || dst.is(src2)) {
1356     ASSERT(!src1.is(kScratchRegister));
1357     ASSERT(!src2.is(kScratchRegister));
1358     movp(kScratchRegister, src1);
1359     orp(kScratchRegister, src2);
1360     JumpIfNotSmi(kScratchRegister, on_not_smis, near_jump);
1361     movp(dst, kScratchRegister);
1362   } else {
1363     movp(dst, src1);
1364     orp(dst, src2);
1365     JumpIfNotSmi(dst, on_not_smis, near_jump);
1366   }
1367 }
1368
1369
1370 Condition MacroAssembler::CheckSmi(Register src) {
1371   STATIC_ASSERT(kSmiTag == 0);
1372   testb(src, Immediate(kSmiTagMask));
1373   return zero;
1374 }
1375
1376
1377 Condition MacroAssembler::CheckSmi(const Operand& src) {
1378   STATIC_ASSERT(kSmiTag == 0);
1379   testb(src, Immediate(kSmiTagMask));
1380   return zero;
1381 }
1382
1383
1384 Condition MacroAssembler::CheckNonNegativeSmi(Register src) {
1385   STATIC_ASSERT(kSmiTag == 0);
1386   // Test that both bits of the mask 0x8000000000000001 are zero.
1387   movp(kScratchRegister, src);
1388   rolp(kScratchRegister, Immediate(1));
1389   testb(kScratchRegister, Immediate(3));
1390   return zero;
1391 }
1392
1393
1394 Condition MacroAssembler::CheckBothSmi(Register first, Register second) {
1395   if (first.is(second)) {
1396     return CheckSmi(first);
1397   }
1398   STATIC_ASSERT(kSmiTag == 0 && kHeapObjectTag == 1 && kHeapObjectTagMask == 3);
1399   if (SmiValuesAre32Bits()) {
1400     leal(kScratchRegister, Operand(first, second, times_1, 0));
1401     testb(kScratchRegister, Immediate(0x03));
1402   } else {
1403     ASSERT(SmiValuesAre31Bits());
1404     movl(kScratchRegister, first);
1405     orl(kScratchRegister, second);
1406     testb(kScratchRegister, Immediate(kSmiTagMask));
1407   }
1408   return zero;
1409 }
1410
1411
1412 Condition MacroAssembler::CheckBothNonNegativeSmi(Register first,
1413                                                   Register second) {
1414   if (first.is(second)) {
1415     return CheckNonNegativeSmi(first);
1416   }
1417   movp(kScratchRegister, first);
1418   orp(kScratchRegister, second);
1419   rolp(kScratchRegister, Immediate(1));
1420   testl(kScratchRegister, Immediate(3));
1421   return zero;
1422 }
1423
1424
1425 Condition MacroAssembler::CheckEitherSmi(Register first,
1426                                          Register second,
1427                                          Register scratch) {
1428   if (first.is(second)) {
1429     return CheckSmi(first);
1430   }
1431   if (scratch.is(second)) {
1432     andl(scratch, first);
1433   } else {
1434     if (!scratch.is(first)) {
1435       movl(scratch, first);
1436     }
1437     andl(scratch, second);
1438   }
1439   testb(scratch, Immediate(kSmiTagMask));
1440   return zero;
1441 }
1442
1443
1444 Condition MacroAssembler::CheckIsMinSmi(Register src) {
1445   ASSERT(!src.is(kScratchRegister));
1446   // If we overflow by subtracting one, it's the minimal smi value.
1447   cmpp(src, kSmiConstantRegister);
1448   return overflow;
1449 }
1450
1451
1452 Condition MacroAssembler::CheckInteger32ValidSmiValue(Register src) {
1453   if (SmiValuesAre32Bits()) {
1454     // A 32-bit integer value can always be converted to a smi.
1455     return always;
1456   } else {
1457     ASSERT(SmiValuesAre31Bits());
1458     cmpl(src, Immediate(0xc0000000));
1459     return positive;
1460   }
1461 }
1462
1463
1464 Condition MacroAssembler::CheckUInteger32ValidSmiValue(Register src) {
1465   if (SmiValuesAre32Bits()) {
1466     // An unsigned 32-bit integer value is valid as long as the high bit
1467     // is not set.
1468     testl(src, src);
1469     return positive;
1470   } else {
1471     ASSERT(SmiValuesAre31Bits());
1472     testl(src, Immediate(0xc0000000));
1473     return zero;
1474   }
1475 }
1476
1477
1478 void MacroAssembler::CheckSmiToIndicator(Register dst, Register src) {
1479   if (dst.is(src)) {
1480     andl(dst, Immediate(kSmiTagMask));
1481   } else {
1482     movl(dst, Immediate(kSmiTagMask));
1483     andl(dst, src);
1484   }
1485 }
1486
1487
1488 void MacroAssembler::CheckSmiToIndicator(Register dst, const Operand& src) {
1489   if (!(src.AddressUsesRegister(dst))) {
1490     movl(dst, Immediate(kSmiTagMask));
1491     andl(dst, src);
1492   } else {
1493     movl(dst, src);
1494     andl(dst, Immediate(kSmiTagMask));
1495   }
1496 }
1497
1498
1499 void MacroAssembler::JumpIfValidSmiValue(Register src,
1500                                          Label* on_valid,
1501                                          Label::Distance near_jump) {
1502   Condition is_valid = CheckInteger32ValidSmiValue(src);
1503   j(is_valid, on_valid, near_jump);
1504 }
1505
1506
1507 void MacroAssembler::JumpIfNotValidSmiValue(Register src,
1508                                             Label* on_invalid,
1509                                             Label::Distance near_jump) {
1510   Condition is_valid = CheckInteger32ValidSmiValue(src);
1511   j(NegateCondition(is_valid), on_invalid, near_jump);
1512 }
1513
1514
1515 void MacroAssembler::JumpIfUIntValidSmiValue(Register src,
1516                                              Label* on_valid,
1517                                              Label::Distance near_jump) {
1518   Condition is_valid = CheckUInteger32ValidSmiValue(src);
1519   j(is_valid, on_valid, near_jump);
1520 }
1521
1522
1523 void MacroAssembler::JumpIfUIntNotValidSmiValue(Register src,
1524                                                 Label* on_invalid,
1525                                                 Label::Distance near_jump) {
1526   Condition is_valid = CheckUInteger32ValidSmiValue(src);
1527   j(NegateCondition(is_valid), on_invalid, near_jump);
1528 }
1529
1530
1531 void MacroAssembler::JumpIfSmi(Register src,
1532                                Label* on_smi,
1533                                Label::Distance near_jump) {
1534   Condition smi = CheckSmi(src);
1535   j(smi, on_smi, near_jump);
1536 }
1537
1538
1539 void MacroAssembler::JumpIfNotSmi(Register src,
1540                                   Label* on_not_smi,
1541                                   Label::Distance near_jump) {
1542   Condition smi = CheckSmi(src);
1543   j(NegateCondition(smi), on_not_smi, near_jump);
1544 }
1545
1546
1547 void MacroAssembler::JumpUnlessNonNegativeSmi(
1548     Register src, Label* on_not_smi_or_negative,
1549     Label::Distance near_jump) {
1550   Condition non_negative_smi = CheckNonNegativeSmi(src);
1551   j(NegateCondition(non_negative_smi), on_not_smi_or_negative, near_jump);
1552 }
1553
1554
1555 void MacroAssembler::JumpIfSmiEqualsConstant(Register src,
1556                                              Smi* constant,
1557                                              Label* on_equals,
1558                                              Label::Distance near_jump) {
1559   SmiCompare(src, constant);
1560   j(equal, on_equals, near_jump);
1561 }
1562
1563
1564 void MacroAssembler::JumpIfNotBothSmi(Register src1,
1565                                       Register src2,
1566                                       Label* on_not_both_smi,
1567                                       Label::Distance near_jump) {
1568   Condition both_smi = CheckBothSmi(src1, src2);
1569   j(NegateCondition(both_smi), on_not_both_smi, near_jump);
1570 }
1571
1572
1573 void MacroAssembler::JumpUnlessBothNonNegativeSmi(Register src1,
1574                                                   Register src2,
1575                                                   Label* on_not_both_smi,
1576                                                   Label::Distance near_jump) {
1577   Condition both_smi = CheckBothNonNegativeSmi(src1, src2);
1578   j(NegateCondition(both_smi), on_not_both_smi, near_jump);
1579 }
1580
1581
1582 void MacroAssembler::SmiAddConstant(Register dst, Register src, Smi* constant) {
1583   if (constant->value() == 0) {
1584     if (!dst.is(src)) {
1585       movp(dst, src);
1586     }
1587     return;
1588   } else if (dst.is(src)) {
1589     ASSERT(!dst.is(kScratchRegister));
1590     switch (constant->value()) {
1591       case 1:
1592         addp(dst, kSmiConstantRegister);
1593         return;
1594       case 2:
1595         leap(dst, Operand(src, kSmiConstantRegister, times_2, 0));
1596         return;
1597       case 4:
1598         leap(dst, Operand(src, kSmiConstantRegister, times_4, 0));
1599         return;
1600       case 8:
1601         leap(dst, Operand(src, kSmiConstantRegister, times_8, 0));
1602         return;
1603       default:
1604         Register constant_reg = GetSmiConstant(constant);
1605         addp(dst, constant_reg);
1606         return;
1607     }
1608   } else {
1609     switch (constant->value()) {
1610       case 1:
1611         leap(dst, Operand(src, kSmiConstantRegister, times_1, 0));
1612         return;
1613       case 2:
1614         leap(dst, Operand(src, kSmiConstantRegister, times_2, 0));
1615         return;
1616       case 4:
1617         leap(dst, Operand(src, kSmiConstantRegister, times_4, 0));
1618         return;
1619       case 8:
1620         leap(dst, Operand(src, kSmiConstantRegister, times_8, 0));
1621         return;
1622       default:
1623         LoadSmiConstant(dst, constant);
1624         addp(dst, src);
1625         return;
1626     }
1627   }
1628 }
1629
1630
1631 void MacroAssembler::SmiAddConstant(const Operand& dst, Smi* constant) {
1632   if (constant->value() != 0) {
1633     if (SmiValuesAre32Bits()) {
1634       addl(Operand(dst, kSmiShift / kBitsPerByte),
1635            Immediate(constant->value()));
1636     } else {
1637       ASSERT(SmiValuesAre31Bits());
1638       addp(dst, Immediate(constant));
1639     }
1640   }
1641 }
1642
1643
1644 void MacroAssembler::SmiAddConstant(Register dst,
1645                                     Register src,
1646                                     Smi* constant,
1647                                     SmiOperationExecutionMode mode,
1648                                     Label* bailout_label,
1649                                     Label::Distance near_jump) {
1650   if (constant->value() == 0) {
1651     if (!dst.is(src)) {
1652       movp(dst, src);
1653     }
1654   } else if (dst.is(src)) {
1655     ASSERT(!dst.is(kScratchRegister));
1656     LoadSmiConstant(kScratchRegister, constant);
1657     addp(dst, kScratchRegister);
1658     if (mode.Contains(BAILOUT_ON_NO_OVERFLOW)) {
1659       j(no_overflow, bailout_label, near_jump);
1660       ASSERT(mode.Contains(PRESERVE_SOURCE_REGISTER));
1661       subp(dst, kScratchRegister);
1662     } else if (mode.Contains(BAILOUT_ON_OVERFLOW)) {
1663       if (mode.Contains(PRESERVE_SOURCE_REGISTER)) {
1664         Label done;
1665         j(no_overflow, &done, Label::kNear);
1666         subp(dst, kScratchRegister);
1667         jmp(bailout_label, near_jump);
1668         bind(&done);
1669       } else {
1670         // Bailout if overflow without reserving src.
1671         j(overflow, bailout_label, near_jump);
1672       }
1673     } else {
1674       CHECK(mode.IsEmpty());
1675     }
1676   } else {
1677     ASSERT(mode.Contains(PRESERVE_SOURCE_REGISTER));
1678     ASSERT(mode.Contains(BAILOUT_ON_OVERFLOW));
1679     LoadSmiConstant(dst, constant);
1680     addp(dst, src);
1681     j(overflow, bailout_label, near_jump);
1682   }
1683 }
1684
1685
1686 void MacroAssembler::SmiSubConstant(Register dst, Register src, Smi* constant) {
1687   if (constant->value() == 0) {
1688     if (!dst.is(src)) {
1689       movp(dst, src);
1690     }
1691   } else if (dst.is(src)) {
1692     ASSERT(!dst.is(kScratchRegister));
1693     Register constant_reg = GetSmiConstant(constant);
1694     subp(dst, constant_reg);
1695   } else {
1696     if (constant->value() == Smi::kMinValue) {
1697       LoadSmiConstant(dst, constant);
1698       // Adding and subtracting the min-value gives the same result, it only
1699       // differs on the overflow bit, which we don't check here.
1700       addp(dst, src);
1701     } else {
1702       // Subtract by adding the negation.
1703       LoadSmiConstant(dst, Smi::FromInt(-constant->value()));
1704       addp(dst, src);
1705     }
1706   }
1707 }
1708
1709
1710 void MacroAssembler::SmiSubConstant(Register dst,
1711                                     Register src,
1712                                     Smi* constant,
1713                                     SmiOperationExecutionMode mode,
1714                                     Label* bailout_label,
1715                                     Label::Distance near_jump) {
1716   if (constant->value() == 0) {
1717     if (!dst.is(src)) {
1718       movp(dst, src);
1719     }
1720   } else if (dst.is(src)) {
1721     ASSERT(!dst.is(kScratchRegister));
1722     LoadSmiConstant(kScratchRegister, constant);
1723     subp(dst, kScratchRegister);
1724     if (mode.Contains(BAILOUT_ON_NO_OVERFLOW)) {
1725       j(no_overflow, bailout_label, near_jump);
1726       ASSERT(mode.Contains(PRESERVE_SOURCE_REGISTER));
1727       addp(dst, kScratchRegister);
1728     } else if (mode.Contains(BAILOUT_ON_OVERFLOW)) {
1729       if (mode.Contains(PRESERVE_SOURCE_REGISTER)) {
1730         Label done;
1731         j(no_overflow, &done, Label::kNear);
1732         addp(dst, kScratchRegister);
1733         jmp(bailout_label, near_jump);
1734         bind(&done);
1735       } else {
1736         // Bailout if overflow without reserving src.
1737         j(overflow, bailout_label, near_jump);
1738       }
1739     } else {
1740       CHECK(mode.IsEmpty());
1741     }
1742   } else {
1743     ASSERT(mode.Contains(PRESERVE_SOURCE_REGISTER));
1744     ASSERT(mode.Contains(BAILOUT_ON_OVERFLOW));
1745     if (constant->value() == Smi::kMinValue) {
1746       ASSERT(!dst.is(kScratchRegister));
1747       movp(dst, src);
1748       LoadSmiConstant(kScratchRegister, constant);
1749       subp(dst, kScratchRegister);
1750       j(overflow, bailout_label, near_jump);
1751     } else {
1752       // Subtract by adding the negation.
1753       LoadSmiConstant(dst, Smi::FromInt(-(constant->value())));
1754       addp(dst, src);
1755       j(overflow, bailout_label, near_jump);
1756     }
1757   }
1758 }
1759
1760
1761 void MacroAssembler::SmiNeg(Register dst,
1762                             Register src,
1763                             Label* on_smi_result,
1764                             Label::Distance near_jump) {
1765   if (dst.is(src)) {
1766     ASSERT(!dst.is(kScratchRegister));
1767     movp(kScratchRegister, src);
1768     negp(dst);  // Low 32 bits are retained as zero by negation.
1769     // Test if result is zero or Smi::kMinValue.
1770     cmpp(dst, kScratchRegister);
1771     j(not_equal, on_smi_result, near_jump);
1772     movp(src, kScratchRegister);
1773   } else {
1774     movp(dst, src);
1775     negp(dst);
1776     cmpp(dst, src);
1777     // If the result is zero or Smi::kMinValue, negation failed to create a smi.
1778     j(not_equal, on_smi_result, near_jump);
1779   }
1780 }
1781
1782
1783 template<class T>
1784 static void SmiAddHelper(MacroAssembler* masm,
1785                          Register dst,
1786                          Register src1,
1787                          T src2,
1788                          Label* on_not_smi_result,
1789                          Label::Distance near_jump) {
1790   if (dst.is(src1)) {
1791     Label done;
1792     masm->addp(dst, src2);
1793     masm->j(no_overflow, &done, Label::kNear);
1794     // Restore src1.
1795     masm->subp(dst, src2);
1796     masm->jmp(on_not_smi_result, near_jump);
1797     masm->bind(&done);
1798   } else {
1799     masm->movp(dst, src1);
1800     masm->addp(dst, src2);
1801     masm->j(overflow, on_not_smi_result, near_jump);
1802   }
1803 }
1804
1805
1806 void MacroAssembler::SmiAdd(Register dst,
1807                             Register src1,
1808                             Register src2,
1809                             Label* on_not_smi_result,
1810                             Label::Distance near_jump) {
1811   ASSERT_NOT_NULL(on_not_smi_result);
1812   ASSERT(!dst.is(src2));
1813   SmiAddHelper<Register>(this, dst, src1, src2, on_not_smi_result, near_jump);
1814 }
1815
1816
1817 void MacroAssembler::SmiAdd(Register dst,
1818                             Register src1,
1819                             const Operand& src2,
1820                             Label* on_not_smi_result,
1821                             Label::Distance near_jump) {
1822   ASSERT_NOT_NULL(on_not_smi_result);
1823   ASSERT(!src2.AddressUsesRegister(dst));
1824   SmiAddHelper<Operand>(this, dst, src1, src2, on_not_smi_result, near_jump);
1825 }
1826
1827
1828 void MacroAssembler::SmiAdd(Register dst,
1829                             Register src1,
1830                             Register src2) {
1831   // No overflow checking. Use only when it's known that
1832   // overflowing is impossible.
1833   if (!dst.is(src1)) {
1834     if (emit_debug_code()) {
1835       movp(kScratchRegister, src1);
1836       addp(kScratchRegister, src2);
1837       Check(no_overflow, kSmiAdditionOverflow);
1838     }
1839     leap(dst, Operand(src1, src2, times_1, 0));
1840   } else {
1841     addp(dst, src2);
1842     Assert(no_overflow, kSmiAdditionOverflow);
1843   }
1844 }
1845
1846
1847 template<class T>
1848 static void SmiSubHelper(MacroAssembler* masm,
1849                          Register dst,
1850                          Register src1,
1851                          T src2,
1852                          Label* on_not_smi_result,
1853                          Label::Distance near_jump) {
1854   if (dst.is(src1)) {
1855     Label done;
1856     masm->subp(dst, src2);
1857     masm->j(no_overflow, &done, Label::kNear);
1858     // Restore src1.
1859     masm->addp(dst, src2);
1860     masm->jmp(on_not_smi_result, near_jump);
1861     masm->bind(&done);
1862   } else {
1863     masm->movp(dst, src1);
1864     masm->subp(dst, src2);
1865     masm->j(overflow, on_not_smi_result, near_jump);
1866   }
1867 }
1868
1869
1870 void MacroAssembler::SmiSub(Register dst,
1871                             Register src1,
1872                             Register src2,
1873                             Label* on_not_smi_result,
1874                             Label::Distance near_jump) {
1875   ASSERT_NOT_NULL(on_not_smi_result);
1876   ASSERT(!dst.is(src2));
1877   SmiSubHelper<Register>(this, dst, src1, src2, on_not_smi_result, near_jump);
1878 }
1879
1880
1881 void MacroAssembler::SmiSub(Register dst,
1882                             Register src1,
1883                             const Operand& src2,
1884                             Label* on_not_smi_result,
1885                             Label::Distance near_jump) {
1886   ASSERT_NOT_NULL(on_not_smi_result);
1887   ASSERT(!src2.AddressUsesRegister(dst));
1888   SmiSubHelper<Operand>(this, dst, src1, src2, on_not_smi_result, near_jump);
1889 }
1890
1891
1892 template<class T>
1893 static void SmiSubNoOverflowHelper(MacroAssembler* masm,
1894                                    Register dst,
1895                                    Register src1,
1896                                    T src2) {
1897   // No overflow checking. Use only when it's known that
1898   // overflowing is impossible (e.g., subtracting two positive smis).
1899   if (!dst.is(src1)) {
1900     masm->movp(dst, src1);
1901   }
1902   masm->subp(dst, src2);
1903   masm->Assert(no_overflow, kSmiSubtractionOverflow);
1904 }
1905
1906
1907 void MacroAssembler::SmiSub(Register dst, Register src1, Register src2) {
1908   ASSERT(!dst.is(src2));
1909   SmiSubNoOverflowHelper<Register>(this, dst, src1, src2);
1910 }
1911
1912
1913 void MacroAssembler::SmiSub(Register dst,
1914                             Register src1,
1915                             const Operand& src2) {
1916   SmiSubNoOverflowHelper<Operand>(this, dst, src1, src2);
1917 }
1918
1919
1920 void MacroAssembler::SmiMul(Register dst,
1921                             Register src1,
1922                             Register src2,
1923                             Label* on_not_smi_result,
1924                             Label::Distance near_jump) {
1925   ASSERT(!dst.is(src2));
1926   ASSERT(!dst.is(kScratchRegister));
1927   ASSERT(!src1.is(kScratchRegister));
1928   ASSERT(!src2.is(kScratchRegister));
1929
1930   if (dst.is(src1)) {
1931     Label failure, zero_correct_result;
1932     movp(kScratchRegister, src1);  // Create backup for later testing.
1933     SmiToInteger64(dst, src1);
1934     imulp(dst, src2);
1935     j(overflow, &failure, Label::kNear);
1936
1937     // Check for negative zero result.  If product is zero, and one
1938     // argument is negative, go to slow case.
1939     Label correct_result;
1940     testp(dst, dst);
1941     j(not_zero, &correct_result, Label::kNear);
1942
1943     movp(dst, kScratchRegister);
1944     xorp(dst, src2);
1945     // Result was positive zero.
1946     j(positive, &zero_correct_result, Label::kNear);
1947
1948     bind(&failure);  // Reused failure exit, restores src1.
1949     movp(src1, kScratchRegister);
1950     jmp(on_not_smi_result, near_jump);
1951
1952     bind(&zero_correct_result);
1953     Set(dst, 0);
1954
1955     bind(&correct_result);
1956   } else {
1957     SmiToInteger64(dst, src1);
1958     imulp(dst, src2);
1959     j(overflow, on_not_smi_result, near_jump);
1960     // Check for negative zero result.  If product is zero, and one
1961     // argument is negative, go to slow case.
1962     Label correct_result;
1963     testp(dst, dst);
1964     j(not_zero, &correct_result, Label::kNear);
1965     // One of src1 and src2 is zero, the check whether the other is
1966     // negative.
1967     movp(kScratchRegister, src1);
1968     xorp(kScratchRegister, src2);
1969     j(negative, on_not_smi_result, near_jump);
1970     bind(&correct_result);
1971   }
1972 }
1973
1974
1975 void MacroAssembler::SmiDiv(Register dst,
1976                             Register src1,
1977                             Register src2,
1978                             Label* on_not_smi_result,
1979                             Label::Distance near_jump) {
1980   ASSERT(!src1.is(kScratchRegister));
1981   ASSERT(!src2.is(kScratchRegister));
1982   ASSERT(!dst.is(kScratchRegister));
1983   ASSERT(!src2.is(rax));
1984   ASSERT(!src2.is(rdx));
1985   ASSERT(!src1.is(rdx));
1986
1987   // Check for 0 divisor (result is +/-Infinity).
1988   testp(src2, src2);
1989   j(zero, on_not_smi_result, near_jump);
1990
1991   if (src1.is(rax)) {
1992     movp(kScratchRegister, src1);
1993   }
1994   SmiToInteger32(rax, src1);
1995   // We need to rule out dividing Smi::kMinValue by -1, since that would
1996   // overflow in idiv and raise an exception.
1997   // We combine this with negative zero test (negative zero only happens
1998   // when dividing zero by a negative number).
1999
2000   // We overshoot a little and go to slow case if we divide min-value
2001   // by any negative value, not just -1.
2002   Label safe_div;
2003   testl(rax, Immediate(~Smi::kMinValue));
2004   j(not_zero, &safe_div, Label::kNear);
2005   testp(src2, src2);
2006   if (src1.is(rax)) {
2007     j(positive, &safe_div, Label::kNear);
2008     movp(src1, kScratchRegister);
2009     jmp(on_not_smi_result, near_jump);
2010   } else {
2011     j(negative, on_not_smi_result, near_jump);
2012   }
2013   bind(&safe_div);
2014
2015   SmiToInteger32(src2, src2);
2016   // Sign extend src1 into edx:eax.
2017   cdq();
2018   idivl(src2);
2019   Integer32ToSmi(src2, src2);
2020   // Check that the remainder is zero.
2021   testl(rdx, rdx);
2022   if (src1.is(rax)) {
2023     Label smi_result;
2024     j(zero, &smi_result, Label::kNear);
2025     movp(src1, kScratchRegister);
2026     jmp(on_not_smi_result, near_jump);
2027     bind(&smi_result);
2028   } else {
2029     j(not_zero, on_not_smi_result, near_jump);
2030   }
2031   if (!dst.is(src1) && src1.is(rax)) {
2032     movp(src1, kScratchRegister);
2033   }
2034   Integer32ToSmi(dst, rax);
2035 }
2036
2037
2038 void MacroAssembler::SmiMod(Register dst,
2039                             Register src1,
2040                             Register src2,
2041                             Label* on_not_smi_result,
2042                             Label::Distance near_jump) {
2043   ASSERT(!dst.is(kScratchRegister));
2044   ASSERT(!src1.is(kScratchRegister));
2045   ASSERT(!src2.is(kScratchRegister));
2046   ASSERT(!src2.is(rax));
2047   ASSERT(!src2.is(rdx));
2048   ASSERT(!src1.is(rdx));
2049   ASSERT(!src1.is(src2));
2050
2051   testp(src2, src2);
2052   j(zero, on_not_smi_result, near_jump);
2053
2054   if (src1.is(rax)) {
2055     movp(kScratchRegister, src1);
2056   }
2057   SmiToInteger32(rax, src1);
2058   SmiToInteger32(src2, src2);
2059
2060   // Test for the edge case of dividing Smi::kMinValue by -1 (will overflow).
2061   Label safe_div;
2062   cmpl(rax, Immediate(Smi::kMinValue));
2063   j(not_equal, &safe_div, Label::kNear);
2064   cmpl(src2, Immediate(-1));
2065   j(not_equal, &safe_div, Label::kNear);
2066   // Retag inputs and go slow case.
2067   Integer32ToSmi(src2, src2);
2068   if (src1.is(rax)) {
2069     movp(src1, kScratchRegister);
2070   }
2071   jmp(on_not_smi_result, near_jump);
2072   bind(&safe_div);
2073
2074   // Sign extend eax into edx:eax.
2075   cdq();
2076   idivl(src2);
2077   // Restore smi tags on inputs.
2078   Integer32ToSmi(src2, src2);
2079   if (src1.is(rax)) {
2080     movp(src1, kScratchRegister);
2081   }
2082   // Check for a negative zero result.  If the result is zero, and the
2083   // dividend is negative, go slow to return a floating point negative zero.
2084   Label smi_result;
2085   testl(rdx, rdx);
2086   j(not_zero, &smi_result, Label::kNear);
2087   testp(src1, src1);
2088   j(negative, on_not_smi_result, near_jump);
2089   bind(&smi_result);
2090   Integer32ToSmi(dst, rdx);
2091 }
2092
2093
2094 void MacroAssembler::SmiNot(Register dst, Register src) {
2095   ASSERT(!dst.is(kScratchRegister));
2096   ASSERT(!src.is(kScratchRegister));
2097   if (SmiValuesAre32Bits()) {
2098     // Set tag and padding bits before negating, so that they are zero
2099     // afterwards.
2100     movl(kScratchRegister, Immediate(~0));
2101   } else {
2102     ASSERT(SmiValuesAre31Bits());
2103     movl(kScratchRegister, Immediate(1));
2104   }
2105   if (dst.is(src)) {
2106     xorp(dst, kScratchRegister);
2107   } else {
2108     leap(dst, Operand(src, kScratchRegister, times_1, 0));
2109   }
2110   notp(dst);
2111 }
2112
2113
2114 void MacroAssembler::SmiAnd(Register dst, Register src1, Register src2) {
2115   ASSERT(!dst.is(src2));
2116   if (!dst.is(src1)) {
2117     movp(dst, src1);
2118   }
2119   andp(dst, src2);
2120 }
2121
2122
2123 void MacroAssembler::SmiAndConstant(Register dst, Register src, Smi* constant) {
2124   if (constant->value() == 0) {
2125     Set(dst, 0);
2126   } else if (dst.is(src)) {
2127     ASSERT(!dst.is(kScratchRegister));
2128     Register constant_reg = GetSmiConstant(constant);
2129     andp(dst, constant_reg);
2130   } else {
2131     LoadSmiConstant(dst, constant);
2132     andp(dst, src);
2133   }
2134 }
2135
2136
2137 void MacroAssembler::SmiOr(Register dst, Register src1, Register src2) {
2138   if (!dst.is(src1)) {
2139     ASSERT(!src1.is(src2));
2140     movp(dst, src1);
2141   }
2142   orp(dst, src2);
2143 }
2144
2145
2146 void MacroAssembler::SmiOrConstant(Register dst, Register src, Smi* constant) {
2147   if (dst.is(src)) {
2148     ASSERT(!dst.is(kScratchRegister));
2149     Register constant_reg = GetSmiConstant(constant);
2150     orp(dst, constant_reg);
2151   } else {
2152     LoadSmiConstant(dst, constant);
2153     orp(dst, src);
2154   }
2155 }
2156
2157
2158 void MacroAssembler::SmiXor(Register dst, Register src1, Register src2) {
2159   if (!dst.is(src1)) {
2160     ASSERT(!src1.is(src2));
2161     movp(dst, src1);
2162   }
2163   xorp(dst, src2);
2164 }
2165
2166
2167 void MacroAssembler::SmiXorConstant(Register dst, Register src, Smi* constant) {
2168   if (dst.is(src)) {
2169     ASSERT(!dst.is(kScratchRegister));
2170     Register constant_reg = GetSmiConstant(constant);
2171     xorp(dst, constant_reg);
2172   } else {
2173     LoadSmiConstant(dst, constant);
2174     xorp(dst, src);
2175   }
2176 }
2177
2178
2179 void MacroAssembler::SmiShiftArithmeticRightConstant(Register dst,
2180                                                      Register src,
2181                                                      int shift_value) {
2182   ASSERT(is_uint5(shift_value));
2183   if (shift_value > 0) {
2184     if (dst.is(src)) {
2185       sarp(dst, Immediate(shift_value + kSmiShift));
2186       shlp(dst, Immediate(kSmiShift));
2187     } else {
2188       UNIMPLEMENTED();  // Not used.
2189     }
2190   }
2191 }
2192
2193
2194 void MacroAssembler::SmiShiftLeftConstant(Register dst,
2195                                           Register src,
2196                                           int shift_value,
2197                                           Label* on_not_smi_result,
2198                                           Label::Distance near_jump) {
2199   if (SmiValuesAre32Bits()) {
2200     if (!dst.is(src)) {
2201       movp(dst, src);
2202     }
2203     if (shift_value > 0) {
2204       // Shift amount specified by lower 5 bits, not six as the shl opcode.
2205       shlq(dst, Immediate(shift_value & 0x1f));
2206     }
2207   } else {
2208     ASSERT(SmiValuesAre31Bits());
2209     if (dst.is(src)) {
2210       UNIMPLEMENTED();  // Not used.
2211     } else {
2212       SmiToInteger32(dst, src);
2213       shll(dst, Immediate(shift_value));
2214       JumpIfNotValidSmiValue(dst, on_not_smi_result, near_jump);
2215       Integer32ToSmi(dst, dst);
2216     }
2217   }
2218 }
2219
2220
2221 void MacroAssembler::SmiShiftLogicalRightConstant(
2222     Register dst, Register src, int shift_value,
2223     Label* on_not_smi_result, Label::Distance near_jump) {
2224   // Logic right shift interprets its result as an *unsigned* number.
2225   if (dst.is(src)) {
2226     UNIMPLEMENTED();  // Not used.
2227   } else {
2228     if (shift_value == 0) {
2229       testp(src, src);
2230       j(negative, on_not_smi_result, near_jump);
2231     }
2232     if (SmiValuesAre32Bits()) {
2233       movp(dst, src);
2234       shrp(dst, Immediate(shift_value + kSmiShift));
2235       shlp(dst, Immediate(kSmiShift));
2236     } else {
2237       ASSERT(SmiValuesAre31Bits());
2238       SmiToInteger32(dst, src);
2239       shrp(dst, Immediate(shift_value));
2240       JumpIfUIntNotValidSmiValue(dst, on_not_smi_result, near_jump);
2241       Integer32ToSmi(dst, dst);
2242     }
2243   }
2244 }
2245
2246
2247 void MacroAssembler::SmiShiftLeft(Register dst,
2248                                   Register src1,
2249                                   Register src2,
2250                                   Label* on_not_smi_result,
2251                                   Label::Distance near_jump) {
2252   if (SmiValuesAre32Bits()) {
2253     ASSERT(!dst.is(rcx));
2254     if (!dst.is(src1)) {
2255       movp(dst, src1);
2256     }
2257     // Untag shift amount.
2258     SmiToInteger32(rcx, src2);
2259     // Shift amount specified by lower 5 bits, not six as the shl opcode.
2260     andp(rcx, Immediate(0x1f));
2261     shlq_cl(dst);
2262   } else {
2263     ASSERT(SmiValuesAre31Bits());
2264     ASSERT(!dst.is(kScratchRegister));
2265     ASSERT(!src1.is(kScratchRegister));
2266     ASSERT(!src2.is(kScratchRegister));
2267     ASSERT(!dst.is(src2));
2268     ASSERT(!dst.is(rcx));
2269
2270     if (src1.is(rcx) || src2.is(rcx)) {
2271       movq(kScratchRegister, rcx);
2272     }
2273     if (dst.is(src1)) {
2274       UNIMPLEMENTED();  // Not used.
2275     } else {
2276       Label valid_result;
2277       SmiToInteger32(dst, src1);
2278       SmiToInteger32(rcx, src2);
2279       shll_cl(dst);
2280       JumpIfValidSmiValue(dst, &valid_result, Label::kNear);
2281       // As src1 or src2 could not be dst, we do not need to restore them for
2282       // clobbering dst.
2283       if (src1.is(rcx) || src2.is(rcx)) {
2284         if (src1.is(rcx)) {
2285           movq(src1, kScratchRegister);
2286         } else {
2287           movq(src2, kScratchRegister);
2288         }
2289       }
2290       jmp(on_not_smi_result, near_jump);
2291       bind(&valid_result);
2292       Integer32ToSmi(dst, dst);
2293     }
2294   }
2295 }
2296
2297
2298 void MacroAssembler::SmiShiftLogicalRight(Register dst,
2299                                           Register src1,
2300                                           Register src2,
2301                                           Label* on_not_smi_result,
2302                                           Label::Distance near_jump) {
2303   ASSERT(!dst.is(kScratchRegister));
2304   ASSERT(!src1.is(kScratchRegister));
2305   ASSERT(!src2.is(kScratchRegister));
2306   ASSERT(!dst.is(src2));
2307   ASSERT(!dst.is(rcx));
2308   if (src1.is(rcx) || src2.is(rcx)) {
2309     movq(kScratchRegister, rcx);
2310   }
2311   if (dst.is(src1)) {
2312     UNIMPLEMENTED();  // Not used.
2313   } else {
2314     Label valid_result;
2315     SmiToInteger32(dst, src1);
2316     SmiToInteger32(rcx, src2);
2317     shrl_cl(dst);
2318     JumpIfUIntValidSmiValue(dst, &valid_result, Label::kNear);
2319     // As src1 or src2 could not be dst, we do not need to restore them for
2320     // clobbering dst.
2321     if (src1.is(rcx) || src2.is(rcx)) {
2322       if (src1.is(rcx)) {
2323         movq(src1, kScratchRegister);
2324       } else {
2325         movq(src2, kScratchRegister);
2326       }
2327      }
2328     jmp(on_not_smi_result, near_jump);
2329     bind(&valid_result);
2330     Integer32ToSmi(dst, dst);
2331   }
2332 }
2333
2334
2335 void MacroAssembler::SmiShiftArithmeticRight(Register dst,
2336                                              Register src1,
2337                                              Register src2) {
2338   ASSERT(!dst.is(kScratchRegister));
2339   ASSERT(!src1.is(kScratchRegister));
2340   ASSERT(!src2.is(kScratchRegister));
2341   ASSERT(!dst.is(rcx));
2342
2343   SmiToInteger32(rcx, src2);
2344   if (!dst.is(src1)) {
2345     movp(dst, src1);
2346   }
2347   SmiToInteger32(dst, dst);
2348   sarl_cl(dst);
2349   Integer32ToSmi(dst, dst);
2350 }
2351
2352
2353 void MacroAssembler::SelectNonSmi(Register dst,
2354                                   Register src1,
2355                                   Register src2,
2356                                   Label* on_not_smis,
2357                                   Label::Distance near_jump) {
2358   ASSERT(!dst.is(kScratchRegister));
2359   ASSERT(!src1.is(kScratchRegister));
2360   ASSERT(!src2.is(kScratchRegister));
2361   ASSERT(!dst.is(src1));
2362   ASSERT(!dst.is(src2));
2363   // Both operands must not be smis.
2364 #ifdef DEBUG
2365   Condition not_both_smis = NegateCondition(CheckBothSmi(src1, src2));
2366   Check(not_both_smis, kBothRegistersWereSmisInSelectNonSmi);
2367 #endif
2368   STATIC_ASSERT(kSmiTag == 0);
2369   ASSERT_EQ(0, Smi::FromInt(0));
2370   movl(kScratchRegister, Immediate(kSmiTagMask));
2371   andp(kScratchRegister, src1);
2372   testl(kScratchRegister, src2);
2373   // If non-zero then both are smis.
2374   j(not_zero, on_not_smis, near_jump);
2375
2376   // Exactly one operand is a smi.
2377   ASSERT_EQ(1, static_cast<int>(kSmiTagMask));
2378   // kScratchRegister still holds src1 & kSmiTag, which is either zero or one.
2379   subp(kScratchRegister, Immediate(1));
2380   // If src1 is a smi, then scratch register all 1s, else it is all 0s.
2381   movp(dst, src1);
2382   xorp(dst, src2);
2383   andp(dst, kScratchRegister);
2384   // If src1 is a smi, dst holds src1 ^ src2, else it is zero.
2385   xorp(dst, src1);
2386   // If src1 is a smi, dst is src2, else it is src1, i.e., the non-smi.
2387 }
2388
2389
2390 SmiIndex MacroAssembler::SmiToIndex(Register dst,
2391                                     Register src,
2392                                     int shift) {
2393   if (SmiValuesAre32Bits()) {
2394     ASSERT(is_uint6(shift));
2395     // There is a possible optimization if shift is in the range 60-63, but that
2396     // will (and must) never happen.
2397     if (!dst.is(src)) {
2398       movp(dst, src);
2399     }
2400     if (shift < kSmiShift) {
2401       sarp(dst, Immediate(kSmiShift - shift));
2402     } else {
2403       shlp(dst, Immediate(shift - kSmiShift));
2404     }
2405     return SmiIndex(dst, times_1);
2406   } else {
2407     ASSERT(SmiValuesAre31Bits());
2408     ASSERT(shift >= times_1 && shift <= (static_cast<int>(times_8) + 1));
2409     if (!dst.is(src)) {
2410       movp(dst, src);
2411     }
2412     // We have to sign extend the index register to 64-bit as the SMI might
2413     // be negative.
2414     movsxlq(dst, dst);
2415     if (shift == times_1) {
2416       sarq(dst, Immediate(kSmiShift));
2417       return SmiIndex(dst, times_1);
2418     }
2419     return SmiIndex(dst, static_cast<ScaleFactor>(shift - 1));
2420   }
2421 }
2422
2423
2424 SmiIndex MacroAssembler::SmiToNegativeIndex(Register dst,
2425                                             Register src,
2426                                             int shift) {
2427   if (SmiValuesAre32Bits()) {
2428     // Register src holds a positive smi.
2429     ASSERT(is_uint6(shift));
2430     if (!dst.is(src)) {
2431       movp(dst, src);
2432     }
2433     negp(dst);
2434     if (shift < kSmiShift) {
2435       sarp(dst, Immediate(kSmiShift - shift));
2436     } else {
2437       shlp(dst, Immediate(shift - kSmiShift));
2438     }
2439     return SmiIndex(dst, times_1);
2440   } else {
2441     ASSERT(SmiValuesAre31Bits());
2442     ASSERT(shift >= times_1 && shift <= (static_cast<int>(times_8) + 1));
2443     if (!dst.is(src)) {
2444       movp(dst, src);
2445     }
2446     negq(dst);
2447     if (shift == times_1) {
2448       sarq(dst, Immediate(kSmiShift));
2449       return SmiIndex(dst, times_1);
2450     }
2451     return SmiIndex(dst, static_cast<ScaleFactor>(shift - 1));
2452   }
2453 }
2454
2455
2456 void MacroAssembler::AddSmiField(Register dst, const Operand& src) {
2457   if (SmiValuesAre32Bits()) {
2458     ASSERT_EQ(0, kSmiShift % kBitsPerByte);
2459     addl(dst, Operand(src, kSmiShift / kBitsPerByte));
2460   } else {
2461     ASSERT(SmiValuesAre31Bits());
2462     SmiToInteger32(kScratchRegister, src);
2463     addl(dst, kScratchRegister);
2464   }
2465 }
2466
2467
2468 void MacroAssembler::Push(Smi* source) {
2469   intptr_t smi = reinterpret_cast<intptr_t>(source);
2470   if (is_int32(smi)) {
2471     Push(Immediate(static_cast<int32_t>(smi)));
2472   } else {
2473     Register constant = GetSmiConstant(source);
2474     Push(constant);
2475   }
2476 }
2477
2478
2479 void MacroAssembler::PushRegisterAsTwoSmis(Register src, Register scratch) {
2480   ASSERT(!src.is(scratch));
2481   movp(scratch, src);
2482   // High bits.
2483   shrp(src, Immediate(kPointerSize * kBitsPerByte - kSmiShift));
2484   shlp(src, Immediate(kSmiShift));
2485   Push(src);
2486   // Low bits.
2487   shlp(scratch, Immediate(kSmiShift));
2488   Push(scratch);
2489 }
2490
2491
2492 void MacroAssembler::PopRegisterAsTwoSmis(Register dst, Register scratch) {
2493   ASSERT(!dst.is(scratch));
2494   Pop(scratch);
2495   // Low bits.
2496   shrp(scratch, Immediate(kSmiShift));
2497   Pop(dst);
2498   shrp(dst, Immediate(kSmiShift));
2499   // High bits.
2500   shlp(dst, Immediate(kPointerSize * kBitsPerByte - kSmiShift));
2501   orp(dst, scratch);
2502 }
2503
2504
2505 void MacroAssembler::Test(const Operand& src, Smi* source) {
2506   if (SmiValuesAre32Bits()) {
2507     testl(Operand(src, kIntSize), Immediate(source->value()));
2508   } else {
2509     ASSERT(SmiValuesAre31Bits());
2510     testl(src, Immediate(source));
2511   }
2512 }
2513
2514
2515 // ----------------------------------------------------------------------------
2516
2517
2518 void MacroAssembler::LookupNumberStringCache(Register object,
2519                                              Register result,
2520                                              Register scratch1,
2521                                              Register scratch2,
2522                                              Label* not_found) {
2523   // Use of registers. Register result is used as a temporary.
2524   Register number_string_cache = result;
2525   Register mask = scratch1;
2526   Register scratch = scratch2;
2527
2528   // Load the number string cache.
2529   LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
2530
2531   // Make the hash mask from the length of the number string cache. It
2532   // contains two elements (number and string) for each cache entry.
2533   SmiToInteger32(
2534       mask, FieldOperand(number_string_cache, FixedArray::kLengthOffset));
2535   shrl(mask, Immediate(1));
2536   subp(mask, Immediate(1));  // Make mask.
2537
2538   // Calculate the entry in the number string cache. The hash value in the
2539   // number string cache for smis is just the smi value, and the hash for
2540   // doubles is the xor of the upper and lower words. See
2541   // Heap::GetNumberStringCache.
2542   Label is_smi;
2543   Label load_result_from_cache;
2544   JumpIfSmi(object, &is_smi);
2545   CheckMap(object,
2546            isolate()->factory()->heap_number_map(),
2547            not_found,
2548            DONT_DO_SMI_CHECK);
2549
2550   STATIC_ASSERT(8 == kDoubleSize);
2551   movl(scratch, FieldOperand(object, HeapNumber::kValueOffset + 4));
2552   xorp(scratch, FieldOperand(object, HeapNumber::kValueOffset));
2553   andp(scratch, mask);
2554   // Each entry in string cache consists of two pointer sized fields,
2555   // but times_twice_pointer_size (multiplication by 16) scale factor
2556   // is not supported by addrmode on x64 platform.
2557   // So we have to premultiply entry index before lookup.
2558   shlp(scratch, Immediate(kPointerSizeLog2 + 1));
2559
2560   Register index = scratch;
2561   Register probe = mask;
2562   movp(probe,
2563        FieldOperand(number_string_cache,
2564                     index,
2565                     times_1,
2566                     FixedArray::kHeaderSize));
2567   JumpIfSmi(probe, not_found);
2568   movsd(xmm0, FieldOperand(object, HeapNumber::kValueOffset));
2569   ucomisd(xmm0, FieldOperand(probe, HeapNumber::kValueOffset));
2570   j(parity_even, not_found);  // Bail out if NaN is involved.
2571   j(not_equal, not_found);  // The cache did not contain this value.
2572   jmp(&load_result_from_cache);
2573
2574   bind(&is_smi);
2575   SmiToInteger32(scratch, object);
2576   andp(scratch, mask);
2577   // Each entry in string cache consists of two pointer sized fields,
2578   // but times_twice_pointer_size (multiplication by 16) scale factor
2579   // is not supported by addrmode on x64 platform.
2580   // So we have to premultiply entry index before lookup.
2581   shlp(scratch, Immediate(kPointerSizeLog2 + 1));
2582
2583   // Check if the entry is the smi we are looking for.
2584   cmpp(object,
2585        FieldOperand(number_string_cache,
2586                     index,
2587                     times_1,
2588                     FixedArray::kHeaderSize));
2589   j(not_equal, not_found);
2590
2591   // Get the result from the cache.
2592   bind(&load_result_from_cache);
2593   movp(result,
2594        FieldOperand(number_string_cache,
2595                     index,
2596                     times_1,
2597                     FixedArray::kHeaderSize + kPointerSize));
2598   IncrementCounter(isolate()->counters()->number_to_string_native(), 1);
2599 }
2600
2601
2602 void MacroAssembler::absps(XMMRegister dst) {
2603   static const struct V8_ALIGNED(16) {
2604     uint32_t a;
2605     uint32_t b;
2606     uint32_t c;
2607     uint32_t d;
2608   } float_absolute_constant =
2609       { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF };
2610   Set(kScratchRegister, reinterpret_cast<intptr_t>(&float_absolute_constant));
2611   andps(dst, Operand(kScratchRegister, 0));
2612 }
2613
2614
2615 void MacroAssembler::abspd(XMMRegister dst) {
2616   static const struct V8_ALIGNED(16) {
2617     uint64_t a;
2618     uint64_t b;
2619   } double_absolute_constant =
2620       { V8_UINT64_C(0x7FFFFFFFFFFFFFFF), V8_UINT64_C(0x7FFFFFFFFFFFFFFF) };
2621   Set(kScratchRegister, reinterpret_cast<intptr_t>(&double_absolute_constant));
2622   andpd(dst, Operand(kScratchRegister, 0));
2623 }
2624
2625
2626 void MacroAssembler::negateps(XMMRegister dst) {
2627   static const struct V8_ALIGNED(16) {
2628     uint32_t a;
2629     uint32_t b;
2630     uint32_t c;
2631     uint32_t d;
2632   } float_negate_constant =
2633       { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
2634   Set(kScratchRegister, reinterpret_cast<intptr_t>(&float_negate_constant));
2635   xorps(dst, Operand(kScratchRegister, 0));
2636 }
2637
2638
2639 void MacroAssembler::negatepd(XMMRegister dst) {
2640   static const struct V8_ALIGNED(16) {
2641     uint64_t a;
2642     uint64_t b;
2643   } double_absolute_constant =
2644       { V8_UINT64_C(0x8000000000000000), V8_UINT64_C(0x8000000000000000) };
2645   Set(kScratchRegister, reinterpret_cast<intptr_t>(&double_absolute_constant));
2646   xorpd(dst, Operand(kScratchRegister, 0));
2647 }
2648
2649
2650 void MacroAssembler::notps(XMMRegister dst) {
2651   static const struct V8_ALIGNED(16) {
2652     uint32_t a;
2653     uint32_t b;
2654     uint32_t c;
2655     uint32_t d;
2656   } float_not_constant =
2657       { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
2658   Set(kScratchRegister, reinterpret_cast<intptr_t>(&float_not_constant));
2659   xorps(dst, Operand(kScratchRegister, 0));
2660 }
2661
2662
2663 void MacroAssembler::pnegd(XMMRegister dst) {
2664   static const struct V8_ALIGNED(16) {
2665     uint32_t a;
2666     uint32_t b;
2667     uint32_t c;
2668     uint32_t d;
2669   } int32_one_constant = { 0x1, 0x1, 0x1, 0x1 };
2670   notps(dst);
2671   Set(kScratchRegister, reinterpret_cast<intptr_t>(&int32_one_constant));
2672   paddd(dst, Operand(kScratchRegister, 0));
2673 }
2674
2675
2676
2677 void MacroAssembler::JumpIfNotString(Register object,
2678                                      Register object_map,
2679                                      Label* not_string,
2680                                      Label::Distance near_jump) {
2681   Condition is_smi = CheckSmi(object);
2682   j(is_smi, not_string, near_jump);
2683   CmpObjectType(object, FIRST_NONSTRING_TYPE, object_map);
2684   j(above_equal, not_string, near_jump);
2685 }
2686
2687
2688 void MacroAssembler::JumpIfNotBothSequentialAsciiStrings(
2689     Register first_object,
2690     Register second_object,
2691     Register scratch1,
2692     Register scratch2,
2693     Label* on_fail,
2694     Label::Distance near_jump) {
2695   // Check that both objects are not smis.
2696   Condition either_smi = CheckEitherSmi(first_object, second_object);
2697   j(either_smi, on_fail, near_jump);
2698
2699   // Load instance type for both strings.
2700   movp(scratch1, FieldOperand(first_object, HeapObject::kMapOffset));
2701   movp(scratch2, FieldOperand(second_object, HeapObject::kMapOffset));
2702   movzxbl(scratch1, FieldOperand(scratch1, Map::kInstanceTypeOffset));
2703   movzxbl(scratch2, FieldOperand(scratch2, Map::kInstanceTypeOffset));
2704
2705   // Check that both are flat ASCII strings.
2706   ASSERT(kNotStringTag != 0);
2707   const int kFlatAsciiStringMask =
2708       kIsNotStringMask | kStringRepresentationMask | kStringEncodingMask;
2709   const int kFlatAsciiStringTag =
2710       kStringTag | kOneByteStringTag | kSeqStringTag;
2711
2712   andl(scratch1, Immediate(kFlatAsciiStringMask));
2713   andl(scratch2, Immediate(kFlatAsciiStringMask));
2714   // Interleave the bits to check both scratch1 and scratch2 in one test.
2715   ASSERT_EQ(0, kFlatAsciiStringMask & (kFlatAsciiStringMask << 3));
2716   leap(scratch1, Operand(scratch1, scratch2, times_8, 0));
2717   cmpl(scratch1,
2718        Immediate(kFlatAsciiStringTag + (kFlatAsciiStringTag << 3)));
2719   j(not_equal, on_fail, near_jump);
2720 }
2721
2722
2723 void MacroAssembler::JumpIfInstanceTypeIsNotSequentialAscii(
2724     Register instance_type,
2725     Register scratch,
2726     Label* failure,
2727     Label::Distance near_jump) {
2728   if (!scratch.is(instance_type)) {
2729     movl(scratch, instance_type);
2730   }
2731
2732   const int kFlatAsciiStringMask =
2733       kIsNotStringMask | kStringRepresentationMask | kStringEncodingMask;
2734
2735   andl(scratch, Immediate(kFlatAsciiStringMask));
2736   cmpl(scratch, Immediate(kStringTag | kSeqStringTag | kOneByteStringTag));
2737   j(not_equal, failure, near_jump);
2738 }
2739
2740
2741 void MacroAssembler::JumpIfBothInstanceTypesAreNotSequentialAscii(
2742     Register first_object_instance_type,
2743     Register second_object_instance_type,
2744     Register scratch1,
2745     Register scratch2,
2746     Label* on_fail,
2747     Label::Distance near_jump) {
2748   // Load instance type for both strings.
2749   movp(scratch1, first_object_instance_type);
2750   movp(scratch2, second_object_instance_type);
2751
2752   // Check that both are flat ASCII strings.
2753   ASSERT(kNotStringTag != 0);
2754   const int kFlatAsciiStringMask =
2755       kIsNotStringMask | kStringRepresentationMask | kStringEncodingMask;
2756   const int kFlatAsciiStringTag =
2757       kStringTag | kOneByteStringTag | kSeqStringTag;
2758
2759   andl(scratch1, Immediate(kFlatAsciiStringMask));
2760   andl(scratch2, Immediate(kFlatAsciiStringMask));
2761   // Interleave the bits to check both scratch1 and scratch2 in one test.
2762   ASSERT_EQ(0, kFlatAsciiStringMask & (kFlatAsciiStringMask << 3));
2763   leap(scratch1, Operand(scratch1, scratch2, times_8, 0));
2764   cmpl(scratch1,
2765        Immediate(kFlatAsciiStringTag + (kFlatAsciiStringTag << 3)));
2766   j(not_equal, on_fail, near_jump);
2767 }
2768
2769
2770 template<class T>
2771 static void JumpIfNotUniqueNameHelper(MacroAssembler* masm,
2772                                       T operand_or_register,
2773                                       Label* not_unique_name,
2774                                       Label::Distance distance) {
2775   STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
2776   Label succeed;
2777   masm->testb(operand_or_register,
2778               Immediate(kIsNotStringMask | kIsNotInternalizedMask));
2779   masm->j(zero, &succeed, Label::kNear);
2780   masm->cmpb(operand_or_register, Immediate(static_cast<uint8_t>(SYMBOL_TYPE)));
2781   masm->j(not_equal, not_unique_name, distance);
2782
2783   masm->bind(&succeed);
2784 }
2785
2786
2787 void MacroAssembler::JumpIfNotUniqueName(Operand operand,
2788                                          Label* not_unique_name,
2789                                          Label::Distance distance) {
2790   JumpIfNotUniqueNameHelper<Operand>(this, operand, not_unique_name, distance);
2791 }
2792
2793
2794 void MacroAssembler::JumpIfNotUniqueName(Register reg,
2795                                          Label* not_unique_name,
2796                                          Label::Distance distance) {
2797   JumpIfNotUniqueNameHelper<Register>(this, reg, not_unique_name, distance);
2798 }
2799
2800
2801 void MacroAssembler::Move(Register dst, Register src) {
2802   if (!dst.is(src)) {
2803     movp(dst, src);
2804   }
2805 }
2806
2807
2808 void MacroAssembler::Move(Register dst, Handle<Object> source) {
2809   AllowDeferredHandleDereference smi_check;
2810   if (source->IsSmi()) {
2811     Move(dst, Smi::cast(*source));
2812   } else {
2813     MoveHeapObject(dst, source);
2814   }
2815 }
2816
2817
2818 void MacroAssembler::Move(const Operand& dst, Handle<Object> source) {
2819   AllowDeferredHandleDereference smi_check;
2820   if (source->IsSmi()) {
2821     Move(dst, Smi::cast(*source));
2822   } else {
2823     MoveHeapObject(kScratchRegister, source);
2824     movp(dst, kScratchRegister);
2825   }
2826 }
2827
2828
2829 void MacroAssembler::Cmp(Register dst, Handle<Object> source) {
2830   AllowDeferredHandleDereference smi_check;
2831   if (source->IsSmi()) {
2832     Cmp(dst, Smi::cast(*source));
2833   } else {
2834     MoveHeapObject(kScratchRegister, source);
2835     cmpp(dst, kScratchRegister);
2836   }
2837 }
2838
2839
2840 void MacroAssembler::Cmp(const Operand& dst, Handle<Object> source) {
2841   AllowDeferredHandleDereference smi_check;
2842   if (source->IsSmi()) {
2843     Cmp(dst, Smi::cast(*source));
2844   } else {
2845     MoveHeapObject(kScratchRegister, source);
2846     cmpp(dst, kScratchRegister);
2847   }
2848 }
2849
2850
2851 void MacroAssembler::Push(Handle<Object> source) {
2852   AllowDeferredHandleDereference smi_check;
2853   if (source->IsSmi()) {
2854     Push(Smi::cast(*source));
2855   } else {
2856     MoveHeapObject(kScratchRegister, source);
2857     Push(kScratchRegister);
2858   }
2859 }
2860
2861
2862 void MacroAssembler::MoveHeapObject(Register result,
2863                                     Handle<Object> object) {
2864   AllowDeferredHandleDereference using_raw_address;
2865   ASSERT(object->IsHeapObject());
2866   if (isolate()->heap()->InNewSpace(*object)) {
2867     Handle<Cell> cell = isolate()->factory()->NewCell(object);
2868     Move(result, cell, RelocInfo::CELL);
2869     movp(result, Operand(result, 0));
2870   } else {
2871     Move(result, object, RelocInfo::EMBEDDED_OBJECT);
2872   }
2873 }
2874
2875
2876 void MacroAssembler::LoadGlobalCell(Register dst, Handle<Cell> cell) {
2877   if (dst.is(rax)) {
2878     AllowDeferredHandleDereference embedding_raw_address;
2879     load_rax(cell.location(), RelocInfo::CELL);
2880   } else {
2881     Move(dst, cell, RelocInfo::CELL);
2882     movp(dst, Operand(dst, 0));
2883   }
2884 }
2885
2886
2887 void MacroAssembler::Drop(int stack_elements) {
2888   if (stack_elements > 0) {
2889     addp(rsp, Immediate(stack_elements * kPointerSize));
2890   }
2891 }
2892
2893
2894 void MacroAssembler::DropUnderReturnAddress(int stack_elements,
2895                                             Register scratch) {
2896   ASSERT(stack_elements > 0);
2897   if (kPointerSize == kInt64Size && stack_elements == 1) {
2898     popq(MemOperand(rsp, 0));
2899     return;
2900   }
2901
2902   PopReturnAddressTo(scratch);
2903   Drop(stack_elements);
2904   PushReturnAddressFrom(scratch);
2905 }
2906
2907
2908 void MacroAssembler::Push(Register src) {
2909   if (kPointerSize == kInt64Size) {
2910     pushq(src);
2911   } else {
2912     // x32 uses 64-bit push for rbp in the prologue.
2913     ASSERT(src.code() != rbp.code());
2914     leal(rsp, Operand(rsp, -4));
2915     movp(Operand(rsp, 0), src);
2916   }
2917 }
2918
2919
2920 void MacroAssembler::Push(const Operand& src) {
2921   if (kPointerSize == kInt64Size) {
2922     pushq(src);
2923   } else {
2924     movp(kScratchRegister, src);
2925     leal(rsp, Operand(rsp, -4));
2926     movp(Operand(rsp, 0), kScratchRegister);
2927   }
2928 }
2929
2930
2931 void MacroAssembler::PushQuad(const Operand& src) {
2932   if (kPointerSize == kInt64Size) {
2933     pushq(src);
2934   } else {
2935     movp(kScratchRegister, src);
2936     pushq(kScratchRegister);
2937   }
2938 }
2939
2940
2941 void MacroAssembler::Push(Immediate value) {
2942   if (kPointerSize == kInt64Size) {
2943     pushq(value);
2944   } else {
2945     leal(rsp, Operand(rsp, -4));
2946     movp(Operand(rsp, 0), value);
2947   }
2948 }
2949
2950
2951 void MacroAssembler::PushImm32(int32_t imm32) {
2952   if (kPointerSize == kInt64Size) {
2953     pushq_imm32(imm32);
2954   } else {
2955     leal(rsp, Operand(rsp, -4));
2956     movp(Operand(rsp, 0), Immediate(imm32));
2957   }
2958 }
2959
2960
2961 void MacroAssembler::Pop(Register dst) {
2962   if (kPointerSize == kInt64Size) {
2963     popq(dst);
2964   } else {
2965     // x32 uses 64-bit pop for rbp in the epilogue.
2966     ASSERT(dst.code() != rbp.code());
2967     movp(dst, Operand(rsp, 0));
2968     leal(rsp, Operand(rsp, 4));
2969   }
2970 }
2971
2972
2973 void MacroAssembler::Pop(const Operand& dst) {
2974   if (kPointerSize == kInt64Size) {
2975     popq(dst);
2976   } else {
2977     Register scratch = dst.AddressUsesRegister(kScratchRegister)
2978         ? kSmiConstantRegister : kScratchRegister;
2979     movp(scratch, Operand(rsp, 0));
2980     movp(dst, scratch);
2981     leal(rsp, Operand(rsp, 4));
2982     if (scratch.is(kSmiConstantRegister)) {
2983       // Restore kSmiConstantRegister.
2984       movp(kSmiConstantRegister,
2985            reinterpret_cast<void*>(Smi::FromInt(kSmiConstantRegisterValue)),
2986            Assembler::RelocInfoNone());
2987     }
2988   }
2989 }
2990
2991
2992 void MacroAssembler::PopQuad(const Operand& dst) {
2993   if (kPointerSize == kInt64Size) {
2994     popq(dst);
2995   } else {
2996     popq(kScratchRegister);
2997     movp(dst, kScratchRegister);
2998   }
2999 }
3000
3001
3002 void MacroAssembler::LoadSharedFunctionInfoSpecialField(Register dst,
3003                                                         Register base,
3004                                                         int offset) {
3005   ASSERT(offset > SharedFunctionInfo::kLengthOffset &&
3006          offset <= SharedFunctionInfo::kSize &&
3007          (((offset - SharedFunctionInfo::kLengthOffset) / kIntSize) % 2 == 1));
3008   if (kPointerSize == kInt64Size) {
3009     movsxlq(dst, FieldOperand(base, offset));
3010   } else {
3011     movp(dst, FieldOperand(base, offset));
3012     SmiToInteger32(dst, dst);
3013   }
3014 }
3015
3016
3017 void MacroAssembler::TestBitSharedFunctionInfoSpecialField(Register base,
3018                                                            int offset,
3019                                                            int bits) {
3020   ASSERT(offset > SharedFunctionInfo::kLengthOffset &&
3021          offset <= SharedFunctionInfo::kSize &&
3022          (((offset - SharedFunctionInfo::kLengthOffset) / kIntSize) % 2 == 1));
3023   if (kPointerSize == kInt32Size) {
3024     // On x32, this field is represented by SMI.
3025     bits += kSmiShift;
3026   }
3027   int byte_offset = bits / kBitsPerByte;
3028   int bit_in_byte = bits & (kBitsPerByte - 1);
3029   testb(FieldOperand(base, offset + byte_offset), Immediate(1 << bit_in_byte));
3030 }
3031
3032
3033 void MacroAssembler::Jump(ExternalReference ext) {
3034   LoadAddress(kScratchRegister, ext);
3035   jmp(kScratchRegister);
3036 }
3037
3038
3039 void MacroAssembler::Jump(const Operand& op) {
3040   if (kPointerSize == kInt64Size) {
3041     jmp(op);
3042   } else {
3043     movp(kScratchRegister, op);
3044     jmp(kScratchRegister);
3045   }
3046 }
3047
3048
3049 void MacroAssembler::Jump(Address destination, RelocInfo::Mode rmode) {
3050   Move(kScratchRegister, destination, rmode);
3051   jmp(kScratchRegister);
3052 }
3053
3054
3055 void MacroAssembler::Jump(Handle<Code> code_object, RelocInfo::Mode rmode) {
3056   // TODO(X64): Inline this
3057   jmp(code_object, rmode);
3058 }
3059
3060
3061 int MacroAssembler::CallSize(ExternalReference ext) {
3062   // Opcode for call kScratchRegister is: Rex.B FF D4 (three bytes).
3063   return LoadAddressSize(ext) +
3064          Assembler::kCallScratchRegisterInstructionLength;
3065 }
3066
3067
3068 void MacroAssembler::Call(ExternalReference ext) {
3069 #ifdef DEBUG
3070   int end_position = pc_offset() + CallSize(ext);
3071 #endif
3072   LoadAddress(kScratchRegister, ext);
3073   call(kScratchRegister);
3074 #ifdef DEBUG
3075   CHECK_EQ(end_position, pc_offset());
3076 #endif
3077 }
3078
3079
3080 void MacroAssembler::Call(const Operand& op) {
3081   if (kPointerSize == kInt64Size) {
3082     call(op);
3083   } else {
3084     movp(kScratchRegister, op);
3085     call(kScratchRegister);
3086   }
3087 }
3088
3089
3090 void MacroAssembler::Call(Address destination, RelocInfo::Mode rmode) {
3091 #ifdef DEBUG
3092   int end_position = pc_offset() + CallSize(destination);
3093 #endif
3094   Move(kScratchRegister, destination, rmode);
3095   call(kScratchRegister);
3096 #ifdef DEBUG
3097   CHECK_EQ(pc_offset(), end_position);
3098 #endif
3099 }
3100
3101
3102 void MacroAssembler::Call(Handle<Code> code_object,
3103                           RelocInfo::Mode rmode,
3104                           TypeFeedbackId ast_id) {
3105 #ifdef DEBUG
3106   int end_position = pc_offset() + CallSize(code_object);
3107 #endif
3108   ASSERT(RelocInfo::IsCodeTarget(rmode) ||
3109       rmode == RelocInfo::CODE_AGE_SEQUENCE);
3110   call(code_object, rmode, ast_id);
3111 #ifdef DEBUG
3112   CHECK_EQ(end_position, pc_offset());
3113 #endif
3114 }
3115
3116
3117 void MacroAssembler::Pushad() {
3118   Push(rax);
3119   Push(rcx);
3120   Push(rdx);
3121   Push(rbx);
3122   // Not pushing rsp or rbp.
3123   Push(rsi);
3124   Push(rdi);
3125   Push(r8);
3126   Push(r9);
3127   // r10 is kScratchRegister.
3128   Push(r11);
3129   // r12 is kSmiConstantRegister.
3130   // r13 is kRootRegister.
3131   Push(r14);
3132   Push(r15);
3133   STATIC_ASSERT(11 == kNumSafepointSavedRegisters);
3134   // Use lea for symmetry with Popad.
3135   int sp_delta =
3136       (kNumSafepointRegisters - kNumSafepointSavedRegisters) * kPointerSize;
3137   leap(rsp, Operand(rsp, -sp_delta));
3138 }
3139
3140
3141 void MacroAssembler::Popad() {
3142   // Popad must not change the flags, so use lea instead of addq.
3143   int sp_delta =
3144       (kNumSafepointRegisters - kNumSafepointSavedRegisters) * kPointerSize;
3145   leap(rsp, Operand(rsp, sp_delta));
3146   Pop(r15);
3147   Pop(r14);
3148   Pop(r11);
3149   Pop(r9);
3150   Pop(r8);
3151   Pop(rdi);
3152   Pop(rsi);
3153   Pop(rbx);
3154   Pop(rdx);
3155   Pop(rcx);
3156   Pop(rax);
3157 }
3158
3159
3160 void MacroAssembler::Dropad() {
3161   addp(rsp, Immediate(kNumSafepointRegisters * kPointerSize));
3162 }
3163
3164
3165 // Order general registers are pushed by Pushad:
3166 // rax, rcx, rdx, rbx, rsi, rdi, r8, r9, r11, r14, r15.
3167 const int
3168 MacroAssembler::kSafepointPushRegisterIndices[Register::kNumRegisters] = {
3169     0,
3170     1,
3171     2,
3172     3,
3173     -1,
3174     -1,
3175     4,
3176     5,
3177     6,
3178     7,
3179     -1,
3180     8,
3181     -1,
3182     -1,
3183     9,
3184     10
3185 };
3186
3187
3188 void MacroAssembler::StoreToSafepointRegisterSlot(Register dst,
3189                                                   const Immediate& imm) {
3190   movp(SafepointRegisterSlot(dst), imm);
3191 }
3192
3193
3194 void MacroAssembler::StoreToSafepointRegisterSlot(Register dst, Register src) {
3195   movp(SafepointRegisterSlot(dst), src);
3196 }
3197
3198
3199 void MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) {
3200   movp(dst, SafepointRegisterSlot(src));
3201 }
3202
3203
3204 Operand MacroAssembler::SafepointRegisterSlot(Register reg) {
3205   return Operand(rsp, SafepointRegisterStackIndex(reg.code()) * kPointerSize);
3206 }
3207
3208
3209 void MacroAssembler::PushTryHandler(StackHandler::Kind kind,
3210                                     int handler_index) {
3211   // Adjust this code if not the case.
3212   STATIC_ASSERT(StackHandlerConstants::kSize == 4 * kPointerSize +
3213                                                 kFPOnStackSize);
3214   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
3215   STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
3216   STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
3217   STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
3218   STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
3219
3220   // We will build up the handler from the bottom by pushing on the stack.
3221   // First push the frame pointer and context.
3222   if (kind == StackHandler::JS_ENTRY) {
3223     // The frame pointer does not point to a JS frame so we save NULL for
3224     // rbp. We expect the code throwing an exception to check rbp before
3225     // dereferencing it to restore the context.
3226     pushq(Immediate(0));  // NULL frame pointer.
3227     Push(Smi::FromInt(0));  // No context.
3228   } else {
3229     pushq(rbp);
3230     Push(rsi);
3231   }
3232
3233   // Push the state and the code object.
3234   unsigned state =
3235       StackHandler::IndexField::encode(handler_index) |
3236       StackHandler::KindField::encode(kind);
3237   Push(Immediate(state));
3238   Push(CodeObject());
3239
3240   // Link the current handler as the next handler.
3241   ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
3242   Push(ExternalOperand(handler_address));
3243   // Set this new handler as the current one.
3244   movp(ExternalOperand(handler_address), rsp);
3245 }
3246
3247
3248 void MacroAssembler::PopTryHandler() {
3249   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
3250   ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
3251   Pop(ExternalOperand(handler_address));
3252   addp(rsp, Immediate(StackHandlerConstants::kSize - kPointerSize));
3253 }
3254
3255
3256 void MacroAssembler::JumpToHandlerEntry() {
3257   // Compute the handler entry address and jump to it.  The handler table is
3258   // a fixed array of (smi-tagged) code offsets.
3259   // rax = exception, rdi = code object, rdx = state.
3260   movp(rbx, FieldOperand(rdi, Code::kHandlerTableOffset));
3261   shrp(rdx, Immediate(StackHandler::kKindWidth));
3262   movp(rdx,
3263        FieldOperand(rbx, rdx, times_pointer_size, FixedArray::kHeaderSize));
3264   SmiToInteger64(rdx, rdx);
3265   leap(rdi, FieldOperand(rdi, rdx, times_1, Code::kHeaderSize));
3266   jmp(rdi);
3267 }
3268
3269
3270 void MacroAssembler::Throw(Register value) {
3271   // Adjust this code if not the case.
3272   STATIC_ASSERT(StackHandlerConstants::kSize == 4 * kPointerSize +
3273                                                 kFPOnStackSize);
3274   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
3275   STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
3276   STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
3277   STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
3278   STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
3279
3280   // The exception is expected in rax.
3281   if (!value.is(rax)) {
3282     movp(rax, value);
3283   }
3284   // Drop the stack pointer to the top of the top handler.
3285   ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
3286   movp(rsp, ExternalOperand(handler_address));
3287   // Restore the next handler.
3288   Pop(ExternalOperand(handler_address));
3289
3290   // Remove the code object and state, compute the handler address in rdi.
3291   Pop(rdi);  // Code object.
3292   Pop(rdx);  // Offset and state.
3293
3294   // Restore the context and frame pointer.
3295   Pop(rsi);  // Context.
3296   popq(rbp);  // Frame pointer.
3297
3298   // If the handler is a JS frame, restore the context to the frame.
3299   // (kind == ENTRY) == (rbp == 0) == (rsi == 0), so we could test either
3300   // rbp or rsi.
3301   Label skip;
3302   testp(rsi, rsi);
3303   j(zero, &skip, Label::kNear);
3304   movp(Operand(rbp, StandardFrameConstants::kContextOffset), rsi);
3305   bind(&skip);
3306
3307   JumpToHandlerEntry();
3308 }
3309
3310
3311 void MacroAssembler::ThrowUncatchable(Register value) {
3312   // Adjust this code if not the case.
3313   STATIC_ASSERT(StackHandlerConstants::kSize == 4 * kPointerSize +
3314                                                 kFPOnStackSize);
3315   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
3316   STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
3317   STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
3318   STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
3319   STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
3320
3321   // The exception is expected in rax.
3322   if (!value.is(rax)) {
3323     movp(rax, value);
3324   }
3325   // Drop the stack pointer to the top of the top stack handler.
3326   ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
3327   Load(rsp, handler_address);
3328
3329   // Unwind the handlers until the top ENTRY handler is found.
3330   Label fetch_next, check_kind;
3331   jmp(&check_kind, Label::kNear);
3332   bind(&fetch_next);
3333   movp(rsp, Operand(rsp, StackHandlerConstants::kNextOffset));
3334
3335   bind(&check_kind);
3336   STATIC_ASSERT(StackHandler::JS_ENTRY == 0);
3337   testl(Operand(rsp, StackHandlerConstants::kStateOffset),
3338         Immediate(StackHandler::KindField::kMask));
3339   j(not_zero, &fetch_next);
3340
3341   // Set the top handler address to next handler past the top ENTRY handler.
3342   Pop(ExternalOperand(handler_address));
3343
3344   // Remove the code object and state, compute the handler address in rdi.
3345   Pop(rdi);  // Code object.
3346   Pop(rdx);  // Offset and state.
3347
3348   // Clear the context pointer and frame pointer (0 was saved in the handler).
3349   Pop(rsi);
3350   popq(rbp);
3351
3352   JumpToHandlerEntry();
3353 }
3354
3355
3356 void MacroAssembler::Ret() {
3357   ret(0);
3358 }
3359
3360
3361 void MacroAssembler::Ret(int bytes_dropped, Register scratch) {
3362   if (is_uint16(bytes_dropped)) {
3363     ret(bytes_dropped);
3364   } else {
3365     PopReturnAddressTo(scratch);
3366     addp(rsp, Immediate(bytes_dropped));
3367     PushReturnAddressFrom(scratch);
3368     ret(0);
3369   }
3370 }
3371
3372
3373 void MacroAssembler::FCmp() {
3374   fucomip();
3375   fstp(0);
3376 }
3377
3378
3379 void MacroAssembler::CmpObjectType(Register heap_object,
3380                                    InstanceType type,
3381                                    Register map) {
3382   movp(map, FieldOperand(heap_object, HeapObject::kMapOffset));
3383   CmpInstanceType(map, type);
3384 }
3385
3386
3387 void MacroAssembler::CmpInstanceType(Register map, InstanceType type) {
3388   cmpb(FieldOperand(map, Map::kInstanceTypeOffset),
3389        Immediate(static_cast<int8_t>(type)));
3390 }
3391
3392
3393 void MacroAssembler::CheckFastElements(Register map,
3394                                        Label* fail,
3395                                        Label::Distance distance) {
3396   STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
3397   STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
3398   STATIC_ASSERT(FAST_ELEMENTS == 2);
3399   STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
3400   cmpb(FieldOperand(map, Map::kBitField2Offset),
3401        Immediate(Map::kMaximumBitField2FastHoleyElementValue));
3402   j(above, fail, distance);
3403 }
3404
3405
3406 void MacroAssembler::CheckFastObjectElements(Register map,
3407                                              Label* fail,
3408                                              Label::Distance distance) {
3409   STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
3410   STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
3411   STATIC_ASSERT(FAST_ELEMENTS == 2);
3412   STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
3413   cmpb(FieldOperand(map, Map::kBitField2Offset),
3414        Immediate(Map::kMaximumBitField2FastHoleySmiElementValue));
3415   j(below_equal, fail, distance);
3416   cmpb(FieldOperand(map, Map::kBitField2Offset),
3417        Immediate(Map::kMaximumBitField2FastHoleyElementValue));
3418   j(above, fail, distance);
3419 }
3420
3421
3422 void MacroAssembler::CheckFastSmiElements(Register map,
3423                                           Label* fail,
3424                                           Label::Distance distance) {
3425   STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
3426   STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
3427   cmpb(FieldOperand(map, Map::kBitField2Offset),
3428        Immediate(Map::kMaximumBitField2FastHoleySmiElementValue));
3429   j(above, fail, distance);
3430 }
3431
3432
3433 void MacroAssembler::StoreNumberToDoubleElements(
3434     Register maybe_number,
3435     Register elements,
3436     Register index,
3437     XMMRegister xmm_scratch,
3438     Label* fail,
3439     int elements_offset) {
3440   Label smi_value, is_nan, maybe_nan, not_nan, have_double_value, done;
3441
3442   JumpIfSmi(maybe_number, &smi_value, Label::kNear);
3443
3444   CheckMap(maybe_number,
3445            isolate()->factory()->heap_number_map(),
3446            fail,
3447            DONT_DO_SMI_CHECK);
3448
3449   // Double value, canonicalize NaN.
3450   uint32_t offset = HeapNumber::kValueOffset + sizeof(kHoleNanLower32);
3451   cmpl(FieldOperand(maybe_number, offset),
3452        Immediate(kNaNOrInfinityLowerBoundUpper32));
3453   j(greater_equal, &maybe_nan, Label::kNear);
3454
3455   bind(&not_nan);
3456   movsd(xmm_scratch, FieldOperand(maybe_number, HeapNumber::kValueOffset));
3457   bind(&have_double_value);
3458   movsd(FieldOperand(elements, index, times_8,
3459                      FixedDoubleArray::kHeaderSize - elements_offset),
3460         xmm_scratch);
3461   jmp(&done);
3462
3463   bind(&maybe_nan);
3464   // Could be NaN or Infinity. If fraction is not zero, it's NaN, otherwise
3465   // it's an Infinity, and the non-NaN code path applies.
3466   j(greater, &is_nan, Label::kNear);
3467   cmpl(FieldOperand(maybe_number, HeapNumber::kValueOffset), Immediate(0));
3468   j(zero, &not_nan);
3469   bind(&is_nan);
3470   // Convert all NaNs to the same canonical NaN value when they are stored in
3471   // the double array.
3472   Set(kScratchRegister, BitCast<uint64_t>(
3473       FixedDoubleArray::canonical_not_the_hole_nan_as_double()));
3474   movq(xmm_scratch, kScratchRegister);
3475   jmp(&have_double_value, Label::kNear);
3476
3477   bind(&smi_value);
3478   // Value is a smi. convert to a double and store.
3479   // Preserve original value.
3480   SmiToInteger32(kScratchRegister, maybe_number);
3481   Cvtlsi2sd(xmm_scratch, kScratchRegister);
3482   movsd(FieldOperand(elements, index, times_8,
3483                      FixedDoubleArray::kHeaderSize - elements_offset),
3484         xmm_scratch);
3485   bind(&done);
3486 }
3487
3488
3489 void MacroAssembler::CompareMap(Register obj, Handle<Map> map) {
3490   Cmp(FieldOperand(obj, HeapObject::kMapOffset), map);
3491 }
3492
3493
3494 void MacroAssembler::CheckMap(Register obj,
3495                               Handle<Map> map,
3496                               Label* fail,
3497                               SmiCheckType smi_check_type) {
3498   if (smi_check_type == DO_SMI_CHECK) {
3499     JumpIfSmi(obj, fail);
3500   }
3501
3502   CompareMap(obj, map);
3503   j(not_equal, fail);
3504 }
3505
3506
3507 void MacroAssembler::ClampUint8(Register reg) {
3508   Label done;
3509   testl(reg, Immediate(0xFFFFFF00));
3510   j(zero, &done, Label::kNear);
3511   setcc(negative, reg);  // 1 if negative, 0 if positive.
3512   decb(reg);  // 0 if negative, 255 if positive.
3513   bind(&done);
3514 }
3515
3516
3517 void MacroAssembler::ClampDoubleToUint8(XMMRegister input_reg,
3518                                         XMMRegister temp_xmm_reg,
3519                                         Register result_reg) {
3520   Label done;
3521   Label conv_failure;
3522   xorps(temp_xmm_reg, temp_xmm_reg);
3523   cvtsd2si(result_reg, input_reg);
3524   testl(result_reg, Immediate(0xFFFFFF00));
3525   j(zero, &done, Label::kNear);
3526   cmpl(result_reg, Immediate(1));
3527   j(overflow, &conv_failure, Label::kNear);
3528   movl(result_reg, Immediate(0));
3529   setcc(sign, result_reg);
3530   subl(result_reg, Immediate(1));
3531   andl(result_reg, Immediate(255));
3532   jmp(&done, Label::kNear);
3533   bind(&conv_failure);
3534   Set(result_reg, 0);
3535   ucomisd(input_reg, temp_xmm_reg);
3536   j(below, &done, Label::kNear);
3537   Set(result_reg, 255);
3538   bind(&done);
3539 }
3540
3541
3542 void MacroAssembler::LoadUint32(XMMRegister dst,
3543                                 Register src) {
3544   if (FLAG_debug_code) {
3545     cmpq(src, Immediate(0xffffffff));
3546     Assert(below_equal, kInputGPRIsExpectedToHaveUpper32Cleared);
3547   }
3548   cvtqsi2sd(dst, src);
3549 }
3550
3551
3552 void MacroAssembler::SlowTruncateToI(Register result_reg,
3553                                      Register input_reg,
3554                                      int offset) {
3555   DoubleToIStub stub(isolate(), input_reg, result_reg, offset, true);
3556   call(stub.GetCode(), RelocInfo::CODE_TARGET);
3557 }
3558
3559
3560 void MacroAssembler::TruncateHeapNumberToI(Register result_reg,
3561                                            Register input_reg) {
3562   Label done;
3563   movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
3564   cvttsd2siq(result_reg, xmm0);
3565   cmpq(result_reg, Immediate(1));
3566   j(no_overflow, &done, Label::kNear);
3567
3568   // Slow case.
3569   if (input_reg.is(result_reg)) {
3570     subp(rsp, Immediate(kDoubleSize));
3571     movsd(MemOperand(rsp, 0), xmm0);
3572     SlowTruncateToI(result_reg, rsp, 0);
3573     addp(rsp, Immediate(kDoubleSize));
3574   } else {
3575     SlowTruncateToI(result_reg, input_reg);
3576   }
3577
3578   bind(&done);
3579   // Keep our invariant that the upper 32 bits are zero.
3580   movl(result_reg, result_reg);
3581 }
3582
3583
3584 void MacroAssembler::TruncateDoubleToI(Register result_reg,
3585                                        XMMRegister input_reg) {
3586   Label done;
3587   cvttsd2siq(result_reg, input_reg);
3588   cmpq(result_reg, Immediate(1));
3589   j(no_overflow, &done, Label::kNear);
3590
3591   subp(rsp, Immediate(kDoubleSize));
3592   movsd(MemOperand(rsp, 0), input_reg);
3593   SlowTruncateToI(result_reg, rsp, 0);
3594   addp(rsp, Immediate(kDoubleSize));
3595
3596   bind(&done);
3597   // Keep our invariant that the upper 32 bits are zero.
3598   movl(result_reg, result_reg);
3599 }
3600
3601
3602 void MacroAssembler::DoubleToI(Register result_reg,
3603                                XMMRegister input_reg,
3604                                XMMRegister scratch,
3605                                MinusZeroMode minus_zero_mode,
3606                                Label* conversion_failed,
3607                                Label::Distance dst) {
3608   cvttsd2si(result_reg, input_reg);
3609   Cvtlsi2sd(xmm0, result_reg);
3610   ucomisd(xmm0, input_reg);
3611   j(not_equal, conversion_failed, dst);
3612   j(parity_even, conversion_failed, dst);  // NaN.
3613   if (minus_zero_mode == FAIL_ON_MINUS_ZERO) {
3614     Label done;
3615     // The integer converted back is equal to the original. We
3616     // only have to test if we got -0 as an input.
3617     testl(result_reg, result_reg);
3618     j(not_zero, &done, Label::kNear);
3619     movmskpd(result_reg, input_reg);
3620     // Bit 0 contains the sign of the double in input_reg.
3621     // If input was positive, we are ok and return 0, otherwise
3622     // jump to conversion_failed.
3623     andl(result_reg, Immediate(1));
3624     j(not_zero, conversion_failed, dst);
3625     bind(&done);
3626   }
3627 }
3628
3629
3630 void MacroAssembler::TaggedToI(Register result_reg,
3631                                Register input_reg,
3632                                XMMRegister temp,
3633                                MinusZeroMode minus_zero_mode,
3634                                Label* lost_precision,
3635                                Label::Distance dst) {
3636   Label done;
3637   ASSERT(!temp.is(xmm0));
3638
3639   // Heap number map check.
3640   CompareRoot(FieldOperand(input_reg, HeapObject::kMapOffset),
3641               Heap::kHeapNumberMapRootIndex);
3642   j(not_equal, lost_precision, dst);
3643
3644   movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
3645   cvttsd2si(result_reg, xmm0);
3646   Cvtlsi2sd(temp, result_reg);
3647   ucomisd(xmm0, temp);
3648   RecordComment("Deferred TaggedToI: lost precision");
3649   j(not_equal, lost_precision, dst);
3650   RecordComment("Deferred TaggedToI: NaN");
3651   j(parity_even, lost_precision, dst);  // NaN.
3652   if (minus_zero_mode == FAIL_ON_MINUS_ZERO) {
3653     testl(result_reg, result_reg);
3654     j(not_zero, &done, Label::kNear);
3655     movmskpd(result_reg, xmm0);
3656     andl(result_reg, Immediate(1));
3657     j(not_zero, lost_precision, dst);
3658   }
3659   bind(&done);
3660 }
3661
3662
3663 void MacroAssembler::LoadInstanceDescriptors(Register map,
3664                                              Register descriptors) {
3665   movp(descriptors, FieldOperand(map, Map::kDescriptorsOffset));
3666 }
3667
3668
3669 void MacroAssembler::NumberOfOwnDescriptors(Register dst, Register map) {
3670   movl(dst, FieldOperand(map, Map::kBitField3Offset));
3671   DecodeField<Map::NumberOfOwnDescriptorsBits>(dst);
3672 }
3673
3674
3675 void MacroAssembler::EnumLength(Register dst, Register map) {
3676   STATIC_ASSERT(Map::EnumLengthBits::kShift == 0);
3677   movl(dst, FieldOperand(map, Map::kBitField3Offset));
3678   andl(dst, Immediate(Map::EnumLengthBits::kMask));
3679   Integer32ToSmi(dst, dst);
3680 }
3681
3682
3683 void MacroAssembler::DispatchMap(Register obj,
3684                                  Register unused,
3685                                  Handle<Map> map,
3686                                  Handle<Code> success,
3687                                  SmiCheckType smi_check_type) {
3688   Label fail;
3689   if (smi_check_type == DO_SMI_CHECK) {
3690     JumpIfSmi(obj, &fail);
3691   }
3692   Cmp(FieldOperand(obj, HeapObject::kMapOffset), map);
3693   j(equal, success, RelocInfo::CODE_TARGET);
3694
3695   bind(&fail);
3696 }
3697
3698
3699 void MacroAssembler::AssertNumber(Register object) {
3700   if (emit_debug_code()) {
3701     Label ok;
3702     Condition is_smi = CheckSmi(object);
3703     j(is_smi, &ok, Label::kNear);
3704     Cmp(FieldOperand(object, HeapObject::kMapOffset),
3705         isolate()->factory()->heap_number_map());
3706     Check(equal, kOperandIsNotANumber);
3707     bind(&ok);
3708   }
3709 }
3710
3711
3712 void MacroAssembler::AssertNotSmi(Register object) {
3713   if (emit_debug_code()) {
3714     Condition is_smi = CheckSmi(object);
3715     Check(NegateCondition(is_smi), kOperandIsASmi);
3716   }
3717 }
3718
3719
3720 void MacroAssembler::AssertSmi(Register object) {
3721   if (emit_debug_code()) {
3722     Condition is_smi = CheckSmi(object);
3723     Check(is_smi, kOperandIsNotASmi);
3724   }
3725 }
3726
3727
3728 void MacroAssembler::AssertSmi(const Operand& object) {
3729   if (emit_debug_code()) {
3730     Condition is_smi = CheckSmi(object);
3731     Check(is_smi, kOperandIsNotASmi);
3732   }
3733 }
3734
3735
3736 void MacroAssembler::AssertZeroExtended(Register int32_register) {
3737   if (emit_debug_code()) {
3738     ASSERT(!int32_register.is(kScratchRegister));
3739     movq(kScratchRegister, V8_INT64_C(0x0000000100000000));
3740     cmpq(kScratchRegister, int32_register);
3741     Check(above_equal, k32BitValueInRegisterIsNotZeroExtended);
3742   }
3743 }
3744
3745
3746 void MacroAssembler::AssertString(Register object) {
3747   if (emit_debug_code()) {
3748     testb(object, Immediate(kSmiTagMask));
3749     Check(not_equal, kOperandIsASmiAndNotAString);
3750     Push(object);
3751     movp(object, FieldOperand(object, HeapObject::kMapOffset));
3752     CmpInstanceType(object, FIRST_NONSTRING_TYPE);
3753     Pop(object);
3754     Check(below, kOperandIsNotAString);
3755   }
3756 }
3757
3758
3759 void MacroAssembler::AssertName(Register object) {
3760   if (emit_debug_code()) {
3761     testb(object, Immediate(kSmiTagMask));
3762     Check(not_equal, kOperandIsASmiAndNotAName);
3763     Push(object);
3764     movp(object, FieldOperand(object, HeapObject::kMapOffset));
3765     CmpInstanceType(object, LAST_NAME_TYPE);
3766     Pop(object);
3767     Check(below_equal, kOperandIsNotAName);
3768   }
3769 }
3770
3771
3772 void MacroAssembler::AssertUndefinedOrAllocationSite(Register object) {
3773   if (emit_debug_code()) {
3774     Label done_checking;
3775     AssertNotSmi(object);
3776     Cmp(object, isolate()->factory()->undefined_value());
3777     j(equal, &done_checking);
3778     Cmp(FieldOperand(object, 0), isolate()->factory()->allocation_site_map());
3779     Assert(equal, kExpectedUndefinedOrCell);
3780     bind(&done_checking);
3781   }
3782 }
3783
3784
3785 void MacroAssembler::AssertRootValue(Register src,
3786                                      Heap::RootListIndex root_value_index,
3787                                      BailoutReason reason) {
3788   if (emit_debug_code()) {
3789     ASSERT(!src.is(kScratchRegister));
3790     LoadRoot(kScratchRegister, root_value_index);
3791     cmpp(src, kScratchRegister);
3792     Check(equal, reason);
3793   }
3794 }
3795
3796
3797
3798 Condition MacroAssembler::IsObjectStringType(Register heap_object,
3799                                              Register map,
3800                                              Register instance_type) {
3801   movp(map, FieldOperand(heap_object, HeapObject::kMapOffset));
3802   movzxbl(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
3803   STATIC_ASSERT(kNotStringTag != 0);
3804   testb(instance_type, Immediate(kIsNotStringMask));
3805   return zero;
3806 }
3807
3808
3809 Condition MacroAssembler::IsObjectNameType(Register heap_object,
3810                                            Register map,
3811                                            Register instance_type) {
3812   movp(map, FieldOperand(heap_object, HeapObject::kMapOffset));
3813   movzxbl(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
3814   cmpb(instance_type, Immediate(static_cast<uint8_t>(LAST_NAME_TYPE)));
3815   return below_equal;
3816 }
3817
3818
3819 void MacroAssembler::TryGetFunctionPrototype(Register function,
3820                                              Register result,
3821                                              Label* miss,
3822                                              bool miss_on_bound_function) {
3823   // Check that the receiver isn't a smi.
3824   testl(function, Immediate(kSmiTagMask));
3825   j(zero, miss);
3826
3827   // Check that the function really is a function.
3828   CmpObjectType(function, JS_FUNCTION_TYPE, result);
3829   j(not_equal, miss);
3830
3831   if (miss_on_bound_function) {
3832     movp(kScratchRegister,
3833          FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
3834     // It's not smi-tagged (stored in the top half of a smi-tagged 8-byte
3835     // field).
3836     TestBitSharedFunctionInfoSpecialField(kScratchRegister,
3837         SharedFunctionInfo::kCompilerHintsOffset,
3838         SharedFunctionInfo::kBoundFunction);
3839     j(not_zero, miss);
3840   }
3841
3842   // Make sure that the function has an instance prototype.
3843   Label non_instance;
3844   testb(FieldOperand(result, Map::kBitFieldOffset),
3845         Immediate(1 << Map::kHasNonInstancePrototype));
3846   j(not_zero, &non_instance, Label::kNear);
3847
3848   // Get the prototype or initial map from the function.
3849   movp(result,
3850        FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
3851
3852   // If the prototype or initial map is the hole, don't return it and
3853   // simply miss the cache instead. This will allow us to allocate a
3854   // prototype object on-demand in the runtime system.
3855   CompareRoot(result, Heap::kTheHoleValueRootIndex);
3856   j(equal, miss);
3857
3858   // If the function does not have an initial map, we're done.
3859   Label done;
3860   CmpObjectType(result, MAP_TYPE, kScratchRegister);
3861   j(not_equal, &done, Label::kNear);
3862
3863   // Get the prototype from the initial map.
3864   movp(result, FieldOperand(result, Map::kPrototypeOffset));
3865   jmp(&done, Label::kNear);
3866
3867   // Non-instance prototype: Fetch prototype from constructor field
3868   // in initial map.
3869   bind(&non_instance);
3870   movp(result, FieldOperand(result, Map::kConstructorOffset));
3871
3872   // All done.
3873   bind(&done);
3874 }
3875
3876
3877 void MacroAssembler::SetCounter(StatsCounter* counter, int value) {
3878   if (FLAG_native_code_counters && counter->Enabled()) {
3879     Operand counter_operand = ExternalOperand(ExternalReference(counter));
3880     movl(counter_operand, Immediate(value));
3881   }
3882 }
3883
3884
3885 void MacroAssembler::IncrementCounter(StatsCounter* counter, int value) {
3886   ASSERT(value > 0);
3887   if (FLAG_native_code_counters && counter->Enabled()) {
3888     Operand counter_operand = ExternalOperand(ExternalReference(counter));
3889     if (value == 1) {
3890       incl(counter_operand);
3891     } else {
3892       addl(counter_operand, Immediate(value));
3893     }
3894   }
3895 }
3896
3897
3898 void MacroAssembler::DecrementCounter(StatsCounter* counter, int value) {
3899   ASSERT(value > 0);
3900   if (FLAG_native_code_counters && counter->Enabled()) {
3901     Operand counter_operand = ExternalOperand(ExternalReference(counter));
3902     if (value == 1) {
3903       decl(counter_operand);
3904     } else {
3905       subl(counter_operand, Immediate(value));
3906     }
3907   }
3908 }
3909
3910
3911 void MacroAssembler::DebugBreak() {
3912   Set(rax, 0);  // No arguments.
3913   LoadAddress(rbx, ExternalReference(Runtime::kDebugBreak, isolate()));
3914   CEntryStub ces(isolate(), 1);
3915   ASSERT(AllowThisStubCall(&ces));
3916   Call(ces.GetCode(), RelocInfo::DEBUG_BREAK);
3917 }
3918
3919
3920 void MacroAssembler::InvokeCode(Register code,
3921                                 const ParameterCount& expected,
3922                                 const ParameterCount& actual,
3923                                 InvokeFlag flag,
3924                                 const CallWrapper& call_wrapper) {
3925   // You can't call a function without a valid frame.
3926   ASSERT(flag == JUMP_FUNCTION || has_frame());
3927
3928   Label done;
3929   bool definitely_mismatches = false;
3930   InvokePrologue(expected,
3931                  actual,
3932                  Handle<Code>::null(),
3933                  code,
3934                  &done,
3935                  &definitely_mismatches,
3936                  flag,
3937                  Label::kNear,
3938                  call_wrapper);
3939   if (!definitely_mismatches) {
3940     if (flag == CALL_FUNCTION) {
3941       call_wrapper.BeforeCall(CallSize(code));
3942       call(code);
3943       call_wrapper.AfterCall();
3944     } else {
3945       ASSERT(flag == JUMP_FUNCTION);
3946       jmp(code);
3947     }
3948     bind(&done);
3949   }
3950 }
3951
3952
3953 void MacroAssembler::InvokeFunction(Register function,
3954                                     const ParameterCount& actual,
3955                                     InvokeFlag flag,
3956                                     const CallWrapper& call_wrapper) {
3957   // You can't call a function without a valid frame.
3958   ASSERT(flag == JUMP_FUNCTION || has_frame());
3959
3960   ASSERT(function.is(rdi));
3961   movp(rdx, FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
3962   movp(rsi, FieldOperand(function, JSFunction::kContextOffset));
3963   LoadSharedFunctionInfoSpecialField(rbx, rdx,
3964       SharedFunctionInfo::kFormalParameterCountOffset);
3965   // Advances rdx to the end of the Code object header, to the start of
3966   // the executable code.
3967   movp(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset));
3968
3969   ParameterCount expected(rbx);
3970   InvokeCode(rdx, expected, actual, flag, call_wrapper);
3971 }
3972
3973
3974 void MacroAssembler::InvokeFunction(Register function,
3975                                     const ParameterCount& expected,
3976                                     const ParameterCount& actual,
3977                                     InvokeFlag flag,
3978                                     const CallWrapper& call_wrapper) {
3979   // You can't call a function without a valid frame.
3980   ASSERT(flag == JUMP_FUNCTION || has_frame());
3981
3982   ASSERT(function.is(rdi));
3983   movp(rsi, FieldOperand(function, JSFunction::kContextOffset));
3984   // Advances rdx to the end of the Code object header, to the start of
3985   // the executable code.
3986   movp(rdx, FieldOperand(rdi, JSFunction::kCodeEntryOffset));
3987
3988   InvokeCode(rdx, expected, actual, flag, call_wrapper);
3989 }
3990
3991
3992 void MacroAssembler::InvokeFunction(Handle<JSFunction> function,
3993                                     const ParameterCount& expected,
3994                                     const ParameterCount& actual,
3995                                     InvokeFlag flag,
3996                                     const CallWrapper& call_wrapper) {
3997   Move(rdi, function);
3998   InvokeFunction(rdi, expected, actual, flag, call_wrapper);
3999 }
4000
4001
4002 void MacroAssembler::InvokePrologue(const ParameterCount& expected,
4003                                     const ParameterCount& actual,
4004                                     Handle<Code> code_constant,
4005                                     Register code_register,
4006                                     Label* done,
4007                                     bool* definitely_mismatches,
4008                                     InvokeFlag flag,
4009                                     Label::Distance near_jump,
4010                                     const CallWrapper& call_wrapper) {
4011   bool definitely_matches = false;
4012   *definitely_mismatches = false;
4013   Label invoke;
4014   if (expected.is_immediate()) {
4015     ASSERT(actual.is_immediate());
4016     if (expected.immediate() == actual.immediate()) {
4017       definitely_matches = true;
4018     } else {
4019       Set(rax, actual.immediate());
4020       if (expected.immediate() ==
4021               SharedFunctionInfo::kDontAdaptArgumentsSentinel) {
4022         // Don't worry about adapting arguments for built-ins that
4023         // don't want that done. Skip adaption code by making it look
4024         // like we have a match between expected and actual number of
4025         // arguments.
4026         definitely_matches = true;
4027       } else {
4028         *definitely_mismatches = true;
4029         Set(rbx, expected.immediate());
4030       }
4031     }
4032   } else {
4033     if (actual.is_immediate()) {
4034       // Expected is in register, actual is immediate. This is the
4035       // case when we invoke function values without going through the
4036       // IC mechanism.
4037       cmpp(expected.reg(), Immediate(actual.immediate()));
4038       j(equal, &invoke, Label::kNear);
4039       ASSERT(expected.reg().is(rbx));
4040       Set(rax, actual.immediate());
4041     } else if (!expected.reg().is(actual.reg())) {
4042       // Both expected and actual are in (different) registers. This
4043       // is the case when we invoke functions using call and apply.
4044       cmpp(expected.reg(), actual.reg());
4045       j(equal, &invoke, Label::kNear);
4046       ASSERT(actual.reg().is(rax));
4047       ASSERT(expected.reg().is(rbx));
4048     }
4049   }
4050
4051   if (!definitely_matches) {
4052     Handle<Code> adaptor = isolate()->builtins()->ArgumentsAdaptorTrampoline();
4053     if (!code_constant.is_null()) {
4054       Move(rdx, code_constant, RelocInfo::EMBEDDED_OBJECT);
4055       addp(rdx, Immediate(Code::kHeaderSize - kHeapObjectTag));
4056     } else if (!code_register.is(rdx)) {
4057       movp(rdx, code_register);
4058     }
4059
4060     if (flag == CALL_FUNCTION) {
4061       call_wrapper.BeforeCall(CallSize(adaptor));
4062       Call(adaptor, RelocInfo::CODE_TARGET);
4063       call_wrapper.AfterCall();
4064       if (!*definitely_mismatches) {
4065         jmp(done, near_jump);
4066       }
4067     } else {
4068       Jump(adaptor, RelocInfo::CODE_TARGET);
4069     }
4070     bind(&invoke);
4071   }
4072 }
4073
4074
4075 void MacroAssembler::StubPrologue() {
4076     pushq(rbp);  // Caller's frame pointer.
4077     movp(rbp, rsp);
4078     Push(rsi);  // Callee's context.
4079     Push(Smi::FromInt(StackFrame::STUB));
4080 }
4081
4082
4083 void MacroAssembler::Prologue(bool code_pre_aging) {
4084   PredictableCodeSizeScope predictible_code_size_scope(this,
4085       kNoCodeAgeSequenceLength);
4086   if (code_pre_aging) {
4087       // Pre-age the code.
4088     Call(isolate()->builtins()->MarkCodeAsExecutedOnce(),
4089          RelocInfo::CODE_AGE_SEQUENCE);
4090     Nop(kNoCodeAgeSequenceLength - Assembler::kShortCallInstructionLength);
4091   } else {
4092     pushq(rbp);  // Caller's frame pointer.
4093     movp(rbp, rsp);
4094     Push(rsi);  // Callee's context.
4095     Push(rdi);  // Callee's JS function.
4096   }
4097 }
4098
4099
4100 void MacroAssembler::EnterFrame(StackFrame::Type type) {
4101   pushq(rbp);
4102   movp(rbp, rsp);
4103   Push(rsi);  // Context.
4104   Push(Smi::FromInt(type));
4105   Move(kScratchRegister, CodeObject(), RelocInfo::EMBEDDED_OBJECT);
4106   Push(kScratchRegister);
4107   if (emit_debug_code()) {
4108     Move(kScratchRegister,
4109          isolate()->factory()->undefined_value(),
4110          RelocInfo::EMBEDDED_OBJECT);
4111     cmpp(Operand(rsp, 0), kScratchRegister);
4112     Check(not_equal, kCodeObjectNotProperlyPatched);
4113   }
4114 }
4115
4116
4117 void MacroAssembler::LeaveFrame(StackFrame::Type type) {
4118   if (emit_debug_code()) {
4119     Move(kScratchRegister, Smi::FromInt(type));
4120     cmpp(Operand(rbp, StandardFrameConstants::kMarkerOffset), kScratchRegister);
4121     Check(equal, kStackFrameTypesMustMatch);
4122   }
4123   movp(rsp, rbp);
4124   popq(rbp);
4125 }
4126
4127
4128 void MacroAssembler::EnterExitFramePrologue(bool save_rax) {
4129   // Set up the frame structure on the stack.
4130   // All constants are relative to the frame pointer of the exit frame.
4131   ASSERT(ExitFrameConstants::kCallerSPDisplacement ==
4132          kFPOnStackSize + kPCOnStackSize);
4133   ASSERT(ExitFrameConstants::kCallerPCOffset == kFPOnStackSize);
4134   ASSERT(ExitFrameConstants::kCallerFPOffset == 0 * kPointerSize);
4135   pushq(rbp);
4136   movp(rbp, rsp);
4137
4138   // Reserve room for entry stack pointer and push the code object.
4139   ASSERT(ExitFrameConstants::kSPOffset == -1 * kPointerSize);
4140   Push(Immediate(0));  // Saved entry sp, patched before call.
4141   Move(kScratchRegister, CodeObject(), RelocInfo::EMBEDDED_OBJECT);
4142   Push(kScratchRegister);  // Accessed from EditFrame::code_slot.
4143
4144   // Save the frame pointer and the context in top.
4145   if (save_rax) {
4146     movp(r14, rax);  // Backup rax in callee-save register.
4147   }
4148
4149   Store(ExternalReference(Isolate::kCEntryFPAddress, isolate()), rbp);
4150   Store(ExternalReference(Isolate::kContextAddress, isolate()), rsi);
4151 }
4152
4153
4154 void MacroAssembler::EnterExitFrameEpilogue(int arg_stack_space,
4155                                             bool save_doubles) {
4156 #ifdef _WIN64
4157   const int kShadowSpace = 4;
4158   arg_stack_space += kShadowSpace;
4159 #endif
4160   // Optionally save all XMM registers.
4161   if (save_doubles) {
4162     int space = XMMRegister::kMaxNumAllocatableRegisters * kSIMD128Size +
4163         arg_stack_space * kRegisterSize;
4164     subp(rsp, Immediate(space));
4165     int offset = -2 * kPointerSize;
4166     for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); i++) {
4167       XMMRegister reg = XMMRegister::FromAllocationIndex(i);
4168       movups(Operand(rbp, offset - ((i + 1) * kSIMD128Size)), reg);
4169     }
4170   } else if (arg_stack_space > 0) {
4171     subp(rsp, Immediate(arg_stack_space * kRegisterSize));
4172   }
4173
4174   // Get the required frame alignment for the OS.
4175   const int kFrameAlignment = OS::ActivationFrameAlignment();
4176   if (kFrameAlignment > 0) {
4177     ASSERT(IsPowerOf2(kFrameAlignment));
4178     ASSERT(is_int8(kFrameAlignment));
4179     andp(rsp, Immediate(-kFrameAlignment));
4180   }
4181
4182   // Patch the saved entry sp.
4183   movp(Operand(rbp, ExitFrameConstants::kSPOffset), rsp);
4184 }
4185
4186
4187 void MacroAssembler::EnterExitFrame(int arg_stack_space, bool save_doubles) {
4188   EnterExitFramePrologue(true);
4189
4190   // Set up argv in callee-saved register r15. It is reused in LeaveExitFrame,
4191   // so it must be retained across the C-call.
4192   int offset = StandardFrameConstants::kCallerSPOffset - kPointerSize;
4193   leap(r15, Operand(rbp, r14, times_pointer_size, offset));
4194
4195   EnterExitFrameEpilogue(arg_stack_space, save_doubles);
4196 }
4197
4198
4199 void MacroAssembler::EnterApiExitFrame(int arg_stack_space) {
4200   EnterExitFramePrologue(false);
4201   EnterExitFrameEpilogue(arg_stack_space, false);
4202 }
4203
4204
4205 void MacroAssembler::LeaveExitFrame(bool save_doubles) {
4206   // Registers:
4207   // r15 : argv
4208   if (save_doubles) {
4209     int offset = -2 * kPointerSize;
4210     for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); i++) {
4211       XMMRegister reg = XMMRegister::FromAllocationIndex(i);
4212       movups(reg, Operand(rbp, offset - ((i + 1) * kSIMD128Size)));
4213     }
4214   }
4215   // Get the return address from the stack and restore the frame pointer.
4216   movp(rcx, Operand(rbp, kFPOnStackSize));
4217   movp(rbp, Operand(rbp, 0 * kPointerSize));
4218
4219   // Drop everything up to and including the arguments and the receiver
4220   // from the caller stack.
4221   leap(rsp, Operand(r15, 1 * kPointerSize));
4222
4223   PushReturnAddressFrom(rcx);
4224
4225   LeaveExitFrameEpilogue(true);
4226 }
4227
4228
4229 void MacroAssembler::LeaveApiExitFrame(bool restore_context) {
4230   movp(rsp, rbp);
4231   popq(rbp);
4232
4233   LeaveExitFrameEpilogue(restore_context);
4234 }
4235
4236
4237 void MacroAssembler::LeaveExitFrameEpilogue(bool restore_context) {
4238   // Restore current context from top and clear it in debug mode.
4239   ExternalReference context_address(Isolate::kContextAddress, isolate());
4240   Operand context_operand = ExternalOperand(context_address);
4241   if (restore_context) {
4242     movp(rsi, context_operand);
4243   }
4244 #ifdef DEBUG
4245   movp(context_operand, Immediate(0));
4246 #endif
4247
4248   // Clear the top frame.
4249   ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress,
4250                                        isolate());
4251   Operand c_entry_fp_operand = ExternalOperand(c_entry_fp_address);
4252   movp(c_entry_fp_operand, Immediate(0));
4253 }
4254
4255
4256 void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
4257                                             Register scratch,
4258                                             Label* miss) {
4259   Label same_contexts;
4260
4261   ASSERT(!holder_reg.is(scratch));
4262   ASSERT(!scratch.is(kScratchRegister));
4263   // Load current lexical context from the stack frame.
4264   movp(scratch, Operand(rbp, StandardFrameConstants::kContextOffset));
4265
4266   // When generating debug code, make sure the lexical context is set.
4267   if (emit_debug_code()) {
4268     cmpp(scratch, Immediate(0));
4269     Check(not_equal, kWeShouldNotHaveAnEmptyLexicalContext);
4270   }
4271   // Load the native context of the current context.
4272   int offset =
4273       Context::kHeaderSize + Context::GLOBAL_OBJECT_INDEX * kPointerSize;
4274   movp(scratch, FieldOperand(scratch, offset));
4275   movp(scratch, FieldOperand(scratch, GlobalObject::kNativeContextOffset));
4276
4277   // Check the context is a native context.
4278   if (emit_debug_code()) {
4279     Cmp(FieldOperand(scratch, HeapObject::kMapOffset),
4280         isolate()->factory()->native_context_map());
4281     Check(equal, kJSGlobalObjectNativeContextShouldBeANativeContext);
4282   }
4283
4284   // Check if both contexts are the same.
4285   cmpp(scratch, FieldOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
4286   j(equal, &same_contexts);
4287
4288   // Compare security tokens.
4289   // Check that the security token in the calling global object is
4290   // compatible with the security token in the receiving global
4291   // object.
4292
4293   // Check the context is a native context.
4294   if (emit_debug_code()) {
4295     // Preserve original value of holder_reg.
4296     Push(holder_reg);
4297     movp(holder_reg,
4298          FieldOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
4299     CompareRoot(holder_reg, Heap::kNullValueRootIndex);
4300     Check(not_equal, kJSGlobalProxyContextShouldNotBeNull);
4301
4302     // Read the first word and compare to native_context_map(),
4303     movp(holder_reg, FieldOperand(holder_reg, HeapObject::kMapOffset));
4304     CompareRoot(holder_reg, Heap::kNativeContextMapRootIndex);
4305     Check(equal, kJSGlobalObjectNativeContextShouldBeANativeContext);
4306     Pop(holder_reg);
4307   }
4308
4309   movp(kScratchRegister,
4310        FieldOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
4311   int token_offset =
4312       Context::kHeaderSize + Context::SECURITY_TOKEN_INDEX * kPointerSize;
4313   movp(scratch, FieldOperand(scratch, token_offset));
4314   cmpp(scratch, FieldOperand(kScratchRegister, token_offset));
4315   j(not_equal, miss);
4316
4317   bind(&same_contexts);
4318 }
4319
4320
4321 // Compute the hash code from the untagged key.  This must be kept in sync with
4322 // ComputeIntegerHash in utils.h and KeyedLoadGenericElementStub in
4323 // code-stub-hydrogen.cc
4324 void MacroAssembler::GetNumberHash(Register r0, Register scratch) {
4325   // First of all we assign the hash seed to scratch.
4326   LoadRoot(scratch, Heap::kHashSeedRootIndex);
4327   SmiToInteger32(scratch, scratch);
4328
4329   // Xor original key with a seed.
4330   xorl(r0, scratch);
4331
4332   // Compute the hash code from the untagged key.  This must be kept in sync
4333   // with ComputeIntegerHash in utils.h.
4334   //
4335   // hash = ~hash + (hash << 15);
4336   movl(scratch, r0);
4337   notl(r0);
4338   shll(scratch, Immediate(15));
4339   addl(r0, scratch);
4340   // hash = hash ^ (hash >> 12);
4341   movl(scratch, r0);
4342   shrl(scratch, Immediate(12));
4343   xorl(r0, scratch);
4344   // hash = hash + (hash << 2);
4345   leal(r0, Operand(r0, r0, times_4, 0));
4346   // hash = hash ^ (hash >> 4);
4347   movl(scratch, r0);
4348   shrl(scratch, Immediate(4));
4349   xorl(r0, scratch);
4350   // hash = hash * 2057;
4351   imull(r0, r0, Immediate(2057));
4352   // hash = hash ^ (hash >> 16);
4353   movl(scratch, r0);
4354   shrl(scratch, Immediate(16));
4355   xorl(r0, scratch);
4356 }
4357
4358
4359
4360 void MacroAssembler::LoadFromNumberDictionary(Label* miss,
4361                                               Register elements,
4362                                               Register key,
4363                                               Register r0,
4364                                               Register r1,
4365                                               Register r2,
4366                                               Register result) {
4367   // Register use:
4368   //
4369   // elements - holds the slow-case elements of the receiver on entry.
4370   //            Unchanged unless 'result' is the same register.
4371   //
4372   // key      - holds the smi key on entry.
4373   //            Unchanged unless 'result' is the same register.
4374   //
4375   // Scratch registers:
4376   //
4377   // r0 - holds the untagged key on entry and holds the hash once computed.
4378   //
4379   // r1 - used to hold the capacity mask of the dictionary
4380   //
4381   // r2 - used for the index into the dictionary.
4382   //
4383   // result - holds the result on exit if the load succeeded.
4384   //          Allowed to be the same as 'key' or 'result'.
4385   //          Unchanged on bailout so 'key' or 'result' can be used
4386   //          in further computation.
4387
4388   Label done;
4389
4390   GetNumberHash(r0, r1);
4391
4392   // Compute capacity mask.
4393   SmiToInteger32(r1, FieldOperand(elements,
4394                                   SeededNumberDictionary::kCapacityOffset));
4395   decl(r1);
4396
4397   // Generate an unrolled loop that performs a few probes before giving up.
4398   for (int i = 0; i < kNumberDictionaryProbes; i++) {
4399     // Use r2 for index calculations and keep the hash intact in r0.
4400     movp(r2, r0);
4401     // Compute the masked index: (hash + i + i * i) & mask.
4402     if (i > 0) {
4403       addl(r2, Immediate(SeededNumberDictionary::GetProbeOffset(i)));
4404     }
4405     andp(r2, r1);
4406
4407     // Scale the index by multiplying by the entry size.
4408     ASSERT(SeededNumberDictionary::kEntrySize == 3);
4409     leap(r2, Operand(r2, r2, times_2, 0));  // r2 = r2 * 3
4410
4411     // Check if the key matches.
4412     cmpp(key, FieldOperand(elements,
4413                            r2,
4414                            times_pointer_size,
4415                            SeededNumberDictionary::kElementsStartOffset));
4416     if (i != (kNumberDictionaryProbes - 1)) {
4417       j(equal, &done);
4418     } else {
4419       j(not_equal, miss);
4420     }
4421   }
4422
4423   bind(&done);
4424   // Check that the value is a normal propety.
4425   const int kDetailsOffset =
4426       SeededNumberDictionary::kElementsStartOffset + 2 * kPointerSize;
4427   ASSERT_EQ(NORMAL, 0);
4428   Test(FieldOperand(elements, r2, times_pointer_size, kDetailsOffset),
4429        Smi::FromInt(PropertyDetails::TypeField::kMask));
4430   j(not_zero, miss);
4431
4432   // Get the value at the masked, scaled index.
4433   const int kValueOffset =
4434       SeededNumberDictionary::kElementsStartOffset + kPointerSize;
4435   movp(result, FieldOperand(elements, r2, times_pointer_size, kValueOffset));
4436 }
4437
4438
4439 void MacroAssembler::LoadAllocationTopHelper(Register result,
4440                                              Register scratch,
4441                                              AllocationFlags flags) {
4442   ExternalReference allocation_top =
4443       AllocationUtils::GetAllocationTopReference(isolate(), flags);
4444
4445   // Just return if allocation top is already known.
4446   if ((flags & RESULT_CONTAINS_TOP) != 0) {
4447     // No use of scratch if allocation top is provided.
4448     ASSERT(!scratch.is_valid());
4449 #ifdef DEBUG
4450     // Assert that result actually contains top on entry.
4451     Operand top_operand = ExternalOperand(allocation_top);
4452     cmpp(result, top_operand);
4453     Check(equal, kUnexpectedAllocationTop);
4454 #endif
4455     return;
4456   }
4457
4458   // Move address of new object to result. Use scratch register if available,
4459   // and keep address in scratch until call to UpdateAllocationTopHelper.
4460   if (scratch.is_valid()) {
4461     LoadAddress(scratch, allocation_top);
4462     movp(result, Operand(scratch, 0));
4463   } else {
4464     Load(result, allocation_top);
4465   }
4466 }
4467
4468
4469 void MacroAssembler::MakeSureDoubleAlignedHelper(Register result,
4470                                                  Register scratch,
4471                                                  Label* gc_required,
4472                                                  AllocationFlags flags) {
4473   if (kPointerSize == kDoubleSize) {
4474     if (FLAG_debug_code) {
4475       testl(result, Immediate(kDoubleAlignmentMask));
4476       Check(zero, kAllocationIsNotDoubleAligned);
4477     }
4478   } else {
4479     // Align the next allocation. Storing the filler map without checking top
4480     // is safe in new-space because the limit of the heap is aligned there.
4481     ASSERT(kPointerSize * 2 == kDoubleSize);
4482     ASSERT((flags & PRETENURE_OLD_POINTER_SPACE) == 0);
4483     ASSERT(kPointerAlignment * 2 == kDoubleAlignment);
4484     // Make sure scratch is not clobbered by this function as it might be
4485     // used in UpdateAllocationTopHelper later.
4486     ASSERT(!scratch.is(kScratchRegister));
4487     Label aligned;
4488     testl(result, Immediate(kDoubleAlignmentMask));
4489     j(zero, &aligned, Label::kNear);
4490     if ((flags & PRETENURE_OLD_DATA_SPACE) != 0) {
4491       ExternalReference allocation_limit =
4492           AllocationUtils::GetAllocationLimitReference(isolate(), flags);
4493       cmpp(result, ExternalOperand(allocation_limit));
4494       j(above_equal, gc_required);
4495     }
4496     LoadRoot(kScratchRegister, Heap::kOnePointerFillerMapRootIndex);
4497     movp(Operand(result, 0), kScratchRegister);
4498     addp(result, Immediate(kDoubleSize / 2));
4499     bind(&aligned);
4500   }
4501 }
4502
4503
4504 void MacroAssembler::UpdateAllocationTopHelper(Register result_end,
4505                                                Register scratch,
4506                                                AllocationFlags flags) {
4507   if (emit_debug_code()) {
4508     testp(result_end, Immediate(kObjectAlignmentMask));
4509     Check(zero, kUnalignedAllocationInNewSpace);
4510   }
4511
4512   ExternalReference allocation_top =
4513       AllocationUtils::GetAllocationTopReference(isolate(), flags);
4514
4515   // Update new top.
4516   if (scratch.is_valid()) {
4517     // Scratch already contains address of allocation top.
4518     movp(Operand(scratch, 0), result_end);
4519   } else {
4520     Store(allocation_top, result_end);
4521   }
4522 }
4523
4524
4525 void MacroAssembler::Allocate(int object_size,
4526                               Register result,
4527                               Register result_end,
4528                               Register scratch,
4529                               Label* gc_required,
4530                               AllocationFlags flags) {
4531   ASSERT((flags & (RESULT_CONTAINS_TOP | SIZE_IN_WORDS)) == 0);
4532   ASSERT(object_size <= Page::kMaxRegularHeapObjectSize);
4533   if (!FLAG_inline_new) {
4534     if (emit_debug_code()) {
4535       // Trash the registers to simulate an allocation failure.
4536       movl(result, Immediate(0x7091));
4537       if (result_end.is_valid()) {
4538         movl(result_end, Immediate(0x7191));
4539       }
4540       if (scratch.is_valid()) {
4541         movl(scratch, Immediate(0x7291));
4542       }
4543     }
4544     jmp(gc_required);
4545     return;
4546   }
4547   ASSERT(!result.is(result_end));
4548
4549   // Load address of new object into result.
4550   LoadAllocationTopHelper(result, scratch, flags);
4551
4552   if ((flags & DOUBLE_ALIGNMENT) != 0) {
4553     MakeSureDoubleAlignedHelper(result, scratch, gc_required, flags);
4554   }
4555
4556   // Calculate new top and bail out if new space is exhausted.
4557   ExternalReference allocation_limit =
4558       AllocationUtils::GetAllocationLimitReference(isolate(), flags);
4559
4560   Register top_reg = result_end.is_valid() ? result_end : result;
4561
4562   if (!top_reg.is(result)) {
4563     movp(top_reg, result);
4564   }
4565   addp(top_reg, Immediate(object_size));
4566   j(carry, gc_required);
4567   Operand limit_operand = ExternalOperand(allocation_limit);
4568   cmpp(top_reg, limit_operand);
4569   j(above, gc_required);
4570
4571   // Update allocation top.
4572   UpdateAllocationTopHelper(top_reg, scratch, flags);
4573
4574   bool tag_result = (flags & TAG_OBJECT) != 0;
4575   if (top_reg.is(result)) {
4576     if (tag_result) {
4577       subp(result, Immediate(object_size - kHeapObjectTag));
4578     } else {
4579       subp(result, Immediate(object_size));
4580     }
4581   } else if (tag_result) {
4582     // Tag the result if requested.
4583     ASSERT(kHeapObjectTag == 1);
4584     incp(result);
4585   }
4586 }
4587
4588
4589 void MacroAssembler::Allocate(int header_size,
4590                               ScaleFactor element_size,
4591                               Register element_count,
4592                               Register result,
4593                               Register result_end,
4594                               Register scratch,
4595                               Label* gc_required,
4596                               AllocationFlags flags) {
4597   ASSERT((flags & SIZE_IN_WORDS) == 0);
4598   leap(result_end, Operand(element_count, element_size, header_size));
4599   Allocate(result_end, result, result_end, scratch, gc_required, flags);
4600 }
4601
4602
4603 void MacroAssembler::Allocate(Register object_size,
4604                               Register result,
4605                               Register result_end,
4606                               Register scratch,
4607                               Label* gc_required,
4608                               AllocationFlags flags) {
4609   ASSERT((flags & SIZE_IN_WORDS) == 0);
4610   if (!FLAG_inline_new) {
4611     if (emit_debug_code()) {
4612       // Trash the registers to simulate an allocation failure.
4613       movl(result, Immediate(0x7091));
4614       movl(result_end, Immediate(0x7191));
4615       if (scratch.is_valid()) {
4616         movl(scratch, Immediate(0x7291));
4617       }
4618       // object_size is left unchanged by this function.
4619     }
4620     jmp(gc_required);
4621     return;
4622   }
4623   ASSERT(!result.is(result_end));
4624
4625   // Load address of new object into result.
4626   LoadAllocationTopHelper(result, scratch, flags);
4627
4628   if ((flags & DOUBLE_ALIGNMENT) != 0) {
4629     MakeSureDoubleAlignedHelper(result, scratch, gc_required, flags);
4630   }
4631
4632   // Calculate new top and bail out if new space is exhausted.
4633   ExternalReference allocation_limit =
4634       AllocationUtils::GetAllocationLimitReference(isolate(), flags);
4635   if (!object_size.is(result_end)) {
4636     movp(result_end, object_size);
4637   }
4638   addp(result_end, result);
4639   j(carry, gc_required);
4640   Operand limit_operand = ExternalOperand(allocation_limit);
4641   cmpp(result_end, limit_operand);
4642   j(above, gc_required);
4643
4644   // Update allocation top.
4645   UpdateAllocationTopHelper(result_end, scratch, flags);
4646
4647   // Tag the result if requested.
4648   if ((flags & TAG_OBJECT) != 0) {
4649     addp(result, Immediate(kHeapObjectTag));
4650   }
4651 }
4652
4653
4654 void MacroAssembler::UndoAllocationInNewSpace(Register object) {
4655   ExternalReference new_space_allocation_top =
4656       ExternalReference::new_space_allocation_top_address(isolate());
4657
4658   // Make sure the object has no tag before resetting top.
4659   andp(object, Immediate(~kHeapObjectTagMask));
4660   Operand top_operand = ExternalOperand(new_space_allocation_top);
4661 #ifdef DEBUG
4662   cmpp(object, top_operand);
4663   Check(below, kUndoAllocationOfNonAllocatedMemory);
4664 #endif
4665   movp(top_operand, object);
4666 }
4667
4668
4669 void MacroAssembler::AllocateHeapNumber(Register result,
4670                                         Register scratch,
4671                                         Label* gc_required) {
4672   // Allocate heap number in new space.
4673   Allocate(HeapNumber::kSize, result, scratch, no_reg, gc_required, TAG_OBJECT);
4674
4675   // Set the map.
4676   LoadRoot(kScratchRegister, Heap::kHeapNumberMapRootIndex);
4677   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4678 }
4679
4680
4681 #define SIMD128_HEAP_ALLOCATE_FUNCTIONS(V) \
4682   V(Float32x4, float32x4)                  \
4683   V(Float64x2, float64x2)                  \
4684   V(Int32x4, int32x4)
4685
4686 #define DECLARE_SIMD_HEAP_ALLOCATE_FUNCTION(TYPE, type)                    \
4687 void MacroAssembler::Allocate##TYPE(Register result,                       \
4688                                     Register scratch1,                     \
4689                                     Register scratch2,                     \
4690                                     Register scratch3,                     \
4691                                     Label* gc_required) {                  \
4692   /* Allocate SIMD128 object. */                                           \
4693   Allocate(TYPE::kSize, result, scratch1, no_reg, gc_required, TAG_OBJECT);\
4694   Handle<Map> simd128_map(                                                 \
4695       isolate()->native_context()->type##_function()->initial_map());      \
4696   MoveHeapObject(kScratchRegister, simd128_map);                           \
4697   movp(FieldOperand(result, JSObject::kMapOffset),                         \
4698        kScratchRegister);                                                  \
4699   MoveHeapObject(kScratchRegister,                                         \
4700                  isolate()->factory()->empty_fixed_array());               \
4701   movp(FieldOperand(result, JSObject::kPropertiesOffset),                  \
4702        kScratchRegister);                                                  \
4703   movp(FieldOperand(result, JSObject::kElementsOffset),                    \
4704        kScratchRegister);                                                  \
4705   /* Allocate FixedTypedArray object. */                                   \
4706   Allocate(FixedTypedArrayBase::kDataOffset + k##TYPE##Size,               \
4707            scratch1, scratch2, no_reg, gc_required, TAG_OBJECT);           \
4708   MoveHeapObject(kScratchRegister,                                         \
4709                  isolate()->factory()->fixed_##type##_array_map());        \
4710   movp(FieldOperand(scratch1, FixedTypedArrayBase::kMapOffset),            \
4711        kScratchRegister);                                                  \
4712   movp(scratch3, Immediate(1));                                            \
4713   Integer32ToSmi(scratch2, scratch3);                                      \
4714   movp(FieldOperand(scratch1, FixedTypedArrayBase::kLengthOffset),         \
4715        scratch2);                                                          \
4716   /* Assign FixedTypedArray object to SIMD128 object. */                   \
4717   movp(FieldOperand(result, TYPE::kValueOffset), scratch1);                \
4718 }
4719
4720 SIMD128_HEAP_ALLOCATE_FUNCTIONS(DECLARE_SIMD_HEAP_ALLOCATE_FUNCTION)
4721
4722
4723 void MacroAssembler::AllocateTwoByteString(Register result,
4724                                            Register length,
4725                                            Register scratch1,
4726                                            Register scratch2,
4727                                            Register scratch3,
4728                                            Label* gc_required) {
4729   // Calculate the number of bytes needed for the characters in the string while
4730   // observing object alignment.
4731   const int kHeaderAlignment = SeqTwoByteString::kHeaderSize &
4732                                kObjectAlignmentMask;
4733   ASSERT(kShortSize == 2);
4734   // scratch1 = length * 2 + kObjectAlignmentMask.
4735   leap(scratch1, Operand(length, length, times_1, kObjectAlignmentMask +
4736                 kHeaderAlignment));
4737   andp(scratch1, Immediate(~kObjectAlignmentMask));
4738   if (kHeaderAlignment > 0) {
4739     subp(scratch1, Immediate(kHeaderAlignment));
4740   }
4741
4742   // Allocate two byte string in new space.
4743   Allocate(SeqTwoByteString::kHeaderSize,
4744            times_1,
4745            scratch1,
4746            result,
4747            scratch2,
4748            scratch3,
4749            gc_required,
4750            TAG_OBJECT);
4751
4752   // Set the map, length and hash field.
4753   LoadRoot(kScratchRegister, Heap::kStringMapRootIndex);
4754   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4755   Integer32ToSmi(scratch1, length);
4756   movp(FieldOperand(result, String::kLengthOffset), scratch1);
4757   movp(FieldOperand(result, String::kHashFieldOffset),
4758        Immediate(String::kEmptyHashField));
4759 }
4760
4761
4762 void MacroAssembler::AllocateAsciiString(Register result,
4763                                          Register length,
4764                                          Register scratch1,
4765                                          Register scratch2,
4766                                          Register scratch3,
4767                                          Label* gc_required) {
4768   // Calculate the number of bytes needed for the characters in the string while
4769   // observing object alignment.
4770   const int kHeaderAlignment = SeqOneByteString::kHeaderSize &
4771                                kObjectAlignmentMask;
4772   movl(scratch1, length);
4773   ASSERT(kCharSize == 1);
4774   addp(scratch1, Immediate(kObjectAlignmentMask + kHeaderAlignment));
4775   andp(scratch1, Immediate(~kObjectAlignmentMask));
4776   if (kHeaderAlignment > 0) {
4777     subp(scratch1, Immediate(kHeaderAlignment));
4778   }
4779
4780   // Allocate ASCII string in new space.
4781   Allocate(SeqOneByteString::kHeaderSize,
4782            times_1,
4783            scratch1,
4784            result,
4785            scratch2,
4786            scratch3,
4787            gc_required,
4788            TAG_OBJECT);
4789
4790   // Set the map, length and hash field.
4791   LoadRoot(kScratchRegister, Heap::kAsciiStringMapRootIndex);
4792   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4793   Integer32ToSmi(scratch1, length);
4794   movp(FieldOperand(result, String::kLengthOffset), scratch1);
4795   movp(FieldOperand(result, String::kHashFieldOffset),
4796        Immediate(String::kEmptyHashField));
4797 }
4798
4799
4800 void MacroAssembler::AllocateTwoByteConsString(Register result,
4801                                         Register scratch1,
4802                                         Register scratch2,
4803                                         Label* gc_required) {
4804   // Allocate heap number in new space.
4805   Allocate(ConsString::kSize, result, scratch1, scratch2, gc_required,
4806            TAG_OBJECT);
4807
4808   // Set the map. The other fields are left uninitialized.
4809   LoadRoot(kScratchRegister, Heap::kConsStringMapRootIndex);
4810   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4811 }
4812
4813
4814 void MacroAssembler::AllocateAsciiConsString(Register result,
4815                                              Register scratch1,
4816                                              Register scratch2,
4817                                              Label* gc_required) {
4818   Allocate(ConsString::kSize,
4819            result,
4820            scratch1,
4821            scratch2,
4822            gc_required,
4823            TAG_OBJECT);
4824
4825   // Set the map. The other fields are left uninitialized.
4826   LoadRoot(kScratchRegister, Heap::kConsAsciiStringMapRootIndex);
4827   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4828 }
4829
4830
4831 void MacroAssembler::AllocateTwoByteSlicedString(Register result,
4832                                           Register scratch1,
4833                                           Register scratch2,
4834                                           Label* gc_required) {
4835   // Allocate heap number in new space.
4836   Allocate(SlicedString::kSize, result, scratch1, scratch2, gc_required,
4837            TAG_OBJECT);
4838
4839   // Set the map. The other fields are left uninitialized.
4840   LoadRoot(kScratchRegister, Heap::kSlicedStringMapRootIndex);
4841   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4842 }
4843
4844
4845 void MacroAssembler::AllocateAsciiSlicedString(Register result,
4846                                                Register scratch1,
4847                                                Register scratch2,
4848                                                Label* gc_required) {
4849   // Allocate heap number in new space.
4850   Allocate(SlicedString::kSize, result, scratch1, scratch2, gc_required,
4851            TAG_OBJECT);
4852
4853   // Set the map. The other fields are left uninitialized.
4854   LoadRoot(kScratchRegister, Heap::kSlicedAsciiStringMapRootIndex);
4855   movp(FieldOperand(result, HeapObject::kMapOffset), kScratchRegister);
4856 }
4857
4858
4859 // Copy memory, byte-by-byte, from source to destination.  Not optimized for
4860 // long or aligned copies.  The contents of scratch and length are destroyed.
4861 // Destination is incremented by length, source, length and scratch are
4862 // clobbered.
4863 // A simpler loop is faster on small copies, but slower on large ones.
4864 // The cld() instruction must have been emitted, to set the direction flag(),
4865 // before calling this function.
4866 void MacroAssembler::CopyBytes(Register destination,
4867                                Register source,
4868                                Register length,
4869                                int min_length,
4870                                Register scratch) {
4871   ASSERT(min_length >= 0);
4872   if (emit_debug_code()) {
4873     cmpl(length, Immediate(min_length));
4874     Assert(greater_equal, kInvalidMinLength);
4875   }
4876   Label short_loop, len8, len16, len24, done, short_string;
4877
4878   const int kLongStringLimit = 4 * kPointerSize;
4879   if (min_length <= kLongStringLimit) {
4880     cmpl(length, Immediate(kPointerSize));
4881     j(below, &short_string, Label::kNear);
4882   }
4883
4884   ASSERT(source.is(rsi));
4885   ASSERT(destination.is(rdi));
4886   ASSERT(length.is(rcx));
4887
4888   if (min_length <= kLongStringLimit) {
4889     cmpl(length, Immediate(2 * kPointerSize));
4890     j(below_equal, &len8, Label::kNear);
4891     cmpl(length, Immediate(3 * kPointerSize));
4892     j(below_equal, &len16, Label::kNear);
4893     cmpl(length, Immediate(4 * kPointerSize));
4894     j(below_equal, &len24, Label::kNear);
4895   }
4896
4897   // Because source is 8-byte aligned in our uses of this function,
4898   // we keep source aligned for the rep movs operation by copying the odd bytes
4899   // at the end of the ranges.
4900   movp(scratch, length);
4901   shrl(length, Immediate(kPointerSizeLog2));
4902   repmovsp();
4903   // Move remaining bytes of length.
4904   andl(scratch, Immediate(kPointerSize - 1));
4905   movp(length, Operand(source, scratch, times_1, -kPointerSize));
4906   movp(Operand(destination, scratch, times_1, -kPointerSize), length);
4907   addp(destination, scratch);
4908
4909   if (min_length <= kLongStringLimit) {
4910     jmp(&done, Label::kNear);
4911     bind(&len24);
4912     movp(scratch, Operand(source, 2 * kPointerSize));
4913     movp(Operand(destination, 2 * kPointerSize), scratch);
4914     bind(&len16);
4915     movp(scratch, Operand(source, kPointerSize));
4916     movp(Operand(destination, kPointerSize), scratch);
4917     bind(&len8);
4918     movp(scratch, Operand(source, 0));
4919     movp(Operand(destination, 0), scratch);
4920     // Move remaining bytes of length.
4921     movp(scratch, Operand(source, length, times_1, -kPointerSize));
4922     movp(Operand(destination, length, times_1, -kPointerSize), scratch);
4923     addp(destination, length);
4924     jmp(&done, Label::kNear);
4925
4926     bind(&short_string);
4927     if (min_length == 0) {
4928       testl(length, length);
4929       j(zero, &done, Label::kNear);
4930     }
4931
4932     bind(&short_loop);
4933     movb(scratch, Operand(source, 0));
4934     movb(Operand(destination, 0), scratch);
4935     incp(source);
4936     incp(destination);
4937     decl(length);
4938     j(not_zero, &short_loop);
4939   }
4940
4941   bind(&done);
4942 }
4943
4944
4945 void MacroAssembler::InitializeFieldsWithFiller(Register start_offset,
4946                                                 Register end_offset,
4947                                                 Register filler) {
4948   Label loop, entry;
4949   jmp(&entry);
4950   bind(&loop);
4951   movp(Operand(start_offset, 0), filler);
4952   addp(start_offset, Immediate(kPointerSize));
4953   bind(&entry);
4954   cmpp(start_offset, end_offset);
4955   j(less, &loop);
4956 }
4957
4958
4959 void MacroAssembler::LoadContext(Register dst, int context_chain_length) {
4960   if (context_chain_length > 0) {
4961     // Move up the chain of contexts to the context containing the slot.
4962     movp(dst, Operand(rsi, Context::SlotOffset(Context::PREVIOUS_INDEX)));
4963     for (int i = 1; i < context_chain_length; i++) {
4964       movp(dst, Operand(dst, Context::SlotOffset(Context::PREVIOUS_INDEX)));
4965     }
4966   } else {
4967     // Slot is in the current function context.  Move it into the
4968     // destination register in case we store into it (the write barrier
4969     // cannot be allowed to destroy the context in rsi).
4970     movp(dst, rsi);
4971   }
4972
4973   // We should not have found a with context by walking the context
4974   // chain (i.e., the static scope chain and runtime context chain do
4975   // not agree).  A variable occurring in such a scope should have
4976   // slot type LOOKUP and not CONTEXT.
4977   if (emit_debug_code()) {
4978     CompareRoot(FieldOperand(dst, HeapObject::kMapOffset),
4979                 Heap::kWithContextMapRootIndex);
4980     Check(not_equal, kVariableResolvedToWithContext);
4981   }
4982 }
4983
4984
4985 void MacroAssembler::LoadTransitionedArrayMapConditional(
4986     ElementsKind expected_kind,
4987     ElementsKind transitioned_kind,
4988     Register map_in_out,
4989     Register scratch,
4990     Label* no_map_match) {
4991   // Load the global or builtins object from the current context.
4992   movp(scratch,
4993        Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
4994   movp(scratch, FieldOperand(scratch, GlobalObject::kNativeContextOffset));
4995
4996   // Check that the function's map is the same as the expected cached map.
4997   movp(scratch, Operand(scratch,
4998                         Context::SlotOffset(Context::JS_ARRAY_MAPS_INDEX)));
4999
5000   int offset = expected_kind * kPointerSize +
5001       FixedArrayBase::kHeaderSize;
5002   cmpp(map_in_out, FieldOperand(scratch, offset));
5003   j(not_equal, no_map_match);
5004
5005   // Use the transitioned cached map.
5006   offset = transitioned_kind * kPointerSize +
5007       FixedArrayBase::kHeaderSize;
5008   movp(map_in_out, FieldOperand(scratch, offset));
5009 }
5010
5011
5012 #ifdef _WIN64
5013 static const int kRegisterPassedArguments = 4;
5014 #else
5015 static const int kRegisterPassedArguments = 6;
5016 #endif
5017
5018 void MacroAssembler::LoadGlobalFunction(int index, Register function) {
5019   // Load the global or builtins object from the current context.
5020   movp(function,
5021        Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
5022   // Load the native context from the global or builtins object.
5023   movp(function, FieldOperand(function, GlobalObject::kNativeContextOffset));
5024   // Load the function from the native context.
5025   movp(function, Operand(function, Context::SlotOffset(index)));
5026 }
5027
5028
5029 void MacroAssembler::LoadGlobalFunctionInitialMap(Register function,
5030                                                   Register map) {
5031   // Load the initial map.  The global functions all have initial maps.
5032   movp(map, FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
5033   if (emit_debug_code()) {
5034     Label ok, fail;
5035     CheckMap(map, isolate()->factory()->meta_map(), &fail, DO_SMI_CHECK);
5036     jmp(&ok);
5037     bind(&fail);
5038     Abort(kGlobalFunctionsMustHaveInitialMap);
5039     bind(&ok);
5040   }
5041 }
5042
5043
5044 int MacroAssembler::ArgumentStackSlotsForCFunctionCall(int num_arguments) {
5045   // On Windows 64 stack slots are reserved by the caller for all arguments
5046   // including the ones passed in registers, and space is always allocated for
5047   // the four register arguments even if the function takes fewer than four
5048   // arguments.
5049   // On AMD64 ABI (Linux/Mac) the first six arguments are passed in registers
5050   // and the caller does not reserve stack slots for them.
5051   ASSERT(num_arguments >= 0);
5052 #ifdef _WIN64
5053   const int kMinimumStackSlots = kRegisterPassedArguments;
5054   if (num_arguments < kMinimumStackSlots) return kMinimumStackSlots;
5055   return num_arguments;
5056 #else
5057   if (num_arguments < kRegisterPassedArguments) return 0;
5058   return num_arguments - kRegisterPassedArguments;
5059 #endif
5060 }
5061
5062
5063 void MacroAssembler::EmitSeqStringSetCharCheck(Register string,
5064                                                Register index,
5065                                                Register value,
5066                                                uint32_t encoding_mask) {
5067   Label is_object;
5068   JumpIfNotSmi(string, &is_object);
5069   Abort(kNonObject);
5070   bind(&is_object);
5071
5072   Push(value);
5073   movp(value, FieldOperand(string, HeapObject::kMapOffset));
5074   movzxbp(value, FieldOperand(value, Map::kInstanceTypeOffset));
5075
5076   andb(value, Immediate(kStringRepresentationMask | kStringEncodingMask));
5077   cmpp(value, Immediate(encoding_mask));
5078   Pop(value);
5079   Check(equal, kUnexpectedStringType);
5080
5081   // The index is assumed to be untagged coming in, tag it to compare with the
5082   // string length without using a temp register, it is restored at the end of
5083   // this function.
5084   Integer32ToSmi(index, index);
5085   SmiCompare(index, FieldOperand(string, String::kLengthOffset));
5086   Check(less, kIndexIsTooLarge);
5087
5088   SmiCompare(index, Smi::FromInt(0));
5089   Check(greater_equal, kIndexIsNegative);
5090
5091   // Restore the index
5092   SmiToInteger32(index, index);
5093 }
5094
5095
5096 void MacroAssembler::PrepareCallCFunction(int num_arguments) {
5097   int frame_alignment = OS::ActivationFrameAlignment();
5098   ASSERT(frame_alignment != 0);
5099   ASSERT(num_arguments >= 0);
5100
5101   // Make stack end at alignment and allocate space for arguments and old rsp.
5102   movp(kScratchRegister, rsp);
5103   ASSERT(IsPowerOf2(frame_alignment));
5104   int argument_slots_on_stack =
5105       ArgumentStackSlotsForCFunctionCall(num_arguments);
5106   subp(rsp, Immediate((argument_slots_on_stack + 1) * kRegisterSize));
5107   andp(rsp, Immediate(-frame_alignment));
5108   movp(Operand(rsp, argument_slots_on_stack * kRegisterSize), kScratchRegister);
5109 }
5110
5111
5112 void MacroAssembler::CallCFunction(ExternalReference function,
5113                                    int num_arguments) {
5114   LoadAddress(rax, function);
5115   CallCFunction(rax, num_arguments);
5116 }
5117
5118
5119 void MacroAssembler::CallCFunction(Register function, int num_arguments) {
5120   ASSERT(has_frame());
5121   // Check stack alignment.
5122   if (emit_debug_code()) {
5123     CheckStackAlignment();
5124   }
5125
5126   call(function);
5127   ASSERT(OS::ActivationFrameAlignment() != 0);
5128   ASSERT(num_arguments >= 0);
5129   int argument_slots_on_stack =
5130       ArgumentStackSlotsForCFunctionCall(num_arguments);
5131   movp(rsp, Operand(rsp, argument_slots_on_stack * kRegisterSize));
5132 }
5133
5134
5135 bool AreAliased(Register r1, Register r2, Register r3, Register r4) {
5136   if (r1.is(r2)) return true;
5137   if (r1.is(r3)) return true;
5138   if (r1.is(r4)) return true;
5139   if (r2.is(r3)) return true;
5140   if (r2.is(r4)) return true;
5141   if (r3.is(r4)) return true;
5142   return false;
5143 }
5144
5145
5146 CodePatcher::CodePatcher(byte* address, int size)
5147     : address_(address),
5148       size_(size),
5149       masm_(NULL, address, size + Assembler::kGap) {
5150   // Create a new macro assembler pointing to the address of the code to patch.
5151   // The size is adjusted with kGap on order for the assembler to generate size
5152   // bytes of instructions without failing with buffer size constraints.
5153   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
5154 }
5155
5156
5157 CodePatcher::~CodePatcher() {
5158   // Indicate that code has changed.
5159   CPU::FlushICache(address_, size_);
5160
5161   // Check that the code was patched as expected.
5162   ASSERT(masm_.pc_ == address_ + size_);
5163   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
5164 }
5165
5166
5167 void MacroAssembler::CheckPageFlag(
5168     Register object,
5169     Register scratch,
5170     int mask,
5171     Condition cc,
5172     Label* condition_met,
5173     Label::Distance condition_met_distance) {
5174   ASSERT(cc == zero || cc == not_zero);
5175   if (scratch.is(object)) {
5176     andp(scratch, Immediate(~Page::kPageAlignmentMask));
5177   } else {
5178     movp(scratch, Immediate(~Page::kPageAlignmentMask));
5179     andp(scratch, object);
5180   }
5181   if (mask < (1 << kBitsPerByte)) {
5182     testb(Operand(scratch, MemoryChunk::kFlagsOffset),
5183           Immediate(static_cast<uint8_t>(mask)));
5184   } else {
5185     testl(Operand(scratch, MemoryChunk::kFlagsOffset), Immediate(mask));
5186   }
5187   j(cc, condition_met, condition_met_distance);
5188 }
5189
5190
5191 void MacroAssembler::CheckMapDeprecated(Handle<Map> map,
5192                                         Register scratch,
5193                                         Label* if_deprecated) {
5194   if (map->CanBeDeprecated()) {
5195     Move(scratch, map);
5196     movl(scratch, FieldOperand(scratch, Map::kBitField3Offset));
5197     andl(scratch, Immediate(Map::Deprecated::kMask));
5198     j(not_zero, if_deprecated);
5199   }
5200 }
5201
5202
5203 void MacroAssembler::JumpIfBlack(Register object,
5204                                  Register bitmap_scratch,
5205                                  Register mask_scratch,
5206                                  Label* on_black,
5207                                  Label::Distance on_black_distance) {
5208   ASSERT(!AreAliased(object, bitmap_scratch, mask_scratch, rcx));
5209   GetMarkBits(object, bitmap_scratch, mask_scratch);
5210
5211   ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
5212   // The mask_scratch register contains a 1 at the position of the first bit
5213   // and a 0 at all other positions, including the position of the second bit.
5214   movp(rcx, mask_scratch);
5215   // Make rcx into a mask that covers both marking bits using the operation
5216   // rcx = mask | (mask << 1).
5217   leap(rcx, Operand(mask_scratch, mask_scratch, times_2, 0));
5218   // Note that we are using a 4-byte aligned 8-byte load.
5219   andp(rcx, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
5220   cmpp(mask_scratch, rcx);
5221   j(equal, on_black, on_black_distance);
5222 }
5223
5224
5225 // Detect some, but not all, common pointer-free objects.  This is used by the
5226 // incremental write barrier which doesn't care about oddballs (they are always
5227 // marked black immediately so this code is not hit).
5228 void MacroAssembler::JumpIfDataObject(
5229     Register value,
5230     Register scratch,
5231     Label* not_data_object,
5232     Label::Distance not_data_object_distance) {
5233   Label is_data_object;
5234   movp(scratch, FieldOperand(value, HeapObject::kMapOffset));
5235   CompareRoot(scratch, Heap::kHeapNumberMapRootIndex);
5236   j(equal, &is_data_object, Label::kNear);
5237   ASSERT(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1);
5238   ASSERT(kNotStringTag == 0x80 && kIsNotStringMask == 0x80);
5239   // If it's a string and it's not a cons string then it's an object containing
5240   // no GC pointers.
5241   testb(FieldOperand(scratch, Map::kInstanceTypeOffset),
5242         Immediate(kIsIndirectStringMask | kIsNotStringMask));
5243   j(not_zero, not_data_object, not_data_object_distance);
5244   bind(&is_data_object);
5245 }
5246
5247
5248 void MacroAssembler::GetMarkBits(Register addr_reg,
5249                                  Register bitmap_reg,
5250                                  Register mask_reg) {
5251   ASSERT(!AreAliased(addr_reg, bitmap_reg, mask_reg, rcx));
5252   movp(bitmap_reg, addr_reg);
5253   // Sign extended 32 bit immediate.
5254   andp(bitmap_reg, Immediate(~Page::kPageAlignmentMask));
5255   movp(rcx, addr_reg);
5256   int shift =
5257       Bitmap::kBitsPerCellLog2 + kPointerSizeLog2 - Bitmap::kBytesPerCellLog2;
5258   shrl(rcx, Immediate(shift));
5259   andp(rcx,
5260        Immediate((Page::kPageAlignmentMask >> shift) &
5261                  ~(Bitmap::kBytesPerCell - 1)));
5262
5263   addp(bitmap_reg, rcx);
5264   movp(rcx, addr_reg);
5265   shrl(rcx, Immediate(kPointerSizeLog2));
5266   andp(rcx, Immediate((1 << Bitmap::kBitsPerCellLog2) - 1));
5267   movl(mask_reg, Immediate(1));
5268   shlp_cl(mask_reg);
5269 }
5270
5271
5272 void MacroAssembler::EnsureNotWhite(
5273     Register value,
5274     Register bitmap_scratch,
5275     Register mask_scratch,
5276     Label* value_is_white_and_not_data,
5277     Label::Distance distance) {
5278   ASSERT(!AreAliased(value, bitmap_scratch, mask_scratch, rcx));
5279   GetMarkBits(value, bitmap_scratch, mask_scratch);
5280
5281   // If the value is black or grey we don't need to do anything.
5282   ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
5283   ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
5284   ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
5285   ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
5286
5287   Label done;
5288
5289   // Since both black and grey have a 1 in the first position and white does
5290   // not have a 1 there we only need to check one bit.
5291   testp(Operand(bitmap_scratch, MemoryChunk::kHeaderSize), mask_scratch);
5292   j(not_zero, &done, Label::kNear);
5293
5294   if (emit_debug_code()) {
5295     // Check for impossible bit pattern.
5296     Label ok;
5297     Push(mask_scratch);
5298     // shl.  May overflow making the check conservative.
5299     addp(mask_scratch, mask_scratch);
5300     testp(Operand(bitmap_scratch, MemoryChunk::kHeaderSize), mask_scratch);
5301     j(zero, &ok, Label::kNear);
5302     int3();
5303     bind(&ok);
5304     Pop(mask_scratch);
5305   }
5306
5307   // Value is white.  We check whether it is data that doesn't need scanning.
5308   // Currently only checks for HeapNumber and non-cons strings.
5309   Register map = rcx;  // Holds map while checking type.
5310   Register length = rcx;  // Holds length of object after checking type.
5311   Label not_heap_number;
5312   Label is_data_object;
5313
5314   // Check for heap-number
5315   movp(map, FieldOperand(value, HeapObject::kMapOffset));
5316   CompareRoot(map, Heap::kHeapNumberMapRootIndex);
5317   j(not_equal, &not_heap_number, Label::kNear);
5318   movp(length, Immediate(HeapNumber::kSize));
5319   jmp(&is_data_object, Label::kNear);
5320
5321   bind(&not_heap_number);
5322   // Check for strings.
5323   ASSERT(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1);
5324   ASSERT(kNotStringTag == 0x80 && kIsNotStringMask == 0x80);
5325   // If it's a string and it's not a cons string then it's an object containing
5326   // no GC pointers.
5327   Register instance_type = rcx;
5328   movzxbl(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
5329   testb(instance_type, Immediate(kIsIndirectStringMask | kIsNotStringMask));
5330   j(not_zero, value_is_white_and_not_data);
5331   // It's a non-indirect (non-cons and non-slice) string.
5332   // If it's external, the length is just ExternalString::kSize.
5333   // Otherwise it's String::kHeaderSize + string->length() * (1 or 2).
5334   Label not_external;
5335   // External strings are the only ones with the kExternalStringTag bit
5336   // set.
5337   ASSERT_EQ(0, kSeqStringTag & kExternalStringTag);
5338   ASSERT_EQ(0, kConsStringTag & kExternalStringTag);
5339   testb(instance_type, Immediate(kExternalStringTag));
5340   j(zero, &not_external, Label::kNear);
5341   movp(length, Immediate(ExternalString::kSize));
5342   jmp(&is_data_object, Label::kNear);
5343
5344   bind(&not_external);
5345   // Sequential string, either ASCII or UC16.
5346   ASSERT(kOneByteStringTag == 0x04);
5347   andp(length, Immediate(kStringEncodingMask));
5348   xorp(length, Immediate(kStringEncodingMask));
5349   addp(length, Immediate(0x04));
5350   // Value now either 4 (if ASCII) or 8 (if UC16), i.e. char-size shifted by 2.
5351   imulp(length, FieldOperand(value, String::kLengthOffset));
5352   shrp(length, Immediate(2 + kSmiTagSize + kSmiShiftSize));
5353   addp(length, Immediate(SeqString::kHeaderSize + kObjectAlignmentMask));
5354   andp(length, Immediate(~kObjectAlignmentMask));
5355
5356   bind(&is_data_object);
5357   // Value is a data object, and it is white.  Mark it black.  Since we know
5358   // that the object is white we can make it black by flipping one bit.
5359   orp(Operand(bitmap_scratch, MemoryChunk::kHeaderSize), mask_scratch);
5360
5361   andp(bitmap_scratch, Immediate(~Page::kPageAlignmentMask));
5362   addl(Operand(bitmap_scratch, MemoryChunk::kLiveBytesOffset), length);
5363
5364   bind(&done);
5365 }
5366
5367
5368 void MacroAssembler::CheckEnumCache(Register null_value, Label* call_runtime) {
5369   Label next, start;
5370   Register empty_fixed_array_value = r8;
5371   LoadRoot(empty_fixed_array_value, Heap::kEmptyFixedArrayRootIndex);
5372   movp(rcx, rax);
5373
5374   // Check if the enum length field is properly initialized, indicating that
5375   // there is an enum cache.
5376   movp(rbx, FieldOperand(rcx, HeapObject::kMapOffset));
5377
5378   EnumLength(rdx, rbx);
5379   Cmp(rdx, Smi::FromInt(kInvalidEnumCacheSentinel));
5380   j(equal, call_runtime);
5381
5382   jmp(&start);
5383
5384   bind(&next);
5385
5386   movp(rbx, FieldOperand(rcx, HeapObject::kMapOffset));
5387
5388   // For all objects but the receiver, check that the cache is empty.
5389   EnumLength(rdx, rbx);
5390   Cmp(rdx, Smi::FromInt(0));
5391   j(not_equal, call_runtime);
5392
5393   bind(&start);
5394
5395   // Check that there are no elements. Register rcx contains the current JS
5396   // object we've reached through the prototype chain.
5397   Label no_elements;
5398   cmpp(empty_fixed_array_value,
5399        FieldOperand(rcx, JSObject::kElementsOffset));
5400   j(equal, &no_elements);
5401
5402   // Second chance, the object may be using the empty slow element dictionary.
5403   LoadRoot(kScratchRegister, Heap::kEmptySlowElementDictionaryRootIndex);
5404   cmpp(kScratchRegister, FieldOperand(rcx, JSObject::kElementsOffset));
5405   j(not_equal, call_runtime);
5406
5407   bind(&no_elements);
5408   movp(rcx, FieldOperand(rbx, Map::kPrototypeOffset));
5409   cmpp(rcx, null_value);
5410   j(not_equal, &next);
5411 }
5412
5413 void MacroAssembler::TestJSArrayForAllocationMemento(
5414     Register receiver_reg,
5415     Register scratch_reg,
5416     Label* no_memento_found) {
5417   ExternalReference new_space_start =
5418       ExternalReference::new_space_start(isolate());
5419   ExternalReference new_space_allocation_top =
5420       ExternalReference::new_space_allocation_top_address(isolate());
5421
5422   leap(scratch_reg, Operand(receiver_reg,
5423       JSArray::kSize + AllocationMemento::kSize - kHeapObjectTag));
5424   Move(kScratchRegister, new_space_start);
5425   cmpp(scratch_reg, kScratchRegister);
5426   j(less, no_memento_found);
5427   cmpp(scratch_reg, ExternalOperand(new_space_allocation_top));
5428   j(greater, no_memento_found);
5429   CompareRoot(MemOperand(scratch_reg, -AllocationMemento::kSize),
5430               Heap::kAllocationMementoMapRootIndex);
5431 }
5432
5433
5434 void MacroAssembler::JumpIfDictionaryInPrototypeChain(
5435     Register object,
5436     Register scratch0,
5437     Register scratch1,
5438     Label* found) {
5439   ASSERT(!(scratch0.is(kScratchRegister) && scratch1.is(kScratchRegister)));
5440   ASSERT(!scratch1.is(scratch0));
5441   Register current = scratch0;
5442   Label loop_again;
5443
5444   movp(current, object);
5445
5446   // Loop based on the map going up the prototype chain.
5447   bind(&loop_again);
5448   movp(current, FieldOperand(current, HeapObject::kMapOffset));
5449   movp(scratch1, FieldOperand(current, Map::kBitField2Offset));
5450   DecodeField<Map::ElementsKindBits>(scratch1);
5451   cmpp(scratch1, Immediate(DICTIONARY_ELEMENTS));
5452   j(equal, found);
5453   movp(current, FieldOperand(current, Map::kPrototypeOffset));
5454   CompareRoot(current, Heap::kNullValueRootIndex);
5455   j(not_equal, &loop_again);
5456 }
5457
5458
5459 void MacroAssembler::TruncatingDiv(Register dividend, int32_t divisor) {
5460   ASSERT(!dividend.is(rax));
5461   ASSERT(!dividend.is(rdx));
5462   MultiplierAndShift ms(divisor);
5463   movl(rax, Immediate(ms.multiplier()));
5464   imull(dividend);
5465   if (divisor > 0 && ms.multiplier() < 0) addl(rdx, dividend);
5466   if (divisor < 0 && ms.multiplier() > 0) subl(rdx, dividend);
5467   if (ms.shift() > 0) sarl(rdx, Immediate(ms.shift()));
5468   movl(rax, dividend);
5469   shrl(rax, Immediate(31));
5470   addl(rdx, rax);
5471 }
5472
5473
5474 } }  // namespace v8::internal
5475
5476 #endif  // V8_TARGET_ARCH_X64