Basic implementation of incremental marking.

src/assembler.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 253 matching lines @@
 
   // Is the pointer this relocation info refers to coded like a plain pointer
   // or is it strange in some way (eg relative or patched into a series of
   // instructions).
   bool IsCodedSpecially();
 
   // Read/modify the code target in the branch/call instruction
   // this relocation applies to;
   // can only be called if IsCodeTarget(rmode_) || rmode_ == RUNTIME_ENTRY
   INLINE(Address target_address());
-  INLINE(void set_target_address(Address target));
+  INLINE(void set_target_address(Address target, Code* code));

[Erik Corry, 2011/02/22 12:27:19]

Could you use GetCodeFromTargetAddress instead of adding an argument?

Actually it seems that they are not the same object.  Perhaps a better name than
'code' can be found.

[Vyacheslav Egorov (Chromium), 2011/02/23 14:31:46]

Done.

   INLINE(Object* target_object());
   INLINE(Handle<Object> target_object_handle(Assembler* origin));
   INLINE(Object** target_object_address());
-  INLINE(void set_target_object(Object* target));
+  INLINE(void set_target_object(Object* target, Code* code));
   INLINE(JSGlobalPropertyCell* target_cell());
   INLINE(Handle<JSGlobalPropertyCell> target_cell_handle());
-  INLINE(void set_target_cell(JSGlobalPropertyCell* cell));
+  INLINE(void set_target_cell(JSGlobalPropertyCell* cell, Code* code));
 
 
   // Read the address of the word containing the target_address in an
   // instruction stream.  What this means exactly is architecture-independent.
   // The only architecture-independent user of this function is the serializer.
   // The serializer uses it to find out how many raw bytes of instruction to
   // output before the next target.  Architecture-independent code shouldn't
   // dereference the pointer it gets back from this.
   INLINE(Address target_address_address());
   // This indicates how much space a target takes up when deserializing a code
@@ skipping 222 matching lines @@
   explicit ExternalReference(StatsCounter* counter);
 
   explicit ExternalReference(Top::AddressId id);
 
   explicit ExternalReference(const SCTableReference& table_ref);
 
   // One-of-a-kind references. These references are not part of a general
   // pattern. This means that they have to be added to the
   // ExternalReferenceTable in serialize.cc manually.
 
+  static ExternalReference incremental_marking_record_write_function();
   static ExternalReference perform_gc_function();
   static ExternalReference fill_heap_number_with_random_function();
   static ExternalReference random_uint32_function();
   static ExternalReference transcendental_cache_array_address();
   static ExternalReference delete_handle_scope_extensions();
 
   // Deoptimization support.
   static ExternalReference new_deoptimizer_function();
   static ExternalReference compute_output_frames_function();
   static ExternalReference global_contexts_list();
@@ skipping 241 matching lines @@
   return num_bits_set;
 }
 
 // Computes pow(x, y) with the special cases in the spec for Math.pow.
 double power_double_int(double x, int y);
 double power_double_double(double x, double y);
 
 } }  // namespace v8::internal
 
 #endif  // V8_ASSEMBLER_H_