[stubs] Add LoadFixedArrayElements with int index

src/ic/accessor-assembler.cc

 // Copyright 2016 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/ic/accessor-assembler.h"
 #include "src/ic/accessor-assembler-impl.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/ic/handler-configuration.h"
@@ skipping 44 matching lines @@
     Node* receiver_map, Node* feedback, Label* if_handler,
     Variable* var_handler, Label* if_miss, int unroll_count) {
   Comment("HandlePolymorphicCase");
   DCHECK_EQ(MachineRepresentation::kTagged, var_handler->rep());
 
   // Iterate {feedback} array.
   const int kEntrySize = 2;
 
   for (int i = 0; i < unroll_count; i++) {
     Label next_entry(this);
-    Node* cached_map = LoadWeakCellValue(LoadFixedArrayElement(
-        feedback, IntPtrConstant(i * kEntrySize), 0, INTPTR_PARAMETERS));
+    Node* cached_map =
+        LoadWeakCellValue(LoadFixedArrayElement(feedback, i * kEntrySize));
     GotoIf(WordNotEqual(receiver_map, cached_map), &next_entry);
 
     // Found, now call handler.
-    Node* handler = LoadFixedArrayElement(
-        feedback, IntPtrConstant(i * kEntrySize + 1), 0, INTPTR_PARAMETERS);
+    Node* handler = LoadFixedArrayElement(feedback, i * kEntrySize + 1);
     var_handler->Bind(handler);
     Goto(if_handler);
 
     Bind(&next_entry);
   }
 
   // Loop from {unroll_count}*kEntrySize to {length}.
   Node* init = IntPtrConstant(unroll_count * kEntrySize);
   Node* length = LoadAndUntagFixedArrayBaseLength(feedback);
   BuildFastLoop(
@@ skipping 343 matching lines @@
 
   BuildFastLoop(
       MachineType::PointerRepresentation(), start_index.value(), handler_length,
       [this, p, handler, miss](CodeStubAssembler*, Node* current) {
         Node* prototype_cell =
             LoadFixedArrayElement(handler, current, 0, INTPTR_PARAMETERS);
         CheckPrototype(prototype_cell, p->name, miss);
       },
       1, IndexAdvanceMode::kPost);
 
-  Node* maybe_holder_cell = LoadFixedArrayElement(
-      handler, IntPtrConstant(LoadHandler::kHolderCellIndex), 0,
-      INTPTR_PARAMETERS);
+  Node* maybe_holder_cell =
+      LoadFixedArrayElement(handler, LoadHandler::kHolderCellIndex);
   Label load_existent(this);
   GotoIf(WordNotEqual(maybe_holder_cell, NullConstant()), &load_existent);
   // This is a handler for a load of a non-existent value.
   if (throw_reference_error_if_nonexistent) {
     TailCallRuntime(Runtime::kThrowReferenceError, p->context, p->name);
   } else {
     Return(UndefinedConstant());
   }
 
   Bind(&load_existent);
@@ skipping 103 matching lines @@
     Node* length = SmiUntag(maybe_transition_cell);
     BuildFastLoop(MachineType::PointerRepresentation(),
                   IntPtrConstant(StoreHandler::kFirstPrototypeIndex), length,
                   [this, p, handler, miss](CodeStubAssembler*, Node* current) {
                     Node* prototype_cell = LoadFixedArrayElement(
                         handler, current, 0, INTPTR_PARAMETERS);
                     CheckPrototype(prototype_cell, p->name, miss);
                   },
                   1, IndexAdvanceMode::kPost);
 
-    Node* maybe_transition_cell = LoadFixedArrayElement(
-        handler, IntPtrConstant(StoreHandler::kTransitionCellIndex), 0,
-        INTPTR_PARAMETERS);
+    Node* maybe_transition_cell =
+        LoadFixedArrayElement(handler, StoreHandler::kTransitionCellIndex);
     Node* transition = LoadWeakCellValue(maybe_transition_cell, miss);
     var_transition.Bind(transition);
     Goto(&if_transition);
   }
 
   Bind(&if_transition);
   {
     Node* holder = p->receiver;
     Node* transition = var_transition.value();
     Node* handler_word = SmiUntag(smi_handler);
@@ skipping 1193 matching lines @@
 void AccessorAssembler::GenerateKeyedStoreICTrampolineTF(
     CodeAssemblerState* state, LanguageMode language_mode) {
   AccessorAssemblerImpl assembler(state);
   assembler.GenerateKeyedStoreICTrampolineTF(language_mode);
 }
 
 #undef ACCESSOR_ASSEMBLER_PUBLIC_INTERFACE
 
 }  // namespace internal
 }  // namespace v8