- Remove function boilerplate objects and use SharedFunctionInfos in...

src/handles.cc

 // Copyright 2009 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 156 matching lines @@
 }
 
 
 void SetExpectedNofPropertiesFromEstimate(Handle<SharedFunctionInfo> shared,
                                           int estimate) {
   shared->set_expected_nof_properties(
       ExpectedNofPropertiesFromEstimate(estimate));
 }
 
 
-void SetExpectedNofPropertiesFromEstimate(Handle<JSFunction> func,
-                                          int estimate) {
-  SetExpectedNofProperties(
-      func, ExpectedNofPropertiesFromEstimate(estimate));
-}
-
-
 void NormalizeProperties(Handle<JSObject> object,
                          PropertyNormalizationMode mode,
                          int expected_additional_properties) {
   CALL_HEAP_FUNCTION_VOID(object->NormalizeProperties(
       mode,
       expected_additional_properties));
 }
 
 
 void NormalizeElements(Handle<JSObject> object) {
@@ skipping 595 matching lines @@
   HandleScope scope;
   Handle<FixedArray> info(FixedArray::cast(obj->map()->constructor()));
   int index = Smi::cast(info->get(0))->value();
   ASSERT(index >= 0);
   Handle<Context> compile_context(Context::cast(info->get(1)));
   Handle<Context> function_context(Context::cast(info->get(2)));
   Handle<Object> receiver(compile_context->global()->builtins());
 
   Vector<const char> name = Natives::GetScriptName(index);
 
-  Handle<JSFunction> boilerplate;
+  Handle<SharedFunctionInfo> function_info;
 
-  if (!Bootstrapper::NativesCacheLookup(name, &boilerplate)) {
+  if (!Bootstrapper::NativesCacheLookup(name, &function_info)) {
     Handle<String> source_code = Bootstrapper::NativesSourceLookup(index);
     Handle<String> script_name = Factory::NewStringFromAscii(name);
     bool allow_natives_syntax = FLAG_allow_natives_syntax;
     FLAG_allow_natives_syntax = true;
-    boilerplate = Compiler::Compile(source_code, script_name, 0, 0, NULL, NULL,
-                                    Handle<String>::null(), NATIVES_CODE);
+    function_info = Compiler::Compile(source_code,
+                                      script_name,
+                                      0, 0, NULL, NULL,
+                                      Handle<String>::null(),
+                                      NATIVES_CODE);
     FLAG_allow_natives_syntax = allow_natives_syntax;
     // If the compilation failed (possibly due to stack overflows), we
     // should never enter the result in the natives cache. Instead we
     // return from the function without marking the function as having
     // been lazily loaded.
-    if (boilerplate.is_null()) {
+    if (function_info.is_null()) {
       *pending_exception = true;
       return;
     }
-    Bootstrapper::NativesCacheAdd(name, boilerplate);
+    Bootstrapper::NativesCacheAdd(name, function_info);
   }
 
   // We shouldn't get here if compiling the script failed.
-  ASSERT(!boilerplate.is_null());
+  ASSERT(!function_info.is_null());
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // When the debugger running in its own context touches lazy loaded
   // functions loading can be triggered. In that case ensure that the
   // execution of the boilerplate is in the correct context.
   SaveContext save;
   if (!Debug::debug_context().is_null() &&
       Top::context() == *Debug::debug_context()) {
     Top::set_context(*compile_context);
   }
 #endif
 
   // Reset the lazy load data before running the script to make sure
   // not to get recursive lazy loading.
   obj->map()->set_needs_loading(false);
   obj->map()->set_constructor(info->get(3));
 
   // Run the script.
   Handle<JSFunction> script_fun(
-      Factory::NewFunctionFromBoilerplate(boilerplate, function_context));
+      Factory::NewFunctionFromSharedFunctionInfo(function_info,
+                                                 function_context));
   Execution::Call(script_fun, receiver, 0, NULL, pending_exception);
 
   // If lazy loading failed, restore the unloaded state of obj.
   if (*pending_exception) {
     obj->map()->set_needs_loading(true);
     obj->map()->set_constructor(*info);
   }
 }
 
 
@@ skipping 10 matching lines @@
   Handle<Map> new_map = Factory::CopyMapDropTransitions(old_map);
   obj->set_map(*new_map);
   new_map->set_needs_loading(true);
   // Store the lazy loading info in the constructor field.  We'll
   // reestablish the constructor from the fixed array after loading.
   new_map->set_constructor(*arr);
   ASSERT(!obj->IsLoaded());
 }
 
 } }  // namespace v8::internal