MIPS: arch-independent changes to support mips.

src/mark-compact.cc

 // Copyright 2011 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 2589 matching lines @@
 
 // -------------------------------------------------------------------------
 // Phase 3: Update pointers
 
 // Helper class for updating pointers in HeapObjects.
 class UpdatingVisitor: public ObjectVisitor {
  public:
   explicit UpdatingVisitor(Heap* heap) : heap_(heap) {}
 
   void VisitPointer(Object** p) {
-    UpdatePointer(p);
+    UpdatePointer(p, NULL);
+  }
+
+  void VisitPointer(Object** p, RelocInfo* rinfo) {
+    // Variant of UpdatePointer, for arch's where RelocInfo is needed.
+    UpdatePointer(p, rinfo);
   }
 
   void VisitPointers(Object** start, Object** end) {
     // Mark all HeapObject pointers in [start, end)
-    for (Object** p = start; p < end; p++) UpdatePointer(p);
+    for (Object** p = start; p < end; p++) UpdatePointer(p, NULL);
   }
 
   void VisitCodeTarget(RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Object* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
     VisitPointer(&target);
     rinfo->set_target_address(
         reinterpret_cast<Code*>(target)->instruction_start());
   }
 
   void VisitDebugTarget(RelocInfo* rinfo) {
     ASSERT((RelocInfo::IsJSReturn(rinfo->rmode()) &&
             rinfo->IsPatchedReturnSequence()) ||
            (RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
             rinfo->IsPatchedDebugBreakSlotSequence()));
     Object* target = Code::GetCodeFromTargetAddress(rinfo->call_address());
     VisitPointer(&target);
     rinfo->set_call_address(
         reinterpret_cast<Code*>(target)->instruction_start());
   }
 
   inline Heap* heap() const { return heap_; }
 
  private:
-  void UpdatePointer(Object** p) {
+  void UpdatePointer(Object** p, RelocInfo* rinfo) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* obj = HeapObject::cast(*p);
     Address old_addr = obj->address();
     Address new_addr;
     ASSERT(!heap()->InFromSpace(obj));
 
     if (heap()->new_space()->Contains(obj)) {
       Address forwarding_pointer_addr =
           heap()->new_space()->FromSpaceLow() +
@@ skipping 25 matching lines @@
         original_space = spaces.next();
       }
       ASSERT(original_space != NULL);
 #endif
       new_addr = MarkCompactCollector::GetForwardingAddressInOldSpace(obj);
       ASSERT(original_space->Contains(new_addr));
       ASSERT(original_space->MCSpaceOffsetForAddress(new_addr) <=
              original_space->MCSpaceOffsetForAddress(old_addr));
     }
 
-    *p = HeapObject::FromAddress(new_addr);
+    if (rinfo) {
+      // For arch (like mips) without natural pointers in embedded code
+      // objects, rinfo->set_target_object() allows proper pointer update.
+      rinfo->set_target_object(HeapObject::FromAddress(new_addr));
+    } else {
+      // Do normal indirect pointer update when there is no reloc info.
+      *p = HeapObject::FromAddress(new_addr);
+    }
 
 #ifdef DEBUG
     if (FLAG_gc_verbose) {
       PrintF("update %p : %p -> %p\n",
              reinterpret_cast<Address>(p), old_addr, new_addr);
     }
 #endif
   }
 
   Heap* heap_;
@@ skipping 432 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal