Introduce accessors on builtins instance

src/bootstrapper.cc

 // Copyright 2006-2008 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 427 matching lines @@
 
   // Allocate the empty function as the prototype for function ECMAScript
   // 262 15.3.4.
   Handle<String> symbol = FACTORY->LookupAsciiSymbol("Empty");
   Handle<JSFunction> empty_function =
       FACTORY->NewFunctionWithoutPrototype(symbol, kNonStrictMode);
 
   // --- E m p t y ---
   Handle<Code> code =
       Handle<Code>(Isolate::Current()->builtins()->builtin(
-          Builtins::EmptyFunction));
+          Builtins::kEmptyFunction));
   empty_function->set_code(*code);
   empty_function->shared()->set_code(*code);
   Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("() {}"));
   Handle<Script> script = FACTORY->NewScript(source);
   script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
   empty_function->shared()->set_script(*script);
   empty_function->shared()->set_start_position(0);
   empty_function->shared()->set_end_position(source->length());
   empty_function->shared()->DontAdaptArguments();
 
@@ skipping 121 matching lines @@
           ADD_READONLY_PROTOTYPE, empty, arguments, caller));
 
   // The final map for the strict mode functions. Writeable prototype.
   // This map is installed in MakeFunctionInstancePrototypeWritable.
   strict_mode_function_instance_map_writable_prototype_ =
       CreateStrictModeFunctionMap(
           ADD_WRITEABLE_PROTOTYPE, empty, arguments, caller);
 
   // Create the ThrowTypeError function instances.
   Handle<JSFunction> arguments_throw =
-      CreateThrowTypeErrorFunction(Builtins::StrictFunctionArguments);
+      CreateThrowTypeErrorFunction(Builtins::kStrictFunctionArguments);
   Handle<JSFunction> caller_throw =
-      CreateThrowTypeErrorFunction(Builtins::StrictFunctionCaller);
+      CreateThrowTypeErrorFunction(Builtins::kStrictFunctionCaller);
 
   // Complete the callback fixed arrays.
   arguments->set(0, *arguments_throw);
   arguments->set(1, *arguments_throw);
   caller->set(0, *caller_throw);
   caller->set(1, *caller_throw);
 }
 
 
 static void AddToWeakGlobalContextList(Context* context) {
@@ skipping 63 matching lines @@
     Handle<Object> proto_template(global_constructor->prototype_template());
     if (!proto_template->IsUndefined()) {
       js_global_template =
           Handle<ObjectTemplateInfo>::cast(proto_template);
     }
   }
 
   if (js_global_template.is_null()) {
     Handle<String> name = Handle<String>(HEAP->empty_symbol());
     Handle<Code> code = Handle<Code>(Isolate::Current()->builtins()->builtin(
-        Builtins::Illegal));
+        Builtins::kIllegal));
     js_global_function =
         FACTORY->NewFunction(name, JS_GLOBAL_OBJECT_TYPE,
                              JSGlobalObject::kSize, code, true);
     // Change the constructor property of the prototype of the
     // hidden global function to refer to the Object function.
     Handle<JSObject> prototype =
         Handle<JSObject>(
             JSObject::cast(js_global_function->instance_prototype()));
     SetLocalPropertyNoThrow(
         prototype,
@@ skipping 13 matching lines @@
       FACTORY->NewGlobalObject(js_global_function);
   if (inner_global_out != NULL) {
     *inner_global_out = inner_global;
   }
 
   // Step 2: create or re-initialize the global proxy object.
   Handle<JSFunction> global_proxy_function;
   if (global_template.IsEmpty()) {
     Handle<String> name = Handle<String>(HEAP->empty_symbol());
     Handle<Code> code = Handle<Code>(Isolate::Current()->builtins()->builtin(
-        Builtins::Illegal));
+        Builtins::kIllegal));
     global_proxy_function =
         FACTORY->NewFunction(name, JS_GLOBAL_PROXY_TYPE,
                              JSGlobalProxy::kSize, code, true);
   } else {
     Handle<ObjectTemplateInfo> data =
         v8::Utils::OpenHandle(*global_template);
     Handle<FunctionTemplateInfo> global_constructor(
             FunctionTemplateInfo::cast(data->constructor()));
     global_proxy_function =
         FACTORY->CreateApiFunction(global_constructor,
@@ skipping 68 matching lines @@
   global_context()->set_security_token(*inner_global);
 
   Handle<String> object_name = Handle<String>(HEAP->Object_symbol());
   SetLocalPropertyNoThrow(inner_global, object_name,
                           Isolate::Current()->object_function(), DONT_ENUM);
 
   Handle<JSObject> global = Handle<JSObject>(global_context()->global());
 
   // Install global Function object
   InstallFunction(global, "Function", JS_FUNCTION_TYPE, JSFunction::kSize,
-                  empty_function, Builtins::Illegal, true);  // ECMA native.
+                  empty_function, Builtins::kIllegal, true);  // ECMA native.
 
   {  // --- A r r a y ---
     Handle<JSFunction> array_function =
         InstallFunction(global, "Array", JS_ARRAY_TYPE, JSArray::kSize,
                         Isolate::Current()->initial_object_prototype(),
-                        Builtins::ArrayCode, true);
+                        Builtins::kArrayCode, true);
     array_function->shared()->set_construct_stub(
-        Isolate::Current()->builtins()->builtin(Builtins::ArrayConstructCode));
+        Isolate::Current()->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<DescriptorArray> array_descriptors =
         FACTORY->CopyAppendProxyDescriptor(
             FACTORY->empty_descriptor_array(),
             FACTORY->length_symbol(),
             FACTORY->NewProxy(&Accessors::ArrayLength),
             static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE));
 
     // Cache the fast JavaScript array map
     global_context()->set_js_array_map(array_function->initial_map());
     global_context()->js_array_map()->set_instance_descriptors(
         *array_descriptors);
     // 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);
   }
 
   {  // --- N u m b e r ---
     Handle<JSFunction> number_fun =
         InstallFunction(global, "Number", JS_VALUE_TYPE, JSValue::kSize,
                         Isolate::Current()->initial_object_prototype(),
-                        Builtins::Illegal, true);
+                        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::Current()->initial_object_prototype(),
-                        Builtins::Illegal, true);
+                        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::Current()->initial_object_prototype(),
-                        Builtins::Illegal, true);
+                        Builtins::kIllegal, true);
     string_fun->shared()->set_construct_stub(
-        Isolate::Current()->builtins()->builtin(Builtins::StringConstructCode));
+        Isolate::Current()->builtins()->builtin(
+            Builtins::kStringConstructCode));
     global_context()->set_string_function(*string_fun);
     // Add 'length' property to strings.
     Handle<DescriptorArray> string_descriptors =
         FACTORY->CopyAppendProxyDescriptor(
             FACTORY->empty_descriptor_array(),
             FACTORY->length_symbol(),
             FACTORY->NewProxy(&Accessors::StringLength),
             static_cast<PropertyAttributes>(DONT_ENUM |
                                             DONT_DELETE |
                                             READ_ONLY));
 
     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_VALUE_TYPE, JSValue::kSize,
                         Isolate::Current()->initial_object_prototype(),
-                        Builtins::Illegal, true);
+                        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::Current()->initial_object_prototype(),
-                        Builtins::Illegal, true);
+                        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());
 
     Handle<DescriptorArray> descriptors = FACTORY->NewDescriptorArray(5);
     PropertyAttributes final =
         static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
@@ skipping 64 matching lines @@
     SetLocalPropertyNoThrow(global, name, json_object, DONT_ENUM);
     global_context()->set_json_object(*json_object);
   }
 
   {  // --- arguments_boilerplate_
     // Make sure we can recognize argument objects at runtime.
     // This is done by introducing an anonymous function with
     // class_name equals 'Arguments'.
     Handle<String> symbol = FACTORY->LookupAsciiSymbol("Arguments");
     Handle<Code> code = Handle<Code>(
-        Isolate::Current()->builtins()->builtin(Builtins::Illegal));
+        Isolate::Current()->builtins()->builtin(Builtins::kIllegal));
     Handle<JSObject> prototype =
         Handle<JSObject>(
             JSObject::cast(global_context()->object_function()->prototype()));
 
     Handle<JSFunction> function =
         FACTORY->NewFunctionWithPrototype(symbol,
                                           JS_OBJECT_TYPE,
                                           JSObject::kHeaderSize,
                                           prototype,
                                           code,
@@ skipping 34 matching lines @@
 
   {  // --- strict mode arguments boilerplate
     const PropertyAttributes attributes =
       static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
 
     // Create the ThrowTypeError functions.
     Handle<FixedArray> callee = FACTORY->NewFixedArray(2, TENURED);
     Handle<FixedArray> caller = FACTORY->NewFixedArray(2, TENURED);
 
     Handle<JSFunction> callee_throw =
-        CreateThrowTypeErrorFunction(Builtins::StrictArgumentsCallee);
+        CreateThrowTypeErrorFunction(Builtins::kStrictArgumentsCallee);
     Handle<JSFunction> caller_throw =
-        CreateThrowTypeErrorFunction(Builtins::StrictArgumentsCaller);
+        CreateThrowTypeErrorFunction(Builtins::kStrictArgumentsCaller);
 
     // Install the ThrowTypeError functions.
     callee->set(0, *callee_throw);
     callee->set(1, *callee_throw);
     caller->set(0, *caller_throw);
     caller->set(1, *caller_throw);
 
     // Create the descriptor array for the arguments object.
     Handle<DescriptorArray> descriptors = FACTORY->NewDescriptorArray(3);
     {  // length
@@ skipping 42 matching lines @@
 
     // Check the state of the object.
     ASSERT(result->HasFastProperties());
     ASSERT(result->HasFastElements());
 #endif
   }
 
   {  // --- context extension
     // Create a function for the context extension objects.
     Handle<Code> code = Handle<Code>(
-        Isolate::Current()->builtins()->builtin(Builtins::Illegal));
+        Isolate::Current()->builtins()->builtin(Builtins::kIllegal));
     Handle<JSFunction> context_extension_fun =
         FACTORY->NewFunction(FACTORY->empty_symbol(),
                              JS_CONTEXT_EXTENSION_OBJECT_TYPE,
                              JSObject::kHeaderSize,
                              code,
                              true);
 
     Handle<String> name = FACTORY->LookupAsciiSymbol("context_extension");
     context_extension_fun->shared()->set_instance_class_name(*name);
     global_context()->set_context_extension_function(*context_extension_fun);
   }
 
 
   {
     // Setup the call-as-function delegate.
     Handle<Code> code =
         Handle<Code>(Isolate::Current()->builtins()->builtin(
-            Builtins::HandleApiCallAsFunction));
+            Builtins::kHandleApiCallAsFunction));
     Handle<JSFunction> delegate =
         FACTORY->NewFunction(FACTORY->empty_symbol(), JS_OBJECT_TYPE,
                              JSObject::kHeaderSize, code, true);
     global_context()->set_call_as_function_delegate(*delegate);
     delegate->shared()->DontAdaptArguments();
   }
 
   {
     // Setup the call-as-constructor delegate.
     Handle<Code> code =
         Handle<Code>(Isolate::Current()->builtins()->builtin(
-            Builtins::HandleApiCallAsConstructor));
+            Builtins::kHandleApiCallAsConstructor));
     Handle<JSFunction> delegate =
         FACTORY->NewFunction(FACTORY->empty_symbol(), JS_OBJECT_TYPE,
                              JSObject::kHeaderSize, code, true);
     global_context()->set_call_as_constructor_delegate(*delegate);
     delegate->shared()->DontAdaptArguments();
   }
 
   // Initialize the out of memory slot.
   global_context()->set_out_of_memory(HEAP->false_value());
 
@@ skipping 112 matching lines @@
 
 bool Genesis::InstallNatives() {
   HandleScope scope;
   Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
 
   // Create a function for the builtins object. Allocate space for the
   // JavaScript builtins, a reference to the builtins object
   // (itself) and a reference to the global_context directly in the object.
   Handle<Code> code = Handle<Code>(
-      isolate->builtins()->builtin(Builtins::Illegal));
+      isolate->builtins()->builtin(Builtins::kIllegal));
   Handle<JSFunction> builtins_fun =
       factory->NewFunction(factory->empty_symbol(), JS_BUILTINS_OBJECT_TYPE,
                            JSBuiltinsObject::kSize, code, true);
 
   Handle<String> name = factory->LookupAsciiSymbol("builtins");
   builtins_fun->shared()->set_instance_class_name(*name);
 
   // Allocate the builtins object.
   Handle<JSBuiltinsObject> builtins =
       Handle<JSBuiltinsObject>::cast(factory->NewGlobalObject(builtins_fun));
@@ skipping 24 matching lines @@
     factory->NewFunctionContext(Context::MIN_CONTEXT_SLOTS, bridge);
   context->set_global(*builtins);  // override builtins global object
 
   global_context()->set_runtime_context(*context);
 
   {  // -- S c r i p t
     // Builtin functions for Script.
     Handle<JSFunction> script_fun =
         InstallFunction(builtins, "Script", JS_VALUE_TYPE, JSValue::kSize,
                         isolate->initial_object_prototype(),
-                        Builtins::Illegal, false);
+                        Builtins::kIllegal, false);
     Handle<JSObject> prototype =
         factory->NewJSObject(isolate->object_function(), TENURED);
     SetPrototype(script_fun, prototype);
     global_context()->set_script_function(*script_fun);
 
     // Add 'source' and 'data' property to scripts.
     PropertyAttributes common_attributes =
         static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
     Handle<Proxy> proxy_source = factory->NewProxy(&Accessors::ScriptSource);
     Handle<DescriptorArray> script_descriptors =
@@ skipping 104 matching lines @@
     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 =
         InstallFunction(builtins, "OpaqueReference", JS_VALUE_TYPE,
                         JSValue::kSize,
                         isolate->initial_object_prototype(),
-                        Builtins::Illegal, false);
+                        Builtins::kIllegal, false);
     Handle<JSObject> prototype =
         factory->NewJSObject(isolate->object_function(), TENURED);
     SetPrototype(opaque_reference_fun, prototype);
     global_context()->set_opaque_reference_function(*opaque_reference_fun);
   }
 
   {  // --- I n t e r n a l   A r r a y ---
     // An array constructor on the builtins object that works like
     // the public Array constructor, except that its prototype
     // doesn't inherit from Object.prototype.
     // To be used only for internal work by builtins. Instances
     // must not be leaked to user code.
     // Only works correctly when called as a constructor. The normal
     // Array code uses Array.prototype as prototype when called as
     // a function.
     Handle<JSFunction> array_function =
         InstallFunction(builtins,
                         "InternalArray",
                         JS_ARRAY_TYPE,
                         JSArray::kSize,
                         isolate->initial_object_prototype(),
-                        Builtins::ArrayCode,
+                        Builtins::kArrayCode,
                         true);
     Handle<JSObject> prototype =
         factory->NewJSObject(isolate->object_function(), TENURED);
     SetPrototype(array_function, prototype);
 
     array_function->shared()->set_construct_stub(
-        isolate->builtins()->builtin(Builtins::ArrayConstructCode));
+        isolate->builtins()->builtin(Builtins::kArrayConstructCode));
     array_function->shared()->DontAdaptArguments();
 
     // Make "length" magic on instances.
     Handle<DescriptorArray> array_descriptors =
         factory->CopyAppendProxyDescriptor(
             factory->empty_descriptor_array(),
             factory->length_symbol(),
             factory->NewProxy(&Accessors::ArrayLength),
             static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE));
 
@@ skipping 34 matching lines @@
   { Handle<String> key = factory->function_class_symbol();
     Handle<JSFunction> function =
         Handle<JSFunction>::cast(GetProperty(isolate->global(), key));
     Handle<JSObject> proto =
         Handle<JSObject>(JSObject::cast(function->instance_prototype()));
 
     // Install the call and the apply functions.
     Handle<JSFunction> call =
         InstallFunction(proto, "call", JS_OBJECT_TYPE, JSObject::kHeaderSize,
                         Handle<JSObject>::null(),
-                        Builtins::FunctionCall,
+                        Builtins::kFunctionCall,
                         false);
     Handle<JSFunction> apply =
         InstallFunction(proto, "apply", JS_OBJECT_TYPE, JSObject::kHeaderSize,
                         Handle<JSObject>::null(),
-                        Builtins::FunctionApply,
+                        Builtins::kFunctionApply,
                         false);
 
     // Make sure that Function.prototype.call appears to be compiled.
     // The code will never be called, but inline caching for call will
     // only work if it appears to be compiled.
     call->shared()->DontAdaptArguments();
     ASSERT(call->is_compiled());
 
     // Set the expected parameters for apply to 2; required by builtin.
     apply->shared()->set_formal_parameter_count(2);
@@ skipping 569 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal