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_X64

#include "code-stubs.h"

#include "codegen.h"

#include "compiler.h"

#include "debug.h"

#include "full-codegen.h"

#include "isolate-inl.h"

#include "parser.h"

#include "scopes.h"

#include "stub-cache.h"

namespace v8 {

namespace internal {

#define __ ACCESS_MASM(masm_)

class JumpPatchSite BASE_EMBEDDED {

 public:

  explicit JumpPatchSite(MacroAssembler* masm) : masm_(masm) {

#ifdef DEBUG

    info_emitted_ = false;

#endif

  }

  ~JumpPatchSite() {

    ASSERT(patch_site_.is_bound() == info_emitted_);

  }

  void EmitJumpIfNotSmi(Register reg,

                        Label* target,

                        Label::Distance near_jump = Label::kFar) {

    __ testb(reg, Immediate(kSmiTagMask));

    EmitJump(not_carry, target, near_jump);   // Always taken before patched.

  }

  void EmitJumpIfSmi(Register reg,

                     Label* target,

                     Label::Distance near_jump = Label::kFar) {

    __ testb(reg, Immediate(kSmiTagMask));

    EmitJump(carry, target, near_jump);  // Never taken before patched.

  }

  void EmitPatchInfo() {

    if (patch_site_.is_bound()) {

      int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(&patch_site_);

      ASSERT(is_int8(delta_to_patch_site));

      __ testl(rax, Immediate(delta_to_patch_site));

#ifdef DEBUG

      info_emitted_ = true;

#endif

    } else {

      __ nop();  // Signals no inlined code.

    }

  }

 private:

  // jc will be patched with jz, jnc will become jnz.

  void EmitJump(Condition cc, Label* target, Label::Distance near_jump) {

    ASSERT(!patch_site_.is_bound() && !info_emitted_);

    ASSERT(cc == carry || cc == not_carry);

    __ bind(&patch_site_);

    __ j(cc, target, near_jump);

  }

  MacroAssembler* masm_;

  Label patch_site_;

#ifdef DEBUG

  bool info_emitted_;

#endif

};

// Generate code for a JS function.  On entry to the function the receiver

// and arguments have been pushed on the stack left to right, with the

// return address on top of them.  The actual argument count matches the

// formal parameter count expected by the function.

//

// The live registers are:

//   o rdi: the JS function object being called (i.e. ourselves)

//   o rsi: our context

//   o rbp: our caller's frame pointer

//   o rsp: stack pointer (pointing to return address)

//

// The function builds a JS frame.  Please see JavaScriptFrameConstants in

// frames-x64.h for its layout.

void FullCodeGenerator::Generate() {

  CompilationInfo* info = info_;

  handler_table_ =

      isolate()->factory()->NewFixedArray(function()->handler_count(), TENURED);

  profiling_counter_ = isolate()->factory()->NewCell(

      Handle<Smi>(Smi::FromInt(FLAG_interrupt_budget), isolate()));

  SetFunctionPosition(function());

  Comment cmnt(masm_, "[ function compiled by full code generator");

  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). 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, info->scope()->num_parameters());

    __ LoadRoot(kScratchRegister, Heap::kUndefinedValueRootIndex);

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

    __ bind(&ok);

  }

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

  FrameScope frame_scope(masm_, StackFrame::MANUAL);

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

  __ Prologue(BUILD_FUNCTION_FRAME);

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

  { Comment cmnt(masm_, "[ Allocate locals");

    int locals_count = info->scope()->num_stack_slots();

    // Generators allocate locals, if any, in context slots.

    ASSERT(!info->function()->is_generator() || locals_count == 0);

    if (locals_count == 1) {

      __ PushRoot(Heap::kUndefinedValueRootIndex);

    } else if (locals_count > 1) {

      __ LoadRoot(rdx, Heap::kUndefinedValueRootIndex);

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

        __ push(rdx);

      }

    }

  }

  bool function_in_register = true;

  // Possibly allocate a local context.

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

  if (heap_slots > 0) {

    Comment cmnt(masm_, "[ Allocate context");

    // Argument to NewContext is the function, which is still in rdi.

    __ push(rdi);

    if (FLAG_harmony_scoping && info->scope()->is_global_scope()) {

      __ Push(info->scope()->GetScopeInfo());

      __ CallRuntime(Runtime::kNewGlobalContext, 2);

    } else if (heap_slots <= FastNewContextStub::kMaximumSlots) {

      FastNewContextStub stub(heap_slots);

      __ CallStub(&stub);

    } else {

      __ CallRuntime(Runtime::kNewFunctionContext, 1);

    }

    function_in_register = false;

    // 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 = info->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, kDontSaveFPRegs);

      }

    }

  }

  // Possibly allocate an arguments object.

  Variable* arguments = scope()->arguments();

  if (arguments != NULL) {

    // Arguments object must be allocated after the context object, in

    // case the "arguments" or ".arguments" variables are in the context.

    Comment cmnt(masm_, "[ Allocate arguments object");

    if (function_in_register) {

      __ push(rdi);

    } else {

      __ push(Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));

    }

    // The receiver is just before the parameters on the caller's stack.

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

    int offset = num_parameters * kPointerSize;

    __ lea(rdx,

           Operand(rbp, StandardFrameConstants::kCallerSPOffset + offset));

    __ push(rdx);

    __ Push(Smi::FromInt(num_parameters));

    // Arguments to ArgumentsAccessStub:

    //   function, receiver address, parameter count.

    // The stub will rewrite receiver and parameter count if the previous

    // stack frame was an arguments adapter frame.

    ArgumentsAccessStub::Type type;

    if (!is_classic_mode()) {

      type = ArgumentsAccessStub::NEW_STRICT;

    } else if (function()->has_duplicate_parameters()) {

      type = ArgumentsAccessStub::NEW_NON_STRICT_SLOW;

    } else {

      type = ArgumentsAccessStub::NEW_NON_STRICT_FAST;

    }

    ArgumentsAccessStub stub(type);

    __ CallStub(&stub);

    SetVar(arguments, rax, rbx, rdx);

  }

  if (FLAG_trace) {

    __ CallRuntime(Runtime::kTraceEnter, 0);

  }

  // Visit the declarations and body unless there is an illegal

  // redeclaration.

  if (scope()->HasIllegalRedeclaration()) {

    Comment cmnt(masm_, "[ Declarations");

    scope()->VisitIllegalRedeclaration(this);

  } else {

    PrepareForBailoutForId(BailoutId::FunctionEntry(), NO_REGISTERS);

    { Comment cmnt(masm_, "[ Declarations");

      // For named function expressions, declare the function name as a

      // constant.

      if (scope()->is_function_scope() && scope()->function() != NULL) {

        VariableDeclaration* function = scope()->function();

        ASSERT(function->proxy()->var()->mode() == CONST ||

               function->proxy()->var()->mode() == CONST_HARMONY);

        ASSERT(function->proxy()->var()->location() != Variable::UNALLOCATED);

        VisitVariableDeclaration(function);

      }

      VisitDeclarations(scope()->declarations());

    }

    { Comment cmnt(masm_, "[ Stack check");

      PrepareForBailoutForId(BailoutId::Declarations(), NO_REGISTERS);

      Label ok;

      __ CompareRoot(rsp, Heap::kStackLimitRootIndex);

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

      __ call(isolate()->builtins()->StackCheck(), RelocInfo::CODE_TARGET);

      __ bind(&ok);

    }

    { Comment cmnt(masm_, "[ Body");

      ASSERT(loop_depth() == 0);

      VisitStatements(function()->body());

      ASSERT(loop_depth() == 0);

    }

  }

  // Always emit a 'return undefined' in case control fell off the end of

  // the body.

  { Comment cmnt(masm_, "[ return <undefined>;");

    __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);

    EmitReturnSequence();

  }

}

void FullCodeGenerator::ClearAccumulator() {

  __ Set(rax, 0);

}

void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {

  __ movq(rbx, profiling_counter_, RelocInfo::EMBEDDED_OBJECT);

  __ SmiAddConstant(FieldOperand(rbx, Cell::kValueOffset),

                    Smi::FromInt(-delta));

}

void FullCodeGenerator::EmitProfilingCounterReset() {

  int reset_value = FLAG_interrupt_budget;

  if (info_->ShouldSelfOptimize() && !FLAG_retry_self_opt) {

    // Self-optimization is a one-off thing; if it fails, don't try again.

    reset_value = Smi::kMaxValue;

  }

  __ movq(rbx, profiling_counter_, RelocInfo::EMBEDDED_OBJECT);

  __ movq(kScratchRegister,

          reinterpret_cast<uint64_t>(Smi::FromInt(reset_value)),

          RelocInfo::NONE64);

  __ movq(FieldOperand(rbx, Cell::kValueOffset), kScratchRegister);

}

void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,

                                                Label* back_edge_target) {

  Comment cmnt(masm_, "[ Back edge bookkeeping");

  Label ok;

  int weight = 1;

  if (FLAG_weighted_back_edges) {

    ASSERT(back_edge_target->is_bound());

    int distance = masm_->SizeOfCodeGeneratedSince(back_edge_target);

    weight = Min(kMaxBackEdgeWeight,

                 Max(1, distance / kCodeSizeMultiplier));

  }

  EmitProfilingCounterDecrement(weight);

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

  __ call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);

  // Record a mapping of this PC offset to the OSR id.  This is used to find

  // the AST id from the unoptimized code in order to use it as a key into

  // the deoptimization input data found in the optimized code.

  RecordBackEdge(stmt->OsrEntryId());

  EmitProfilingCounterReset();

  __ bind(&ok);

  PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);

  // Record a mapping of the OSR id to this PC.  This is used if the OSR

  // entry becomes the target of a bailout.  We don't expect it to be, but

  // we want it to work if it is.

  PrepareForBailoutForId(stmt->OsrEntryId(), NO_REGISTERS);

}

void FullCodeGenerator::EmitReturnSequence() {

  Comment cmnt(masm_, "[ Return sequence");

  if (return_label_.is_bound()) {

    __ jmp(&return_label_);

  } else {

    __ bind(&return_label_);

    if (FLAG_trace) {

      __ push(rax);

      __ CallRuntime(Runtime::kTraceExit, 1);

    }

    if (FLAG_interrupt_at_exit || FLAG_self_optimization) {

      // Pretend that the exit is a backwards jump to the entry.

      int weight = 1;

      if (info_->ShouldSelfOptimize()) {

        weight = FLAG_interrupt_budget / FLAG_self_opt_count;

      } else if (FLAG_weighted_back_edges) {

        int distance = masm_->pc_offset();

        weight = Min(kMaxBackEdgeWeight,

                     Max(1, distance / kCodeSizeMultiplier));

      }

      EmitProfilingCounterDecrement(weight);

      Label ok;

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

      __ push(rax);

      if (info_->ShouldSelfOptimize() && FLAG_direct_self_opt) {

        __ push(Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));

        __ CallRuntime(Runtime::kOptimizeFunctionOnNextCall, 1);

      } else {

        __ call(isolate()->builtins()->InterruptCheck(),

                RelocInfo::CODE_TARGET);

      }

      __ pop(rax);

      EmitProfilingCounterReset();

      __ bind(&ok);

    }

#ifdef DEBUG

    // Add a label for checking the size of the code used for returning.

    Label check_exit_codesize;

    masm_->bind(&check_exit_codesize);

#endif

    CodeGenerator::RecordPositions(masm_, function()->end_position() - 1);

    __ RecordJSReturn();

    // Do not use the leave instruction here because it is too short to

    // patch with the code required by the debugger.

    __ movq(rsp, rbp);

    __ pop(rbp);

    int no_frame_start = masm_->pc_offset();

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

    __ Ret(arguments_bytes, rcx);

#ifdef ENABLE_DEBUGGER_SUPPORT

    // Add padding that will be overwritten by a debugger breakpoint.  We

    // have just generated at least 7 bytes: "movq rsp, rbp; pop rbp; ret k"

    // (3 + 1 + 3).

    const int kPadding = Assembler::kJSReturnSequenceLength - 7;

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

      masm_->int3();

    }

    // Check that the size of the code used for returning is large enough

    // for the debugger's requirements.

    ASSERT(Assembler::kJSReturnSequenceLength <=

           masm_->SizeOfCodeGeneratedSince(&check_exit_codesize));

#endif

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

  }

}

void FullCodeGenerator::EffectContext::Plug(Variable* var) const {

  ASSERT(var->IsStackAllocated() || var->IsContextSlot());

}

void FullCodeGenerator::AccumulatorValueContext::Plug(Variable* var) const {

  ASSERT(var->IsStackAllocated() || var->IsContextSlot());

  codegen()->GetVar(result_register(), var);

}

void FullCodeGenerator::StackValueContext::Plug(Variable* var) const {

  ASSERT(var->IsStackAllocated() || var->IsContextSlot());

  MemOperand operand = codegen()->VarOperand(var, result_register());

  __ push(operand);

}

void FullCodeGenerator::TestContext::Plug(Variable* var) const {

  codegen()->GetVar(result_register(), var);

  codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);

  codegen()->DoTest(this);

}

void FullCodeGenerator::EffectContext::Plug(Heap::RootListIndex index) const {

}

void FullCodeGenerator::AccumulatorValueContext::Plug(

    Heap::RootListIndex index) const {

  __ LoadRoot(result_register(), index);

}

void FullCodeGenerator::StackValueContext::Plug(

    Heap::RootListIndex index) const {

  __ PushRoot(index);

}

void FullCodeGenerator::TestContext::Plug(Heap::RootListIndex index) const {

  codegen()->PrepareForBailoutBeforeSplit(condition(),

                                          true,

                                          true_label_,

                                          false_label_);

  if (index == Heap::kUndefinedValueRootIndex ||

      index == Heap::kNullValueRootIndex ||

      index == Heap::kFalseValueRootIndex) {

    if (false_label_ != fall_through_) __ jmp(false_label_);

  } else if (index == Heap::kTrueValueRootIndex) {

    if (true_label_ != fall_through_) __ jmp(true_label_);

  } else {

    __ LoadRoot(result_register(), index);

    codegen()->DoTest(this);

  }

}

void FullCodeGenerator::EffectContext::Plug(Handle<Object> lit) const {

}

void FullCodeGenerator::AccumulatorValueContext::Plug(

    Handle<Object> lit) const {

  if (lit->IsSmi()) {

    __ SafeMove(result_register(), Smi::cast(*lit));

  } else {

    __ Move(result_register(), lit);

  }

}

void FullCodeGenerator::StackValueContext::Plug(Handle<Object> lit) const {

  if (lit->IsSmi()) {

    __ SafePush(Smi::cast(*lit));

  } else {

    __ Push(lit);

  }

}

void FullCodeGenerator::TestContext::Plug(Handle<Object> lit) const {

  codegen()->PrepareForBailoutBeforeSplit(condition(),

                                          true,

                                          true_label_,

                                          false_label_);

  ASSERT(!lit->IsUndetectableObject());  // There are no undetectable literals.

  if (lit->IsUndefined() || lit->IsNull() || lit->IsFalse()) {

    if (false_label_ != fall_through_) __ jmp(false_label_);

  } else if (lit->IsTrue() || lit->IsJSObject()) {

    if (true_label_ != fall_through_) __ jmp(true_label_);

  } else if (lit->IsString()) {

    if (String::cast(*lit)->length() == 0) {

      if (false_label_ != fall_through_) __ jmp(false_label_);

    } else {

      if (true_label_ != fall_through_) __ jmp(true_label_);

    }

  } else if (lit->IsSmi()) {

    if (Smi::cast(*lit)->value() == 0) {

      if (false_label_ != fall_through_) __ jmp(false_label_);

    } else {

      if (true_label_ != fall_through_) __ jmp(true_label_);

    }

  } else {

    // For simplicity we always test the accumulator register.

    __ Move(result_register(), lit);

    codegen()->DoTest(this);

  }

}

void FullCodeGenerator::EffectContext::DropAndPlug(int count,

                                                   Register reg) const {

  ASSERT(count > 0);

  __ Drop(count);

}

void FullCodeGenerator::AccumulatorValueContext::DropAndPlug(

    int count,

    Register reg) const {

  ASSERT(count > 0);

  __ Drop(count);

  __ Move(result_register(), reg);

}

void FullCodeGenerator::StackValueContext::DropAndPlug(int count,

                                                       Register reg) const {

  ASSERT(count > 0);

  if (count > 1) __ Drop(count - 1);

  __ movq(Operand(rsp, 0), reg);

}

void FullCodeGenerator::TestContext::DropAndPlug(int count,

                                                 Register reg) const {

  ASSERT(count > 0);

  // For simplicity we always test the accumulator register.

  __ Drop(count);

  __ Move(result_register(), reg);

  codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);

  codegen()->DoTest(this);

}

void FullCodeGenerator::EffectContext::Plug(Label* materialize_true,

                                            Label* materialize_false) const {

  ASSERT(materialize_true == materialize_false);

  __ bind(materialize_true);

}

void FullCodeGenerator::AccumulatorValueContext::Plug(

    Label* materialize_true,

    Label* materialize_false) const {

  Label done;

  __ bind(materialize_true);

  __ Move(result_register(), isolate()->factory()->true_value());

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

  __ bind(materialize_false);

  __ Move(result_register(), isolate()->factory()->false_value());

  __ bind(&done);

}

void FullCodeGenerator::StackValueContext::Plug(

    Label* materialize_true,

    Label* materialize_false) const {

  Label done;

  __ bind(materialize_true);

  __ Push(isolate()->factory()->true_value());

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

  __ bind(materialize_false);

  __ Push(isolate()->factory()->false_value());

  __ bind(&done);

}

void FullCodeGenerator::TestContext::Plug(Label* materialize_true,

                                          Label* materialize_false) const {

  ASSERT(materialize_true == true_label_);

  ASSERT(materialize_false == false_label_);

}

void FullCodeGenerator::EffectContext::Plug(bool flag) const {

}

void FullCodeGenerator::AccumulatorValueContext::Plug(bool flag) const {

  Heap::RootListIndex value_root_index =

      flag ? Heap::kTrueValueRootIndex : Heap::kFalseValueRootIndex;

  __ LoadRoot(result_register(), value_root_index);

}

void FullCodeGenerator::StackValueContext::Plug(bool flag) const {

  Heap::RootListIndex value_root_index =

      flag ? Heap::kTrueValueRootIndex : Heap::kFalseValueRootIndex;

  __ PushRoot(value_root_index);

}

void FullCodeGenerator::TestContext::Plug(bool flag) const {

  codegen()->PrepareForBailoutBeforeSplit(condition(),

                                          true,

                                          true_label_,

                                          false_label_);

  if (flag) {

    if (true_label_ != fall_through_) __ jmp(true_label_);

  } else {

    if (false_label_ != fall_through_) __ jmp(false_label_);

  }

}

void FullCodeGenerator::DoTest(Expression* condition,

                               Label* if_true,

                               Label* if_false,

                               Label* fall_through) {

  Handle<Code> ic = ToBooleanStub::GetUninitialized(isolate());

  CallIC(ic, RelocInfo::CODE_TARGET, condition->test_id());

  __ testq(result_register(), result_register());

  // The stub returns nonzero for true.

  Split(not_zero, if_true, if_false, fall_through);

}

void FullCodeGenerator::Split(Condition cc,

                              Label* if_true,

                              Label* if_false,

                              Label* fall_through) {

  if (if_false == fall_through) {

    __ j(cc, if_true);

  } else if (if_true == fall_through) {

    __ j(NegateCondition(cc), if_false);

  } else {

    __ j(cc, if_true);

    __ jmp(if_false);

  }

}

MemOperand FullCodeGenerator::StackOperand(Variable* var) {

  ASSERT(var->IsStackAllocated());

  // Offset is negative because higher indexes are at lower addresses.

  int offset = -var->index() * kPointerSize;

  // Adjust by a (parameter or local) base offset.

  if (var->IsParameter()) {

    offset += kFPOnStackSize + kPCOnStackSize +

              (info_->scope()->num_parameters() - 1) * kPointerSize;

  } else {

    offset += JavaScriptFrameConstants::kLocal0Offset;

  }

  return Operand(rbp, offset);

}

MemOperand FullCodeGenerator::VarOperand(Variable* var, Register scratch) {

  ASSERT(var->IsContextSlot() || var->IsStackAllocated());

  if (var->IsContextSlot()) {

    int context_chain_length = scope()->ContextChainLength(var->scope());

    __ LoadContext(scratch, context_chain_length);

    return ContextOperand(scratch, var->index());

  } else {

    return StackOperand(var);

  }

}

void FullCodeGenerator::GetVar(Register dest, Variable* var) {

  ASSERT(var->IsContextSlot() || var->IsStackAllocated());

  MemOperand location = VarOperand(var, dest);

  __ movq(dest, location);

}

void FullCodeGenerator::SetVar(Variable* var,

                               Register src,

                               Register scratch0,

                               Register scratch1) {

  ASSERT(var->IsContextSlot() || var->IsStackAllocated());

  ASSERT(!scratch0.is(src));

  ASSERT(!scratch0.is(scratch1));

  ASSERT(!scratch1.is(src));

  MemOperand location = VarOperand(var, scratch0);

  __ movq(location, src);

  // Emit the write barrier code if the location is in the heap.

  if (var->IsContextSlot()) {

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

    __ RecordWriteContextSlot(scratch0, offset, src, scratch1, kDontSaveFPRegs);

  }

}

void FullCodeGenerator::PrepareForBailoutBeforeSplit(Expression* expr,

                                                     bool should_normalize,

                                                     Label* if_true,

                                                     Label* if_false) {

  // Only prepare for bailouts before splits if we're in a test

  // context. Otherwise, we let the Visit function deal with the

  // preparation to avoid preparing with the same AST id twice.

  if (!context()->IsTest() || !info_->IsOptimizable()) return;

  Label skip;

  if (should_normalize) __ jmp(&skip, Label::kNear);

  PrepareForBailout(expr, TOS_REG);

  if (should_normalize) {

    __ CompareRoot(rax, Heap::kTrueValueRootIndex);

    Split(equal, if_true, if_false, NULL);

    __ bind(&skip);

  }

}

void FullCodeGenerator::EmitDebugCheckDeclarationContext(Variable* variable) {

  // The variable in the declaration always resides in the current context.

  ASSERT_EQ(0, scope()->ContextChainLength(variable->scope()));

  if (generate_debug_code_) {

    // Check that we're not inside a with or catch context.

    __ movq(rbx, FieldOperand(rsi, HeapObject::kMapOffset));

    __ CompareRoot(rbx, Heap::kWithContextMapRootIndex);

    __ Check(not_equal, kDeclarationInWithContext);

    __ CompareRoot(rbx, Heap::kCatchContextMapRootIndex);

    __ Check(not_equal, kDeclarationInCatchContext);

  }

}

void FullCodeGenerator::VisitVariableDeclaration(

    VariableDeclaration* declaration) {

  // If it was not possible to allocate the variable at compile time, we

  // need to "declare" it at runtime to make sure it actually exists in the

  // local context.

  VariableProxy* proxy = declaration->proxy();

  VariableMode mode = declaration->mode();

  Variable* variable = proxy->var();

  bool hole_init = mode == CONST || mode == CONST_HARMONY || mode == LET;

  switch (variable->location()) {

    case Variable::UNALLOCATED:

      globals_->Add(variable->name(), zone());

      globals_->Add(variable->binding_needs_init()

                        ? isolate()->factory()->the_hole_value()

                    : isolate()->factory()->undefined_value(),

                    zone());

      break;

    case Variable::PARAMETER:

    case Variable::LOCAL:

      if (hole_init) {

        Comment cmnt(masm_, "[ VariableDeclaration");

        __ LoadRoot(kScratchRegister, Heap::kTheHoleValueRootIndex);

        __ movq(StackOperand(variable), kScratchRegister);

      }

      break;

    case Variable::CONTEXT:

      if (hole_init) {

        Comment cmnt(masm_, "[ VariableDeclaration");

        EmitDebugCheckDeclarationContext(variable);

        __ LoadRoot(kScratchRegister, Heap::kTheHoleValueRootIndex);

        __ movq(ContextOperand(rsi, variable->index()), kScratchRegister);

        // No write barrier since the hole value is in old space.

        PrepareForBailoutForId(proxy->id(), NO_REGISTERS);

      }

      break;

    case Variable::LOOKUP: {

      Comment cmnt(masm_, "[ VariableDeclaration");

      __ push(rsi);

      __ Push(variable->name());

      // Declaration nodes are always introduced in one of four modes.

      ASSERT(IsDeclaredVariableMode(mode));

      PropertyAttributes attr =

          IsImmutableVariableMode(mode) ? READ_ONLY : NONE;

      __ Push(Smi::FromInt(attr));

      // Push initial value, if any.

      // Note: For variables we must not push an initial value (such as

      // 'undefined') because we may have a (legal) redeclaration and we

      // must not destroy the current value.

      if (hole_init) {

        __ PushRoot(Heap::kTheHoleValueRootIndex);

      } else {

        __ Push(Smi::FromInt(0));  // Indicates no initial value.

      }

      __ CallRuntime(Runtime::kDeclareContextSlot, 4);

      break;

    }

  }

}

void FullCodeGenerator::VisitFunctionDeclaration(

    FunctionDeclaration* declaration) {

  VariableProxy* proxy = declaration->proxy();

  Variable* variable = proxy->var();

  switch (variable->location()) {

    case Variable::UNALLOCATED: {

      globals_->Add(variable->name(), zone());

      Handle<SharedFunctionInfo> function =

          Compiler::BuildFunctionInfo(declaration->fun(), script());

      // Check for stack-overflow exception.

      if (function.is_null()) return SetStackOverflow();

      globals_->Add(function, zone());

      break;

    }

    case Variable::PARAMETER:

    case Variable::LOCAL: {

      Comment cmnt(masm_, "[ FunctionDeclaration");

      VisitForAccumulatorValue(declaration->fun());

      __ movq(StackOperand(variable), result_register());

      break;

    }

    case Variable::CONTEXT: {

      Comment cmnt(masm_, "[ FunctionDeclaration");

      EmitDebugCheckDeclarationContext(variable);

      VisitForAccumulatorValue(declaration->fun());

      __ movq(ContextOperand(rsi, variable->index()), result_register());

      int offset = Context::SlotOffset(variable->index());

      // We know that we have written a function, which is not a smi.

      __ RecordWriteContextSlot(rsi,

                                offset,

                                result_register(),

                                rcx,

                                kDontSaveFPRegs,

                                EMIT_REMEMBERED_SET,

                                OMIT_SMI_CHECK);

      PrepareForBailoutForId(proxy->id(), NO_REGISTERS);

      break;

    }

    case Variable::LOOKUP: {

      Comment cmnt(masm_, "[ FunctionDeclaration");

      __ push(rsi);

      __ Push(variable->name());

      __ Push(Smi::FromInt(NONE));

      VisitForStackValue(declaration->fun());

      __ CallRuntime(Runtime::kDeclareContextSlot, 4);

      break;

    }

  }

}

void FullCodeGenerator::VisitModuleDeclaration(ModuleDeclaration* declaration) {

  Variable* variable = declaration->proxy()->var();

  ASSERT(variable->location() == Variable::CONTEXT);

  ASSERT(variable->interface()->IsFrozen());

  Comment cmnt(masm_, "[ ModuleDeclaration");

  EmitDebugCheckDeclarationContext(variable);

  // Load instance object.

  __ LoadContext(rax, scope_->ContextChainLength(scope_->GlobalScope()));

  __ movq(rax, ContextOperand(rax, variable->interface()->Index()));

  __ movq(rax, ContextOperand(rax, Context::EXTENSION_INDEX));

  // Assign it.

  __ movq(ContextOperand(rsi, variable->index()), rax);

  // We know that we have written a module, which is not a smi.

  __ RecordWriteContextSlot(rsi,

                            Context::SlotOffset(variable->index()),

                            rax,

                            rcx,

                            kDontSaveFPRegs,

                            EMIT_REMEMBERED_SET,

                            OMIT_SMI_CHECK);

  PrepareForBailoutForId(declaration->proxy()->id(), NO_REGISTERS);

  // Traverse into body.

  Visit(declaration->module());

}

void FullCodeGenerator::VisitImportDeclaration(ImportDeclaration* declaration) {

  VariableProxy* proxy = declaration->proxy();

  Variable* variable = proxy->var();

  switch (variable->location()) {

    case Variable::UNALLOCATED:

      // TODO(rossberg)

      break;

    case Variable::CONTEXT: {

      Comment cmnt(masm_, "[ ImportDeclaration");

      EmitDebugCheckDeclarationContext(variable);

      // TODO(rossberg)

      break;

    }

    case Variable::PARAMETER:

    case Variable::LOCAL:

    case Variable::LOOKUP:

      UNREACHABLE();

  }

}

void FullCodeGenerator::VisitExportDeclaration(ExportDeclaration* declaration) {

  // TODO(rossberg)

}

void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {

  // Call the runtime to declare the globals.

  __ push(rsi);  // The context is the first argument.

  __ Push(pairs);

  __ Push(Smi::FromInt(DeclareGlobalsFlags()));

  __ CallRuntime(Runtime::kDeclareGlobals, 3);

  // Return value is ignored.

}

void FullCodeGenerator::DeclareModules(Handle<FixedArray> descriptions) {

  // Call the runtime to declare the modules.

  __ Push(descriptions);

  __ CallRuntime(Runtime::kDeclareModules, 1);

  // Return value is ignored.

}

void FullCodeGenerator::VisitSwitchStatement(SwitchStatement* stmt) {

  Comment cmnt(masm_, "[ SwitchStatement");

  Breakable nested_statement(this, stmt);

  SetStatementPosition(stmt);

  // Keep the switch value on the stack until a case matches.

  VisitForStackValue(stmt->tag());

  PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);

  ZoneList<CaseClause*>* clauses = stmt->cases();

  CaseClause* default_clause = NULL;  // Can occur anywhere in the list.

  Label next_test;  // Recycled for each test.

  // Compile all the tests with branches to their bodies.

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

    CaseClause* clause = clauses->at(i);

    clause->body_target()->Unuse();

    // The default is not a test, but remember it as final fall through.

    if (clause->is_default()) {

      default_clause = clause;

      continue;

    }

    Comment cmnt(masm_, "[ Case comparison");

    __ bind(&next_test);

    next_test.Unuse();

    // Compile the label expression.

    VisitForAccumulatorValue(clause->label());

    // Perform the comparison as if via '==='.

    __ movq(rdx, Operand(rsp, 0));  // Switch value.

    bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);

    JumpPatchSite patch_site(masm_);

    if (inline_smi_code) {

      Label slow_case;

      __ movq(rcx, rdx);

      __ or_(rcx, rax);

      patch_site.EmitJumpIfNotSmi(rcx, &slow_case, Label::kNear);

      __ cmpq(rdx, rax);

      __ j(not_equal, &next_test);

      __ Drop(1);  // Switch value is no longer needed.

      __ jmp(clause->body_target());

      __ bind(&slow_case);

    }

    // Record position before stub call for type feedback.

    SetSourcePosition(clause->position());

    Handle<Code> ic = CompareIC::GetUninitialized(isolate(), Token::EQ_STRICT);

    CallIC(ic, RelocInfo::CODE_TARGET, clause->CompareId());

    patch_site.EmitPatchInfo();

    __ testq(rax, rax);

    __ j(not_equal, &next_test);

    __ Drop(1);  // Switch value is no longer needed.

    __ jmp(clause->body_target());

  }

  // Discard the test value and jump to the default if present, otherwise to

  // the end of the statement.

  __ bind(&next_test);

  __ Drop(1);  // Switch value is no longer needed.

  if (default_clause == NULL) {

    __ jmp(nested_statement.break_label());

  } else {

    __ jmp(default_clause->body_target());

  }

  // Compile all the case bodies.

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

    Comment cmnt(masm_, "[ Case body");

    CaseClause* clause = clauses->at(i);

    __ bind(clause->body_target());

    PrepareForBailoutForId(clause->EntryId(), NO_REGISTERS);

    VisitStatements(clause->statements());

  }

  __ bind(nested_statement.break_label());

  PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);

}

void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {

  Comment cmnt(masm_, "[ ForInStatement");

  SetStatementPosition(stmt);

  Label loop, exit;

  ForIn loop_statement(this, stmt);

  increment_loop_depth();

  // Get the object to enumerate over. If the object is null or undefined, skip

  // over the loop.  See ECMA-262 version 5, section 12.6.4.

  VisitForAccumulatorValue(stmt->enumerable());

  __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);

  __ j(equal, &exit);

  Register null_value = rdi;

  __ LoadRoot(null_value, Heap::kNullValueRootIndex);

  __ cmpq(rax, null_value);

  __ j(equal, &exit);

  PrepareForBailoutForId(stmt->PrepareId(), TOS_REG);

  // Convert the object to a JS object.

  Label convert, done_convert;

  __ JumpIfSmi(rax, &convert);

  __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);

  __ j(above_equal, &done_convert);

  __ bind(&convert);

  __ push(rax);

  __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);

  __ bind(&done_convert);

  __ push(rax);

  // Check for proxies.

  Label call_runtime;

  STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);

  __ CmpObjectType(rax, LAST_JS_PROXY_TYPE, rcx);

  __ j(below_equal, &call_runtime);

  // Check cache validity in generated code. This is a fast case for

  // the JSObject::IsSimpleEnum cache validity checks. If we cannot

  // guarantee cache validity, call the runtime system to check cache

  // validity or get the property names in a fixed array.

  __ CheckEnumCache(null_value, &call_runtime);

  // The enum cache is valid.  Load the map of the object being

  // iterated over and use the cache for the iteration.

  Label use_cache;

  __ movq(rax, FieldOperand(rax, HeapObject::kMapOffset));

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

  // Get the set of properties to enumerate.

  __ bind(&call_runtime);

  __ push(rax);  // Duplicate the enumerable object on the stack.

  __ CallRuntime(Runtime::kGetPropertyNamesFast, 1);

  // If we got a map from the runtime call, we can do a fast

  // modification check. Otherwise, we got a fixed array, and we have

  // to do a slow check.

  Label fixed_array;

  __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),

                 Heap::kMetaMapRootIndex);

  __ j(not_equal, &fixed_array);

  // We got a map in register rax. Get the enumeration cache from it.

  __ bind(&use_cache);

  Label no_descriptors;

  __ EnumLength(rdx, rax);

  __ Cmp(rdx, Smi::FromInt(0));

  __ j(equal, &no_descriptors);

  __ LoadInstanceDescriptors(rax, rcx);

  __ movq(rcx, FieldOperand(rcx, DescriptorArray::kEnumCacheOffset));

  __ movq(rcx, FieldOperand(rcx, DescriptorArray::kEnumCacheBridgeCacheOffset));

  // Set up the four remaining stack slots.

  __ push(rax);  // Map.

  __ push(rcx);  // Enumeration cache.

  __ push(rdx);  // Number of valid entries for the map in the enum cache.

  __ Push(Smi::FromInt(0));  // Initial index.

  __ jmp(&loop);

  __ bind(&no_descriptors);

  __ addq(rsp, Immediate(kPointerSize));

  __ jmp(&exit);

  // We got a fixed array in register rax. Iterate through that.

  Label non_proxy;

  __ bind(&fixed_array);

  Handle<Cell> cell = isolate()->factory()->NewCell(

      Handle<Object>(Smi::FromInt(TypeFeedbackCells::kForInFastCaseMarker),

                     isolate()));

  RecordTypeFeedbackCell(stmt->ForInFeedbackId(), cell);

  __ Move(rbx, cell);

  __ Move(FieldOperand(rbx, Cell::kValueOffset),

          Smi::FromInt(TypeFeedbackCells::kForInSlowCaseMarker));

  __ Move(rbx, Smi::FromInt(1));  // Smi indicates slow check

  __ movq(rcx, Operand(rsp, 0 * kPointerSize));  // Get enumerated object

  STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);

  __ CmpObjectType(rcx, LAST_JS_PROXY_TYPE, rcx);

  __ j(above, &non_proxy);

  __ Move(rbx, Smi::FromInt(0));  // Zero indicates proxy

  __ bind(&non_proxy);

  __ push(rbx);  // Smi

  __ push(rax);  // Array

  __ movq(rax, FieldOperand(rax, FixedArray::kLengthOffset));

  __ push(rax);  // Fixed array length (as smi).

  __ Push(Smi::FromInt(0));  // Initial index.

  // Generate code for doing the condition check.

  PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);

  __ bind(&loop);

  __ movq(rax, Operand(rsp, 0 * kPointerSize));  // Get the current index.

  __ cmpq(rax, Operand(rsp, 1 * kPointerSize));  // Compare to the array length.

  __ j(above_equal, loop_statement.break_label());

  // Get the current entry of the array into register rbx.

  __ movq(rbx, Operand(rsp, 2 * kPointerSize));

  SmiIndex index = masm()->SmiToIndex(rax, rax, kPointerSizeLog2);

  __ movq(rbx, FieldOperand(rbx,

                            index.reg,

                            index.scale,

                            FixedArray::kHeaderSize));

  // Get the expected map from the stack or a smi in the

  // permanent slow case into register rdx.

  __ movq(rdx, Operand(rsp, 3 * kPointerSize));

  // Check if the expected map still matches that of the enumerable.

  // If not, we may have to filter the key.

  Label update_each;

  __ movq(rcx, Operand(rsp, 4 * kPointerSize));

  __ cmpq(rdx, FieldOperand(rcx, HeapObject::kMapOffset));

  __ j(equal, &update_each, Label::kNear);

  // For proxies, no filtering is done.

  // TODO(rossberg): What if only a prototype is a proxy? Not specified yet.

  __ Cmp(rdx, Smi::FromInt(0));

  __ j(equal, &update_each, Label::kNear);

  // Convert the entry to a string or null if it isn't a property

  // anymore. If the property has been removed while iterating, we

  // just skip it.

  __ push(rcx);  // Enumerable.

  __ push(rbx);  // Current entry.

  __ InvokeBuiltin(Builtins::FILTER_KEY, CALL_FUNCTION);

  __ Cmp(rax, Smi::FromInt(0));

  __ j(equal, loop_statement.continue_label());

  __ movq(rbx, rax);

  // Update the 'each' property or variable from the possibly filtered

  // entry in register rbx.

  __ bind(&update_each);

  __ movq(result_register(), rbx);

  // Perform the assignment as if via '='.

  { EffectContext context(this);

    EmitAssignment(stmt->each());

  }

  // Generate code for the body of the loop.

  Visit(stmt->body());

  // Generate code for going to the next element by incrementing the

  // index (smi) stored on top of the stack.

  __ bind(loop_statement.continue_label());

  __ SmiAddConstant(Operand(rsp, 0 * kPointerSize), Smi::FromInt(1));

  EmitBackEdgeBookkeeping(stmt, &loop);

  __ jmp(&loop);

  // Remove the pointers stored on the stack.

  __ bind(loop_statement.break_label());

  __ addq(rsp, Immediate(5 * kPointerSize));

  // Exit and decrement the loop depth.

  PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);

  __ bind(&exit);

  decrement_loop_depth();

}

void FullCodeGenerator::VisitForOfStatement(ForOfStatement* stmt) {

  Comment cmnt(masm_, "[ ForOfStatement");

  SetStatementPosition(stmt);

  Iteration loop_statement(this, stmt);

  increment_loop_depth();

  // var iterator = iterable[@@iterator]()

  VisitForAccumulatorValue(stmt->assign_iterator());

  // As with for-in, skip the loop if the iterator is null or undefined.

  __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);

  __ j(equal, loop_statement.break_label());

  __ CompareRoot(rax, Heap::kNullValueRootIndex);

  __ j(equal, loop_statement.break_label());

  // Convert the iterator to a JS object.

  Label convert, done_convert;

  __ JumpIfSmi(rax, &convert);

  __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);

  __ j(above_equal, &done_convert);

  __ bind(&convert);

  __ push(rax);

  __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);

  __ bind(&done_convert);

  // Loop entry.

  __ bind(loop_statement.continue_label());

  // result = iterator.next()

  VisitForEffect(stmt->next_result());

  // if (result.done) break;

  Label result_not_done;

  VisitForControl(stmt->result_done(),

                  loop_statement.break_label(),

                  &result_not_done,

                  &result_not_done);

  __ bind(&result_not_done);

  // each = result.value

  VisitForEffect(stmt->assign_each());

  // Generate code for the body of the loop.

  Visit(stmt->body());

  // Check stack before looping.

  PrepareForBailoutForId(stmt->BackEdgeId(), NO_REGISTERS);

  EmitBackEdgeBookkeeping(stmt, loop_statement.continue_label());

  __ jmp(loop_statement.continue_label());

  // Exit and decrement the loop depth.

  PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);

  __ bind(loop_statement.break_label());

  decrement_loop_depth();

}

void FullCodeGenerator::EmitNewClosure(Handle<SharedFunctionInfo> info,

                                       bool pretenure) {

  // Use the fast case closure allocation code that allocates in new

  // space for nested functions that don't need literals cloning. If

  // we're running with the --always-opt or the --prepare-always-opt

  // flag, we need to use the runtime function so that the new function

  // we are creating here gets a chance to have its code optimized and

  // doesn't just get a copy of the existing unoptimized code.

  if (!FLAG_always_opt &&

      !FLAG_prepare_always_opt &&

      !pretenure &&

      scope()->is_function_scope() &&

      info->num_literals() == 0) {

    FastNewClosureStub stub(info->language_mode(), info->is_generator());

    __ Move(rbx, info);

    __ CallStub(&stub);

  } else {

    __ push(rsi);

    __ Push(info);

    __ Push(pretenure

            ? isolate()->factory()->true_value()

            : isolate()->factory()->false_value());

    __ CallRuntime(Runtime::kNewClosure, 3);

  }

  context()->Plug(rax);

}

void FullCodeGenerator::VisitVariableProxy(VariableProxy* expr) {

  Comment cmnt(masm_, "[ VariableProxy");

  EmitVariableLoad(expr);

}

void FullCodeGenerator::EmitLoadGlobalCheckExtensions(Variable* var,

                                                      TypeofState typeof_state,

                                                      Label* slow) {

  Register context = rsi;

  Register temp = rdx;

  Scope* s = scope();

  while (s != NULL) {

    if (s->num_heap_slots() > 0) {

      if (s->calls_non_strict_eval()) {

        // Check that extension is NULL.

        __ cmpq(ContextOperand(context, Context::EXTENSION_INDEX),

                Immediate(0));

        __ j(not_equal, slow);

      }

      // Load next context in chain.

      __ movq(temp, ContextOperand(context, Context::PREVIOUS_INDEX));

      // Walk the rest of the chain without clobbering rsi.

      context = temp;

    }

    // If no outer scope calls eval, we do not need to check more

    // context extensions.  If we have reached an eval scope, we check

    // all extensions from this point.

    if (!s->outer_scope_calls_non_strict_eval() || s->is_eval_scope()) break;

    s = s->outer_scope();

  }

  if (s != NULL && s->is_eval_scope()) {

    // Loop up the context chain.  There is no frame effect so it is

    // safe to use raw labels here.

    Label next, fast;

    if (!context.is(temp)) {

      __ movq(temp, context);

    }

    // Load map for comparison into register, outside loop.

    __ LoadRoot(kScratchRegister, Heap::kNativeContextMapRootIndex);

    __ bind(&next);

    // Terminate at native context.

    __ cmpq(kScratchRegister, FieldOperand(temp, HeapObject::kMapOffset));

    __ j(equal, &fast, Label::kNear);

    // Check that extension is NULL.

    __ cmpq(ContextOperand(temp, Context::EXTENSION_INDEX), Immediate(0));

    __ j(not_equal, slow);

    // Load next context in chain.

    __ movq(temp, ContextOperand(temp, Context::PREVIOUS_INDEX));

    __ jmp(&next);

    __ bind(&fast);

  }

  // All extension objects were empty and it is safe to use a global

  // load IC call.

  __ movq(rax, GlobalObjectOperand());

  __ Move(rcx, var->name());

  Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();

  RelocInfo::Mode mode = (typeof_state == INSIDE_TYPEOF)

      ? RelocInfo::CODE_TARGET

      : RelocInfo::CODE_TARGET_CONTEXT;

  CallIC(ic, mode);

}

MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var,

                                                                Label* slow) {

  ASSERT(var->IsContextSlot());

  Register context = rsi;

  Register temp = rbx;

  for (Scope* s = scope(); s != var->scope(); s = s->outer_scope()) {

    if (s->num_heap_slots() > 0) {

      if (s->calls_non_strict_eval()) {

        // Check that extension is NULL.

        __ cmpq(ContextOperand(context, Context::EXTENSION_INDEX),

                Immediate(0));

        __ j(not_equal, slow);

      }

      __ movq(temp, ContextOperand(context, Context::PREVIOUS_INDEX));

      // Walk the rest of the chain without clobbering rsi.

      context = temp;

    }

  }

  // Check that last extension is NULL.

  __ cmpq(ContextOperand(context, Context::EXTENSION_INDEX), Immediate(0));

  __ j(not_equal, slow);

  // This function is used only for loads, not stores, so it's safe to

  // return an rsi-based operand (the write barrier cannot be allowed to

  // destroy the rsi register).

  return ContextOperand(context, var->index());

}

void FullCodeGenerator::EmitDynamicLookupFastCase(Variable* var,

                                                  TypeofState typeof_state,

                                                  Label* slow,

                                                  Label* done) {

  // Generate fast-case code for variables that might be shadowed by

  // eval-introduced variables.  Eval is used a lot without

  // introducing variables.  In those cases, we do not want to

  // perform a runtime call for all variables in the scope

  // containing the eval.

  if (var->mode() == DYNAMIC_GLOBAL) {

    EmitLoadGlobalCheckExtensions(var, typeof_state, slow);

    __ jmp(done);

  } else if (var->mode() == DYNAMIC_LOCAL) {

    Variable* local = var->local_if_not_shadowed();

    __ movq(rax, ContextSlotOperandCheckExtensions(local, slow));

    if (local->mode() == LET ||

        local->mode() == CONST ||

        local->mode() == CONST_HARMONY) {

      __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);

      __ j(not_equal, done);

      if (local->mode() == CONST) {

        __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);

      } else {  // LET || CONST_HARMONY

        __ Push(var->name());

        __ CallRuntime(Runtime::kThrowReferenceError, 1);

      }

    }

    __ jmp(done);

  }

}

void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy) {

  // Record position before possible IC call.