[interpreter] Add CreateFunctionContext bytecode

src/code-stubs.cc

 // Copyright 2012 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 "src/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 4605 matching lines @@
                                             assembler->UndefinedConstant());
 
   return result;
 }
 
 void FastNewClosureStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   assembler->Return(
       Generate(assembler, assembler->Parameter(0), assembler->Parameter(1)));
 }
 
-void FastNewFunctionContextStub::GenerateAssembly(
-    CodeStubAssembler* assembler) const {
+// static
+compiler::Node* FastNewFunctionContextStub::Generate(
+    CodeStubAssembler* assembler, compiler::Node* function,
+    compiler::Node* slots, compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
-  Node* function = assembler->Parameter(Descriptor::kFunction);
-  Node* slots = assembler->Parameter(FastNewFunctionContextDescriptor::kSlots);
-  Node* context = assembler->Parameter(Descriptor::kContext);
-
   Node* min_context_slots =
       assembler->Int32Constant(Context::MIN_CONTEXT_SLOTS);
   Node* length = assembler->Int32Add(slots, min_context_slots);
   Node* size = assembler->Int32Add(
       assembler->Word32Shl(length, assembler->Int32Constant(kPointerSizeLog2)),
       assembler->Int32Constant(FixedArray::kHeaderSize));
 
   // Create a new closure from the given function info in new space
   Node* function_context = assembler->Allocate(size);
 
+  Isolate* isolate = assembler->isolate();
   assembler->StoreMapNoWriteBarrier(
       function_context,
-      assembler->HeapConstant(isolate()->factory()->function_context_map()));
+      assembler->HeapConstant(isolate->factory()->function_context_map()));
   assembler->StoreObjectFieldNoWriteBarrier(function_context,
                                             Context::kLengthOffset,
                                             assembler->SmiFromWord32(length));
 
   // Set up the fixed slots.
   assembler->StoreFixedArrayElement(
       function_context, assembler->Int32Constant(Context::CLOSURE_INDEX),
       function, SKIP_WRITE_BARRIER);
   assembler->StoreFixedArrayElement(
       function_context, assembler->Int32Constant(Context::PREVIOUS_INDEX),
@@ skipping 23 matching lines @@
     assembler->StoreFixedArrayElement(function_context, slot_index, undefined,
                                       SKIP_WRITE_BARRIER);
     Node* one = assembler->Int32Constant(1);
     Node* next_index = assembler->Int32Add(slot_index, one);
     var_slot_index.Bind(next_index);
     assembler->Branch(assembler->Int32LessThan(next_index, length), &loop,
                       &after_loop);
   }
   assembler->Bind(&after_loop);
 
-  assembler->Return(function_context);
+  return function_context;
+}
+
+void FastNewFunctionContextStub::GenerateAssembly(
+    CodeStubAssembler* assembler) const {
+  typedef compiler::Node Node;
+  Node* function = assembler->Parameter(Descriptor::kFunction);
+  Node* slots = assembler->Parameter(FastNewFunctionContextDescriptor::kSlots);
+  Node* context = assembler->Parameter(Descriptor::kContext);
+
+  assembler->Return(Generate(assembler, function, slots, context));
 }
 
 void CreateAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateAllocationSiteStub stub(isolate);
   stub.GetCode();
 }
 
 
 void CreateWeakCellStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateWeakCellStub stub(isolate);
@@ skipping 359 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8