[runtime] Introduce dedicated JSBoundFunction to represent bound functions.

src/profiler/heap-snapshot-generator.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/profiler/heap-snapshot-generator.h"
 
 #include "src/code-stubs.h"
 #include "src/conversions.h"
 #include "src/debug/debug.h"
 #include "src/objects-body-descriptors.h"
@@ skipping 787 matching lines @@
 
 HeapEntry* V8HeapExplorer::AllocateEntry(HeapThing ptr) {
   return AddEntry(reinterpret_cast<HeapObject*>(ptr));
 }
 
 
 HeapEntry* V8HeapExplorer::AddEntry(HeapObject* object) {
   if (object->IsJSFunction()) {
     JSFunction* func = JSFunction::cast(object);
     SharedFunctionInfo* shared = func->shared();
-    const char* name = shared->bound() ? "native_bind" :
-        names_->GetName(String::cast(shared->name()));
+    const char* name = names_->GetName(String::cast(shared->name()));
     return AddEntry(object, HeapEntry::kClosure, name);
+  } else if (object->IsJSBoundFunction()) {
+    return AddEntry(object, HeapEntry::kClosure, "native_bind");
   } else if (object->IsJSRegExp()) {
     JSRegExp* re = JSRegExp::cast(object);
     return AddEntry(object,
                     HeapEntry::kRegExp,
                     names_->GetName(re->Pattern()));
   } else if (object->IsJSObject()) {
     const char* name = names_->GetName(
         GetConstructorName(JSObject::cast(object)));
     if (object->IsJSGlobalObject()) {
       const char* tag = objects_tags_.GetTag(object);
@@ skipping 270 matching lines @@
     int entry, JSGlobalProxy* proxy) {
   SetInternalReference(proxy, entry,
                        "native_context", proxy->native_context(),
                        JSGlobalProxy::kNativeContextOffset);
 }
 
 
 void V8HeapExplorer::ExtractJSObjectReferences(
     int entry, JSObject* js_obj) {
   HeapObject* obj = js_obj;
-  ExtractClosureReferences(js_obj, entry);
   ExtractPropertyReferences(js_obj, entry);
   ExtractElementReferences(js_obj, entry);
   ExtractInternalReferences(js_obj, entry);
   PrototypeIterator iter(heap_->isolate(), js_obj);
   SetPropertyReference(obj, entry, heap_->proto_string(), iter.GetCurrent());
-  if (obj->IsJSFunction()) {
+  if (obj->IsJSBoundFunction()) {
+    JSBoundFunction* js_fun = JSBoundFunction::cast(obj);
+    TagObject(js_fun->bound_arguments(), "(bound arguments)");
+    SetInternalReference(js_fun, entry, "bindings", js_fun->bound_arguments(),
+                         JSBoundFunction::kBoundArgumentsOffset);
+    TagObject(js_fun->creation_context(), "(creation context)");
+    SetInternalReference(js_fun, entry, "creation_context",
+                         js_fun->creation_context(),
+                         JSBoundFunction::kCreationContextOffset);
+    SetNativeBindReference(js_obj, entry, "bound_this", js_fun->bound_this());
+    SetNativeBindReference(js_obj, entry, "bound_function",
+                           js_fun->bound_target_function());
+    FixedArray* bindings = js_fun->bound_arguments();
+    for (int i = 0; i < bindings->length(); i++) {
+      const char* reference_name = names_->GetFormatted("bound_argument_%d", i);
+      SetNativeBindReference(js_obj, entry, reference_name, bindings->get(i));
+    }
+  } else if (obj->IsJSFunction()) {
     JSFunction* js_fun = JSFunction::cast(js_obj);
     Object* proto_or_map = js_fun->prototype_or_initial_map();
     if (!proto_or_map->IsTheHole()) {
       if (!proto_or_map->IsMap()) {
         SetPropertyReference(
             obj, entry,
             heap_->prototype_string(), proto_or_map,
             NULL,
             JSFunction::kPrototypeOrInitialMapOffset);
       } else {
         SetPropertyReference(
             obj, entry,
             heap_->prototype_string(), js_fun->prototype());
         SetInternalReference(
             obj, entry, "initial_map", proto_or_map,
             JSFunction::kPrototypeOrInitialMapOffset);
       }
     }
     SharedFunctionInfo* shared_info = js_fun->shared();
-    // JSFunction has either bindings or literals and never both.
-    bool bound = shared_info->bound();
-    TagObject(js_fun->literals_or_bindings(),
-              bound ? "(function bindings)" : "(function literals)");
-    SetInternalReference(js_fun, entry,
-                         bound ? "bindings" : "literals",
-                         js_fun->literals_or_bindings(),
+    TagObject(js_fun->literals(), "(function literals)");
+    SetInternalReference(js_fun, entry, "literals", js_fun->literals(),
                          JSFunction::kLiteralsOffset);
     TagObject(shared_info, "(shared function info)");
     SetInternalReference(js_fun, entry,
                          "shared", shared_info,
                          JSFunction::kSharedFunctionInfoOffset);
     TagObject(js_fun->context(), "(context)");
     SetInternalReference(js_fun, entry,
                          "context", js_fun->context(),
                          JSFunction::kContextOffset);
     SetWeakReference(js_fun, entry,
@@ skipping 424 matching lines @@
       SetWeakReference(array, entry,
                        i, array->get(i), array->OffsetOfElementAt(i));
     } else {
       SetInternalReference(array, entry,
                            i, array->get(i), array->OffsetOfElementAt(i));
     }
   }
 }
 
 
-void V8HeapExplorer::ExtractClosureReferences(JSObject* js_obj, int entry) {
-  if (!js_obj->IsJSFunction()) return;
-
-  JSFunction* func = JSFunction::cast(js_obj);
-  if (func->shared()->bound()) {
-    BindingsArray* bindings = func->function_bindings();
-    SetNativeBindReference(js_obj, entry, "bound_this", bindings->bound_this());
-    SetNativeBindReference(js_obj, entry, "bound_function",
-                           bindings->bound_function());
-    for (int i = 0; i < bindings->bindings_count(); i++) {
-      const char* reference_name = names_->GetFormatted("bound_argument_%d", i);
-      SetNativeBindReference(js_obj, entry, reference_name,
-                             bindings->binding(i));
-    }
-  }
-}
-
-
 void V8HeapExplorer::ExtractPropertyReferences(JSObject* js_obj, int entry) {
   if (js_obj->HasFastProperties()) {
     DescriptorArray* descs = js_obj->map()->instance_descriptors();
     int real_size = js_obj->map()->NumberOfOwnDescriptors();
     for (int i = 0; i < real_size; i++) {
       PropertyDetails details = descs->GetDetails(i);
       switch (details.location()) {
         case kField: {
           Representation r = details.representation();
           if (r.IsSmi() || r.IsDouble()) break;
@@ skipping 1561 matching lines @@
   for (int i = 1; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(sorted_strings[i]);
     if (writer_->aborted()) return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8