Initial (stub) port of jump targets to the ARM platform....

src/codegen-arm.cc

 // Copyright 2006-2008 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
@@ skipping 46 matching lines @@
       typeof_state_(NOT_INSIDE_TYPEOF),
       true_target_(NULL),
       false_target_(NULL),
       previous_(NULL) {
   owner_->set_state(this);
 }
 
 
 CodeGenState::CodeGenState(CodeGenerator* owner,
                            TypeofState typeof_state,
-                           Label* true_target,
-                           Label* false_target)
+                           JumpTarget* true_target,
+                           JumpTarget* false_target)
     : owner_(owner),
       typeof_state_(typeof_state),
       true_target_(true_target),
       false_target_(false_target),
       previous_(owner->state()) {
   owner_->set_state(this);
 }
 
 
 CodeGenState::~CodeGenState() {
@@ skipping 30 matching lines @@
 void CodeGenerator::GenCode(FunctionLiteral* fun) {
   ZoneList<Statement*>* body = fun->body();
 
   // Initialize state.
   ASSERT(scope_ == NULL);
   scope_ = fun->scope();
   ASSERT(frame_ == NULL);
   VirtualFrame virtual_frame(this);
   frame_ = &virtual_frame;
   cc_reg_ = al;
+  function_return_.set_code_generator(this);
   {
     CodeGenState state(this);
 
     // Entry
     // stack: function, receiver, arguments, return address
     // r0: number of arguments
     // sp: stack pointer
     // fp: frame pointer
     // pp: caller's parameter pointer
     // cp: callee's context
@@ skipping 136 matching lines @@
   }
 
   // exit
   // r0: result
   // sp: stack pointer
   // fp: frame pointer
   // pp: parameter pointer
   // cp: callee's context
   __ mov(r0, Operand(Factory::undefined_value()));
 
-  __ bind(&function_return_);
+  function_return_.Bind();
   if (FLAG_trace) {
     // Push the return value on the stack as the parameter.
     // Runtime::TraceExit returns the parameter as it is.
     __ push(r0);
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
 
   // Tear down the frame which will restore the caller's frame pointer and the
   // link register.
   ExitJSFrame();
@@ skipping 59 matching lines @@
   }
 }
 
 
 // Loads a value on the stack. If it is a boolean value, the result may have
 // been (partially) translated into branches, or it may have set the condition
 // code register. If force_cc is set, the value is forced to set the condition
 // code register and no value is pushed. If the condition code register was set,
 // has_cc() is true and cc_reg_ contains the condition to test for 'true'.
 void CodeGenerator::LoadCondition(Expression* x,
-                                     TypeofState typeof_state,
-                                     Label* true_target,
-                                     Label* false_target,
-                                     bool force_cc) {
+                                  TypeofState typeof_state,
+                                  JumpTarget* true_target,
+                                  JumpTarget* false_target,
+                                  bool force_cc) {
   ASSERT(!has_cc());
 
   { CodeGenState new_state(this, typeof_state, true_target, false_target);
     Visit(x);
   }
   if (force_cc && !has_cc()) {
     // Convert the TOS value to a boolean in the condition code register.
     ToBoolean(true_target, false_target);
   }
   ASSERT(has_cc() || !force_cc);
 }
 
 
 void CodeGenerator::Load(Expression* x, TypeofState typeof_state) {
-  Label true_target;
-  Label false_target;
+  JumpTarget true_target(this);
+  JumpTarget false_target(this);
   LoadCondition(x, typeof_state, &true_target, &false_target, false);
 
   if (has_cc()) {
     // convert cc_reg_ into a bool
     Label loaded, materialize_true;
     __ b(cc_reg_, &materialize_true);
     __ mov(r0, Operand(Factory::false_value()));
     __ push(r0);
     __ b(&loaded);
     __ bind(&materialize_true);
     __ mov(r0, Operand(Factory::true_value()));
     __ push(r0);
     __ bind(&loaded);
     cc_reg_ = al;
   }
 
   if (true_target.is_linked() || false_target.is_linked()) {
     // we have at least one condition value
     // that has been "translated" into a branch,
     // thus it needs to be loaded explicitly again
     Label loaded;
     __ b(&loaded);  // don't lose current TOS
     bool both = true_target.is_linked() && false_target.is_linked();
     // reincarnate "true", if necessary
     if (true_target.is_linked()) {
-      __ bind(&true_target);
+      true_target.Bind();
       __ mov(r0, Operand(Factory::true_value()));
       __ push(r0);
     }
     // if both "true" and "false" need to be reincarnated,
     // jump across code for "false"
     if (both)
       __ b(&loaded);
     // reincarnate "false", if necessary
     if (false_target.is_linked()) {
-      __ bind(&false_target);
+      false_target.Bind();
       __ mov(r0, Operand(Factory::false_value()));
       __ push(r0);
     }
     // everything is loaded at this point
     __ bind(&loaded);
   }
   ASSERT(!has_cc());
 }
 
 
@@ skipping 95 matching lines @@
     __ pop(r0);
     __ add(sp, sp, Operand(size * kPointerSize));
     __ push(r0);
   }
 }
 
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Convert the given
 // register to a boolean in the condition code register. The code
 // may jump to 'false_target' in case the register converts to 'false'.
-void CodeGenerator::ToBoolean(Label* true_target,
-                                 Label* false_target) {
+void CodeGenerator::ToBoolean(JumpTarget* true_target,
+                              JumpTarget* false_target) {
   // Note: The generated code snippet does not change stack variables.
   //       Only the condition code should be set.
   __ pop(r0);
 
   // Fast case checks
 
   // Check if the value is 'false'.
   __ cmp(r0, Operand(Factory::false_value()));
-  __ b(eq, false_target);
+  false_target->Branch(eq);
 
   // Check if the value is 'true'.
   __ cmp(r0, Operand(Factory::true_value()));
-  __ b(eq, true_target);
+  true_target->Branch(eq);
 
   // Check if the value is 'undefined'.
   __ cmp(r0, Operand(Factory::undefined_value()));
-  __ b(eq, false_target);
+  false_target->Branch(eq);
 
   // Check if the value is a smi.
   __ cmp(r0, Operand(Smi::FromInt(0)));
-  __ b(eq, false_target);
+  false_target->Branch(eq);
   __ tst(r0, Operand(kSmiTagMask));
-  __ b(eq, true_target);
+  true_target->Branch(eq);
 
   // Slow case: call the runtime.
   __ push(r0);
   __ CallRuntime(Runtime::kToBool, 1);
 
   // Convert result (r0) to condition code
   __ cmp(r0, Operand(Factory::false_value()));
 
   cc_reg_ = ne;
 }
@@ skipping 431 matching lines @@
   // Use the shared code stub to call the function.
   CallFunctionStub call_function(args->length());
   __ CallStub(&call_function);
 
   // Restore context and pop function from the stack.
   __ ldr(cp, frame_->Context());
   __ pop();  // discard the TOS
 }
 
 
-void CodeGenerator::Branch(bool if_true, Label* L) {
+void CodeGenerator::Branch(bool if_true, JumpTarget* target) {
   ASSERT(has_cc());
   Condition cc = if_true ? cc_reg_ : NegateCondition(cc_reg_);
-  __ b(cc, L);
+  target->Branch(cc);
   cc_reg_ = al;
 }
 
 
 void CodeGenerator::CheckStack() {
   if (FLAG_check_stack) {
     Comment cmnt(masm_, "[ check stack");
     StackCheckStub stub;
     __ CallStub(&stub);
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
   Comment cmnt(masm_, "[ Block");
   if (FLAG_debug_info) RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
+  node->break_target()->set_code_generator(this);
   VisitStatements(node->statements());
-  __ bind(node->break_target());
+  node->break_target()->Bind();
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   __ mov(r0, Operand(pairs));
   __ push(r0);
   __ push(cp);
   __ mov(r0, Operand(Smi::FromInt(is_eval() ? 1 : 0)));
   __ push(r0);
   __ CallRuntime(Runtime::kDeclareGlobals, 3);
@@ skipping 84 matching lines @@
 
 void CodeGenerator::VisitIfStatement(IfStatement* node) {
   Comment cmnt(masm_, "[ IfStatement");
   // Generate different code depending on which
   // parts of the if statement are present or not.
   bool has_then_stm = node->HasThenStatement();
   bool has_else_stm = node->HasElseStatement();
 
   if (FLAG_debug_info) RecordStatementPosition(node);
 
-  Label exit;
+  JumpTarget exit(this);
   if (has_then_stm && has_else_stm) {
     Comment cmnt(masm_, "[ IfThenElse");
-    Label then;
-    Label else_;
+    JumpTarget then(this);
+    JumpTarget else_(this);
     // if (cond)
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
     Branch(false, &else_);
     // then
-    __ bind(&then);
+    then.Bind();
     Visit(node->then_statement());
-    __ b(&exit);
+    exit.Jump();
     // else
-    __ bind(&else_);
+    else_.Bind();
     Visit(node->else_statement());
 
   } else if (has_then_stm) {
     Comment cmnt(masm_, "[ IfThen");
     ASSERT(!has_else_stm);
-    Label then;
+    JumpTarget then(this);
     // if (cond)
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &exit, true);
     Branch(false, &exit);
     // then
-    __ bind(&then);
+    then.Bind();
     Visit(node->then_statement());
 
   } else if (has_else_stm) {
     Comment cmnt(masm_, "[ IfElse");
     ASSERT(!has_then_stm);
-    Label else_;
+    JumpTarget else_(this);
     // if (!cond)
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &exit, &else_, true);
     Branch(true, &exit);
     // else
-    __ bind(&else_);
+    else_.Bind();
     Visit(node->else_statement());
 
   } else {
     Comment cmnt(masm_, "[ If");
     ASSERT(!has_then_stm && !has_else_stm);
     // if (cond)
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &exit, &exit, false);
     if (has_cc()) {
       cc_reg_ = al;
     } else {
       __ pop(r0);  // __ Pop(no_reg)
     }
   }
 
   // end
-  __ bind(&exit);
+  exit.Bind();
 }
 
 
 void CodeGenerator::CleanStack(int num_bytes) {
   ASSERT(num_bytes >= 0);
   if (num_bytes > 0) {
     __ add(sp, sp, Operand(num_bytes));
   }
 }
 
 
 void CodeGenerator::VisitContinueStatement(ContinueStatement* node) {
   Comment cmnt(masm_, "[ ContinueStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
-  __ b(node->target()->continue_target());
+  node->target()->continue_target()->Jump();
 }
 
 
 void CodeGenerator::VisitBreakStatement(BreakStatement* node) {
   Comment cmnt(masm_, "[ BreakStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
-  __ b(node->target()->break_target());
+  node->target()->break_target()->Jump();
 }
 
 
 void CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
   Comment cmnt(masm_, "[ ReturnStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
   Load(node->expression());
   // Move the function result into r0.
   __ pop(r0);
 
-  __ b(&function_return_);
+  function_return_.Jump();
 }
 
 
 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
   Comment cmnt(masm_, "[ WithEnterStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
   Load(node->expression());
   __ CallRuntime(Runtime::kPushContext, 1);
   if (kDebug) {
     Label verified_true;
@@ skipping 22 matching lines @@
 
 int CodeGenerator::FastCaseSwitchMinCaseCount() {
     return kFastSwitchMinCaseCount;
 }
 
 
 void CodeGenerator::GenerateFastCaseSwitchJumpTable(
     SwitchStatement* node,
     int min_index,
     int range,
-    Label* fail_label,
-    Vector<Label*> case_targets,
-    Vector<Label> case_labels) {
+    JumpTarget* fail_label,
+    Vector<JumpTarget*> case_targets,
+    Vector<JumpTarget> case_labels) {
 
   ASSERT(kSmiTag == 0 && kSmiTagSize <= 2);
 
   __ pop(r0);
 
   // Test for a Smi value in a HeapNumber.
   Label is_smi;
   __ tst(r0, Operand(kSmiTagMask));
   __ b(eq, &is_smi);
   __ ldr(r1, MemOperand(r0, HeapObject::kMapOffset - kHeapObjectTag));
   __ ldrb(r1, MemOperand(r1, Map::kInstanceTypeOffset - kHeapObjectTag));
   __ cmp(r1, Operand(HEAP_NUMBER_TYPE));
-  __ b(ne, fail_label);
+  fail_label->Branch(ne);
   __ push(r0);
   __ CallRuntime(Runtime::kNumberToSmi, 1);
   __ bind(&is_smi);
 
   if (min_index != 0) {
     // Small positive numbers can be immediate operands.
     if (min_index < 0) {
       // If min_index is Smi::kMinValue, -min_index is not a Smi.
       if (Smi::IsValid(-min_index)) {
         __ add(r0, r0, Operand(Smi::FromInt(-min_index)));
       } else {
         __ add(r0, r0, Operand(Smi::FromInt(-min_index - 1)));
         __ add(r0, r0, Operand(Smi::FromInt(1)));
       }
     } else {
       __ sub(r0, r0, Operand(Smi::FromInt(min_index)));
     }
   }
   __ tst(r0, Operand(0x80000000 | kSmiTagMask));
-  __ b(ne, fail_label);
+  fail_label->Branch(ne);
   __ cmp(r0, Operand(Smi::FromInt(range)));
-  __ b(ge, fail_label);
+  fail_label->Branch(ge);
   __ add(pc, pc, Operand(r0, LSL, 2 - kSmiTagSize));
   // One extra instruction offsets the table, so the table's start address is
   // the pc-register at the above add.
   __ stop("Unreachable: Switch table alignment");
 
+  JumpTarget table_start(this);
+  table_start.Bind();
   // Table containing branch operations.
   for (int i = 0; i < range; i++) {
-    __ b(case_targets[i]);
+    case_targets[i]->Jump();
   }
 
-  GenerateFastCaseSwitchCases(node, case_labels);
+  GenerateFastCaseSwitchCases(node, case_labels, &table_start);
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   Comment cmnt(masm_, "[ SwitchStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
+  node->break_target()->set_code_generator(this);
 
   Load(node->tag());
 
   if (TryGenerateFastCaseSwitchStatement(node)) {
       return;
   }
 
-  Label next, fall_through, default_case;
+  JumpTarget next(this);
+  Label fall_through, default_case;
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
 
   for (int i = 0; i < length; i++) {
     CaseClause* clause = cases->at(i);
 
     Comment cmnt(masm_, "[ case clause");
 
     if (clause->is_default()) {
       // Continue matching cases. The program will execute the default case's
       // statements if it does not match any of the cases.
-      __ b(&next);
+      next.Jump();
 
       // Bind the default case label, so we can branch to it when we
       // have compared against all other cases.
       ASSERT(default_case.is_unused());  // at most one default clause
       __ bind(&default_case);
     } else {
-      __ bind(&next);
+      next.Bind();
       next.Unuse();
       __ ldr(r0, frame_->Top());
       __ push(r0);  // duplicate TOS
       Load(clause->label());
       Comparison(eq, true);
       Branch(false, &next);
     }
 
     // Entering the case statement for the first time. Remove the switch value
     // from the stack.
     __ pop(r0);
 
     // Generate code for the body.
     // This is also the target for the fall through from the previous case's
     // statements which has to skip over the matching code and the popping of
     // the switch value.
     __ bind(&fall_through);
     fall_through.Unuse();
     VisitStatements(clause->statements());
     __ b(&fall_through);
   }
 
-  __ bind(&next);
+  next.Bind();
   // Reached the end of the case statements without matching any of the cases.
   if (default_case.is_bound()) {
     // A default case exists -> execute its statements.
     __ b(&default_case);
   } else {
     // Remove the switch value from the stack.
     __ pop(r0);
   }
 
   __ bind(&fall_through);
-  __ bind(node->break_target());
+  node->break_target()->Bind();
 }
 
 
 void CodeGenerator::VisitLoopStatement(LoopStatement* node) {
   Comment cmnt(masm_, "[ LoopStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
+  node->break_target()->set_code_generator(this);
+  node->continue_target()->set_code_generator(this);
 
   // simple condition analysis
   enum { ALWAYS_TRUE, ALWAYS_FALSE, DONT_KNOW } info = DONT_KNOW;
   if (node->cond() == NULL) {
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     info = ALWAYS_TRUE;
   } else {
     Literal* lit = node->cond()->AsLiteral();
     if (lit != NULL) {
       if (lit->IsTrue()) {
         info = ALWAYS_TRUE;
       } else if (lit->IsFalse()) {
         info = ALWAYS_FALSE;
       }
     }
   }
 
-  Label loop, entry;
+  JumpTarget loop(this);
+  Label entry;
 
   // init
   if (node->init() != NULL) {
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     Visit(node->init());
   }
   if (node->type() != LoopStatement::DO_LOOP && info != ALWAYS_TRUE) {
     __ b(&entry);
   }
 
   // body
-  __ bind(&loop);
+  loop.Bind();
   Visit(node->body());
 
   // next
-  __ bind(node->continue_target());
+  node->continue_target()->Bind();
   if (node->next() != NULL) {
     // Record source position of the statement as this code which is after the
     // code for the body actually belongs to the loop statement and not the
     // body.
     if (FLAG_debug_info) __ RecordPosition(node->statement_pos());
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     Visit(node->next());
   }
 
   // cond
   __ bind(&entry);
   switch (info) {
     case ALWAYS_TRUE:
       CheckStack();  // TODO(1222600): ignore if body contains calls.
-      __ b(&loop);
+      loop.Jump();
       break;
     case ALWAYS_FALSE:
       break;
     case DONT_KNOW:
       CheckStack();  // TODO(1222600): ignore if body contains calls.
       LoadCondition(node->cond(),
                     NOT_INSIDE_TYPEOF,
                     &loop,
                     node->break_target(),
                     true);
       Branch(true, &loop);
       break;
   }
 
   // exit
-  __ bind(node->break_target());
+  node->break_target()->Bind();
 }
 
 
 void CodeGenerator::VisitForInStatement(ForInStatement* node) {
   Comment cmnt(masm_, "[ ForInStatement");
   if (FLAG_debug_info) RecordStatementPosition(node);
 
   // We keep stuff on the stack while the body is executing.
   // Record it, so that a break/continue crossing this statement
   // can restore the stack.
   const int kForInStackSize = 5 * kPointerSize;
   break_stack_height_ += kForInStackSize;
   node->set_break_stack_height(break_stack_height_);
+  node->break_target()->set_code_generator(this);
+  node->continue_target()->set_code_generator(this);
 
   Label loop, next, entry, cleanup, exit, primitive, jsobject;
   Label filter_key, end_del_check, fixed_array, non_string;
 
   // Get the object to enumerate over (converted to JSObject).
   Load(node->enumerable());
   __ pop(r0);
 
   // Both SpiderMonkey and kjs ignore null and undefined in contrast
   // to the specification.  12.6.4 mandates a call to ToObject.
@@ skipping 67 matching lines @@
   __ mov(r0, Operand(Smi::FromInt(0)));  // init index
   __ push(r0);
 
   __ b(&entry);
 
   // Body.
   __ bind(&loop);
   Visit(node->body());
 
   // Next.
-  __ bind(node->continue_target());
+  node->continue_target()->Bind();
   __ bind(&next);
   __ pop(r0);
   __ add(r0, r0, Operand(Smi::FromInt(1)));
   __ push(r0);
 
   // Condition.
   __ bind(&entry);
 
   // sp[0] : index
   // sp[1] : array/enum cache length
@@ skipping 60 matching lines @@
     }
   }
   // Discard the i'th entry pushed above or else the remainder of the
   // reference, whichever is currently on top of the stack.
   __ pop();
   CheckStack();  // TODO(1222600): ignore if body contains calls.
   __ jmp(&loop);
 
   // Cleanup.
   __ bind(&cleanup);
-  __ bind(node->break_target());
+  node->break_target()->Bind();
   __ add(sp, sp, Operand(5 * kPointerSize));
 
   // Exit.
   __ bind(&exit);
 
   break_stack_height_ -= kForInStackSize;
 }
 
 
 void CodeGenerator::VisitTryCatch(TryCatch* node) {
@@ skipping 27 matching lines @@
 
   __ PushTryHandler(IN_JAVASCRIPT, TRY_CATCH_HANDLER);
 
   // Shadow the labels for all escapes from the try block, including
   // returns. During shadowing, the original label is hidden as the
   // LabelShadow and operations on the original actually affect the
   // shadowing label.
   //
   // We should probably try to unify the escaping labels and the return
   // label.
-  int nof_escapes = node->escaping_labels()->length();
-  List<LabelShadow*> shadows(1 + nof_escapes);
-  shadows.Add(new LabelShadow(&function_return_));
+  int nof_escapes = node->escaping_targets()->length();
+  List<ShadowTarget*> shadows(1 + nof_escapes);
+  shadows.Add(new ShadowTarget(&function_return_));
   for (int i = 0; i < nof_escapes; i++) {
-    shadows.Add(new LabelShadow(node->escaping_labels()->at(i)));
+    shadows.Add(new ShadowTarget(node->escaping_targets()->at(i)));
   }
 
   // Generate code for the statements in the try block.
   VisitStatements(node->try_block()->statements());
   __ pop(r0);  // Discard the result.
 
   // Stop the introduced shadowing and count the number of required unlinks.
   // After shadowing stops, the original labels are unshadowed and the
   // LabelShadows represent the formerly shadowing labels.
   int nof_unlinks = 0;
@@ skipping 13 matching lines @@
   ASSERT(StackHandlerConstants::kCodeOffset == 0);  // first field is code
   __ add(sp, sp, Operand(StackHandlerConstants::kSize - kPointerSize));
   // Code slot popped.
   if (nof_unlinks > 0) __ b(&exit);
 
   // Generate unlink code for the (formerly) shadowing labels that have been
   // jumped to.
   for (int i = 0; i <= nof_escapes; i++) {
     if (shadows[i]->is_linked()) {
       // Unlink from try chain;
-      __ bind(shadows[i]);
+      shadows[i]->Bind();
 
       // Reload sp from the top handler, because some statements that we
       // break from (eg, for...in) may have left stuff on the stack.
       __ mov(r3, Operand(ExternalReference(Top::k_handler_address)));
       __ ldr(sp, MemOperand(r3));
 
       __ ldr(r1, frame_->Element(kNextIndex));
       __ str(r1, MemOperand(r3));
       ASSERT(StackHandlerConstants::kCodeOffset == 0);  // first field is code
       __ add(sp, sp, Operand(StackHandlerConstants::kSize - kPointerSize));
       // Code slot popped.
 
-      __ b(shadows[i]->original_label());
+      shadows[i]->original_target()->Jump();
     }
   }
 
   __ bind(&exit);
 }
 
 
 void CodeGenerator::VisitTryFinally(TryFinally* node) {
   Comment cmnt(masm_, "[ TryFinally");
 
@@ skipping 16 matching lines @@
   __ bind(&try_block);
 
   __ PushTryHandler(IN_JAVASCRIPT, TRY_FINALLY_HANDLER);
 
   // Shadow the labels for all escapes from the try block, including
   // returns.  Shadowing hides the original label as the LabelShadow and
   // operations on the original actually affect the shadowing label.
   //
   // We should probably try to unify the escaping labels and the return
   // label.
-  int nof_escapes = node->escaping_labels()->length();
-  List<LabelShadow*> shadows(1 + nof_escapes);
-  shadows.Add(new LabelShadow(&function_return_));
+  int nof_escapes = node->escaping_targets()->length();
+  List<ShadowTarget*> shadows(1 + nof_escapes);
+  shadows.Add(new ShadowTarget(&function_return_));
   for (int i = 0; i < nof_escapes; i++) {
-    shadows.Add(new LabelShadow(node->escaping_labels()->at(i)));
+    shadows.Add(new ShadowTarget(node->escaping_targets()->at(i)));
   }
 
   // Generate code for the statements in the try block.
   VisitStatements(node->try_block()->statements());
 
   // Stop the introduced shadowing and count the number of required unlinks.
   // After shadowing stops, the original labels are unshadowed and the
   // LabelShadows represent the formerly shadowing labels.
   int nof_unlinks = 0;
   for (int i = 0; i <= nof_escapes; i++) {
     shadows[i]->StopShadowing();
     if (shadows[i]->is_linked()) nof_unlinks++;
   }
 
   // Set the state on the stack to FALLING.
   __ mov(r0, Operand(Factory::undefined_value()));  // fake TOS
   __ push(r0);
   __ mov(r2, Operand(Smi::FromInt(FALLING)));
   if (nof_unlinks > 0) __ b(&unlink);
 
   // Generate code to set the state for the (formerly) shadowing labels that
   // have been jumped to.
   for (int i = 0; i <= nof_escapes; i++) {
     if (shadows[i]->is_linked()) {
-      __ bind(shadows[i]);
-      if (shadows[i]->original_label() == &function_return_) {
+      shadows[i]->Bind();
+      if (shadows[i]->original_target() == &function_return_) {
         // If this label shadowed the function return, materialize the
         // return value on the stack.
         __ push(r0);
       } else {
         // Fake TOS for labels that shadowed breaks and continues.
         __ mov(r0, Operand(Factory::undefined_value()));
         __ push(r0);
       }
       __ mov(r2, Operand(Smi::FromInt(JUMPING + i)));
       __ b(&unlink);
@@ skipping 37 matching lines @@
   // Restore state and return value or faked TOS.
   __ pop(r2);
   __ pop(r0);
   break_stack_height_ -= kFinallyStackSize;
 
   // Generate code to jump to the right destination for all used (formerly)
   // shadowing labels.
   for (int i = 0; i <= nof_escapes; i++) {
     if (shadows[i]->is_bound()) {
       __ cmp(r2, Operand(Smi::FromInt(JUMPING + i)));
-      if (shadows[i]->original_label() != &function_return_) {
+      if (shadows[i]->original_target() != &function_return_) {
         Label next;
         __ b(ne, &next);
-        __ b(shadows[i]->original_label());
+        shadows[i]->original_target()->Jump();
         __ bind(&next);
       } else {
-        __ b(eq, shadows[i]->original_label());
+        shadows[i]->original_target()->Branch(eq);
       }
     }
   }
 
   // Check if we need to rethrow the exception.
   __ cmp(r2, Operand(Smi::FromInt(THROWING)));
   __ b(ne, &exit);
 
   // Rethrow exception.
   __ push(r0);
@@ skipping 39 matching lines @@
 
 void CodeGenerator::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* node) {
   Comment cmnt(masm_, "[ FunctionBoilerplateLiteral");
   InstantiateBoilerplate(node->boilerplate());
 }
 
 
 void CodeGenerator::VisitConditional(Conditional* node) {
   Comment cmnt(masm_, "[ Conditional");
-  Label then, else_, exit;
+  JumpTarget then(this);
+  JumpTarget else_(this);
+  Label exit;
   LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
   Branch(false, &else_);
-  __ bind(&then);
+  then.Bind();
   Load(node->then_expression(), typeof_state());
   __ b(&exit);
-  __ bind(&else_);
+  else_.Bind();
   Load(node->else_expression(), typeof_state());
   __ bind(&exit);
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
@@ skipping 871 matching lines @@
   // produced by a && or || operator is not necessarily a boolean.
 
   // NOTE: If the left hand side produces a materialized value (not in
   // the CC register), we force the right hand side to do the
   // same. This is necessary because we may have to branch to the exit
   // after evaluating the left hand side (due to the shortcut
   // semantics), but the compiler must (statically) know if the result
   // of compiling the binary operation is materialized or not.
 
   if (op == Token::AND) {
-    Label is_true;
+    JumpTarget is_true(this);
     LoadCondition(node->left(),
                   NOT_INSIDE_TYPEOF,
                   &is_true,
                   false_target(),
                   false);
     if (has_cc()) {
       Branch(false, false_target());
 
       // Evaluate right side expression.
-      __ bind(&is_true);
+      is_true.Bind();
       LoadCondition(node->right(),
                     NOT_INSIDE_TYPEOF,
                     true_target(),
                     false_target(),
                     false);
 
     } else {
-      Label pop_and_continue, exit;
+      JumpTarget pop_and_continue(this);
+      JumpTarget exit(this);
 
       __ ldr(r0, frame_->Top());  // dup the stack top
       __ push(r0);
       // Avoid popping the result if it converts to 'false' using the
       // standard ToBoolean() conversion as described in ECMA-262,
       // section 9.2, page 30.
       ToBoolean(&pop_and_continue, &exit);
       Branch(false, &exit);
 
       // Pop the result of evaluating the first part.
-      __ bind(&pop_and_continue);
+      pop_and_continue.Bind();
       __ pop(r0);
 
       // Evaluate right side expression.
-      __ bind(&is_true);
+      is_true.Bind();
       Load(node->right());
 
       // Exit (always with a materialized value).
-      __ bind(&exit);
+      exit.Bind();
     }
 
   } else if (op == Token::OR) {
-    Label is_false;
+    JumpTarget is_false(this);
     LoadCondition(node->left(),
                   NOT_INSIDE_TYPEOF,
                   true_target(),
                   &is_false,
                   false);
     if (has_cc()) {
       Branch(true, true_target());
 
       // Evaluate right side expression.
-      __ bind(&is_false);
+      is_false.Bind();
       LoadCondition(node->right(),
                     NOT_INSIDE_TYPEOF,
                     true_target(),
                     false_target(),
                     false);
 
     } else {
-      Label pop_and_continue, exit;
+      JumpTarget pop_and_continue(this);
+      JumpTarget exit(this);
 
       __ ldr(r0, frame_->Top());
       __ push(r0);
       // Avoid popping the result if it converts to 'true' using the
       // standard ToBoolean() conversion as described in ECMA-262,
       // section 9.2, page 30.
       ToBoolean(&exit, &pop_and_continue);
       Branch(true, &exit);
 
       // Pop the result of evaluating the first part.
-      __ bind(&pop_and_continue);
+      pop_and_continue.Bind();
       __ pop(r0);
 
       // Evaluate right side expression.
-      __ bind(&is_false);
+      is_false.Bind();
       Load(node->right());
 
       // Exit (always with a materialized value).
-      __ bind(&exit);
+      exit.Bind();
     }
 
   } else {
     // Optimize for the case where (at least) one of the expressions
     // is a literal small integer.
     Literal* lliteral = node->left()->AsLiteral();
     Literal* rliteral = node->right()->AsLiteral();
 
     if (rliteral != NULL && rliteral->handle()->IsSmi()) {
       Load(node->left());
@@ skipping 48 matching lines @@
       // non-strict comparisons.
       if (op != Token::EQ_STRICT) {
         __ b(eq, &exit);
         __ cmp(r0, Operand(Factory::undefined_value()));
 
         // NOTE: it can be undetectable object.
         __ b(eq, &exit);
         __ tst(r0, Operand(kSmiTagMask));
 
         __ b(ne, &undetectable);
-        __ b(false_target());
+        false_target()->Jump();
 
         __ bind(&undetectable);
         __ ldr(r1, FieldMemOperand(r0, HeapObject::kMapOffset));
         __ ldrb(r2, FieldMemOperand(r1, Map::kBitFieldOffset));
         __ and_(r2, r2, Operand(1 << Map::kIsUndetectable));
         __ cmp(r2, Operand(1 << Map::kIsUndetectable));
       }
 
       __ bind(&exit);
 
@@ skipping 13 matching lines @@
       (right->AsLiteral() != NULL &&
        right->AsLiteral()->handle()->IsString())) {
     Handle<String> check(String::cast(*right->AsLiteral()->handle()));
 
     // Load the operand, move it to register r1.
     LoadTypeofExpression(operation->expression());
     __ pop(r1);
 
     if (check->Equals(Heap::number_symbol())) {
       __ tst(r1, Operand(kSmiTagMask));
-      __ b(eq, true_target());
+      true_target()->Branch(eq);
       __ ldr(r1, FieldMemOperand(r1, HeapObject::kMapOffset));
       __ cmp(r1, Operand(Factory::heap_number_map()));
       cc_reg_ = eq;
 
     } else if (check->Equals(Heap::string_symbol())) {
       __ tst(r1, Operand(kSmiTagMask));
-      __ b(eq, false_target());
+      false_target()->Branch(eq);
 
       __ ldr(r1, FieldMemOperand(r1, HeapObject::kMapOffset));
 
       // NOTE: it might be an undetectable string object
       __ ldrb(r2, FieldMemOperand(r1, Map::kBitFieldOffset));
       __ and_(r2, r2, Operand(1 << Map::kIsUndetectable));
       __ cmp(r2, Operand(1 << Map::kIsUndetectable));
-      __ b(eq, false_target());
+      false_target()->Branch(eq);
 
       __ ldrb(r2, FieldMemOperand(r1, Map::kInstanceTypeOffset));
       __ cmp(r2, Operand(FIRST_NONSTRING_TYPE));
       cc_reg_ = lt;
 
     } else if (check->Equals(Heap::boolean_symbol())) {
       __ cmp(r1, Operand(Factory::true_value()));
-      __ b(eq, true_target());
+      true_target()->Branch(eq);
       __ cmp(r1, Operand(Factory::false_value()));
       cc_reg_ = eq;
 
     } else if (check->Equals(Heap::undefined_symbol())) {
       __ cmp(r1, Operand(Factory::undefined_value()));
-      __ b(eq, true_target());
+      true_target()->Branch(eq);
 
       __ tst(r1, Operand(kSmiTagMask));
-      __ b(eq, false_target());
+      false_target()->Branch(eq);
 
       // NOTE: it can be undetectable object.
       __ ldr(r1, FieldMemOperand(r1, HeapObject::kMapOffset));
       __ ldrb(r2, FieldMemOperand(r1, Map::kBitFieldOffset));
       __ and_(r2, r2, Operand(1 << Map::kIsUndetectable));
       __ cmp(r2, Operand(1 << Map::kIsUndetectable));
 
       cc_reg_ = eq;
 
     } else if (check->Equals(Heap::function_symbol())) {
       __ tst(r1, Operand(kSmiTagMask));
-      __ b(eq, false_target());
+      false_target()->Branch(eq);
       __ ldr(r1, FieldMemOperand(r1, HeapObject::kMapOffset));
       __ ldrb(r1, FieldMemOperand(r1, Map::kInstanceTypeOffset));
       __ cmp(r1, Operand(JS_FUNCTION_TYPE));
       cc_reg_ = eq;
 
     } else if (check->Equals(Heap::object_symbol())) {
       __ tst(r1, Operand(kSmiTagMask));
-      __ b(eq, false_target());
+      false_target()->Branch(eq);
 
       __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset));
       __ cmp(r1, Operand(Factory::null_value()));
-      __ b(eq, true_target());
+      true_target()->Branch(eq);
 
       // NOTE: it might be an undetectable object.
       __ ldrb(r1, FieldMemOperand(r2, Map::kBitFieldOffset));
       __ and_(r1, r1, Operand(1 << Map::kIsUndetectable));
       __ cmp(r1, Operand(1 << Map::kIsUndetectable));
-      __ b(eq, false_target());
+      false_target()->Branch(eq);
 
       __ ldrb(r2, FieldMemOperand(r2, Map::kInstanceTypeOffset));
       __ cmp(r2, Operand(FIRST_JS_OBJECT_TYPE));
-      __ b(lt, false_target());
+      false_target()->Branch(lt);
       __ cmp(r2, Operand(LAST_JS_OBJECT_TYPE));
       cc_reg_ = le;
 
     } else {
       // Uncommon case: Typeof testing against a string literal that
       // is never returned from the typeof operator.
-      __ b(false_target());
+      false_target()->Jump();
     }
     return;
   }
 
   Load(left);
   Load(right);
   switch (op) {
     case Token::EQ:
       Comparison(eq, false);
       break;
@@ skipping 1167 matching lines @@
   // Slow-case: Non-function called.
   __ bind(&slow);
   __ mov(r0, Operand(argc_));  // Setup the number of arguments.
   __ InvokeBuiltin(Builtins::CALL_NON_FUNCTION, JUMP_JS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal