[ignition] Reuse code-stub-assembler's context load operations.

src/interpreter/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/interpreter/interpreter-assembler.h"
 
 #include <limits>
 #include <ostream>
 
 #include "src/code-factory.h"
@@ skipping 86 matching lines @@
   Label context_search(this, 2, context_search_loop_variables);
 
   // Fast path if the depth is 0.
   Branch(Word32Equal(depth, Int32Constant(0)), &context_found, &context_search);
 
   // Loop until the depth is 0.
   Bind(&context_search);
   {
     cur_depth.Bind(Int32Sub(cur_depth.value(), Int32Constant(1)));
     cur_context.Bind(
-        LoadContextSlot(cur_context.value(), Context::PREVIOUS_INDEX));
+        LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX));
 
     Branch(Word32Equal(cur_depth.value(), Int32Constant(0)), &context_found,
            &context_search);
   }
 
   Bind(&context_found);
   return cur_context.value();
 }
 
 void InterpreterAssembler::GotoIfHasContextExtensionUpToDepth(Node* context,
@@ skipping 10 matching lines @@
 
   // Loop until the depth is 0.
   Goto(&context_search);
   Bind(&context_search);
   {
     // TODO(leszeks): We only need to do this check if the context had a sloppy
     // eval, we could pass in a context chain bitmask to figure out which
     // contexts actually need to be checked.
 
     Node* extension_slot =
-        LoadContextSlot(cur_context.value(), Context::EXTENSION_INDEX);
+        LoadContextElement(cur_context.value(), Context::EXTENSION_INDEX);
 
     // Jump to the target if the extension slot is not a hole.
     GotoIf(WordNotEqual(extension_slot, TheHoleConstant()), target);
 
     cur_depth.Bind(Int32Sub(cur_depth.value(), Int32Constant(1)));
     cur_context.Bind(
-        LoadContextSlot(cur_context.value(), Context::PREVIOUS_INDEX));
+        LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX));
 
     GotoIf(Word32NotEqual(cur_depth.value(), Int32Constant(0)),
            &context_search);
   }
 }
 
 Node* InterpreterAssembler::BytecodeOffset() {
   return bytecode_offset_.value();
 }
 
@@ skipping 322 matching lines @@
       IntPtrAdd(IntPtrConstant(offset), WordShl(index, kPointerSizeLog2));
   if (Is64()) {
     return ChangeInt32ToInt64(
         Load(MachineType::Int32(), constant_pool, entry_offset));
   } else {
     return SmiUntag(
         Load(MachineType::AnyTagged(), constant_pool, entry_offset));
   }
 }
 
-Node* InterpreterAssembler::LoadContextSlot(Node* context, int slot_index) {
-  return Load(MachineType::AnyTagged(), context,
-              IntPtrConstant(Context::SlotOffset(slot_index)));
-}
-
 Node* InterpreterAssembler::LoadContextSlot(Node* context, Node* slot_index) {
   Node* offset =
       IntPtrAdd(WordShl(slot_index, kPointerSizeLog2),
                 IntPtrConstant(Context::kHeaderSize - kHeapObjectTag));
   return Load(MachineType::AnyTagged(), context, offset);
 }
 
 Node* InterpreterAssembler::StoreContextSlot(Node* context, Node* slot_index,
                                              Node* value) {
   Node* offset =
@@ skipping 875 matching lines @@
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8