[stubs] Remove CSA::INTEGER_PARAMETERS in favor of CSA::INTPTR_PARAMETERS.

src/builtins/builtins-array.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/builtins/builtins.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/contexts.h"
@@ skipping 1552 matching lines @@
         assembler.Word32Equal(search_type,
                               assembler.Int32Constant(SIMD128_VALUE_TYPE)),
         &simd_loop);
     assembler.Goto(&ident_loop);
 
     assembler.Bind(&ident_loop);
     {
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_false);
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.WordEqual(element_k, search_element),
                        &return_true);
 
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&ident_loop);
     }
 
     assembler.Bind(&undef_loop);
     {
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_false);
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.WordEqual(element_k, undefined), &return_true);
       assembler.GotoIf(assembler.WordEqual(element_k, the_hole), &return_true);
 
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&undef_loop);
     }
 
     assembler.Bind(&heap_num_loop);
     {
       Label nan_loop(&assembler, &index_var),
           not_nan_loop(&assembler, &index_var);
       assembler.BranchIfFloat64IsNaN(search_num.value(), &nan_loop,
                                      &not_nan_loop);
 
       assembler.Bind(&not_nan_loop);
       {
         Label continue_loop(&assembler), not_smi(&assembler);
         assembler.GotoUnless(
             assembler.UintPtrLessThan(index_var.value(), len_var.value()),
             &return_false);
-        Node* element_k = assembler.LoadFixedArrayElement(
-            elements, index_var.value(), 0,
-            CodeStubAssembler::INTPTR_PARAMETERS);
+        Node* element_k =
+            assembler.LoadFixedArrayElement(elements, index_var.value());
         assembler.GotoUnless(assembler.TaggedIsSmi(element_k), &not_smi);
         assembler.Branch(
             assembler.Float64Equal(search_num.value(),
                                    assembler.SmiToFloat64(element_k)),
             &return_true, &continue_loop);
 
         assembler.Bind(&not_smi);
         assembler.GotoUnless(
             assembler.IsHeapNumberMap(assembler.LoadMap(element_k)),
             &continue_loop);
         assembler.Branch(
             assembler.Float64Equal(search_num.value(),
                                    assembler.LoadHeapNumberValue(element_k)),
             &return_true, &continue_loop);
 
         assembler.Bind(&continue_loop);
         index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
         assembler.Goto(&not_nan_loop);
       }
 
       assembler.Bind(&nan_loop);
       {
         Label continue_loop(&assembler);
         assembler.GotoUnless(
             assembler.UintPtrLessThan(index_var.value(), len_var.value()),
             &return_false);
-        Node* element_k = assembler.LoadFixedArrayElement(
-            elements, index_var.value(), 0,
-            CodeStubAssembler::INTPTR_PARAMETERS);
+        Node* element_k =
+            assembler.LoadFixedArrayElement(elements, index_var.value());
         assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
         assembler.GotoUnless(
             assembler.IsHeapNumberMap(assembler.LoadMap(element_k)),
             &continue_loop);
         assembler.BranchIfFloat64IsNaN(assembler.LoadHeapNumberValue(element_k),
                                        &return_true, &continue_loop);
 
         assembler.Bind(&continue_loop);
         index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
         assembler.Goto(&nan_loop);
       }
     }
 
     assembler.Bind(&string_loop);
     {
       Label continue_loop(&assembler);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_false);
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
       assembler.GotoUnless(
           assembler.IsStringInstanceType(assembler.LoadInstanceType(element_k)),
           &continue_loop);
 
       // TODO(bmeurer): Consider inlining the StringEqual logic here.
       Callable callable = CodeFactory::StringEqual(assembler.isolate());
       Node* result =
           assembler.CallStub(callable, context, search_element, element_k);
       assembler.Branch(
@@ skipping 10 matching lines @@
       Label continue_loop(&assembler, &index_var),
           loop_body(&assembler, &index_var);
       Node* map = assembler.LoadMap(search_element);
 
       assembler.Goto(&loop_body);
       assembler.Bind(&loop_body);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_false);
 
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
 
       Node* map_k = assembler.LoadMap(element_k);
       assembler.BranchIfSimd128Equal(search_element, map, element_k, map_k,
                                      &return_true, &continue_loop);
 
       assembler.Bind(&continue_loop);
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&loop_body);
     }
@@ skipping 21 matching lines @@
                                    &not_nan_loop);
 
     // Search for HeapNumber
     assembler.Bind(&not_nan_loop);
     {
       Label continue_loop(&assembler);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_false);
       Node* element_k = assembler.LoadFixedDoubleArrayElement(
-          elements, index_var.value(), MachineType::Float64(), 0,
-          CodeStubAssembler::INTPTR_PARAMETERS);
+          elements, index_var.value(), MachineType::Float64());
       assembler.Branch(assembler.Float64Equal(element_k, search_num.value()),
                        &return_true, &continue_loop);
       assembler.Bind(&continue_loop);
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&not_nan_loop);
     }
 
     // Search for NaN
     assembler.Bind(&nan_loop);
     {
       Label continue_loop(&assembler);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_false);
       Node* element_k = assembler.LoadFixedDoubleArrayElement(
-          elements, index_var.value(), MachineType::Float64(), 0,
-          CodeStubAssembler::INTPTR_PARAMETERS);
+          elements, index_var.value(), MachineType::Float64());
       assembler.BranchIfFloat64IsNaN(element_k, &return_true, &continue_loop);
       assembler.Bind(&continue_loop);
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&nan_loop);
     }
   }
 
   assembler.Bind(&if_holey_doubles);
   {
     Label nan_loop(&assembler, &index_var),
@@ skipping 240 matching lines @@
         assembler.Word32Equal(search_type,
                               assembler.Int32Constant(SIMD128_VALUE_TYPE)),
         &simd_loop);
     assembler.Goto(&ident_loop);
 
     assembler.Bind(&ident_loop);
     {
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_not_found);
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.WordEqual(element_k, search_element),
                        &return_found);
 
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&ident_loop);
     }
 
     assembler.Bind(&undef_loop);
     {
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_not_found);
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.WordEqual(element_k, undefined),
                        &return_found);
 
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&undef_loop);
     }
 
     assembler.Bind(&heap_num_loop);
     {
       Label not_nan_loop(&assembler, &index_var);
       assembler.BranchIfFloat64IsNaN(search_num.value(), &return_not_found,
                                      &not_nan_loop);
 
       assembler.Bind(&not_nan_loop);
       {
         Label continue_loop(&assembler), not_smi(&assembler);
         assembler.GotoUnless(
             assembler.UintPtrLessThan(index_var.value(), len_var.value()),
             &return_not_found);
-        Node* element_k = assembler.LoadFixedArrayElement(
-            elements, index_var.value(), 0,
-            CodeStubAssembler::INTPTR_PARAMETERS);
+        Node* element_k =
+            assembler.LoadFixedArrayElement(elements, index_var.value());
         assembler.GotoUnless(assembler.TaggedIsSmi(element_k), &not_smi);
         assembler.Branch(
             assembler.Float64Equal(search_num.value(),
                                    assembler.SmiToFloat64(element_k)),
             &return_found, &continue_loop);
 
         assembler.Bind(&not_smi);
         assembler.GotoUnless(
             assembler.IsHeapNumberMap(assembler.LoadMap(element_k)),
             &continue_loop);
         assembler.Branch(
             assembler.Float64Equal(search_num.value(),
                                    assembler.LoadHeapNumberValue(element_k)),
             &return_found, &continue_loop);
 
         assembler.Bind(&continue_loop);
         index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
         assembler.Goto(&not_nan_loop);
       }
     }
 
     assembler.Bind(&string_loop);
     {
       Label continue_loop(&assembler);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_not_found);
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
       assembler.GotoUnless(
           assembler.IsStringInstanceType(assembler.LoadInstanceType(element_k)),
           &continue_loop);
 
       // TODO(bmeurer): Consider inlining the StringEqual logic here.
       Callable callable = CodeFactory::StringEqual(assembler.isolate());
       Node* result =
           assembler.CallStub(callable, context, search_element, element_k);
       assembler.Branch(
@@ skipping 10 matching lines @@
       Label continue_loop(&assembler, &index_var),
           loop_body(&assembler, &index_var);
       Node* map = assembler.LoadMap(search_element);
 
       assembler.Goto(&loop_body);
       assembler.Bind(&loop_body);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_not_found);
 
-      Node* element_k = assembler.LoadFixedArrayElement(
-          elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
+      Node* element_k =
+          assembler.LoadFixedArrayElement(elements, index_var.value());
       assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
 
       Node* map_k = assembler.LoadMap(element_k);
       assembler.BranchIfSimd128Equal(search_element, map, element_k, map_k,
                                      &return_found, &continue_loop);
 
       assembler.Bind(&continue_loop);
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&loop_body);
     }
@@ skipping 19 matching lines @@
                                    &not_nan_loop);
 
     // Search for HeapNumber
     assembler.Bind(&not_nan_loop);
     {
       Label continue_loop(&assembler);
       assembler.GotoUnless(
           assembler.UintPtrLessThan(index_var.value(), len_var.value()),
           &return_not_found);
       Node* element_k = assembler.LoadFixedDoubleArrayElement(
-          elements, index_var.value(), MachineType::Float64(), 0,
-          CodeStubAssembler::INTPTR_PARAMETERS);
+          elements, index_var.value(), MachineType::Float64());
       assembler.Branch(assembler.Float64Equal(element_k, search_num.value()),
                        &return_found, &continue_loop);
       assembler.Bind(&continue_loop);
       index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
       assembler.Goto(&not_nan_loop);
     }
   }
 
   assembler.Bind(&if_holey_doubles);
   {
@@ skipping 538 matching lines @@
   }
 
   assembler.Bind(&allocate_entry_if_needed);
   {
     assembler.GotoIf(
         assembler.Int32GreaterThan(
             instance_type,
             assembler.Int32Constant(LAST_ARRAY_KEY_VALUE_ITERATOR_TYPE)),
         &allocate_iterator_result);
 
-    Node* elements =
-        assembler.AllocateFixedArray(FAST_ELEMENTS, assembler.Int32Constant(2));
+    Node* elements = assembler.AllocateFixedArray(FAST_ELEMENTS,
+                                                  assembler.IntPtrConstant(2));
     assembler.StoreFixedArrayElement(elements, 0, index, SKIP_WRITE_BARRIER);
     assembler.StoreFixedArrayElement(elements, 1, var_value.value(),
                                      SKIP_WRITE_BARRIER);
 
     Node* entry = assembler.Allocate(JSArray::kSize);
     Node* map =
         assembler.LoadContextElement(assembler.LoadNativeContext(context),
                                      Context::JS_ARRAY_FAST_ELEMENTS_MAP_INDEX);
 
     assembler.StoreMapNoWriteBarrier(entry, map);
@@ skipping 33 matching lines @@
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler.HeapConstant(assembler.factory()->NewStringFromAsciiChecked(
             "Array Iterator.prototype.next", TENURED)),
         iterator);
     assembler.Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8