Fix memory leak caused by treating Code::next_code_link as strong in marker.

src/objects.h

 // 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 287 matching lines @@
 // that piggy-back on marking can use the parity to ensure that they only
 // perform an operation on an object once per marking phase: they record the
 // MarkingParity when they visit an object, and only re-visit the object when it
 // is marked again and the MarkingParity changes.
 enum MarkingParity {
   NO_MARKING_PARITY,
   ODD_MARKING_PARITY,
   EVEN_MARKING_PARITY
 };
 
+
 // ICs store extra state in a Code object. The default extra state is
 // kNoExtraICState.
 typedef int ExtraICState;
 static const ExtraICState kNoExtraICState = 0;
 
 // Instance size sentinel for objects of variable size.
 const int kVariableSizeSentinel = 0;
 
 const int kStubMajorKeyBits = 7;
 const int kStubMinorKeyBits = kBitsPerInt - kSmiTagSize - kStubMajorKeyBits;
@@ skipping 10360 matching lines @@
   enum SyncTag {
     VISITOR_SYNCHRONIZATION_TAGS_LIST(DECLARE_ENUM)
     kNumberOfSyncTags
   };
 #undef DECLARE_ENUM
 
   static const char* const kTags[kNumberOfSyncTags];
   static const char* const kTagNames[kNumberOfSyncTags];
 };
 
+
+enum WeakPointerMode {

[Michael Starzinger, 2014/03/04 12:31:12]

As discussed offline: I am not a particular fan of having this mode, because it
assumes that all visitors either visit _all_ or _none_ weak pointers and I am
not sure this hold in general.

Alternatively I would suggest having a special visitor method (e.g.
VisitCodeNextPointer) that the concrete visitor can override to handle this slot
specially. This could be applied to both, the virtual as well as the static
visitor I think.

[ulan, 2014/03/06 11:13:32]

Done. Thanks for suggestion, it is cleaner indeed.

+  VISIT_WEAK_POINTERS,
+  SKIP_WEAK_POINTERS
+};
+
+
 // Abstract base class for visiting, and optionally modifying, the
 // pointers contained in Objects. Used in GC and serialization/deserialization.
 class ObjectVisitor BASE_EMBEDDED {
  public:
   virtual ~ObjectVisitor() {}
 
   // Visits a contiguous arrays of pointers in the half-open range
   // [start, end). Any or all of the values may be modified on return.
   virtual void VisitPointers(Object** start, Object** end) = 0;
 
@@ skipping 37 matching lines @@
   // Visits an external reference. The value may be modified on return.
   virtual void VisitExternalReference(Address* p) {}
 
   // Visits a handle that has an embedder-assigned class ID.
   virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
 
   // Intended for serialization/deserialization checking: insert, or
   // check for the presence of, a tag at this position in the stream.
   // Also used for marking up GC roots in heap snapshots.
   virtual void Synchronize(VisitorSynchronization::SyncTag tag) {}
+
+  virtual WeakPointerMode weak_pointer_mode() { return VISIT_WEAK_POINTERS; }
 };
 
 
 class StructBodyDescriptor : public
   FlexibleBodyDescriptor<HeapObject::kHeaderSize> {
  public:
   static inline int SizeOf(Map* map, HeapObject* object) {
     return map->instance_size();
   }
 };
@@ skipping 21 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_