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_ARM

#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"

#include "arm/code-stubs-arm.h"

#include "arm/macro-assembler-arm.h"

namespace v8 {

namespace internal {

#define __ ACCESS_MASM(masm_)

// A patch site is a location in the code which it is possible to patch. This

// class has a number of methods to emit the code which is patchable and the

// method EmitPatchInfo to record a marker back to the patchable code. This

// marker is a cmp rx, #yyy instruction, and x * 0x00000fff + yyy (raw 12 bit

// immediate value is used) is the delta from the pc to the first instruction of

// the patchable code.

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

  }

  // When initially emitting this ensure that a jump is always generated to skip

  // the inlined smi code.

  void EmitJumpIfNotSmi(Register reg, Label* target) {

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

    Assembler::BlockConstPoolScope block_const_pool(masm_);

    __ bind(&patch_site_);

    __ cmp(reg, Operand(reg));

    __ b(eq, target);  // Always taken before patched.

  }

  // When initially emitting this ensure that a jump is never generated to skip

  // the inlined smi code.

  void EmitJumpIfSmi(Register reg, Label* target) {

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

    Assembler::BlockConstPoolScope block_const_pool(masm_);

    __ bind(&patch_site_);

    __ cmp(reg, Operand(reg));

    __ b(ne, target);  // Never taken before patched.

  }

  void EmitPatchInfo() {

    // Block literal pool emission whilst recording patch site information.

    Assembler::BlockConstPoolScope block_const_pool(masm_);

    if (patch_site_.is_bound()) {

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

      Register reg;

      reg.set_code(delta_to_patch_site / kOff12Mask);

      __ cmp_raw_immediate(reg, delta_to_patch_site % kOff12Mask);

#ifdef DEBUG

      info_emitted_ = true;

#endif

    } else {

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

    }

  }

 private:

  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.  The actual

// argument count matches the formal parameter count expected by the

// function.

//

// The live registers are:

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

//   o cp: our context

//   o fp: our caller's frame pointer

//   o sp: stack pointer

//   o lr: return address

//

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

// frames-arm.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))) {

    __ stop("stop-at");

  }

#endif

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

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

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

  // function calls.

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

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

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

    __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);

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

  }

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

      __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);

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

        __ push(ip);

      }

    }

  }

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

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

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

    __ push(r1);

    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 r0 and cp.  It replaces the context

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

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

    // Copy any necessary parameters into the context.

    int num_parameters = 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.

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

        // Store it in the context.

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

        __ str(r0, target);

        // Update the write barrier.

        __ RecordWriteContextSlot(

            cp, target.offset(), r0, r3, kLRHasBeenSaved, kDontSaveFPRegs);

      }

    }

  }

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

  if (arguments != NULL) {

    // Function uses arguments object.

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

    if (!function_in_register) {

      // Load this again, if it's used by the local context below.

      __ ldr(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));

    } else {

      __ mov(r3, r1);

    }

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

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

    int offset = num_parameters * kPointerSize;

    __ add(r2, fp,

           Operand(StandardFrameConstants::kCallerSPOffset + offset));

    __ mov(r1, Operand(Smi::FromInt(num_parameters)));

    __ Push(r3, r2, r1);

    // Arguments to ArgumentsAccessStub:

    //   function, receiver address, parameter count.

    // The stub will rewrite receiever 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, r0, r1, r2);

  }

  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;

      __ LoadRoot(ip, Heap::kStackLimitRootIndex);

      __ cmp(sp, Operand(ip));

      __ b(hs, &ok);

      PredictableCodeSizeScope predictable(masm_, 2 * Assembler::kInstrSize);

      __ 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(r0, Heap::kUndefinedValueRootIndex);

  }

  EmitReturnSequence();

  // Force emit the constant pool, so it doesn't get emitted in the middle

  // of the back edge table.

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

}

void FullCodeGenerator::ClearAccumulator() {

  __ mov(r0, Operand(Smi::FromInt(0)));

}

void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {

  __ mov(r2, Operand(profiling_counter_));

  __ ldr(r3, FieldMemOperand(r2, Cell::kValueOffset));

  __ sub(r3, r3, Operand(Smi::FromInt(delta)), SetCC);

  __ str(r3, FieldMemOperand(r2, Cell::kValueOffset));

}

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;

  }

  if (isolate()->IsDebuggerActive()) {

    // Detect debug break requests as soon as possible.

    reset_value = FLAG_interrupt_budget >> 4;

  }

  __ mov(r2, Operand(profiling_counter_));

  __ mov(r3, Operand(Smi::FromInt(reset_value)));

  __ str(r3, FieldMemOperand(r2, Cell::kValueOffset));

}

void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,

                                                Label* back_edge_target) {

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

  // Block literal pools whilst emitting back edge code.

  Assembler::BlockConstPoolScope block_const_pool(masm_);

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

  __ b(pl, &ok);

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

    __ b(&return_label_);

  } else {

    __ bind(&return_label_);

    if (FLAG_trace) {

      // Push the return value on the stack as the parameter.

      // Runtime::TraceExit returns its parameter in r0.

      __ push(r0);

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

      __ b(pl, &ok);

      __ push(r0);

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

        __ ldr(r2, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));

        __ push(r2);

        __ CallRuntime(Runtime::kOptimizeFunctionOnNextCall, 1);

      } else {

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

                RelocInfo::CODE_TARGET);

      }

      __ pop(r0);

      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

    // Make sure that the constant pool is not emitted inside of the return

    // sequence.

    { Assembler::BlockConstPoolScope block_const_pool(masm_);

      // Here we use masm_-> instead of the __ macro to avoid the code coverage

      // tool from instrumenting as we rely on the code size here.

      int32_t sp_delta = (info_->scope()->num_parameters() + 1) * kPointerSize;

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

      // TODO(svenpanne) The code below is sometimes 4 words, sometimes 5!

      PredictableCodeSizeScope predictable(masm_, -1);

      __ RecordJSReturn();

      masm_->mov(sp, fp);

      int no_frame_start = masm_->pc_offset();

      masm_->ldm(ia_w, sp, fp.bit() | lr.bit());

      masm_->add(sp, sp, Operand(sp_delta));

      masm_->Jump(lr);

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

    }

#ifdef DEBUG

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

    // for the debugger's requirements.

    ASSERT(Assembler::kJSReturnSequenceInstructions <=

           masm_->InstructionsGeneratedSince(&check_exit_codesize));

#endif

  }

}

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

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

  __ push(result_register());

}

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

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

  // For simplicity we always test the accumulator register.

  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 {

  __ LoadRoot(result_register(), index);

  __ push(result_register());

}

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

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

    if (true_label_ != fall_through_) __ b(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 {

  __ mov(result_register(), Operand(lit));

}

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

  // Immediates cannot be pushed directly.

  __ mov(result_register(), Operand(lit));

  __ push(result_register());

}

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

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

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

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

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

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

    } else {

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

    }

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

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

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

    } else {

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

    }

  } else {

    // For simplicity we always test the accumulator register.

    __ mov(result_register(), Operand(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);

  __ str(reg, MemOperand(sp, 0));

}

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

  __ LoadRoot(result_register(), Heap::kTrueValueRootIndex);

  __ jmp(&done);

  __ bind(materialize_false);

  __ LoadRoot(result_register(), Heap::kFalseValueRootIndex);

  __ bind(&done);

}

void FullCodeGenerator::StackValueContext::Plug(

    Label* materialize_true,

    Label* materialize_false) const {

  Label done;

  __ bind(materialize_true);

  __ LoadRoot(ip, Heap::kTrueValueRootIndex);

  __ push(ip);

  __ jmp(&done);

  __ bind(materialize_false);

  __ LoadRoot(ip, Heap::kFalseValueRootIndex);

  __ push(ip);

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

  __ LoadRoot(ip, value_root_index);

  __ push(ip);

}

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

  codegen()->PrepareForBailoutBeforeSplit(condition(),

                                          true,

                                          true_label_,

                                          false_label_);

  if (flag) {

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

  } else {

    if (false_label_ != fall_through_) __ b(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());

  __ tst(result_register(), result_register());

  Split(ne, if_true, if_false, fall_through);

}

void FullCodeGenerator::Split(Condition cond,

                              Label* if_true,

                              Label* if_false,

                              Label* fall_through) {

  if (if_false == fall_through) {

    __ b(cond, if_true);

  } else if (if_true == fall_through) {

    __ b(NegateCondition(cond), if_false);

  } else {

    __ b(cond, if_true);

    __ b(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 += (info_->scope()->num_parameters() + 1) * kPointerSize;

  } else {

    offset += JavaScriptFrameConstants::kLocal0Offset;

  }

  return MemOperand(fp, 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) {

  // Use destination as scratch.

  MemOperand location = VarOperand(var, dest);

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

  __ str(src, location);

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

  if (var->IsContextSlot()) {

    __ RecordWriteContextSlot(scratch0,

                              location.offset(),

                              src,

                              scratch1,

                              kLRHasBeenSaved,

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

  PrepareForBailout(expr, TOS_REG);

  if (should_normalize) {

    __ LoadRoot(ip, Heap::kTrueValueRootIndex);

    __ cmp(r0, ip);

    Split(eq, if_true, if_false, NULL);

    __ bind(&skip);

  }

}

void FullCodeGenerator::EmitDebugCheckDeclarationContext(Variable* variable) {

  // The variable in the declaration always resides in the current function

  // context.

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

  if (generate_debug_code_) {

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

    __ ldr(r1, FieldMemOperand(cp, HeapObject::kMapOffset));

    __ CompareRoot(r1, Heap::kWithContextMapRootIndex);

    __ Check(ne, kDeclarationInWithContext);

    __ CompareRoot(r1, Heap::kCatchContextMapRootIndex);

    __ Check(ne, 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(ip, Heap::kTheHoleValueRootIndex);

        __ str(ip, StackOperand(variable));

      }

      break;

    case Variable::CONTEXT:

      if (hole_init) {

        Comment cmnt(masm_, "[ VariableDeclaration");

        EmitDebugCheckDeclarationContext(variable);

        __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

        __ str(ip, ContextOperand(cp, variable->index()));

        // No write barrier since the_hole_value is in old space.

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

      }

      break;

    case Variable::LOOKUP: {

      Comment cmnt(masm_, "[ VariableDeclaration");

      __ mov(r2, Operand(variable->name()));

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

      ASSERT(IsDeclaredVariableMode(mode));

      PropertyAttributes attr =

          IsImmutableVariableMode(mode) ? READ_ONLY : NONE;

      __ mov(r1, Operand(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) {

        __ LoadRoot(r0, Heap::kTheHoleValueRootIndex);

        __ Push(cp, r2, r1, r0);

      } else {

        __ mov(r0, Operand(Smi::FromInt(0)));  // Indicates no initial value.

        __ Push(cp, r2, r1, r0);

      }

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

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

      break;

    }

    case Variable::CONTEXT: {

      Comment cmnt(masm_, "[ FunctionDeclaration");

      EmitDebugCheckDeclarationContext(variable);

      VisitForAccumulatorValue(declaration->fun());

      __ str(result_register(), ContextOperand(cp, variable->index()));

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

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

      __ RecordWriteContextSlot(cp,

                                offset,

                                result_register(),

                                r2,

                                kLRHasBeenSaved,

                                kDontSaveFPRegs,

                                EMIT_REMEMBERED_SET,

                                OMIT_SMI_CHECK);

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

      break;

    }

    case Variable::LOOKUP: {

      Comment cmnt(masm_, "[ FunctionDeclaration");

      __ mov(r2, Operand(variable->name()));

      __ mov(r1, Operand(Smi::FromInt(NONE)));

      __ Push(cp, r2, r1);

      // Push initial value for function declaration.

      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(r1, scope_->ContextChainLength(scope_->GlobalScope()));

  __ ldr(r1, ContextOperand(r1, variable->interface()->Index()));

  __ ldr(r1, ContextOperand(r1, Context::EXTENSION_INDEX));

  // Assign it.

  __ str(r1, ContextOperand(cp, variable->index()));

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

  __ RecordWriteContextSlot(cp,

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

                            r1,

                            r3,

                            kLRHasBeenSaved,

                            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.

  // The context is the first argument.

  __ mov(r1, Operand(pairs));

  __ mov(r0, Operand(Smi::FromInt(DeclareGlobalsFlags())));

  __ Push(cp, r1, r0);

  __ 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 '==='.

    __ ldr(r1, MemOperand(sp, 0));  // Switch value.

    bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);

    JumpPatchSite patch_site(masm_);

    if (inline_smi_code) {

      Label slow_case;

      __ orr(r2, r1, r0);

      patch_site.EmitJumpIfNotSmi(r2, &slow_case);

      __ cmp(r1, r0);

      __ b(ne, &next_test);

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

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

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

    __ b(ne, &next_test);

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

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

    __ b(nested_statement.break_label());

  } else {

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

  __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);

  __ cmp(r0, ip);

  __ b(eq, &exit);

  Register null_value = r5;

  __ LoadRoot(null_value, Heap::kNullValueRootIndex);

  __ cmp(r0, null_value);

  __ b(eq, &exit);

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

  // Convert the object to a JS object.

  Label convert, done_convert;

  __ JumpIfSmi(r0, &convert);

  __ CompareObjectType(r0, r1, r1, FIRST_SPEC_OBJECT_TYPE);

  __ b(ge, &done_convert);

  __ bind(&convert);

  __ push(r0);

  __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);

  __ bind(&done_convert);

  __ push(r0);

  // Check for proxies.

  Label call_runtime;

  STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);

  __ CompareObjectType(r0, r1, r1, LAST_JS_PROXY_TYPE);

  __ b(le, &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;

  __ ldr(r0, FieldMemOperand(r0, HeapObject::kMapOffset));

  __ b(&use_cache);

  // Get the set of properties to enumerate.

  __ bind(&call_runtime);

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

  __ ldr(r2, FieldMemOperand(r0, HeapObject::kMapOffset));

  __ LoadRoot(ip, Heap::kMetaMapRootIndex);

  __ cmp(r2, ip);

  __ b(ne, &fixed_array);

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

  Label no_descriptors;

  __ bind(&use_cache);

  __ EnumLength(r1, r0);

  __ cmp(r1, Operand(Smi::FromInt(0)));

  __ b(eq, &no_descriptors);

  __ LoadInstanceDescriptors(r0, r2);

  __ ldr(r2, FieldMemOperand(r2, DescriptorArray::kEnumCacheOffset));

  __ ldr(r2, FieldMemOperand(r2, DescriptorArray::kEnumCacheBridgeCacheOffset));

  // Set up the four remaining stack slots.

  __ push(r0);  // Map.

  __ mov(r0, Operand(Smi::FromInt(0)));

  // Push enumeration cache, enumeration cache length (as smi) and zero.

  __ Push(r2, r1, r0);

  __ jmp(&loop);

  __ bind(&no_descriptors);

  __ Drop(1);

  __ jmp(&exit);

  // We got a fixed array in register r0. 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(r1, cell);

  __ mov(r2, Operand(Smi::FromInt(TypeFeedbackCells::kForInSlowCaseMarker)));

  __ str(r2, FieldMemOperand(r1, Cell::kValueOffset));

  __ mov(r1, Operand(Smi::FromInt(1)));  // Smi indicates slow check

  __ ldr(r2, MemOperand(sp, 0 * kPointerSize));  // Get enumerated object

  STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);

  __ CompareObjectType(r2, r3, r3, LAST_JS_PROXY_TYPE);

  __ b(gt, &non_proxy);

  __ mov(r1, Operand(Smi::FromInt(0)));  // Zero indicates proxy

  __ bind(&non_proxy);

  __ Push(r1, r0);  // Smi and array

  __ ldr(r1, FieldMemOperand(r0, FixedArray::kLengthOffset));

  __ mov(r0, Operand(Smi::FromInt(0)));

  __ Push(r1, r0);  // Fixed array length (as smi) and initial index.

  // Generate code for doing the condition check.

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

  __ bind(&loop);

  // Load the current count to r0, load the length to r1.

  __ Ldrd(r0, r1, MemOperand(sp, 0 * kPointerSize));

  __ cmp(r0, r1);  // Compare to the array length.

  __ b(hs, loop_statement.break_label());

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

  __ ldr(r2, MemOperand(sp, 2 * kPointerSize));

  __ add(r2, r2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));

  __ ldr(r3, MemOperand::PointerAddressFromSmiKey(r2, r0));

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

  // permanent slow case into register r2.

  __ ldr(r2, MemOperand(sp, 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;

  __ ldr(r1, MemOperand(sp, 4 * kPointerSize));

  __ ldr(r4, FieldMemOperand(r1, HeapObject::kMapOffset));

  __ cmp(r4, Operand(r2));

  __ b(eq, &update_each);

  // For proxies, no filtering is done.

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

  __ cmp(r2, Operand(Smi::FromInt(0)));

  __ b(eq, &update_each);

  // Convert the entry to a string or (smi) 0 if it isn't a property

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

  // just skip it.

  __ push(r1);  // Enumerable.

  __ push(r3);  // Current entry.

  __ InvokeBuiltin(Builtins::FILTER_KEY, CALL_FUNCTION);

  __ mov(r3, Operand(r0), SetCC);

  __ b(eq, loop_statement.continue_label());

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

  // entry in register r3.

  __ bind(&update_each);

  __ mov(result_register(), r3);

  // 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 the going to the next element by incrementing

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

  __ bind(loop_statement.continue_label());

  __ pop(r0);

  __ add(r0, r0, Operand(Smi::FromInt(1)));

  __ push(r0);

  EmitBackEdgeBookkeeping(stmt, &loop);

  __ b(&loop);

  // Remove the pointers stored on the stack.

  __ bind(loop_statement.break_label());

  __ Drop(5);

  // 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(r0, Heap::kUndefinedValueRootIndex);

  __ b(eq, loop_statement.break_label());

  __ CompareRoot(r0, Heap::kNullValueRootIndex);

  __ b(eq, loop_statement.break_label());

  // Convert the iterator to a JS object.

  Label convert, done_convert;

  __ JumpIfSmi(r0, &convert);

  __ CompareObjectType(r0, r1, r1, FIRST_SPEC_OBJECT_TYPE);

  __ b(ge, &done_convert);

  __ bind(&convert);

  __ push(r0);

  __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);

  __ bind(&done_convert);

  __ push(r0);

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

    __ mov(r2, Operand(info));

    __ CallStub(&stub);

  } else {

    __ mov(r0, Operand(info));

    __ LoadRoot(r1, pretenure ? Heap::kTrueValueRootIndex

                              : Heap::kFalseValueRootIndex);

    __ Push(cp, r0, r1);

    __ CallRuntime(Runtime::kNewClosure, 3);

  }

  context()->Plug(r0);

}

void FullCodeGenerator::VisitVariableProxy(VariableProxy* expr) {

  Comment cmnt(masm_, "[ VariableProxy");

  EmitVariableLoad(expr);

}

void FullCodeGenerator::EmitLoadGlobalCheckExtensions(Variable* var,

                                                      TypeofState typeof_state,

                                                      Label* slow) {

  Register current = cp;

  Register next = r1;

  Register temp = r2;

  Scope* s = scope();

  while (s != NULL) {

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

      if (s->calls_non_strict_eval()) {

        // Check that extension is NULL.

        __ ldr(temp, ContextOperand(current, Context::EXTENSION_INDEX));

        __ tst(temp, temp);

        __ b(ne, slow);

      }

      // Load next context in chain.

      __ ldr(next, ContextOperand(current, Context::PREVIOUS_INDEX));

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

      current = next;

    }

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

    // context extensions.

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

    s = s->outer_scope();

  }

  if (s->is_eval_scope()) {

    Label loop, fast;

    if (!current.is(next)) {

      __ Move(next, current);

    }

    __ bind(&loop);

    // Terminate at native context.

    __ ldr(temp, FieldMemOperand(next, HeapObject::kMapOffset));

    __ LoadRoot(ip, Heap::kNativeContextMapRootIndex);

    __ cmp(temp, ip);

    __ b(eq, &fast);

    // Check that extension is NULL.

    __ ldr(temp, ContextOperand(next, Context::EXTENSION_INDEX));

    __ tst(temp, temp);

    __ b(ne, slow);

    // Load next context in chain.

    __ ldr(next, ContextOperand(next, Context::PREVIOUS_INDEX));

    __ b(&loop);

    __ bind(&fast);

  }

  __ ldr(r0, GlobalObjectOperand());

  __ mov(r2, Operand(var->name()));

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

      ? RelocInfo::CODE_TARGET

      : RelocInfo::CODE_TARGET_CONTEXT;

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

  CallIC(ic, mode);

}

MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var,

                                                                Label* slow) {

  ASSERT(var->IsContextSlot());

  Register context = cp;

  Register next = r3;

  Register temp = r4;

  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.

        __ ldr(temp, ContextOperand(context, Context::EXTENSION_INDEX));

        __ tst(temp, temp);

        __ b(ne, slow);

      }

      __ ldr(next, ContextOperand(context, Context::PREVIOUS_INDEX));

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

      context = next;

    }

  }

  // Check that last extension is NULL.

  __ ldr(temp, ContextOperand(context, Context::EXTENSION_INDEX));

  __ tst(temp, temp);

  __ b(ne, slow);

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

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

  // destroy the cp 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.