Experimental: statically distinguish between named basic block entries...

src/codegen-ia32.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 120 matching lines @@
   ZoneList<Statement*>* body = fun->body();
 
   // Initialize state.
   ASSERT(scope_ == NULL);
   scope_ = fun->scope();
   ASSERT(allocator_ == NULL);
   RegisterAllocator register_allocator(this);
   allocator_ = &register_allocator;
   ASSERT(frame_ == NULL);
   frame_ = new VirtualFrame(this);
-  function_return_.set_code_generator(this);
+  function_return_.Initialize(this, JumpTarget::BIDIRECTIONAL);
   function_return_is_shadowed_ = false;
   set_in_spilled_code(false);
 
   // Adjust for function-level loop nesting.
   loop_nesting_ += fun->loop_nesting();
 
   {
     CodeGenState state(this);
 
     // Entry
@@ skipping 1198 matching lines @@
     Visit(statements->at(i));
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ Block");
   CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
-  node->break_target()->set_code_generator(this);
+  node->break_target()->Initialize(this);
   VisitStatements(node->statements());
   if (node->break_target()->is_linked()) {
     node->break_target()->Bind();
   }
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   VirtualFrame::SpilledScope spilled_scope(this);
   frame_->EmitPush(Immediate(pairs));
@@ skipping 361 matching lines @@
     __ WriteInternalReference(entry_pos, *case_targets[i]->entry_label());
   }
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ SwitchStatement");
   CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
-  node->break_target()->set_code_generator(this);
+  node->break_target()->Initialize(this);
 
   Load(node->tag());
 
   if (TryGenerateFastCaseSwitchStatement(node)) {
     return;
   }
 
   JumpTarget next_test(this);
   JumpTarget fall_through(this);
   JumpTarget default_entry(this);
-  JumpTarget default_exit(this);
+  JumpTarget default_exit(this, JumpTarget::BIDIRECTIONAL);
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
   CaseClause* default_clause = NULL;
 
   for (int i = 0; i < length; i++) {
     CaseClause* clause = cases->at(i);
     if (clause->is_default()) {
       // Remember the default clause and compile it at the end.
       default_clause = clause;
       continue;
@@ skipping 67 matching lines @@
     node->break_target()->Bind();
   }
 }
 
 
 void CodeGenerator::VisitLoopStatement(LoopStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ LoopStatement");
   CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
-  node->break_target()->set_code_generator(this);
-  node->continue_target()->set_code_generator(this);
+  node->break_target()->Initialize(this);
 
   // 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 body(this, JumpTarget::BIDIRECTIONAL);
       IncrementLoopNesting();
 
       // Label the top of the loop for the backward CFG edge.  If the test
       // is always true we can use the continue target, and if the test is
       // always false there is no need.
       if (info == ALWAYS_TRUE) {
+        node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
+        node->continue_target()->Initialize(this);
         // There is no need, we will never jump back.
       } else {
         ASSERT(info == DONT_KNOW);
+        node->continue_target()->Initialize(this);
         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.
@@ skipping 22 matching lines @@
 
     case LoopStatement::WHILE_LOOP: {
       IncrementLoopNesting();
 
       // If the test is never true and has no side effects there is no need
       // to compile the test or body.
       if (info == ALWAYS_FALSE) break;
 
       // Label the top of the loop with the continue target for the backward
       // CFG edge.
+      node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
       node->continue_target()->Bind();
 
       // If the test is always true and has no side effects there is no need
       // to compile it.  We only compile the test when we do not know its
       // outcome or it may have side effects.
       if (info == DONT_KNOW) {
         JumpTarget body(this);
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                       &body, node->break_target(), true);
         if (body.is_linked()) {
           body.Bind();
         }
       }
 
       if (has_valid_frame()) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         // If control flow can fall out of the body, jump back to the top.
         if (has_valid_frame()) {
           node->continue_target()->Jump();
         }
       }
       break;
     }
 
     case LoopStatement::FOR_LOOP: {
-      JumpTarget loop(this);
+      JumpTarget loop(this, JumpTarget::BIDIRECTIONAL);
       if (node->init() != NULL) {
         Visit(node->init());
       }
 
       IncrementLoopNesting();
       // If the test is never true and has no side effects there is no need
       // to compile the test or body.
       if (info == ALWAYS_FALSE) break;
 
       // Label the top of the loop for the backward CFG edge.  If there is
       // no update expression we can use the continue target.
       if (node->next() == NULL) {
+        node->continue_target()->Initialize(this, JumpTarget::BIDIRECTIONAL);
         node->continue_target()->Bind();
       } else {
+        node->continue_target()->Initialize(this);
         loop.Bind();
       }
 
       // If the test is always true and has no side effects there is no need
       // to compile it.  We only compile the test when we do not know its
       // outcome or it has side effects.
       if (info == DONT_KNOW) {
         JumpTarget body(this);
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                       &body, node->break_target(), true);
@@ skipping 46 matching lines @@
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ ForInStatement");
   CodeForStatement(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);
+  node->break_target()->Initialize(this);
+  node->continue_target()->Initialize(this);
 
   JumpTarget primitive(this);
   JumpTarget jsobject(this);
   JumpTarget fixed_array(this);
-  JumpTarget entry(this);
+  JumpTarget entry(this, JumpTarget::BIDIRECTIONAL);
   JumpTarget end_del_check(this);
   JumpTarget cleanup(this);
   JumpTarget exit(this);
 
   // 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);
@@ skipping 1315 matching lines @@
 // 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 not_a_cons_string_either(this);
-  JumpTarget try_again_with_new_string(this);
+  JumpTarget try_again_with_new_string(this, JumpTarget::BIDIRECTIONAL);
   JumpTarget ascii_string(this);
   JumpTarget got_char_code(this);
 
   // Load the string into eax and the index into ebx.
   LoadAndSpill(args->at(0));
   LoadAndSpill(args->at(1));
   frame_->EmitPop(ebx);
   frame_->EmitPop(eax);
   // If the receiver is a smi return undefined.
   ASSERT(kSmiTag == 0);
@@ skipping 2706 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal