filler

src/heap-snapshot-generator.h

 // Copyright 2013 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 115 matching lines @@
   int children_count() const { return children_count_; }
   INLINE(int set_children_index(int index));
   void add_child(HeapGraphEdge* edge) {
     children_arr()[children_count_++] = edge;
   }
   Vector<HeapGraphEdge*> children() {
     return Vector<HeapGraphEdge*>(children_arr(), children_count_); }
 
   void SetIndexedReference(
       HeapGraphEdge::Type type, int index, HeapEntry* entry);
+  void SetIndexedAutoIndexReference(
+      HeapGraphEdge::Type type, HeapEntry* child_entry);
   void SetNamedReference(
       HeapGraphEdge::Type type, const char* name, HeapEntry* entry);
+  void SetNamedAutoIndexReference(HeapGraphEdge::Type type,
+                                  HeapEntry* child_entry,
+                                  StringsStorage* names);
 
   void Print(
       const char* prefix, const char* edge_name, int max_depth, int indent);
 
  private:
   INLINE(HeapGraphEdge** children_arr());
   const char* TypeAsString();
 
   unsigned type_: 4;
   int children_count_: 28;
@@ skipping 192 matching lines @@
 
 // An interface used to populate a snapshot with nodes and edges.
 class SnapshotFillerInterface {
  public:
   virtual ~SnapshotFillerInterface() { }
   virtual HeapEntry* AddEntry(HeapThing ptr,
                               HeapEntriesAllocator* allocator) = 0;
   virtual HeapEntry* FindEntry(HeapThing ptr) = 0;
   virtual HeapEntry* FindOrAddEntry(HeapThing ptr,
                                     HeapEntriesAllocator* allocator) = 0;
-  virtual void SetIndexedReference(HeapGraphEdge::Type type,
-                                   int parent_entry,
-                                   int index,
-                                   HeapEntry* child_entry) = 0;
-  virtual void SetIndexedAutoIndexReference(HeapGraphEdge::Type type,
-                                            int parent_entry,
-                                            HeapEntry* child_entry) = 0;
-  virtual void SetNamedReference(HeapGraphEdge::Type type,
-                                 int parent_entry,
-                                 const char* reference_name,
-                                 HeapEntry* child_entry) = 0;
-  virtual void SetNamedAutoIndexReference(HeapGraphEdge::Type type,
-                                          int parent_entry,
-                                          HeapEntry* child_entry) = 0;
 };
 
 
 class SnapshottingProgressReportingInterface {
  public:
   virtual ~SnapshottingProgressReportingInterface() { }
   virtual void ProgressStep() = 0;
   virtual bool ProgressReport(bool force) = 0;
 };
 
@@ skipping 23 matching lines @@
 
  private:
   HeapEntry* AddEntry(HeapObject* object);
   HeapEntry* AddEntry(HeapObject* object,
                       HeapEntry::Type type,
                       const char* name);
 
   const char* GetSystemEntryName(HeapObject* object);
 
   void ExtractReferences(HeapObject* obj);
-  void ExtractJSGlobalProxyReferences(int entry, JSGlobalProxy* proxy);
-  void ExtractJSObjectReferences(int entry, JSObject* js_obj);
-  void ExtractStringReferences(int entry, String* obj);
-  void ExtractContextReferences(int entry, Context* context);
-  void ExtractMapReferences(int entry, Map* map);
-  void ExtractSharedFunctionInfoReferences(int entry,
+  void ExtractJSGlobalProxyReferences(HeapEntry* entry, JSGlobalProxy* proxy);
+  void ExtractJSObjectReferences(HeapEntry* entry, JSObject* js_obj);
+  void ExtractStringReferences(HeapEntry* entry, String* obj);
+  void ExtractContextReferences(HeapEntry* entry, Context* context);
+  void ExtractMapReferences(HeapEntry* entry, Map* map);
+  void ExtractSharedFunctionInfoReferences(HeapEntry* entry,
                                            SharedFunctionInfo* shared);
-  void ExtractScriptReferences(int entry, Script* script);
-  void ExtractAccessorPairReferences(int entry, AccessorPair* accessors);
-  void ExtractCodeCacheReferences(int entry, CodeCache* code_cache);
-  void ExtractCodeReferences(int entry, Code* code);
-  void ExtractBoxReferences(int entry, Box* box);
-  void ExtractCellReferences(int entry, Cell* cell);
-  void ExtractPropertyCellReferences(int entry, PropertyCell* cell);
-  void ExtractAllocationSiteReferences(int entry, AllocationSite* site);
-  void ExtractJSArrayBufferReferences(int entry, JSArrayBuffer* buffer);
-  void ExtractClosureReferences(JSObject* js_obj, int entry);
-  void ExtractPropertyReferences(JSObject* js_obj, int entry);
-  bool ExtractAccessorPairProperty(JSObject* js_obj, int entry,
+  void ExtractScriptReferences(HeapEntry* entry, Script* script);
+  void ExtractAccessorPairReferences(HeapEntry* entry, AccessorPair* accessors);
+  void ExtractCodeCacheReferences(HeapEntry* entry, CodeCache* code_cache);
+  void ExtractCodeReferences(HeapEntry* entry, Code* code);
+  void ExtractBoxReferences(HeapEntry* entry, Box* box);
+  void ExtractCellReferences(HeapEntry* entry, Cell* cell);
+  void ExtractPropertyCellReferences(HeapEntry* entry, PropertyCell* cell);
+  void ExtractAllocationSiteReferences(HeapEntry* entry, AllocationSite* site);
+  void ExtractJSArrayBufferReferences(HeapEntry* entry, JSArrayBuffer* buffer);
+  void ExtractClosureReferences(JSObject* js_obj, HeapEntry* entry);
+  void ExtractPropertyReferences(JSObject* js_obj, HeapEntry* entry);
+  bool ExtractAccessorPairProperty(JSObject* js_obj, HeapEntry* entry,
                                    Object* key, Object* callback_obj);
-  void ExtractElementReferences(JSObject* js_obj, int entry);
-  void ExtractInternalReferences(JSObject* js_obj, int entry);
+  void ExtractElementReferences(JSObject* js_obj, HeapEntry* entry);
+  void ExtractInternalReferences(JSObject* js_obj, HeapEntry* entry);
   bool IsEssentialObject(Object* object);
   void SetContextReference(HeapObject* parent_obj,
-                           int parent,
+                           HeapEntry* parent,
                            String* reference_name,
                            Object* child,
                            int field_offset);
   void SetNativeBindReference(HeapObject* parent_obj,
-                              int parent,
+                              HeapEntry* parent,
                               const char* reference_name,
                               Object* child);
   void SetElementReference(HeapObject* parent_obj,
-                           int parent,
+                           HeapEntry* parent,
                            int index,
                            Object* child);
   void SetInternalReference(HeapObject* parent_obj,
-                            int parent,
+                            HeapEntry* parent,
                             const char* reference_name,
                             Object* child,
                             int field_offset = -1);
   void SetInternalReference(HeapObject* parent_obj,
-                            int parent,
+                            HeapEntry* parent,
                             int index,
                             Object* child,
                             int field_offset = -1);
   void SetHiddenReference(HeapObject* parent_obj,
-                          int parent,
+                          HeapEntry* parent,
                           int index,
                           Object* child);
   void SetWeakReference(HeapObject* parent_obj,
-                        int parent,
+                        HeapEntry* parent,
                         const char* reference_name,
                         Object* child_obj,
                         int field_offset);
   void SetPropertyReference(HeapObject* parent_obj,
-                            int parent,
+                            HeapEntry* parent,
                             Name* reference_name,
                             Object* child,
                             const char* name_format_string = NULL,
                             int field_offset = -1);
   void SetUserGlobalReference(Object* user_global);
   void SetRootGcRootsReference();
   void SetGcRootsReference(VisitorSynchronization::SyncTag tag);
   void SetGcSubrootReference(
       VisitorSynchronization::SyncTag tag, bool is_weak, Object* child);
   const char* GetStrongGcSubrootName(Object* object);
@@ skipping 168 matching lines @@
   friend class HeapSnapshotJSONSerializerEnumerator;
   friend class HeapSnapshotJSONSerializerIterator;
 
   DISALLOW_COPY_AND_ASSIGN(HeapSnapshotJSONSerializer);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_SNAPSHOT_GENERATOR_H_