CSE2410 Fall 2014 Bounce

// Copyright 2013 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "v8.h"

#if V8_TARGET_ARCH_X64

#include "bootstrapper.h"

#include "code-stubs.h"

#include "regexp-macro-assembler.h"

#include "stub-cache.h"

#include "runtime.h"

namespace v8 {

namespace internal {

void FastNewClosureStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rbx };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kNewClosureFromStubFailure)->entry;

}

void ToNumberStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void NumberToStringStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kNumberToString)->entry;

}

void FastCloneShallowArrayStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax, rbx, rcx };

  descriptor->register_param_count_ = 3;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kCreateArrayLiteralShallow)->entry;

}

void FastCloneShallowObjectStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax, rbx, rcx, rdx };

  descriptor->register_param_count_ = 4;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry;

}

void CreateAllocationSiteStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rbx };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rdx, rax };

  descriptor->register_param_count_ = 2;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(KeyedLoadIC_MissFromStubFailure);

}

void LoadFieldStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFieldStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rdx };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedStoreFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rdx, rcx, rax };

  descriptor->register_param_count_ = 3;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(KeyedStoreIC_MissFromStubFailure);

}

void TransitionElementsKindStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax, rbx };

  descriptor->register_param_count_ = 2;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kTransitionElementsKind)->entry;

}

void BinaryOpStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rdx, rax };

  descriptor->register_param_count_ = 2;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = FUNCTION_ADDR(BinaryOpIC_Miss);

  descriptor->SetMissHandler(

      ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate));

}

static void InitializeArrayConstructorDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor,

    int constant_stack_parameter_count) {

  // register state

  // rax -- number of arguments

  // rdi -- function

  // rbx -- type info cell with elements kind

  static Register registers[] = { rdi, rbx };

  descriptor->register_param_count_ = 2;

  if (constant_stack_parameter_count != 0) {

    // stack param count needs (constructor pointer, and single argument)

    descriptor->stack_parameter_count_ = rax;

  }

  descriptor->hint_stack_parameter_count_ = constant_stack_parameter_count;

  descriptor->register_params_ = registers;

  descriptor->function_mode_ = JS_FUNCTION_STUB_MODE;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kArrayConstructor)->entry;

}

static void InitializeInternalArrayConstructorDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor,

    int constant_stack_parameter_count) {

  // register state

  // rax -- number of arguments

  // rdi -- constructor function

  static Register registers[] = { rdi };

  descriptor->register_param_count_ = 1;

  if (constant_stack_parameter_count != 0) {

    // stack param count needs (constructor pointer, and single argument)

    descriptor->stack_parameter_count_ = rax;

  }

  descriptor->hint_stack_parameter_count_ = constant_stack_parameter_count;

  descriptor->register_params_ = registers;

  descriptor->function_mode_ = JS_FUNCTION_STUB_MODE;

  descriptor->deoptimization_handler_ =

      Runtime::FunctionForId(Runtime::kInternalArrayConstructor)->entry;

}

void ArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  InitializeArrayConstructorDescriptor(isolate, descriptor, 0);

}

void ArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  InitializeArrayConstructorDescriptor(isolate, descriptor, 1);

}

void ArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  InitializeArrayConstructorDescriptor(isolate, descriptor, -1);

}

void InternalArrayNoArgumentConstructorStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  InitializeInternalArrayConstructorDescriptor(isolate, descriptor, 0);

}

void InternalArraySingleArgumentConstructorStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  InitializeInternalArrayConstructorDescriptor(isolate, descriptor, 1);

}

void InternalArrayNArgumentsConstructorStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  InitializeInternalArrayConstructorDescriptor(isolate, descriptor, -1);

}

void CompareNilICStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(CompareNilIC_Miss);

  descriptor->SetMissHandler(

      ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate));

}

void ToBooleanStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

     FUNCTION_ADDR(ToBooleanIC_Miss);

  descriptor->SetMissHandler(

     ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate));

}

void StoreGlobalStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rdx, rcx, rax };

  descriptor->register_param_count_ = 3;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(StoreIC_MissFromStubFailure);

}

void ElementsTransitionAndStoreStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { rax, rbx, rcx, rdx };

  descriptor->register_param_count_ = 4;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(ElementsTransitionAndStoreIC_Miss);

}

#define __ ACCESS_MASM(masm)

void HydrogenCodeStub::GenerateLightweightMiss(MacroAssembler* masm) {

  // Update the static counter each time a new code stub is generated.

  Isolate* isolate = masm->isolate();

  isolate->counters()->code_stubs()->Increment();

  CodeStubInterfaceDescriptor* descriptor = GetInterfaceDescriptor(isolate);

  int param_count = descriptor->register_param_count_;

  {

    // Call the runtime system in a fresh internal frame.

    FrameScope scope(masm, StackFrame::INTERNAL);

    ASSERT(descriptor->register_param_count_ == 0 ||

           rax.is(descriptor->register_params_[param_count - 1]));

    // Push arguments

    for (int i = 0; i < param_count; ++i) {

      __ push(descriptor->register_params_[i]);

    }

    ExternalReference miss = descriptor->miss_handler();

    __ CallExternalReference(miss, descriptor->register_param_count_);

  }

  __ Ret();

}

void FastNewContextStub::Generate(MacroAssembler* masm) {

  // Try to allocate the context in new space.

  Label gc;

  int length = slots_ + Context::MIN_CONTEXT_SLOTS;

  __ Allocate((length * kPointerSize) + FixedArray::kHeaderSize,

              rax, rbx, rcx, &gc, TAG_OBJECT);

  // Get the function from the stack.

  StackArgumentsAccessor args(rsp, 1, ARGUMENTS_DONT_CONTAIN_RECEIVER);

  __ movq(rcx, args.GetArgumentOperand(0));

  // Set up the object header.

  __ LoadRoot(kScratchRegister, Heap::kFunctionContextMapRootIndex);

  __ movq(FieldOperand(rax, HeapObject::kMapOffset), kScratchRegister);

  __ Move(FieldOperand(rax, FixedArray::kLengthOffset), Smi::FromInt(length));

  // Set up the fixed slots.

  __ Set(rbx, 0);  // Set to NULL.

  __ movq(Operand(rax, Context::SlotOffset(Context::CLOSURE_INDEX)), rcx);

  __ movq(Operand(rax, Context::SlotOffset(Context::PREVIOUS_INDEX)), rsi);

  __ movq(Operand(rax, Context::SlotOffset(Context::EXTENSION_INDEX)), rbx);

  // Copy the global object from the previous context.

  __ movq(rbx, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  __ movq(Operand(rax, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)), rbx);

  // Initialize the rest of the slots to undefined.

  __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);

  for (int i = Context::MIN_CONTEXT_SLOTS; i < length; i++) {

    __ movq(Operand(rax, Context::SlotOffset(i)), rbx);

  }

  // Return and remove the on-stack parameter.

  __ movq(rsi, rax);

  __ ret(1 * kPointerSize);

  // Need to collect. Call into runtime system.

  __ bind(&gc);

  __ TailCallRuntime(Runtime::kNewFunctionContext, 1, 1);

}

void FastNewBlockContextStub::Generate(MacroAssembler* masm) {

  // Stack layout on entry:

  //

  // [rsp + (1 * kPointerSize)] : function

  // [rsp + (2 * kPointerSize)] : serialized scope info

  // Try to allocate the context in new space.

  Label gc;

  int length = slots_ + Context::MIN_CONTEXT_SLOTS;

  __ Allocate(FixedArray::SizeFor(length),

              rax, rbx, rcx, &gc, TAG_OBJECT);

  // Get the function from the stack.

  StackArgumentsAccessor args(rsp, 2, ARGUMENTS_DONT_CONTAIN_RECEIVER);

  __ movq(rcx, args.GetArgumentOperand(1));

  // Get the serialized scope info from the stack.

  __ movq(rbx, args.GetArgumentOperand(0));

  // Set up the object header.

  __ LoadRoot(kScratchRegister, Heap::kBlockContextMapRootIndex);

  __ movq(FieldOperand(rax, HeapObject::kMapOffset), kScratchRegister);

  __ Move(FieldOperand(rax, FixedArray::kLengthOffset), Smi::FromInt(length));

  // If this block context is nested in the native context we get a smi

  // sentinel instead of a function. The block context should get the

  // canonical empty function of the native context as its closure which

  // we still have to look up.

  Label after_sentinel;

  __ JumpIfNotSmi(rcx, &after_sentinel, Label::kNear);

  if (FLAG_debug_code) {

    __ cmpq(rcx, Immediate(0));

    __ Assert(equal, kExpected0AsASmiSentinel);

  }

  __ movq(rcx, GlobalObjectOperand());

  __ movq(rcx, FieldOperand(rcx, GlobalObject::kNativeContextOffset));

  __ movq(rcx, ContextOperand(rcx, Context::CLOSURE_INDEX));

  __ bind(&after_sentinel);

  // Set up the fixed slots.

  __ movq(ContextOperand(rax, Context::CLOSURE_INDEX), rcx);

  __ movq(ContextOperand(rax, Context::PREVIOUS_INDEX), rsi);

  __ movq(ContextOperand(rax, Context::EXTENSION_INDEX), rbx);

  // Copy the global object from the previous context.

  __ movq(rbx, ContextOperand(rsi, Context::GLOBAL_OBJECT_INDEX));

  __ movq(ContextOperand(rax, Context::GLOBAL_OBJECT_INDEX), rbx);

  // Initialize the rest of the slots to the hole value.

  __ LoadRoot(rbx, Heap::kTheHoleValueRootIndex);

  for (int i = 0; i < slots_; i++) {

    __ movq(ContextOperand(rax, i + Context::MIN_CONTEXT_SLOTS), rbx);

  }

  // Return and remove the on-stack parameter.

  __ movq(rsi, rax);

  __ ret(2 * kPointerSize);

  // Need to collect. Call into runtime system.

  __ bind(&gc);

  __ TailCallRuntime(Runtime::kPushBlockContext, 2, 1);

}

void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {

  __ PushCallerSaved(save_doubles_);

  const int argument_count = 1;

  __ PrepareCallCFunction(argument_count);

  __ LoadAddress(arg_reg_1,

                 ExternalReference::isolate_address(masm->isolate()));

  AllowExternalCallThatCantCauseGC scope(masm);

  __ CallCFunction(

      ExternalReference::store_buffer_overflow_function(masm->isolate()),

      argument_count);

  __ PopCallerSaved(save_doubles_);

  __ ret(0);

}

class FloatingPointHelper : public AllStatic {

 public:

  enum ConvertUndefined {

    CONVERT_UNDEFINED_TO_ZERO,

    BAILOUT_ON_UNDEFINED

  };

  // Load the operands from rdx and rax into xmm0 and xmm1, as doubles.

  // If the operands are not both numbers, jump to not_numbers.

  // Leaves rdx and rax unchanged.  SmiOperands assumes both are smis.

  // NumberOperands assumes both are smis or heap numbers.

  static void LoadSSE2UnknownOperands(MacroAssembler* masm,

                                      Label* not_numbers);

};

void DoubleToIStub::Generate(MacroAssembler* masm) {

    Register input_reg = this->source();

    Register final_result_reg = this->destination();

    ASSERT(is_truncating());

    Label check_negative, process_64_bits, done;

    int double_offset = offset();

    // Account for return address and saved regs if input is rsp.

    if (input_reg.is(rsp)) double_offset += 3 * kPointerSize;

    MemOperand mantissa_operand(MemOperand(input_reg, double_offset));

    MemOperand exponent_operand(MemOperand(input_reg,

                                           double_offset + kDoubleSize / 2));

    Register scratch1;

    Register scratch_candidates[3] = { rbx, rdx, rdi };

    for (int i = 0; i < 3; i++) {

      scratch1 = scratch_candidates[i];

      if (!final_result_reg.is(scratch1) && !input_reg.is(scratch1)) break;

    }

    // Since we must use rcx for shifts below, use some other register (rax)

    // to calculate the result if ecx is the requested return register.

    Register result_reg = final_result_reg.is(rcx) ? rax : final_result_reg;

    // Save ecx if it isn't the return register and therefore volatile, or if it

    // is the return register, then save the temp register we use in its stead

    // for the result.

    Register save_reg = final_result_reg.is(rcx) ? rax : rcx;

    __ push(scratch1);

    __ push(save_reg);

    bool stash_exponent_copy = !input_reg.is(rsp);

    __ movl(scratch1, mantissa_operand);

    __ movsd(xmm0, mantissa_operand);

    __ movl(rcx, exponent_operand);

    if (stash_exponent_copy) __ push(rcx);

    __ andl(rcx, Immediate(HeapNumber::kExponentMask));

    __ shrl(rcx, Immediate(HeapNumber::kExponentShift));

    __ leal(result_reg, MemOperand(rcx, -HeapNumber::kExponentBias));

    __ cmpl(result_reg, Immediate(HeapNumber::kMantissaBits));

    __ j(below, &process_64_bits);

    // Result is entirely in lower 32-bits of mantissa

    int delta = HeapNumber::kExponentBias + Double::kPhysicalSignificandSize;

    __ subl(rcx, Immediate(delta));

    __ xorl(result_reg, result_reg);

    __ cmpl(rcx, Immediate(31));

    __ j(above, &done);

    __ shll_cl(scratch1);

    __ jmp(&check_negative);

    __ bind(&process_64_bits);

    __ cvttsd2siq(result_reg, xmm0);

    __ jmp(&done, Label::kNear);

    // If the double was negative, negate the integer result.

    __ bind(&check_negative);

    __ movl(result_reg, scratch1);

    __ negl(result_reg);

    if (stash_exponent_copy) {

        __ cmpl(MemOperand(rsp, 0), Immediate(0));

    } else {

        __ cmpl(exponent_operand, Immediate(0));

    }

    __ cmovl(greater, result_reg, scratch1);

    // Restore registers

    __ bind(&done);

    if (stash_exponent_copy) {

        __ addq(rsp, Immediate(kDoubleSize));

    }

    if (!final_result_reg.is(result_reg)) {

        ASSERT(final_result_reg.is(rcx));

        __ movl(final_result_reg, result_reg);

    }

    __ pop(save_reg);

    __ pop(scratch1);

    __ ret(0);

}

void TranscendentalCacheStub::Generate(MacroAssembler* masm) {

  // TAGGED case:

  //   Input:

  //     rsp[8] : argument (should be number).

  //     rsp[0] : return address.

  //   Output:

  //     rax: tagged double result.

  // UNTAGGED case:

  //   Input::

  //     rsp[0] : return address.

  //     xmm1   : untagged double input argument

  //   Output:

  //     xmm1   : untagged double result.

  Label runtime_call;

  Label runtime_call_clear_stack;

  Label skip_cache;

  const bool tagged = (argument_type_ == TAGGED);

  if (tagged) {

    Label input_not_smi, loaded;

    // Test that rax is a number.

    StackArgumentsAccessor args(rsp, 1, ARGUMENTS_DONT_CONTAIN_RECEIVER);

    __ movq(rax, args.GetArgumentOperand(0));

    __ JumpIfNotSmi(rax, &input_not_smi, Label::kNear);

    // Input is a smi. Untag and load it onto the FPU stack.

    // Then load the bits of the double into rbx.

    __ SmiToInteger32(rax, rax);

    __ subq(rsp, Immediate(kDoubleSize));

    __ Cvtlsi2sd(xmm1, rax);

    __ movsd(Operand(rsp, 0), xmm1);

    __ movq(rbx, xmm1);

    __ movq(rdx, xmm1);

    __ fld_d(Operand(rsp, 0));

    __ addq(rsp, Immediate(kDoubleSize));

    __ jmp(&loaded, Label::kNear);

    __ bind(&input_not_smi);

    // Check if input is a HeapNumber.

    __ LoadRoot(rbx, Heap::kHeapNumberMapRootIndex);

    __ cmpq(rbx, FieldOperand(rax, HeapObject::kMapOffset));

    __ j(not_equal, &runtime_call);

    // Input is a HeapNumber. Push it on the FPU stack and load its

    // bits into rbx.

    __ fld_d(FieldOperand(rax, HeapNumber::kValueOffset));

    __ MoveDouble(rbx, FieldOperand(rax, HeapNumber::kValueOffset));

    __ movq(rdx, rbx);

    __ bind(&loaded);

  } else {  // UNTAGGED.

    __ movq(rbx, xmm1);

    __ movq(rdx, xmm1);

  }

  // ST[0] == double value, if TAGGED.

  // rbx = bits of double value.

  // rdx = also bits of double value.

  // Compute hash (h is 32 bits, bits are 64 and the shifts are arithmetic):

  //   h = h0 = bits ^ (bits >> 32);

  //   h ^= h >> 16;

  //   h ^= h >> 8;

  //   h = h & (cacheSize - 1);

  // or h = (h0 ^ (h0 >> 8) ^ (h0 >> 16) ^ (h0 >> 24)) & (cacheSize - 1)

  __ sar(rdx, Immediate(32));

  __ xorl(rdx, rbx);

  __ movl(rcx, rdx);

  __ movl(rax, rdx);

  __ movl(rdi, rdx);

  __ sarl(rdx, Immediate(8));

  __ sarl(rcx, Immediate(16));

  __ sarl(rax, Immediate(24));

  __ xorl(rcx, rdx);

  __ xorl(rax, rdi);

  __ xorl(rcx, rax);

  ASSERT(IsPowerOf2(TranscendentalCache::SubCache::kCacheSize));

  __ andl(rcx, Immediate(TranscendentalCache::SubCache::kCacheSize - 1));

  // ST[0] == double value.

  // rbx = bits of double value.

  // rcx = TranscendentalCache::hash(double value).

  ExternalReference cache_array =

      ExternalReference::transcendental_cache_array_address(masm->isolate());

  __ movq(rax, cache_array);

  int cache_array_index =

      type_ * sizeof(masm->isolate()->transcendental_cache()->caches_[0]);

  __ movq(rax, Operand(rax, cache_array_index));

  // rax points to the cache for the type type_.

  // If NULL, the cache hasn't been initialized yet, so go through runtime.

  __ testq(rax, rax);

  __ j(zero, &runtime_call_clear_stack);  // Only clears stack if TAGGED.

#ifdef DEBUG

  // Check that the layout of cache elements match expectations.

  {  // NOLINT - doesn't like a single brace on a line.

    TranscendentalCache::SubCache::Element test_elem[2];

    char* elem_start = reinterpret_cast<char*>(&test_elem[0]);

    char* elem2_start = reinterpret_cast<char*>(&test_elem[1]);

    char* elem_in0  = reinterpret_cast<char*>(&(test_elem[0].in[0]));

    char* elem_in1  = reinterpret_cast<char*>(&(test_elem[0].in[1]));

    char* elem_out = reinterpret_cast<char*>(&(test_elem[0].output));

    // Two uint_32's and a pointer per element.

    CHECK_EQ(2 * kIntSize + 1 * kPointerSize,

             static_cast<int>(elem2_start - elem_start));

    CHECK_EQ(0, static_cast<int>(elem_in0 - elem_start));

    CHECK_EQ(kIntSize, static_cast<int>(elem_in1 - elem_start));

    CHECK_EQ(2 * kIntSize, static_cast<int>(elem_out - elem_start));

  }

#endif

  // Find the address of the rcx'th entry in the cache, i.e., &rax[rcx*16].

  __ addl(rcx, rcx);

  __ lea(rcx, Operand(rax, rcx, times_8, 0));

  // Check if cache matches: Double value is stored in uint32_t[2] array.

  Label cache_miss;

  __ cmpq(rbx, Operand(rcx, 0));

  __ j(not_equal, &cache_miss, Label::kNear);

  // Cache hit!

  Counters* counters = masm->isolate()->counters();

  __ IncrementCounter(counters->transcendental_cache_hit(), 1);

  __ movq(rax, Operand(rcx, 2 * kIntSize));

  if (tagged) {

    __ fstp(0);  // Clear FPU stack.

    __ ret(kPointerSize);

  } else {  // UNTAGGED.

    __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));

    __ Ret();

  }

  __ bind(&cache_miss);

  __ IncrementCounter(counters->transcendental_cache_miss(), 1);

  // Update cache with new value.

  if (tagged) {

  __ AllocateHeapNumber(rax, rdi, &runtime_call_clear_stack);

  } else {  // UNTAGGED.

    __ AllocateHeapNumber(rax, rdi, &skip_cache);

    __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm1);

    __ fld_d(FieldOperand(rax, HeapNumber::kValueOffset));

  }

  GenerateOperation(masm, type_);

  __ movq(Operand(rcx, 0), rbx);

  __ movq(Operand(rcx, 2 * kIntSize), rax);

  __ fstp_d(FieldOperand(rax, HeapNumber::kValueOffset));

  if (tagged) {

    __ ret(kPointerSize);

  } else {  // UNTAGGED.

    __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));

    __ Ret();

    // Skip cache and return answer directly, only in untagged case.

    __ bind(&skip_cache);

    __ subq(rsp, Immediate(kDoubleSize));

    __ movsd(Operand(rsp, 0), xmm1);

    __ fld_d(Operand(rsp, 0));

    GenerateOperation(masm, type_);

    __ fstp_d(Operand(rsp, 0));

    __ movsd(xmm1, Operand(rsp, 0));

    __ addq(rsp, Immediate(kDoubleSize));

    // We return the value in xmm1 without adding it to the cache, but

    // we cause a scavenging GC so that future allocations will succeed.

    {

      FrameScope scope(masm, StackFrame::INTERNAL);

      // Allocate an unused object bigger than a HeapNumber.

      __ Push(Smi::FromInt(2 * kDoubleSize));

      __ CallRuntimeSaveDoubles(Runtime::kAllocateInNewSpace);

    }

    __ Ret();

  }

  // Call runtime, doing whatever allocation and cleanup is necessary.

  if (tagged) {

    __ bind(&runtime_call_clear_stack);

    __ fstp(0);

    __ bind(&runtime_call);

    __ TailCallExternalReference(

        ExternalReference(RuntimeFunction(), masm->isolate()), 1, 1);

  } else {  // UNTAGGED.

    __ bind(&runtime_call_clear_stack);

    __ bind(&runtime_call);

    __ AllocateHeapNumber(rax, rdi, &skip_cache);

    __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm1);

    {

      FrameScope scope(masm, StackFrame::INTERNAL);

      __ push(rax);

      __ CallRuntime(RuntimeFunction(), 1);

    }

    __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));

    __ Ret();

  }

}

Runtime::FunctionId TranscendentalCacheStub::RuntimeFunction() {

  switch (type_) {

    // Add more cases when necessary.

    case TranscendentalCache::SIN: return Runtime::kMath_sin;

    case TranscendentalCache::COS: return Runtime::kMath_cos;

    case TranscendentalCache::TAN: return Runtime::kMath_tan;

    case TranscendentalCache::LOG: return Runtime::kMath_log;

    default:

      UNIMPLEMENTED();

      return Runtime::kAbort;

  }

}

void TranscendentalCacheStub::GenerateOperation(

    MacroAssembler* masm, TranscendentalCache::Type type) {

  // Registers:

  // rax: Newly allocated HeapNumber, which must be preserved.

  // rbx: Bits of input double. Must be preserved.

  // rcx: Pointer to cache entry. Must be preserved.

  // st(0): Input double

  Label done;

  if (type == TranscendentalCache::SIN ||

      type == TranscendentalCache::COS ||

      type == TranscendentalCache::TAN) {

    // Both fsin and fcos require arguments in the range +/-2^63 and

    // return NaN for infinities and NaN. They can share all code except

    // the actual fsin/fcos operation.

    Label in_range;

    // If argument is outside the range -2^63..2^63, fsin/cos doesn't

    // work. We must reduce it to the appropriate range.

    __ movq(rdi, rbx);

    // Move exponent and sign bits to low bits.

    __ shr(rdi, Immediate(HeapNumber::kMantissaBits));

    // Remove sign bit.

    __ andl(rdi, Immediate((1 << HeapNumber::kExponentBits) - 1));

    int supported_exponent_limit = (63 + HeapNumber::kExponentBias);

    __ cmpl(rdi, Immediate(supported_exponent_limit));

    __ j(below, &in_range);

    // Check for infinity and NaN. Both return NaN for sin.

    __ cmpl(rdi, Immediate(0x7ff));

    Label non_nan_result;

    __ j(not_equal, &non_nan_result, Label::kNear);

    // Input is +/-Infinity or NaN. Result is NaN.

    __ fstp(0);

    // NaN is represented by 0x7ff8000000000000.

    __ subq(rsp, Immediate(kPointerSize));

    __ movl(Operand(rsp, 4), Immediate(0x7ff80000));

    __ movl(Operand(rsp, 0), Immediate(0x00000000));

    __ fld_d(Operand(rsp, 0));

    __ addq(rsp, Immediate(kPointerSize));

    __ jmp(&done);

    __ bind(&non_nan_result);

    // Use fpmod to restrict argument to the range +/-2*PI.

    __ movq(rdi, rax);  // Save rax before using fnstsw_ax.

    __ fldpi();

    __ fadd(0);

    __ fld(1);

    // FPU Stack: input, 2*pi, input.

    {

      Label no_exceptions;

      __ fwait();

      __ fnstsw_ax();

      // Clear if Illegal Operand or Zero Division exceptions are set.

      __ testl(rax, Immediate(5));  // #IO and #ZD flags of FPU status word.

      __ j(zero, &no_exceptions);

      __ fnclex();

      __ bind(&no_exceptions);

    }

    // Compute st(0) % st(1)

    {

      Label partial_remainder_loop;

      __ bind(&partial_remainder_loop);

      __ fprem1();

      __ fwait();

      __ fnstsw_ax();

      __ testl(rax, Immediate(0x400));  // Check C2 bit of FPU status word.

      // If C2 is set, computation only has partial result. Loop to

      // continue computation.

      __ j(not_zero, &partial_remainder_loop);

  }

    // FPU Stack: input, 2*pi, input % 2*pi

    __ fstp(2);

    // FPU Stack: input % 2*pi, 2*pi,

    __ fstp(0);

    // FPU Stack: input % 2*pi

    __ movq(rax, rdi);  // Restore rax, pointer to the new HeapNumber.

    __ bind(&in_range);

    switch (type) {

      case TranscendentalCache::SIN:

        __ fsin();

        break;

      case TranscendentalCache::COS:

        __ fcos();

        break;

      case TranscendentalCache::TAN:

        // FPTAN calculates tangent onto st(0) and pushes 1.0 onto the

        // FP register stack.

        __ fptan();

        __ fstp(0);  // Pop FP register stack.

        break;

      default:

        UNREACHABLE();

    }

    __ bind(&done);

  } else {

    ASSERT(type == TranscendentalCache::LOG);

    __ fldln2();

    __ fxch();

    __ fyl2x();

  }

}

void FloatingPointHelper::LoadSSE2UnknownOperands(MacroAssembler* masm,

                                                  Label* not_numbers) {

  Label load_smi_rdx, load_nonsmi_rax, load_smi_rax, load_float_rax, done;

  // Load operand in rdx into xmm0, or branch to not_numbers.

  __ LoadRoot(rcx, Heap::kHeapNumberMapRootIndex);

  __ JumpIfSmi(rdx, &load_smi_rdx);

  __ cmpq(FieldOperand(rdx, HeapObject::kMapOffset), rcx);

  __ j(not_equal, not_numbers);  // Argument in rdx is not a number.

  __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));

  // Load operand in rax into xmm1, or branch to not_numbers.

  __ JumpIfSmi(rax, &load_smi_rax);

  __ bind(&load_nonsmi_rax);

  __ cmpq(FieldOperand(rax, HeapObject::kMapOffset), rcx);

  __ j(not_equal, not_numbers);

  __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));

  __ jmp(&done);

  __ bind(&load_smi_rdx);

  __ SmiToInteger32(kScratchRegister, rdx);

  __ Cvtlsi2sd(xmm0, kScratchRegister);

  __ JumpIfNotSmi(rax, &load_nonsmi_rax);

  __ bind(&load_smi_rax);

  __ SmiToInteger32(kScratchRegister, rax);

  __ Cvtlsi2sd(xmm1, kScratchRegister);

  __ bind(&done);

}

void MathPowStub::Generate(MacroAssembler* masm) {

  const Register exponent = rdx;

  const Register base = rax;

  const Register scratch = rcx;

  const XMMRegister double_result = xmm3;

  const XMMRegister double_base = xmm2;

  const XMMRegister double_exponent = xmm1;

  const XMMRegister double_scratch = xmm4;

  Label call_runtime, done, exponent_not_smi, int_exponent;

  // Save 1 in double_result - we need this several times later on.

  __ movq(scratch, Immediate(1));

  __ Cvtlsi2sd(double_result, scratch);

  if (exponent_type_ == ON_STACK) {

    Label base_is_smi, unpack_exponent;

    // The exponent and base are supplied as arguments on the stack.

    // This can only happen if the stub is called from non-optimized code.

    // Load input parameters from stack.

    StackArgumentsAccessor args(rsp, 2, ARGUMENTS_DONT_CONTAIN_RECEIVER);

    __ movq(base, args.GetArgumentOperand(0));

    __ movq(exponent, args.GetArgumentOperand(1));

    __ JumpIfSmi(base, &base_is_smi, Label::kNear);

    __ CompareRoot(FieldOperand(base, HeapObject::kMapOffset),

                   Heap::kHeapNumberMapRootIndex);

    __ j(not_equal, &call_runtime);

    __ movsd(double_base, FieldOperand(base, HeapNumber::kValueOffset));

    __ jmp(&unpack_exponent, Label::kNear);

    __ bind(&base_is_smi);

    __ SmiToInteger32(base, base);

    __ Cvtlsi2sd(double_base, base);

    __ bind(&unpack_exponent);

    __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);

    __ SmiToInteger32(exponent, exponent);

    __ jmp(&int_exponent);

    __ bind(&exponent_not_smi);

    __ CompareRoot(FieldOperand(exponent, HeapObject::kMapOffset),

                   Heap::kHeapNumberMapRootIndex);

    __ j(not_equal, &call_runtime);

    __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));

  } else if (exponent_type_ == TAGGED) {

    __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);

    __ SmiToInteger32(exponent, exponent);

    __ jmp(&int_exponent);

    __ bind(&exponent_not_smi);

    __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));

  }

  if (exponent_type_ != INTEGER) {

    Label fast_power, try_arithmetic_simplification;

    // Detect integer exponents stored as double.

    __ DoubleToI(exponent, double_exponent, double_scratch,

                 TREAT_MINUS_ZERO_AS_ZERO, &try_arithmetic_simplification);

    __ jmp(&int_exponent);

    __ bind(&try_arithmetic_simplification);

    __ cvttsd2si(exponent, double_exponent);

    // Skip to runtime if possibly NaN (indicated by the indefinite integer).

    __ cmpl(exponent, Immediate(0x80000000u));

    __ j(equal, &call_runtime);

    if (exponent_type_ == ON_STACK) {

      // Detect square root case.  Crankshaft detects constant +/-0.5 at

      // compile time and uses DoMathPowHalf instead.  We then skip this check

      // for non-constant cases of +/-0.5 as these hardly occur.

      Label continue_sqrt, continue_rsqrt, not_plus_half;

      // Test for 0.5.

      // Load double_scratch with 0.5.

      __ movq(scratch, V8_UINT64_C(0x3FE0000000000000), RelocInfo::NONE64);

      __ movq(double_scratch, scratch);

      // Already ruled out NaNs for exponent.

      __ ucomisd(double_scratch, double_exponent);

      __ j(not_equal, &not_plus_half, Label::kNear);

      // Calculates square root of base.  Check for the special case of

      // Math.pow(-Infinity, 0.5) == Infinity (ECMA spec, 15.8.2.13).

      // According to IEEE-754, double-precision -Infinity has the highest

      // 12 bits set and the lowest 52 bits cleared.

      __ movq(scratch, V8_UINT64_C(0xFFF0000000000000), RelocInfo::NONE64);

      __ movq(double_scratch, scratch);

      __ ucomisd(double_scratch, double_base);

      // Comparing -Infinity with NaN results in "unordered", which sets the

      // zero flag as if both were equal.  However, it also sets the carry flag.

      __ j(not_equal, &continue_sqrt, Label::kNear);

      __ j(carry, &continue_sqrt, Label::kNear);

      // Set result to Infinity in the special case.

      __ xorps(double_result, double_result);

      __ subsd(double_result, double_scratch);

      __ jmp(&done);

      __ bind(&continue_sqrt);

      // sqrtsd returns -0 when input is -0.  ECMA spec requires +0.

      __ xorps(double_scratch, double_scratch);

      __ addsd(double_scratch, double_base);  // Convert -0 to 0.

      __ sqrtsd(double_result, double_scratch);

      __ jmp(&done);

      // Test for -0.5.

      __ bind(&not_plus_half);

      // Load double_scratch with -0.5 by substracting 1.

      __ subsd(double_scratch, double_result);

      // Already ruled out NaNs for exponent.

      __ ucomisd(double_scratch, double_exponent);

      __ j(not_equal, &fast_power, Label::kNear);

      // Calculates reciprocal of square root of base.  Check for the special

      // case of Math.pow(-Infinity, -0.5) == 0 (ECMA spec, 15.8.2.13).

      // According to IEEE-754, double-precision -Infinity has the highest

      // 12 bits set and the lowest 52 bits cleared.

      __ movq(scratch, V8_UINT64_C(0xFFF0000000000000), RelocInfo::NONE64);

      __ movq(double_scratch, scratch);

      __ ucomisd(double_scratch, double_base);

      // Comparing -Infinity with NaN results in "unordered", which sets the

      // zero flag as if both were equal.  However, it also sets the carry flag.

      __ j(not_equal, &continue_rsqrt, Label::kNear);

      __ j(carry, &continue_rsqrt, Label::kNear);

      // Set result to 0 in the special case.

      __ xorps(double_result, double_result);

      __ jmp(&done);

      __ bind(&continue_rsqrt);

      // sqrtsd returns -0 when input is -0.  ECMA spec requires +0.

      __ xorps(double_exponent, double_exponent);

      __ addsd(double_exponent, double_base);  // Convert -0 to +0.

      __ sqrtsd(double_exponent, double_exponent);

      __ divsd(double_result, double_exponent);

      __ jmp(&done);

    }

    // Using FPU instructions to calculate power.

    Label fast_power_failed;

    __ bind(&fast_power);

    __ fnclex();  // Clear flags to catch exceptions later.

    // Transfer (B)ase and (E)xponent onto the FPU register stack.

    __ subq(rsp, Immediate(kDoubleSize));

    __ movsd(Operand(rsp, 0), double_exponent);

    __ fld_d(Operand(rsp, 0));  // E

    __ movsd(Operand(rsp, 0), double_base);

    __ fld_d(Operand(rsp, 0));  // B, E

    // Exponent is in st(1) and base is in st(0)

    // B ^ E = (2^(E * log2(B)) - 1) + 1 = (2^X - 1) + 1 for X = E * log2(B)

    // FYL2X calculates st(1) * log2(st(0))

    __ fyl2x();    // X

    __ fld(0);     // X, X

    __ frndint();  // rnd(X), X

    __ fsub(1);    // rnd(X), X-rnd(X)

    __ fxch(1);    // X - rnd(X), rnd(X)

    // F2XM1 calculates 2^st(0) - 1 for -1 < st(0) < 1

    __ f2xm1();    // 2^(X-rnd(X)) - 1, rnd(X)

    __ fld1();     // 1, 2^(X-rnd(X)) - 1, rnd(X)

    __ faddp(1);   // 2^(X-rnd(X)), rnd(X)

    // FSCALE calculates st(0) * 2^st(1)

    __ fscale();   // 2^X, rnd(X)

    __ fstp(1);

    // Bail out to runtime in case of exceptions in the status word.

    __ fnstsw_ax();

    __ testb(rax, Immediate(0x5F));  // Check for all but precision exception.

    __ j(not_zero, &fast_power_failed, Label::kNear);

    __ fstp_d(Operand(rsp, 0));

    __ movsd(double_result, Operand(rsp, 0));

    __ addq(rsp, Immediate(kDoubleSize));

    __ jmp(&done);

    __ bind(&fast_power_failed);

    __ fninit();

    __ addq(rsp, Immediate(kDoubleSize));

    __ jmp(&call_runtime);

  }

  // Calculate power with integer exponent.

  __ bind(&int_exponent);

  const XMMRegister double_scratch2 = double_exponent;

  // Back up exponent as we need to check if exponent is negative later.

  __ movq(scratch, exponent);  // Back up exponent.

  __ movsd(double_scratch, double_base);  // Back up base.

  __ movsd(double_scratch2, double_result);  // Load double_exponent with 1.

  // Get absolute value of exponent.

  Label no_neg, while_true, while_false;

  __ testl(scratch, scratch);

  __ j(positive, &no_neg, Label::kNear);

  __ negl(scratch);

  __ bind(&no_neg);

  __ j(zero, &while_false, Label::kNear);

  __ shrl(scratch, Immediate(1));

  // Above condition means CF==0 && ZF==0.  This means that the

  // bit that has been shifted out is 0 and the result is not 0.

  __ j(above, &while_true, Label::kNear);

  __ movsd(double_result, double_scratch);

  __ j(zero, &while_false, Label::kNear);

  __ bind(&while_true);

  __ shrl(scratch, Immediate(1));

  __ mulsd(double_scratch, double_scratch);

  __ j(above, &while_true, Label::kNear);

  __ mulsd(double_result, double_scratch);

  __ j(not_zero, &while_true);

  __ bind(&while_false);

  // If the exponent is negative, return 1/result.

  __ testl(exponent, exponent);

  __ j(greater, &done);

  __ divsd(double_scratch2, double_result);

  __ movsd(double_result, double_scratch2);

  // Test whether result is zero.  Bail out to check for subnormal result.

  // Due to subnormals, x^-y == (1/x)^y does not hold in all cases.

  __ xorps(double_scratch2, double_scratch2);

  __ ucomisd(double_scratch2, double_result);

  // double_exponent aliased as double_scratch2 has already been overwritten

  // and may not have contained the exponent value in the first place when the

  // input was a smi.  We reset it with exponent value before bailing out.

  __ j(not_equal, &done);

  __ Cvtlsi2sd(double_exponent, exponent);

  // Returning or bailing out.

  Counters* counters = masm->isolate()->counters();

  if (exponent_type_ == ON_STACK) {

    // The arguments are still on the stack.

    __ bind(&call_runtime);

    __ TailCallRuntime(Runtime::kMath_pow_cfunction, 2, 1);

    // The stub is called from non-optimized code, which expects the result

    // as heap number in rax.

    __ bind(&done);

    __ AllocateHeapNumber(rax, rcx, &call_runtime);

    __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), double_result);

    __ IncrementCounter(counters->math_pow(), 1);

    __ ret(2 * kPointerSize);

  } else {

    __ bind(&call_runtime);

    // Move base to the correct argument register.  Exponent is already in xmm1.

    __ movsd(xmm0, double_base);

    ASSERT(double_exponent.is(xmm1));

    {

      AllowExternalCallThatCantCauseGC scope(masm);

      __ PrepareCallCFunction(2);

      __ CallCFunction(

          ExternalReference::power_double_double_function(masm->isolate()), 2);

    }

    // Return value is in xmm0.

    __ movsd(double_result, xmm0);

    // Restore context register.

    __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));

    __ bind(&done);

    __ IncrementCounter(counters->math_pow(), 1);

    __ ret(0);

  }

}

void FunctionPrototypeStub::Generate(MacroAssembler* masm) {

  Label miss;

  Register receiver;

  if (kind() == Code::KEYED_LOAD_IC) {

    // ----------- S t a t e -------------

    //  -- rax    : key

    //  -- rdx    : receiver

    //  -- rsp[0] : return address

    // -----------------------------------

    __ Cmp(rax, masm->isolate()->factory()->prototype_string());

    __ j(not_equal, &miss);

    receiver = rdx;

  } else {

    ASSERT(kind() == Code::LOAD_IC);

    // ----------- S t a t e -------------

    //  -- rax    : receiver

    //  -- rcx    : name

    //  -- rsp[0] : return address

    // -----------------------------------

    receiver = rax;

  }

  StubCompiler::GenerateLoadFunctionPrototype(masm, receiver, r8, r9, &miss);

  __ bind(&miss);

  StubCompiler::TailCallBuiltin(

      masm, BaseLoadStoreStubCompiler::MissBuiltin(kind()));

}

void StringLengthStub::Generate(MacroAssembler* masm) {

  Label miss;

  Register receiver;

  if (kind() == Code::KEYED_LOAD_IC) {

    // ----------- S t a t e -------------

    //  -- rax    : key

    //  -- rdx    : receiver

    //  -- rsp[0] : return address

    // -----------------------------------

    __ Cmp(rax, masm->isolate()->factory()->length_string());

    __ j(not_equal, &miss);

    receiver = rdx;

  } else {

    ASSERT(kind() == Code::LOAD_IC);

    // ----------- S t a t e -------------

    //  -- rax    : receiver

    //  -- rcx    : name

    //  -- rsp[0] : return address

    // -----------------------------------

    receiver = rax;

  }

  StubCompiler::GenerateLoadStringLength(masm, receiver, r8, r9, &miss);

  __ bind(&miss);

  StubCompiler::TailCallBuiltin(

      masm, BaseLoadStoreStubCompiler::MissBuiltin(kind()));

}

void StoreArrayLengthStub::Generate(MacroAssembler* masm) {

  // ----------- S t a t e -------------

  //  -- rax    : value

  //  -- rcx    : key

  //  -- rdx    : receiver

  //  -- rsp[0] : return address

  // -----------------------------------

  //

  // This accepts as a receiver anything JSArray::SetElementsLength accepts

  // (currently anything except for external arrays which means anything with

  // elements of FixedArray type).  Value must be a number, but only smis are

  // accepted as the most common case.

  Label miss;

  Register receiver = rdx;

  Register value = rax;

  Register scratch = rbx;

  if (kind() == Code::KEYED_STORE_IC) {

    __ Cmp(rcx, masm->isolate()->factory()->length_string());

    __ j(not_equal, &miss);

  }

  // Check that the receiver isn't a smi.

  __ JumpIfSmi(receiver, &miss);

  // Check that the object is a JS array.

  __ CmpObjectType(receiver, JS_ARRAY_TYPE, scratch);

  __ j(not_equal, &miss);

  // Check that elements are FixedArray.

  // We rely on StoreIC_ArrayLength below to deal with all types of

  // fast elements (including COW).

  __ movq(scratch, FieldOperand(receiver, JSArray::kElementsOffset));

  __ CmpObjectType(scratch, FIXED_ARRAY_TYPE, scratch);

  __ j(not_equal, &miss);

  // Check that the array has fast properties, otherwise the length

  // property might have been redefined.

  __ movq(scratch, FieldOperand(receiver, JSArray::kPropertiesOffset));

  __ CompareRoot(FieldOperand(scratch, FixedArray::kMapOffset),

                 Heap::kHashTableMapRootIndex);

  __ j(equal, &miss);

  // Check that value is a smi.

  __ JumpIfNotSmi(value, &miss);

  // Prepare tail call to StoreIC_ArrayLength.

  __ PopReturnAddressTo(scratch);

  __ push(receiver);

  __ push(value);

  __ PushReturnAddressFrom(scratch);

  ExternalReference ref =

      ExternalReference(IC_Utility(IC::kStoreIC_ArrayLength), masm->isolate());

  __ TailCallExternalReference(ref, 2, 1);

  __ bind(&miss);

  StubCompiler::TailCallBuiltin(

      masm, BaseLoadStoreStubCompiler::MissBuiltin(kind()));

}

void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {

  // The key is in rdx and the parameter count is in rax.

  // Check that the key is a smi.

  Label slow;

  __ JumpIfNotSmi(rdx, &slow);

  // Check if the calling frame is an arguments adaptor frame.  We look at the

  // context offset, and if the frame is not a regular one, then we find a

  // Smi instead of the context.  We can't use SmiCompare here, because that

  // only works for comparing two smis.

  Label adaptor;

  __ movq(rbx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));

  __ Cmp(Operand(rbx, StandardFrameConstants::kContextOffset),

         Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));

  __ j(equal, &adaptor);

  // Check index against formal parameters count limit passed in

  // through register rax. Use unsigned comparison to get negative

  // check for free.

  __ cmpq(rdx, rax);

  __ j(above_equal, &slow);

  // Read the argument from the stack and return it.

  __ SmiSub(rax, rax, rdx);

  __ SmiToInteger32(rax, rax);

  StackArgumentsAccessor args(rbp, rax, ARGUMENTS_DONT_CONTAIN_RECEIVER);

  __ movq(rax, args.GetArgumentOperand(0));

  __ Ret();

  // Arguments adaptor case: Check index against actual arguments

  // limit found in the arguments adaptor frame. Use unsigned

  // comparison to get negative check for free.

  __ bind(&adaptor);

  __ movq(rcx, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));

  __ cmpq(rdx, rcx);

  __ j(above_equal, &slow);

  // Read the argument from the stack and return it.

  __ SmiSub(rcx, rcx, rdx);

  __ SmiToInteger32(rcx, rcx);

  StackArgumentsAccessor adaptor_args(rbx, rcx,

                                      ARGUMENTS_DONT_CONTAIN_RECEIVER);

  __ movq(rax, adaptor_args.GetArgumentOperand(0));

  __ Ret();

  // Slow-case: Handle non-smi or out-of-bounds access to arguments

  // by calling the runtime system.

  __ bind(&slow);

  __ PopReturnAddressTo(rbx);

  __ push(rdx);

  __ PushReturnAddressFrom(rbx);

  __ TailCallRuntime(Runtime::kGetArgumentsProperty, 1, 1);

}

void ArgumentsAccessStub::GenerateNewNonStrictFast(MacroAssembler* masm) {

  // Stack layout:

  //  rsp[0]  : return address

  //  rsp[8]  : number of parameters (tagged)

  //  rsp[16] : receiver displacement

  //  rsp[24] : function

  // Registers used over the whole function:

  //  rbx: the mapped parameter count (untagged)

  //  rax: the allocated object (tagged).

  Factory* factory = masm->isolate()->factory();

  StackArgumentsAccessor args(rsp, 3, ARGUMENTS_DONT_CONTAIN_RECEIVER);

  __ SmiToInteger64(rbx, args.GetArgumentOperand(2));

  // rbx = parameter count (untagged)

  // Check if the calling frame is an arguments adaptor frame.

  Label runtime;

  Label adaptor_frame, try_allocate;

  __ movq(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));

  __ movq(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));

  __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));

  __ j(equal, &adaptor_frame);

  // No adaptor, parameter count = argument count.

  __ movq(rcx, rbx);

  __ jmp(&try_allocate, Label::kNear);

  // We have an adaptor frame. Patch the parameters pointer.

  __ bind(&adaptor_frame);

  __ SmiToInteger64(rcx,

                    Operand(rdx,

                            ArgumentsAdaptorFrameConstants::kLengthOffset));

  __ lea(rdx, Operand(rdx, rcx, times_pointer_size,

                      StandardFrameConstants::kCallerSPOffset));

  __ movq(args.GetArgumentOperand(1), rdx);

  // rbx = parameter count (untagged)

  // rcx = argument count (untagged)

  // Compute the mapped parameter count = min(rbx, rcx) in rbx.

  __ cmpq(rbx, rcx);

  __ j(less_equal, &try_allocate, Label::kNear);

  __ movq(rbx, rcx);

  __ bind(&try_allocate);

  // Compute the sizes of backing store, parameter map, and arguments object.

  // 1. Parameter map, has 2 extra words containing context and backing store.

  const int kParameterMapHeaderSize =

      FixedArray::kHeaderSize + 2 * kPointerSize;

  Label no_parameter_map;

  __ xor_(r8, r8);

  __ testq(rbx, rbx);

  __ j(zero, &no_parameter_map, Label::kNear);

  __ lea(r8, Operand(rbx, times_pointer_size, kParameterMapHeaderSize));

  __ bind(&no_parameter_map);

  // 2. Backing store.

  __ lea(r8, Operand(r8, rcx, times_pointer_size, FixedArray::kHeaderSize));

  // 3. Arguments object.

  __ addq(r8, Immediate(Heap::kArgumentsObjectSize));

  // Do the allocation of all three objects in one go.

  __ Allocate(r8, rax, rdx, rdi, &runtime, TAG_OBJECT);

  // rax = address of new object(s) (tagged)

  // rcx = argument count (untagged)

  // Get the arguments boilerplate from the current native context into rdi.

  Label has_mapped_parameters, copy;

  __ movq(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  __ movq(rdi, FieldOperand(rdi, GlobalObject::kNativeContextOffset));

  __ testq(rbx, rbx);

  __ j(not_zero, &has_mapped_parameters, Label::kNear);

  const int kIndex = Context::ARGUMENTS_BOILERPLATE_INDEX;

  __ movq(rdi, Operand(rdi, Context::SlotOffset(kIndex)));

  __ jmp(&copy, Label::kNear);

  const int kAliasedIndex = Context::ALIASED_ARGUMENTS_BOILERPLATE_INDEX;

  __ bind(&has_mapped_parameters);

  __ movq(rdi, Operand(rdi, Context::SlotOffset(kAliasedIndex)));

  __ bind(&copy);

  // rax = address of new object (tagged)

  // rbx = mapped parameter count (untagged)

  // rcx = argument count (untagged)

  // rdi = address of boilerplate object (tagged)

  // Copy the JS object part.

  for (int i = 0; i < JSObject::kHeaderSize; i += kPointerSize) {

    __ movq(rdx, FieldOperand(rdi, i));

    __ movq(FieldOperand(rax, i), rdx);

  }

  // Set up the callee in-object property.

  STATIC_ASSERT(Heap::kArgumentsCalleeIndex == 1);

  __ movq(rdx, args.GetArgumentOperand(0));

  __ movq(FieldOperand(rax, JSObject::kHeaderSize +

                       Heap::kArgumentsCalleeIndex * kPointerSize),

          rdx);

  // Use the length (smi tagged) and set that as an in-object property too.

  // Note: rcx is tagged from here on.

  STATIC_ASSERT(Heap::kArgumentsLengthIndex == 0);

  __ Integer32ToSmi(rcx, rcx);

  __ movq(FieldOperand(rax, JSObject::kHeaderSize +

                       Heap::kArgumentsLengthIndex * kPointerSize),

          rcx);

  // Set up the elements pointer in the allocated arguments object.

  // If we allocated a parameter map, edi will point there, otherwise to the

  // backing store.

  __ lea(rdi, Operand(rax, Heap::kArgumentsObjectSize));

  __ movq(FieldOperand(rax, JSObject::kElementsOffset), rdi);

  // rax = address of new object (tagged)

  // rbx = mapped parameter count (untagged)

  // rcx = argument count (tagged)

  // rdi = address of parameter map or backing store (tagged)