Fix CopyCode to properly record object pointer writes.

src/heap.cc

 // Copyright 2012 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 3844 matching lines @@
 
   // Copy code object.
   Address old_addr = code->address();
   Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
   CopyBlock(new_addr, old_addr, obj_size);
   // Relocate the copy.
   Code* new_code = Code::cast(result);
   ASSERT(!isolate_->code_range()->exists() ||
       isolate_->code_range()->contains(code->address()));
   new_code->Relocate(new_addr - old_addr);
+
+  // Make sure new object is handled properly by the GC.
+  incremental_marking()->RecordWrites(new_code);

[Michael Starzinger, 2013/05/14 16:43:10]

So I looked into this write-barrier and I don't think we need one here. The
reasons for this are the following ...

1) All objects reachable from the code object header are pretenured and hence
cannot be in new-space. That's why the assertion in Heap::RecordWrites that the
address is not in code-space makes sense.

2) The newly allocated code object is guaranteed to still be white after we
copied over it's contents. So we couldn't have introduced black-to-white
pointers with the block copy.

3) The newly allocated code object will eventually be scanned by the marker
before a GC (it's still white) and hence all slots that point into evacuation
candidates will be discovered.

+  //  RecordWrites(new_code->address(), 0, Code::kHeaderSize);
+
   return new_code;
 }
 
 
 MaybeObject* Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
   // Allocate ByteArray before the Code object, so that we do not risk
   // leaving uninitialized Code object (and breaking the heap).
   Object* reloc_info_array;
   { MaybeObject* maybe_reloc_info_array =
         AllocateByteArray(reloc_info.length(), TENURED);
@@ skipping 4001 matching lines @@
   if (FLAG_parallel_recompilation) {
     heap_->relocation_mutex_->Lock();
 #ifdef DEBUG
     heap_->relocation_mutex_locked_by_optimizer_thread_ =
         heap_->isolate()->optimizing_compiler_thread()->IsOptimizerThread();
 #endif  // DEBUG
   }
 }
 
 } }  // namespace v8::internal