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_MIPS

#include "bootstrapper.h"

#include "code-stubs.h"

#include "codegen.h"

#include "regexp-macro-assembler.h"

#include "stub-cache.h"

namespace v8 {

namespace internal {

void FastNewClosureStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a2 };

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

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void NumberToStringStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a0 };

  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[] = { a3, a2, a1 };

  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[] = { a3, a2, a1, a0 };

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

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a1, a0 };

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

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFieldStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a1 };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedStoreFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a2, a1, a0 };

  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[] = { a0, a1 };

  descriptor->register_param_count_ = 2;

  descriptor->register_params_ = registers;

  Address entry =

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

  descriptor->deoptimization_handler_ = FUNCTION_ADDR(entry);

}

void CompareNilICStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a0 };

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

}

static void InitializeArrayConstructorDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor,

    int constant_stack_parameter_count) {

  // register state

  // a0 -- number of arguments

  // a1 -- function

  // a2 -- type info cell with elements kind

  static Register registers[] = { a1, a2 };

  descriptor->register_param_count_ = 2;

  if (constant_stack_parameter_count != 0) {

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

    descriptor->stack_parameter_count_ = a0;

  }

  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

  // a0 -- number of arguments

  // a1 -- constructor function

  static Register registers[] = { a1 };

  descriptor->register_param_count_ = 1;

  if (constant_stack_parameter_count != 0) {

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

    descriptor->stack_parameter_count_ = a0;

  }

  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 ToBooleanStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a0 };

  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 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 StoreGlobalStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a1, a2, a0 };

  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[] = { a0, a3, a1, a2 };

  descriptor->register_param_count_ = 4;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ =

      FUNCTION_ADDR(ElementsTransitionAndStoreIC_Miss);

}

#define __ ACCESS_MASM(masm)

static void EmitIdenticalObjectComparison(MacroAssembler* masm,

                                          Label* slow,

                                          Condition cc);

static void EmitSmiNonsmiComparison(MacroAssembler* masm,

                                    Register lhs,

                                    Register rhs,

                                    Label* rhs_not_nan,

                                    Label* slow,

                                    bool strict);

static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,

                                           Register lhs,

                                           Register rhs);

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

           a0.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;

  // Attempt to allocate the context in new space.

  __ Allocate(FixedArray::SizeFor(length), v0, a1, a2, &gc, TAG_OBJECT);

  // Load the function from the stack.

  __ lw(a3, MemOperand(sp, 0));

  // Set up the object header.

  __ LoadRoot(a1, Heap::kFunctionContextMapRootIndex);

  __ li(a2, Operand(Smi::FromInt(length)));

  __ sw(a2, FieldMemOperand(v0, FixedArray::kLengthOffset));

  __ sw(a1, FieldMemOperand(v0, HeapObject::kMapOffset));

  // Set up the fixed slots, copy the global object from the previous context.

  __ lw(a2, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  __ li(a1, Operand(Smi::FromInt(0)));

  __ sw(a3, MemOperand(v0, Context::SlotOffset(Context::CLOSURE_INDEX)));

  __ sw(cp, MemOperand(v0, Context::SlotOffset(Context::PREVIOUS_INDEX)));

  __ sw(a1, MemOperand(v0, Context::SlotOffset(Context::EXTENSION_INDEX)));

  __ sw(a2, MemOperand(v0, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  // Initialize the rest of the slots to undefined.

  __ LoadRoot(a1, Heap::kUndefinedValueRootIndex);

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

    __ sw(a1, MemOperand(v0, Context::SlotOffset(i)));

  }

  // Remove the on-stack argument and return.

  __ mov(cp, v0);

  __ DropAndRet(1);

  // Need to collect. Call into runtime system.

  __ bind(&gc);

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

}

void FastNewBlockContextStub::Generate(MacroAssembler* masm) {

  // Stack layout on entry:

  //

  // [sp]: function.

  // [sp + 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), v0, a1, a2, &gc, TAG_OBJECT);

  // Load the function from the stack.

  __ lw(a3, MemOperand(sp, 0));

  // Load the serialized scope info from the stack.

  __ lw(a1, MemOperand(sp, 1 * kPointerSize));

  // Set up the object header.

  __ LoadRoot(a2, Heap::kBlockContextMapRootIndex);

  __ sw(a2, FieldMemOperand(v0, HeapObject::kMapOffset));

  __ li(a2, Operand(Smi::FromInt(length)));

  __ sw(a2, FieldMemOperand(v0, FixedArray::kLengthOffset));

  // 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(a3, &after_sentinel);

  if (FLAG_debug_code) {

    __ Assert(eq, kExpected0AsASmiSentinel, a3, Operand(zero_reg));

  }

  __ lw(a3, GlobalObjectOperand());

  __ lw(a3, FieldMemOperand(a3, GlobalObject::kNativeContextOffset));

  __ lw(a3, ContextOperand(a3, Context::CLOSURE_INDEX));

  __ bind(&after_sentinel);

  // Set up the fixed slots, copy the global object from the previous context.

  __ lw(a2, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));

  __ sw(a3, ContextOperand(v0, Context::CLOSURE_INDEX));

  __ sw(cp, ContextOperand(v0, Context::PREVIOUS_INDEX));

  __ sw(a1, ContextOperand(v0, Context::EXTENSION_INDEX));

  __ sw(a2, ContextOperand(v0, Context::GLOBAL_OBJECT_INDEX));

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

  __ LoadRoot(a1, Heap::kTheHoleValueRootIndex);

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

    __ sw(a1, ContextOperand(v0, i + Context::MIN_CONTEXT_SLOTS));

  }

  // Remove the on-stack argument and return.

  __ mov(cp, v0);

  __ DropAndRet(2);

  // Need to collect. Call into runtime system.

  __ bind(&gc);

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

}

// Takes a Smi and converts to an IEEE 64 bit floating point value in two

// registers.  The format is 1 sign bit, 11 exponent bits (biased 1023) and

// 52 fraction bits (20 in the first word, 32 in the second).  Zeros is a

// scratch register.  Destroys the source register.  No GC occurs during this

// stub so you don't have to set up the frame.

class ConvertToDoubleStub : public PlatformCodeStub {

 public:

  ConvertToDoubleStub(Register result_reg_1,

                      Register result_reg_2,

                      Register source_reg,

                      Register scratch_reg)

      : result1_(result_reg_1),

        result2_(result_reg_2),

        source_(source_reg),

        zeros_(scratch_reg) { }

 private:

  Register result1_;

  Register result2_;

  Register source_;

  Register zeros_;

  // Minor key encoding in 16 bits.

  class ModeBits: public BitField<OverwriteMode, 0, 2> {};

  class OpBits: public BitField<Token::Value, 2, 14> {};

  Major MajorKey() { return ConvertToDouble; }

  int MinorKey() {

    // Encode the parameters in a unique 16 bit value.

    return  result1_.code() +

           (result2_.code() << 4) +

           (source_.code() << 8) +

           (zeros_.code() << 12);

  }

  void Generate(MacroAssembler* masm);

};

void ConvertToDoubleStub::Generate(MacroAssembler* masm) {

#ifndef BIG_ENDIAN_FLOATING_POINT

  Register exponent = result1_;

  Register mantissa = result2_;

#else

  Register exponent = result2_;

  Register mantissa = result1_;

#endif

  Label not_special;

  // Convert from Smi to integer.

  __ sra(source_, source_, kSmiTagSize);

  // Move sign bit from source to destination.  This works because the sign bit

  // in the exponent word of the double has the same position and polarity as

  // the 2's complement sign bit in a Smi.

  STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);

  __ And(exponent, source_, Operand(HeapNumber::kSignMask));

  // Subtract from 0 if source was negative.

  __ subu(at, zero_reg, source_);

  __ Movn(source_, at, exponent);

  // We have -1, 0 or 1, which we treat specially. Register source_ contains

  // absolute value: it is either equal to 1 (special case of -1 and 1),

  // greater than 1 (not a special case) or less than 1 (special case of 0).

  __ Branch(&not_special, gt, source_, Operand(1));

  // For 1 or -1 we need to or in the 0 exponent (biased to 1023).

  const uint32_t exponent_word_for_1 =

      HeapNumber::kExponentBias << HeapNumber::kExponentShift;

  // Safe to use 'at' as dest reg here.

  __ Or(at, exponent, Operand(exponent_word_for_1));

  __ Movn(exponent, at, source_);  // Write exp when source not 0.

  // 1, 0 and -1 all have 0 for the second word.

  __ Ret(USE_DELAY_SLOT);

  __ mov(mantissa, zero_reg);

  __ bind(&not_special);

  // Count leading zeros.

  // Gets the wrong answer for 0, but we already checked for that case above.

  __ Clz(zeros_, source_);

  // Compute exponent and or it into the exponent register.

  // We use mantissa as a scratch register here.

  __ li(mantissa, Operand(31 + HeapNumber::kExponentBias));

  __ subu(mantissa, mantissa, zeros_);

  __ sll(mantissa, mantissa, HeapNumber::kExponentShift);

  __ Or(exponent, exponent, mantissa);

  // Shift up the source chopping the top bit off.

  __ Addu(zeros_, zeros_, Operand(1));

  // This wouldn't work for 1.0 or -1.0 as the shift would be 32 which means 0.

  __ sllv(source_, source_, zeros_);

  // Compute lower part of fraction (last 12 bits).

  __ sll(mantissa, source_, HeapNumber::kMantissaBitsInTopWord);

  // And the top (top 20 bits).

  __ srl(source_, source_, 32 - HeapNumber::kMantissaBitsInTopWord);

  __ Ret(USE_DELAY_SLOT);

  __ or_(exponent, exponent, source_);

}

void DoubleToIStub::Generate(MacroAssembler* masm) {

  Label out_of_range, only_low, negate, done;

  Register input_reg = source();

  Register result_reg = destination();

  int double_offset = offset();

  // Account for saved regs if input is sp.

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

  Register scratch =

      GetRegisterThatIsNotOneOf(input_reg, result_reg);

  Register scratch2 =

      GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch);

  Register scratch3 =

      GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch, scratch2);

  DoubleRegister double_scratch = kLithiumScratchDouble;

  __ Push(scratch, scratch2, scratch3);

  if (!skip_fastpath()) {

    // Load double input.

    __ ldc1(double_scratch, MemOperand(input_reg, double_offset));

    // Clear cumulative exception flags and save the FCSR.

    __ cfc1(scratch2, FCSR);

    __ ctc1(zero_reg, FCSR);

    // Try a conversion to a signed integer.

    __ Trunc_w_d(double_scratch, double_scratch);

    // Move the converted value into the result register.

    __ mfc1(result_reg, double_scratch);

    // Retrieve and restore the FCSR.

    __ cfc1(scratch, FCSR);

    __ ctc1(scratch2, FCSR);

    // Check for overflow and NaNs.

    __ And(

        scratch, scratch,

        kFCSROverflowFlagMask | kFCSRUnderflowFlagMask

           | kFCSRInvalidOpFlagMask);

    // If we had no exceptions we are done.

    __ Branch(&done, eq, scratch, Operand(zero_reg));

  }

  // Load the double value and perform a manual truncation.

  Register input_high = scratch2;

  Register input_low = scratch3;

  __ lw(input_low, MemOperand(input_reg, double_offset));

  __ lw(input_high, MemOperand(input_reg, double_offset + kIntSize));

  Label normal_exponent, restore_sign;

  // Extract the biased exponent in result.

  __ Ext(result_reg,

         input_high,

         HeapNumber::kExponentShift,

         HeapNumber::kExponentBits);

  // Check for Infinity and NaNs, which should return 0.

  __ Subu(scratch, result_reg, HeapNumber::kExponentMask);

  __ Movz(result_reg, zero_reg, scratch);

  __ Branch(&done, eq, scratch, Operand(zero_reg));

  // Express exponent as delta to (number of mantissa bits + 31).

  __ Subu(result_reg,

          result_reg,

          Operand(HeapNumber::kExponentBias + HeapNumber::kMantissaBits + 31));

  // If the delta is strictly positive, all bits would be shifted away,

  // which means that we can return 0.

  __ Branch(&normal_exponent, le, result_reg, Operand(zero_reg));

  __ mov(result_reg, zero_reg);

  __ Branch(&done);

  __ bind(&normal_exponent);

  const int kShiftBase = HeapNumber::kNonMantissaBitsInTopWord - 1;

  // Calculate shift.

  __ Addu(scratch, result_reg, Operand(kShiftBase + HeapNumber::kMantissaBits));

  // Save the sign.

  Register sign = result_reg;

  result_reg = no_reg;

  __ And(sign, input_high, Operand(HeapNumber::kSignMask));

  // On ARM shifts > 31 bits are valid and will result in zero. On MIPS we need

  // to check for this specific case.

  Label high_shift_needed, high_shift_done;

  __ Branch(&high_shift_needed, lt, scratch, Operand(32));

  __ mov(input_high, zero_reg);

  __ Branch(&high_shift_done);

  __ bind(&high_shift_needed);

  // Set the implicit 1 before the mantissa part in input_high.

  __ Or(input_high,

        input_high,

        Operand(1 << HeapNumber::kMantissaBitsInTopWord));

  // Shift the mantissa bits to the correct position.

  // We don't need to clear non-mantissa bits as they will be shifted away.

  // If they weren't, it would mean that the answer is in the 32bit range.

  __ sllv(input_high, input_high, scratch);

  __ bind(&high_shift_done);

  // Replace the shifted bits with bits from the lower mantissa word.

  Label pos_shift, shift_done;

  __ li(at, 32);

  __ subu(scratch, at, scratch);

  __ Branch(&pos_shift, ge, scratch, Operand(zero_reg));

  // Negate scratch.

  __ Subu(scratch, zero_reg, scratch);

  __ sllv(input_low, input_low, scratch);

  __ Branch(&shift_done);

  __ bind(&pos_shift);

  __ srlv(input_low, input_low, scratch);

  __ bind(&shift_done);

  __ Or(input_high, input_high, Operand(input_low));

  // Restore sign if necessary.

  __ mov(scratch, sign);

  result_reg = sign;

  sign = no_reg;

  __ Subu(result_reg, zero_reg, input_high);

  __ Movz(result_reg, input_high, scratch);

  __ bind(&done);

  __ Pop(scratch, scratch2, scratch3);

  __ Ret();

}

bool WriteInt32ToHeapNumberStub::IsPregenerated(Isolate* isolate) {

  // These variants are compiled ahead of time.  See next method.

  if (the_int_.is(a1) &&

      the_heap_number_.is(v0) &&

      scratch_.is(a2) &&

      sign_.is(a3)) {

    return true;

  }

  if (the_int_.is(a2) &&

      the_heap_number_.is(v0) &&

      scratch_.is(a3) &&

      sign_.is(a0)) {

    return true;

  }

  // Other register combinations are generated as and when they are needed,

  // so it is unsafe to call them from stubs (we can't generate a stub while

  // we are generating a stub).

  return false;

}

void WriteInt32ToHeapNumberStub::GenerateFixedRegStubsAheadOfTime(

    Isolate* isolate) {

  WriteInt32ToHeapNumberStub stub1(a1, v0, a2, a3);

  WriteInt32ToHeapNumberStub stub2(a2, v0, a3, a0);

  stub1.GetCode(isolate)->set_is_pregenerated(true);

  stub2.GetCode(isolate)->set_is_pregenerated(true);

}

// See comment for class, this does NOT work for int32's that are in Smi range.

void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) {

  Label max_negative_int;

  // the_int_ has the answer which is a signed int32 but not a Smi.

  // We test for the special value that has a different exponent.

  STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);

  // Test sign, and save for later conditionals.

  __ And(sign_, the_int_, Operand(0x80000000u));

  __ Branch(&max_negative_int, eq, the_int_, Operand(0x80000000u));

  // Set up the correct exponent in scratch_.  All non-Smi int32s have the same.

  // A non-Smi integer is 1.xxx * 2^30 so the exponent is 30 (biased).

  uint32_t non_smi_exponent =

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

  __ li(scratch_, Operand(non_smi_exponent));

  // Set the sign bit in scratch_ if the value was negative.

  __ or_(scratch_, scratch_, sign_);

  // Subtract from 0 if the value was negative.

  __ subu(at, zero_reg, the_int_);

  __ Movn(the_int_, at, sign_);

  // We should be masking the implict first digit of the mantissa away here,

  // but it just ends up combining harmlessly with the last digit of the

  // exponent that happens to be 1.  The sign bit is 0 so we shift 10 to get

  // the most significant 1 to hit the last bit of the 12 bit sign and exponent.

  ASSERT(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0);

  const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;

  __ srl(at, the_int_, shift_distance);

  __ or_(scratch_, scratch_, at);

  __ sw(scratch_, FieldMemOperand(the_heap_number_,

                                   HeapNumber::kExponentOffset));

  __ sll(scratch_, the_int_, 32 - shift_distance);

  __ Ret(USE_DELAY_SLOT);

  __ sw(scratch_, FieldMemOperand(the_heap_number_,

                                   HeapNumber::kMantissaOffset));

  __ bind(&max_negative_int);

  // The max negative int32 is stored as a positive number in the mantissa of

  // a double because it uses a sign bit instead of using two's complement.

  // The actual mantissa bits stored are all 0 because the implicit most

  // significant 1 bit is not stored.

  non_smi_exponent += 1 << HeapNumber::kExponentShift;

  __ li(scratch_, Operand(HeapNumber::kSignMask | non_smi_exponent));

  __ sw(scratch_,

        FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset));

  __ mov(scratch_, zero_reg);

  __ Ret(USE_DELAY_SLOT);

  __ sw(scratch_,

        FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset));

}

// Handle the case where the lhs and rhs are the same object.

// Equality is almost reflexive (everything but NaN), so this is a test

// for "identity and not NaN".

static void EmitIdenticalObjectComparison(MacroAssembler* masm,

                                          Label* slow,

                                          Condition cc) {

  Label not_identical;

  Label heap_number, return_equal;

  Register exp_mask_reg = t5;

  __ Branch(&not_identical, ne, a0, Operand(a1));

  __ li(exp_mask_reg, Operand(HeapNumber::kExponentMask));

  // Test for NaN. Sadly, we can't just compare to Factory::nan_value(),

  // so we do the second best thing - test it ourselves.

  // They are both equal and they are not both Smis so both of them are not

  // Smis. If it's not a heap number, then return equal.

  if (cc == less || cc == greater) {

    __ GetObjectType(a0, t4, t4);

    __ Branch(slow, greater, t4, Operand(FIRST_SPEC_OBJECT_TYPE));

  } else {

    __ GetObjectType(a0, t4, t4);

    __ Branch(&heap_number, eq, t4, Operand(HEAP_NUMBER_TYPE));

    // Comparing JS objects with <=, >= is complicated.

    if (cc != eq) {

    __ Branch(slow, greater, t4, Operand(FIRST_SPEC_OBJECT_TYPE));

      // Normally here we fall through to return_equal, but undefined is

      // special: (undefined == undefined) == true, but

      // (undefined <= undefined) == false!  See ECMAScript 11.8.5.

      if (cc == less_equal || cc == greater_equal) {

        __ Branch(&return_equal, ne, t4, Operand(ODDBALL_TYPE));

        __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);

        __ Branch(&return_equal, ne, a0, Operand(t2));

        ASSERT(is_int16(GREATER) && is_int16(LESS));

        __ Ret(USE_DELAY_SLOT);

        if (cc == le) {

          // undefined <= undefined should fail.

          __ li(v0, Operand(GREATER));

        } else  {

          // undefined >= undefined should fail.

          __ li(v0, Operand(LESS));

        }

      }

    }

  }

  __ bind(&return_equal);

  ASSERT(is_int16(GREATER) && is_int16(LESS));

  __ Ret(USE_DELAY_SLOT);

  if (cc == less) {

    __ li(v0, Operand(GREATER));  // Things aren't less than themselves.

  } else if (cc == greater) {

    __ li(v0, Operand(LESS));     // Things aren't greater than themselves.

  } else {

    __ mov(v0, zero_reg);         // Things are <=, >=, ==, === themselves.

  }

  // For less and greater we don't have to check for NaN since the result of

  // x < x is false regardless.  For the others here is some code to check

  // for NaN.

  if (cc != lt && cc != gt) {

    __ bind(&heap_number);

    // It is a heap number, so return non-equal if it's NaN and equal if it's

    // not NaN.

    // The representation of NaN values has all exponent bits (52..62) set,

    // and not all mantissa bits (0..51) clear.

    // Read top bits of double representation (second word of value).

    __ lw(t2, FieldMemOperand(a0, HeapNumber::kExponentOffset));

    // Test that exponent bits are all set.

    __ And(t3, t2, Operand(exp_mask_reg));

    // If all bits not set (ne cond), then not a NaN, objects are equal.

    __ Branch(&return_equal, ne, t3, Operand(exp_mask_reg));

    // Shift out flag and all exponent bits, retaining only mantissa.

    __ sll(t2, t2, HeapNumber::kNonMantissaBitsInTopWord);

    // Or with all low-bits of mantissa.

    __ lw(t3, FieldMemOperand(a0, HeapNumber::kMantissaOffset));

    __ Or(v0, t3, Operand(t2));

    // For equal we already have the right value in v0:  Return zero (equal)

    // if all bits in mantissa are zero (it's an Infinity) and non-zero if

    // not (it's a NaN).  For <= and >= we need to load v0 with the failing

    // value if it's a NaN.

    if (cc != eq) {

      // All-zero means Infinity means equal.

      __ Ret(eq, v0, Operand(zero_reg));

      ASSERT(is_int16(GREATER) && is_int16(LESS));

      __ Ret(USE_DELAY_SLOT);

      if (cc == le) {

        __ li(v0, Operand(GREATER));  // NaN <= NaN should fail.

      } else {

        __ li(v0, Operand(LESS));     // NaN >= NaN should fail.

      }

    }

  }

  // No fall through here.

  __ bind(&not_identical);

}

static void EmitSmiNonsmiComparison(MacroAssembler* masm,

                                    Register lhs,

                                    Register rhs,

                                    Label* both_loaded_as_doubles,

                                    Label* slow,

                                    bool strict) {

  ASSERT((lhs.is(a0) && rhs.is(a1)) ||

         (lhs.is(a1) && rhs.is(a0)));

  Label lhs_is_smi;

  __ JumpIfSmi(lhs, &lhs_is_smi);

  // Rhs is a Smi.

  // Check whether the non-smi is a heap number.

  __ GetObjectType(lhs, t4, t4);

  if (strict) {

    // If lhs was not a number and rhs was a Smi then strict equality cannot

    // succeed. Return non-equal (lhs is already not zero).

    __ Ret(USE_DELAY_SLOT, ne, t4, Operand(HEAP_NUMBER_TYPE));

    __ mov(v0, lhs);

  } else {

    // Smi compared non-strictly with a non-Smi non-heap-number. Call

    // the runtime.

    __ Branch(slow, ne, t4, Operand(HEAP_NUMBER_TYPE));

  }

  // Rhs is a smi, lhs is a number.

  // Convert smi rhs to double.

  __ sra(at, rhs, kSmiTagSize);

  __ mtc1(at, f14);

  __ cvt_d_w(f14, f14);

  __ ldc1(f12, FieldMemOperand(lhs, HeapNumber::kValueOffset));

  // We now have both loaded as doubles.

  __ jmp(both_loaded_as_doubles);

  __ bind(&lhs_is_smi);

  // Lhs is a Smi.  Check whether the non-smi is a heap number.

  __ GetObjectType(rhs, t4, t4);

  if (strict) {

    // If lhs was not a number and rhs was a Smi then strict equality cannot

    // succeed. Return non-equal.

    __ Ret(USE_DELAY_SLOT, ne, t4, Operand(HEAP_NUMBER_TYPE));

    __ li(v0, Operand(1));

  } else {

    // Smi compared non-strictly with a non-Smi non-heap-number. Call

    // the runtime.

    __ Branch(slow, ne, t4, Operand(HEAP_NUMBER_TYPE));

  }

  // Lhs is a smi, rhs is a number.

  // Convert smi lhs to double.

  __ sra(at, lhs, kSmiTagSize);

  __ mtc1(at, f12);

  __ cvt_d_w(f12, f12);

  __ ldc1(f14, FieldMemOperand(rhs, HeapNumber::kValueOffset));

  // Fall through to both_loaded_as_doubles.

}

static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,

                                           Register lhs,

                                           Register rhs) {

    // If either operand is a JS object or an oddball value, then they are

    // not equal since their pointers are different.

    // There is no test for undetectability in strict equality.

    STATIC_ASSERT(LAST_TYPE == LAST_SPEC_OBJECT_TYPE);

    Label first_non_object;

    // Get the type of the first operand into a2 and compare it with

    // FIRST_SPEC_OBJECT_TYPE.

    __ GetObjectType(lhs, a2, a2);

    __ Branch(&first_non_object, less, a2, Operand(FIRST_SPEC_OBJECT_TYPE));

    // Return non-zero.

    Label return_not_equal;

    __ bind(&return_not_equal);

    __ Ret(USE_DELAY_SLOT);

    __ li(v0, Operand(1));

    __ bind(&first_non_object);

    // Check for oddballs: true, false, null, undefined.

    __ Branch(&return_not_equal, eq, a2, Operand(ODDBALL_TYPE));

    __ GetObjectType(rhs, a3, a3);

    __ Branch(&return_not_equal, greater, a3, Operand(FIRST_SPEC_OBJECT_TYPE));

    // Check for oddballs: true, false, null, undefined.

    __ Branch(&return_not_equal, eq, a3, Operand(ODDBALL_TYPE));

    // Now that we have the types we might as well check for

    // internalized-internalized.

    STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);

    __ Or(a2, a2, Operand(a3));

    __ And(at, a2, Operand(kIsNotStringMask | kIsNotInternalizedMask));

    __ Branch(&return_not_equal, eq, at, Operand(zero_reg));

}

static void EmitCheckForTwoHeapNumbers(MacroAssembler* masm,

                                       Register lhs,

                                       Register rhs,

                                       Label* both_loaded_as_doubles,

                                       Label* not_heap_numbers,

                                       Label* slow) {

  __ GetObjectType(lhs, a3, a2);

  __ Branch(not_heap_numbers, ne, a2, Operand(HEAP_NUMBER_TYPE));

  __ lw(a2, FieldMemOperand(rhs, HeapObject::kMapOffset));

  // If first was a heap number & second wasn't, go to slow case.

  __ Branch(slow, ne, a3, Operand(a2));

  // Both are heap numbers. Load them up then jump to the code we have

  // for that.

  __ ldc1(f12, FieldMemOperand(lhs, HeapNumber::kValueOffset));

  __ ldc1(f14, FieldMemOperand(rhs, HeapNumber::kValueOffset));

  __ jmp(both_loaded_as_doubles);

}

// Fast negative check for internalized-to-internalized equality.

static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,

                                                     Register lhs,

                                                     Register rhs,

                                                     Label* possible_strings,

                                                     Label* not_both_strings) {

  ASSERT((lhs.is(a0) && rhs.is(a1)) ||

         (lhs.is(a1) && rhs.is(a0)));

  // a2 is object type of rhs.

  Label object_test;

  STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);

  __ And(at, a2, Operand(kIsNotStringMask));

  __ Branch(&object_test, ne, at, Operand(zero_reg));

  __ And(at, a2, Operand(kIsNotInternalizedMask));

  __ Branch(possible_strings, ne, at, Operand(zero_reg));

  __ GetObjectType(rhs, a3, a3);

  __ Branch(not_both_strings, ge, a3, Operand(FIRST_NONSTRING_TYPE));

  __ And(at, a3, Operand(kIsNotInternalizedMask));

  __ Branch(possible_strings, ne, at, Operand(zero_reg));

  // Both are internalized strings. We already checked they weren't the same

  // pointer so they are not equal.

  __ Ret(USE_DELAY_SLOT);

  __ li(v0, Operand(1));   // Non-zero indicates not equal.

  __ bind(&object_test);

  __ Branch(not_both_strings, lt, a2, Operand(FIRST_SPEC_OBJECT_TYPE));

  __ GetObjectType(rhs, a2, a3);

  __ Branch(not_both_strings, lt, a3, Operand(FIRST_SPEC_OBJECT_TYPE));

  // If both objects are undetectable, they are equal.  Otherwise, they

  // are not equal, since they are different objects and an object is not

  // equal to undefined.

  __ lw(a3, FieldMemOperand(lhs, HeapObject::kMapOffset));

  __ lbu(a2, FieldMemOperand(a2, Map::kBitFieldOffset));

  __ lbu(a3, FieldMemOperand(a3, Map::kBitFieldOffset));

  __ and_(a0, a2, a3);

  __ And(a0, a0, Operand(1 << Map::kIsUndetectable));

  __ Ret(USE_DELAY_SLOT);

  __ xori(v0, a0, 1 << Map::kIsUndetectable);

}

static void ICCompareStub_CheckInputType(MacroAssembler* masm,

                                         Register input,

                                         Register scratch,

                                         CompareIC::State expected,

                                         Label* fail) {

  Label ok;

  if (expected == CompareIC::SMI) {

    __ JumpIfNotSmi(input, fail);

  } else if (expected == CompareIC::NUMBER) {

    __ JumpIfSmi(input, &ok);

    __ CheckMap(input, scratch, Heap::kHeapNumberMapRootIndex, fail,

                DONT_DO_SMI_CHECK);

  }

  // We could be strict about internalized/string here, but as long as

  // hydrogen doesn't care, the stub doesn't have to care either.

  __ bind(&ok);

}

// On entry a1 and a2 are the values to be compared.

// On exit a0 is 0, positive or negative to indicate the result of

// the comparison.

void ICCompareStub::GenerateGeneric(MacroAssembler* masm) {

  Register lhs = a1;

  Register rhs = a0;

  Condition cc = GetCondition();

  Label miss;

  ICCompareStub_CheckInputType(masm, lhs, a2, left_, &miss);

  ICCompareStub_CheckInputType(masm, rhs, a3, right_, &miss);

  Label slow;  // Call builtin.

  Label not_smis, both_loaded_as_doubles;

  Label not_two_smis, smi_done;

  __ Or(a2, a1, a0);

  __ JumpIfNotSmi(a2, &not_two_smis);

  __ sra(a1, a1, 1);

  __ sra(a0, a0, 1);

  __ Ret(USE_DELAY_SLOT);

  __ subu(v0, a1, a0);

  __ bind(&not_two_smis);

  // NOTICE! This code is only reached after a smi-fast-case check, so

  // it is certain that at least one operand isn't a smi.

  // Handle the case where the objects are identical.  Either returns the answer

  // or goes to slow.  Only falls through if the objects were not identical.

  EmitIdenticalObjectComparison(masm, &slow, cc);

  // If either is a Smi (we know that not both are), then they can only

  // be strictly equal if the other is a HeapNumber.

  STATIC_ASSERT(kSmiTag == 0);

  ASSERT_EQ(0, Smi::FromInt(0));

  __ And(t2, lhs, Operand(rhs));

  __ JumpIfNotSmi(t2, &not_smis, t0);

  // One operand is a smi. EmitSmiNonsmiComparison generates code that can:

  // 1) Return the answer.

  // 2) Go to slow.

  // 3) Fall through to both_loaded_as_doubles.

  // 4) Jump to rhs_not_nan.

  // In cases 3 and 4 we have found out we were dealing with a number-number

  // comparison and the numbers have been loaded into f12 and f14 as doubles,

  // or in GP registers (a0, a1, a2, a3) depending on the presence of the FPU.

  EmitSmiNonsmiComparison(masm, lhs, rhs,

                          &both_loaded_as_doubles, &slow, strict());

  __ bind(&both_loaded_as_doubles);

  // f12, f14 are the double representations of the left hand side

  // and the right hand side if we have FPU. Otherwise a2, a3 represent

  // left hand side and a0, a1 represent right hand side.

  Isolate* isolate = masm->isolate();

  Label nan;

  __ li(t0, Operand(LESS));

  __ li(t1, Operand(GREATER));

  __ li(t2, Operand(EQUAL));

  // Check if either rhs or lhs is NaN.

  __ BranchF(NULL, &nan, eq, f12, f14);

  // Check if LESS condition is satisfied. If true, move conditionally

  // result to v0.

  __ c(OLT, D, f12, f14);

  __ Movt(v0, t0);

  // Use previous check to store conditionally to v0 oposite condition

  // (GREATER). If rhs is equal to lhs, this will be corrected in next

  // check.

  __ Movf(v0, t1);

  // Check if EQUAL condition is satisfied. If true, move conditionally

  // result to v0.

  __ c(EQ, D, f12, f14);

  __ Movt(v0, t2);

  __ Ret();

  __ bind(&nan);

  // NaN comparisons always fail.

  // Load whatever we need in v0 to make the comparison fail.

  ASSERT(is_int16(GREATER) && is_int16(LESS));

  __ Ret(USE_DELAY_SLOT);

  if (cc == lt || cc == le) {

    __ li(v0, Operand(GREATER));

  } else {

    __ li(v0, Operand(LESS));

  }

  __ bind(&not_smis);

  // At this point we know we are dealing with two different objects,

  // and neither of them is a Smi. The objects are in lhs_ and rhs_.

  if (strict()) {

    // This returns non-equal for some object types, or falls through if it

    // was not lucky.

    EmitStrictTwoHeapObjectCompare(masm, lhs, rhs);

  }

  Label check_for_internalized_strings;

  Label flat_string_check;

  // Check for heap-number-heap-number comparison. Can jump to slow case,

  // or load both doubles and jump to the code that handles

  // that case. If the inputs are not doubles then jumps to

  // check_for_internalized_strings.

  // In this case a2 will contain the type of lhs_.

  EmitCheckForTwoHeapNumbers(masm,

                             lhs,

                             rhs,

                             &both_loaded_as_doubles,

                             &check_for_internalized_strings,

                             &flat_string_check);

  __ bind(&check_for_internalized_strings);

  if (cc == eq && !strict()) {

    // Returns an answer for two internalized strings or two

    // detectable objects.

    // Otherwise jumps to string case or not both strings case.

    // Assumes that a2 is the type of lhs_ on entry.

    EmitCheckForInternalizedStringsOrObjects(

        masm, lhs, rhs, &flat_string_check, &slow);

  }

  // Check for both being sequential ASCII strings, and inline if that is the

  // case.

  __ bind(&flat_string_check);

  __ JumpIfNonSmisNotBothSequentialAsciiStrings(lhs, rhs, a2, a3, &slow);

  __ IncrementCounter(isolate->counters()->string_compare_native(), 1, a2, a3);

  if (cc == eq) {

    StringCompareStub::GenerateFlatAsciiStringEquals(masm,

                                                     lhs,

                                                     rhs,

                                                     a2,

                                                     a3,

                                                     t0);

  } else {

    StringCompareStub::GenerateCompareFlatAsciiStrings(masm,

                                                       lhs,

                                                       rhs,

                                                       a2,

                                                       a3,

                                                       t0,

                                                       t1);

  }

  // Never falls through to here.

  __ bind(&slow);

  // Prepare for call to builtin. Push object pointers, a0 (lhs) first,

  // a1 (rhs) second.

  __ Push(lhs, rhs);

  // Figure out which native to call and setup the arguments.

  Builtins::JavaScript native;

  if (cc == eq) {

    native = strict() ? Builtins::STRICT_EQUALS : Builtins::EQUALS;

  } else {

    native = Builtins::COMPARE;

    int ncr;  // NaN compare result.

    if (cc == lt || cc == le) {

      ncr = GREATER;

    } else {

      ASSERT(cc == gt || cc == ge);  // Remaining cases.

      ncr = LESS;

    }

    __ li(a0, Operand(Smi::FromInt(ncr)));

    __ push(a0);

  }

  // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)

  // tagged as a small integer.

  __ InvokeBuiltin(native, JUMP_FUNCTION);

  __ bind(&miss);

  GenerateMiss(masm);

}

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.

  __ MultiPush(kJSCallerSaved | ra.bit());

  if (save_doubles_ == kSaveFPRegs) {

    __ MultiPushFPU(kCallerSavedFPU);

  }

  const int argument_count = 1;

  const int fp_argument_count = 0;

  const Register scratch = a1;

  AllowExternalCallThatCantCauseGC scope(masm);

  __ PrepareCallCFunction(argument_count, fp_argument_count, scratch);

  __ li(a0, Operand(ExternalReference::isolate_address(masm->isolate())));

  __ CallCFunction(

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

      argument_count);

  if (save_doubles_ == kSaveFPRegs) {

    __ MultiPopFPU(kCallerSavedFPU);

  }

  __ MultiPop(kJSCallerSaved | ra.bit());

  __ Ret();

}

void BinaryOpStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { a1, a0 };

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

}

void TranscendentalCacheStub::Generate(MacroAssembler* masm) {

  // Untagged case: double input in f4, double result goes

  //   into f4.

  // Tagged case: tagged input on top of stack and in a0,

  //   tagged result (heap number) goes into v0.

  Label input_not_smi;

  Label loaded;

  Label calculate;

  Label invalid_cache;

  const Register scratch0 = t5;

  const Register scratch1 = t3;

  const Register cache_entry = a0;

  const bool tagged = (argument_type_ == TAGGED);

  if (tagged) {

    // Argument is a number and is on stack and in a0.

    // Load argument and check if it is a smi.

    __ JumpIfNotSmi(a0, &input_not_smi);

    // Input is a smi. Convert to double and load the low and high words

    // of the double into a2, a3.

    __ sra(t0, a0, kSmiTagSize);

    __ mtc1(t0, f4);

    __ cvt_d_w(f4, f4);

    __ Move(a2, a3, f4);

    __ Branch(&loaded);

    __ bind(&input_not_smi);

    // Check if input is a HeapNumber.

    __ CheckMap(a0,

                a1,

                Heap::kHeapNumberMapRootIndex,

                &calculate,

                DONT_DO_SMI_CHECK);

    // Input is a HeapNumber. Store the

    // low and high words into a2, a3.

    __ lw(a2, FieldMemOperand(a0, HeapNumber::kValueOffset));

    __ lw(a3, FieldMemOperand(a0, HeapNumber::kValueOffset + 4));

  } else {

    // Input is untagged double in f4. Output goes to f4.

    __ Move(a2, a3, f4);

  }

  __ bind(&loaded);

  // a2 = low 32 bits of double value.

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

  __ Xor(a1, a2, a3);

  __ sra(t0, a1, 16);

  __ Xor(a1, a1, t0);

  __ sra(t0, a1, 8);

  __ Xor(a1, a1, t0);

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

  __ And(a1, a1, Operand(TranscendentalCache::SubCache::kCacheSize - 1));

  // a2 = low 32 bits of double value.

  // a3 = high 32 bits of double value.

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

  __ li(cache_entry, Operand(

      ExternalReference::transcendental_cache_array_address(

          masm->isolate())));

  // a0 points to cache array.

  __ lw(cache_entry, MemOperand(cache_entry, type_ * sizeof(

      Isolate::Current()->transcendental_cache()->caches_[0])));

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

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

  __ Branch(&invalid_cache, eq, cache_entry, Operand(zero_reg));

#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 a1'st entry in the cache, i.e., &a0[a1*12].

  __ sll(t0, a1, 1);

  __ Addu(a1, a1, t0);

  __ sll(t0, a1, 2);

  __ Addu(cache_entry, cache_entry, t0);

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

  __ lw(t0, MemOperand(cache_entry, 0));

  __ lw(t1, MemOperand(cache_entry, 4));

  __ lw(t2, MemOperand(cache_entry, 8));

  __ Branch(&calculate, ne, a2, Operand(t0));

  __ Branch(&calculate, ne, a3, Operand(t1));

  // Cache hit. Load result, cleanup and return.

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

  __ IncrementCounter(

      counters->transcendental_cache_hit(), 1, scratch0, scratch1);

  if (tagged) {

    // Pop input value from stack and load result into v0.

    __ Drop(1);

    __ mov(v0, t2);

  } else {

    // Load result into f4.

    __ ldc1(f4, FieldMemOperand(t2, HeapNumber::kValueOffset));

  }

  __ Ret();

  __ bind(&calculate);

  __ IncrementCounter(

      counters->transcendental_cache_miss(), 1, scratch0, scratch1);

  if (tagged) {

    __ bind(&invalid_cache);

    __ TailCallExternalReference(ExternalReference(RuntimeFunction(),

                                                   masm->isolate()),

                                 1,

                                 1);

  } else {

    Label no_update;

    Label skip_cache;

    // Call C function to calculate the result and update the cache.

    // a0: precalculated cache entry address.

    // a2 and a3: parts of the double value.

    // Store a0, a2 and a3 on stack for later before calling C function.

    __ Push(a3, a2, cache_entry);

    GenerateCallCFunction(masm, scratch0);

    __ GetCFunctionDoubleResult(f4);

    // Try to update the cache. If we cannot allocate a

    // heap number, we return the result without updating.

    __ Pop(a3, a2, cache_entry);

    __ LoadRoot(t1, Heap::kHeapNumberMapRootIndex);

    __ AllocateHeapNumber(t2, scratch0, scratch1, t1, &no_update);

    __ sdc1(f4, FieldMemOperand(t2, HeapNumber::kValueOffset));

    __ sw(a2, MemOperand(cache_entry, 0 * kPointerSize));

    __ sw(a3, MemOperand(cache_entry, 1 * kPointerSize));

    __ sw(t2, MemOperand(cache_entry, 2 * kPointerSize));

    __ Ret(USE_DELAY_SLOT);

    __ mov(v0, cache_entry);

    __ bind(&invalid_cache);

    // The cache is invalid. Call runtime which will recreate the

    // cache.

    __ LoadRoot(t1, Heap::kHeapNumberMapRootIndex);

    __ AllocateHeapNumber(a0, scratch0, scratch1, t1, &skip_cache);

    __ sdc1(f4, FieldMemOperand(a0, HeapNumber::kValueOffset));

    {

      FrameScope scope(masm, StackFrame::INTERNAL);

      __ push(a0);

      __ CallRuntime(RuntimeFunction(), 1);

    }

    __ ldc1(f4, FieldMemOperand(v0, HeapNumber::kValueOffset));

    __ Ret();

    __ bind(&skip_cache);

    // Call C function to calculate the result and answer directly

    // without updating the cache.

    GenerateCallCFunction(masm, scratch0);

    __ GetCFunctionDoubleResult(f4);

    __ bind(&no_update);

    // We return the value in f4 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 aligned object larger than a HeapNumber.

      ASSERT(4 * kPointerSize >= HeapNumber::kSize);

      __ li(scratch0, Operand(4 * kPointerSize));

      __ push(scratch0);

      __ CallRuntimeSaveDoubles(Runtime::kAllocateInNewSpace);

    }

    __ Ret();

  }

}

void TranscendentalCacheStub::GenerateCallCFunction(MacroAssembler* masm,

                                                    Register scratch) {

  __ push(ra);

  __ PrepareCallCFunction(2, scratch);

  if (IsMipsSoftFloatABI) {

    __ Move(a0, a1, f4);

  } else {

    __ mov_d(f12, f4);

  }

  AllowExternalCallThatCantCauseGC scope(masm);

  Isolate* isolate = masm->isolate();

  switch (type_) {

    case TranscendentalCache::SIN:

      __ CallCFunction(

          ExternalReference::math_sin_double_function(isolate),

          0, 1);

      break;

    case TranscendentalCache::COS:

      __ CallCFunction(

          ExternalReference::math_cos_double_function(isolate),

          0, 1);

      break;

    case TranscendentalCache::TAN: