Have one, long-lived map for bound functions.

src/bootstrapper.cc

 // Copyright 2014 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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/isolate-inl.h"
 #include "src/natives.h"
 #include "src/snapshot.h"
@@ skipping 250 matching lines @@
   void TransferObject(Handle<JSObject> from, Handle<JSObject> to);
   void TransferNamedProperties(Handle<JSObject> from, Handle<JSObject> to);
   void TransferIndexedProperties(Handle<JSObject> from, Handle<JSObject> to);
 
   enum PrototypePropertyMode {
     DONT_ADD_PROTOTYPE,
     ADD_READONLY_PROTOTYPE,
     ADD_WRITEABLE_PROTOTYPE
   };
 
+  enum ForBoundFunctionMode {

[Toon Verwaest, 2014/06/12 21:53:35]

I'd rather name this

enum FunctionMapMode {
  REGULAR_FUNCTION_MAP,
  BOUND_FUNCTION_MAP
}

And perhaps you could even merge it with the above PrototypePropertyMode, since
BOUND_FUNCTION always implies DONT_ADD_PROTOTYPE:

enum FunctionMode {
  // With prototype.
  FUNCTION_WITH_WRITEABLE_PROTOTYPE,
  FUNCTION_WITH_READONLY_PROTOTYPE,
  // Without prototype.
  FUNCTION_WITHOUT_PROTOTYPE,
  BOUND_FUNCTION
}

[Jakob Kummerow, 2014/06/13 11:43:13]

Done.

+    FOR_REGULAR_FUNCTION,
+    FOR_BOUND_FUNCTION
+  };
+
   Handle<Map> CreateFunctionMap(PrototypePropertyMode prototype_mode);
 
   void SetFunctionInstanceDescriptor(Handle<Map> map,
                                      PrototypePropertyMode prototypeMode);
   void MakeFunctionInstancePrototypeWritable();
 
   Handle<Map> CreateStrictFunctionMap(
       PrototypePropertyMode prototype_mode,
-      Handle<JSFunction> empty_function);
+      Handle<JSFunction> empty_function,
+      ForBoundFunctionMode bound_mode = FOR_REGULAR_FUNCTION);
 
   void SetStrictFunctionInstanceDescriptor(Handle<Map> map,
-                                           PrototypePropertyMode propertyMode);
+                                           PrototypePropertyMode propertyMode,
+                                           ForBoundFunctionMode bound_mode);
 
   static bool CompileBuiltin(Isolate* isolate, int index);
   static bool CompileExperimentalBuiltin(Isolate* isolate, int index);
   static bool CompileNative(Isolate* isolate,
                             Vector<const char> name,
                             Handle<String> source);
   static bool CompileScriptCached(Isolate* isolate,
                                   Vector<const char> name,
                                   Handle<String> source,
                                   SourceCodeCache* cache,
@@ skipping 223 matching lines @@
   // Allocate the function map first and then patch the prototype later
   Handle<Map> empty_function_map = CreateFunctionMap(DONT_ADD_PROTOTYPE);
   empty_function_map->set_prototype(
       native_context()->object_function()->prototype());
   empty_function->set_map(*empty_function_map);
   return empty_function;
 }
 
 
 void Genesis::SetStrictFunctionInstanceDescriptor(
-    Handle<Map> map, PrototypePropertyMode prototypeMode) {
+    Handle<Map> map, PrototypePropertyMode prototypeMode,
+    ForBoundFunctionMode bound_mode) {
   int size = (prototypeMode == DONT_ADD_PROTOTYPE) ? 4 : 5;
   Map::EnsureDescriptorSlack(map, size);
 
   Handle<AccessorPair> arguments(factory()->NewAccessorPair());
   Handle<AccessorPair> caller(factory()->NewAccessorPair());
   PropertyAttributes rw_attribs =
       static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE);
   PropertyAttributes ro_attribs =
       static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
 
-  Handle<AccessorInfo> length =
-      Accessors::FunctionLengthInfo(isolate(), ro_attribs);
-  {  // Add length.
+  // Add length.
+  if (bound_mode == FOR_REGULAR_FUNCTION) {
+    Handle<AccessorInfo> length =
+        Accessors::FunctionLengthInfo(isolate(), ro_attribs);
     CallbacksDescriptor d(Handle<Name>(Name::cast(length->name())),
                           length, ro_attribs);
     map->AppendDescriptor(&d);
+  } else {
+    ASSERT(bound_mode == FOR_BOUND_FUNCTION);
+    Handle<String> length_string = isolate()->factory()->length_string();
+    PropertyAttributes attr =
+        static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY);
+    FieldDescriptor d(length_string, 0, attr, Representation::Tagged());
+    map->AppendDescriptor(&d);
   }
   Handle<AccessorInfo> name =
       Accessors::FunctionNameInfo(isolate(), ro_attribs);
   {  // Add name.
     CallbacksDescriptor d(Handle<Name>(Name::cast(name->name())),
                           name, ro_attribs);
     map->AppendDescriptor(&d);
   }
   {  // Add arguments.
     CallbacksDescriptor d(factory()->arguments_string(), arguments,
@@ skipping 46 matching lines @@
     generator_poison_function->shared()->DontAdaptArguments();
 
     JSObject::PreventExtensions(generator_poison_function).Assert();
   }
   return generator_poison_function;
 }
 
 
 Handle<Map> Genesis::CreateStrictFunctionMap(
     PrototypePropertyMode prototype_mode,
-    Handle<JSFunction> empty_function) {
+    Handle<JSFunction> empty_function,
+    ForBoundFunctionMode bound_mode) {
   Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
-  SetStrictFunctionInstanceDescriptor(map, prototype_mode);
+  SetStrictFunctionInstanceDescriptor(map, prototype_mode, bound_mode);
   map->set_function_with_prototype(prototype_mode != DONT_ADD_PROTOTYPE);
   map->set_prototype(*empty_function);
   return map;
 }
 
 
 void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) {
   // Allocate map for the prototype-less strict mode instances.
   Handle<Map> strict_function_without_prototype_map =
       CreateStrictFunctionMap(DONT_ADD_PROTOTYPE, empty);
   native_context()->set_strict_function_without_prototype_map(
       *strict_function_without_prototype_map);
 
   // Allocate map for the strict mode functions. This map is temporary, used
   // only for processing of builtins.
   // Later the map is replaced with writable prototype map, allocated below.
   Handle<Map> strict_function_map =
       CreateStrictFunctionMap(ADD_READONLY_PROTOTYPE, empty);
   native_context()->set_strict_function_map(*strict_function_map);
 
   // The final map for the strict mode functions. Writeable prototype.
   // This map is installed in MakeFunctionInstancePrototypeWritable.
   strict_function_map_writable_prototype_ =
       CreateStrictFunctionMap(ADD_WRITEABLE_PROTOTYPE, empty);
+  // Special map for bound functions.
+  Handle<Map> bound_function_map =
+      CreateStrictFunctionMap(DONT_ADD_PROTOTYPE, empty, FOR_BOUND_FUNCTION);
+  native_context()->set_bound_function_map(*bound_function_map);
 
   // Complete the callbacks.
   PoisonArgumentsAndCaller(strict_function_without_prototype_map);
   PoisonArgumentsAndCaller(strict_function_map);
   PoisonArgumentsAndCaller(strict_function_map_writable_prototype_);
+  PoisonArgumentsAndCaller(bound_function_map);
 }
 
 
 static void SetAccessors(Handle<Map> map,
                          Handle<String> name,
                          Handle<JSFunction> func) {
   DescriptorArray* descs = map->instance_descriptors();
   int number = descs->SearchWithCache(*name, *map);
   AccessorPair* accessors = AccessorPair::cast(descs->GetValue(number));
   accessors->set_getter(*func);
@@ skipping 2063 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal