CSE2410 Fall 2014 Bounce

// Copyright 2012 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "v8.h"

#if V8_TARGET_ARCH_IA32

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

#include "ic.h"

#include "code-stubs.h"

#include "deoptimizer.h"

#include "stub-cache.h"

#include "codegen.h"

#include "hydrogen-osr.h"

namespace v8 {

namespace internal {

static SaveFPRegsMode GetSaveFPRegsMode() {

  // We don't need to save floating point regs when generating the snapshot

  return CpuFeatures::IsSafeForSnapshot(SSE2) ? kSaveFPRegs : kDontSaveFPRegs;

}

// When invoking builtins, we need to record the safepoint in the middle of

// the invoke instruction sequence generated by the macro assembler.

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

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

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

  FrameScope frame_scope(masm_, StackFrame::MANUAL);

  support_aligned_spilled_doubles_ = info()->IsOptimizing();

  dynamic_frame_alignment_ = info()->IsOptimizing() &&

      ((chunk()->num_double_slots() > 2 &&

        !chunk()->graph()->is_recursive()) ||

       !info()->osr_ast_id().IsNone());

  return GeneratePrologue() &&

      GenerateBody() &&

      GenerateDeferredCode() &&

      GenerateJumpTable() &&

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

  if (!info()->IsStub()) {

    Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(code);

  }

  info()->CommitDependencies(code);

}

void LCodeGen::Abort(BailoutReason reason) {

  info()->set_bailout_reason(reason);

  status_ = ABORTED;

}

#ifdef _MSC_VER

void LCodeGen::MakeSureStackPagesMapped(int offset) {

  const int kPageSize = 4 * KB;

  for (offset -= kPageSize; offset > 0; offset -= kPageSize) {

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

  }

}

#endif

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

      __ int3();

    }

#endif

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

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

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

    // function calls.

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

      Label ok;

      __ test(ecx, Operand(ecx));

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

      // +1 for return address.

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

      __ mov(Operand(esp, receiver_offset),

             Immediate(isolate()->factory()->undefined_value()));

      __ bind(&ok);

    }

    if (support_aligned_spilled_doubles_ && dynamic_frame_alignment_) {

      // Move state of dynamic frame alignment into edx.

      __ mov(edx, Immediate(kNoAlignmentPadding));

      Label do_not_pad, align_loop;

      STATIC_ASSERT(kDoubleSize == 2 * kPointerSize);

      // Align esp + 4 to a multiple of 2 * kPointerSize.

      __ test(esp, Immediate(kPointerSize));

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

      __ push(Immediate(0));

      __ mov(ebx, esp);

      __ mov(edx, Immediate(kAlignmentPaddingPushed));

      // Copy arguments, receiver, and return address.

      __ mov(ecx, Immediate(scope()->num_parameters() + 2));

      __ bind(&align_loop);

      __ mov(eax, Operand(ebx, 1 * kPointerSize));

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

      __ add(Operand(ebx), Immediate(kPointerSize));

      __ dec(ecx);

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

      __ mov(Operand(ebx, 0), Immediate(kAlignmentZapValue));

      __ bind(&do_not_pad);

    }

  }

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

  if (NeedsEagerFrame()) {

    ASSERT(!frame_is_built_);

    frame_is_built_ = true;

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

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

  }

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

      dynamic_frame_alignment_ &&

      FLAG_debug_code) {

    __ test(esp, Immediate(kPointerSize));

    __ Assert(zero, kFrameIsExpectedToBeAligned);

  }

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

  int slots = GetStackSlotCount();

  ASSERT(slots != 0 || !info()->IsOptimizing());

  if (slots > 0) {

    if (slots == 1) {

      if (dynamic_frame_alignment_) {

        __ push(edx);

      } else {

        __ push(Immediate(kNoAlignmentPadding));

      }

    } else {

      if (FLAG_debug_code) {

        __ sub(Operand(esp), Immediate(slots * kPointerSize));

#ifdef _MSC_VER

        MakeSureStackPagesMapped(slots * kPointerSize);

#endif

        __ push(eax);

        __ mov(Operand(eax), Immediate(slots));

        Label loop;

        __ bind(&loop);

        __ mov(MemOperand(esp, eax, times_4, 0),

               Immediate(kSlotsZapValue));

        __ dec(eax);

        __ j(not_zero, &loop);

        __ pop(eax);

      } else {

        __ sub(Operand(esp), Immediate(slots * kPointerSize));

#ifdef _MSC_VER

        MakeSureStackPagesMapped(slots * kPointerSize);

#endif

      }

      if (support_aligned_spilled_doubles_) {

        Comment(";;; Store dynamic frame alignment tag for spilled doubles");

        // Store dynamic frame alignment state in the first local.

        int offset = JavaScriptFrameConstants::kDynamicAlignmentStateOffset;

        if (dynamic_frame_alignment_) {

          __ mov(Operand(ebp, offset), edx);

        } else {

          __ mov(Operand(ebp, offset), Immediate(kNoAlignmentPadding));

        }

      }

    }

    if (info()->saves_caller_doubles() && CpuFeatures::IsSupported(SSE2)) {

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

      CpuFeatureScope scope(masm(), SSE2);

      int count = 0;

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

      BitVector::Iterator save_iterator(doubles);

      while (!save_iterator.Done()) {

        __ movsd(MemOperand(esp, count * kDoubleSize),

                  XMMRegister::FromAllocationIndex(save_iterator.Current()));

        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 still in edi.

    __ push(edi);

    if (heap_slots <= FastNewContextStub::kMaximumSlots) {

      FastNewContextStub stub(heap_slots);

      __ CallStub(&stub);

    } else {

      __ CallRuntime(Runtime::kNewFunctionContext, 1);

    }

    RecordSafepoint(Safepoint::kNoLazyDeopt);

    // Context is returned in both eax and esi.  It replaces the context

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

    __ mov(Operand(ebp, StandardFrameConstants::kContextOffset), esi);

    // Copy parameters into context if necessary.

    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.

        __ mov(eax, Operand(ebp, parameter_offset));

        // Store it in the context.

        int context_offset = Context::SlotOffset(var->index());

        __ mov(Operand(esi, context_offset), eax);

        // Update the write barrier. This clobbers eax and ebx.

        __ RecordWriteContextSlot(esi,

                                  context_offset,

                                  eax,

                                  ebx,

                                  kDontSaveFPRegs);

      }

    }

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

  }

  // Trace the call.

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

    // We have not executed any compiled code yet, so esi 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();

    // Move state of dynamic frame alignment into edx.

  __ mov(edx, Immediate(kNoAlignmentPadding));

  if (support_aligned_spilled_doubles_ && dynamic_frame_alignment_) {

    Label do_not_pad, align_loop;

    // Align ebp + 4 to a multiple of 2 * kPointerSize.

    __ test(ebp, Immediate(kPointerSize));

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

    __ push(Immediate(0));

    __ mov(ebx, esp);

    __ mov(edx, Immediate(kAlignmentPaddingPushed));

    // Move all parts of the frame over one word. The frame consists of:

    // unoptimized frame slots, alignment state, context, frame pointer, return

    // address, receiver, and the arguments.

    __ mov(ecx, Immediate(scope()->num_parameters() +

           5 + graph()->osr()->UnoptimizedFrameSlots()));

    __ bind(&align_loop);

    __ mov(eax, Operand(ebx, 1 * kPointerSize));

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

    __ add(Operand(ebx), Immediate(kPointerSize));

    __ dec(ecx);

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

    __ mov(Operand(ebx, 0), Immediate(kAlignmentZapValue));

    __ sub(Operand(ebp), Immediate(kPointerSize));

    __ bind(&do_not_pad);

  }

  // Save the first local, which is overwritten by the alignment state.

  Operand alignment_loc = MemOperand(ebp, -3 * kPointerSize);

  __ push(alignment_loc);

  // Set the dynamic frame alignment state.

  __ mov(alignment_loc, edx);

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

  // optimized frame.

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

  ASSERT(slots >= 1);

  __ sub(esp, Immediate((slots - 1) * kPointerSize));

}

void LCodeGen::GenerateBodyInstructionPre(LInstruction* instr) {

  if (!CpuFeatures::IsSupported(SSE2)) FlushX87StackIfNecessary(instr);

}

void LCodeGen::GenerateBodyInstructionPost(LInstruction* instr) {

  if (!CpuFeatures::IsSupported(SSE2)) {

    if (instr->IsGoto()) {

      x87_stack_.LeavingBlock(current_block_, LGoto::cast(instr));

    } else if (FLAG_debug_code && FLAG_enable_slow_asserts &&

               !instr->IsGap() && !instr->IsReturn()) {

      if (instr->ClobbersDoubleRegisters()) {

        if (instr->HasDoubleRegisterResult()) {

          ASSERT_EQ(1, x87_stack_.depth());

        } else {

          ASSERT_EQ(0, x87_stack_.depth());

        }

      }

      __ VerifyX87StackDepth(x87_stack_.depth());

    }

  }

}

bool LCodeGen::GenerateJumpTable() {

  Label needs_frame;

  if (jump_table_.length() > 0) {

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

  }

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

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

    Address entry = jump_table_[i].address;

    Deoptimizer::BailoutType type = 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 (jump_table_[i].needs_frame) {

      __ push(Immediate(ExternalReference::ForDeoptEntry(entry)));

      if (needs_frame.is_bound()) {

        __ jmp(&needs_frame);

      } else {

        __ bind(&needs_frame);

        __ push(MemOperand(ebp, StandardFrameConstants::kContextOffset));

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

        __ push(Immediate(Smi::FromInt(StackFrame::STUB)));

        // Push a PC inside the function so that the deopt code can find where

        // the deopt comes from. It doesn't have to be the precise return

        // address of a "calling" LAZY deopt, it only has to be somewhere

        // inside the code body.

        Label push_approx_pc;

        __ call(&push_approx_pc);

        __ bind(&push_approx_pc);

        // Push the continuation which was stashed were the ebp should

        // be. Replace it with the saved ebp.

        __ push(MemOperand(esp, 3 * kPointerSize));

        __ mov(MemOperand(esp, 4 * kPointerSize), ebp);

        __ lea(ebp, MemOperand(esp, 4 * kPointerSize));

        __ ret(0);  // Call the continuation without clobbering registers.

      }

    } else {

      __ call(entry, RelocInfo::RUNTIME_ENTRY);

    }

  }

  return !is_aborted();

}

bool LCodeGen::GenerateDeferredCode() {

  ASSERT(is_generating());

  if (deferred_.length() > 0) {

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

      LDeferredCode* code = deferred_[i];

      X87Stack copy(code->x87_stack());

      x87_stack_ = copy;

      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;

        // Build the frame in such a way that esi isn't trashed.

        __ push(ebp);  // Caller's frame pointer.

        __ push(Operand(ebp, StandardFrameConstants::kContextOffset));

        __ push(Immediate(Smi::FromInt(StackFrame::STUB)));

        __ lea(ebp, Operand(esp, 2 * kPointerSize));

        Comment(";;; Deferred code");

      }

      code->Generate();

      if (NeedsDeferredFrame()) {

        __ bind(code->done());

        Comment(";;; Destroy frame");

        ASSERT(frame_is_built_);

        frame_is_built_ = false;

        __ mov(esp, ebp);

        __ pop(ebp);

      }

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

  ASSERT(is_done());

  if (!info()->IsStub()) {

    // For lazy deoptimization we need space to patch a call after every call.

    // Ensure there is always space for such patching, even if the code ends

    // in a call.

    int target_offset = masm()->pc_offset() + Deoptimizer::patch_size();

    while (masm()->pc_offset() < target_offset) {

      masm()->nop();

    }

  }

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

  return !is_aborted();

}

Register LCodeGen::ToRegister(int index) const {

  return Register::FromAllocationIndex(index);

}

X87Register LCodeGen::ToX87Register(int index) const {

  return X87Register::FromAllocationIndex(index);

}

XMMRegister LCodeGen::ToDoubleRegister(int index) const {

  return XMMRegister::FromAllocationIndex(index);

}

void LCodeGen::X87LoadForUsage(X87Register reg) {

  ASSERT(x87_stack_.Contains(reg));

  x87_stack_.Fxch(reg);

  x87_stack_.pop();

}

void LCodeGen::X87LoadForUsage(X87Register reg1, X87Register reg2) {

  ASSERT(x87_stack_.Contains(reg1));

  ASSERT(x87_stack_.Contains(reg2));

  x87_stack_.Fxch(reg1, 1);

  x87_stack_.Fxch(reg2);

  x87_stack_.pop();

  x87_stack_.pop();

}

void LCodeGen::X87Stack::Fxch(X87Register reg, int other_slot) {

  ASSERT(is_mutable_);

  ASSERT(Contains(reg) && stack_depth_ > other_slot);

  int i  = ArrayIndex(reg);

  int st = st2idx(i);

  if (st != other_slot) {

    int other_i = st2idx(other_slot);

    X87Register other = stack_[other_i];

    stack_[other_i]   = reg;

    stack_[i]         = other;

    if (st == 0) {

      __ fxch(other_slot);

    } else if (other_slot == 0) {

      __ fxch(st);

    } else {

      __ fxch(st);

      __ fxch(other_slot);

      __ fxch(st);

    }

  }

}

int LCodeGen::X87Stack::st2idx(int pos) {

  return stack_depth_ - pos - 1;

}

int LCodeGen::X87Stack::ArrayIndex(X87Register reg) {

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

    if (stack_[i].is(reg)) return i;

  }

  UNREACHABLE();

  return -1;

}

bool LCodeGen::X87Stack::Contains(X87Register reg) {

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

    if (stack_[i].is(reg)) return true;

  }

  return false;

}

void LCodeGen::X87Stack::Free(X87Register reg) {

  ASSERT(is_mutable_);

  ASSERT(Contains(reg));

  int i  = ArrayIndex(reg);

  int st = st2idx(i);

  if (st > 0) {

    // keep track of how fstp(i) changes the order of elements

    int tos_i = st2idx(0);

    stack_[i] = stack_[tos_i];

  }

  pop();

  __ fstp(st);

}

void LCodeGen::X87Mov(X87Register dst, Operand src, X87OperandType opts) {

  if (x87_stack_.Contains(dst)) {

    x87_stack_.Fxch(dst);

    __ fstp(0);

  } else {

    x87_stack_.push(dst);

  }

  X87Fld(src, opts);

}

void LCodeGen::X87Fld(Operand src, X87OperandType opts) {

  ASSERT(!src.is_reg_only());

  switch (opts) {

    case kX87DoubleOperand:

      __ fld_d(src);

      break;

    case kX87FloatOperand:

      __ fld_s(src);

      break;

    case kX87IntOperand:

      __ fild_s(src);

      break;

    default:

      UNREACHABLE();

  }

}

void LCodeGen::X87Mov(Operand dst, X87Register src, X87OperandType opts) {

  ASSERT(!dst.is_reg_only());

  x87_stack_.Fxch(src);

  switch (opts) {

    case kX87DoubleOperand:

      __ fst_d(dst);

      break;

    case kX87IntOperand:

      __ fist_s(dst);

      break;

    default:

      UNREACHABLE();

  }

}

void LCodeGen::X87Stack::PrepareToWrite(X87Register reg) {

  ASSERT(is_mutable_);

  if (Contains(reg)) {

    Free(reg);

  }

  // Mark this register as the next register to write to

  stack_[stack_depth_] = reg;

}

void LCodeGen::X87Stack::CommitWrite(X87Register reg) {

  ASSERT(is_mutable_);

  // Assert the reg is prepared to write, but not on the virtual stack yet

  ASSERT(!Contains(reg) && stack_[stack_depth_].is(reg) &&

      stack_depth_ < X87Register::kNumAllocatableRegisters);

  stack_depth_++;

}

void LCodeGen::X87PrepareBinaryOp(

    X87Register left, X87Register right, X87Register result) {

  // You need to use DefineSameAsFirst for x87 instructions

  ASSERT(result.is(left));

  x87_stack_.Fxch(right, 1);

  x87_stack_.Fxch(left);

}

void LCodeGen::X87Stack::FlushIfNecessary(LInstruction* instr, LCodeGen* cgen) {

  if (stack_depth_ > 0 && instr->ClobbersDoubleRegisters()) {

    bool double_inputs = instr->HasDoubleRegisterInput();

    // Flush stack from tos down, since FreeX87() will mess with tos

    for (int i = stack_depth_-1; i >= 0; i--) {

      X87Register reg = stack_[i];

      // Skip registers which contain the inputs for the next instruction

      // when flushing the stack

      if (double_inputs && instr->IsDoubleInput(reg, cgen)) {

        continue;

      }

      Free(reg);

      if (i < stack_depth_-1) i++;

    }

  }

  if (instr->IsReturn()) {

    while (stack_depth_ > 0) {

      __ fstp(0);

      stack_depth_--;

    }

    if (FLAG_debug_code && FLAG_enable_slow_asserts) __ VerifyX87StackDepth(0);

  }

}

void LCodeGen::X87Stack::LeavingBlock(int current_block_id, LGoto* goto_instr) {

  ASSERT(stack_depth_ <= 1);

  // If ever used for new stubs producing two pairs of doubles joined into two

  // phis this assert hits. That situation is not handled, since the two stacks

  // might have st0 and st1 swapped.

  if (current_block_id + 1 != goto_instr->block_id()) {

    // If we have a value on the x87 stack on leaving a block, it must be a

    // phi input. If the next block we compile is not the join block, we have

    // to discard the stack state.

    stack_depth_ = 0;

  }

}

void LCodeGen::EmitFlushX87ForDeopt() {

  // The deoptimizer does not support X87 Registers. But as long as we

  // deopt from a stub its not a problem, since we will re-materialize the

  // original stub inputs, which can't be double registers.

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

  if (FLAG_debug_code && FLAG_enable_slow_asserts) {

    __ pushfd();

    __ VerifyX87StackDepth(x87_stack_.depth());

    __ popfd();

  }

  for (int i = 0; i < x87_stack_.depth(); i++) __ fstp(0);

}

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

  ASSERT(op->IsRegister());

  return ToRegister(op->index());

}

X87Register LCodeGen::ToX87Register(LOperand* op) const {

  ASSERT(op->IsDoubleRegister());

  return ToX87Register(op->index());

}

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

  ASSERT(op->IsDoubleRegister());

  return ToDoubleRegister(op->index());

}

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

}

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

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

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

  return constant->handle(isolate());

}

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

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

  ASSERT(constant->HasDoubleValue());

  return constant->DoubleValue();

}

ExternalReference LCodeGen::ToExternalReference(LConstantOperand* op) const {

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

  ASSERT(constant->HasExternalReferenceValue());

  return constant->ExternalReferenceValue();

}

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

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

}

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

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

}

Operand LCodeGen::ToOperand(LOperand* op) const {

  if (op->IsRegister()) return Operand(ToRegister(op));

  if (op->IsDoubleRegister()) return Operand(ToDoubleRegister(op));

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

  return Operand(ebp, StackSlotOffset(op->index()));

}

Operand LCodeGen::HighOperand(LOperand* op) {

  ASSERT(op->IsDoubleStackSlot());

  return Operand(ebp, 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 ARGUMENTS_ADAPTOR:

      translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);

      break;

    case STUB:

      translation->BeginCompiledStubFrame();

      break;

    default:

      UNREACHABLE();

  }

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

    XMMRegister 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::CallCodeGeneric(Handle<Code> code,

                               RelocInfo::Mode mode,

                               LInstruction* instr,

                               SafepointMode safepoint_mode) {

  ASSERT(instr != NULL);

  __ call(code, 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::CallCode(Handle<Code> code,

                        RelocInfo::Mode mode,

                        LInstruction* instr) {

  CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);

}

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

                           int argc,

                           LInstruction* instr,

                           SaveFPRegsMode save_doubles) {

  ASSERT(instr != NULL);

  ASSERT(instr->HasPointerMap());

  __ CallRuntime(fun, argc, save_doubles);

  RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);

  ASSERT(info()->is_calling());

}

void LCodeGen::LoadContextFromDeferred(LOperand* context) {

  if (context->IsRegister()) {

    if (!ToRegister(context).is(esi)) {

      __ mov(esi, ToRegister(context));

    }

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

    __ mov(esi, ToOperand(context));

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

    HConstant* constant =

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

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

  ASSERT(info()->is_calling());

}

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

                            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;

  }

  if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {

    ExternalReference count = ExternalReference::stress_deopt_count(isolate());

    Label no_deopt;

    __ pushfd();

    __ push(eax);

    __ mov(eax, Operand::StaticVariable(count));

    __ sub(eax, Immediate(1));

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

    if (FLAG_trap_on_deopt) __ int3();

    __ mov(eax, Immediate(FLAG_deopt_every_n_times));

    __ mov(Operand::StaticVariable(count), eax);

    __ pop(eax);

    __ popfd();

    ASSERT(frame_is_built_);

    __ call(entry, RelocInfo::RUNTIME_ENTRY);

    __ bind(&no_deopt);

    __ mov(Operand::StaticVariable(count), eax);

    __ pop(eax);

    __ popfd();

  }

  // Before Instructions which can deopt, we normally flush the x87 stack. But

  // we can have inputs or outputs of the current instruction on the stack,

  // thus we need to flush them here from the physical stack to leave it in a

  // consistent state.

  if (x87_stack_.depth() > 0) {

    Label done;

    if (cc != no_condition) __ j(NegateCondition(cc), &done, Label::kNear);

    EmitFlushX87ForDeopt();

    __ bind(&done);

  }

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

    Label done;

    if (cc != no_condition) __ j(NegateCondition(cc), &done, Label::kNear);

    __ int3();

    __ bind(&done);

  }

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

  if (cc == no_condition && 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 (jump_table_.is_empty() ||

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

        jump_table_.last().needs_frame != !frame_is_built_ ||

        jump_table_.last().bailout_type != bailout_type) {

      Deoptimizer::JumpTableEntry table_entry(entry,

                                              bailout_type,

                                              !frame_is_built_);

      jump_table_.Add(table_entry, zone());

    }

    if (cc == no_condition) {

      __ jmp(&jump_table_.last().label);

    } else {

      __ j(cc, &jump_table_.last().label);

    }

  }

}

void LCodeGen::DeoptimizeIf(Condition cc,

                            LEnvironment* environment) {

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

      ? Deoptimizer::LAZY

      : Deoptimizer::EAGER;

  DeoptimizeIf(cc, 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(kind == expected_safepoint_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 mode) {

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

}

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

  LPointerMap empty_pointers(zone());

  RecordSafepoint(&empty_pointers, mode);

}

void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,

                                            int arguments,

                                            Safepoint::DeoptMode mode) {

  RecordSafepoint(pointers, Safepoint::kWithRegisters, arguments, 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(esi));

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

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

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

    ASSERT(left_reg.is(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()) {

      __ test(left_reg, Operand(left_reg));

      __ j(not_sign, &left_is_not_negative, Label::kNear);

      __ neg(left_reg);

      __ and_(left_reg, divisor - 1);

      __ neg(left_reg);

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

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

      }

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

    }

    __ bind(&left_is_not_negative);

    __ and_(left_reg, divisor - 1);

    __ bind(&done);

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

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

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

    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.

    __ cmp(right_reg, Immediate(divisor));

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

    Label left_is_not_negative, done;

    if (left->CanBeNegative()) {

      __ test(left_reg, Operand(left_reg));

      __ j(not_sign, &left_is_not_negative, Label::kNear);

      __ neg(left_reg);

      __ and_(left_reg, divisor - 1);

      __ neg(left_reg);

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

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

      }

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

    }

    __ bind(&left_is_not_negative);

    __ and_(left_reg, divisor - 1);

    __ bind(&done);

  } else {

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

    ASSERT(left_reg.is(eax));

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

    ASSERT(!right_reg.is(eax));

    ASSERT(!right_reg.is(edx));

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

    ASSERT(result_reg.is(edx));

    Label done;

    // Check for x % 0, idiv would signal a divide error. We have to

    // deopt in this case because we can't return a NaN.

    if (right->CanBeZero()) {

      __ test(right_reg, Operand(right_reg));

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

    }

    // Check for kMinInt % -1, idiv would signal a divide error. 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, kMinInt);