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

src/jump-target.h

 // 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 65 matching lines @@
   CodeGenerator* code_generator() const { return cgen_; }
 
   Label* entry_label() { return &entry_label_; }
 
   VirtualFrame* expected_frame() const { return expected_frame_; }
   void set_expected_frame(VirtualFrame* frame) {
     expected_frame_ = frame;
   }
 
   // Predicates testing the state of the encapsulated label.
-  bool is_bound() const { return expected_frame_ != NULL; }
-  bool is_linked() const { return reaching_frames_.length() > 0; }
+  bool is_bound() const { return is_bound_; }
+  bool is_linked() const { return is_linked_; }
   bool is_unused() const { return !is_bound() && !is_linked(); }
 
   // Treat the jump target as a fresh one.  The expected frame if any
   // will be deallocated and there should be no dangling jumps to the
   // target (thus no reaching frames).
-  void Unuse() {
-    ASSERT(!is_linked());
-    entry_label_.Unuse();
-    delete expected_frame_;
-    expected_frame_ = NULL;
-  }
+  void Unuse();
 
   // Reset the internal state of this jump target.  Pointed-to virtual
   // frames are not deallocated and dangling jumps to the target are
   // left dangling.
-  void Reset() {
-    reaching_frames_.Clear();
-    merge_labels_.Clear();
-    expected_frame_ = NULL;
-    entry_label_.Unuse();
-  }
+  void Reset();
 
   // Copy the state of this jump target to the destination.  The lists
   // of forward-reaching frames and merge-point labels are copied.
   // All virtual frame pointers are copied, not the pointed-to frames.
   // The previous state of the destination is overwritten, without
   // deallocating pointed-to virtual frames.
   void CopyTo(JumpTarget* destination);
 
   // Emit a jump to the target.  There must be a current frame at the
   // jump and there will be no current frame after the jump.
@@ skipping 52 matching lines @@
 
   // A parallel list of labels for merge code.
   List<Label> merge_labels_;
 
   // The (mergable) frame expected at backward jumps to the block.
   VirtualFrame* expected_frame_;
 
   // The actual entry label of the block.
   Label entry_label_;
 
+  // A target is bound if its Bind member function has been called.
+  // It is linked if it is not bound but its Jump, Branch, or Call
+  // member functions have been called.
+  bool is_bound_;
+  bool is_linked_;
+
   // Add a virtual frame reaching this labeled block via a forward
   // jump, and a fresh label for its merge code.
   void AddReachingFrame(VirtualFrame* frame);
 
   DISALLOW_COPY_AND_ASSIGN(JumpTarget);
 };
 
 
 // -------------------------------------------------------------------------
 // Shadow jump targets
@@ skipping 35 matching lines @@
   bool is_shadowing_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ShadowTarget);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JUMP_TARGET_H_