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

src/jump-target-ia32.cc

 // Copyright 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 24 matching lines @@
 // -------------------------------------------------------------------------
 // JumpTarget implementation.
 
 #define __ masm_->
 
 JumpTarget::JumpTarget(CodeGenerator* cgen, Directionality direction)
     : cgen_(cgen),
       direction_(direction),
       reaching_frames_(0),
       merge_labels_(0),
-      expected_frame_(NULL) {
+      expected_frame_(NULL),
+      is_bound_(false),
+      is_linked_(false) {
   ASSERT(cgen_ != NULL);
   masm_ = cgen_->masm();
 }
 
 
 JumpTarget::JumpTarget()
     : cgen_(NULL),
       masm_(NULL),
       direction_(FORWARD_ONLY),
       reaching_frames_(0),
       merge_labels_(0),
-      expected_frame_(NULL) {
+      expected_frame_(NULL),
+      is_bound_(false),
+      is_linked_(false) {
 }
 
 
 void JumpTarget::Initialize(CodeGenerator* cgen, Directionality direction) {
   ASSERT(cgen != NULL);
   ASSERT(cgen_ == NULL);
   cgen_ = cgen;
   masm_ = cgen->masm();
   direction_ = direction;
 }
 
 
+void JumpTarget::Unuse() {
+  ASSERT(!is_linked());
+  entry_label_.Unuse();
+  delete expected_frame_;
+  expected_frame_ = NULL;
+  is_bound_ = false;
+  is_linked_ = false;
+}
+
+
+void JumpTarget::Reset() {
+  reaching_frames_.Clear();
+  merge_labels_.Clear();
+  expected_frame_ = NULL;
+  entry_label_.Unuse();
+  is_bound_ = false;
+  is_linked_ = false;
+}
+
+
 void JumpTarget::Jump() {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
   // Live non-frame registers are not allowed at unconditional jumps
   // because we have no way of invalidating the corresponding results
   // which are still live in the C++ code.
   ASSERT(cgen_->HasValidEntryRegisters());
 
   if (is_bound()) {
     // Backward jump.  There is an expected frame to merge to.
     ASSERT(direction_ == BIDIRECTIONAL);
     cgen_->frame()->MergeTo(expected_frame_);
     cgen_->DeleteFrame();
     __ jmp(&entry_label_);
   } else {
     // Forward jump.  The current frame is added to the end of the list
     // of frames reaching the target block and a jump to the merge code
     // is emitted.
     AddReachingFrame(cgen_->frame());
     RegisterFile empty;
     cgen_->SetFrame(NULL, &empty);
     __ jmp(&merge_labels_.last());
   }
+
+  is_linked_ = !is_bound_;
 }
 
 
 void JumpTarget::Jump(Result* arg) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
 
   cgen_->frame()->Push(arg);
   Jump();
 }
@@ skipping 50 matching lines @@
     // Restore the frame and its associated non-frame registers.
     cgen_->SetFrame(original_frame, &non_frame_registers);
     __ bind(&original_fall_through);
   } else {
     // Forward branch.  A copy of the current frame is added to the end
     // of the list of frames reaching the target block and a branch to
     // the merge code is emitted.
     AddReachingFrame(new VirtualFrame(cgen_->frame()));
     __ j(cc, &merge_labels_.last(), hint);
   }
+
+  is_linked_ = !is_bound_;
 }
 
 
 #ifdef DEBUG
 #define DECLARE_ARGCHECK_VARS(name)                                \
   Result::Type name##_type = name->type();                         \
   Register name##_reg = name->is_register() ? name->reg() : no_reg
 
 #define ASSERT_ARGCHECK(name)                                \
   ASSERT(name->type() == name##_type);                       \
@@ skipping 118 matching lines @@
   ASSERT(cgen_->has_valid_frame());
   // There are no non-frame references across the call.
   ASSERT(cgen_->HasValidEntryRegisters());
   ASSERT(!is_linked());
 
   cgen_->frame()->SpillAll();
   VirtualFrame* target_frame = new VirtualFrame(cgen_->frame());
   target_frame->Adjust(1);
   AddReachingFrame(target_frame);
   __ call(&merge_labels_.last());
+
+  is_linked_ = !is_bound_;
 }
 
 
 void JumpTarget::Bind() {
   ASSERT(cgen_ != NULL);
-  ASSERT(is_linked() || cgen_->has_valid_frame());
   ASSERT(!is_bound());
 
   if (is_linked()) {
     // There were forward jumps.  A mergable frame is created and all
     // the frames reaching the block via forward jumps are merged to it.
     ASSERT(reaching_frames_.length() == merge_labels_.length());
 
-    // Choose a frame as the basis of the expected frame, and make it
-    // mergable.  If there is a current frame use it, otherwise use the
-    // first in the list (there will be at least one).
-    int start_index = 0;
-    if (cgen_->has_valid_frame()) {
-      // Live non-frame registers are not allowed at the start of a labeled
-      // basic block.
-      ASSERT(cgen_->HasValidEntryRegisters());
+    // A special case is that there was only one jump to the block so
+    // far, no fall-through, and there cannot be another entry because
+    // the block is forward only.  In that case, simply use the single
+    // frame.
+    bool single_entry = (direction_ == FORWARD_ONLY) &&
+                        !cgen_->has_valid_frame() &&
+                        (reaching_frames_.length() == 1);
+    if (single_entry) {
+      // Pick up the only forward reaching frame and bind its merge
+      // label.  No merge code is emitted.
+      RegisterFile reserved_registers = RegisterAllocator::Reserved();
+      cgen_->SetFrame(reaching_frames_[0], &reserved_registers);
+      __ bind(&merge_labels_[0]);
     } else {
-      RegisterFile reserved_registers = RegisterAllocator::Reserved();
-      cgen_->SetFrame(reaching_frames_[start_index], &reserved_registers);
-      __ bind(&merge_labels_[start_index++]);
+      // Otherwise, choose a frame as the basis of the expected frame,
+      // and make it mergable.  If there is a current frame use it,
+      // otherwise use the first in the list (there will be at least
+      // one).
+      int start_index = 0;
+      if (cgen_->has_valid_frame()) {
+        // Live non-frame registers are not allowed at the start of a
+        // labeled basic block.
+        ASSERT(cgen_->HasValidEntryRegisters());
+      } else {
+        RegisterFile reserved_registers = RegisterAllocator::Reserved();
+        cgen_->SetFrame(reaching_frames_[start_index], &reserved_registers);
+        __ bind(&merge_labels_[start_index++]);
+      }
+      cgen_->frame()->MakeMergable();
+      expected_frame_ = new VirtualFrame(cgen_->frame());
+
+      for (int i = start_index; i < reaching_frames_.length(); i++) {
+        cgen_->DeleteFrame();
+        __ jmp(&entry_label_);
+
+        RegisterFile reserved_registers = RegisterAllocator::Reserved();
+        cgen_->SetFrame(reaching_frames_[i], &reserved_registers);
+        __ bind(&merge_labels_[i]);
+
+        cgen_->frame()->MergeTo(expected_frame_);
+      }
+
+      __ bind(&entry_label_);
     }
-    cgen_->frame()->MakeMergable();
-    expected_frame_ = new VirtualFrame(cgen_->frame());
-
-    for (int i = start_index; i < reaching_frames_.length(); i++) {
-      cgen_->DeleteFrame();
-      __ jmp(&entry_label_);
-
-      RegisterFile reserved_registers = RegisterAllocator::Reserved();
-      cgen_->SetFrame(reaching_frames_[i], &reserved_registers);
-      __ bind(&merge_labels_[i]);
-
-      cgen_->frame()->MergeTo(expected_frame_);
-    }
-    __ bind(&entry_label_);
 
     // All but the last reaching virtual frame have been deleted, and
     // the last one is the current frame.
     reaching_frames_.Clear();
     merge_labels_.Clear();
+
   } else {
-    // There were no forward jumps.  There must be a current frame,
-    // which is made mergable and used as the expected frame.
-    ASSERT(cgen_->HasValidEntryRegisters());
-    cgen_->frame()->MakeMergable();
-    expected_frame_ = new VirtualFrame(cgen_->frame());
-    __ bind(&entry_label_);
+    // There were no forward jumps.  If this jump target is not
+    // bidirectional, there is no need to do anything.  For
+    // bidirectional jump targets, the current frame is made mergable
+    // and used for the expected frame.
+    if (direction_ == BIDIRECTIONAL) {
+      ASSERT(cgen_->HasValidEntryRegisters());
+      cgen_->frame()->MakeMergable();
+      expected_frame_ = new VirtualFrame(cgen_->frame());
+      __ bind(&entry_label_);
+    }
   }
+
+  is_linked_ = false;
+  is_bound_ = true;
 }
 
 
 void JumpTarget::Bind(Result* arg) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg);
   }
   Bind();
@@ skipping 53 matching lines @@
   destination->direction_ = direction_;
   destination->reaching_frames_.Clear();
   destination->merge_labels_.Clear();
   ASSERT(reaching_frames_.length() == merge_labels_.length());
   for (int i = 0; i < reaching_frames_.length(); i++) {
     destination->reaching_frames_.Add(reaching_frames_[i]);
     destination->merge_labels_.Add(merge_labels_[i]);
   }
   destination->expected_frame_ = expected_frame_;
   destination->entry_label_ = entry_label_;
+  destination->is_bound_ = is_bound_;
+  destination->is_linked_ = is_linked_;
 }
 
 
 void JumpTarget::AddReachingFrame(VirtualFrame* frame) {
   ASSERT(reaching_frames_.length() == merge_labels_.length());
   Label fresh;
   merge_labels_.Add(fresh);
   reaching_frames_.Add(frame);
 }
 
@@ skipping 41 matching lines @@
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 #undef __
 
 
 } }  // namespace v8::internal