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 "mips/lithium-codegen-mips.h"

#include "mips/lithium-gap-resolver-mips.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 LChunkBuilder::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

    // a1: 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()) {

      Label ok;

      __ Branch(&ok, eq, t1, Operand(zero_reg));

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

      __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);

      __ sw(a2, MemOperand(sp, receiver_offset));

      __ bind(&ok);

    }

  }

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

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

      __ push(a0);

      __ push(a1);

      __ Addu(a0, sp, Operand(slots *  kPointerSize));

      __ li(a1, Operand(kSlotsZapValue));

      Label loop;

      __ bind(&loop);

      __ Subu(a0, a0, Operand(kPointerSize));

      __ sw(a1, MemOperand(a0, 2 * kPointerSize));

      __ Branch(&loop, ne, a0, Operand(sp));

      __ pop(a1);

      __ pop(a0);

    } else {

      __ Subu(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()) {

      __ sdc1(DoubleRegister::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 a1.

    __ push(a1);

    if (heap_slots <= FastNewContextStub::kMaximumSlots) {

      FastNewContextStub stub(heap_slots);

      __ CallStub(&stub);

    } else {

      __ CallRuntime(Runtime::kNewFunctionContext, 1);

    }

    RecordSafepoint(Safepoint::kNoLazyDeopt);

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

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

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

        __ lw(a0, MemOperand(fp, parameter_offset));

        // Store it in the context.

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

        __ sw(a0, target);

        // Update the write barrier. This clobbers a3 and a0.

        __ RecordWriteContextSlot(

            cp, target.offset(), a0, a3, GetRAState(), 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);

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

        __ MultiPush(cp.bit() | fp.bit() | ra.bit());

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

        __ push(scratch0());

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

        Comment(";;; Deferred code");

      }

      code->Generate();

      if (NeedsDeferredFrame()) {

        Comment(";;; Destroy frame");

        ASSERT(frame_is_built_);

        __ pop(at);

        __ MultiPop(cp.bit() | fp.bit() | ra.bit());

        frame_is_built_ = false;

      }

      __ jmp(code->exit());

    }

  }

  // Deferred code 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::GenerateDeoptJumpTable() {

  if (deopt_jump_table_.length() > 0) {

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

  }

  Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

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

    }

    __ li(t9, Operand(ExternalReference::ForDeoptEntry(entry)));

    if (deopt_jump_table_[i].needs_frame) {

      if (needs_frame.is_bound()) {

        __ Branch(&needs_frame);

      } else {

        __ bind(&needs_frame);

        __ MultiPush(cp.bit() | fp.bit() | ra.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());

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

        __ push(scratch0());

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

        __ Call(t9);

      }

    } else {

      __ Call(t9);

    }

  }

  __ RecordComment("]");

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

}

DoubleRegister LCodeGen::ToDoubleRegister(int index) const {

  return DoubleRegister::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());

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

    } else if (r.IsSmi()) {

      ASSERT(constant->HasSmiValue());

      __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));

    } else if (r.IsDouble()) {

      Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);

    } else {

      ASSERT(r.IsSmiOrTagged());

      __ LoadObject(scratch, literal);

    }

    return scratch;

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

    __ lw(scratch, ToMemOperand(op));

    return scratch;

  }

  UNREACHABLE();

  return scratch;

}

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

  ASSERT(op->IsDoubleRegister());

  return ToDoubleRegister(op->index());

}

DoubleRegister LCodeGen::EmitLoadDoubleRegister(LOperand* op,

                                                FloatRegister flt_scratch,

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

      __ li(at, Operand(static_cast<int32_t>(literal->Number())));

      __ mtc1(at, flt_scratch);

      __ cvt_d_w(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()) {

    MemOperand mem_op = ToMemOperand(op);

    __ ldc1(dbl_scratch, mem_op);

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

  }

  // Stack slots not implemented, use ToMemOperand instead.

  UNREACHABLE();

  return Operand(0);

}

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

  CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);

}

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

                               RelocInfo::Mode mode,

                               LInstruction* instr,

                               SafepointMode safepoint_mode) {

  EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());

  ASSERT(instr != NULL);

  __ Call(code, mode);

  RecordSafepointWithLazyDeopt(instr, safepoint_mode);

}

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

    __ lw(cp, ToMemOperand(context));

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

    HConstant* constant =

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

    __ LoadObject(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,

                            Register src1,

                            const Operand& src2) {

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

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

    Label skip;

    if (condition != al) {

      __ Branch(&skip, NegateCondition(condition), src1, src2);

    }

    __ stop("trap_on_deopt");

    __ bind(&skip);

  }

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

  if (condition == al && frame_is_built_) {

    __ Call(entry, RelocInfo::RUNTIME_ENTRY, condition, src1, src2);

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

    }

    __ Branch(&deopt_jump_table_.last().label, condition, src1, src2);

  }

}

void LCodeGen::DeoptimizeIf(Condition condition,

                            LEnvironment* environment,

                            Register src1,

                            const Operand& src2) {

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

      ? Deoptimizer::LAZY

      : Deoptimizer::EAGER;

  DeoptimizeIf(condition, environment, bailout_type, src1, src2);

}

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

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

      __ lw(a0, 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()) {

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

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

      __ Branch(left_reg.is(result_reg) ? PROTECT : USE_DELAY_SLOT,

                &left_is_not_negative, ge, left_reg, Operand(zero_reg));

      __ subu(result_reg, zero_reg, left_reg);

      __ And(result_reg, result_reg, divisor - 1);

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

        DeoptimizeIf(eq, instr->environment(), result_reg, Operand(zero_reg));

      }

      __ Branch(USE_DELAY_SLOT, &done);

      __ subu(result_reg, zero_reg, result_reg);

    }

    __ bind(&left_is_not_negative);

    __ And(result_reg, left_reg, divisor - 1);

    __ bind(&done);

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

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

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

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

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

    ASSERT(IsPowerOf2(divisor));

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

    DeoptimizeIf(ne, instr->environment(), right_reg, Operand(divisor));

    Label left_is_not_negative, done;

    if (left->CanBeNegative()) {

      __ Branch(left_reg.is(result_reg) ? PROTECT : USE_DELAY_SLOT,

                &left_is_not_negative, ge, left_reg, Operand(zero_reg));

      __ subu(result_reg, zero_reg, left_reg);

      __ And(result_reg, result_reg, divisor - 1);

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

        DeoptimizeIf(eq, instr->environment(), result_reg, Operand(zero_reg));

      }

      __ Branch(USE_DELAY_SLOT, &done);

      __ subu(result_reg, zero_reg, result_reg);

    }

    __ bind(&left_is_not_negative);

    __ And(result_reg, left_reg, divisor - 1);

    __ bind(&done);

  } else {

    const Register scratch = scratch0();

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

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

    // div runs in the background while we check for special cases.

    Register right_reg = EmitLoadRegister(instr->right(), scratch);

    __ div(left_reg, right_reg);

    Label done;

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

    // NaN.

    if (right->CanBeZero()) {

      DeoptimizeIf(eq, instr->environment(), right_reg, Operand(zero_reg));

    }

    // Check for kMinInt % -1, we have to deopt if we care about -0, because we

    // can't return that.

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

      Label left_not_min_int;

      __ Branch(&left_not_min_int, ne, left_reg, Operand(kMinInt));

      // TODO(svenpanne) Don't deopt when we don't care about -0.

      DeoptimizeIf(eq, instr->environment(), right_reg, Operand(-1));

      __ bind(&left_not_min_int);

    }

    // TODO(svenpanne) Only emit the test/deopt if we have to.

    __ Branch(USE_DELAY_SLOT, &done, ge, left_reg, Operand(zero_reg));

    __ mfhi(result_reg);

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

      DeoptimizeIf(eq, instr->environment(), result_reg, Operand(zero_reg));

    }

    __ bind(&done);

  }

}

void LCodeGen::EmitSignedIntegerDivisionByConstant(

    Register result,

    Register dividend,

    int32_t divisor,

    Register remainder,

    Register scratch,

    LEnvironment* environment) {

  ASSERT(!AreAliased(dividend, scratch, at, no_reg));

  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 {

        __ SubuAndCheckForOverflow(result, zero_reg, dividend, scratch);

        DeoptimizeIf(lt, environment, scratch, Operand(zero_reg));

      }

      // Compute the remainder.

      __ Move(remainder, zero_reg);

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

          __ sra(scratch, dividend, power - 1);

        }

        __ srl(scratch, scratch, 32 - power);

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

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

          __ Subu(result, zero_reg, Operand(result));

        }

        // Compute the remainder.

        if (divisor > 0) {

          __ sll(scratch, result, power);

          __ Subu(remainder, dividend, Operand(scratch));

        } else {

          __ sll(scratch, result, power);

          __ Addu(remainder, dividend, Operand(scratch));

        }

        return;

      } else if (LChunkBuilder::HasMagicNumberForDivisor(divisor)) {

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

        __ li(scratch, Operand(M));

        __ mult(dividend, scratch);

        __ mfhi(scratch);

        if (M < 0) {

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

        }

        if (s > 0) {

          __ sra(scratch, scratch, s);

          __ mov(scratch, scratch);

        }

        __ srl(at, dividend, 31);

        __ Addu(result, scratch, Operand(at));

        if (divisor < 0) __ Subu(result, zero_reg, Operand(result));

        // Compute the remainder.

        __ li(scratch, Operand(divisor));

        __ Mul(scratch, result, Operand(scratch));

        __ Subu(remainder, dividend, Operand(scratch));

      } else {

        __ li(scratch, Operand(divisor));

        __ div(dividend, scratch);

        __ mfhi(remainder);

        __ mflo(result);

      }

  }

}

void LCodeGen::DoDivI(LDivI* instr) {

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

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

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

  // On MIPS div is asynchronous - it will run in the background while we

  // check for special cases.

  __ div(left, right);

  // Check for x / 0.

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

    DeoptimizeIf(eq, instr->environment(), right, Operand(zero_reg));

  }

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

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

    Label left_not_zero;

    __ Branch(&left_not_zero, ne, left, Operand(zero_reg));

    DeoptimizeIf(lt, instr->environment(), right, Operand(zero_reg));

    __ bind(&left_not_zero);

  }

  // Check for (kMinInt / -1).

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

    Label left_not_min_int;

    __ Branch(&left_not_min_int, ne, left, Operand(kMinInt));

    DeoptimizeIf(eq, instr->environment(), right, Operand(-1));

    __ bind(&left_not_min_int);

  }

  if (!instr->hydrogen()->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {

    __ mfhi(result);

    DeoptimizeIf(ne, instr->environment(), result, Operand(zero_reg));

  }

  __ mflo(result);

}

void LCodeGen::DoMultiplyAddD(LMultiplyAddD* instr) {

  DoubleRegister addend = ToDoubleRegister(instr->addend());

  DoubleRegister multiplier = ToDoubleRegister(instr->multiplier());

  DoubleRegister multiplicand = ToDoubleRegister(instr->multiplicand());

  // This is computed in-place.

  ASSERT(addend.is(ToDoubleRegister(instr->result())));

  __ madd_d(addend, addend, multiplier, multiplicand);

}

void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {

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

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

  const Register remainder = ToRegister(instr->temp());

  const Register scratch = scratch0();

  if (instr->right()->IsConstantOperand()) {

    Label done;

    int32_t divisor = ToInteger32(LConstantOperand::cast(instr->right()));

    if (divisor < 0) {

      DeoptimizeIf(eq, instr->environment(), left, Operand(zero_reg));

    }

    EmitSignedIntegerDivisionByConstant(result,

                                        left,

                                        divisor,

                                        remainder,

                                        scratch,

                                        instr->environment());

    // We performed a truncating division. Correct the result if necessary.

    __ Branch(&done, eq, remainder, Operand(zero_reg), USE_DELAY_SLOT);

    __ Xor(scratch , remainder, Operand(divisor));

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

    __ Subu(result, result, Operand(1));

    __ bind(&done);

  } else {

    Label done;

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

    // On MIPS div is asynchronous - it will run in the background while we

    // check for special cases.

    __ div(left, right);

    // Check for x / 0.

    DeoptimizeIf(eq, instr->environment(), right, Operand(zero_reg));

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

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

      Label left_not_zero;

      __ Branch(&left_not_zero, ne, left, Operand(zero_reg));

      DeoptimizeIf(lt, instr->environment(), right, Operand(zero_reg));

      __ bind(&left_not_zero);

    }

    // Check for (kMinInt / -1).

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

      Label left_not_min_int;

      __ Branch(&left_not_min_int, ne, left, Operand(kMinInt));

      DeoptimizeIf(eq, instr->environment(), right, Operand(-1));

      __ bind(&left_not_min_int);

    }

    __ mfhi(remainder);

    __ mflo(result);

    // We performed a truncating division. Correct the result if necessary.

    __ Branch(&done, eq, remainder, Operand(zero_reg), USE_DELAY_SLOT);

    __ Xor(scratch , remainder, Operand(right));

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

    __ Subu(result, result, Operand(1));

    __ bind(&done);

  }

}

void LCodeGen::DoMulI(LMulI* instr) {

  Register scratch = scratch0();

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

  // Note that result may alias left.

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

  LOperand* right_op = instr->right();

  bool bailout_on_minus_zero =

    instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);

  bool overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);

  if (right_op->IsConstantOperand()) {

    int32_t constant = ToInteger32(LConstantOperand::cast(right_op));

    if (bailout_on_minus_zero && (constant < 0)) {

      // The case of a null constant will be handled separately.

      // If constant is negative and left is null, the result should be -0.

      DeoptimizeIf(eq, instr->environment(), left, Operand(zero_reg));

    }

    switch (constant) {

      case -1:

        if (overflow) {

          __ SubuAndCheckForOverflow(result, zero_reg, left, scratch);

          DeoptimizeIf(lt, instr->environment(), scratch, Operand(zero_reg));

        } else {

          __ Subu(result, zero_reg, left);

        }

        break;

      case 0:

        if (bailout_on_minus_zero) {

          // If left is strictly negative and the constant is null, the

          // result is -0. Deoptimize if required, otherwise return 0.

          DeoptimizeIf(lt, instr->environment(), left, Operand(zero_reg));

        }

        __ mov(result, zero_reg);

        break;

      case 1:

        // Nothing to do.

        __ Move(result, left);

        break;

      default:

        // Multiplying by powers of two and powers of two plus or minus

        // one can be done faster with shifted operands.

        // For other constants we emit standard code.

        int32_t mask = constant >> 31;

        uint32_t constant_abs = (constant + mask) ^ mask;

        if (IsPowerOf2(constant_abs)) {

          int32_t shift = WhichPowerOf2(constant_abs);

          __ sll(result, left, shift);

          // Correct the sign of the result if the constant is negative.

          if (constant < 0)  __ Subu(result, zero_reg, result);

        } else if (IsPowerOf2(constant_abs - 1)) {

          int32_t shift = WhichPowerOf2(constant_abs - 1);

          __ sll(scratch, left, shift);

          __ Addu(result, scratch, left);

          // Correct the sign of the result if the constant is negative.

          if (constant < 0)  __ Subu(result, zero_reg, result);

        } else if (IsPowerOf2(constant_abs + 1)) {

          int32_t shift = WhichPowerOf2(constant_abs + 1);

          __ sll(scratch, left, shift);

          __ Subu(result, scratch, left);

          // Correct the sign of the result if the constant is negative.

          if (constant < 0)  __ Subu(result, zero_reg, result);

        } else {

          // Generate standard code.

          __ li(at, constant);

          __ Mul(result, left, at);

        }

    }

  } else {

    ASSERT(right_op->IsRegister());

    Register right = ToRegister(right_op);

    if (overflow) {

      // hi:lo = left * right.

      if (instr->hydrogen()->representation().IsSmi()) {

        __ SmiUntag(result, left);

        __ mult(result, right);

        __ mfhi(scratch);

        __ mflo(result);

      } else {

        __ mult(left, right);

        __ mfhi(scratch);

        __ mflo(result);