Experimental: introduce a simple mechanism to allow jump targets with...

src/jump-target.cc

 // Copyright 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 121 matching lines @@
     } else {
       return right;
     }
   }
 
   // Otherwise they are incompatible and we will reallocate them.
   return NULL;
 }
 
 
-void JumpTarget::ComputeEntryFrame() {
+void JumpTarget::ComputeEntryFrame(int mergable_elements) {
   // Given: a collection of frames reaching by forward CFG edges
   // (including the code generator's current frame) and the
   // directionality of the block.  Compute: an entry frame for the
   // block.
 
   // Choose an initial frame, either the code generator's current
   // frame if there is one, or the first reaching frame if not.
   VirtualFrame* initial_frame = cgen_->frame();
   int start_index = 0;  // Begin iteration with the 1st reaching frame.
   if (initial_frame == NULL) {
     initial_frame = reaching_frames_[0];
     start_index = 1;  // Begin iteration with the 2nd reaching frame.
   }
 
   // A list of pointers to frame elements in the entry frame.  NULL
   // indicates that the element has not yet been determined.
   int length = initial_frame->elements_.length();
   List<FrameElement*> elements(length);
 
+  // Convert the number of mergable elements (counted from the top
+  // down) to a frame high-water mark (counted from the bottom up).
+  // Elements strictly above the high-water index will be mergable in
+  // entry frames for bidirectional jump targets.
+  int high_water_mark = (mergable_elements == kAllElements)
+      ? VirtualFrame::kIllegalIndex  // All frame indices are above this.
+      : length - mergable_elements - 1;  // Top index if m_e == 0.
+
   // Initially populate the list of elements based on the initial
   // frame.
   for (int i = 0; i < length; i++) {
     FrameElement element = initial_frame->elements_[i];
     // We do not allow copies or constants in bidirectional frames.
     if (direction_ == BIDIRECTIONAL &&
+        i > high_water_mark &&
         (element.is_constant() || element.is_copy())) {
       elements.Add(NULL);
     } else {
       elements.Add(&initial_frame->elements_[i]);
     }
   }
 
   // Compute elements based on the other reaching frames.
   if (start_index < reaching_frames_.length()) {
     for (int i = 0; i < length; i++) {
@@ skipping 255 matching lines @@
   ASSERT_ARGCHECK(arg0);
   ASSERT_ARGCHECK(arg1);
   ASSERT_ARGCHECK(arg2);
   ASSERT_ARGCHECK(arg3);
 }
 
 #undef DECLARE_ARGCHECK_VARS
 #undef ASSERT_ARGCHECK
 
 
-void JumpTarget::Bind(Result* arg) {
+void JumpTarget::Bind(Result* arg, int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg);
   }
-  Bind();
+  Bind(mergable_elements);
   *arg = cgen_->frame()->Pop();
 }
 
 
-void JumpTarget::Bind(Result* arg0, Result* arg1) {
+void JumpTarget::Bind(Result* arg0, Result* arg1, int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg0);
     cgen_->frame()->Push(arg1);
   }
-  Bind();
+  Bind(mergable_elements);
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
-void JumpTarget::Bind(Result* arg0, Result* arg1, Result* arg2) {
+void JumpTarget::Bind(Result* arg0,
+                      Result* arg1,
+                      Result* arg2,
+                      int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg0);
     cgen_->frame()->Push(arg1);
     cgen_->frame()->Push(arg2);
   }
-  Bind();
+  Bind(mergable_elements);
   *arg2 = cgen_->frame()->Pop();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
-void JumpTarget::Bind(Result* arg0, Result* arg1, Result* arg2, Result* arg3) {
+void JumpTarget::Bind(Result* arg0,
+                      Result* arg1,
+                      Result* arg2,
+                      Result* arg3,
+                      int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg0);
     cgen_->frame()->Push(arg1);
     cgen_->frame()->Push(arg2);
     cgen_->frame()->Push(arg3);
   }
-  Bind();
+  Bind(mergable_elements);
   *arg3 = cgen_->frame()->Pop();
   *arg2 = cgen_->frame()->Pop();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
 void JumpTarget::CopyTo(JumpTarget* destination) {
   ASSERT(destination != NULL);
   destination->cgen_ = cgen_;
@@ skipping 62 matching lines @@
   temp.CopyTo(this);
   temp.Reset();  // So the destructor does not deallocate virtual frames.
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 
 } }  // namespace v8::internal