[Interpreter] Add support for new local function context creation.

src/compiler/interpreter-assembler.cc

 // Copyright 2015 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/compiler/interpreter-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 17 matching lines @@
 InterpreterAssembler::InterpreterAssembler(Isolate* isolate, Zone* zone,
                                            interpreter::Bytecode bytecode)
     : bytecode_(bytecode),
       raw_assembler_(new RawMachineAssembler(
           isolate, new (zone) Graph(zone),
           Linkage::GetInterpreterDispatchDescriptor(zone), kMachPtr,
           InstructionSelector::SupportedMachineOperatorFlags())),
       end_nodes_(zone),
       accumulator_(
           raw_assembler_->Parameter(Linkage::kInterpreterAccumulatorParameter)),
+      context_(
+          raw_assembler_->Parameter(Linkage::kInterpreterContextParameter)),
       code_generated_(false) {}
 
 
 InterpreterAssembler::~InterpreterAssembler() {}
 
 
 Handle<Code> InterpreterAssembler::GenerateCode() {
   DCHECK(!code_generated_);
 
   End();
@@ skipping 11 matching lines @@
     code->Disassemble(bytecode_name, os);
     os << std::flush;
   }
 #endif
 
   code_generated_ = true;
   return code;
 }
 
 
-Node* InterpreterAssembler::GetAccumulator() {
-  return accumulator_;
-}
+Node* InterpreterAssembler::GetAccumulator() { return accumulator_; }
 
 
-void InterpreterAssembler::SetAccumulator(Node* value) {
-  accumulator_ = value;
-}
+void InterpreterAssembler::SetAccumulator(Node* value) { accumulator_ = value; }
 
 
-Node* InterpreterAssembler::ContextTaggedPointer() {
-  return raw_assembler_->Parameter(Linkage::kInterpreterContextParameter);
-}
+Node* InterpreterAssembler::GetContext() { return context_; }
+
+
+void InterpreterAssembler::SetContext(Node* value) { context_ = value; }
 
 
 Node* InterpreterAssembler::RegisterFileRawPointer() {
   return raw_assembler_->Parameter(Linkage::kInterpreterRegisterFileParameter);
 }
 
 
 Node* InterpreterAssembler::BytecodeArrayTaggedPointer() {
   return raw_assembler_->Parameter(Linkage::kInterpreterBytecodeArrayParameter);
 }
@@ skipping 240 matching lines @@
   Callable callable = CodeFactory::InterpreterPushArgsAndCall(isolate());
   CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 0, CallDescriptor::kNoFlags);
 
   Node* code_target = HeapConstant(callable.code());
 
   Node** args = zone()->NewArray<Node*>(4);
   args[0] = arg_count;
   args[1] = first_arg;
   args[2] = function;
-  args[3] = ContextTaggedPointer();
+  args[3] = GetContext();
 
   return CallN(descriptor, code_target, args);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
                                    Node* target, Node** args) {
   CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), descriptor, 0, CallDescriptor::kNoFlags);
   return CallN(call_descriptor, target, args);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
                                    Node* target, Node* arg1, Node* arg2,
                                    Node* arg3, Node* arg4) {
   Node** args = zone()->NewArray<Node*>(5);
   args[0] = arg1;
   args[1] = arg2;
   args[2] = arg3;
   args[3] = arg4;
-  args[4] = ContextTaggedPointer();
+  args[4] = GetContext();
   return CallIC(descriptor, target, args);
 }
 
 
 Node* InterpreterAssembler::CallIC(CallInterfaceDescriptor descriptor,
                                    Node* target, Node* arg1, Node* arg2,
                                    Node* arg3, Node* arg4, Node* arg5) {
   Node** args = zone()->NewArray<Node*>(6);
   args[0] = arg1;
   args[1] = arg2;
   args[2] = arg3;
   args[3] = arg4;
   args[4] = arg5;
-  args[5] = ContextTaggedPointer();
+  args[5] = GetContext();
   return CallIC(descriptor, target, args);
 }
 
 
 Node* InterpreterAssembler::CallRuntime(Node* function_id, Node* first_arg,
                                         Node* arg_count) {
   Callable callable = CodeFactory::InterpreterCEntry(isolate());
   CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 0, CallDescriptor::kNoFlags);
 
   Node* code_target = HeapConstant(callable.code());
 
   // Get the function entry from the function id.
   Node* function_table = raw_assembler_->ExternalConstant(
       ExternalReference::runtime_function_table_address(isolate()));
   Node* function_offset = raw_assembler_->Int32Mul(
       function_id, Int32Constant(sizeof(Runtime::Function)));
   Node* function = IntPtrAdd(function_table, function_offset);
   Node* function_entry = raw_assembler_->Load(
       kMachPtr, function, Int32Constant(offsetof(Runtime::Function, entry)));
 
   Node** args = zone()->NewArray<Node*>(4);
   args[0] = arg_count;
   args[1] = first_arg;
   args[2] = function_entry;
-  args[3] = ContextTaggedPointer();
+  args[3] = GetContext();
 
   return CallN(descriptor, code_target, args);
 }
 
 
 Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id,
                                         Node* arg1) {
-  return raw_assembler_->CallRuntime1(function_id, arg1,
-                                      ContextTaggedPointer());
+  return raw_assembler_->CallRuntime1(function_id, arg1, GetContext());
 }
 
 
 Node* InterpreterAssembler::CallRuntime(Runtime::FunctionId function_id,
                                         Node* arg1, Node* arg2) {
-  return raw_assembler_->CallRuntime2(function_id, arg1, arg2,
-                                      ContextTaggedPointer());
+  return raw_assembler_->CallRuntime2(function_id, arg1, arg2, GetContext());
 }
 
 
 void InterpreterAssembler::Return() {
   Node* exit_trampoline_code_object =
       HeapConstant(isolate()->builtins()->InterpreterExitTrampoline());
   // If the order of the parameters you need to change the call signature below.
   STATIC_ASSERT(0 == Linkage::kInterpreterAccumulatorParameter);
   STATIC_ASSERT(1 == Linkage::kInterpreterRegisterFileParameter);
   STATIC_ASSERT(2 == Linkage::kInterpreterBytecodeOffsetParameter);
   STATIC_ASSERT(3 == Linkage::kInterpreterBytecodeArrayParameter);
   STATIC_ASSERT(4 == Linkage::kInterpreterDispatchTableParameter);
   STATIC_ASSERT(5 == Linkage::kInterpreterContextParameter);
   Node* args[] = { GetAccumulator(),
                    RegisterFileRawPointer(),
                    BytecodeOffset(),
                    BytecodeArrayTaggedPointer(),
                    DispatchTableRawPointer(),
-                   ContextTaggedPointer() };
+                   GetContext() };
   Node* tail_call = raw_assembler_->TailCallN(
       call_descriptor(), exit_trampoline_code_object, args);
   // This should always be the end node.
   AddEndInput(tail_call);
 }
 
 
 Node* InterpreterAssembler::Advance(int delta) {
   return IntPtrAdd(BytecodeOffset(), Int32Constant(delta));
 }
@@ skipping 39 matching lines @@
   STATIC_ASSERT(1 == Linkage::kInterpreterRegisterFileParameter);
   STATIC_ASSERT(2 == Linkage::kInterpreterBytecodeOffsetParameter);
   STATIC_ASSERT(3 == Linkage::kInterpreterBytecodeArrayParameter);
   STATIC_ASSERT(4 == Linkage::kInterpreterDispatchTableParameter);
   STATIC_ASSERT(5 == Linkage::kInterpreterContextParameter);
   Node* args[] = { GetAccumulator(),
                    RegisterFileRawPointer(),
                    new_bytecode_offset,
                    BytecodeArrayTaggedPointer(),
                    DispatchTableRawPointer(),
-                   ContextTaggedPointer() };
+                   GetContext() };
   Node* tail_call =
       raw_assembler_->TailCallN(call_descriptor(), target_code_object, args);
   // This should always be the end node.
   AddEndInput(tail_call);
 }
 
 
 void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
                                                BailoutReason bailout_reason) {
   RawMachineAssembler::Label match, no_match;
@@ skipping 52 matching lines @@
   return raw_assembler_->schedule();
 }
 
 
 Zone* InterpreterAssembler::zone() { return raw_assembler_->zone(); }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8