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

src/builtins/builtins-regexp.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-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 165 matching lines @@
   var_to_cursor.Bind(IntPtrConstant(1));
 
   Variable* vars[] = {&var_from_cursor, &var_to_cursor};
   Label loop(this, 2, vars);
 
   Goto(&loop);
   Bind(&loop);
   {
     Node* const from_cursor = var_from_cursor.value();
     Node* const to_cursor = var_to_cursor.value();
-    Node* const start =
-        LoadFixedArrayElement(match_info, from_cursor, 0, INTPTR_PARAMETERS);
+    Node* const start = LoadFixedArrayElement(match_info, from_cursor);
 
     Label next_iter(this);
     GotoIf(SmiEqual(start, SmiConstant(Smi::FromInt(-1))), &next_iter);
 
     Node* const from_cursor_plus1 = IntPtrAdd(from_cursor, IntPtrConstant(1));
-    Node* const end = LoadFixedArrayElement(match_info, from_cursor_plus1, 0,
-                                            INTPTR_PARAMETERS);
+    Node* const end = LoadFixedArrayElement(match_info, from_cursor_plus1);
 
     Node* const capture = SubString(context, string, start, end);
-    StoreFixedArrayElement(result_elements, to_cursor, capture,
-                           UPDATE_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
+    StoreFixedArrayElement(result_elements, to_cursor, capture);
     Goto(&next_iter);
 
     Bind(&next_iter);
     var_from_cursor.Bind(IntPtrAdd(from_cursor, IntPtrConstant(2)));
     var_to_cursor.Bind(IntPtrAdd(to_cursor, IntPtrConstant(1)));
     Branch(UintPtrLessThan(var_from_cursor.value(), limit), &loop, &out);
   }
 
   Bind(&out);
   return result;
@@ skipping 1161 matching lines @@
 
   Node* length() const { return var_length_.value(); }
 
   Variable* var_array() { return &var_array_; }
   Variable* var_length() { return &var_length_; }
   Variable* var_capacity() { return &var_capacity_; }
 
   void Push(Node* const value) {
     CodeStubAssembler* a = assembler_;
 
-    const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
-    const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-
     Node* const length = var_length_.value();
     Node* const capacity = var_capacity_.value();
 
     Label grow(a), store(a);
     a->Branch(a->IntPtrEqual(capacity, length), &grow, &store);
 
     a->Bind(&grow);
     {
       Node* const new_capacity = NewCapacity(a, capacity);
-      Node* const new_array = ResizeFixedArray(length, new_capacity, mode);
+      Node* const new_array = ResizeFixedArray(length, new_capacity);
 
       var_capacity_.Bind(new_capacity);
       var_array_.Bind(new_array);
       a->Goto(&store);
     }
 
     a->Bind(&store);
     {
       Node* const array = var_array_.value();
-      a->StoreFixedArrayElement(array, length, value, barrier_mode, 0, mode);
+      a->StoreFixedArrayElement(array, length, value);
 
       Node* const new_length = a->IntPtrAdd(length, a->IntPtrConstant(1));
       var_length_.Bind(new_length);
     }
   }
 
   Node* ToJSArray(Node* const context) {
     CodeStubAssembler* a = assembler_;
 
     const ElementsKind kind = FAST_ELEMENTS;
-    const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
 
     Node* const native_context = a->LoadNativeContext(context);
     Node* const array_map = a->LoadJSArrayElementsMap(kind, native_context);
 
     // Shrink to fit if necessary.
     {
       Label next(a);
 
       Node* const length = var_length_.value();
       Node* const capacity = var_capacity_.value();
 
       a->GotoIf(a->WordEqual(length, capacity), &next);
 
-      Node* const array = ResizeFixedArray(length, length, mode);
+      Node* const array = ResizeFixedArray(length, length);
       var_array_.Bind(array);
       var_capacity_.Bind(length);
       a->Goto(&next);
 
       a->Bind(&next);
     }
 
     Node* const result_length = a->SmiTag(length());
     Node* const result = a->AllocateUninitializedJSArrayWithoutElements(
         kind, array_map, result_length, nullptr);
 
     // Note: We do not currently shrink the fixed array.
 
     a->StoreObjectField(result, JSObject::kElementsOffset, var_array_.value());
 
     return result;
   }
 
  private:
   void Initialize() {
     CodeStubAssembler* a = assembler_;
 
     const ElementsKind kind = FAST_ELEMENTS;
-    const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
 
     static const int kInitialArraySize = 8;
     Node* const capacity = a->IntPtrConstant(kInitialArraySize);
-    Node* const array = a->AllocateFixedArray(kind, capacity, mode);
+    Node* const array = a->AllocateFixedArray(kind, capacity);
 
     a->FillFixedArrayWithValue(kind, array, a->IntPtrConstant(0), capacity,
-                               Heap::kTheHoleValueRootIndex, mode);
+                               Heap::kTheHoleValueRootIndex);
 
     var_array_.Bind(array);
     var_capacity_.Bind(capacity);
     var_length_.Bind(a->IntPtrConstant(0));
   }
 
   Node* NewCapacity(CodeStubAssembler* a, Node* const current_capacity) {
     CSA_ASSERT(a, a->IntPtrGreaterThan(current_capacity, a->IntPtrConstant(0)));
 
     // Growth rate is analog to JSObject::NewElementsCapacity:
     // new_capacity = (current_capacity + (current_capacity >> 1)) + 16.
 
     Node* const new_capacity = a->IntPtrAdd(
         a->IntPtrAdd(current_capacity, a->WordShr(current_capacity, 1)),
         a->IntPtrConstant(16));
 
     return new_capacity;
   }
 
   // Creates a new array with {new_capacity} and copies the first
   // {element_count} elements from the current array.
-  Node* ResizeFixedArray(Node* const element_count, Node* const new_capacity,
-                         ParameterMode mode) {
-    DCHECK(mode == CodeStubAssembler::INTPTR_PARAMETERS);
-
+  Node* ResizeFixedArray(Node* const element_count, Node* const new_capacity) {
     CodeStubAssembler* a = assembler_;
 
     CSA_ASSERT(a, a->IntPtrGreaterThan(element_count, a->IntPtrConstant(0)));
     CSA_ASSERT(a, a->IntPtrGreaterThan(new_capacity, a->IntPtrConstant(0)));
     CSA_ASSERT(a, a->IntPtrGreaterThanOrEqual(new_capacity, element_count));
 
     const ElementsKind kind = FAST_ELEMENTS;
     const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
+    const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
     const CodeStubAssembler::AllocationFlags flags =
         CodeStubAssembler::kAllowLargeObjectAllocation;
 
     Node* const from_array = var_array_.value();
     Node* const to_array =
         a->AllocateFixedArray(kind, new_capacity, mode, flags);
     a->CopyFixedArrayElements(kind, from_array, kind, to_array, element_count,
                               new_capacity, barrier_mode, mode);
 
     return to_array;
@@ skipping 696 matching lines @@
     var_i.Bind(int_zero);
 
     Variable* vars[] = {&var_i, &var_match_start};
     Label loop(this, 2, vars);
     Goto(&loop);
     Bind(&loop);
     {
       Node* const i = var_i.value();
       GotoUnless(IntPtrLessThan(i, end), &create_result);
 
-      ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-      Node* const elem = LoadFixedArrayElement(res_elems, i, 0, mode);
+      Node* const elem = LoadFixedArrayElement(res_elems, i);
 
       Label if_issmi(this), if_isstring(this), loop_epilogue(this);
       Branch(TaggedIsSmi(elem), &if_issmi, &if_isstring);
 
       Bind(&if_issmi);
       {
         // Integers represent slices of the original string.
         Label if_isnegativeorzero(this), if_ispositive(this);
         BranchIfSmiLessThanOrEqual(elem, smi_zero, &if_isnegativeorzero,
                                    &if_ispositive);
 
         Bind(&if_ispositive);
         {
           Node* const int_elem = SmiUntag(elem);
           Node* const new_match_start =
               IntPtrAdd(WordShr(int_elem, IntPtrConstant(11)),
                         WordAnd(int_elem, IntPtrConstant(0x7ff)));
           var_match_start.Bind(SmiTag(new_match_start));
           Goto(&loop_epilogue);
         }
 
         Bind(&if_isnegativeorzero);
         {
           Node* const next_i = IntPtrAdd(i, int_one);
           var_i.Bind(next_i);
 
-          Node* const next_elem =
-              LoadFixedArrayElement(res_elems, next_i, 0, mode);
+          Node* const next_elem = LoadFixedArrayElement(res_elems, next_i);
 
           Node* const new_match_start = SmiSub(next_elem, elem);
           var_match_start.Bind(new_match_start);
           Goto(&loop_epilogue);
         }
       }
 
       Bind(&if_isstring);
       {
         CSA_ASSERT(this, IsStringInstanceType(LoadInstanceType(elem)));
 
         Callable call_callable = CodeFactory::Call(isolate);
         Node* const replacement_obj =
             CallJS(call_callable, context, replace_callable, undefined, elem,
                    var_match_start.value(), string);
 
         Node* const replacement_str = ToString(context, replacement_obj);
-        StoreFixedArrayElement(res_elems, i, replacement_str,
-                               UPDATE_WRITE_BARRIER, 0, mode);
+        StoreFixedArrayElement(res_elems, i, replacement_str);
 
         Node* const elem_length = LoadStringLength(elem);
         Node* const new_match_start =
             SmiAdd(var_match_start.value(), elem_length);
         var_match_start.Bind(new_match_start);
 
         Goto(&loop_epilogue);
       }
 
       Bind(&loop_epilogue);
       {
         var_i.Bind(IntPtrAdd(var_i.value(), int_one));
         Goto(&loop);
       }
     }
   }
 
   Bind(&if_hasexplicitcaptures);
   {
-    ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-
     Node* const from = int_zero;
     Node* const to = SmiUntag(res_length);
     const int increment = 1;
 
     BuildFastLoop(
         MachineType::PointerRepresentation(), from, to,
         [this, res_elems, isolate, native_context, context, undefined,
-         replace_callable, mode](Node* index) {
-          Node* const elem = LoadFixedArrayElement(res_elems, index, 0, mode);
+         replace_callable](Node* index) {
+          Node* const elem = LoadFixedArrayElement(res_elems, index);
 
           Label do_continue(this);
           GotoIf(TaggedIsSmi(elem), &do_continue);
 
           // elem must be an Array.
           // Use the apply argument as backing for global RegExp properties.
 
           CSA_ASSERT(this, HasInstanceType(elem, JS_ARRAY_TYPE));
 
           // TODO(jgruber): Remove indirection through Call->ReflectApply.
           Callable call_callable = CodeFactory::Call(isolate);
           Node* const reflect_apply =
               LoadContextElement(native_context, Context::REFLECT_APPLY_INDEX);
 
           Node* const replacement_obj =
               CallJS(call_callable, context, reflect_apply, undefined,
                      replace_callable, undefined, elem);
 
           // Overwrite the i'th element in the results with the string we got
           // back from the callback function.
 
           Node* const replacement_str = ToString(context, replacement_obj);
-          StoreFixedArrayElement(res_elems, index, replacement_str,
-                                 UPDATE_WRITE_BARRIER, 0, mode);
+          StoreFixedArrayElement(res_elems, index, replacement_str);
 
           Goto(&do_continue);
           Bind(&do_continue);
         },
         increment, CodeStubAssembler::IndexAdvanceMode::kPost);
 
     Goto(&create_result);
   }
 
   Bind(&create_result);
@@ skipping 225 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8