[csa] Remove ParameterMode from CSA::Load/StoreFeedbackVectorSlot

... and from AccessorAssembler::LoadGlobalIC().

Tbr: tebbi@chromium.org
Bug: v8:9708
Change-Id: Ia7d2ab30cfcfd513257655eb30a466d929ac774a
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1801853
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Cr-Commit-Position: refs/heads/master@{#63759}

src/builtins/builtins-constructor-gen.cc

@@ -295,8 +295,9 @@ TNode<JSRegExp> ConstructorBuiltinsAssembler::EmitCreateRegExpLiteral(
   GotoIf(IsUndefined(maybe_feedback_vector), &call_runtime);
 
   TVARIABLE(JSRegExp, result);
-  TNode<Object> literal_site = CAST(LoadFeedbackVectorSlot(
-      maybe_feedback_vector, slot, 0, INTPTR_PARAMETERS));
+  TNode<FeedbackVector> feedback_vector = CAST(maybe_feedback_vector);
+  TNode<Object> literal_site =
+      CAST(LoadFeedbackVectorSlot(feedback_vector, slot));
   GotoIf(NotHasBoilerplate(literal_site), &call_runtime);
   {
     TNode<JSRegExp> boilerplate = CAST(literal_site);
@@ -342,7 +343,7 @@ TNode<JSArray> ConstructorBuiltinsAssembler::EmitCreateShallowArrayLiteral(
       return_result(this);
 
   TNode<Object> maybe_allocation_site =
-      CAST(LoadFeedbackVectorSlot(feedback_vector, slot, 0, INTPTR_PARAMETERS));
+      CAST(LoadFeedbackVectorSlot(feedback_vector, slot));
   GotoIf(NotHasBoilerplate(maybe_allocation_site), call_runtime);
 
   TNode<AllocationSite> allocation_site = CAST(maybe_allocation_site);
@@ -385,7 +386,7 @@ TNode<JSArray> ConstructorBuiltinsAssembler::EmitCreateEmptyArrayLiteral(
   // Array literals always have a valid AllocationSite to properly track
   // elements transitions.
   TNode<Object> maybe_allocation_site =
-      CAST(LoadFeedbackVectorSlot(feedback_vector, slot, 0, INTPTR_PARAMETERS));
+      CAST(LoadFeedbackVectorSlot(feedback_vector, slot));
   TVARIABLE(AllocationSite, allocation_site);
 
   Label create_empty_array(this),
@@ -398,8 +399,8 @@ TNode<JSArray> ConstructorBuiltinsAssembler::EmitCreateEmptyArrayLiteral(
   // TODO(cbruni): create the AllocationSite in CSA.
   BIND(&initialize_allocation_site);
   {
-    allocation_site = CreateAllocationSiteInFeedbackVector(
-        feedback_vector, SmiTag(Signed(slot)));
+    allocation_site =
+        CreateAllocationSiteInFeedbackVector(feedback_vector, slot);
     Goto(&create_empty_array);
   }
 
@@ -434,7 +435,7 @@ TNode<HeapObject> ConstructorBuiltinsAssembler::EmitCreateShallowObjectLiteral(
     TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
     Label* call_runtime) {
   TNode<Object> maybe_allocation_site =
-      CAST(LoadFeedbackVectorSlot(feedback_vector, slot, 0, INTPTR_PARAMETERS));
+      CAST(LoadFeedbackVectorSlot(feedback_vector, slot));
   GotoIf(NotHasBoilerplate(maybe_allocation_site), call_runtime);
 
   TNode<AllocationSite> allocation_site = CAST(maybe_allocation_site);

src/builtins/builtins-string-gen.cc

@@ -583,8 +583,7 @@ TF_BUILTIN(StringFromCharCode, CodeStubAssembler) {
     // Assume that the resulting string contains only one-byte characters.
     TNode<String> one_byte_result = AllocateSeqOneByteString(Unsigned(argc));
 
-    TVARIABLE(IntPtrT, var_max_index);
-    var_max_index = IntPtrConstant(0);
+    TVARIABLE(IntPtrT, var_max_index, IntPtrConstant(0));
 
     // Iterate over the incoming arguments, converting them to 8-bit character
     // codes. Stop if any of the conversions generates a code that doesn't fit
@@ -601,7 +600,6 @@ TF_BUILTIN(StringFromCharCode, CodeStubAssembler) {
       // The {code16} fits into the SeqOneByteString {one_byte_result}.
       TNode<IntPtrT> offset = ElementOffsetFromIndex(
           var_max_index.value(), UINT8_ELEMENTS,
-          CodeStubAssembler::INTPTR_PARAMETERS,
           SeqOneByteString::kHeaderSize - kHeapObjectTag);
       StoreNoWriteBarrier(MachineRepresentation::kWord8, one_byte_result,
                           offset, code16);
@@ -626,7 +624,6 @@ TF_BUILTIN(StringFromCharCode, CodeStubAssembler) {
     // Write the character that caused the 8-bit to 16-bit fault.
     TNode<IntPtrT> max_index_offset =
         ElementOffsetFromIndex(var_max_index.value(), UINT16_ELEMENTS,
-                               CodeStubAssembler::INTPTR_PARAMETERS,
                                SeqTwoByteString::kHeaderSize - kHeapObjectTag);
     StoreNoWriteBarrier(MachineRepresentation::kWord16, two_byte_result,
                         max_index_offset, code16);

src/codegen/code-stub-assembler.h

@@ -1384,9 +1384,10 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
       TNode<Int32T> elements_kind, Label* if_accessor, Label* if_hole);
 
   // Load a feedback slot from a FeedbackVector.
+  template <typename TIndex>
   TNode<MaybeObject> LoadFeedbackVectorSlot(
-      Node* object, Node* index, int additional_offset = 0,
-      ParameterMode parameter_mode = INTPTR_PARAMETERS);
+      TNode<FeedbackVector> feedback_vector, TNode<TIndex> slot,
+      int additional_offset = 0);
 
   TNode<IntPtrT> LoadFeedbackVectorLength(TNode<FeedbackVector>);
   TNode<Float64T> LoadDoubleWithHoleCheck(TNode<FixedDoubleArray> array,
@@ -1651,10 +1652,10 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   }
 
   void StoreFeedbackVectorSlot(
-      Node* object, Node* index, Node* value,
+      TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
+      TNode<AnyTaggedT> value,
       WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
-      int additional_offset = 0,
-      ParameterMode parameter_mode = INTPTR_PARAMETERS);
+      int additional_offset = 0);
 
   void EnsureArrayLengthWritable(TNode<Map> map, Label* bailout);
 
@@ -3219,7 +3220,9 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
       SloppyTNode<JSFunction> closure);
 
   // Update the type feedback vector.
-  void UpdateFeedback(Node* feedback, Node* feedback_vector, Node* slot_id);
+  void UpdateFeedback(TNode<Smi> feedback,
+                      TNode<HeapObject> maybe_feedback_vector,
+                      TNode<UintPtrT> slot_id);
 
   // Report that there was a feedback update, performing any tasks that should
   // be done after a feedback update.
@@ -3311,13 +3314,12 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
 
   // Store a weak in-place reference into the FeedbackVector.
   TNode<MaybeObject> StoreWeakReferenceInFeedbackVector(
-      SloppyTNode<FeedbackVector> feedback_vector, Node* slot,
-      SloppyTNode<HeapObject> value, int additional_offset = 0,
-      ParameterMode parameter_mode = INTPTR_PARAMETERS);
+      TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
+      TNode<HeapObject> value, int additional_offset = 0);
 
   // Create a new AllocationSite and install it into a feedback vector.
   TNode<AllocationSite> CreateAllocationSiteInFeedbackVector(
-      SloppyTNode<FeedbackVector> feedback_vector, TNode<Smi> slot);
+      TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot);
 
   // TODO(ishell, cbruni): Change to HasBoilerplate.
   TNode<BoolT> NotHasBoilerplate(TNode<Object> maybe_literal_site);
@@ -3907,22 +3909,20 @@ class V8_EXPORT_PRIVATE CodeStubArguments {
 
   // Iteration doesn't include the receiver. |first| and |last| are zero-based.
   template <typename TIndex>
-  void ForEach(const ForEachBodyFunction& body,
-               TNode<TIndex> first = TNode<TIndex>(),
-               TNode<TIndex> last = TNode<TIndex>()) {
+  void ForEach(const ForEachBodyFunction& body, TNode<TIndex> first = {},
+               TNode<TIndex> last = {}) {
     CodeStubAssembler::VariableList list(0, assembler_->zone());
     ForEach(list, body, first, last);
   }
 
   // Iteration doesn't include the receiver. |first| and |last| are zero-based.
   void ForEach(const CodeStubAssembler::VariableList& vars,
-               const ForEachBodyFunction& body,
-               TNode<IntPtrT> first = TNode<IntPtrT>(),
-               TNode<IntPtrT> last = TNode<IntPtrT>());
+               const ForEachBodyFunction& body, TNode<IntPtrT> first = {},
+               TNode<IntPtrT> last = {});
 
   void ForEach(const CodeStubAssembler::VariableList& vars,
                const ForEachBodyFunction& body, TNode<Smi> first,
-               TNode<Smi> last = TNode<Smi>()) {
+               TNode<Smi> last = {}) {
     TNode<IntPtrT> first_intptr = assembler_->ParameterToIntPtr(first);
     TNode<IntPtrT> last_intptr;
     if (last != nullptr) {

src/compiler/code-assembler.cc

@@ -29,6 +29,7 @@ namespace internal {
 
 constexpr MachineType MachineTypeOf<Smi>::value;
 constexpr MachineType MachineTypeOf<Object>::value;
+constexpr MachineType MachineTypeOf<MaybeObject>::value;
 
 namespace compiler {
 

src/ic/accessor-assembler.h

@@ -66,7 +66,7 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
 
   struct LoadICParameters {
     LoadICParameters(TNode<Context> context, Node* receiver, TNode<Object> name,
-                     Node* slot, Node* vector, Node* holder = nullptr)
+                     TNode<Smi> slot, Node* vector, Node* holder = nullptr)
         : context_(context),
           receiver_(receiver),
           name_(name),
@@ -85,7 +85,7 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
     TNode<Context> context() const { return context_; }
     Node* receiver() const { return receiver_; }
     TNode<Object> name() const { return name_; }
-    Node* slot() const { return slot_; }
+    TNode<Smi> slot() const { return slot_; }
     Node* vector() const { return vector_; }
     Node* holder() const { return holder_; }
 
@@ -93,15 +93,15 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
     TNode<Context> context_;
     Node* receiver_;
     TNode<Object> name_;
-    Node* slot_;
+    TNode<Smi> slot_;
     Node* vector_;
     Node* holder_;
   };
 
   struct LazyLoadICParameters {
     LazyLoadICParameters(LazyNode<Context> context, Node* receiver,
-                         LazyNode<Object> name, Node* slot, Node* vector,
-                         Node* holder = nullptr)
+                         LazyNode<Object> name, LazyNode<Smi> slot,
+                         Node* vector, Node* holder = nullptr)
         : context_(context),
           receiver_(receiver),
           name_(name),
@@ -111,19 +111,17 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
 
     explicit LazyLoadICParameters(const LoadICParameters* p)
         : receiver_(p->receiver()),
-          slot_(p->slot()),
           vector_(p->vector()),
           holder_(p->holder()) {
-      TNode<Context> p_context = p->context();
-      context_ = [=] { return p_context; };
-      TNode<Object> p_name = p->name();
-      name_ = [=] { return p_name; };
+      slot_ = [=] { return p->slot(); };
+      context_ = [=] { return p->context(); };
+      name_ = [=] { return p->name(); };
     }
 
     TNode<Context> context() const { return context_(); }
     Node* receiver() const { return receiver_; }
     TNode<Object> name() const { return name_(); }
-    Node* slot() const { return slot_; }
+    TNode<Smi> slot() const { return slot_(); }
     Node* vector() const { return vector_; }
     Node* holder() const { return holder_; }
 
@@ -131,16 +129,17 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
     LazyNode<Context> context_;
     Node* receiver_;
     LazyNode<Object> name_;
-    Node* slot_;
+    LazyNode<Smi> slot_;
     Node* vector_;
     Node* holder_;
   };
 
-  void LoadGlobalIC(Node* vector, Node* slot,
+  void LoadGlobalIC(TNode<HeapObject> maybe_feedback_vector,
+                    const LazyNode<Smi>& lazy_smi_slot,
+                    const LazyNode<UintPtrT>& lazy_slot,
                     const LazyNode<Context>& lazy_context,
                     const LazyNode<Name>& lazy_name, TypeofMode typeof_mode,
-                    ExitPoint* exit_point,
-                    ParameterMode slot_mode = SMI_PARAMETERS);
+                    ExitPoint* exit_point);
 
   // Specialized LoadIC for inlined bytecode handler, hand-tuned to omit frame
   // construction on common paths.
@@ -154,8 +153,8 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  protected:
   struct StoreICParameters : public LoadICParameters {
     StoreICParameters(TNode<Context> context, Node* receiver,
-                      TNode<Object> name, SloppyTNode<Object> value, Node* slot,
-                      Node* vector)
+                      TNode<Object> name, SloppyTNode<Object> value,
+                      TNode<Smi> slot, Node* vector)
         : LoadICParameters(context, receiver, name, slot, vector),
           value_(value) {}
 
@@ -229,8 +228,9 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
   // IC dispatcher behavior.
 
   // Checks monomorphic case. Returns {feedback} entry of the vector.
-  TNode<MaybeObject> TryMonomorphicCase(Node* slot, Node* vector,
-                                        Node* receiver_map, Label* if_handler,
+  TNode<MaybeObject> TryMonomorphicCase(TNode<Smi> slot, Node* vector,
+                                        TNode<Map> receiver_map,
+                                        Label* if_handler,
                                         TVariable<MaybeObject>* var_handler,
                                         Label* if_miss);
   void HandlePolymorphicCase(Node* receiver_map, TNode<WeakFixedArray> feedback,
@@ -292,18 +292,19 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
 
   // LoadGlobalIC implementation.
 
-  void LoadGlobalIC_TryPropertyCellCase(
-      TNode<FeedbackVector> vector, Node* slot,
-      const LazyNode<Context>& lazy_context, ExitPoint* exit_point,
-      Label* try_handler, Label* miss,
-      ParameterMode slot_mode = SMI_PARAMETERS);
+  void LoadGlobalIC_TryPropertyCellCase(TNode<FeedbackVector> vector,
+                                        TNode<UintPtrT> slot,
+                                        const LazyNode<Context>& lazy_context,
+                                        ExitPoint* exit_point,
+                                        Label* try_handler, Label* miss);
 
-  void LoadGlobalIC_TryHandlerCase(TNode<FeedbackVector> vector, Node* slot,
+  void LoadGlobalIC_TryHandlerCase(TNode<FeedbackVector> vector,
+                                   TNode<UintPtrT> slot,
+                                   const LazyNode<Smi>& lazy_smi_slot,
                                    const LazyNode<Context>& lazy_context,
                                    const LazyNode<Name>& lazy_name,
                                    TypeofMode typeof_mode,
-                                   ExitPoint* exit_point, Label* miss,
-                                   ParameterMode slot_mode);
+                                   ExitPoint* exit_point, Label* miss);
 
   // StoreIC implementation.
 

src/ic/keyed-store-generic.cc

@@ -1015,7 +1015,7 @@ void KeyedStoreGenericAssembler::KeyedStoreGeneric(
   BIND(&if_unique_name);
   {
     Comment("key is unique name");
-    StoreICParameters p(context, receiver, var_unique.value(), value, nullptr,
+    StoreICParameters p(context, receiver, var_unique.value(), value, {},
                         nullptr);
     ExitPoint direct_exit(this);
     EmitGenericPropertyStore(CAST(receiver), receiver_map, &p, &direct_exit,
@@ -1105,7 +1105,7 @@ void KeyedStoreGenericAssembler::SetProperty(TNode<Context> context,
                                              TNode<Name> unique_name,
                                              TNode<Object> value,
                                              LanguageMode language_mode) {
-  StoreICParameters p(context, receiver, unique_name, value, nullptr, nullptr);
+  StoreICParameters p(context, receiver, unique_name, value, {}, nullptr);
 
   Label done(this), slow(this, Label::kDeferred);
   ExitPoint exit_point(this, [&](Node* result) { Goto(&done); });

src/interpreter/interpreter-assembler.cc

@@ -930,12 +930,10 @@ TNode<Object> InterpreterAssembler::Construct(
       Branch(TaggedEqual(target, array_function), &create_allocation_site,
              &store_weak_reference);
 
-      TNode<IntPtrT> slot_id_int_ptr = Signed(slot_id);
-
       BIND(&create_allocation_site);
       {
-        var_site = CreateAllocationSiteInFeedbackVector(
-            feedback_vector, SmiTag(slot_id_int_ptr));
+        var_site =
+            CreateAllocationSiteInFeedbackVector(feedback_vector, slot_id);
         ReportFeedbackUpdate(feedback_vector, slot_id,
                              "Construct:CreateAllocationSite");
         Goto(&construct_array);
@@ -943,7 +941,7 @@ TNode<Object> InterpreterAssembler::Construct(
 
       BIND(&store_weak_reference);
       {
-        StoreWeakReferenceInFeedbackVector(feedback_vector, slot_id_int_ptr,
+        StoreWeakReferenceInFeedbackVector(feedback_vector, slot_id,
                                            CAST(new_target));
         ReportFeedbackUpdate(feedback_vector, slot_id,
                              "Construct:StoreWeakReference");

src/interpreter/interpreter-generator.cc

@@ -160,7 +160,6 @@ class InterpreterLoadGlobalAssembler : public InterpreterAssembler {
   void LdaGlobal(int slot_operand_index, int name_operand_index,
                  TypeofMode typeof_mode) {
     TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
-    TNode<UintPtrT> feedback_slot = BytecodeOperandIdx(slot_operand_index);
 
     AccessorAssembler accessor_asm(state());
     ExitPoint exit_point(this, [=](Node* result) {
@@ -168,6 +167,14 @@ class InterpreterLoadGlobalAssembler : public InterpreterAssembler {
       Dispatch();
     });
 
+    LazyNode<Smi> lazy_smi_slot = [=] {
+      return SmiTag(Signed(BytecodeOperandIdx(slot_operand_index)));
+    };
+
+    LazyNode<UintPtrT> lazy_slot = [=] {
+      return BytecodeOperandIdx(slot_operand_index);
+    };
+
     LazyNode<Context> lazy_context = [=] { return GetContext(); };
 
     LazyNode<Name> lazy_name = [=] {
@@ -176,10 +183,9 @@ class InterpreterLoadGlobalAssembler : public InterpreterAssembler {
       return name;
     };
 
-    ParameterMode slot_mode = CodeStubAssembler::INTPTR_PARAMETERS;
-    accessor_asm.LoadGlobalIC(maybe_feedback_vector, feedback_slot,
-                              lazy_context, lazy_name, typeof_mode, &exit_point,
-                              slot_mode);
+    accessor_asm.LoadGlobalIC(maybe_feedback_vector, lazy_smi_slot, lazy_slot,
+                              lazy_context, lazy_name, typeof_mode,
+                              &exit_point);
   }
 };
 
@@ -507,24 +513,24 @@ IGNITION_HANDLER(StaLookupSlot, InterpreterAssembler) {
 // constant pool entry <name_index>.
 IGNITION_HANDLER(LdaNamedProperty, InterpreterAssembler) {
   TNode<HeapObject> feedback_vector = LoadFeedbackVector();
-  TNode<IntPtrT> feedback_slot = Signed(BytecodeOperandIdx(2));
-  TNode<Smi> smi_slot = SmiTag(feedback_slot);
+  TNode<UintPtrT> feedback_slot = BytecodeOperandIdx(2);
 
   // Load receiver.
   TNode<Object> recv = LoadRegisterAtOperandIndex(0);
 
   // Load the name and context lazily.
-  LazyNode<Name> name = [=] {
+  LazyNode<Smi> lazy_smi_slot = [=] { return SmiTag(Signed(feedback_slot)); };
+  LazyNode<Name> lazy_name = [=] {
     return CAST(LoadConstantPoolEntryAtOperandIndex(1));
   };
-  LazyNode<Context> context = [=] { return GetContext(); };
+  LazyNode<Context> lazy_context = [=] { return GetContext(); };
 
   Label done(this);
   TVARIABLE(Object, var_result);
   ExitPoint exit_point(this, &done, &var_result);
 
-  AccessorAssembler::LazyLoadICParameters params(context, recv, name, smi_slot,
-                                                 feedback_vector);
+  AccessorAssembler::LazyLoadICParameters params(
+      lazy_context, recv, lazy_name, lazy_smi_slot, feedback_vector);
   AccessorAssembler accessor_asm(state());
   accessor_asm.LoadIC_BytecodeHandler(&params, &exit_point);
 
@@ -961,7 +967,7 @@ class InterpreterBitwiseBinaryOpAssembler : public InterpreterAssembler {
     TNode<Object> left = LoadRegisterAtOperandIndex(0);
     TNode<Object> right = GetAccumulator();
     TNode<Context> context = GetContext();
-    TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(1));
+    TNode<UintPtrT> slot_index = BytecodeOperandIdx(1);
     TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
 
     TVARIABLE(Smi, var_left_feedback);
@@ -1010,7 +1016,7 @@ class InterpreterBitwiseBinaryOpAssembler : public InterpreterAssembler {
   void BitwiseBinaryOpWithSmi(Operation bitwise_op) {
     TNode<Object> left = GetAccumulator();
     TNode<Smi> right = BytecodeOperandImmSmi(0);
-    TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(1));
+    TNode<UintPtrT> slot_index = BytecodeOperandIdx(1);
     TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
     TNode<Context> context = GetContext();
 
@@ -1119,7 +1125,7 @@ IGNITION_HANDLER(BitwiseAndSmi, InterpreterBitwiseBinaryOpAssembler) {
 // Perform bitwise-not on the accumulator.
 IGNITION_HANDLER(BitwiseNot, InterpreterAssembler) {
   TNode<Object> operand = GetAccumulator();
-  TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(0));
+  TNode<UintPtrT> slot_index = BytecodeOperandIdx(0);
   TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
   TNode<Context> context = GetContext();
 
@@ -1281,7 +1287,7 @@ class UnaryNumericOpAssembler : public InterpreterAssembler {
     }
 
     BIND(&end);
-    TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(0));
+    TNode<UintPtrT> slot_index = BytecodeOperandIdx(0);
     TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
     UpdateFeedback(var_feedback.value(), maybe_feedback_vector, slot_index);
     SetAccumulator(var_result.value());
@@ -1831,7 +1837,7 @@ class InterpreterCompareOpAssembler : public InterpreterAssembler {
         UNREACHABLE();
     }
 
-    TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(1));
+    TNode<UintPtrT> slot_index = BytecodeOperandIdx(1);
     TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
     UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector,
                    slot_index);
@@ -2646,14 +2652,14 @@ IGNITION_HANDLER(CloneObject, InterpreterAssembler) {
 // accumulator, creating and caching the site object on-demand as per the
 // specification.
 IGNITION_HANDLER(GetTemplateObject, InterpreterAssembler) {
-  TNode<HeapObject> feedback_vector = LoadFeedbackVector();
+  TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
   TNode<UintPtrT> slot = BytecodeOperandIdx(1);
 
   Label call_runtime(this, Label::kDeferred);
-  GotoIf(IsUndefined(feedback_vector), &call_runtime);
+  GotoIf(IsUndefined(maybe_feedback_vector), &call_runtime);
 
   TNode<Object> cached_value =
-      CAST(LoadFeedbackVectorSlot(feedback_vector, slot, 0, INTPTR_PARAMETERS));
+      CAST(LoadFeedbackVectorSlot(CAST(maybe_feedback_vector), slot));
 
   GotoIf(TaggedEqual(cached_value, SmiConstant(0)), &call_runtime);
 
@@ -2673,8 +2679,8 @@ IGNITION_HANDLER(GetTemplateObject, InterpreterAssembler) {
                                        description, shared_info, slot_smi);
 
     Label end(this);
-    GotoIf(IsUndefined(feedback_vector), &end);
-    StoreFeedbackVectorSlot(feedback_vector, slot, result);
+    GotoIf(IsUndefined(maybe_feedback_vector), &end);
+    StoreFeedbackVectorSlot(CAST(maybe_feedback_vector), slot, result);
     Goto(&end);
 
     Bind(&end);