Modify JumpTarget::ComputeEntryFrame to mark copied elements...

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 177 matching lines @@
       }
     }
   }
 
   // Build the new frame.  A freshly allocated frame has memory elements
   // for the parameters and some platform-dependent elements (e.g.,
   // return address).  Replace those first.
   entry_frame_ = new VirtualFrame(cgen_);
   int index = 0;
   for (; index < entry_frame_->elements_.length(); index++) {
-    // If the element is determined, set it now and count registers.
-    // Undetermined elements are initially recorded as if in memory.
+    // If the element is determined, set it now.  Count registers.
+    // Mark elements as copied exactly if they are.  Undetermined
+    // elements are initially recorded as if in memory.
     if (elements[index] != NULL) {
       entry_frame_->elements_[index] = *elements[index];
+      entry_frame_->elements_[index].clear_copied();
       if (elements[index]->is_register()) {
         entry_frame_->register_locations_[elements[index]->reg().code()] =
             index;
+      } else if (elements[index]->is_copy()) {
+        entry_frame_->elements_[elements[index]->index()].set_copied();
       }
     }
   }
   // Then fill in the rest of the frame with new elements.
   for (; index < length; index++) {
     if (elements[index] == NULL) {
       entry_frame_->elements_.Add(FrameElement::MemoryElement());
     } else {
       entry_frame_->elements_.Add(*elements[index]);
+      entry_frame_->elements_[index].clear_copied();
       if (elements[index]->is_register()) {
         entry_frame_->register_locations_[elements[index]->reg().code()] =
             index;
+      } else if (elements[index]->is_copy()) {
+        entry_frame_->elements_[elements[index]->index()].set_copied();
       }
     }
   }
 
   // Allocate any still-undetermined frame elements to registers or
   // memory, from the top down.
   for (int i = length - 1; i >= 0; i--) {
     if (elements[i] == NULL) {
       // If the value is synced on all frames, put it in memory.  This
       // costs nothing at the merge code but will incur a
@@ skipping 27 matching lines @@
       // If there was no preferred choice consider any free register.
       if (best_reg_code == no_reg.code_) {
         for (int j = 0; j < kNumRegisters; j++) {
           if (!entry_frame_->is_used(j) && !RegisterAllocator::IsReserved(j)) {
             best_reg_code = j;
             break;
           }
         }
       }
 
-      // If there was a register choice, use it.  If not do nothing
-      // (the element is already recorded as in memory)
       if (best_reg_code != no_reg.code_) {
+        // If there was a register choice, use it.  Preserve the copied
+        // flag on the element.
+        bool is_copied = entry_frame_->elements_[i].is_copied();
         Register reg = { best_reg_code };
         entry_frame_->elements_[i] =
             FrameElement::RegisterElement(reg,
                                           FrameElement::NOT_SYNCED);
+        if (is_copied) entry_frame_->elements_[i].set_copied();
         entry_frame_->register_locations_[best_reg_code] = i;
       }
+      // If there was no register found, the element is already
+      // recorded as in memory.
     }
   }
 
-  // Set the copied flags in the frame to be exact.  This assumes that
-  // the backing store of copies is always lower in the frame.
+  // Set the static type of frame elements.
   for (int i = 0; i < length; i++) {
     FrameElement* current = &entry_frame_->elements_[i];
-    current->clear_copied();
-    if (current->is_copy()) {
-      entry_frame_->elements_[current->index()].set_copied();
-    }
-
     if (direction_ == BIDIRECTIONAL && i >= high_water_mark) {
       current->set_static_type(StaticType::unknown());
     } else {
       StaticType merged_type = reaching_frames_[0]->elements_[i].static_type();
       for (int j = 1, n = reaching_frames_.length();
            !merged_type.is_unknown() && j < n;
            j++) {
         merged_type =
             merged_type.merge(reaching_frames_[j]->elements_[i].static_type());
       }
@@ skipping 430 matching lines @@
   temp.CopyTo(this);
   temp.Reset();  // So the destructor does not deallocate virtual frames.
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 
 } }  // namespace v8::internal