First round of size reduction for JumpTargets. Reduce their size by...

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 122 matching lines @@
         fun->name()->IsEqualTo(CStrVector(FLAG_stop_at))) {
       frame_->SpillAll();
       __ int3();
     }
 #endif
 
     // Allocate space for locals and initialize them.
     frame_->AllocateStackSlots(scope_->num_stack_slots());
     // Initialize the function return target after the locals are set
     // up, because it needs the expected frame height from the frame.
-    function_return_.Initialize(this, JumpTarget::BIDIRECTIONAL);
+    function_return_.set_direction(JumpTarget::BIDIRECTIONAL);
     function_return_is_shadowed_ = false;
 
     // Allocate the arguments object and copy the parameters into it.
     if (scope_->arguments() != NULL) {
       ASSERT(scope_->arguments_shadow() != NULL);
       Comment cmnt(masm_, "[ Allocate arguments object");
       ArgumentsAccessStub stub(ArgumentsAccessStub::NEW_OBJECT);
       frame_->PushFunction();
       frame_->PushReceiverSlotAddress();
       frame_->Push(Smi::FromInt(scope_->num_parameters()));
@@ skipping 306 matching lines @@
   frame_->SpillAll();
   set_in_spilled_code(true);
 }
 
 
 void CodeGenerator::Load(Expression* x, TypeofState typeof_state) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   ASSERT(!in_spilled_code());
-  JumpTarget true_target(this);
-  JumpTarget false_target(this);
+  JumpTarget true_target;
+  JumpTarget false_target;
   ControlDestination dest(&true_target, &false_target, true);
   LoadCondition(x, typeof_state, &dest, false);
 
   if (dest.false_was_fall_through()) {
     // The false target was just bound.
-    JumpTarget loaded(this);
+    JumpTarget loaded;
     frame_->Push(Factory::false_value());
     // There may be dangling jumps to the true target.
     if (true_target.is_linked()) {
       loaded.Jump();
       true_target.Bind();
       frame_->Push(Factory::true_value());
       loaded.Bind();
     }
 
   } else if (dest.is_used()) {
     // There is true, and possibly false, control flow (with true as
     // the fall through).
-    JumpTarget loaded(this);
+    JumpTarget loaded;
     frame_->Push(Factory::true_value());
     if (false_target.is_linked()) {
       loaded.Jump();
       false_target.Bind();
       frame_->Push(Factory::false_value());
       loaded.Bind();
     }
 
   } else {
     // We have a valid value on top of the frame, but we still may
     // have dangling jumps to the true and false targets from nested
     // subexpressions (eg, the left subexpressions of the
     // short-circuited boolean operators).
     ASSERT(has_valid_frame());
     if (true_target.is_linked() || false_target.is_linked()) {
-      JumpTarget loaded(this);
+      JumpTarget loaded;
       loaded.Jump();  // Don't lose the current TOS.
       if (true_target.is_linked()) {
         true_target.Bind();
         frame_->Push(Factory::true_value());
         if (false_target.is_linked()) {
           loaded.Jump();
         }
       }
       if (false_target.is_linked()) {
         false_target.Bind();
@@ skipping 1016 matching lines @@
         left_side = right_side;
         right_side = temp;
         cc = ReverseCondition(cc);
         // This may reintroduce greater or less_equal as the value of cc.
         // CompareStub and the inline code both support all values of cc.
       }
       // Implement comparison against a constant Smi, inlining the case
       // where both sides are Smis.
       left_side.ToRegister();
       ASSERT(left_side.is_valid());
-      JumpTarget is_smi(this);
+      JumpTarget is_smi;
       __ test(left_side.reg(), Immediate(kSmiTagMask));
       is_smi.Branch(zero, &left_side, &right_side, taken);
 
       // Setup and call the compare stub, which expects its arguments
       // in registers.
       CompareStub stub(cc, strict);
       Result result = frame_->CallStub(&stub, &left_side, &right_side);
       result.ToRegister();
       __ cmp(result.reg(), 0);
       result.Unuse();
@@ skipping 50 matching lines @@
       operand.Unuse();
       dest->Split(not_zero);
     }
   } else {  // Neither side is a constant Smi or null.
     // If either side is a non-smi constant, skip the smi check.
     bool known_non_smi =
         (left_side.is_constant() && !left_side.handle()->IsSmi()) ||
         (right_side.is_constant() && !right_side.handle()->IsSmi());
     left_side.ToRegister();
     right_side.ToRegister();
-    JumpTarget is_smi(this);
+    JumpTarget is_smi;
     if (!known_non_smi) {
       // Check for the smi case.
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
       __ mov(temp.reg(), left_side.reg());
       __ or_(temp.reg(), Operand(right_side.reg()));
       __ test(temp.reg(), Immediate(kSmiTagMask));
       temp.Unuse();
       is_smi.Branch(zero, &left_side, &right_side, taken);
     }
@@ skipping 124 matching lines @@
   for (int i = 0; has_valid_frame() && i < statements->length(); i++) {
     Visit(statements->at(i));
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ Block");
   CodeForStatementPosition(node);
-  node->break_target()->Initialize(this);
+  node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
   VisitStatements(node->statements());
   if (node->break_target()->is_linked()) {
     node->break_target()->Bind();
   }
   node->break_target()->Unuse();
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   frame_->Push(pairs);
@@ skipping 93 matching lines @@
 
 void CodeGenerator::VisitIfStatement(IfStatement* node) {
   ASSERT(!in_spilled_code());
   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();
 
   CodeForStatementPosition(node);
-  JumpTarget exit(this);
+  JumpTarget exit;
   if (has_then_stm && has_else_stm) {
-    JumpTarget then(this);
-    JumpTarget else_(this);
+    JumpTarget then;
+    JumpTarget else_;
     ControlDestination dest(&then, &else_, true);
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &dest, true);
 
     if (dest.false_was_fall_through()) {
       // The else target was bound, so we compile the else part first.
       Visit(node->else_statement());
 
       // We may have dangling jumps to the then part.
       if (then.is_linked()) {
         if (has_valid_frame()) exit.Jump();
         then.Bind();
         Visit(node->then_statement());
       }
     } else {
       // The then target was bound, so we compile the then part first.
       Visit(node->then_statement());
 
       if (else_.is_linked()) {
         if (has_valid_frame()) exit.Jump();
         else_.Bind();
         Visit(node->else_statement());
       }
     }
 
   } else if (has_then_stm) {
     ASSERT(!has_else_stm);
-    JumpTarget then(this);
+    JumpTarget then;
     ControlDestination dest(&then, &exit, true);
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &dest, true);
 
     if (dest.false_was_fall_through()) {
       // The exit label was bound.  We may have dangling jumps to the
       // then part.
       if (then.is_linked()) {
         exit.Unuse();
         exit.Jump();
         then.Bind();
         Visit(node->then_statement());
       }
     } else {
       // The then label was bound.
       Visit(node->then_statement());
     }
 
   } else if (has_else_stm) {
     ASSERT(!has_then_stm);
-    JumpTarget else_(this);
+    JumpTarget else_;
     ControlDestination dest(&exit, &else_, false);
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &dest, true);
 
     if (dest.true_was_fall_through()) {
       // The exit label was bound.  We may have dangling jumps to the
       // else part.
       if (else_.is_linked()) {
         exit.Unuse();
         exit.Jump();
         else_.Bind();
@@ skipping 146 matching lines @@
     Vector<Label*> case_targets,
     Vector<Label> case_labels) {
   // Notice: Internal references, used by both the jmp instruction and
   // the table entries, need to be relocated if the buffer grows. This
   // prevents the forward use of Labels, since a displacement cannot
   // survive relocation, and it also cannot safely be distinguished
   // from a real address.  Instead we put in zero-values as
   // placeholders, and fill in the addresses after the labels have been
   // bound.
 
-  JumpTarget setup_default(this);
-  JumpTarget is_smi(this);
+  JumpTarget setup_default;
+  JumpTarget is_smi;
 
   // A non-null default label pointer indicates a default case among
   // the case labels.  Otherwise we use the break target as a
   // "default".
   JumpTarget* default_target =
       (default_label == NULL) ? node->break_target() : &setup_default;
 
   // Test whether input is a smi.
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
   Result switch_value = frame_->Pop();
@@ skipping 24 matching lines @@
   __ test(smi_value.reg(), Immediate(0x80000000 | kSmiTagMask));
   default_target->Branch(not_equal, not_taken);
   __ cmp(smi_value.reg(), range << kSmiTagSize);
   default_target->Branch(greater_equal, not_taken);
 
   // The expected frame at all the case labels is a version of the
   // current one (the bidirectional entry frame, which an arbitrary
   // frame of the correct height can be merged to).  Keep a copy to
   // restore at the start of every label.  Create a jump target and
   // bind it to set its entry frame properly.
-  JumpTarget entry_target(this, JumpTarget::BIDIRECTIONAL);
+  JumpTarget entry_target(JumpTarget::BIDIRECTIONAL);
   entry_target.Bind(&smi_value);
   VirtualFrame* start_frame = new VirtualFrame(frame_);
 
   // 0 is placeholder.
   // Jump to the address at table_address + 2 * smi_value.reg().
   // The target of the jump is read from table_address + 4 * switch_value.
   // The Smi encoding of smi_value.reg() is 2 * switch_value.
   smi_value.ToRegister();
   __ jmp(Operand(smi_value.reg(), smi_value.reg(),
                  times_1, 0x0, RelocInfo::INTERNAL_REFERENCE));
@@ skipping 36 matching lines @@
       __ WriteInternalReference(entry_pos, *case_targets[i]);
     }
   }
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ SwitchStatement");
   CodeForStatementPosition(node);
-  node->break_target()->Initialize(this);
+  node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
 
   // Compile the switch value.
   Load(node->tag());
 
   if (TryGenerateFastCaseSwitchStatement(node)) {
     return;
   }
 
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
   CaseClause* default_clause = NULL;
 
-  JumpTarget next_test(this);
+  JumpTarget next_test;
   // Compile the case label expressions and comparisons.  Exit early
   // if a comparison is unconditionally true.  The target next_test is
   // bound before the loop in order to indicate control flow to the
   // first comparison.
   next_test.Bind();
   for (int i = 0; i < length && !next_test.is_unused(); i++) {
     CaseClause* clause = cases->at(i);
-    clause->body_target()->Initialize(this);
     // The default is not a test, but remember it for later.
     if (clause->is_default()) {
       default_clause = clause;
       continue;
     }
 
     Comment cmnt(masm_, "[ Case comparison");
     // We recycle the same target next_test for each test.  Bind it if
     // the previous test has not done so and then unuse it for the
     // loop.
@@ skipping 50 matching lines @@
     if (clause->body_target()->is_linked() || has_valid_frame()) {
       if (clause->body_target()->is_linked()) {
         if (has_valid_frame()) {
           // If we have both a jump to the test and a fall through, put
           // a jump on the fall through path to avoid the dropping of
           // the switch value on the test path.  The exception is the
           // default which has already had the switch value dropped.
           if (clause->is_default()) {
             clause->body_target()->Bind();
           } else {
-            JumpTarget body(this);
+            JumpTarget body;
             body.Jump();
             clause->body_target()->Bind();
             frame_->Drop();
             body.Bind();
           }
         } else {
           // No fall through to worry about.
           clause->body_target()->Bind();
           if (!clause->is_default()) {
             frame_->Drop();
@@ skipping 17 matching lines @@
     node->break_target()->Bind();
   }
   node->break_target()->Unuse();
 }
 
 
 void CodeGenerator::VisitLoopStatement(LoopStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ LoopStatement");
   CodeForStatementPosition(node);
-  node->break_target()->Initialize(this);
+  node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
 
   // Simple condition analysis.  ALWAYS_TRUE and ALWAYS_FALSE represent a
   // known result for the test expression, with no side effects.
   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;
       }
     }
   }
 
   switch (node->type()) {
     case LoopStatement::DO_LOOP: {
-      JumpTarget body(this, JumpTarget::BIDIRECTIONAL);
+      JumpTarget body(JumpTarget::BIDIRECTIONAL);
       IncrementLoopNesting();
 
       // Label the top of the loop for the backward jump if necessary.
       if (info == ALWAYS_TRUE) {
         // Use the continue target.
-        node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
+        node->continue_target()->set_direction(JumpTarget::BIDIRECTIONAL);
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
         // No need to label it.
-        node->continue_target()->Initialize(this);
+        node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
       } else {
         // Continue is the test, so use the backward body target.
         ASSERT(info == DONT_KNOW);
-        node->continue_target()->Initialize(this);
+        node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
         body.Bind();
       }
 
       CheckStack();  // TODO(1222600): ignore if body contains calls.
       Visit(node->body());
 
       // Compile the test.
       if (info == ALWAYS_TRUE) {
         // If control flow can fall off the end of the body, jump back
         // to the top and bind the break target at the exit.
@@ skipping 38 matching lines @@
       bool test_at_bottom = !node->may_have_function_literal();
 
       IncrementLoopNesting();
 
       // If the condition is always false and has no side effects, we
       // do not need to compile anything.
       if (info == ALWAYS_FALSE) break;
 
       JumpTarget body;
       if (test_at_bottom) {
-        body.Initialize(this, JumpTarget::BIDIRECTIONAL);
-      } else {
-        body.Initialize(this);
+        body.set_direction(JumpTarget::BIDIRECTIONAL);
       }
 
       // Based on the condition analysis, compile the test as necessary.
       if (info == ALWAYS_TRUE) {
         // We will not compile the test expression.  Label the top of
         // the loop with the continue target.
-        node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
+        node->continue_target()->set_direction(JumpTarget::BIDIRECTIONAL);
         node->continue_target()->Bind();
       } else {
         ASSERT(info == DONT_KNOW);  // ALWAYS_FALSE cannot reach here.
         if (test_at_bottom) {
           // Continue is the test at the bottom, no need to label the
           // test at the top.  The body is a backward target.
-          node->continue_target()->Initialize(this);
+          node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
         } else {
           // Label the test at the top as the continue target.  The
           // body is a forward-only target.
-          node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
+          node->continue_target()->set_direction(JumpTarget::BIDIRECTIONAL);
           node->continue_target()->Bind();
         }
         // Compile the test with the body as the true target and
         // preferred fall-through and with the break target as the
         // false target.
         ControlDestination dest(&body, node->break_target(), true);
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF, &dest, true);
 
         if (dest.false_was_fall_through()) {
           // If we got the break target as fall-through, the test may
@@ skipping 62 matching lines @@
       }
 
       IncrementLoopNesting();
 
       // If the condition is always false and has no side effects, we
       // do not need to compile anything else.
       if (info == ALWAYS_FALSE) break;
 
       // Target for backward edge if no test at the bottom, otherwise
       // unused.
-      JumpTarget loop(this, JumpTarget::BIDIRECTIONAL);
+      JumpTarget loop(JumpTarget::BIDIRECTIONAL);
 
       // Target for backward edge if there is a test at the bottom,
       // otherwise used as target for test at the top.
       JumpTarget body;
       if (test_at_bottom) {
-        body.Initialize(this, JumpTarget::BIDIRECTIONAL);
-      } else {
-        body.Initialize(this);
+        body.set_direction(JumpTarget::BIDIRECTIONAL);
       }
 
       // Based on the condition analysis, compile the test as necessary.
       if (info == ALWAYS_TRUE) {
         // We will not compile the test expression.  Label the top of
         // the loop.
         if (node->next() == NULL) {
           // Use the continue target if there is no update expression.
-          node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
+          node->continue_target()->set_direction(JumpTarget::BIDIRECTIONAL);
           node->continue_target()->Bind();
         } else {
           // Otherwise use the backward loop target.
-          node->continue_target()->Initialize(this);
+          node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
           loop.Bind();
         }
       } else {
         ASSERT(info == DONT_KNOW);
         if (test_at_bottom) {
           // Continue is either the update expression or the test at
           // the bottom, no need to label the test at the top.
-          node->continue_target()->Initialize(this);
+          node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
         } else if (node->next() == NULL) {
           // We are not recompiling the test at the bottom and there
           // is no update expression.
-          node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
+          node->continue_target()->set_direction(JumpTarget::BIDIRECTIONAL);
           node->continue_target()->Bind();
         } else {
           // We are not recompiling the test at the bottom and there
           // is an update expression.
-          node->continue_target()->Initialize(this);
+          node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
           loop.Bind();
         }
 
         // Compile the test with the body as the true target and
         // preferred fall-through and with the break target as the
         // false target.
         ControlDestination dest(&body, node->break_target(), true);
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF, &dest, true);
 
         if (dest.false_was_fall_through()) {
@@ skipping 83 matching lines @@
   node->break_target()->Unuse();
 }
 
 
 void CodeGenerator::VisitForInStatement(ForInStatement* node) {
   ASSERT(!in_spilled_code());
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ ForInStatement");
   CodeForStatementPosition(node);
 
-  JumpTarget primitive(this);
-  JumpTarget jsobject(this);
-  JumpTarget fixed_array(this);
-  JumpTarget entry(this, JumpTarget::BIDIRECTIONAL);
-  JumpTarget end_del_check(this);
-  JumpTarget exit(this);
+  JumpTarget primitive;
+  JumpTarget jsobject;
+  JumpTarget fixed_array;
+  JumpTarget entry(JumpTarget::BIDIRECTIONAL);
+  JumpTarget end_del_check;
+  JumpTarget exit;
 
   // Get the object to enumerate over (converted to JSObject).
   LoadAndSpill(node->enumerable());
 
   // Both SpiderMonkey and kjs ignore null and undefined in contrast
   // to the specification.  12.6.4 mandates a call to ToObject.
   frame_->EmitPop(eax);
 
   // eax: value to be iterated over
   __ cmp(eax, Factory::undefined_value());
@@ skipping 64 matching lines @@
   // Push the length of the array and the initial index onto the stack.
   __ mov(eax, FieldOperand(eax, FixedArray::kLengthOffset));
   __ shl(eax, kSmiTagSize);
   frame_->EmitPush(eax);  // <- slot 1
   frame_->EmitPush(Immediate(Smi::FromInt(0)));  // <- slot 0
 
   // Condition.
   entry.Bind();
   // Grab the current frame's height for the break and continue
   // targets only after all the state is pushed on the frame.
-  node->break_target()->Initialize(this);
-  node->continue_target()->Initialize(this);
+  node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
+  node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
 
   __ mov(eax, frame_->ElementAt(0));  // load the current count
   __ cmp(eax, frame_->ElementAt(1));  // compare to the array length
   node->break_target()->Branch(above_equal);
 
   // Get the i'th entry of the array.
   __ mov(edx, frame_->ElementAt(2));
   __ mov(ebx, Operand(edx, eax, times_2,
                       FixedArray::kHeaderSize - kHeapObjectTag));
 
@@ skipping 78 matching lines @@
   node->break_target()->Unuse();
 }
 
 
 void CodeGenerator::VisitTryCatch(TryCatch* node) {
   ASSERT(!in_spilled_code());
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ TryCatch");
   CodeForStatementPosition(node);
 
-  JumpTarget try_block(this);
-  JumpTarget exit(this);
+  JumpTarget try_block;
+  JumpTarget exit;
 
   try_block.Call();
   // --- Catch block ---
   frame_->EmitPush(eax);
 
   // Store the caught exception in the catch variable.
   { Reference ref(this, node->catch_var());
     ASSERT(ref.is_slot());
     // Load the exception to the top of the stack.  Here we make use of the
     // convenient property that it doesn't matter whether a value is
@@ skipping 122 matching lines @@
   ASSERT(!in_spilled_code());
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ TryFinally");
   CodeForStatementPosition(node);
 
   // State: Used to keep track of reason for entering the finally
   // block. Should probably be extended to hold information for
   // break/continue from within the try block.
   enum { FALLING, THROWING, JUMPING };
 
-  JumpTarget try_block(this);
-  JumpTarget finally_block(this);
+  JumpTarget try_block;
+  JumpTarget finally_block;
 
   try_block.Call();
 
   frame_->EmitPush(eax);
   // In case of thrown exceptions, this is where we continue.
   __ Set(ecx, Immediate(Smi::FromInt(THROWING)));
   finally_block.Jump();
 
   // --- Try block ---
   try_block.Bind();
@@ skipping 131 matching lines @@
       __ cmp(Operand(ecx), Immediate(Smi::FromInt(JUMPING + i)));
       if (i == kReturnShadowIndex) {
         // The return value is (already) in eax.
         Result return_value = allocator_->Allocate(eax);
         ASSERT(return_value.is_valid());
         if (function_return_is_shadowed_) {
           original->Branch(equal, &return_value);
         } else {
           // Branch around the preparation for return which may emit
           // code.
-          JumpTarget skip(this);
+          JumpTarget skip;
           skip.Branch(not_equal);
           frame_->PrepareForReturn();
           original->Jump(&return_value);
           skip.Bind();
         }
       } else {
         original->Branch(equal);
       }
     }
   }
 
   if (has_valid_frame()) {
     // Check if we need to rethrow the exception.
-    JumpTarget exit(this);
+    JumpTarget exit;
     __ cmp(Operand(ecx), Immediate(Smi::FromInt(THROWING)));
     exit.Branch(not_equal);
 
     // Rethrow exception.
     frame_->EmitPush(eax);  // undo pop from above
     frame_->CallRuntime(Runtime::kReThrow, 1);
 
     // Done.
     exit.Bind();
   }
@@ 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");
-  JumpTarget then(this);
-  JumpTarget else_(this);
-  JumpTarget exit(this);
+  JumpTarget then;
+  JumpTarget else_;
+  JumpTarget exit;
   ControlDestination dest(&then, &else_, true);
   LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &dest, true);
 
   if (dest.false_was_fall_through()) {
     // The else target was bound, so we compile the else part first.
     Load(node->else_expression(), typeof_state());
 
     if (then.is_linked()) {
       exit.Jump();
       then.Bind();
@@ skipping 11 matching lines @@
   }
 
   exit.Bind();
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->is_dynamic());
 
-    JumpTarget slow(this);
-    JumpTarget done(this);
+    JumpTarget slow;
+    JumpTarget done;
     Result value;
 
     // 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 (slot->var()->mode() == Variable::DYNAMIC_GLOBAL) {
       value = LoadFromGlobalSlotCheckExtensions(slot, typeof_state, &slow);
       // If there was no control flow to slow, we can exit early.
@@ skipping 45 matching lines @@
 
   } else if (slot->var()->mode() == Variable::CONST) {
     // Const slots may contain 'the hole' value (the constant hasn't been
     // initialized yet) which needs to be converted into the 'undefined'
     // value.
     //
     // We currently spill the virtual frame because constants use the
     // potentially unsafe direct-frame access of SlotOperand.
     VirtualFrame::SpilledScope spilled_scope(this);
     Comment cmnt(masm_, "[ Load const");
-    JumpTarget exit(this);
+    JumpTarget exit;
     __ mov(ecx, SlotOperand(slot, ecx));
     __ cmp(ecx, Factory::the_hole_value());
     exit.Branch(not_equal);
     __ mov(ecx, Factory::undefined_value());
     exit.Bind();
     frame_->EmitPush(ecx);
 
   } else if (slot->type() == Slot::PARAMETER) {
     frame_->PushParameterAt(slot->index());
 
@@ skipping 117 matching lines @@
       value = frame_->CallRuntime(Runtime::kStoreContextSlot, 3);
     }
     // Storing a variable must keep the (new) value on the expression
     // stack. This is necessary for compiling chained assignment
     // expressions.
     frame_->Push(&value);
 
   } else {
     ASSERT(!slot->var()->is_dynamic());
 
-    JumpTarget exit(this);
+    JumpTarget exit;
     if (init_state == CONST_INIT) {
       ASSERT(slot->var()->mode() == Variable::CONST);
       // Only the first const initialization must be executed (the slot
       // still contains 'the hole' value). When the assignment is executed,
       // the code is identical to a normal store (see below).
       //
       // We spill the frame in the code below because the direct-frame
       // access of SlotOperand is potentially unsafe with an unspilled
       // frame.
       VirtualFrame::SpilledScope spilled_scope(this);
@@ skipping 804 matching lines @@
 
 // This generates code that performs a charCodeAt() call or returns
 // undefined in order to trigger the slow case, Runtime_StringCharCodeAt.
 // It can handle flat and sliced strings, 8 and 16 bit characters and
 // cons strings where the answer is found in the left hand branch of the
 // cons.  The slow case will flatten the string, which will ensure that
 // the answer is in the left hand side the next time around.
 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
 
-  JumpTarget slow_case(this);
-  JumpTarget end(this);
-  JumpTarget not_a_flat_string(this);
-  JumpTarget a_cons_string(this);
-  JumpTarget try_again_with_new_string(this, JumpTarget::BIDIRECTIONAL);
-  JumpTarget ascii_string(this);
-  JumpTarget got_char_code(this);
+  JumpTarget slow_case;
+  JumpTarget end;
+  JumpTarget not_a_flat_string;
+  JumpTarget a_cons_string;
+  JumpTarget try_again_with_new_string(JumpTarget::BIDIRECTIONAL);
+  JumpTarget ascii_string;
+  JumpTarget got_char_code;
 
   Load(args->at(0));
   Load(args->at(1));
   // Reserve register ecx, to use as shift amount later
   Result shift_amount = allocator()->Allocate(ecx);
   ASSERT(shift_amount.is_valid());
   Result index = frame_->Pop();
   index.ToRegister();
   Result object = frame_->Pop();
   object.ToRegister();
@@ skipping 137 matching lines @@
   Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())));
   // Call the shared stub to get to the arguments.length.
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_LENGTH);
   Result result = frame_->CallStub(&stub, &count);
   frame_->Push(&result);
 }
 
 
 void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
-  JumpTarget leave(this);
+  JumpTarget leave;
   Load(args->at(0));  // Load the object.
   frame_->Dup();
   Result object = frame_->Pop();
   object.ToRegister();
   ASSERT(object.is_valid());
   // if (object->IsSmi()) return object.
   __ test(object.reg(), Immediate(kSmiTagMask));
   leave.Branch(zero, taken);
   // It is a heap object - get map.
   Result temp = allocator()->Allocate();
   ASSERT(temp.is_valid());
   // if (!object->IsJSValue()) return object.
   __ CmpObjectType(object.reg(), JS_VALUE_TYPE, temp.reg());
   leave.Branch(not_equal, not_taken);
   __ mov(temp.reg(), FieldOperand(object.reg(), JSValue::kValueOffset));
   object.Unuse();
   frame_->SetElementAt(0, &temp);
   leave.Bind();
 }
 
 
 void CodeGenerator::GenerateSetValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
-  JumpTarget leave(this);
+  JumpTarget leave;
   Load(args->at(0));  // Load the object.
   Load(args->at(1));  // Load the value.
   Result value = frame_->Pop();
   Result object = frame_->Pop();
   value.ToRegister();
   object.ToRegister();
 
   // if (object->IsSmi()) return value.
   __ test(object.reg(), Immediate(kSmiTagMask));
   leave.Branch(zero, &value, taken);
@@ skipping 208 matching lines @@
         UnarySubStub stub;
         // TODO(1222589): remove dependency of TOS being cached inside stub
         Result operand = frame_->Pop();
         Result answer = frame_->CallStub(&stub, &operand);
         frame_->Push(&answer);
         break;
       }
 
       case Token::BIT_NOT: {
         // Smi check.
-        JumpTarget smi_label(this);
-        JumpTarget continue_label(this);
+        JumpTarget smi_label;
+        JumpTarget continue_label;
         Result operand = frame_->Pop();
         operand.ToRegister();
         __ test(operand.reg(), Immediate(kSmiTagMask));
         smi_label.Branch(zero, &operand, taken);
 
         frame_->Push(&operand);  // undo popping of TOS
         Result answer = frame_->InvokeBuiltin(Builtins::BIT_NOT,
                                               CALL_FUNCTION, 1);
 
         continue_label.Jump(&answer);
         smi_label.Bind(&answer);
         answer.ToRegister();
         frame_->Spill(answer.reg());
         __ not_(answer.reg());
         __ and_(answer.reg(), ~kSmiTagMask);  // Remove inverted smi-tag.
         continue_label.Bind(&answer);
         frame_->Push(&answer);
         break;
       }
 
       case Token::ADD: {
         // Smi check.
-        JumpTarget continue_label(this);
+        JumpTarget continue_label;
         Result operand = frame_->Pop();
         operand.ToRegister();
         __ test(operand.reg(), Immediate(kSmiTagMask));
         continue_label.Branch(zero, &operand, taken);
 
         frame_->Push(&operand);
         Result answer = frame_->InvokeBuiltin(Builtins::TO_NUMBER,
                                               CALL_FUNCTION, 1);
 
         continue_label.Bind(&answer);
@@ skipping 174 matching lines @@
   // According to ECMA-262 section 11.11, page 58, the binary logical
   // operators must yield the result of one of the two expressions
   // before any ToBoolean() conversions. This means that the value
   // produced by a && or || operator is not necessarily a boolean.
 
   // NOTE: If the left hand side produces a materialized value (not
   // control flow), we force the right hand side to do the same. This
   // is necessary because we assume that if we get control flow on the
   // last path out of an expression we got it on all paths.
   if (op == Token::AND) {
-    JumpTarget is_true(this);
+    JumpTarget is_true;
     ControlDestination dest(&is_true, destination()->false_target(), true);
     LoadCondition(node->left(), NOT_INSIDE_TYPEOF, &dest, false);
 
     if (dest.false_was_fall_through()) {
       // The current false target was used as the fall-through.  If
       // there are no dangling jumps to is_true then the left
       // subexpression was unconditionally false.  Otherwise we have
       // paths where we do have to evaluate the right subexpression.
       if (is_true.is_linked()) {
         // We need to compile the right subexpression.  If the jump to
@@ skipping 17 matching lines @@
 
     } else if (dest.is_used()) {
       // The left subexpression compiled to control flow (and is_true
       // was just bound), so the right is free to do so as well.
       LoadCondition(node->right(), NOT_INSIDE_TYPEOF, destination(), false);
 
     } else {
       // We have a materialized value on the frame, so we exit with
       // one on all paths.  There are possibly also jumps to is_true
       // from nested subexpressions.
-      JumpTarget pop_and_continue(this);
-      JumpTarget exit(this);
+      JumpTarget pop_and_continue;
+      JumpTarget exit;
 
       // Avoid popping the result if it converts to 'false' using the
       // standard ToBoolean() conversion as described in ECMA-262,
       // section 9.2, page 30.
       //
       // Duplicate the TOS value. The duplicate will be popped by
       // ToBoolean.
       frame_->Dup();
       ControlDestination dest(&pop_and_continue, &exit, true);
       ToBoolean(&dest);
 
       // Pop the result of evaluating the first part.
       frame_->Drop();
 
       // Compile right side expression.
       is_true.Bind();
       Load(node->right());
 
       // Exit (always with a materialized value).
       exit.Bind();
     }
 
   } else if (op == Token::OR) {
-    JumpTarget is_false(this);
+    JumpTarget is_false;
     ControlDestination dest(destination()->true_target(), &is_false, false);
     LoadCondition(node->left(), NOT_INSIDE_TYPEOF, &dest, false);
 
     if (dest.true_was_fall_through()) {
       // The current true target was used as the fall-through.  If
       // there are no dangling jumps to is_false then the left
       // subexpression was unconditionally true.  Otherwise we have
       // paths where we do have to evaluate the right subexpression.
       if (is_false.is_linked()) {
         // We need to compile the right subexpression.  If the jump to
@@ skipping 16 matching lines @@
 
     } else if (dest.is_used()) {
       // The left subexpression compiled to control flow (and is_false
       // was just bound), so the right is free to do so as well.
       LoadCondition(node->right(), NOT_INSIDE_TYPEOF, destination(), false);
 
     } else {
       // We have a materialized value on the frame, so we exit with
       // one on all paths.  There are possibly also jumps to is_false
       // from nested subexpressions.
-      JumpTarget pop_and_continue(this);
-      JumpTarget exit(this);
+      JumpTarget pop_and_continue;
+      JumpTarget exit;
 
       // Avoid popping the result if it converts to 'true' using the
       // standard ToBoolean() conversion as described in ECMA-262,
       // section 9.2, page 30.
       //
       // Duplicate the TOS value. The duplicate will be popped by
       // ToBoolean.
       frame_->Dup();
       ControlDestination dest(&exit, &pop_and_continue, false);
       ToBoolean(&dest);
@@ skipping 933 matching lines @@
           // Check that the *unsigned* result fits in a smi.
           // Neither of the two high-order bits can be set:
           // - 0x80000000: high bit would be lost when smi tagging.
           // - 0x40000000: this number would convert to negative when
           // Smi tagging these two cases can only happen with shifts
           // by 0 or 1 when handed a valid smi.
           // If the answer cannot be represented by a SMI, restore
           // the left and right arguments, and jump to slow case.
           // The low bit of the left argument may be lost, but only
           // in a case where it is dropped anyway.
-          JumpTarget result_ok(generator());
+          JumpTarget result_ok;
           __ test(left->reg(), Immediate(0xc0000000));
           result_ok.Branch(zero, left, taken);
           __ shl(left->reg());
           ASSERT(kSmiTag == 0);
           __ shl(left->reg(), kSmiTagSize);
           __ shl(right->reg(), kSmiTagSize);
           enter()->Jump(left, right);
           result_ok.Bind(left);
           break;
         }
         case Token::SHL: {
           __ shl(left->reg());
           // Check that the *signed* result fits in a smi.
-          JumpTarget result_ok(generator());
+          JumpTarget result_ok;
           __ cmp(left->reg(), 0xc0000000);
           result_ok.Branch(positive, left, taken);
 
           __ shr(left->reg());
           ASSERT(kSmiTag == 0);
           __ shl(left->reg(), kSmiTagSize);
           __ shl(right->reg(), kSmiTagSize);
           enter()->Jump(left, right);
           result_ok.Bind(left);
           break;
@@ skipping 1235 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal