CSE2410 Fall 2014 Bounce

// Copyright 2012 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_IA32

#include "bootstrapper.h"

#include "code-stubs.h"

#include "isolate.h"

#include "jsregexp.h"

#include "regexp-macro-assembler.h"

#include "runtime.h"

#include "stub-cache.h"

#include "codegen.h"

#include "runtime.h"

namespace v8 {

namespace internal {

void FastNewClosureStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { ebx };

  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[] = { eax };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void NumberToStringStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { eax };

  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[] = { eax, ebx, ecx };

  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[] = { eax, ebx, ecx, edx };

  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[] = { ebx };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { edx, ecx };

  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[] = { edx };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFieldStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { edx };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedStoreFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { edx, ecx, eax };

  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[] = { eax, ebx };

  descriptor->register_param_count_ = 2;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

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

}

static void InitializeArrayConstructorDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor,

    int constant_stack_parameter_count) {

  // register state

  // eax -- number of arguments

  // edi -- function

  // ebx -- type info cell with elements kind

  static Register registers[] = { edi, ebx };

  descriptor->register_param_count_ = 2;

  if (constant_stack_parameter_count != 0) {

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

    descriptor->stack_parameter_count_ = eax;

  }

  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

  // eax -- number of arguments

  // edi -- constructor function

  static Register registers[] = { edi };

  descriptor->register_param_count_ = 1;

  if (constant_stack_parameter_count != 0) {

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

    descriptor->stack_parameter_count_ = eax;

  }

  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[] = { eax };

  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[] = { eax };

  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[] = { edx, ecx, eax };

  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[] = { eax, ebx, ecx, edx };

  descriptor->register_param_count_ = 4;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(ElementsTransitionAndStoreIC_Miss);

}

void BinaryOpStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { edx, eax };

  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));

}

#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 ||

           eax.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(0);

}

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,

              eax, ebx, ecx, &gc, TAG_OBJECT);

  // Get the function from the stack.

  __ mov(ecx, Operand(esp, 1 * kPointerSize));

  // Set up the object header.

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

  __ mov(FieldOperand(eax, HeapObject::kMapOffset),

         factory->function_context_map());

  __ mov(FieldOperand(eax, Context::kLengthOffset),

         Immediate(Smi::FromInt(length)));

  // Set up the fixed slots.

  __ Set(ebx, Immediate(0));  // Set to NULL.

  __ mov(Operand(eax, Context::SlotOffset(Context::CLOSURE_INDEX)), ecx);

  __ mov(Operand(eax, Context::SlotOffset(Context::PREVIOUS_INDEX)), esi);

  __ mov(Operand(eax, Context::SlotOffset(Context::EXTENSION_INDEX)), ebx);

  // Copy the global object from the previous context.

  __ mov(ebx, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  __ mov(Operand(eax, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)), ebx);

  // Initialize the rest of the slots to undefined.

  __ mov(ebx, factory->undefined_value());

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

    __ mov(Operand(eax, Context::SlotOffset(i)), ebx);

  }

  // Return and remove the on-stack parameter.

  __ mov(esi, eax);

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

  //

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

  // [esp + (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), eax, ebx, ecx, &gc, TAG_OBJECT);

  // Get the function or sentinel from the stack.

  __ mov(ecx, Operand(esp, 1 * kPointerSize));

  // Get the serialized scope info from the stack.

  __ mov(ebx, Operand(esp, 2 * kPointerSize));

  // Set up the object header.

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

  __ mov(FieldOperand(eax, HeapObject::kMapOffset),

         factory->block_context_map());

  __ mov(FieldOperand(eax, Context::kLengthOffset),

         Immediate(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(ecx, &after_sentinel, Label::kNear);

  if (FLAG_debug_code) {

    __ cmp(ecx, 0);

    __ Assert(equal, kExpected0AsASmiSentinel);

  }

  __ mov(ecx, GlobalObjectOperand());

  __ mov(ecx, FieldOperand(ecx, GlobalObject::kNativeContextOffset));

  __ mov(ecx, ContextOperand(ecx, Context::CLOSURE_INDEX));

  __ bind(&after_sentinel);

  // Set up the fixed slots.

  __ mov(ContextOperand(eax, Context::CLOSURE_INDEX), ecx);

  __ mov(ContextOperand(eax, Context::PREVIOUS_INDEX), esi);

  __ mov(ContextOperand(eax, Context::EXTENSION_INDEX), ebx);

  // Copy the global object from the previous context.

  __ mov(ebx, ContextOperand(esi, Context::GLOBAL_OBJECT_INDEX));

  __ mov(ContextOperand(eax, Context::GLOBAL_OBJECT_INDEX), ebx);

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

  if (slots_ == 1) {

    __ mov(ContextOperand(eax, Context::MIN_CONTEXT_SLOTS),

           factory->the_hole_value());

  } else {

    __ mov(ebx, factory->the_hole_value());

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

      __ mov(ContextOperand(eax, i + Context::MIN_CONTEXT_SLOTS), ebx);

    }

  }

  // Return and remove the on-stack parameters.

  __ mov(esi, eax);

  __ ret(2 * kPointerSize);

  // Need to collect. Call into runtime system.

  __ bind(&gc);

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

}

void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {

  // We don't allow a GC during a store buffer overflow so there is no need to

  // store the registers in any particular way, but we do have to store and

  // restore them.

  __ pushad();

  if (save_doubles_ == kSaveFPRegs) {

    CpuFeatureScope scope(masm, SSE2);

    __ sub(esp, Immediate(kDoubleSize * XMMRegister::kNumRegisters));

    for (int i = 0; i < XMMRegister::kNumRegisters; i++) {

      XMMRegister reg = XMMRegister::from_code(i);

      __ movsd(Operand(esp, i * kDoubleSize), reg);

    }

  }

  const int argument_count = 1;

  AllowExternalCallThatCantCauseGC scope(masm);

  __ PrepareCallCFunction(argument_count, ecx);

  __ mov(Operand(esp, 0 * kPointerSize),

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

  __ CallCFunction(

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

      argument_count);

  if (save_doubles_ == kSaveFPRegs) {

    CpuFeatureScope scope(masm, SSE2);

    for (int i = 0; i < XMMRegister::kNumRegisters; i++) {

      XMMRegister reg = XMMRegister::from_code(i);

      __ movsd(reg, Operand(esp, i * kDoubleSize));

    }

    __ add(esp, Immediate(kDoubleSize * XMMRegister::kNumRegisters));

  }

  __ popad();

  __ ret(0);

}

class FloatingPointHelper : public AllStatic {

 public:

  enum ArgLocation {

    ARGS_ON_STACK,

    ARGS_IN_REGISTERS

  };

  // Code pattern for loading a floating point value. Input value must

  // be either a smi or a heap number object (fp value). Requirements:

  // operand in register number. Returns operand as floating point number

  // on FPU stack.

  static void LoadFloatOperand(MacroAssembler* masm, Register number);

  // Test if operands are smi or number objects (fp). Requirements:

  // operand_1 in eax, operand_2 in edx; falls through on float

  // operands, jumps to the non_float label otherwise.

  static void CheckFloatOperands(MacroAssembler* masm,

                                 Label* non_float,

                                 Register scratch);

  // Test if operands are numbers (smi or HeapNumber objects), and load

  // them into xmm0 and xmm1 if they are.  Jump to label not_numbers if

  // either operand is not a number.  Operands are in edx and eax.

  // Leaves operands unchanged.

  static void LoadSSE2Operands(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, done_no_stash;

  int double_offset = offset();

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

  if (input_reg.is(esp)) 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] = { ebx, edx, edi };

    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 ecx for shifts below, use some other register (eax)

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

  Register result_reg = final_result_reg.is(ecx) ? eax : 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(ecx) ? eax : ecx;

  __ push(scratch1);

  __ push(save_reg);

  bool stash_exponent_copy = !input_reg.is(esp);

  __ mov(scratch1, mantissa_operand);

  if (CpuFeatures::IsSupported(SSE3)) {

    CpuFeatureScope scope(masm, SSE3);

    // Load x87 register with heap number.

    __ fld_d(mantissa_operand);

  }

  __ mov(ecx, exponent_operand);

  if (stash_exponent_copy) __ push(ecx);

  __ and_(ecx, HeapNumber::kExponentMask);

  __ shr(ecx, HeapNumber::kExponentShift);

  __ lea(result_reg, MemOperand(ecx, -HeapNumber::kExponentBias));

  __ cmp(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;

  if (CpuFeatures::IsSupported(SSE3)) {

    __ fstp(0);

  }

  __ sub(ecx, Immediate(delta));

  __ xor_(result_reg, result_reg);

  __ cmp(ecx, Immediate(31));

  __ j(above, &done);

  __ shl_cl(scratch1);

  __ jmp(&check_negative);

  __ bind(&process_64_bits);

  if (CpuFeatures::IsSupported(SSE3)) {

    CpuFeatureScope scope(masm, SSE3);

    if (stash_exponent_copy) {

      // Already a copy of the exponent on the stack, overwrite it.

      STATIC_ASSERT(kDoubleSize == 2 * kPointerSize);

      __ sub(esp, Immediate(kDoubleSize / 2));

    } else {

      // Reserve space for 64 bit answer.

      __ sub(esp, Immediate(kDoubleSize));  // Nolint.

    }

    // Do conversion, which cannot fail because we checked the exponent.

    __ fisttp_d(Operand(esp, 0));

    __ mov(result_reg, Operand(esp, 0));  // Load low word of answer as result

    __ add(esp, Immediate(kDoubleSize));

    __ jmp(&done_no_stash);

  } else {

    // Result must be extracted from shifted 32-bit mantissa

    __ sub(ecx, Immediate(delta));

    __ neg(ecx);

    if (stash_exponent_copy) {

      __ mov(result_reg, MemOperand(esp, 0));

    } else {

      __ mov(result_reg, exponent_operand);

    }

    __ and_(result_reg,

            Immediate(static_cast<uint32_t>(Double::kSignificandMask >> 32)));

    __ add(result_reg,

           Immediate(static_cast<uint32_t>(Double::kHiddenBit >> 32)));

    __ shrd(result_reg, scratch1);

    __ shr_cl(result_reg);

    __ test(ecx, Immediate(32));

    if (CpuFeatures::IsSupported(CMOV)) {

      CpuFeatureScope use_cmov(masm, CMOV);

      __ cmov(not_equal, scratch1, result_reg);

    } else {

      Label skip_mov;

      __ j(equal, &skip_mov, Label::kNear);

      __ mov(scratch1, result_reg);

      __ bind(&skip_mov);

    }

  }

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

  __ bind(&check_negative);

  __ mov(result_reg, scratch1);

  __ neg(result_reg);

  if (stash_exponent_copy) {

    __ cmp(MemOperand(esp, 0), Immediate(0));

  } else {

    __ cmp(exponent_operand, Immediate(0));

  }

  if (CpuFeatures::IsSupported(CMOV)) {

    CpuFeatureScope use_cmov(masm, CMOV);

    __ cmov(greater, result_reg, scratch1);

  } else {

    Label skip_mov;

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

    __ mov(result_reg, scratch1);

    __ bind(&skip_mov);

  }

  // Restore registers

  __ bind(&done);

  if (stash_exponent_copy) {

    __ add(esp, Immediate(kDoubleSize / 2));

  }

  __ bind(&done_no_stash);

  if (!final_result_reg.is(result_reg)) {

    ASSERT(final_result_reg.is(ecx));

    __ mov(final_result_reg, result_reg);

  }

  __ pop(save_reg);

  __ pop(scratch1);

  __ ret(0);

}

void TranscendentalCacheStub::Generate(MacroAssembler* masm) {

  // TAGGED case:

  //   Input:

  //     esp[4]: tagged number input argument (should be number).

  //     esp[0]: return address.

  //   Output:

  //     eax: tagged double result.

  // UNTAGGED case:

  //   Input::

  //     esp[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) {

    // Test that eax is a number.

    Label input_not_smi;

    Label loaded;

    __ mov(eax, Operand(esp, kPointerSize));

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

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

    // Then load the low and high words of the double into ebx, edx.

    STATIC_ASSERT(kSmiTagSize == 1);

    __ sar(eax, 1);

    __ sub(esp, Immediate(2 * kPointerSize));

    __ mov(Operand(esp, 0), eax);

    __ fild_s(Operand(esp, 0));

    __ fst_d(Operand(esp, 0));

    __ pop(edx);

    __ pop(ebx);

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

    __ bind(&input_not_smi);

    // Check if input is a HeapNumber.

    __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));

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

    __ cmp(ebx, Immediate(factory->heap_number_map()));

    __ j(not_equal, &runtime_call);

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

    // low and high words into ebx, edx.

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

    __ mov(edx, FieldOperand(eax, HeapNumber::kExponentOffset));

    __ mov(ebx, FieldOperand(eax, HeapNumber::kMantissaOffset));

    __ bind(&loaded);

  } else {  // UNTAGGED.

    CpuFeatureScope scope(masm, SSE2);

    if (CpuFeatures::IsSupported(SSE4_1)) {

      CpuFeatureScope sse4_scope(masm, SSE4_1);

      __ pextrd(edx, xmm1, 0x1);  // copy xmm1[63..32] to edx.

    } else {

      __ pshufd(xmm0, xmm1, 0x1);

      __ movd(edx, xmm0);

    }

    __ movd(ebx, xmm1);

  }

  // ST[0] or xmm1  == double value

  // ebx = low 32 bits of double value

  // edx = high 32 bits of double value

  // Compute hash (the shifts are arithmetic):

  //   h = (low ^ high); h ^= h >> 16; h ^= h >> 8; h = h & (cacheSize - 1);

  __ mov(ecx, ebx);

  __ xor_(ecx, edx);

  __ mov(eax, ecx);

  __ sar(eax, 16);

  __ xor_(ecx, eax);

  __ mov(eax, ecx);

  __ sar(eax, 8);

  __ xor_(ecx, eax);

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

  __ and_(ecx,

          Immediate(TranscendentalCache::SubCache::kCacheSize - 1));

  // ST[0] or xmm1 == double value.

  // ebx = low 32 bits of double value.

  // edx = high 32 bits of double value.

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

  ExternalReference cache_array =

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

  __ mov(eax, Immediate(cache_array));

  int cache_array_index =

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

  __ mov(eax, Operand(eax, cache_array_index));

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

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

  __ test(eax, eax);

  __ j(zero, &runtime_call_clear_stack);

#ifdef DEBUG

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

  { 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));

    CHECK_EQ(12, elem2_start - elem_start);  // Two uint_32's and a pointer.

    CHECK_EQ(0, elem_in0 - elem_start);

    CHECK_EQ(kIntSize, elem_in1 - elem_start);

    CHECK_EQ(2 * kIntSize, elem_out - elem_start);

  }

#endif

  // Find the address of the ecx'th entry in the cache, i.e., &eax[ecx*12].

  __ lea(ecx, Operand(ecx, ecx, times_2, 0));

  __ lea(ecx, Operand(eax, ecx, times_4, 0));

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

  Label cache_miss;

  __ cmp(ebx, Operand(ecx, 0));

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

  __ cmp(edx, Operand(ecx, kIntSize));

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

  // Cache hit!

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

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

  __ mov(eax, Operand(ecx, 2 * kIntSize));

  if (tagged) {

    __ fstp(0);

    __ ret(kPointerSize);

  } else {  // UNTAGGED.

    CpuFeatureScope scope(masm, SSE2);

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

    __ Ret();

  }

  __ bind(&cache_miss);

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

  // Update cache with new value.

  // We are short on registers, so use no_reg as scratch.

  // This gives slightly larger code.

  if (tagged) {

    __ AllocateHeapNumber(eax, edi, no_reg, &runtime_call_clear_stack);

  } else {  // UNTAGGED.

    CpuFeatureScope scope(masm, SSE2);

    __ AllocateHeapNumber(eax, edi, no_reg, &skip_cache);

    __ sub(esp, Immediate(kDoubleSize));

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

    __ fld_d(Operand(esp, 0));

    __ add(esp, Immediate(kDoubleSize));

  }

  GenerateOperation(masm, type_);

  __ mov(Operand(ecx, 0), ebx);

  __ mov(Operand(ecx, kIntSize), edx);

  __ mov(Operand(ecx, 2 * kIntSize), eax);

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

  if (tagged) {

    __ ret(kPointerSize);

  } else {  // UNTAGGED.

    CpuFeatureScope scope(masm, SSE2);

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

    __ Ret();

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

    __ bind(&skip_cache);

    __ sub(esp, Immediate(kDoubleSize));

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

    __ fld_d(Operand(esp, 0));

    GenerateOperation(masm, type_);

    __ fstp_d(Operand(esp, 0));

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

    __ add(esp, 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(Immediate(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);

    ExternalReference runtime =

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

    __ TailCallExternalReference(runtime, 1, 1);

  } else {  // UNTAGGED.

    CpuFeatureScope scope(masm, SSE2);

    __ bind(&runtime_call_clear_stack);

    __ bind(&runtime_call);

    __ AllocateHeapNumber(eax, edi, no_reg, &skip_cache);

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

    {

      FrameScope scope(masm, StackFrame::INTERNAL);

      __ push(eax);

      __ CallRuntime(RuntimeFunction(), 1);

    }

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

    __ Ret();

  }

}

Runtime::FunctionId TranscendentalCacheStub::RuntimeFunction() {

  switch (type_) {

    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) {

  // Only free register is edi.

  // Input value is on FP stack, and also in ebx/edx.

  // Input value is possibly in xmm1.

  // Address of result (a newly allocated HeapNumber) may be in eax.

  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, done;

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

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

    __ mov(edi, edx);

    __ and_(edi, Immediate(0x7ff00000));  // Exponent only.

    int supported_exponent_limit =

        (63 + HeapNumber::kExponentBias) << HeapNumber::kExponentShift;

    __ cmp(edi, Immediate(supported_exponent_limit));

    __ j(below, &in_range, Label::kNear);

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

    __ cmp(edi, Immediate(0x7ff00000));

    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.

    __ push(Immediate(0x7ff80000));

    __ push(Immediate(0));

    __ fld_d(Operand(esp, 0));

    __ add(esp, Immediate(2 * kPointerSize));

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

    __ bind(&non_nan_result);

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

    __ mov(edi, eax);  // Save eax 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.

      __ test(eax, Immediate(5));

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

      __ fnclex();

      __ bind(&no_exceptions);

    }

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

    {

      Label partial_remainder_loop;

      __ bind(&partial_remainder_loop);

      __ fprem1();

      __ fwait();

      __ fnstsw_ax();

      __ test(eax, Immediate(0x400 /* C2 */));

      // 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);

    __ fstp(0);

    __ mov(eax, edi);  // Restore eax (allocated HeapNumber pointer).

    // FPU Stack: input % 2*pi

    __ 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::LoadFloatOperand(MacroAssembler* masm,

                                           Register number) {

  Label load_smi, done;

  __ JumpIfSmi(number, &load_smi, Label::kNear);

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

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

  __ bind(&load_smi);

  __ SmiUntag(number);

  __ push(number);

  __ fild_s(Operand(esp, 0));

  __ pop(number);

  __ bind(&done);

}

void FloatingPointHelper::LoadSSE2Operands(MacroAssembler* masm,

                                           Label* not_numbers) {

  Label load_smi_edx, load_eax, load_smi_eax, load_float_eax, done;

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

  __ JumpIfSmi(edx, &load_smi_edx, Label::kNear);

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

  __ cmp(FieldOperand(edx, HeapObject::kMapOffset), factory->heap_number_map());

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

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

  __ bind(&load_eax);

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

  __ JumpIfSmi(eax, &load_smi_eax, Label::kNear);

  __ cmp(FieldOperand(eax, HeapObject::kMapOffset), factory->heap_number_map());

  __ j(equal, &load_float_eax, Label::kNear);

  __ jmp(not_numbers);  // Argument in eax is not a number.

  __ bind(&load_smi_edx);

  __ SmiUntag(edx);  // Untag smi before converting to float.

  __ Cvtsi2sd(xmm0, edx);

  __ SmiTag(edx);  // Retag smi for heap number overwriting test.

  __ jmp(&load_eax);

  __ bind(&load_smi_eax);

  __ SmiUntag(eax);  // Untag smi before converting to float.

  __ Cvtsi2sd(xmm1, eax);

  __ SmiTag(eax);  // Retag smi for heap number overwriting test.

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

  __ bind(&load_float_eax);

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

  __ bind(&done);

}

void FloatingPointHelper::CheckFloatOperands(MacroAssembler* masm,

                                             Label* non_float,

                                             Register scratch) {

  Label test_other, done;

  // Test if both operands are floats or smi -> scratch=k_is_float;

  // Otherwise scratch = k_not_float.

  __ JumpIfSmi(edx, &test_other, Label::kNear);

  __ mov(scratch, FieldOperand(edx, HeapObject::kMapOffset));

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

  __ cmp(scratch, factory->heap_number_map());

  __ j(not_equal, non_float);  // argument in edx is not a number -> NaN

  __ bind(&test_other);

  __ JumpIfSmi(eax, &done, Label::kNear);

  __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset));

  __ cmp(scratch, factory->heap_number_map());

  __ j(not_equal, non_float);  // argument in eax is not a number -> NaN

  // Fall-through: Both operands are numbers.

  __ bind(&done);

}

void MathPowStub::Generate(MacroAssembler* masm) {

  CpuFeatureScope use_sse2(masm, SSE2);

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

  const Register exponent = eax;

  const Register base = edx;

  const Register scratch = ecx;

  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.

  __ mov(scratch, Immediate(1));

  __ Cvtsi2sd(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.

    __ mov(base, Operand(esp, 2 * kPointerSize));

    __ mov(exponent, Operand(esp, 1 * kPointerSize));

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

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

           factory->heap_number_map());

    __ j(not_equal, &call_runtime);

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

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

    __ bind(&base_is_smi);

    __ SmiUntag(base);

    __ Cvtsi2sd(double_base, base);

    __ bind(&unpack_exponent);

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

    __ SmiUntag(exponent);

    __ jmp(&int_exponent);

    __ bind(&exponent_not_smi);

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

           factory->heap_number_map());

    __ j(not_equal, &call_runtime);

    __ movsd(double_exponent,

              FieldOperand(exponent, HeapNumber::kValueOffset));

  } else if (exponent_type_ == TAGGED) {

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

    __ SmiUntag(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;

    __ DoubleToI(exponent, double_exponent, double_scratch,

                 TREAT_MINUS_ZERO_AS_ZERO, &try_arithmetic_simplification);

    __ jmp(&int_exponent);

    __ bind(&try_arithmetic_simplification);

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

    __ cvttsd2si(exponent, Operand(double_exponent));

    __ cmp(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.

      __ mov(scratch, Immediate(0x3F000000u));

      __ movd(double_scratch, scratch);

      __ cvtss2sd(double_scratch, double_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, single-precision -Infinity has the highest

      // 9 bits set and the lowest 23 bits cleared.

      __ mov(scratch, 0xFF800000u);

      __ movd(double_scratch, scratch);

      __ cvtss2sd(double_scratch, double_scratch);

      __ ucomisd(double_base, double_scratch);

      // 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_exponent 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, single-precision -Infinity has the highest

      // 9 bits set and the lowest 23 bits cleared.

      __ mov(scratch, 0xFF800000u);

      __ movd(double_scratch, scratch);

      __ cvtss2sd(double_scratch, double_scratch);

      __ ucomisd(double_base, double_scratch);

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

    __ sub(esp, Immediate(kDoubleSize));

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

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

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

    __ fld_d(Operand(esp, 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);    // 2^X

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

    __ fnstsw_ax();

    __ test_b(eax, 0x5F);  // We check for all but precision exception.

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

    __ fstp_d(Operand(esp, 0));

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

    __ add(esp, Immediate(kDoubleSize));

    __ jmp(&done);

    __ bind(&fast_power_failed);

    __ fninit();

    __ add(esp, Immediate(kDoubleSize));

    __ jmp(&call_runtime);

  }

  // Calculate power with integer exponent.

  __ bind(&int_exponent);

  const XMMRegister double_scratch2 = double_exponent;

  __ mov(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;

  __ test(scratch, scratch);

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

  __ neg(scratch);

  __ bind(&no_neg);

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

  __ shr(scratch, 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);

  __ shr(scratch, 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);

  // scratch has the original value of the exponent - if the exponent is

  // negative, return 1/result.

  __ test(exponent, exponent);

  __ j(positive, &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);  // Result cannot be NaN.

  // double_exponent aliased as double_scratch2 has already been overwritten

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

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

  __ j(not_equal, &done);

  __ Cvtsi2sd(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 exponent.

    __ bind(&done);

    __ AllocateHeapNumber(eax, scratch, base, &call_runtime);

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

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

    __ ret(2 * kPointerSize);

  } else {

    __ bind(&call_runtime);

    {

      AllowExternalCallThatCantCauseGC scope(masm);

      __ PrepareCallCFunction(4, scratch);

      __ movsd(Operand(esp, 0 * kDoubleSize), double_base);

      __ movsd(Operand(esp, 1 * kDoubleSize), double_exponent);

      __ CallCFunction(

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

    }

    // Return value is in st(0) on ia32.

    // Store it into the (fixed) result register.

    __ sub(esp, Immediate(kDoubleSize));

    __ fstp_d(Operand(esp, 0));

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

    __ add(esp, Immediate(kDoubleSize));

    __ bind(&done);

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

    __ ret(0);

  }

}

void FunctionPrototypeStub::Generate(MacroAssembler* masm) {

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

  //  -- ecx    : name

  //  -- edx    : receiver

  //  -- esp[0] : return address

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

  Label miss;

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

    __ cmp(ecx, Immediate(masm->isolate()->factory()->prototype_string()));

    __ j(not_equal, &miss);

  }

  StubCompiler::GenerateLoadFunctionPrototype(masm, edx, eax, ebx, &miss);

  __ bind(&miss);

  StubCompiler::TailCallBuiltin(

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

}

void StringLengthStub::Generate(MacroAssembler* masm) {

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

  //  -- ecx    : name

  //  -- edx    : receiver

  //  -- esp[0] : return address

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

  Label miss;

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

    __ cmp(ecx, Immediate(masm->isolate()->factory()->length_string()));

    __ j(not_equal, &miss);

  }

  StubCompiler::GenerateLoadStringLength(masm, edx, eax, ebx, &miss);

  __ bind(&miss);

  StubCompiler::TailCallBuiltin(

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

}

void StoreArrayLengthStub::Generate(MacroAssembler* masm) {

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

  //  -- eax    : value

  //  -- ecx    : name

  //  -- edx    : receiver

  //  -- esp[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 = edx;

  Register value = eax;

  Register scratch = ebx;

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

    __ cmp(ecx, Immediate(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).

  __ mov(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.

  __ mov(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.

  __ pop(scratch);

  __ push(receiver);

  __ push(value);

  __ push(scratch);  // return address

  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 edx and the parameter count is in eax.

  // The displacement is used for skipping the frame pointer on the

  // stack. It is the offset of the last parameter (if any) relative

  // to the frame pointer.

  static const int kDisplacement = 1 * kPointerSize;

  // Check that the key is a smi.

  Label slow;

  __ JumpIfNotSmi(edx, &slow, Label::kNear);

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

  Label adaptor;

  __ mov(ebx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));

  __ mov(ecx, Operand(ebx, StandardFrameConstants::kContextOffset));

  __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));

  __ j(equal, &adaptor, Label::kNear);

  // Check index against formal parameters count limit passed in

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

  // check for free.

  __ cmp(edx, eax);

  __ j(above_equal, &slow, Label::kNear);

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

  STATIC_ASSERT(kSmiTagSize == 1);

  STATIC_ASSERT(kSmiTag == 0);  // Shifting code depends on these.

  __ lea(ebx, Operand(ebp, eax, times_2, 0));

  __ neg(edx);

  __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));

  __ ret(0);

  // 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);

  __ mov(ecx, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));

  __ cmp(edx, ecx);