CSE2410 Fall 2014 Bounce

// Copyright 2013 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_X64

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

#include "code-stubs.h"

#include "stub-cache.h"

#include "hydrogen-osr.h"

namespace v8 {

namespace internal {

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

    codegen_->EnsureSpaceForLazyDeopt(Deoptimizer::patch_size() - call_size);

  }

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

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

  RegisterDependentCodeForEmbeddedMaps(code);

  PopulateDeoptimizationData(code);

  info()->CommitDependencies(code);

}

void LChunkBuilder::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) {

    __ movq(Operand(rsp, offset), rax);

  }

}

#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 need to replace the receiver with undefined

    // when called as functions (without an explicit receiver

    // object). rcx is zero for method calls and non-zero for function

    // calls.

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

      Label ok;

      __ testq(rcx, rcx);

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

      StackArgumentsAccessor args(rsp, scope()->num_parameters());

      __ LoadRoot(kScratchRegister, Heap::kUndefinedValueRootIndex);

      __ movq(args.GetReceiverOperand(), kScratchRegister);

      __ bind(&ok);

    }

  }

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

  }

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

  int slots = GetStackSlotCount();

  if (slots > 0) {

    if (FLAG_debug_code) {

      __ subq(rsp, Immediate(slots * kPointerSize));

#ifdef _MSC_VER

      MakeSureStackPagesMapped(slots * kPointerSize);

#endif

      __ push(rax);

      __ Set(rax, slots);

      __ movq(kScratchRegister, kSlotsZapValue, RelocInfo::NONE64);

      Label loop;

      __ bind(&loop);

      __ movq(MemOperand(rsp, rax, times_pointer_size, 0),

              kScratchRegister);

      __ decl(rax);

      __ j(not_zero, &loop);

      __ pop(rax);

    } else {

      __ subq(rsp, Immediate(slots * kPointerSize));

#ifdef _MSC_VER

      MakeSureStackPagesMapped(slots * kPointerSize);

#endif

    }

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

        __ movsd(MemOperand(rsp, 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 rdi.

    __ push(rdi);

    if (heap_slots <= FastNewContextStub::kMaximumSlots) {

      FastNewContextStub stub(heap_slots);

      __ CallStub(&stub);

    } else {

      __ CallRuntime(Runtime::kNewFunctionContext, 1);

    }

    RecordSafepoint(Safepoint::kNoLazyDeopt);

    // Context is returned in both rax and rsi.  It replaces the context

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

    __ movq(Operand(rbp, StandardFrameConstants::kContextOffset), rsi);

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

        __ movq(rax, Operand(rbp, parameter_offset));

        // Store it in the context.

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

        __ movq(Operand(rsi, context_offset), rax);

        // Update the write barrier. This clobbers rax and rbx.

        __ RecordWriteContextSlot(rsi, context_offset, rax, rbx, kSaveFPRegs);

      }

    }

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

  }

  // Trace the call.

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

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

  __ subq(rsp, Immediate(slots * kPointerSize));

}

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

      __ movq(kScratchRegister, ExternalReference::ForDeoptEntry(entry));

      if (needs_frame.is_bound()) {

        __ jmp(&needs_frame);

      } else {

        __ bind(&needs_frame);

        __ push(rbp);

        __ movq(rbp, rsp);

        __ push(rsi);

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

        __ Move(rsi, Smi::FromInt(StackFrame::STUB));

        __ push(rsi);

        __ movq(rsi, MemOperand(rsp, kPointerSize));

        __ call(kScratchRegister);

      }

    } 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];

      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(rbp);  // Caller's frame pointer.

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

        __ Push(Smi::FromInt(StackFrame::STUB));

        __ lea(rbp, Operand(rsp, 2 * kPointerSize));

        Comment(";;; Deferred code");

      }

      code->Generate();

      if (NeedsDeferredFrame()) {

        __ bind(code->done());

        Comment(";;; Destroy frame");

        ASSERT(frame_is_built_);

        frame_is_built_ = false;

        __ movq(rsp, rbp);

        __ pop(rbp);

      }

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

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

  return !is_aborted();

}

Register LCodeGen::ToRegister(int index) const {

  return Register::FromAllocationIndex(index);

}

XMMRegister LCodeGen::ToDoubleRegister(int index) const {

  return XMMRegister::FromAllocationIndex(index);

}

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

  ASSERT(op->IsRegister());

  return ToRegister(op->index());

}

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

  ASSERT(op->IsDoubleRegister());

  return ToDoubleRegister(op->index());

}

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

  return op->IsConstantOperand() &&

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

}

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

  return op->IsConstantOperand() &&

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

}

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

  return op->IsConstantOperand() &&

      chunk_->LookupLiteralRepresentation(op).IsTagged();

}

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

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

  return constant->Integer32Value();

}

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

}

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

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

  ASSERT(constant->HasExternalReferenceValue());

  return constant->ExternalReferenceValue();

}

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

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

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

  return constant->handle(isolate());

}

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

  // Does not handle registers. In X64 assembler, plain registers are not

  // representable as an Operand.

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

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

}

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;

  }

  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,

                               int argc) {

  EnsureSpaceForLazyDeopt(Deoptimizer::patch_size() - masm()->CallSize(code));

  ASSERT(instr != NULL);

  __ call(code, mode);

  RecordSafepointWithLazyDeopt(instr, safepoint_mode, argc);

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

}

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

                           int num_arguments,

                           LInstruction* instr,

                           SaveFPRegsMode save_doubles) {

  ASSERT(instr != NULL);

  ASSERT(instr->HasPointerMap());

  __ CallRuntime(function, num_arguments, save_doubles);

  RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT, 0);

}

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

                                       int argc,

                                       LInstruction* instr) {

  __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));

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

  }

  ASSERT(FLAG_deopt_every_n_times == 0);  // Not yet implemented on x64.

  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, int argc) {

  if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {

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

  } else {

    ASSERT(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS);

    RecordSafepointWithRegisters(

        instr->pointer_map(), argc, 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());

    }

  }

  if (kind & Safepoint::kWithRegisters) {

    // Register rsi always contains a pointer to the context.

    safepoint.DefinePointerRegister(rsi, 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::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->result()).is(rax));

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

      __ testl(left_reg, left_reg);

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

      __ negl(left_reg);

      __ andl(left_reg, Immediate(divisor - 1));

      __ negl(left_reg);

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

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

      }

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

    }

    __ bind(&left_is_not_negative);

    __ andl(left_reg, Immediate(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.

    __ cmpl(right_reg, Immediate(divisor));

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

    Label left_is_not_negative, done;

    if (left->CanBeNegative()) {

      __ testl(left_reg, left_reg);

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

      __ negl(left_reg);

      __ andl(left_reg, Immediate(divisor - 1));

      __ negl(left_reg);

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

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

      }

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

    }

    __ bind(&left_is_not_negative);

    __ andl(left_reg, Immediate(divisor - 1));

    __ bind(&done);

  } else {

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

    ASSERT(left_reg.is(rax));

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

    ASSERT(!right_reg.is(rax));

    ASSERT(!right_reg.is(rdx));

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

    ASSERT(result_reg.is(rdx));

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

      __ testl(right_reg, 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;

      __ cmpl(left_reg, Immediate(kMinInt));

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

      __ cmpl(right_reg, Immediate(-1));

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

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

      } else {

        __ j(not_equal, &no_overflow_possible, Label::kNear);

        __ Set(result_reg, 0);

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

      }

      __ bind(&no_overflow_possible);

    }

    // Sign extend dividend in eax into edx:eax, since we are using only the low

    // 32 bits of the values.

    __ cdq();

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

    if (left->CanBeNegative() &&

        hmod->CanBeZero() &&

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

      Label positive_left;

      __ testl(left_reg, left_reg);

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

      __ idivl(right_reg);

      __ testl(result_reg, result_reg);

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

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

      __ bind(&positive_left);

    }

    __ idivl(right_reg);

    __ bind(&done);

  }

}

void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {

  ASSERT(instr->right()->IsConstantOperand());

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

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

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

  switch (divisor) {

  case 0:

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

    return;

  case 1:

    if (!result.is(dividend)) {

        __ movl(result, dividend);

    }

    return;

  case -1:

    if (!result.is(dividend)) {

      __ movl(result, dividend);

    }

    __ negl(result);

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

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

    }

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

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

    }

    return;

  }

  uint32_t divisor_abs = abs(divisor);

  if (IsPowerOf2(divisor_abs)) {

    int32_t power = WhichPowerOf2(divisor_abs);

    if (divisor < 0) {

      __ movsxlq(result, dividend);

      __ neg(result);

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

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

      }

      __ sar(result, Immediate(power));

    } else {

      if (!result.is(dividend)) {

        __ movl(result, dividend);

      }

      __ sarl(result, Immediate(power));

    }

  } else {

    Register reg1 = ToRegister(instr->temp());

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

    // Find b which: 2^b < divisor_abs < 2^(b+1).

    unsigned b = 31 - CompilerIntrinsics::CountLeadingZeros(divisor_abs);

    unsigned shift = 32 + b;  // Precision +1bit (effectively).

    double multiplier_f =

        static_cast<double>(static_cast<uint64_t>(1) << shift) / divisor_abs;

    int64_t multiplier;

    if (multiplier_f - floor(multiplier_f) < 0.5) {

        multiplier = static_cast<int64_t>(floor(multiplier_f));

    } else {

        multiplier = static_cast<int64_t>(floor(multiplier_f)) + 1;

    }

    // The multiplier is a uint32.

    ASSERT(multiplier > 0 &&

           multiplier < (static_cast<int64_t>(1) << 32));

    // The multiply is int64, so sign-extend to r64.

    __ movsxlq(reg1, dividend);

    if (divisor < 0 &&

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

      __ neg(reg1);

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

    }

    __ movq(reg2, multiplier, RelocInfo::NONE64);

    // Result just fit in r64, because it's int32 * uint32.

    __ imul(reg2, reg1);

    __ addq(reg2, Immediate(1 << 30));

    __ sar(reg2, Immediate(shift));

  }

}

void LCodeGen::DoDivI(LDivI* instr) {

  if (!instr->is_flooring() && instr->hydrogen()->HasPowerOf2Divisor()) {

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

    int32_t divisor =

        HConstant::cast(instr->hydrogen()->right())->Integer32Value();

    int32_t test_value = 0;

    int32_t power = 0;

    if (divisor > 0) {

      test_value = divisor - 1;

      power = WhichPowerOf2(divisor);

    } else {

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

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

        __ testl(dividend, dividend);

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

      }

      // Check for (kMinInt / -1).

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

        __ cmpl(dividend, Immediate(kMinInt));

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

      }

      test_value = - divisor - 1;

      power = WhichPowerOf2(-divisor);

    }

    if (test_value != 0) {

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

          HInstruction::kAllUsesTruncatingToInt32)) {

        Label done, negative;

        __ cmpl(dividend, Immediate(0));

        __ j(less, &negative, Label::kNear);

        __ sarl(dividend, Immediate(power));

        if (divisor < 0) __ negl(dividend);

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

        __ bind(&negative);

        __ negl(dividend);

        __ sarl(dividend, Immediate(power));

        if (divisor > 0) __ negl(dividend);

        __ bind(&done);

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

      } else {

        // Deoptimize if remainder is not 0.

        __ testl(dividend, Immediate(test_value));

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

        __ sarl(dividend, Immediate(power));

      }

    }

    if (divisor < 0) __ negl(dividend);

    return;

  }

  LOperand* right = instr->right();

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

  ASSERT(ToRegister(instr->left()).is(rax));

  ASSERT(!ToRegister(instr->right()).is(rax));

  ASSERT(!ToRegister(instr->right()).is(rdx));

  Register left_reg = rax;

  // Check for x / 0.

  Register right_reg = ToRegister(right);

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

    __ testl(right_reg, right_reg);

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

  }

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

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

    Label left_not_zero;

    __ testl(left_reg, left_reg);

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

    __ testl(right_reg, right_reg);

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

    __ bind(&left_not_zero);

  }

  // Check for (kMinInt / -1).

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

    Label left_not_min_int;

    __ cmpl(left_reg, Immediate(kMinInt));

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

    __ cmpl(right_reg, Immediate(-1));

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

    __ bind(&left_not_min_int);

  }

  // Sign extend to rdx.

  __ cdq();

  __ idivl(right_reg);

  if (instr->is_flooring()) {

    Label done;

    __ testl(rdx, rdx);

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

    __ xorl(rdx, right_reg);

    __ sarl(rdx, Immediate(31));

    __ addl(rax, rdx);

    __ bind(&done);

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

      HInstruction::kAllUsesTruncatingToInt32)) {

    // Deoptimize if remainder is not 0.

    __ testl(rdx, rdx);

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

  }

}

void LCodeGen::DoMulI(LMulI* instr) {

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

  LOperand* right = instr->right();

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

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

      __ movq(kScratchRegister, left);

    } else {

      __ movl(kScratchRegister, left);

    }

  }

  bool can_overflow =

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

  if (right->IsConstantOperand()) {

    int32_t right_value = ToInteger32(LConstantOperand::cast(right));

    if (right_value == -1) {

      __ negl(left);

    } else if (right_value == 0) {

      __ xorl(left, left);

    } else if (right_value == 2) {

      __ addl(left, left);

    } else if (!can_overflow) {

      // If the multiplication is known to not overflow, we

      // can use operations that don't set the overflow flag

      // correctly.

      switch (right_value) {

        case 1:

          // Do nothing.

          break;

        case 3:

          __ leal(left, Operand(left, left, times_2, 0));

          break;

        case 4:

          __ shll(left, Immediate(2));

          break;

        case 5:

          __ leal(left, Operand(left, left, times_4, 0));

          break;

        case 8:

          __ shll(left, Immediate(3));

          break;

        case 9:

          __ leal(left, Operand(left, left, times_8, 0));

          break;

        case 16:

          __ shll(left, Immediate(4));

          break;

        default:

          __ imull(left, left, Immediate(right_value));

          break;

      }

    } else {

      __ imull(left, left, Immediate(right_value));

    }

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

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

      __ SmiToInteger64(left, left);

      __ imul(left, ToOperand(right));

    } else {

      __ imull(left, ToOperand(right));

    }

  } else {

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

      __ SmiToInteger64(left, left);

      __ imul(left, ToRegister(right));

    } else {

      __ imull(left, ToRegister(right));

    }

  }

  if (can_overflow) {

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

  }

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

    // Bail out if the result is supposed to be negative zero.

    Label done;

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

      __ testq(left, left);

    } else {

      __ testl(left, left);

    }

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

    if (right->IsConstantOperand()) {

      // Constant can't be represented as Smi due to immediate size limit.

      ASSERT(!instr->hydrogen_value()->representation().IsSmi());

      if (ToInteger32(LConstantOperand::cast(right)) < 0) {

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

      } else if (ToInteger32(LConstantOperand::cast(right)) == 0) {

        __ cmpl(kScratchRegister, Immediate(0));

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

      }

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

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

        __ or_(kScratchRegister, ToOperand(right));

      } else {

        __ orl(kScratchRegister, ToOperand(right));

      }

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

    } else {

      // Test the non-zero operand for negative sign.

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

        __ or_(kScratchRegister, ToRegister(right));

      } else {

        __ orl(kScratchRegister, ToRegister(right));

      }

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

    }

    __ bind(&done);

  }

}

void LCodeGen::DoBitI(LBitI* instr) {

  LOperand* left = instr->left();

  LOperand* right = instr->right();

  ASSERT(left->Equals(instr->result()));

  ASSERT(left->IsRegister());

  if (right->IsConstantOperand()) {

    int32_t right_operand = ToInteger32(LConstantOperand::cast(right));

    switch (instr->op()) {

      case Token::BIT_AND:

        __ andl(ToRegister(left), Immediate(right_operand));

        break;

      case Token::BIT_OR:

        __ orl(ToRegister(left), Immediate(right_operand));

        break;

      case Token::BIT_XOR:

        if (right_operand == int32_t(~0)) {

          __ notl(ToRegister(left));

        } else {

          __ xorl(ToRegister(left), Immediate(right_operand));

        }

        break;

      default:

        UNREACHABLE();

        break;

    }

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

    switch (instr->op()) {

      case Token::BIT_AND:

        __ and_(ToRegister(left), ToOperand(right));

        break;

      case Token::BIT_OR:

        __ or_(ToRegister(left), ToOperand(right));

        break;

      case Token::BIT_XOR:

        __ xor_(ToRegister(left), ToOperand(right));

        break;

      default:

        UNREACHABLE();

        break;

    }

  } else {

    ASSERT(right->IsRegister());

    switch (instr->op()) {

      case Token::BIT_AND:

        __ and_(ToRegister(left), ToRegister(right));

        break;

      case Token::BIT_OR:

        __ or_(ToRegister(left), ToRegister(right));

        break;

      case Token::BIT_XOR:

        __ xor_(ToRegister(left), ToRegister(right));

        break;

      default:

        UNREACHABLE();

        break;

    }

  }

}

void LCodeGen::DoShiftI(LShiftI* instr) {

  LOperand* left = instr->left();

  LOperand* right = instr->right();

  ASSERT(left->Equals(instr->result()));

  ASSERT(left->IsRegister());

  if (right->IsRegister()) {

    ASSERT(ToRegister(right).is(rcx));

    switch (instr->op()) {

      case Token::ROR:

        __ rorl_cl(ToRegister(left));

        break;

      case Token::SAR: