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"

#include "arm/lithium-codegen-arm.h"

#include "arm/lithium-gap-resolver-arm.h"

#include "code-stubs.h"

#include "stub-cache.h"

#include "hydrogen-osr.h"

namespace v8 {

namespace internal {

class SafepointGenerator V8_FINAL : public CallWrapper {

 public:

  SafepointGenerator(LCodeGen* codegen,

                     LPointerMap* pointers,

                     Safepoint::DeoptMode mode)

      : codegen_(codegen),

        pointers_(pointers),

        deopt_mode_(mode) { }

  virtual ~SafepointGenerator() {}

  virtual void BeforeCall(int call_size) const V8_OVERRIDE {}

  virtual void AfterCall() const V8_OVERRIDE {

    codegen_->RecordSafepoint(pointers_, deopt_mode_);

  }

 private:

  LCodeGen* codegen_;

  LPointerMap* pointers_;

  Safepoint::DeoptMode deopt_mode_;

};

#define __ masm()->

bool LCodeGen::GenerateCode() {

  LPhase phase("Z_Code generation", chunk());

  ASSERT(is_unused());

  status_ = GENERATING;

  // Open a frame scope to indicate that there is a frame on the stack.  The

  // NONE indicates that the scope shouldn't actually generate code to set up

  // the frame (that is done in GeneratePrologue).

  FrameScope frame_scope(masm_, StackFrame::NONE);

  return GeneratePrologue() &&

      GenerateBody() &&

      GenerateDeferredCode() &&

      GenerateDeoptJumpTable() &&

      GenerateSafepointTable();

}

void LCodeGen::FinishCode(Handle<Code> code) {

  ASSERT(is_done());

  code->set_stack_slots(GetStackSlotCount());

  code->set_safepoint_table_offset(safepoints_.GetCodeOffset());

  if (FLAG_weak_embedded_maps_in_optimized_code) {

    RegisterDependentCodeForEmbeddedMaps(code);

  }

  PopulateDeoptimizationData(code);

  info()->CommitDependencies(code);

}

void LCodeGen::Abort(BailoutReason reason) {

  info()->set_bailout_reason(reason);

  status_ = ABORTED;

}

bool LCodeGen::GeneratePrologue() {

  ASSERT(is_generating());

  if (info()->IsOptimizing()) {

    ProfileEntryHookStub::MaybeCallEntryHook(masm_);

#ifdef DEBUG

    if (strlen(FLAG_stop_at) > 0 &&

        info_->function()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {

      __ stop("stop_at");

    }

#endif

    // r1: Callee's JS function.

    // cp: Callee's context.

    // fp: Caller's frame pointer.

    // lr: Caller's pc.

    // Strict mode functions and builtins need to replace the receiver

    // with undefined when called as functions (without an explicit

    // receiver object). r5 is zero for method calls and non-zero for

    // function calls.

    if (!info_->is_classic_mode() || info_->is_native()) {

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

      int receiver_offset = scope()->num_parameters() * kPointerSize;

      __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);

      __ str(r2, MemOperand(sp, receiver_offset), ne);

    }

  }

  info()->set_prologue_offset(masm_->pc_offset());

  if (NeedsEagerFrame()) {

    __ Prologue(info()->IsStub() ? BUILD_STUB_FRAME : BUILD_FUNCTION_FRAME);

    frame_is_built_ = true;

    info_->AddNoFrameRange(0, masm_->pc_offset());

  }

  // Reserve space for the stack slots needed by the code.

  int slots = GetStackSlotCount();

  if (slots > 0) {

    if (FLAG_debug_code) {

      __ sub(sp,  sp, Operand(slots * kPointerSize));

      __ push(r0);

      __ push(r1);

      __ add(r0, sp, Operand(slots *  kPointerSize));

      __ mov(r1, Operand(kSlotsZapValue));

      Label loop;

      __ bind(&loop);

      __ sub(r0, r0, Operand(kPointerSize));

      __ str(r1, MemOperand(r0, 2 * kPointerSize));

      __ cmp(r0, sp);

      __ b(ne, &loop);

      __ pop(r1);

      __ pop(r0);

    } else {

      __ sub(sp,  sp, Operand(slots * kPointerSize));

    }

  }

  if (info()->saves_caller_doubles()) {

    Comment(";;; Save clobbered callee double registers");

    int count = 0;

    BitVector* doubles = chunk()->allocated_double_registers();

    BitVector::Iterator save_iterator(doubles);

    while (!save_iterator.Done()) {

      __ vstr(DwVfpRegister::FromAllocationIndex(save_iterator.Current()),

              MemOperand(sp, count * kDoubleSize));

      save_iterator.Advance();

      count++;

    }

  }

  // Possibly allocate a local context.

  int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;

  if (heap_slots > 0) {

    Comment(";;; Allocate local context");

    // Argument to NewContext is the function, which is in r1.

    __ push(r1);

    if (heap_slots <= FastNewContextStub::kMaximumSlots) {

      FastNewContextStub stub(heap_slots);

      __ CallStub(&stub);

    } else {

      __ CallRuntime(Runtime::kNewFunctionContext, 1);

    }

    RecordSafepoint(Safepoint::kNoLazyDeopt);

    // Context is returned in both r0 and cp.  It replaces the context

    // passed to us.  It's saved in the stack and kept live in cp.

    __ str(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));

    // Copy any necessary parameters into the context.

    int num_parameters = scope()->num_parameters();

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

      Variable* var = scope()->parameter(i);

      if (var->IsContextSlot()) {

        int parameter_offset = StandardFrameConstants::kCallerSPOffset +

            (num_parameters - 1 - i) * kPointerSize;

        // Load parameter from stack.

        __ ldr(r0, MemOperand(fp, parameter_offset));

        // Store it in the context.

        MemOperand target = ContextOperand(cp, var->index());

        __ str(r0, target);

        // Update the write barrier. This clobbers r3 and r0.

        __ RecordWriteContextSlot(

            cp,

            target.offset(),

            r0,

            r3,

            GetLinkRegisterState(),

            kSaveFPRegs);

      }

    }

    Comment(";;; End allocate local context");

  }

  // Trace the call.

  if (FLAG_trace && info()->IsOptimizing()) {

    // We have not executed any compiled code yet, so cp still holds the

    // incoming context.

    __ CallRuntime(Runtime::kTraceEnter, 0);

  }

  return !is_aborted();

}

void LCodeGen::GenerateOsrPrologue() {

  // Generate the OSR entry prologue at the first unknown OSR value, or if there

  // are none, at the OSR entrypoint instruction.

  if (osr_pc_offset_ >= 0) return;

  osr_pc_offset_ = masm()->pc_offset();

  // Adjust the frame size, subsuming the unoptimized frame into the

  // optimized frame.

  int slots = GetStackSlotCount() - graph()->osr()->UnoptimizedFrameSlots();

  ASSERT(slots >= 0);

  __ sub(sp, sp, Operand(slots * kPointerSize));

}

bool LCodeGen::GenerateDeferredCode() {

  ASSERT(is_generating());

  if (deferred_.length() > 0) {

    for (int i = 0; !is_aborted() && i < deferred_.length(); i++) {

      LDeferredCode* code = deferred_[i];

      HValue* value =

          instructions_->at(code->instruction_index())->hydrogen_value();

      RecordAndWritePosition(value->position());

      Comment(";;; <@%d,#%d> "

              "-------------------- Deferred %s --------------------",

              code->instruction_index(),

              code->instr()->hydrogen_value()->id(),

              code->instr()->Mnemonic());

      __ bind(code->entry());

      if (NeedsDeferredFrame()) {

        Comment(";;; Build frame");

        ASSERT(!frame_is_built_);

        ASSERT(info()->IsStub());

        frame_is_built_ = true;

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

        __ mov(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));

        __ push(scratch0());

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

        Comment(";;; Deferred code");

      }

      code->Generate();

      if (NeedsDeferredFrame()) {

        Comment(";;; Destroy frame");

        ASSERT(frame_is_built_);

        __ pop(ip);

        __ ldm(ia_w, sp, cp.bit() | fp.bit() | lr.bit());

        frame_is_built_ = false;

      }

      __ jmp(code->exit());

    }

  }

  // Force constant pool emission at the end of the deferred code to make

  // sure that no constant pools are emitted after.

  masm()->CheckConstPool(true, false);

  return !is_aborted();

}

bool LCodeGen::GenerateDeoptJumpTable() {

  // Check that the jump table is accessible from everywhere in the function

  // code, i.e. that offsets to the table can be encoded in the 24bit signed

  // immediate of a branch instruction.

  // To simplify we consider the code size from the first instruction to the

  // end of the jump table. We also don't consider the pc load delta.

  // Each entry in the jump table generates one instruction and inlines one

  // 32bit data after it.

  if (!is_int24((masm()->pc_offset() / Assembler::kInstrSize) +

      deopt_jump_table_.length() * 7)) {

    Abort(kGeneratedCodeIsTooLarge);

  }

  if (deopt_jump_table_.length() > 0) {

    Comment(";;; -------------------- Jump table --------------------");

  }

  Label table_start;

  __ bind(&table_start);

  Label needs_frame;

  for (int i = 0; i < deopt_jump_table_.length(); i++) {

    __ bind(&deopt_jump_table_[i].label);

    Address entry = deopt_jump_table_[i].address;

    Deoptimizer::BailoutType type = deopt_jump_table_[i].bailout_type;

    int id = Deoptimizer::GetDeoptimizationId(isolate(), entry, type);

    if (id == Deoptimizer::kNotDeoptimizationEntry) {

      Comment(";;; jump table entry %d.", i);

    } else {

      Comment(";;; jump table entry %d: deoptimization bailout %d.", i, id);

    }

    if (deopt_jump_table_[i].needs_frame) {

      __ mov(ip, Operand(ExternalReference::ForDeoptEntry(entry)));

      if (needs_frame.is_bound()) {

        __ b(&needs_frame);

      } else {

        __ bind(&needs_frame);

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

        // This variant of deopt can only be used with stubs. Since we don't

        // have a function pointer to install in the stack frame that we're

        // building, install a special marker there instead.

        ASSERT(info()->IsStub());

        __ mov(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));

        __ push(scratch0());

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

        __ mov(lr, Operand(pc), LeaveCC, al);

        __ mov(pc, ip);

      }

    } else {

      __ mov(lr, Operand(pc), LeaveCC, al);

      __ mov(pc, Operand(ExternalReference::ForDeoptEntry(entry)));

    }

    masm()->CheckConstPool(false, false);

  }

  // Force constant pool emission at the end of the deopt jump table to make

  // sure that no constant pools are emitted after.

  masm()->CheckConstPool(true, false);

  // The deoptimization jump table is the last part of the instruction

  // sequence. Mark the generated code as done unless we bailed out.

  if (!is_aborted()) status_ = DONE;

  return !is_aborted();

}

bool LCodeGen::GenerateSafepointTable() {

  ASSERT(is_done());

  safepoints_.Emit(masm(), GetStackSlotCount());

  return !is_aborted();

}

Register LCodeGen::ToRegister(int index) const {

  return Register::FromAllocationIndex(index);

}

DwVfpRegister LCodeGen::ToDoubleRegister(int index) const {

  return DwVfpRegister::FromAllocationIndex(index);

}

Register LCodeGen::ToRegister(LOperand* op) const {

  ASSERT(op->IsRegister());

  return ToRegister(op->index());

}

Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {

  if (op->IsRegister()) {

    return ToRegister(op->index());

  } else if (op->IsConstantOperand()) {

    LConstantOperand* const_op = LConstantOperand::cast(op);

    HConstant* constant = chunk_->LookupConstant(const_op);

    Handle<Object> literal = constant->handle(isolate());

    Representation r = chunk_->LookupLiteralRepresentation(const_op);

    if (r.IsInteger32()) {

      ASSERT(literal->IsNumber());

      __ mov(scratch, Operand(static_cast<int32_t>(literal->Number())));

    } else if (r.IsDouble()) {

      Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);

    } else {

      ASSERT(r.IsSmiOrTagged());

      __ Move(scratch, literal);

    }

    return scratch;

  } else if (op->IsStackSlot() || op->IsArgument()) {

    __ ldr(scratch, ToMemOperand(op));

    return scratch;

  }

  UNREACHABLE();

  return scratch;

}

DwVfpRegister LCodeGen::ToDoubleRegister(LOperand* op) const {

  ASSERT(op->IsDoubleRegister());

  return ToDoubleRegister(op->index());

}

DwVfpRegister LCodeGen::EmitLoadDoubleRegister(LOperand* op,

                                               SwVfpRegister flt_scratch,

                                               DwVfpRegister dbl_scratch) {

  if (op->IsDoubleRegister()) {

    return ToDoubleRegister(op->index());

  } else if (op->IsConstantOperand()) {

    LConstantOperand* const_op = LConstantOperand::cast(op);

    HConstant* constant = chunk_->LookupConstant(const_op);

    Handle<Object> literal = constant->handle(isolate());

    Representation r = chunk_->LookupLiteralRepresentation(const_op);

    if (r.IsInteger32()) {

      ASSERT(literal->IsNumber());

      __ mov(ip, Operand(static_cast<int32_t>(literal->Number())));

      __ vmov(flt_scratch, ip);

      __ vcvt_f64_s32(dbl_scratch, flt_scratch);

      return dbl_scratch;

    } else if (r.IsDouble()) {

      Abort(kUnsupportedDoubleImmediate);

    } else if (r.IsTagged()) {

      Abort(kUnsupportedTaggedImmediate);

    }

  } else if (op->IsStackSlot() || op->IsArgument()) {

    // TODO(regis): Why is vldr not taking a MemOperand?

    // __ vldr(dbl_scratch, ToMemOperand(op));

    MemOperand mem_op = ToMemOperand(op);

    __ vldr(dbl_scratch, mem_op.rn(), mem_op.offset());

    return dbl_scratch;

  }

  UNREACHABLE();

  return dbl_scratch;

}

Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {

  HConstant* constant = chunk_->LookupConstant(op);

  ASSERT(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());

  return constant->handle(isolate());

}

bool LCodeGen::IsInteger32(LConstantOperand* op) const {

  return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();

}

bool LCodeGen::IsSmi(LConstantOperand* op) const {

  return chunk_->LookupLiteralRepresentation(op).IsSmi();

}

int32_t LCodeGen::ToInteger32(LConstantOperand* op) const {

  return ToRepresentation(op, Representation::Integer32());

}

int32_t LCodeGen::ToRepresentation(LConstantOperand* op,

                                   const Representation& r) const {

  HConstant* constant = chunk_->LookupConstant(op);

  int32_t value = constant->Integer32Value();

  if (r.IsInteger32()) return value;

  ASSERT(r.IsSmiOrTagged());

  return reinterpret_cast<int32_t>(Smi::FromInt(value));

}

Smi* LCodeGen::ToSmi(LConstantOperand* op) const {

  HConstant* constant = chunk_->LookupConstant(op);

  return Smi::FromInt(constant->Integer32Value());

}

double LCodeGen::ToDouble(LConstantOperand* op) const {

  HConstant* constant = chunk_->LookupConstant(op);

  ASSERT(constant->HasDoubleValue());

  return constant->DoubleValue();

}

Operand LCodeGen::ToOperand(LOperand* op) {

  if (op->IsConstantOperand()) {

    LConstantOperand* const_op = LConstantOperand::cast(op);

    HConstant* constant = chunk()->LookupConstant(const_op);

    Representation r = chunk_->LookupLiteralRepresentation(const_op);

    if (r.IsSmi()) {

      ASSERT(constant->HasSmiValue());

      return Operand(Smi::FromInt(constant->Integer32Value()));

    } else if (r.IsInteger32()) {

      ASSERT(constant->HasInteger32Value());

      return Operand(constant->Integer32Value());

    } else if (r.IsDouble()) {

      Abort(kToOperandUnsupportedDoubleImmediate);

    }

    ASSERT(r.IsTagged());

    return Operand(constant->handle(isolate()));

  } else if (op->IsRegister()) {

    return Operand(ToRegister(op));

  } else if (op->IsDoubleRegister()) {

    Abort(kToOperandIsDoubleRegisterUnimplemented);

    return Operand::Zero();

  }

  // Stack slots not implemented, use ToMemOperand instead.

  UNREACHABLE();

  return Operand::Zero();

}

MemOperand LCodeGen::ToMemOperand(LOperand* op) const {

  ASSERT(!op->IsRegister());

  ASSERT(!op->IsDoubleRegister());

  ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());

  return MemOperand(fp, StackSlotOffset(op->index()));

}

MemOperand LCodeGen::ToHighMemOperand(LOperand* op) const {

  ASSERT(op->IsDoubleStackSlot());

  return MemOperand(fp, StackSlotOffset(op->index()) + kPointerSize);

}

void LCodeGen::WriteTranslation(LEnvironment* environment,

                                Translation* translation) {

  if (environment == NULL) return;

  // The translation includes one command per value in the environment.

  int translation_size = environment->translation_size();

  // The output frame height does not include the parameters.

  int height = translation_size - environment->parameter_count();

  WriteTranslation(environment->outer(), translation);

  bool has_closure_id = !info()->closure().is_null() &&

      !info()->closure().is_identical_to(environment->closure());

  int closure_id = has_closure_id

      ? DefineDeoptimizationLiteral(environment->closure())

      : Translation::kSelfLiteralId;

  switch (environment->frame_type()) {

    case JS_FUNCTION:

      translation->BeginJSFrame(environment->ast_id(), closure_id, height);

      break;

    case JS_CONSTRUCT:

      translation->BeginConstructStubFrame(closure_id, translation_size);

      break;

    case JS_GETTER:

      ASSERT(translation_size == 1);

      ASSERT(height == 0);

      translation->BeginGetterStubFrame(closure_id);

      break;

    case JS_SETTER:

      ASSERT(translation_size == 2);

      ASSERT(height == 0);

      translation->BeginSetterStubFrame(closure_id);

      break;

    case STUB:

      translation->BeginCompiledStubFrame();

      break;

    case ARGUMENTS_ADAPTOR:

      translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);

      break;

  }

  int object_index = 0;

  int dematerialized_index = 0;

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

    LOperand* value = environment->values()->at(i);

    AddToTranslation(environment,

                     translation,

                     value,

                     environment->HasTaggedValueAt(i),

                     environment->HasUint32ValueAt(i),

                     &object_index,

                     &dematerialized_index);

  }

}

void LCodeGen::AddToTranslation(LEnvironment* environment,

                                Translation* translation,

                                LOperand* op,

                                bool is_tagged,

                                bool is_uint32,

                                int* object_index_pointer,

                                int* dematerialized_index_pointer) {

  if (op == LEnvironment::materialization_marker()) {

    int object_index = (*object_index_pointer)++;

    if (environment->ObjectIsDuplicateAt(object_index)) {

      int dupe_of = environment->ObjectDuplicateOfAt(object_index);

      translation->DuplicateObject(dupe_of);

      return;

    }

    int object_length = environment->ObjectLengthAt(object_index);

    if (environment->ObjectIsArgumentsAt(object_index)) {

      translation->BeginArgumentsObject(object_length);

    } else {

      translation->BeginCapturedObject(object_length);

    }

    int dematerialized_index = *dematerialized_index_pointer;

    int env_offset = environment->translation_size() + dematerialized_index;

    *dematerialized_index_pointer += object_length;

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

      LOperand* value = environment->values()->at(env_offset + i);

      AddToTranslation(environment,

                       translation,

                       value,

                       environment->HasTaggedValueAt(env_offset + i),

                       environment->HasUint32ValueAt(env_offset + i),

                       object_index_pointer,

                       dematerialized_index_pointer);

    }

    return;

  }

  if (op->IsStackSlot()) {

    if (is_tagged) {

      translation->StoreStackSlot(op->index());

    } else if (is_uint32) {

      translation->StoreUint32StackSlot(op->index());

    } else {

      translation->StoreInt32StackSlot(op->index());

    }

  } else if (op->IsDoubleStackSlot()) {

    translation->StoreDoubleStackSlot(op->index());

  } else if (op->IsArgument()) {

    ASSERT(is_tagged);

    int src_index = GetStackSlotCount() + op->index();

    translation->StoreStackSlot(src_index);

  } else if (op->IsRegister()) {

    Register reg = ToRegister(op);

    if (is_tagged) {

      translation->StoreRegister(reg);

    } else if (is_uint32) {

      translation->StoreUint32Register(reg);

    } else {

      translation->StoreInt32Register(reg);

    }

  } else if (op->IsDoubleRegister()) {

    DoubleRegister reg = ToDoubleRegister(op);

    translation->StoreDoubleRegister(reg);

  } else if (op->IsConstantOperand()) {

    HConstant* constant = chunk()->LookupConstant(LConstantOperand::cast(op));

    int src_index = DefineDeoptimizationLiteral(constant->handle(isolate()));

    translation->StoreLiteral(src_index);

  } else {

    UNREACHABLE();

  }

}

void LCodeGen::CallCode(Handle<Code> code,

                        RelocInfo::Mode mode,

                        LInstruction* instr,

                        TargetAddressStorageMode storage_mode) {

  CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT, storage_mode);

}

void LCodeGen::CallCodeGeneric(Handle<Code> code,

                               RelocInfo::Mode mode,

                               LInstruction* instr,

                               SafepointMode safepoint_mode,

                               TargetAddressStorageMode storage_mode) {

  EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());

  ASSERT(instr != NULL);

  // Block literal pool emission to ensure nop indicating no inlined smi code

  // is in the correct position.

  Assembler::BlockConstPoolScope block_const_pool(masm());

  __ Call(code, mode, TypeFeedbackId::None(), al, storage_mode);

  RecordSafepointWithLazyDeopt(instr, safepoint_mode);

  // Signal that we don't inline smi code before these stubs in the

  // optimizing code generator.

  if (code->kind() == Code::BINARY_OP_IC ||

      code->kind() == Code::COMPARE_IC) {

    __ nop();

  }

}

void LCodeGen::CallRuntime(const Runtime::Function* function,

                           int num_arguments,

                           LInstruction* instr,

                           SaveFPRegsMode save_doubles) {

  ASSERT(instr != NULL);

  __ CallRuntime(function, num_arguments, save_doubles);

  RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);

}

void LCodeGen::LoadContextFromDeferred(LOperand* context) {

  if (context->IsRegister()) {

    __ Move(cp, ToRegister(context));

  } else if (context->IsStackSlot()) {

    __ ldr(cp, ToMemOperand(context));

  } else if (context->IsConstantOperand()) {

    HConstant* constant =

        chunk_->LookupConstant(LConstantOperand::cast(context));

    __ Move(cp, Handle<Object>::cast(constant->handle(isolate())));

  } else {

    UNREACHABLE();

  }

}

void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,

                                       int argc,

                                       LInstruction* instr,

                                       LOperand* context) {

  LoadContextFromDeferred(context);

  __ CallRuntimeSaveDoubles(id);

  RecordSafepointWithRegisters(

      instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);

}

void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,

                                                    Safepoint::DeoptMode mode) {

  if (!environment->HasBeenRegistered()) {

    // Physical stack frame layout:

    // -x ............. -4  0 ..................................... y

    // [incoming arguments] [spill slots] [pushed outgoing arguments]

    // Layout of the environment:

    // 0 ..................................................... size-1

    // [parameters] [locals] [expression stack including arguments]

    // Layout of the translation:

    // 0 ........................................................ size - 1 + 4

    // [expression stack including arguments] [locals] [4 words] [parameters]

    // |>------------  translation_size ------------<|

    int frame_count = 0;

    int jsframe_count = 0;

    for (LEnvironment* e = environment; e != NULL; e = e->outer()) {

      ++frame_count;

      if (e->frame_type() == JS_FUNCTION) {

        ++jsframe_count;

      }

    }

    Translation translation(&translations_, frame_count, jsframe_count, zone());

    WriteTranslation(environment, &translation);

    int deoptimization_index = deoptimizations_.length();

    int pc_offset = masm()->pc_offset();

    environment->Register(deoptimization_index,

                          translation.index(),

                          (mode == Safepoint::kLazyDeopt) ? pc_offset : -1);

    deoptimizations_.Add(environment, zone());

  }

}

void LCodeGen::DeoptimizeIf(Condition condition,

                            LEnvironment* environment,

                            Deoptimizer::BailoutType bailout_type) {

  RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);

  ASSERT(environment->HasBeenRegistered());

  int id = environment->deoptimization_index();

  ASSERT(info()->IsOptimizing() || info()->IsStub());

  Address entry =

      Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);

  if (entry == NULL) {

    Abort(kBailoutWasNotPrepared);

    return;

  }

  ASSERT(FLAG_deopt_every_n_times < 2);  // Other values not supported on ARM.

  if (FLAG_deopt_every_n_times == 1 &&

      !info()->IsStub() &&

      info()->opt_count() == id) {

    ASSERT(frame_is_built_);

    __ Call(entry, RelocInfo::RUNTIME_ENTRY);

    return;

  }

  if (info()->ShouldTrapOnDeopt()) {

    __ stop("trap_on_deopt", condition);

  }

  ASSERT(info()->IsStub() || frame_is_built_);

  if (condition == al && frame_is_built_) {

    __ Call(entry, RelocInfo::RUNTIME_ENTRY);

  } else {

    // We often have several deopts to the same entry, reuse the last

    // jump entry if this is the case.

    if (deopt_jump_table_.is_empty() ||

        (deopt_jump_table_.last().address != entry) ||

        (deopt_jump_table_.last().bailout_type != bailout_type) ||

        (deopt_jump_table_.last().needs_frame != !frame_is_built_)) {

      Deoptimizer::JumpTableEntry table_entry(entry,

                                              bailout_type,

                                              !frame_is_built_);

      deopt_jump_table_.Add(table_entry, zone());

    }

    __ b(condition, &deopt_jump_table_.last().label);

  }

}

void LCodeGen::DeoptimizeIf(Condition condition,

                            LEnvironment* environment) {

  Deoptimizer::BailoutType bailout_type = info()->IsStub()

      ? Deoptimizer::LAZY

      : Deoptimizer::EAGER;

  DeoptimizeIf(condition, environment, bailout_type);

}

void LCodeGen::RegisterDependentCodeForEmbeddedMaps(Handle<Code> code) {

  ZoneList<Handle<Map> > maps(1, zone());

  ZoneList<Handle<JSObject> > objects(1, zone());

  int mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);

  for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {

    if (Code::IsWeakEmbeddedObject(code->kind(), it.rinfo()->target_object())) {

      if (it.rinfo()->target_object()->IsMap()) {

        Handle<Map> map(Map::cast(it.rinfo()->target_object()));

        maps.Add(map, zone());

      } else if (it.rinfo()->target_object()->IsJSObject()) {

        Handle<JSObject> object(JSObject::cast(it.rinfo()->target_object()));

        objects.Add(object, zone());

      }

    }

  }

#ifdef VERIFY_HEAP

  // This disables verification of weak embedded objects after full GC.

  // AddDependentCode can cause a GC, which would observe the state where

  // this code is not yet in the depended code lists of the embedded maps.

  NoWeakObjectVerificationScope disable_verification_of_embedded_objects;

#endif

  for (int i = 0; i < maps.length(); i++) {

    maps.at(i)->AddDependentCode(DependentCode::kWeaklyEmbeddedGroup, code);

  }

  for (int i = 0; i < objects.length(); i++) {

    AddWeakObjectToCodeDependency(isolate()->heap(), objects.at(i), code);

  }

}

void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {

  int length = deoptimizations_.length();

  if (length == 0) return;

  Handle<DeoptimizationInputData> data =

      factory()->NewDeoptimizationInputData(length, TENURED);

  Handle<ByteArray> translations =

      translations_.CreateByteArray(isolate()->factory());

  data->SetTranslationByteArray(*translations);

  data->SetInlinedFunctionCount(Smi::FromInt(inlined_function_count_));

  Handle<FixedArray> literals =

      factory()->NewFixedArray(deoptimization_literals_.length(), TENURED);

  { AllowDeferredHandleDereference copy_handles;

    for (int i = 0; i < deoptimization_literals_.length(); i++) {

      literals->set(i, *deoptimization_literals_[i]);

    }

    data->SetLiteralArray(*literals);

  }

  data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id().ToInt()));

  data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_));

  // Populate the deoptimization entries.

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

    LEnvironment* env = deoptimizations_[i];

    data->SetAstId(i, env->ast_id());

    data->SetTranslationIndex(i, Smi::FromInt(env->translation_index()));

    data->SetArgumentsStackHeight(i,

                                  Smi::FromInt(env->arguments_stack_height()));

    data->SetPc(i, Smi::FromInt(env->pc_offset()));

  }

  code->set_deoptimization_data(*data);

}

int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) {

  int result = deoptimization_literals_.length();

  for (int i = 0; i < deoptimization_literals_.length(); ++i) {

    if (deoptimization_literals_[i].is_identical_to(literal)) return i;

  }

  deoptimization_literals_.Add(literal, zone());

  return result;

}

void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() {

  ASSERT(deoptimization_literals_.length() == 0);

  const ZoneList<Handle<JSFunction> >* inlined_closures =

      chunk()->inlined_closures();

  for (int i = 0, length = inlined_closures->length();

       i < length;

       i++) {

    DefineDeoptimizationLiteral(inlined_closures->at(i));

  }

  inlined_function_count_ = deoptimization_literals_.length();

}

void LCodeGen::RecordSafepointWithLazyDeopt(

    LInstruction* instr, SafepointMode safepoint_mode) {

  if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {

    RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);

  } else {

    ASSERT(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);

    RecordSafepointWithRegisters(

        instr->pointer_map(), 0, Safepoint::kLazyDeopt);

  }

}

void LCodeGen::RecordSafepoint(

    LPointerMap* pointers,

    Safepoint::Kind kind,

    int arguments,

    Safepoint::DeoptMode deopt_mode) {

  ASSERT(expected_safepoint_kind_ == kind);

  const ZoneList<LOperand*>* operands = pointers->GetNormalizedOperands();

  Safepoint safepoint = safepoints_.DefineSafepoint(masm(),

      kind, arguments, deopt_mode);

  for (int i = 0; i < operands->length(); i++) {

    LOperand* pointer = operands->at(i);

    if (pointer->IsStackSlot()) {

      safepoint.DefinePointerSlot(pointer->index(), zone());

    } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {

      safepoint.DefinePointerRegister(ToRegister(pointer), zone());

    }

  }

}

void LCodeGen::RecordSafepoint(LPointerMap* pointers,

                               Safepoint::DeoptMode deopt_mode) {

  RecordSafepoint(pointers, Safepoint::kSimple, 0, deopt_mode);

}

void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {

  LPointerMap empty_pointers(zone());

  RecordSafepoint(&empty_pointers, deopt_mode);

}

void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,

                                            int arguments,

                                            Safepoint::DeoptMode deopt_mode) {

  RecordSafepoint(

      pointers, Safepoint::kWithRegisters, arguments, deopt_mode);

}

void LCodeGen::RecordSafepointWithRegistersAndDoubles(

    LPointerMap* pointers,

    int arguments,

    Safepoint::DeoptMode deopt_mode) {

  RecordSafepoint(

      pointers, Safepoint::kWithRegistersAndDoubles, arguments, deopt_mode);

}

void LCodeGen::RecordAndWritePosition(int position) {

  if (position == RelocInfo::kNoPosition) return;

  masm()->positions_recorder()->RecordPosition(position);

  masm()->positions_recorder()->WriteRecordedPositions();

}

static const char* LabelType(LLabel* label) {

  if (label->is_loop_header()) return " (loop header)";

  if (label->is_osr_entry()) return " (OSR entry)";

  return "";

}

void LCodeGen::DoLabel(LLabel* label) {

  Comment(";;; <@%d,#%d> -------------------- B%d%s --------------------",

          current_instruction_,

          label->hydrogen_value()->id(),

          label->block_id(),

          LabelType(label));

  __ bind(label->label());

  current_block_ = label->block_id();

  DoGap(label);

}

void LCodeGen::DoParallelMove(LParallelMove* move) {

  resolver_.Resolve(move);

}

void LCodeGen::DoGap(LGap* gap) {

  for (int i = LGap::FIRST_INNER_POSITION;

       i <= LGap::LAST_INNER_POSITION;

       i++) {

    LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);

    LParallelMove* move = gap->GetParallelMove(inner_pos);

    if (move != NULL) DoParallelMove(move);

  }

}

void LCodeGen::DoInstructionGap(LInstructionGap* instr) {

  DoGap(instr);

}

void LCodeGen::DoParameter(LParameter* instr) {

  // Nothing to do.

}

void LCodeGen::DoCallStub(LCallStub* instr) {

  ASSERT(ToRegister(instr->context()).is(cp));

  ASSERT(ToRegister(instr->result()).is(r0));

  switch (instr->hydrogen()->major_key()) {

    case CodeStub::RegExpConstructResult: {

      RegExpConstructResultStub stub;

      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);

      break;

    }

    case CodeStub::RegExpExec: {

      RegExpExecStub stub;

      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);

      break;

    }

    case CodeStub::SubString: {

      SubStringStub stub;

      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);

      break;

    }

    case CodeStub::StringCompare: {

      StringCompareStub stub;

      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);

      break;

    }

    case CodeStub::TranscendentalCache: {

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

      TranscendentalCacheStub stub(instr->transcendental_type(),

                                   TranscendentalCacheStub::TAGGED);

      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);

      break;

    }

    default:

      UNREACHABLE();

  }

}

void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {

  GenerateOsrPrologue();

}

void LCodeGen::DoModI(LModI* instr) {

  HMod* hmod = instr->hydrogen();

  HValue* left = hmod->left();

  HValue* right = hmod->right();

  if (hmod->HasPowerOf2Divisor()) {

    // TODO(svenpanne) We should really do the strength reduction on the

    // Hydrogen level.

    Register left_reg = ToRegister(instr->left());

    Register result_reg = ToRegister(instr->result());

    // Note: The code below even works when right contains kMinInt.

    int32_t divisor = Abs(right->GetInteger32Constant());

    Label left_is_not_negative, done;

    if (left->CanBeNegative()) {

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

      __ b(pl, &left_is_not_negative);

      __ rsb(result_reg, left_reg, Operand::Zero());

      __ and_(result_reg, result_reg, Operand(divisor - 1));

      __ rsb(result_reg, result_reg, Operand::Zero(), SetCC);

      if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {

        DeoptimizeIf(eq, instr->environment());

      }

      __ b(&done);

    }

    __ bind(&left_is_not_negative);

    __ and_(result_reg, left_reg, Operand(divisor - 1));

    __ bind(&done);

  } else if (hmod->fixed_right_arg().has_value) {

    Register left_reg = ToRegister(instr->left());

    Register right_reg = ToRegister(instr->right());

    Register result_reg = ToRegister(instr->result());

    int32_t divisor = hmod->fixed_right_arg().value;

    ASSERT(IsPowerOf2(divisor));

    // Check if our assumption of a fixed right operand still holds.

    __ cmp(right_reg, Operand(divisor));

    DeoptimizeIf(ne, instr->environment());

    Label left_is_not_negative, done;

    if (left->CanBeNegative()) {

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

      __ b(pl, &left_is_not_negative);

      __ rsb(result_reg, left_reg, Operand::Zero());

      __ and_(result_reg, result_reg, Operand(divisor - 1));

      __ rsb(result_reg, result_reg, Operand::Zero(), SetCC);

      if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {

        DeoptimizeIf(eq, instr->environment());

      }

      __ b(&done);

    }

    __ bind(&left_is_not_negative);

    __ and_(result_reg, left_reg, Operand(divisor - 1));

    __ bind(&done);

  } else if (CpuFeatures::IsSupported(SUDIV)) {

    CpuFeatureScope scope(masm(), SUDIV);

    Register left_reg = ToRegister(instr->left());

    Register right_reg = ToRegister(instr->right());

    Register result_reg = ToRegister(instr->result());

    Label done;

    // Check for x % 0, sdiv might signal an exception. We have to deopt in this

    // case because we can't return a NaN.

    if (right->CanBeZero()) {

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

      DeoptimizeIf(eq, instr->environment());

    }

    // Check for kMinInt % -1, sdiv will return kMinInt, which is not what we

    // want. We have to deopt if we care about -0, because we can't return that.

    if (left->RangeCanInclude(kMinInt) && right->RangeCanInclude(-1)) {

      Label no_overflow_possible;

      __ cmp(left_reg, Operand(kMinInt));

      __ b(ne, &no_overflow_possible);

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

      if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {

        DeoptimizeIf(eq, instr->environment());

      } else {

        __ b(ne, &no_overflow_possible);

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

        __ jmp(&done);

      }

      __ bind(&no_overflow_possible);

    }

    // For 'r3 = r1 % r2' we can have the following ARM code:

    //   sdiv r3, r1, r2

    //   mls r3, r3, r2, r1

    __ sdiv(result_reg, left_reg, right_reg);

    __ mls(result_reg, result_reg, right_reg, left_reg);

    // If we care about -0, test if the dividend is <0 and the result is 0.

    if (left->CanBeNegative() &&

        hmod->CanBeZero() &&

        hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {

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

      __ b(ne, &done);

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

      DeoptimizeIf(lt, instr->environment());

    }

    __ bind(&done);

  } else {

    // General case, without any SDIV support.

    Register left_reg = ToRegister(instr->left());

    Register right_reg = ToRegister(instr->right());

    Register result_reg = ToRegister(instr->result());

    Register scratch = scratch0();

    ASSERT(!scratch.is(left_reg));

    ASSERT(!scratch.is(right_reg));

    ASSERT(!scratch.is(result_reg));

    DwVfpRegister dividend = ToDoubleRegister(instr->temp());

    DwVfpRegister divisor = ToDoubleRegister(instr->temp2());

    ASSERT(!divisor.is(dividend));

    LowDwVfpRegister quotient = double_scratch0();

    ASSERT(!quotient.is(dividend));

    ASSERT(!quotient.is(divisor));

    Label done;

    // Check for x % 0, we have to deopt in this case because we can't return a

    // NaN.

    if (right->CanBeZero()) {

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

      DeoptimizeIf(eq, instr->environment());

    }

    __ Move(result_reg, left_reg);

    // Load the arguments in VFP registers. The divisor value is preloaded

    // before. Be careful that 'right_reg' is only live on entry.

    // TODO(svenpanne) The last comments seems to be wrong nowadays.

    __ vmov(double_scratch0().low(), left_reg);

    __ vcvt_f64_s32(dividend, double_scratch0().low());

    __ vmov(double_scratch0().low(), right_reg);

    __ vcvt_f64_s32(divisor, double_scratch0().low());

    // We do not care about the sign of the divisor. Note that we still handle

    // the kMinInt % -1 case correctly, though.

    __ vabs(divisor, divisor);

    // Compute the quotient and round it to a 32bit integer.

    __ vdiv(quotient, dividend, divisor);

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

    __ vcvt_f64_s32(quotient, quotient.low());

    // Compute the remainder in result.

    __ vmul(double_scratch0(), divisor, quotient);

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

    __ vmov(scratch, double_scratch0().low());

    __ sub(result_reg, left_reg, scratch, SetCC);

    // If we care about -0, test if the dividend is <0 and the result is 0.

    if (left->CanBeNegative() &&

        hmod->CanBeZero() &&

        hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {

      __ b(ne, &done);

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

      DeoptimizeIf(mi, instr->environment());

    }

    __ bind(&done);

  }

}

void LCodeGen::EmitSignedIntegerDivisionByConstant(

    Register result,

    Register dividend,

    int32_t divisor,

    Register remainder,

    Register scratch,

    LEnvironment* environment) {

  ASSERT(!AreAliased(dividend, scratch, ip));

  ASSERT(LChunkBuilder::HasMagicNumberForDivisor(divisor));

  uint32_t divisor_abs = abs(divisor);

  int32_t power_of_2_factor =

    CompilerIntrinsics::CountTrailingZeros(divisor_abs);

  switch (divisor_abs) {

    case 0:

      DeoptimizeIf(al, environment);

      return;

    case 1:

      if (divisor > 0) {

        __ Move(result, dividend);

      } else {

        __ rsb(result, dividend, Operand::Zero(), SetCC);

        DeoptimizeIf(vs, environment);

      }

      // Compute the remainder.

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

      return;

    default:

      if (IsPowerOf2(divisor_abs)) {

        // Branch and condition free code for integer division by a power

        // of two.

        int32_t power = WhichPowerOf2(divisor_abs);

        if (power > 1) {

          __ mov(scratch, Operand(dividend, ASR, power - 1));

        }

        __ add(scratch, dividend, Operand(scratch, LSR, 32 - power));

        __ mov(result, Operand(scratch, ASR, power));

        // Negate if necessary.

        // We don't need to check for overflow because the case '-1' is

        // handled separately.

        if (divisor < 0) {

          ASSERT(divisor != -1);

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

        }

        // Compute the remainder.

        if (divisor > 0) {

          __ sub(remainder, dividend, Operand(result, LSL, power));

        } else {

          __ add(remainder, dividend, Operand(result, LSL, power));

        }

        return;

      } else {

        // Use magic numbers for a few specific divisors.

        // Details and proofs can be found in:

        // - Hacker's Delight, Henry S. Warren, Jr.

        // - The PowerPC Compiler Writer’s Guide

        // and probably many others.

        //

        // We handle

        //   <divisor with magic numbers> * <power of 2>

        // but not

        //   <divisor with magic numbers> * <other divisor with magic numbers>

        DivMagicNumbers magic_numbers =

          DivMagicNumberFor(divisor_abs >> power_of_2_factor);

        // Branch and condition free code for integer division by a power

        // of two.

        const int32_t M = magic_numbers.M;

        const int32_t s = magic_numbers.s + power_of_2_factor;

        __ mov(ip, Operand(M));

        __ smull(ip, scratch, dividend, ip);

        if (M < 0) {

          __ add(scratch, scratch, Operand(dividend));

        }

        if (s > 0) {

          __ mov(scratch, Operand(scratch, ASR, s));

        }

        __ add(result, scratch, Operand(dividend, LSR, 31));

        if (divisor < 0) __ rsb(result, result, Operand::Zero());

        // Compute the remainder.

        __ mov(ip, Operand(divisor));

        // This sequence could be replaced with 'mls' when

        // it gets implemented.

        __ mul(scratch, result, ip);

        __ sub(remainder, dividend, scratch);

      }

  }

}

void LCodeGen::DoDivI(LDivI* instr) {

  if (instr->hydrogen()->HasPowerOf2Divisor()) {

    const Register dividend = ToRegister(instr->left());

    const Register result = ToRegister(instr->result());

    int32_t divisor = instr->hydrogen()->right()->GetInteger32Constant();

    int32_t test_value = 0;

    int32_t power = 0;

    if (divisor > 0) {

      test_value = divisor - 1;

      power = WhichPowerOf2(divisor);

    } else {

      // Check for (0 / -x) that will produce negative zero.

      if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {

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

        DeoptimizeIf(eq, instr->environment());

      }

      // Check for (kMinInt / -1).

      if (divisor == -1 && instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {

        __ cmp(dividend, Operand(kMinInt));

        DeoptimizeIf(eq, instr->environment());

      }

      test_value = - divisor - 1;

      power = WhichPowerOf2(-divisor);

    }

    if (test_value != 0) {

      if (instr->hydrogen()->CheckFlag(

          HInstruction::kAllUsesTruncatingToInt32)) {

        __ sub(result, dividend, Operand::Zero(), SetCC);

        __ rsb(result, result, Operand::Zero(), LeaveCC, lt);

        __ mov(result, Operand(result, ASR, power));

        if (divisor > 0) __ rsb(result, result, Operand::Zero(), LeaveCC, lt);

        if (divisor < 0) __ rsb(result, result, Operand::Zero(), LeaveCC, gt);

        return;  // Don't fall through to "__ rsb" below.

      } else {

        // Deoptimize if remainder is not 0.

        __ tst(dividend, Operand(test_value));

        DeoptimizeIf(ne, instr->environment());

        __ mov(result, Operand(dividend, ASR, power));

        if (divisor < 0) __ rsb(result, result, Operand(0));

      }

    } else {

      if (divisor < 0) {

        __ rsb(result, dividend, Operand(0));

      } else {

        __ Move(result, dividend);

      }

    }

    return;

  }

  const Register left = ToRegister(instr->left());

  const Register right = ToRegister(instr->right());

  const Register result = ToRegister(instr->result());

  // Check for x / 0.

  if (instr->hydrogen()->CheckFlag(HValue::kCanBeDivByZero)) {

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

    DeoptimizeIf(eq, instr->environment());

  }

  // Check for (0 / -x) that will produce negative zero.

  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {

    Label positive;

    if (!instr->hydrogen()->CheckFlag(HValue::kCanBeDivByZero)) {

      // Do the test only if it hadn't be done above.

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

    }

    __ b(pl, &positive);

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

    DeoptimizeIf(eq, instr->environment());

    __ bind(&positive);

  }

  // Check for (kMinInt / -1).

  if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {

    Label left_not_min_int;

    __ cmp(left, Operand(kMinInt));

    __ b(ne, &left_not_min_int);

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

    DeoptimizeIf(eq, instr->environment());

    __ bind(&left_not_min_int);

  }

  if (CpuFeatures::IsSupported(SUDIV)) {

    CpuFeatureScope scope(masm(), SUDIV);

    __ sdiv(result, left, right);

    if (!instr->hydrogen()->CheckFlag(

        HInstruction::kAllUsesTruncatingToInt32)) {

      // Compute remainder and deopt if it's not zero.

      const Register remainder = scratch0();

      __ mls(remainder, result, right, left);

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

      DeoptimizeIf(ne, instr->environment());

    }

  } else {

    const DoubleRegister vleft = ToDoubleRegister(instr->temp());

    const DoubleRegister vright = double_scratch0();

    __ vmov(double_scratch0().low(), left);

    __ vcvt_f64_s32(vleft, double_scratch0().low());

    __ vmov(double_scratch0().low(), right);

    __ vcvt_f64_s32(vright, double_scratch0().low());

    __ vdiv(vleft, vleft, vright);  // vleft now contains the result.

    __ vcvt_s32_f64(double_scratch0().low(), vleft);

    __ vmov(result, double_scratch0().low());

    if (!instr->hydrogen()->CheckFlag(

        HInstruction::kAllUsesTruncatingToInt32)) {

      // Deopt if exact conversion to integer was not possible.