[Interpreter] Add support for global declarations and load/store of global variables

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 273 matching lines @@
   return raw_assembler_->Load(kMachAnyTagged, constant_pool, entry_offset);
 }
 
 
 Node* InterpreterAssembler::LoadObjectField(Node* object, int offset) {
   return raw_assembler_->Load(kMachAnyTagged, object,
                               IntPtrConstant(offset - kHeapObjectTag));
 }
 
 
-Node* InterpreterAssembler::LoadContextSlot(Node* context, int slot_index) {
-  return raw_assembler_->Load(kMachAnyTagged, context,
-                              IntPtrConstant(Context::SlotOffset(slot_index)));
+Node* InterpreterAssembler::LoadContextSlot(Node* context, Node* slot_index) {
+  Node* offset =
+      IntPtrAdd(WordShl(slot_index, kPointerSizeLog2),
+                Int32Constant(Context::kHeaderSize - kHeapObjectTag));
+  return raw_assembler_->Load(kMachAnyTagged, context, offset);
 }
 
 
-Node* InterpreterAssembler::LoadContextSlot(int slot_index) {
-  return LoadContextSlot(ContextTaggedPointer(), slot_index);
-}
-
-
 Node* InterpreterAssembler::LoadTypeFeedbackVector() {
   Node* function = raw_assembler_->Load(
       kMachAnyTagged, RegisterFileRawPointer(),
       IntPtrConstant(InterpreterFrameConstants::kFunctionFromRegisterPointer));
   Node* shared_info =
       LoadObjectField(function, JSFunction::kSharedFunctionInfoOffset);
   Node* vector =
       LoadObjectField(shared_info, SharedFunctionInfo::kFeedbackVectorOffset);
   return vector;
 }
 
 
-Node* InterpreterAssembler::CallN(CallDescriptor* descriptor,
-                                  Node* code_target,
+Node* InterpreterAssembler::CallN(CallDescriptor* descriptor, Node* code_target,
                                   Node** args) {
   Node* stack_pointer_before_call = nullptr;
   if (FLAG_debug_code) {
     stack_pointer_before_call = raw_assembler_->LoadStackPointer();
   }
   Node* return_val = raw_assembler_->CallN(descriptor, code_target, args);
   if (FLAG_debug_code) {
     Node* stack_pointer_after_call = raw_assembler_->LoadStackPointer();
     AbortIfWordNotEqual(stack_pointer_before_call, stack_pointer_after_call,
                         kUnexpectedStackPointer);
@@ skipping 172 matching lines @@
                    BytecodeArrayTaggedPointer(),
                    DispatchTableRawPointer(),
                    ContextTaggedPointer() };
   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) {
+void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
+                                               BailoutReason bailout_reason) {
   RawMachineAssembler::Label match, no_match;
   Node* condition = raw_assembler_->WordEqual(lhs, rhs);
   raw_assembler_->Branch(condition, &match, &no_match);
   raw_assembler_->Bind(&no_match);
   Node* abort_id = SmiTag(Int32Constant(bailout_reason));
   CallRuntime(Runtime::kAbort, abort_id);
   Return();
   raw_assembler_->Bind(&match);
 }
 
@@ skipping 43 matching lines @@
   return raw_assembler_->schedule();
 }
 
 
 Zone* InterpreterAssembler::zone() { return raw_assembler_->zone(); }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8