Swapped transition array and descriptor array.

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 381 matching lines @@
   Handle<Foreign> length(factory()->NewForeign(&Accessors::FunctionLength));
   Handle<Foreign> name(factory()->NewForeign(&Accessors::FunctionName));
   Handle<Foreign> args(factory()->NewForeign(&Accessors::FunctionArguments));
   Handle<Foreign> caller(factory()->NewForeign(&Accessors::FunctionCaller));
   Handle<Foreign> prototype;
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
     prototype = factory()->NewForeign(&Accessors::FunctionPrototype);
   }
   PropertyAttributes attribs = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE | READ_ONLY);
-  map->set_instance_descriptors(*descriptors);
+  Map::SetDescriptors(map, descriptors);
 
   {  // Add length.
     CallbacksDescriptor d(*factory()->length_symbol(), *length, attribs);
     map->AppendDescriptor(&d, witness);
   }
   {  // Add name.
     CallbacksDescriptor d(*factory()->name_symbol(), *name, attribs);
     map->AppendDescriptor(&d, witness);
   }
   {  // Add arguments.
@@ skipping 120 matching lines @@
   Handle<Foreign> length(factory()->NewForeign(&Accessors::FunctionLength));
   Handle<Foreign> name(factory()->NewForeign(&Accessors::FunctionName));
   Handle<AccessorPair> arguments(factory()->NewAccessorPair());
   Handle<AccessorPair> caller(factory()->NewAccessorPair());
   Handle<Foreign> prototype;
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
     prototype = factory()->NewForeign(&Accessors::FunctionPrototype);
   }
   PropertyAttributes attribs = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE);
-  map->set_instance_descriptors(*descriptors);
+

[Michael Starzinger, 2012/08/12 18:18:08]

Drop the empty newline.

+  Map::SetDescriptors(map, descriptors);
 
   {  // Add length.
     CallbacksDescriptor d(*factory()->length_symbol(), *length, attribs);
     map->AppendDescriptor(&d, witness);
   }
   {  // Add name.
     CallbacksDescriptor d(*factory()->name_symbol(), *name, attribs);
     map->AppendDescriptor(&d, witness);
   }
   {  // Add arguments.
@@ skipping 306 matching lines @@
                         isolate->initial_object_prototype(),
                         Builtins::kArrayCode, true);
     array_function->shared()->set_construct_stub(
         isolate->builtins()->builtin(Builtins::kArrayConstructCode));
     array_function->shared()->DontAdaptArguments();
 
     // This seems a bit hackish, but we need to make sure Array.length
     // is 1.
     array_function->shared()->set_length(1);
 
+    Handle<Map> initial_map(array_function->initial_map());
     Handle<DescriptorArray> array_descriptors(factory->NewDescriptorArray(1));
     DescriptorArray::WhitenessWitness witness(*array_descriptors);
 
     Handle<Foreign> array_length(factory->NewForeign(&Accessors::ArrayLength));
     PropertyAttributes attribs = static_cast<PropertyAttributes>(
         DONT_ENUM | DONT_DELETE);
-    array_function->initial_map()->set_instance_descriptors(*array_descriptors);
+    Map::SetDescriptors(initial_map, array_descriptors);
 
     {  // Add length.
       CallbacksDescriptor d(*factory->length_symbol(), *array_length, attribs);
       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.
@@ skipping 27 matching lines @@
 
     Handle<Map> string_map =
         Handle<Map>(global_context()->string_function()->initial_map());
     Handle<DescriptorArray> string_descriptors(factory->NewDescriptorArray(1));
     DescriptorArray::WhitenessWitness witness(*string_descriptors);
 
     Handle<Foreign> string_length(
         factory->NewForeign(&Accessors::StringLength));
     PropertyAttributes attribs = static_cast<PropertyAttributes>(
         DONT_ENUM | DONT_DELETE | READ_ONLY);
-    string_map->set_instance_descriptors(*string_descriptors);
+    Map::SetDescriptors(string_map, string_descriptors);
 
     {  // Add length.
       CallbacksDescriptor d(*factory->length_symbol(), *string_length, attribs);
       string_map->AppendDescriptor(&d, witness);
     }
   }
 
   {  // --- D a t e ---
     // Builtin functions for Date.prototype.
     Handle<JSFunction> date_fun =
@@ skipping 15 matching lines @@
 
     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);
-    initial_map->set_instance_descriptors(*descriptors);
+    Map::SetDescriptors(initial_map, descriptors);
 
     {
       // ECMA-262, section 15.10.7.1.
       FieldDescriptor field(heap->source_symbol(),
                             JSRegExp::kSourceFieldIndex,
                             final);
       initial_map->AppendDescriptor(&field, witness);
     }
     {
       // ECMA-262, section 15.10.7.2.
@@ skipping 163 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);
+    Map::SetDescriptors(map, descriptors);
 
     {  // length
       FieldDescriptor d(*factory->length_symbol(), 0, DONT_ENUM);
       map->AppendDescriptor(&d, witness);
     }
     {  // callee
       CallbacksDescriptor d(*factory->callee_symbol(),
                             *callee,
                             attributes);
       map->AppendDescriptor(&d, witness);
@@ skipping 364 matching lines @@
     Handle<String> eval_from_script_position_symbol(
         factory()->LookupAsciiSymbol("eval_from_script_position"));
     Handle<Foreign> script_eval_from_script_position(
         factory()->NewForeign(&Accessors::ScriptEvalFromScriptPosition));
     Handle<String> eval_from_function_name_symbol(
         factory()->LookupAsciiSymbol("eval_from_function_name"));
     Handle<Foreign> script_eval_from_function_name(
         factory()->NewForeign(&Accessors::ScriptEvalFromFunctionName));
     PropertyAttributes attribs =
         static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
-    script_map->set_instance_descriptors(*script_descriptors);
+    Map::SetDescriptors(script_map, script_descriptors);
 
     {
       CallbacksDescriptor d(
           *factory()->source_symbol(), *script_source, attribs);
       script_map->AppendDescriptor(&d, witness);
     }
 
     {
       CallbacksDescriptor d(*factory()->name_symbol(), *script_name, attribs);
       script_map->AppendDescriptor(&d, witness);
@@ skipping 104 matching lines @@
 
     array_function->shared()->set_construct_stub(
         isolate()->builtins()->builtin(Builtins::kArrayConstructCode));
     array_function->shared()->DontAdaptArguments();
 
     // InternalArrays should not use Smi-Only array optimizations. There are too
     // many places in the C++ runtime code (e.g. RegEx) that assume that
     // elements in InternalArrays can be set to non-Smi values without going
     // through a common bottleneck that would make the SMI_ONLY -> FAST_ELEMENT
     // transition easy to trap. Moreover, they rarely are smi-only.
-    MaybeObject* maybe_map =
-        array_function->initial_map()->Copy(DescriptorArray::MAY_BE_SHARED);
+    MaybeObject* maybe_map = array_function->initial_map()->Copy();
     Map* new_map;
     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<Map> initial_map(array_function->initial_map());
     Handle<DescriptorArray> array_descriptors(factory()->NewDescriptorArray(1));
     DescriptorArray::WhitenessWitness witness(*array_descriptors);
 
     Handle<Foreign> array_length(factory()->NewForeign(
         &Accessors::ArrayLength));
     PropertyAttributes attribs = static_cast<PropertyAttributes>(
         DONT_ENUM | DONT_DELETE);
-    array_function->initial_map()->set_instance_descriptors(*array_descriptors);
+    Map::SetDescriptors(initial_map, array_descriptors);
 
     {  // Add length.
       CallbacksDescriptor d(
           *factory()->length_symbol(), *array_length, attribs);
       array_function->initial_map()->AppendDescriptor(&d, witness);
     }
 
     global_context()->set_internal_array_function(*array_function);
   }
 
@@ skipping 74 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);
+    Map::SetDescriptors(initial_map, reresult_descriptors);
 
     {
       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),
@@ skipping 611 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal