Change the register allocator so that it no longer tracks references...

src/ia32/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 66 matching lines @@
   if (is_bound()) {
     ASSERT(direction_ == BIDIRECTIONAL);
     // Backward branch.  We have an expected frame to merge to on the
     // backward edge.
 
     // Swap the current frame for a copy (we do the swapping to get
     // the off-frame registers off the fall through) to use for the
     // branch.
     VirtualFrame* fall_through_frame = cgen()->frame();
     VirtualFrame* branch_frame = new VirtualFrame(fall_through_frame);
-    RegisterFile non_frame_registers = RegisterAllocator::Reserved();
+    RegisterFile non_frame_registers;
     cgen()->SetFrame(branch_frame, &non_frame_registers);
 
     // Check if we can avoid merge code.
     cgen()->frame()->PrepareMergeTo(entry_frame_);
     if (cgen()->frame()->Equals(entry_frame_)) {
       // Branch right in to the block.
       cgen()->DeleteFrame();
       __ j(cc, &entry_label_, hint);
       cgen()->SetFrame(fall_through_frame, &non_frame_registers);
       return;
@@ skipping 74 matching lines @@
   // block.
   ASSERT(!cgen()->has_valid_frame() || cgen()->HasValidEntryRegisters());
 
   // Fast case: the jump target was manually configured with an entry
   // frame to use.
   if (entry_frame_ != NULL) {
     // Assert no reaching frames to deal with.
     ASSERT(reaching_frames_.is_empty());
     ASSERT(!cgen()->has_valid_frame());
 
-    RegisterFile reserved = RegisterAllocator::Reserved();
+    RegisterFile empty;
     if (direction_ == BIDIRECTIONAL) {
       // Copy the entry frame so the original can be used for a
       // possible backward jump.
-      cgen()->SetFrame(new VirtualFrame(entry_frame_), &reserved);
+      cgen()->SetFrame(new VirtualFrame(entry_frame_), &empty);
     } else {
       // Take ownership of the entry frame.
-      cgen()->SetFrame(entry_frame_, &reserved);
+      cgen()->SetFrame(entry_frame_, &empty);
       entry_frame_ = NULL;
     }
     __ bind(&entry_label_);
     return;
   }
 
   if (!is_linked()) {
     ASSERT(cgen()->has_valid_frame());
     if (direction_ == FORWARD_ONLY) {
       // Fast case: no forward jumps and no possible backward jumps.
       // The stack pointer can be floating above the top of the
       // virtual frame before the bind.  Afterward, it should not.
       VirtualFrame* frame = cgen()->frame();
-      int difference =
-          frame->stack_pointer_ - (frame->elements_.length() - 1);
+      int difference = frame->stack_pointer_ - (frame->element_count() - 1);
       if (difference > 0) {
         frame->stack_pointer_ -= difference;
         __ add(Operand(esp), Immediate(difference * kPointerSize));
       }
     } else {
       ASSERT(direction_ == BIDIRECTIONAL);
       // Fast case: no forward jumps, possible backward ones.  Remove
       // constants and copies above the watermark on the fall-through
       // frame and use it as the entry frame.
       cgen()->frame()->MakeMergable(mergable_elements);
       entry_frame_ = new VirtualFrame(cgen()->frame());
     }
     __ bind(&entry_label_);
     return;
   }
 
   if (direction_ == FORWARD_ONLY &&
       !cgen()->has_valid_frame() &&
       reaching_frames_.length() == 1) {
     // Fast case: no fall-through, a single forward jump, and no
     // possible backward jumps.  Pick up the only reaching frame, take
     // ownership of it, and use it for the block about to be emitted.
     VirtualFrame* frame = reaching_frames_[0];
-    RegisterFile reserved = RegisterAllocator::Reserved();
-    cgen()->SetFrame(frame, &reserved);
+    RegisterFile empty;
+    cgen()->SetFrame(frame, &empty);
     reaching_frames_[0] = NULL;
     __ bind(&merge_labels_[0]);
 
     // The stack pointer can be floating above the top of the
     // virtual frame before the bind.  Afterward, it should not.
-    int difference =
-        frame->stack_pointer_ - (frame->elements_.length() - 1);
+    int difference = frame->stack_pointer_ - (frame->element_count() - 1);
     if (difference > 0) {
       frame->stack_pointer_ -= difference;
       __ add(Operand(esp), Immediate(difference * kPointerSize));
     }
 
     __ bind(&entry_label_);
     return;
   }
 
   // If there is a current frame, record it as the fall-through.  It
@@ skipping 37 matching lines @@
           // We could have a valid frame as the fall through to the
           // binding site or as the fall through from a previous merge
           // code block.  Jump around the code we are about to
           // generate.
           if (cgen()->has_valid_frame()) {
             cgen()->DeleteFrame();
             __ jmp(&entry_label_);
           }
           // Pick up the frame for this block.  Assume ownership if
           // there cannot be backward jumps.
-          RegisterFile reserved = RegisterAllocator::Reserved();
+          RegisterFile empty;
           if (direction_ == BIDIRECTIONAL) {
-            cgen()->SetFrame(new VirtualFrame(frame), &reserved);
+            cgen()->SetFrame(new VirtualFrame(frame), &empty);
           } else {
-            cgen()->SetFrame(frame, &reserved);
+            cgen()->SetFrame(frame, &empty);
             reaching_frames_[i] = NULL;
           }
           __ bind(&merge_labels_[i]);
 
           // Loop over the remaining (non-null) reaching frames,
           // looking for any that can share merge code with this one.
           for (int j = 0; j < i; j++) {
             VirtualFrame* other = reaching_frames_[j];
             if (other != NULL && other->Equals(cgen()->frame())) {
               // Set the reaching frame element to null to avoid
               // processing it later, and then bind its entry label.
               reaching_frames_[j] = NULL;
               __ bind(&merge_labels_[j]);
             }
           }
 
           // Emit the merge code.
           cgen()->frame()->MergeTo(entry_frame_);
         } else if (i == reaching_frames_.length() - 1 && had_fall_through) {
           // If this is the fall through frame, and it didn't need
           // merge code, we need to pick up the frame so we can jump
           // around subsequent merge blocks if necessary.
-          RegisterFile reserved = RegisterAllocator::Reserved();
-          cgen()->SetFrame(frame, &reserved);
+          RegisterFile empty;
+          cgen()->SetFrame(frame, &empty);
           reaching_frames_[i] = NULL;
         }
       }
     }
 
     // The code generator may not have a current frame if there was no
     // fall through and none of the reaching frames needed merging.
     // In that case, clone the entry frame as the current frame.
     if (!cgen()->has_valid_frame()) {
-      RegisterFile reserved_registers = RegisterAllocator::Reserved();
-      cgen()->SetFrame(new VirtualFrame(entry_frame_), &reserved_registers);
+      RegisterFile empty;
+      cgen()->SetFrame(new VirtualFrame(entry_frame_), &empty);
     }
 
     // There may be unprocessed reaching frames that did not need
     // merge code.  They will have unbound merge labels.  Bind their
     // merge labels to be the same as the entry label and deallocate
     // them.
     for (int i = 0; i < reaching_frames_.length(); i++) {
       if (!merge_labels_[i].is_bound()) {
         reaching_frames_[i] = NULL;
         __ bind(&merge_labels_[i]);
       }
     }
 
     // There are non-NULL reaching frames with bound labels for each
     // merge block, but only on backward targets.
   } else {
     // There were no forward jumps.  There must be a current frame and
     // this must be a bidirectional target.
     ASSERT(reaching_frames_.length() == 1);
     ASSERT(reaching_frames_[0] != NULL);
     ASSERT(direction_ == BIDIRECTIONAL);
 
     // Use a copy of the reaching frame so the original can be saved
     // for possible reuse as a backward merge block.
-    RegisterFile reserved = RegisterAllocator::Reserved();
-    cgen()->SetFrame(new VirtualFrame(reaching_frames_[0]), &reserved);
+    RegisterFile empty;
+    cgen()->SetFrame(new VirtualFrame(reaching_frames_[0]), &empty);
     __ bind(&merge_labels_[0]);
     cgen()->frame()->MergeTo(entry_frame_);
   }
 
   __ bind(&entry_label_);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal