Provide user-friendly access to natively bound function parameters

src/profile-generator.cc

 // Copyright 2011 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 1757 matching lines @@
       name = collection_->names()->GetFormatted("%s / %s", name, tag);
     }
     return AddEntry(object,
                     HeapEntry::kObject,
                     name,
                     children_count,
                     retainers_count);
   } else if (object->IsJSFunction()) {
     JSFunction* func = JSFunction::cast(object);
     SharedFunctionInfo* shared = func->shared();
+    const char* name = shared->bound() ? "native bind" :
+        collection_->names()->GetName(String::cast(shared->name()));
     return AddEntry(object,
                     HeapEntry::kClosure,
-                    collection_->names()->GetName(String::cast(shared->name())),
+                    name,
                     children_count,
                     retainers_count);
   } else if (object->IsJSRegExp()) {
     JSRegExp* re = JSRegExp::cast(object);
     return AddEntry(object,
                     HeapEntry::kRegExp,
                     collection_->names()->GetName(re->Pattern()),
                     children_count,
                     retainers_count);
   } else if (object->IsJSObject()) {
@@ skipping 220 matching lines @@
               heap_->prototype_symbol(), js_fun->prototype());
         }
       }
       SetInternalReference(js_fun, entry,
                            "shared", js_fun->shared(),
                            JSFunction::kSharedFunctionInfoOffset);
       TagObject(js_fun->unchecked_context(), "(context)");
       SetInternalReference(js_fun, entry,
                            "context", js_fun->unchecked_context(),
                            JSFunction::kContextOffset);
-      TagObject(js_fun->literals_or_bindings(),
-                "(function literals_or_bindings)");
-      SetInternalReference(js_fun, entry,
-                           "literals_or_bindings",
-                           js_fun->literals_or_bindings(),
-                           JSFunction::kLiteralsOffset);
+      // JSFunction has either bindings or literals and never both.
+      if (js_fun->shared()->bound()) {
+        TagObject(js_fun->literals(), "(function literals)");
+        SetInternalReference(js_fun, entry,
+                             "literals",
+                             js_fun->literals(),
+                             JSFunction::kLiteralsOffset);
+      } else {
+        TagObject(js_fun->function_bindings(), "(function bindings)");
+        SetInternalReference(js_fun, entry,
+                             "bindings",
+                             js_fun->function_bindings(),
+                             JSFunction::kLiteralsOffset);
+      }
       for (int i = JSFunction::kNonWeakFieldsEndOffset;
            i < JSFunction::kSize;
            i += kPointerSize) {
         SetWeakReference(js_fun, entry, i, *HeapObject::RawField(js_fun, i), i);
       }
     }
     TagObject(js_obj->properties(), "(object properties)");
     SetInternalReference(obj, entry,
                          "properties", js_obj->properties(),
                          JSObject::kPropertiesOffset);
@@ skipping 82 matching lines @@
     SetInternalReference(obj, entry,
                          "data", script->data(),
                          Script::kDataOffset);
     SetInternalReference(obj, entry,
                          "context_data", script->context_data(),
                          Script::kContextOffset);
     TagObject(script->line_ends(), "(script line ends)");
     SetInternalReference(obj, entry,
                          "line_ends", script->line_ends(),
                          Script::kLineEndsOffset);
-  } else if (obj->IsDescriptorArray()) {

[yurys, 2012/02/10 11:30:14]

DescriptorArray is indistinguishable from a regular FixedArray, so this check is
wrong, I'm removing this special case.

[mnaganov (inactive), 2012/02/10 12:28:21]

OK, thanks!

-    DescriptorArray* desc_array = DescriptorArray::cast(obj);
-    if (desc_array->length() > DescriptorArray::kContentArrayIndex) {
-      Object* content_array =
-          desc_array->get(DescriptorArray::kContentArrayIndex);
-      TagObject(content_array, "(map descriptor content)");
-      SetInternalReference(obj, entry,
-                           "content", content_array,
-                           FixedArray::OffsetOfElementAt(
-                               DescriptorArray::kContentArrayIndex));
-    }
   } else if (obj->IsCodeCache()) {
     CodeCache* code_cache = CodeCache::cast(obj);
     TagObject(code_cache->default_cache(), "(default code cache)");
     SetInternalReference(obj, entry,
                          "default_cache", code_cache->default_cache(),
                          CodeCache::kDefaultCacheOffset);
     TagObject(code_cache->normal_type_cache(), "(code type cache)");
     SetInternalReference(obj, entry,
                          "type_cache", code_cache->normal_type_cache(),
                          CodeCache::kNormalTypeCacheOffset);
   } else if (obj->IsCode()) {
     Code* code = Code::cast(obj);
     TagObject(code->unchecked_relocation_info(), "(code relocation info)");
     TagObject(code->unchecked_deoptimization_data(), "(code deopt data)");
   }
   if (extract_indexed_refs) {
     SetInternalReference(obj, entry, "map", obj->map(), HeapObject::kMapOffset);
     IndexedReferencesExtractor refs_extractor(this, obj, entry);
     obj->Iterate(&refs_extractor);
   }
 }
 
 
 void V8HeapExplorer::ExtractClosureReferences(JSObject* js_obj,
                                               HeapEntry* entry) {
-  if (js_obj->IsJSFunction()) {
-    JSFunction* func = JSFunction::cast(js_obj);
-    Context* context = func->context();
-    ScopeInfo* scope_info = context->closure()->shared()->scope_info();
+  if (!js_obj->IsJSFunction()) return;
 
+  JSFunction* func = JSFunction::cast(js_obj);
+  Context* context = func->context();
+  ScopeInfo* scope_info = context->closure()->shared()->scope_info();
+
+  if (func->shared()->bound()) {
+    FixedArray* bindings = func->function_bindings();
+    SetNativeBindReference(js_obj, entry, "bound this",

[mnaganov (inactive), 2012/02/10 12:28:21]

Perhaps, use underscores for names? Otherwise it might look confusing when
showing retaining paths. Have you checked that?

[yurys, 2012/02/10 13:48:59]

Makes sense. Done.

+                           bindings->get(JSFunction::kBoundThisIndex));
+    SetNativeBindReference(js_obj, entry, "bound function",
+                           bindings->get(JSFunction::kBoundFunctionIndex));
+    for (int i = JSFunction::kBoundArgumentsStartIndex;
+         i < bindings->length(); i++) {
+      SetNativeBindReference(js_obj, entry, "bound argument",

[mnaganov (inactive), 2012/02/10 12:28:21]

Does it make sense to label them "bound_argument_%d"?

[yurys, 2012/02/10 13:48:59]

Done.

+                             bindings->get(i));
+    }
+  } else {
     // Add context allocated locals.
     int context_locals = scope_info->ContextLocalCount();
     for (int i = 0; i < context_locals; ++i) {
       String* local_name = scope_info->ContextLocalName(i);
       int idx = Context::MIN_CONTEXT_SLOTS + i;
       SetClosureReference(js_obj, entry, local_name, context->get(idx));
     }
 
     // Add function variable.
     if (scope_info->HasFunctionName()) {
@@ skipping 257 matching lines @@
     filler_->SetNamedReference(HeapGraphEdge::kContextVariable,
                                parent_obj,
                                parent_entry,
                                collection_->names()->GetName(reference_name),
                                child_obj,
                                child_entry);
   }
 }
 
 
+void V8HeapExplorer::SetNativeBindReference(HeapObject* parent_obj,
+                                            HeapEntry* parent_entry,
+                                            const char* reference_name,
+                                            Object* child_obj) {
+  HeapEntry* child_entry = GetEntry(child_obj);
+  if (child_entry != NULL) {
+    filler_->SetNamedReference(HeapGraphEdge::kShortcut,
+                               parent_obj,
+                               parent_entry,
+                               reference_name,
+                               child_obj,
+                               child_entry);
+  }
+}
+
+
 void V8HeapExplorer::SetElementReference(HeapObject* parent_obj,
                                          HeapEntry* parent_entry,
                                          int index,
                                          Object* child_obj) {
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     filler_->SetIndexedReference(HeapGraphEdge::kElement,
                                  parent_obj,
                                  parent_entry,
                                  index,
@@ skipping 1270 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal