New GC related APIs: Implicit references.

src/global-handles.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 837 matching lines @@
   }
 #endif
   if (length == 0) {
     if (info != NULL) info->Dispose();
     return;
   }
   for (size_t i = 0; i < length; ++i) {
     object_groups_.Add(ObjectGroupConnection(
         UniqueId(reinterpret_cast<intptr_t>(handles[0])), handles[i]));
   }
-  retainer_infos_.Add(ObjectGroupRetainerInfo(
-      UniqueId(reinterpret_cast<intptr_t>(handles[0])), info));
+  for (size_t i = 0; i < length; ++i) {
+    if ((*handles[i])->IsHeapObject()) {
+      representative_objects_.Add(ObjectGroupRepresentativeObject(
+          UniqueId(reinterpret_cast<intptr_t>(handles[0])),
+          reinterpret_cast<HeapObject**>(handles[i])));
+      break;
+    }
+  }
+  if (info != NULL) {
+    retainer_infos_.Add(ObjectGroupRetainerInfo(
+        UniqueId(reinterpret_cast<intptr_t>(handles[0])), info));
+  }
 }
 
 void GlobalHandles::SetObjectGroupId(Object** handle,
                                      UniqueId id) {
   object_groups_.Add(ObjectGroupConnection(id, handle));
 }
 
 
 void GlobalHandles::SetRetainedObjectInfo(UniqueId id,
                                           RetainedObjectInfo* info) {
   retainer_infos_.Add(ObjectGroupRetainerInfo(id, info));
 }
 
 
+void GlobalHandles::SetRepresentativeObject(
+    UniqueId id,
+    HeapObject** representative_object) {
+  representative_objects_.Add(
+      ObjectGroupRepresentativeObject(id, representative_object));
+}
+
+
 void GlobalHandles::AddImplicitReferences(HeapObject** parent,
                                           Object*** children,
                                           size_t length) {
 #ifdef DEBUG
   ASSERT(!Node::FromLocation(BitCast<Object**>(parent))->is_independent());
   for (size_t i = 0; i < length; ++i) {
     ASSERT(!Node::FromLocation(children[i])->is_independent());
   }
 #endif
-  if (length == 0) return;
-  implicit_ref_groups_.Add(ImplicitRefGroup::New(parent, children, length));
+  for (size_t i = 0; i < length; ++i) {
+    implicit_ref_groups_.Add(ObjectGroupConnection(
+        UniqueId(reinterpret_cast<intptr_t>(parent)), children[i]));
+  }
 }
 
 
+void GlobalHandles::AddImplicitReference(UniqueId id, Object** child) {

[Michael Starzinger, 2013/04/16 10:56:08]

Can we add an assertion here to check that the child is not marked independent?

ASSERT(!Node::FromLocation(child)->is_independent());

[marja, 2013/04/16 12:28:37]

Done.

+  implicit_ref_groups_.Add(ObjectGroupConnection(id, child));
+}
+
+
 void GlobalHandles::RemoveObjectGroups() {
   object_groups_.Clear();
   for (int i = 0; i < retainer_infos_.length(); ++i) {
     if (retainer_infos_[i].info != NULL)
       retainer_infos_[i].info->Dispose();
   }
   retainer_infos_.Clear();
 }
 
 
 void GlobalHandles::RemoveImplicitRefGroups() {
-  for (int i = 0; i < implicit_ref_groups_.length(); i++) {
-    implicit_ref_groups_.at(i)->Dispose();
-  }
+  representative_objects_.Clear();
   implicit_ref_groups_.Clear();
 }
 
 
 void GlobalHandles::TearDown() {
   // TODO(1428): invoke weak callbacks.
 }
 
 
 } }  // namespace v8::internal