Append to descriptors over map.

src/bootstrapper.cc

 // Copyright 2012 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 373 matching lines @@
 
 
 void Genesis::SetFunctionInstanceDescriptor(
     Handle<Map> map, PrototypePropertyMode prototypeMode) {
   int size = (prototypeMode == DONT_ADD_PROTOTYPE) ? 4 : 5;
   Handle<DescriptorArray> descriptors(factory()->NewDescriptorArray(size));
   PropertyAttributes attribs = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   DescriptorArray::WhitenessWitness witness(*descriptors);
+  map->set_instance_descriptors(*descriptors);
 
   {  // Add length.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionLength));
     CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   {  // Add name.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionName));
     CallbacksDescriptor d(*factory()->name_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   {  // Add arguments.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionArguments));
     CallbacksDescriptor d(*factory()->arguments_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   {  // Add caller.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionCaller));
     CallbacksDescriptor d(*factory()->caller_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
     // Add prototype.
     if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
       attribs = static_cast<PropertyAttributes>(attribs & ~READ_ONLY);
     }
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionPrototype));
     CallbacksDescriptor d(*factory()->prototype_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
-
-  map->set_instance_descriptors(*descriptors);
 }
 
 
 Handle<Map> Genesis::CreateFunctionMap(PrototypePropertyMode prototype_mode) {
   Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
   SetFunctionInstanceDescriptor(map, prototype_mode);
   map->set_function_with_prototype(prototype_mode != DONT_ADD_PROTOTYPE);
   return map;
 }
 
@@ skipping 87 matching lines @@
 
 
 void Genesis::SetStrictFunctionInstanceDescriptor(
     Handle<Map> map, PrototypePropertyMode prototypeMode) {
   int size = (prototypeMode == DONT_ADD_PROTOTYPE) ? 4 : 5;
   Handle<DescriptorArray> descriptors(factory()->NewDescriptorArray(size));
   PropertyAttributes attribs = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE);
 
   DescriptorArray::WhitenessWitness witness(*descriptors);
+  map->set_instance_descriptors(*descriptors);
 
   {  // Add length.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionLength));
     CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   {  // Add name.
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionName));
     CallbacksDescriptor d(*factory()->name_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   {  // Add arguments.
     Handle<AccessorPair> arguments(factory()->NewAccessorPair());
     CallbacksDescriptor d(*factory()->arguments_symbol(), *arguments, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
   {  // Add caller.
     Handle<AccessorPair> caller(factory()->NewAccessorPair());
     CallbacksDescriptor d(*factory()->caller_symbol(), *caller, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
 
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
     // Add prototype.
     if (prototypeMode != ADD_WRITEABLE_PROTOTYPE) {
       attribs = static_cast<PropertyAttributes>(attribs | READ_ONLY);
     }
     Handle<Foreign> f(factory()->NewForeign(&Accessors::FunctionPrototype));
     CallbacksDescriptor d(*factory()->prototype_symbol(), *f, attribs);
-    descriptors->Append(&d, witness);
+    map->AppendDescriptor(&d, witness);
   }
-
-  map->set_instance_descriptors(*descriptors);
 }
 
 
 // ECMAScript 5th Edition, 13.2.3
 Handle<JSFunction> Genesis::GetThrowTypeErrorFunction() {
   if (throw_type_error_function.is_null()) {
     Handle<String> name = factory()->LookupAsciiSymbol("ThrowTypeError");
     throw_type_error_function =
       factory()->NewFunctionWithoutPrototype(name, CLASSIC_MODE);
     Handle<Code> code(isolate()->builtins()->builtin(
@@ skipping 287 matching lines @@
 
     // This seems a bit hackish, but we need to make sure Array.length
     // is 1.
     array_function->shared()->set_length(1);
 
     Handle<DescriptorArray> array_descriptors(factory->NewDescriptorArray(1));
     PropertyAttributes attribs = static_cast<PropertyAttributes>(
         DONT_ENUM | DONT_DELETE);
 
     DescriptorArray::WhitenessWitness witness(*array_descriptors);
+    array_function->initial_map()->set_instance_descriptors(*array_descriptors);
 
     {  // Add length.
       Handle<Foreign> f(factory->NewForeign(&Accessors::ArrayLength));
       CallbacksDescriptor d(*factory->length_symbol(), *f, attribs);
-      array_descriptors->Append(&d, witness);
+      array_function->initial_map()->AppendDescriptor(&d, witness);
     }
 
     // array_function is used internally. JS code creating array object should
     // search for the 'Array' property on the global object and use that one
     // as the constructor. 'Array' property on a global object can be
     // overwritten by JS code.
     global_context()->set_array_function(*array_function);
-    array_function->initial_map()->set_instance_descriptors(*array_descriptors);
   }
 
   {  // --- N u m b e r ---
     Handle<JSFunction> number_fun =
         InstallFunction(global, "Number", JS_VALUE_TYPE, JSValue::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal, true);
     global_context()->set_number_function(*number_fun);
   }
 
   {  // --- B o o l e a n ---
     Handle<JSFunction> boolean_fun =
         InstallFunction(global, "Boolean", JS_VALUE_TYPE, JSValue::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal, true);
     global_context()->set_boolean_function(*boolean_fun);
   }
 
   {  // --- S t r i n g ---
     Handle<JSFunction> string_fun =
         InstallFunction(global, "String", JS_VALUE_TYPE, JSValue::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal, true);
     string_fun->shared()->set_construct_stub(
         isolate->builtins()->builtin(Builtins::kStringConstructCode));
     global_context()->set_string_function(*string_fun);
 
+    Handle<Map> string_map =
+        Handle<Map>(global_context()->string_function()->initial_map());
     Handle<DescriptorArray> string_descriptors(factory->NewDescriptorArray(1));
     PropertyAttributes attribs = static_cast<PropertyAttributes>(
         DONT_ENUM | DONT_DELETE | READ_ONLY);
 
     DescriptorArray::WhitenessWitness witness(*string_descriptors);
+    string_map->set_instance_descriptors(*string_descriptors);
 
     {  // Add length.
       Handle<Foreign> f(factory->NewForeign(&Accessors::StringLength));
       CallbacksDescriptor d(*factory->length_symbol(), *f, attribs);
-      string_descriptors->Append(&d, witness);
+      string_map->AppendDescriptor(&d, witness);
     }
-
-    Handle<Map> string_map =
-        Handle<Map>(global_context()->string_function()->initial_map());
-    string_map->set_instance_descriptors(*string_descriptors);
   }
 
   {  // --- D a t e ---
     // Builtin functions for Date.prototype.
     Handle<JSFunction> date_fun =
         InstallFunction(global, "Date", JS_DATE_TYPE, JSDate::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal, true);
 
     global_context()->set_date_function(*date_fun);
   }
 
 
   {  // -- R e g E x p
     // Builtin functions for RegExp.prototype.
     Handle<JSFunction> regexp_fun =
         InstallFunction(global, "RegExp", JS_REGEXP_TYPE, JSRegExp::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal, true);
     global_context()->set_regexp_function(*regexp_fun);
 
     ASSERT(regexp_fun->has_initial_map());
     Handle<Map> initial_map(regexp_fun->initial_map());
 
     ASSERT_EQ(0, initial_map->inobject_properties());
 
+    PropertyAttributes final =
+        static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
     Handle<DescriptorArray> descriptors = factory->NewDescriptorArray(5);
     DescriptorArray::WhitenessWitness witness(*descriptors);
-    PropertyAttributes final =
-        static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
+    initial_map->set_instance_descriptors(*descriptors);
+
     {
       // ECMA-262, section 15.10.7.1.
       FieldDescriptor field(heap->source_symbol(),
                             JSRegExp::kSourceFieldIndex,
                             final);
-      descriptors->Append(&field, witness);
+      initial_map->AppendDescriptor(&field, witness);
     }
     {
       // ECMA-262, section 15.10.7.2.
       FieldDescriptor field(heap->global_symbol(),
                             JSRegExp::kGlobalFieldIndex,
                             final);
-      descriptors->Append(&field, witness);
+      initial_map->AppendDescriptor(&field, witness);
     }
     {
       // ECMA-262, section 15.10.7.3.
       FieldDescriptor field(heap->ignore_case_symbol(),
                             JSRegExp::kIgnoreCaseFieldIndex,
                             final);
-      descriptors->Append(&field, witness);
+      initial_map->AppendDescriptor(&field, witness);
     }
     {
       // ECMA-262, section 15.10.7.4.
       FieldDescriptor field(heap->multiline_symbol(),
                             JSRegExp::kMultilineFieldIndex,
                             final);
-      descriptors->Append(&field, witness);
+      initial_map->AppendDescriptor(&field, witness);
     }
     {
       // ECMA-262, section 15.10.7.5.
       PropertyAttributes writable =
           static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE);
       FieldDescriptor field(heap->last_index_symbol(),
                             JSRegExp::kLastIndexFieldIndex,
                             writable);
-      descriptors->Append(&field, witness);
+      initial_map->AppendDescriptor(&field, witness);
     }
-    initial_map->set_instance_descriptors(*descriptors);
 
     initial_map->set_inobject_properties(5);
     initial_map->set_pre_allocated_property_fields(5);
     initial_map->set_unused_property_fields(0);
     initial_map->set_instance_size(
         initial_map->instance_size() + 5 * kPointerSize);
     initial_map->set_visitor_id(StaticVisitorBase::GetVisitorId(*initial_map));
 
     // RegExp prototype object is itself a RegExp.
     Handle<Map> proto_map = factory->CopyMap(initial_map);
@@ skipping 125 matching lines @@
     callee->set_setter(*throw_function);
     caller->set_getter(*throw_function);
     caller->set_setter(*throw_function);
 
     // Create the map. Allocate one in-object field for length.
     Handle<Map> map = factory->NewMap(JS_OBJECT_TYPE,
                                       Heap::kArgumentsObjectSizeStrict);
     // Create the descriptor array for the arguments object.
     Handle<DescriptorArray> descriptors = factory->NewDescriptorArray(3);
     DescriptorArray::WhitenessWitness witness(*descriptors);
+    map->set_instance_descriptors(*descriptors);
+
     {  // length
       FieldDescriptor d(*factory->length_symbol(), 0, DONT_ENUM);
-      descriptors->Append(&d, witness);
+      map->AppendDescriptor(&d, witness);
     }
     {  // callee
       CallbacksDescriptor d(*factory->callee_symbol(),
                             *callee,
                             attributes);
-      descriptors->Append(&d, witness);
+      map->AppendDescriptor(&d, witness);
     }
     {  // caller
       CallbacksDescriptor d(*factory->caller_symbol(),
                             *caller,
                             attributes);
-      descriptors->Append(&d, witness);
+      map->AppendDescriptor(&d, witness);
     }
-    map->set_instance_descriptors(*descriptors);
 
     map->set_function_with_prototype(true);
     map->set_prototype(global_context()->object_function()->prototype());
     map->set_pre_allocated_property_fields(1);
     map->set_inobject_properties(1);
 
     // Copy constructor from the non-strict arguments boilerplate.
     map->set_constructor(
       global_context()->arguments_boilerplate()->map()->constructor());
 
@@ skipping 308 matching lines @@
 
     PropertyAttributes attribs =
         static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
 
     Handle<Map> script_map = Handle<Map>(script_fun->initial_map());
 
     Handle<DescriptorArray> script_descriptors(
         factory()->NewDescriptorArray(13));
 
     DescriptorArray::WhitenessWitness witness(*script_descriptors);
+    script_map->set_instance_descriptors(*script_descriptors);
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptSource));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("source"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptName));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("name"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptId));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("id"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptLineOffset));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("line_offset"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptColumnOffset));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("column_offset"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptData));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("data"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptType));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("type"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(
           &Accessors::ScriptCompilationType));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("compilation_type"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptLineEnds));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("line_ends"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ScriptContextData));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("context_data"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(
           &Accessors::ScriptEvalFromScript));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("eval_from_script"), *f, attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(
           &Accessors::ScriptEvalFromScriptPosition));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("eval_from_script_position"),
           *f,
           attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
     {
       Handle<Foreign> f(factory()->NewForeign(
           &Accessors::ScriptEvalFromFunctionName));
       CallbacksDescriptor d(
           *factory()->LookupAsciiSymbol("eval_from_function_name"),
           *f,
           attribs);
-      script_descriptors->Append(&d, witness);
+      script_map->AppendDescriptor(&d, witness);
     }
 
-    script_map->set_instance_descriptors(*script_descriptors);
-
     // Allocate the empty script.
     Handle<Script> script = factory()->NewScript(factory()->empty_string());
     script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
     heap()->public_set_empty_script(*script);
   }
   {
     // Builtin function for OpaqueReference -- a JSValue-based object,
     // that keeps its field isolated from JavaScript code. It may store
     // objects, that JavaScript code may not access.
     Handle<JSFunction> opaque_reference_fun =
@@ skipping 40 matching lines @@
     if (!maybe_map->To(&new_map)) return false;
     new_map->set_elements_kind(FAST_HOLEY_ELEMENTS);
     array_function->set_initial_map(new_map);
 
     // Make "length" magic on instances.
     Handle<DescriptorArray> array_descriptors(factory()->NewDescriptorArray(1));
     PropertyAttributes attribs = static_cast<PropertyAttributes>(
         DONT_ENUM | DONT_DELETE);
 
     DescriptorArray::WhitenessWitness witness(*array_descriptors);
+    array_function->initial_map()->set_instance_descriptors(*array_descriptors);
 
     {  // Add length.
       Handle<Foreign> f(factory()->NewForeign(&Accessors::ArrayLength));
       CallbacksDescriptor d(*factory()->length_symbol(), *f, attribs);
-      array_descriptors->Append(&d, witness);
+      array_function->initial_map()->AppendDescriptor(&d, witness);
     }
 
-    array_function->initial_map()->set_instance_descriptors(*array_descriptors);
-
     global_context()->set_internal_array_function(*array_function);
   }
 
   if (FLAG_disable_native_files) {
     PrintF("Warning: Running without installed natives!\n");
     return true;
   }
 
   // Install natives.
   for (int i = Natives::GetDebuggerCount();
@@ skipping 67 matching lines @@
     initial_map->set_constructor(*array_constructor);
 
     // Set prototype on map.
     initial_map->set_non_instance_prototype(false);
     initial_map->set_prototype(*array_prototype);
 
     // Update map with length accessor from Array and add "index" and "input".
     Handle<DescriptorArray> reresult_descriptors =
         factory()->NewDescriptorArray(3);
     DescriptorArray::WhitenessWitness witness(*reresult_descriptors);
+    initial_map->set_instance_descriptors(*reresult_descriptors);
 
-    JSFunction* array_function = global_context()->array_function();
-    Handle<DescriptorArray> array_descriptors(
-        array_function->initial_map()->instance_descriptors());
-    int old = array_descriptors->SearchWithCache(heap()->length_symbol());
-    reresult_descriptors->CopyFrom(0, *array_descriptors, old, witness);
-
-    reresult_descriptors->SetLastAdded(0);
-
+    {
+      JSFunction* array_function = global_context()->array_function();
+      Handle<DescriptorArray> array_descriptors(
+          array_function->initial_map()->instance_descriptors());
+      String* length = heap()->length_symbol();
+      int old = array_descriptors->SearchWithCache(length);
+      ASSERT(old != DescriptorArray::kNotFound);
+      CallbacksDescriptor desc(length,
+                               array_descriptors->GetValue(old),
+                               array_descriptors->GetDetails(old).attributes());
+      initial_map->AppendDescriptor(&desc, witness);
+    }
     {
       FieldDescriptor index_field(heap()->index_symbol(),
                                   JSRegExpResult::kIndexIndex,
                                   NONE);
-      reresult_descriptors->Append(&index_field, witness);
+      initial_map->AppendDescriptor(&index_field, witness);
     }
 
     {
       FieldDescriptor input_field(heap()->input_symbol(),
                                   JSRegExpResult::kInputIndex,
                                   NONE);
-      reresult_descriptors->Append(&input_field, witness);
+      initial_map->AppendDescriptor(&input_field, witness);
     }
-    initial_map->set_instance_descriptors(*reresult_descriptors);
 
     initial_map->set_inobject_properties(2);
     initial_map->set_pre_allocated_property_fields(2);
     initial_map->set_unused_property_fields(0);
 
     global_context()->set_regexp_result_map(*initial_map);
   }
 
 #ifdef DEBUG
   builtins->Verify();
@@ skipping 585 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal