Experimental: handle single-entry basic blocks as a special case....

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 1425 matching lines @@
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ Block");
   CodeForStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
   node->break_target()->Initialize(this);
   VisitStatements(node->statements());
-  if (node->break_target()->is_linked()) {
-    node->break_target()->Bind();
-  }
+  node->break_target()->Bind();
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   VirtualFrame::SpilledScope spilled_scope(this);
   frame_->EmitPush(Immediate(pairs));
   frame_->EmitPush(esi);
   frame_->EmitPush(Immediate(Smi::FromInt(is_eval() ? 1 : 0)));
   frame_->CallRuntime(Runtime::kDeclareGlobals, 3);
   // Return value is ignored.
@@ skipping 136 matching lines @@
     // or control flow effect).  LoadCondition is called without
     // forcing control flow.
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &exit, &exit, false);
     if (has_valid_frame()) {
       // Control flow can fall off the end of the condition with a
       // value on the frame.
       frame_->Drop();
     }
   }
 
-  if (exit.is_linked()) {
-    exit.Bind();
-  }
+  exit.Bind();
 }
 
 
 void CodeGenerator::CleanStack(int num_bytes) {
   ASSERT(num_bytes % kPointerSize == 0);
   frame_->Drop(num_bytes / kPointerSize);
 }
 
 
 void CodeGenerator::VisitContinueStatement(ContinueStatement* node) {
@@ skipping 130 matching lines @@
 int CodeGenerator::FastCaseSwitchMinCaseCount() {
     return kFastSwitchMinCaseCount;
 }
 
 
 // Generate a computed jump to a switch case.
 void CodeGenerator::GenerateFastCaseSwitchJumpTable(
     SwitchStatement* node,
     int min_index,
     int range,
-    JumpTarget* fail_label,
-    Vector<JumpTarget*> case_targets,
-    Vector<JumpTarget> case_labels) {
+    Label* default_label,
+    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.
 
-  Result switch_value = frame_->Pop();  // supposed Smi
-  // If value is not in range [0..length-1] then jump to the default/end label.
+  JumpTarget setup_default(this);
+  JumpTarget is_smi(this);
+
+  // 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);
-
-  // Test whether input is a HeapNumber that is really a Smi
-  JumpTarget is_smi(this);
+  Result switch_value = frame_->Pop();
   switch_value.ToRegister();
   __ test(switch_value.reg(), Immediate(kSmiTagMask));
   is_smi.Branch(equal, &switch_value, taken);
-  // It's a heap object, not a Smi or a Failure
+
+  // It's a heap object, not a smi or a failure.  Check if it is a
+  // heap number.
   Result temp = allocator()->Allocate();
   ASSERT(temp.is_valid());
   __ mov(temp.reg(), FieldOperand(switch_value.reg(), HeapObject::kMapOffset));
   __ movzx_b(temp.reg(), FieldOperand(temp.reg(), Map::kInstanceTypeOffset));
   __ cmp(temp.reg(), HEAP_NUMBER_TYPE);
   temp.Unuse();
-  fail_label->Branch(not_equal);
-  // Result switch_value is a heap number.
+  default_target->Branch(not_equal);
+
+  // The switch value is a heap number.  Convert it to a smi.
   frame_->Push(&switch_value);
   Result smi_value = frame_->CallRuntime(Runtime::kNumberToSmi, 1);
+
   is_smi.Bind(&smi_value);
   smi_value.ToRegister();
-
+  // Convert the switch value to a 0-based table index.
   if (min_index != 0) {
     frame_->Spill(smi_value.reg());
     __ sub(Operand(smi_value.reg()), Immediate(min_index << kSmiTagSize));
   }
+  // Go to the default case if the table index is negative or not a smi.
   __ test(smi_value.reg(), Immediate(0x80000000 | kSmiTagMask));
-  // Go to slow case if adjusted index is negative or not a Smi.
-  fail_label->Branch(not_equal, not_taken);
+  default_target->Branch(not_equal, not_taken);
   __ cmp(smi_value.reg(), range << kSmiTagSize);
-  fail_label->Branch(greater_equal, not_taken);
+  default_target->Branch(greater_equal, not_taken);
 
   // 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.
   __ jmp(Operand(smi_value.reg(), smi_value.reg(),
                  times_1, 0x0, RelocInfo::INTERNAL_REFERENCE));
+  smi_value.Unuse();
+
+  // The expected frame at all the case labels is the (mergable
+  // version of the) current one.  Keep a copy to restore at the start
+  // of every label.
+  frame_->MakeMergable();
+  VirtualFrame* start_frame = new VirtualFrame(frame_);
+
   // Calculate address to overwrite later with actual address of table.
   int32_t jump_table_ref = __ pc_offset() - sizeof(int32_t);
-
   __ Align(4);
-  JumpTarget table_start(this);
-  smi_value.Unuse();
-  table_start.Bind();
-  __ WriteInternalReference(jump_table_ref, *table_start.entry_label());
+  Label table_start;
+  __ bind(&table_start);
+  __ WriteInternalReference(jump_table_ref, table_start);
 
   for (int i = 0; i < range; i++) {
     // These are the table entries. 0x0 is the placeholder for case address.
     __ dd(0x0, RelocInfo::INTERNAL_REFERENCE);
   }
 
-  GenerateFastCaseSwitchCases(node, case_labels, &table_start);
+  GenerateFastCaseSwitchCases(node, case_labels, start_frame);
 
-  for (int i = 0, entry_pos = table_start.entry_label()->pos();
+  // If there was a default case, we need to emit the code to match it.
+  if (default_label != NULL) {
+    node->break_target()->Jump();
+    setup_default.Bind();
+    frame_->MergeTo(start_frame);
+    __ jmp(default_label);
+    DeleteFrame();
+  }
+  node->break_target()->Bind();
+
+  for (int i = 0, entry_pos = table_start.pos();
        i < range;
        i++, entry_pos += sizeof(uint32_t)) {
-    __ WriteInternalReference(entry_pos, *case_targets[i]->entry_label());
+    if (case_targets[i] == NULL) {
+      __ WriteInternalReference(entry_pos,
+                                *node->break_target()->entry_label());
+    } else {
+      __ WriteInternalReference(entry_pos, *case_targets[i]);
+    }
   }
+
+  delete start_frame;
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ SwitchStatement");
   CodeForStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
   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::BIDIRECTIONAL);
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
@@ skipping 60 matching lines @@
     Comment cmnt(masm_, "[ Default clause");
     default_entry.Bind();
     VisitStatements(default_clause->statements());
     // If control flow can fall out of the default and there is a case after
     // it, jump to that case's body.
     if (has_valid_frame() && default_exit.is_bound()) {
       default_exit.Jump();
     }
   }
 
-  if (fall_through.is_linked()) {
-    fall_through.Bind();
-  }
-
-  if (node->break_target()->is_linked()) {
-    node->break_target()->Bind();
-  }
+  fall_through.Bind();
+  node->break_target()->Bind();
 }
 
 
 void CodeGenerator::VisitLoopStatement(LoopStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ LoopStatement");
   CodeForStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
   node->break_target()->Initialize(this);
 
@@ skipping 39 matching lines @@
 
       // Compile the test.
       if (info == ALWAYS_TRUE) {
         // If control flow can fall off the end of the body, jump back to
         // the top.
         if (has_valid_frame()) {
           node->continue_target()->Jump();
         }
       } else if (info == ALWAYS_FALSE) {
         // If we had a continue in the body we have to bind its jump target.
-        if (node->continue_target()->is_linked()) {
-          node->continue_target()->Bind();
-        }
+        node->continue_target()->Bind();
       } else {
         ASSERT(info == DONT_KNOW);
         // We have to compile the test expression if it can be reached by
         // control flow falling out of the body or via continue.
-        if (node->continue_target()->is_linked()) {
-          node->continue_target()->Bind();
-        }
+        node->continue_target()->Bind();
         if (has_valid_frame()) {
           LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                         &body, node->break_target(), true);
         }
       }
       break;
     }
 
     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();
-        }
+        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();
         }
@@ skipping 22 matching lines @@
         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);
-        if (body.is_linked()) {
-          body.Bind();
-        }
+        body.Bind();
       }
 
       if (has_valid_frame()) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         if (node->next() == NULL) {
           // If there is no update statement and control flow can fall out
           // of the loop, jump to the continue label.
           if (has_valid_frame()) {
             node->continue_target()->Jump();
           }
         } else {
           // If there is an update statement and control flow can reach it
           // via falling out of the body of the loop or continuing, we
           // compile the update statement.
-          if (node->continue_target()->is_linked()) {
-            node->continue_target()->Bind();
-          }
+          node->continue_target()->Bind();
           if (has_valid_frame()) {
             // 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.
             CodeForStatementPosition(node);
             ASSERT(node->type() == LoopStatement::FOR_LOOP);
             Visit(node->next());
             loop.Jump();
           }
         }
       }
       break;
     }
   }
 
   DecrementLoopNesting();
-  if (node->break_target()->is_linked()) {
-    node->break_target()->Bind();
-  }
+  node->break_target()->Bind();
 }
 
 
 void CodeGenerator::VisitForInStatement(ForInStatement* node) {
   ASSERT(!in_spilled_code());
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ ForInStatement");
   CodeForStatementPosition(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()->Initialize(this);
   node->continue_target()->Initialize(this);
 
   JumpTarget primitive(this);
   JumpTarget jsobject(this);
   JumpTarget fixed_array(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);
 
   // eax: value to be iterated over
@@ skipping 65 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();
   __ mov(eax, frame_->ElementAt(0));  // load the current count
   __ cmp(eax, frame_->ElementAt(1));  // compare to the array length
-  cleanup.Branch(above_equal);
+  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));
 
   // Get the expected map from the stack or a zero map in the
   // permanent slow case eax: current iteration count ebx: i'th entry
   // of the enum cache
   __ mov(edx, frame_->ElementAt(3));
@@ skipping 54 matching lines @@
   VisitAndSpill(node->body());
 
   // Next.
   node->continue_target()->Bind();
   frame_->EmitPop(eax);
   __ add(Operand(eax), Immediate(Smi::FromInt(1)));
   frame_->EmitPush(eax);
   entry.Jump();
 
   // Cleanup.
-  cleanup.Bind();
   node->break_target()->Bind();
   frame_->Drop(5);
 
   // Exit.
   exit.Bind();
 
   break_stack_height_ -= kForInStackSize;
 }
 
 
@@ skipping 349 matching lines @@
     if (else_.is_linked()) {
       exit.Jump();
     }
   }
 
   if (else_.is_linked()) {
     else_.Bind();
     Load(node->else_expression(), typeof_state());
   }
 
-  if (exit.is_linked()) {
-    exit.Bind();
-  }
+  exit.Bind();
 }
 
 
 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.
     frame_->Push(esi);
     frame_->Push(slot->var()->name());
@@ skipping 117 matching lines @@
       // needed (probably the common case).
       frame_->Spill(value.reg());
       int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
       __ RecordWrite(start.reg(), offset, value.reg(), temp.reg());
       // The results start, value, and temp are unused by going out of
       // scope.
     }
 
-    // If we definitely did not jump over the assignment, we do not need
-    // to bind the exit label.  Doing so can defeat peephole
-    // optimization.
-    if (exit.is_linked()) {
-      exit.Bind();
-    }
+    exit.Bind();
   }
 }
 
 
 void CodeGenerator::VisitSlot(Slot* node) {
   Comment cmnt(masm_, "[ Slot");
   LoadFromSlot(node, typeof_state());
 }
 
 
@@ skipping 3468 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal