Set code on the SharedFunctionInfo before creating the function.

src/factory.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 "factory.h"
 
 #include "macro-assembler.h"
 #include "isolate-inl.h"
 #include "v8conversions.h"
 
@@ skipping 1233 matching lines @@
   return result;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
                                         InstanceType type,
                                         int instance_size,
                                         Handle<Code> code,
                                         bool force_initial_map) {
   // Allocate the function
-  Handle<JSFunction> function = NewFunction(name, the_hole_value());
-
-  // Set up the code pointer in both the shared function info and in
-  // the function itself.
-  function->shared()->set_code(*code);
-  function->set_code(*code);
+  Handle<JSFunction> function = NewFunction(name, code, the_hole_value());
 
   if (force_initial_map ||
       type != JS_OBJECT_TYPE ||
       instance_size != JSObject::kHeaderSize) {
     Handle<Map> initial_map = NewMap(type, instance_size);
     Handle<JSObject> prototype = NewFunctionPrototype(function);
     initial_map->set_prototype(*prototype);
     function->set_initial_map(*initial_map);
     initial_map->set_constructor(*function);
   } else {
     ASSERT(!function->has_initial_map());
     ASSERT(!function->has_prototype());
   }
 
   return function;
 }
 
 
 Handle<JSFunction> Factory::NewFunctionWithPrototype(Handle<String> name,
                                                      InstanceType type,
                                                      int instance_size,
                                                      Handle<JSObject> prototype,
                                                      Handle<Code> code,
                                                      bool force_initial_map) {
   // Allocate the function.
-  Handle<JSFunction> function = NewFunction(name, prototype);
-
-  // Set up the code pointer in both the shared function info and in
-  // the function itself.
-  function->shared()->set_code(*code);
-  function->set_code(*code);
+  Handle<JSFunction> function = NewFunction(name, code, prototype);
 
   if (force_initial_map ||
       type != JS_OBJECT_TYPE ||
       instance_size != JSObject::kHeaderSize) {
     Handle<Map> initial_map = NewMap(type,
                                      instance_size,
                                      GetInitialFastElementsKind());
     function->set_initial_map(*initial_map);
     initial_map->set_constructor(*function);
   }
@@ skipping 699 matching lines @@
                                         PretenureFlag pretenure) {
   Handle<Map> map = MapForNewFunction(isolate(), info, maybe_prototype);
   AllocationSpace space = pretenure == TENURED ? OLD_POINTER_SPACE : NEW_SPACE;
   Handle<JSFunction> result = New<JSFunction>(map, space);
   InitializeFunction(result, info, context, maybe_prototype);
   return result;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
-                                        Handle<Object> prototype) {
+                                        Handle<Code> code,
+                                        MaybeHandle<Object> maybe_prototype) {
+  Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name);
+  info->set_code(*code);
+  Handle<Context> context(isolate()->context()->native_context());
+  return NewFunction(info, context, maybe_prototype);
+}
+
+
+Handle<JSFunction> Factory::NewFunctionWithPrototype(Handle<String> name,
+                                                     Handle<Object> prototype) {
   Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name);
   Handle<Context> context(isolate()->context()->native_context());
   return NewFunction(info, context, prototype);
 }
 
 
-Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
-                                                        Handle<Code> code) {
-  Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name);
-  info->set_code(*code);
-  Handle<Context> context(isolate()->context()->native_context());
-  return NewFunction(info, context, MaybeHandle<Object>());
-}
-
-
 #ifdef ENABLE_DEBUGGER_SUPPORT
 Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
   // Get the original code of the function.
   Handle<Code> code(shared->code());
 
   // Create a copy of the code before allocating the debug info object to avoid
   // allocation while setting up the debug info object.
   Handle<Code> original_code(*Factory::CopyCode(code));
 
   // Allocate initial fixed array for active break points before allocating the
@@ skipping 281 matching lines @@
   if (String::Equals(name, infinity_string())) return infinity_value();
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 } }  // namespace v8::internal