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_ARM

#include "bootstrapper.h"

#include "code-stubs.h"

#include "regexp-macro-assembler.h"

#include "stub-cache.h"

namespace v8 {

namespace internal {

void FastNewClosureStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { r2 };

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

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void NumberToStringStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { r0 };

  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[] = { r3, r2, r1 };

  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[] = { r3, r2, r1, r0 };

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

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { r1, r0 };

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

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedLoadFieldStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { r1 };

  descriptor->register_param_count_ = 1;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = NULL;

}

void KeyedStoreFastElementStub::InitializeInterfaceDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { r2, r1, r0 };

  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[] = { r0, r1 };

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

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

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor) {

  static Register registers[] = { r1, r0 };

  descriptor->register_param_count_ = 2;

  descriptor->register_params_ = registers;

  descriptor->deoptimization_handler_ = FUNCTION_ADDR(BinaryOpIC_Miss);

  descriptor->SetMissHandler(

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

}

static void InitializeArrayConstructorDescriptor(

    Isolate* isolate,

    CodeStubInterfaceDescriptor* descriptor,

    int constant_stack_parameter_count) {

  // register state

  // r0 -- number of arguments

  // r1 -- function

  // r2 -- type info cell with elements kind

  static Register registers[] = { r1, r2 };

  descriptor->register_param_count_ = 2;

  if (constant_stack_parameter_count != 0) {

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

    descriptor->stack_parameter_count_ = r0;

  }

  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

  // r0 -- number of arguments

  // r1 -- constructor function

  static Register registers[] = { r1 };

  descriptor->register_param_count_ = 1;

  if (constant_stack_parameter_count != 0) {

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

    descriptor->stack_parameter_count_ = r0;

  }

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

  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[] = { r1, r2, r0 };

  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[] = { r0, r3, r1, r2 };

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

static void EmitSmiNonsmiComparison(MacroAssembler* masm,

                                    Register lhs,

                                    Register rhs,

                                    Label* lhs_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 ||

           r0.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), r0, r1, r2, &gc, TAG_OBJECT);

  // Load the function from the stack.

  __ ldr(r3, MemOperand(sp, 0));

  // Set up the object header.

  __ LoadRoot(r1, Heap::kFunctionContextMapRootIndex);

  __ mov(r2, Operand(Smi::FromInt(length)));

  __ str(r2, FieldMemOperand(r0, FixedArray::kLengthOffset));

  __ str(r1, FieldMemOperand(r0, HeapObject::kMapOffset));

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

  __ ldr(r2, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  __ mov(r1, Operand(Smi::FromInt(0)));

  __ str(r3, MemOperand(r0, Context::SlotOffset(Context::CLOSURE_INDEX)));

  __ str(cp, MemOperand(r0, Context::SlotOffset(Context::PREVIOUS_INDEX)));

  __ str(r1, MemOperand(r0, Context::SlotOffset(Context::EXTENSION_INDEX)));

  __ str(r2, MemOperand(r0, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));

  // Initialize the rest of the slots to undefined.

  __ LoadRoot(r1, Heap::kUndefinedValueRootIndex);

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

    __ str(r1, MemOperand(r0, Context::SlotOffset(i)));

  }

  // Remove the on-stack argument and return.

  __ mov(cp, r0);

  __ pop();

  __ Ret();

  // 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), r0, r1, r2, &gc, TAG_OBJECT);

  // Load the function from the stack.

  __ ldr(r3, MemOperand(sp, 0));

  // Load the serialized scope info from the stack.

  __ ldr(r1, MemOperand(sp, 1 * kPointerSize));

  // Set up the object header.

  __ LoadRoot(r2, Heap::kBlockContextMapRootIndex);

  __ str(r2, FieldMemOperand(r0, HeapObject::kMapOffset));

  __ mov(r2, Operand(Smi::FromInt(length)));

  __ str(r2, FieldMemOperand(r0, 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(r3, &after_sentinel);

  if (FLAG_debug_code) {

    __ cmp(r3, Operand::Zero());

    __ Assert(eq, kExpected0AsASmiSentinel);

  }

  __ ldr(r3, GlobalObjectOperand());

  __ ldr(r3, FieldMemOperand(r3, GlobalObject::kNativeContextOffset));

  __ ldr(r3, ContextOperand(r3, Context::CLOSURE_INDEX));

  __ bind(&after_sentinel);

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

  __ ldr(r2, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));

  __ str(r3, ContextOperand(r0, Context::CLOSURE_INDEX));

  __ str(cp, ContextOperand(r0, Context::PREVIOUS_INDEX));

  __ str(r1, ContextOperand(r0, Context::EXTENSION_INDEX));

  __ str(r2, ContextOperand(r0, Context::GLOBAL_OBJECT_INDEX));

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

  __ LoadRoot(r1, Heap::kTheHoleValueRootIndex);

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

    __ str(r1, ContextOperand(r0, i + Context::MIN_CONTEXT_SLOTS));

  }

  // Remove the on-stack argument and return.

  __ mov(cp, r0);

  __ add(sp, sp, Operand(2 * kPointerSize));

  __ Ret();

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

  Register exponent = result1_;

  Register mantissa = result2_;

  Label not_special;

  __ SmiUntag(source_);

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

  // Subtract from 0 if source was negative.

  __ rsb(source_, source_, Operand::Zero(), LeaveCC, ne);

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

  __ cmp(source_, Operand(1));

  __ b(gt, &not_special);

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

  __ orr(exponent, exponent, Operand(exponent_word_for_1), LeaveCC, eq);

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

  __ mov(mantissa, Operand::Zero());

  __ Ret();

  __ bind(&not_special);

  __ clz(zeros_, source_);

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

  // We use mantissa as a scratch register here.  Use a fudge factor to

  // divide the constant 31 + HeapNumber::kExponentBias, 0x41d, into two parts

  // that fit in the ARM's constant field.

  int fudge = 0x400;

  __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias - fudge));

  __ add(mantissa, mantissa, Operand(fudge));

  __ orr(exponent,

         exponent,

         Operand(mantissa, LSL, HeapNumber::kExponentShift));

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

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

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

  __ mov(source_, Operand(source_, LSL, zeros_));

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

  __ mov(mantissa, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord));

  // And the top (top 20 bits).

  __ orr(exponent,

         exponent,

         Operand(source_, LSR, 32 - HeapNumber::kMantissaBitsInTopWord));

  __ Ret();

}

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 += 2 * kPointerSize;

  // Immediate values for this stub fit in instructions, so it's safe to use ip.

  Register scratch = ip;

  Register scratch_low =

      GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch);

  Register scratch_high =

      GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch, scratch_low);

  LowDwVfpRegister double_scratch = kScratchDoubleReg;

  __ Push(scratch_high, scratch_low);

  if (!skip_fastpath()) {

    // Load double input.

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

    __ vmov(scratch_low, scratch_high, double_scratch);

    // Do fast-path convert from double to int.

    __ vcvt_s32_f64(double_scratch.low(), double_scratch);

    __ vmov(result_reg, double_scratch.low());

    // If result is not saturated (0x7fffffff or 0x80000000), we are done.

    __ sub(scratch, result_reg, Operand(1));

    __ cmp(scratch, Operand(0x7ffffffe));

    __ b(lt, &done);

  } else {

    // We've already done MacroAssembler::TryFastTruncatedDoubleToILoad, so we

    // know exponent > 31, so we can skip the vcvt_s32_f64 which will saturate.

    if (double_offset == 0) {

      __ ldm(ia, input_reg, scratch_low.bit() | scratch_high.bit());

    } else {

      __ ldr(scratch_low, MemOperand(input_reg, double_offset));

      __ ldr(scratch_high, MemOperand(input_reg, double_offset + kIntSize));

    }

  }

  __ Ubfx(scratch, scratch_high,

         HeapNumber::kExponentShift, HeapNumber::kExponentBits);

  // Load scratch with exponent - 1. This is faster than loading

  // with exponent because Bias + 1 = 1024 which is an *ARM* immediate value.

  STATIC_ASSERT(HeapNumber::kExponentBias + 1 == 1024);

  __ sub(scratch, scratch, Operand(HeapNumber::kExponentBias + 1));

  // If exponent is greater than or equal to 84, the 32 less significant

  // bits are 0s (2^84 = 1, 52 significant bits, 32 uncoded bits),

  // the result is 0.

  // Compare exponent with 84 (compare exponent - 1 with 83).

  __ cmp(scratch, Operand(83));

  __ b(ge, &out_of_range);

  // If we reach this code, 31 <= exponent <= 83.

  // So, we don't have to handle cases where 0 <= exponent <= 20 for

  // which we would need to shift right the high part of the mantissa.

  // Scratch contains exponent - 1.

  // Load scratch with 52 - exponent (load with 51 - (exponent - 1)).

  __ rsb(scratch, scratch, Operand(51), SetCC);

  __ b(ls, &only_low);

  // 21 <= exponent <= 51, shift scratch_low and scratch_high

  // to generate the result.

  __ mov(scratch_low, Operand(scratch_low, LSR, scratch));

  // Scratch contains: 52 - exponent.

  // We needs: exponent - 20.

  // So we use: 32 - scratch = 32 - 52 + exponent = exponent - 20.

  __ rsb(scratch, scratch, Operand(32));

  __ Ubfx(result_reg, scratch_high,

          0, HeapNumber::kMantissaBitsInTopWord);

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

  __ orr(result_reg, result_reg,

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

  __ orr(result_reg, scratch_low, Operand(result_reg, LSL, scratch));

  __ b(&negate);

  __ bind(&out_of_range);

  __ mov(result_reg, Operand::Zero());

  __ b(&done);

  __ bind(&only_low);

  // 52 <= exponent <= 83, shift only scratch_low.

  // On entry, scratch contains: 52 - exponent.

  __ rsb(scratch, scratch, Operand::Zero());

  __ mov(result_reg, Operand(scratch_low, LSL, scratch));

  __ bind(&negate);

  // If input was positive, scratch_high ASR 31 equals 0 and

  // scratch_high LSR 31 equals zero.

  // New result = (result eor 0) + 0 = result.

  // If the input was negative, we have to negate the result.

  // Input_high ASR 31 equals 0xffffffff and scratch_high LSR 31 equals 1.

  // New result = (result eor 0xffffffff) + 1 = 0 - result.

  __ eor(result_reg, result_reg, Operand(scratch_high, ASR, 31));

  __ add(result_reg, result_reg, Operand(scratch_high, LSR, 31));

  __ bind(&done);

  __ Pop(scratch_high, scratch_low);

  __ Ret();

}

bool WriteInt32ToHeapNumberStub::IsPregenerated(Isolate* isolate) {

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

  if (the_int_.is(r1) && the_heap_number_.is(r0) && scratch_.is(r2)) {

    return true;

  }

  if (the_int_.is(r2) && the_heap_number_.is(r0) && scratch_.is(r3)) {

    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(r1, r0, r2);

  WriteInt32ToHeapNumberStub stub2(r2, r0, r3);

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

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

}

// See comment for class.

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.  This test

  // has the neat side effect of setting the flags according to the sign.

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

  __ cmp(the_int_, Operand(0x80000000u));

  __ b(eq, &max_negative_int);

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

  __ mov(scratch_, Operand(non_smi_exponent));

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

  __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs);

  // Subtract from 0 if the value was negative.

  __ rsb(the_int_, the_int_, Operand::Zero(), LeaveCC, cs);

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

  __ orr(scratch_, scratch_, Operand(the_int_, LSR, shift_distance));

  __ str(scratch_, FieldMemOperand(the_heap_number_,

                                   HeapNumber::kExponentOffset));

  __ mov(scratch_, Operand(the_int_, LSL, 32 - shift_distance));

  __ str(scratch_, FieldMemOperand(the_heap_number_,

                                   HeapNumber::kMantissaOffset));

  __ Ret();

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

  __ mov(ip, Operand(HeapNumber::kSignMask | non_smi_exponent));

  __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset));

  __ mov(ip, Operand::Zero());

  __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset));

  __ Ret();

}

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

  Label not_identical;

  Label heap_number, return_equal;

  __ cmp(r0, r1);

  __ b(ne, &not_identical);

  // 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 (cond == lt || cond == gt) {

    __ CompareObjectType(r0, r4, r4, FIRST_SPEC_OBJECT_TYPE);

    __ b(ge, slow);

  } else {

    __ CompareObjectType(r0, r4, r4, HEAP_NUMBER_TYPE);

    __ b(eq, &heap_number);

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

    if (cond != eq) {

      __ cmp(r4, Operand(FIRST_SPEC_OBJECT_TYPE));

      __ b(ge, slow);

      // 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 (cond == le || cond == ge) {

        __ cmp(r4, Operand(ODDBALL_TYPE));

        __ b(ne, &return_equal);

        __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);

        __ cmp(r0, r2);

        __ b(ne, &return_equal);

        if (cond == le) {

          // undefined <= undefined should fail.

          __ mov(r0, Operand(GREATER));

        } else  {

          // undefined >= undefined should fail.

          __ mov(r0, Operand(LESS));

        }

        __ Ret();

      }

    }

  }

  __ bind(&return_equal);

  if (cond == lt) {

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

  } else if (cond == gt) {

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

  } else {

    __ mov(r0, Operand(EQUAL));    // Things are <=, >=, ==, === themselves.

  }

  __ Ret();

  // 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 (cond != lt && cond != 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).

    __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));

    // Test that exponent bits are all set.

    __ Sbfx(r3, r2, HeapNumber::kExponentShift, HeapNumber::kExponentBits);

    // NaNs have all-one exponents so they sign extend to -1.

    __ cmp(r3, Operand(-1));

    __ b(ne, &return_equal);

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

    __ mov(r2, Operand(r2, LSL, HeapNumber::kNonMantissaBitsInTopWord));

    // Or with all low-bits of mantissa.

    __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));

    __ orr(r0, r3, Operand(r2), SetCC);

    // For equal we already have the right value in r0:  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 r0 with the failing

    // value if it's a NaN.

    if (cond != eq) {

      // All-zero means Infinity means equal.

      __ Ret(eq);

      if (cond == le) {

        __ mov(r0, Operand(GREATER));  // NaN <= NaN should fail.

      } else {

        __ mov(r0, Operand(LESS));     // NaN >= NaN should fail.

      }

    }

    __ Ret();

  }

  // No fall through here.

  __ bind(&not_identical);

}

// See comment at call site.

static void EmitSmiNonsmiComparison(MacroAssembler* masm,

                                    Register lhs,

                                    Register rhs,

                                    Label* lhs_not_nan,

                                    Label* slow,

                                    bool strict) {

  ASSERT((lhs.is(r0) && rhs.is(r1)) ||

         (lhs.is(r1) && rhs.is(r0)));

  Label rhs_is_smi;

  __ JumpIfSmi(rhs, &rhs_is_smi);

  // Lhs is a Smi.  Check whether the rhs is a heap number.

  __ CompareObjectType(rhs, r4, r4, HEAP_NUMBER_TYPE);

  if (strict) {

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

    // succeed.  Return non-equal

    // If rhs is r0 then there is already a non zero value in it.

    if (!rhs.is(r0)) {

      __ mov(r0, Operand(NOT_EQUAL), LeaveCC, ne);

    }

    __ Ret(ne);

  } else {

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

    // the runtime.

    __ b(ne, slow);

  }

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

  // Convert lhs to a double in d7.

  __ SmiToDouble(d7, lhs);

  // Load the double from rhs, tagged HeapNumber r0, to d6.

  __ vldr(d6, rhs, HeapNumber::kValueOffset - kHeapObjectTag);

  // We now have both loaded as doubles but we can skip the lhs nan check

  // since it's a smi.

  __ jmp(lhs_not_nan);

  __ bind(&rhs_is_smi);

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

  __ CompareObjectType(lhs, r4, r4, HEAP_NUMBER_TYPE);

  if (strict) {

    // If lhs is not a number and rhs is a smi then strict equality cannot

    // succeed.  Return non-equal.

    // If lhs is r0 then there is already a non zero value in it.

    if (!lhs.is(r0)) {

      __ mov(r0, Operand(NOT_EQUAL), LeaveCC, ne);

    }

    __ Ret(ne);

  } else {

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

    // the runtime.

    __ b(ne, slow);

  }

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

  // Load the double from lhs, tagged HeapNumber r1, to d7.

  __ vldr(d7, lhs, HeapNumber::kValueOffset - kHeapObjectTag);

  // Convert rhs to a double in d6              .

  __ SmiToDouble(d6, rhs);

  // Fall through to both_loaded_as_doubles.

}

// See comment at call site.

static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,

                                           Register lhs,

                                           Register rhs) {

    ASSERT((lhs.is(r0) && rhs.is(r1)) ||

           (lhs.is(r1) && rhs.is(r0)));

    // 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 r2 and compare it with

    // FIRST_SPEC_OBJECT_TYPE.

    __ CompareObjectType(rhs, r2, r2, FIRST_SPEC_OBJECT_TYPE);

    __ b(lt, &first_non_object);

    // Return non-zero (r0 is not zero)

    Label return_not_equal;

    __ bind(&return_not_equal);

    __ Ret();

    __ bind(&first_non_object);

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

    __ cmp(r2, Operand(ODDBALL_TYPE));

    __ b(eq, &return_not_equal);

    __ CompareObjectType(lhs, r3, r3, FIRST_SPEC_OBJECT_TYPE);

    __ b(ge, &return_not_equal);

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

    __ cmp(r3, Operand(ODDBALL_TYPE));

    __ b(eq, &return_not_equal);

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

    // internalized-internalized.

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

    __ orr(r2, r2, Operand(r3));

    __ tst(r2, Operand(kIsNotStringMask | kIsNotInternalizedMask));

    __ b(eq, &return_not_equal);

}

// See comment at call site.

static void EmitCheckForTwoHeapNumbers(MacroAssembler* masm,

                                       Register lhs,

                                       Register rhs,

                                       Label* both_loaded_as_doubles,

                                       Label* not_heap_numbers,

                                       Label* slow) {

  ASSERT((lhs.is(r0) && rhs.is(r1)) ||

         (lhs.is(r1) && rhs.is(r0)));

  __ CompareObjectType(rhs, r3, r2, HEAP_NUMBER_TYPE);

  __ b(ne, not_heap_numbers);

  __ ldr(r2, FieldMemOperand(lhs, HeapObject::kMapOffset));

  __ cmp(r2, r3);

  __ b(ne, slow);  // First was a heap number, second wasn't.  Go slow case.

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

  // for that.

  __ vldr(d6, rhs, HeapNumber::kValueOffset - kHeapObjectTag);

  __ vldr(d7, lhs, HeapNumber::kValueOffset - kHeapObjectTag);

  __ 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(r0) && rhs.is(r1)) ||

         (lhs.is(r1) && rhs.is(r0)));

  // r2 is object type of rhs.

  Label object_test;

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

  __ tst(r2, Operand(kIsNotStringMask));

  __ b(ne, &object_test);

  __ tst(r2, Operand(kIsNotInternalizedMask));

  __ b(ne, possible_strings);

  __ CompareObjectType(lhs, r3, r3, FIRST_NONSTRING_TYPE);

  __ b(ge, not_both_strings);

  __ tst(r3, Operand(kIsNotInternalizedMask));

  __ b(ne, possible_strings);

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

  // so they are not equal.

  __ mov(r0, Operand(NOT_EQUAL));

  __ Ret();

  __ bind(&object_test);

  __ cmp(r2, Operand(FIRST_SPEC_OBJECT_TYPE));

  __ b(lt, not_both_strings);

  __ CompareObjectType(lhs, r2, r3, FIRST_SPEC_OBJECT_TYPE);

  __ b(lt, not_both_strings);

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

  __ ldr(r3, FieldMemOperand(rhs, HeapObject::kMapOffset));

  __ ldrb(r2, FieldMemOperand(r2, Map::kBitFieldOffset));

  __ ldrb(r3, FieldMemOperand(r3, Map::kBitFieldOffset));

  __ and_(r0, r2, Operand(r3));

  __ and_(r0, r0, Operand(1 << Map::kIsUndetectable));

  __ eor(r0, r0, Operand(1 << Map::kIsUndetectable));

  __ Ret();

}

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/non-internalized here, but as long as

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

  __ bind(&ok);

}

// On entry r1 and r2 are the values to be compared.

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

// the comparison.

void ICCompareStub::GenerateGeneric(MacroAssembler* masm) {

  Register lhs = r1;

  Register rhs = r0;

  Condition cc = GetCondition();

  Label miss;

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

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

  Label slow;  // Call builtin.

  Label not_smis, both_loaded_as_doubles, lhs_not_nan;

  Label not_two_smis, smi_done;

  __ orr(r2, r1, r0);

  __ JumpIfNotSmi(r2, &not_two_smis);

  __ mov(r1, Operand(r1, ASR, 1));

  __ sub(r0, r1, Operand(r0, ASR, 1));

  __ Ret();

  __ 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_(r2, lhs, Operand(rhs));

  __ JumpIfNotSmi(r2, &not_smis);

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

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

  // comparison.  If VFP3 is supported the double values of the numbers have

  // been loaded into d7 and d6.  Otherwise, the double values have been loaded

  // into r0, r1, r2, and r3.

  EmitSmiNonsmiComparison(masm, lhs, rhs, &lhs_not_nan, &slow, strict());

  __ bind(&both_loaded_as_doubles);

  // The arguments have been converted to doubles and stored in d6 and d7, if

  // VFP3 is supported, or in r0, r1, r2, and r3.

  Isolate* isolate = masm->isolate();

  __ bind(&lhs_not_nan);

  Label no_nan;

  // ARMv7 VFP3 instructions to implement double precision comparison.

  __ VFPCompareAndSetFlags(d7, d6);

  Label nan;

  __ b(vs, &nan);

  __ mov(r0, Operand(EQUAL), LeaveCC, eq);

  __ mov(r0, Operand(LESS), LeaveCC, lt);

  __ mov(r0, Operand(GREATER), LeaveCC, gt);

  __ Ret();

  __ bind(&nan);

  // If one of the sides was a NaN then the v flag is set.  Load r0 with

  // whatever it takes to make the comparison fail, since comparisons with NaN

  // always fail.

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

    __ mov(r0, Operand(GREATER));

  } else {

    __ mov(r0, Operand(LESS));

  }

  __ Ret();

  __ 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 rhs_ and lhs_.

  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 into r0, r1, r2, r3 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 r2 will contain the type of rhs_.  Never falls through.

  EmitCheckForTwoHeapNumbers(masm,

                             lhs,

                             rhs,

                             &both_loaded_as_doubles,

                             &check_for_internalized_strings,

                             &flat_string_check);

  __ bind(&check_for_internalized_strings);

  // In the strict case the EmitStrictTwoHeapObjectCompare already took care of

  // 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 r2 is the type of rhs_ 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, r2, r3, &slow);

  __ IncrementCounter(isolate->counters()->string_compare_native(), 1, r2, r3);

  if (cc == eq) {

    StringCompareStub::GenerateFlatAsciiStringEquals(masm,

                                                     lhs,

                                                     rhs,

                                                     r2,

                                                     r3,

                                                     r4);

  } else {

    StringCompareStub::GenerateCompareFlatAsciiStrings(masm,

                                                       lhs,

                                                       rhs,

                                                       r2,

                                                       r3,

                                                       r4,

                                                       r5);

  }

  // Never falls through to here.

  __ bind(&slow);

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

    }

    __ mov(r0, Operand(Smi::FromInt(ncr)));

    __ push(r0);

  }

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

  __ stm(db_w, sp, kCallerSaved | lr.bit());

  const Register scratch = r1;

  if (save_doubles_ == kSaveFPRegs) {

    __ SaveFPRegs(sp, scratch);

  }

  const int argument_count = 1;

  const int fp_argument_count = 0;

  AllowExternalCallThatCantCauseGC scope(masm);

  __ PrepareCallCFunction(argument_count, fp_argument_count, scratch);

  __ mov(r0, Operand(ExternalReference::isolate_address(masm->isolate())));

  __ CallCFunction(

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

      argument_count);

  if (save_doubles_ == kSaveFPRegs) {

    __ RestoreFPRegs(sp, scratch);

  }

  __ ldm(ia_w, sp, kCallerSaved | pc.bit());  // Also pop pc to get Ret(0).

}

void TranscendentalCacheStub::Generate(MacroAssembler* masm) {

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

  //   into d2.

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

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

  Label input_not_smi;

  Label loaded;

  Label calculate;

  Label invalid_cache;

  const Register scratch0 = r9;

  Register scratch1 = no_reg;  // will be r4

  const Register cache_entry = r0;

  const bool tagged = (argument_type_ == TAGGED);

  if (tagged) {

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

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

    __ JumpIfNotSmi(r0, &input_not_smi);

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

    // of the double into r2, r3.

    __ SmiToDouble(d7, r0);

    __ vmov(r2, r3, d7);

    __ b(&loaded);

    __ bind(&input_not_smi);

    // Check if input is a HeapNumber.

    __ CheckMap(r0,

                r1,

                Heap::kHeapNumberMapRootIndex,

                &calculate,

                DONT_DO_SMI_CHECK);

    // Input is a HeapNumber. Load it to a double register and store the

    // low and high words into r2, r3.

    __ vldr(d0, FieldMemOperand(r0, HeapNumber::kValueOffset));

    __ vmov(r2, r3, d0);

  } else {

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

    __ vmov(r2, r3, d2);

  }

  __ bind(&loaded);

  // r2 = low 32 bits of double value

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

  __ eor(r1, r2, Operand(r3));

  __ eor(r1, r1, Operand(r1, ASR, 16));

  __ eor(r1, r1, Operand(r1, ASR, 8));

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

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

  // r2 = low 32 bits of double value.

  // r3 = high 32 bits of double value.

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

  Isolate* isolate = masm->isolate();

  ExternalReference cache_array =

      ExternalReference::transcendental_cache_array_address(isolate);

  __ mov(cache_entry, Operand(cache_array));

  // cache_entry points to cache array.

  int cache_array_index

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

  __ ldr(cache_entry, MemOperand(cache_entry, cache_array_index));

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

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

  __ cmp(cache_entry, Operand::Zero());

  __ b(eq, &invalid_cache);

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

  __ add(r1, r1, Operand(r1, LSL, 1));

  __ add(cache_entry, cache_entry, Operand(r1, LSL, 2));

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

  __ ldm(ia, cache_entry, r4.bit() | r5.bit() | r6.bit());

  __ cmp(r2, r4);

  __ cmp(r3, r5, eq);

  __ b(ne, &calculate);

  scratch1 = r4;  // Start of scratch1 range.

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

    __ pop();

    __ mov(r0, Operand(r6));

  } else {

    // Load result into d2.

    __ vldr(d2, FieldMemOperand(r6, HeapNumber::kValueOffset));

  }

  __ Ret();

  __ bind(&calculate);

  __ IncrementCounter(

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

  if (tagged) {

    __ bind(&invalid_cache);

    ExternalReference runtime_function =

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

    __ TailCallExternalReference(runtime_function, 1, 1);

  } else {

    Label no_update;

    Label skip_cache;

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

    // r0: precalculated cache entry address.

    // r2 and r3: parts of the double value.

    // Store r0, r2 and r3 on stack for later before calling C function.

    __ Push(r3, r2, cache_entry);

    GenerateCallCFunction(masm, scratch0);

    __ GetCFunctionDoubleResult(d2);

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

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

    __ Pop(r3, r2, cache_entry);

    __ LoadRoot(r5, Heap::kHeapNumberMapRootIndex);

    __ AllocateHeapNumber(r6, scratch0, scratch1, r5, &no_update);

    __ vstr(d2, FieldMemOperand(r6, HeapNumber::kValueOffset));

    __ stm(ia, cache_entry, r2.bit() | r3.bit() | r6.bit());

    __ Ret();

    __ bind(&invalid_cache);

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

    // cache.

    __ LoadRoot(r5, Heap::kHeapNumberMapRootIndex);

    __ AllocateHeapNumber(r0, scratch0, scratch1, r5, &skip_cache);

    __ vstr(d2, FieldMemOperand(r0, HeapNumber::kValueOffset));

    {

      FrameScope scope(masm, StackFrame::INTERNAL);

      __ push(r0);

      __ CallRuntime(RuntimeFunction(), 1);

    }

    __ vldr(d2, FieldMemOperand(r0, HeapNumber::kValueOffset));

    __ Ret();

    __ bind(&skip_cache);

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

    // without updating the cache.

    GenerateCallCFunction(masm, scratch0);

    __ GetCFunctionDoubleResult(d2);

    __ bind(&no_update);

    // We return the value in d2 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);

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

      __ push(scratch0);

      __ CallRuntimeSaveDoubles(Runtime::kAllocateInNewSpace);

    }

    __ Ret();

  }

}

void TranscendentalCacheStub::GenerateCallCFunction(MacroAssembler* masm,

                                                    Register scratch) {

  Isolate* isolate = masm->isolate();

  __ push(lr);

  __ PrepareCallCFunction(0, 1, scratch);

  if (masm->use_eabi_hardfloat()) {

    __ vmov(d0, d2);

  } else {

    __ vmov(r0, r1, d2);

  }

  AllowExternalCallThatCantCauseGC scope(masm);

  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:

      __ CallCFunction(ExternalReference::math_tan_double_function(isolate),

          0, 1);

      break;

    case TranscendentalCache::LOG:

      __ CallCFunction(ExternalReference::math_log_double_function(isolate),

          0, 1);

      break;

    default:

      UNIMPLEMENTED();

      break;

  }

  __ pop(lr);

}

Runtime::FunctionId TranscendentalCacheStub::RuntimeFunction() {

  switch (type_) {

    // Add more cases when necessary.

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

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

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

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

    default:

      UNIMPLEMENTED();

      return Runtime::kAbort;

  }

}

void MathPowStub::Generate(MacroAssembler* masm) {

  const Register base = r1;

  const Register exponent = r2;

  const Register heapnumbermap = r5;

  const Register heapnumber = r0;

  const DwVfpRegister double_base = d1;

  const DwVfpRegister double_exponent = d2;

  const DwVfpRegister double_result = d3;

  const DwVfpRegister double_scratch = d0;

  const SwVfpRegister single_scratch = s0;

  const Register scratch = r9;

  const Register scratch2 = r4;

  Label call_runtime, done, int_exponent;

  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 to double registers.

    __ ldr(base, MemOperand(sp, 1 * kPointerSize));