Polish code of VirtualFrame::MoveMemoryToRegister

src/ia32/virtual-frame-ia32.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 406 matching lines @@
 void VirtualFrame::MergeMoveMemoryToRegisters(VirtualFrame* expected) {
   // Move memory, constants, and copies to registers.  This is the
   // final step and is done from the bottom up so that the backing
   // elements of copies are in their correct locations when we
   // encounter the copies.
   for (int i = 0; i < kNumRegisters; i++) {
     int index = expected->register_locations_[i];
     if (index != kIllegalIndex) {
       FrameElement source = elements_[index];
       FrameElement target = expected->elements_[index];
+      Register target_reg = { i };
+      ASSERT(expected->elements_[index].reg().is(target_reg));
       switch (source.type()) {
         case FrameElement::INVALID:  // Fall through.
           UNREACHABLE();
           break;
         case FrameElement::REGISTER:
-          ASSERT(source.reg().is(target.reg()));
-          continue;  // Go to next iteration.  Skips Use(target.reg()) below.
+          ASSERT(source.reg().is(target_reg));
+          continue;  // Go to next iteration.  Skips Use(target_reg) below.
           break;
         case FrameElement::MEMORY:
           ASSERT(index <= stack_pointer_);
-          __ mov(target.reg(), Operand(ebp, fp_relative(index)));
+          __ mov(target_reg, Operand(ebp, fp_relative(index)));
           break;
 
         case FrameElement::CONSTANT:
           if (cgen_->IsUnsafeSmi(source.handle())) {
-            cgen_->LoadUnsafeSmi(target.reg(), source.handle());
+            cgen_->LoadUnsafeSmi(target_reg, source.handle());
           } else {
-           __ Set(target.reg(), Immediate(source.handle()));
+           __ Set(target_reg, Immediate(source.handle()));
           }
           break;
 
         case FrameElement::COPY: {
           int backing_index = source.index();
           FrameElement backing = elements_[backing_index];
           ASSERT(backing.is_memory() || backing.is_register());
           if (backing.is_memory()) {
             ASSERT(backing_index <= stack_pointer_);
             // Code optimization if backing store should also move
             // to a register: move backing store to its register first.
             if (expected->elements_[backing_index].is_register()) {
               FrameElement new_backing = expected->elements_[backing_index];
               Register new_backing_reg = new_backing.reg();
               ASSERT(!is_used(new_backing_reg));
               elements_[backing_index] = new_backing;
               Use(new_backing_reg, backing_index);
               __ mov(new_backing_reg,
                      Operand(ebp, fp_relative(backing_index)));
-              __ mov(target.reg(), new_backing_reg);
+              __ mov(target_reg, new_backing_reg);
             } else {
-              __ mov(target.reg(), Operand(ebp, fp_relative(backing_index)));
+              __ mov(target_reg, Operand(ebp, fp_relative(backing_index)));
             }
           } else {
-            __ mov(target.reg(), backing.reg());
+            __ mov(target_reg, backing.reg());
           }
         }
       }
       // Ensure the proper sync state.  If the source was memory no
       // code needs to be emitted.
       if (target.is_synced() && !source.is_synced()) {
-        __ mov(Operand(ebp, fp_relative(index)), target.reg());
+        __ mov(Operand(ebp, fp_relative(index)), target_reg);
       }
-      Use(target.reg(), index);
+      Use(target_reg, index);
       elements_[index] = target;
     }
   }
 }
 
 
 void VirtualFrame::Enter() {
   // Registers live on entry: esp, ebp, esi, edi.
   Comment cmnt(masm_, "[ Enter JS frame");
 
@@ skipping 630 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal