[stubs] Add LoadFixedArrayElements with int index

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/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 208 matching lines @@
 
 void StoreLastIndex(CodeStubAssembler* a, Node* context, Node* regexp,
                     Node* value, bool is_fastpath) {
   if (is_fastpath) {
     FastStoreLastIndex(a, regexp, value);
   } else {
     SlowStoreLastIndex(a, context, regexp, value);
   }
 }
 
-Node* LoadMatchInfoField(CodeStubAssembler* a, Node* const match_info,
-                         const int index) {
-  const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-  Node* const result =
-      a->LoadFixedArrayElement(match_info, a->IntPtrConstant(index), 0, mode);
-  return result;
-}
-
 Node* ConstructNewResultFromMatchInfo(Isolate* isolate, CodeStubAssembler* a,
                                       Node* context, Node* match_info,
                                       Node* string) {
   CLabel out(a);
 
-  Node* const num_indices = a->SmiUntag(LoadMatchInfoField(
-      a, match_info, RegExpMatchInfo::kNumberOfCapturesIndex));
+  Node* const num_indices = a->SmiUntag(a->LoadFixedArrayElement(
+      match_info, RegExpMatchInfo::kNumberOfCapturesIndex));
   Node* const num_results = a->SmiTag(a->WordShr(num_indices, 1));
   Node* const start =
-      LoadMatchInfoField(a, match_info, RegExpMatchInfo::kFirstCaptureIndex);
-  Node* const end = LoadMatchInfoField(a, match_info,
-                                       RegExpMatchInfo::kFirstCaptureIndex + 1);
+      a->LoadFixedArrayElement(match_info, RegExpMatchInfo::kFirstCaptureIndex);
+  Node* const end = a->LoadFixedArrayElement(
+      match_info, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
   // Calculate the substring of the first match before creating the result array
   // to avoid an unnecessary write barrier storing the first result.
   Node* const first = a->SubString(context, string, start, end);
 
   Node* const result =
       a->AllocateRegExpResult(context, num_results, start, string);
   Node* const result_elements = a->LoadElements(result);
 
   a->StoreFixedArrayElement(result_elements, 0, first, SKIP_WRITE_BARRIER);
@@ skipping 154 matching lines @@
 
     StoreLastIndex(a, context, regexp, smi_zero, is_fastpath);
     a->Goto(if_didnotmatch);
   }
 
   a->Bind(&successful_match);
   {
     a->GotoUnless(should_update_last_index, &out);
 
     // Update the new last index from {match_indices}.
-    Node* const new_lastindex = LoadMatchInfoField(
-        a, match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
+    Node* const new_lastindex = a->LoadFixedArrayElement(
+        match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
     StoreLastIndex(a, context, regexp, new_lastindex, is_fastpath);
     a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 // ES#sec-regexp.prototype.exec
@@ skipping 947 matching lines @@
     {
       CVariable var_match(a, MachineRepresentation::kTagged);
 
       CLabel if_didmatch(a), if_didnotmatch(a);
       if (is_fastpath) {
         // On the fast path, grab the matching string from the raw match index
         // array.
         Node* const match_indices = RegExpPrototypeExecBodyWithoutResult(
             a, context, regexp, string, &if_didnotmatch, true);
 
-        Node* const match_from = LoadMatchInfoField(
-            a, match_indices, RegExpMatchInfo::kFirstCaptureIndex);
-        Node* const match_to = LoadMatchInfoField(
-            a, match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
+        Node* const match_from = a->LoadFixedArrayElement(
+            match_indices, RegExpMatchInfo::kFirstCaptureIndex);
+        Node* const match_to = a->LoadFixedArrayElement(
+            match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
         Node* match = a->SubString(context, string, match_from, match_to);
         var_match.Bind(match);
 
         a->Goto(&if_didmatch);
       } else {
         DCHECK(!is_fastpath);
         Node* const result = RegExpExec(a, context, regexp, string);
 
         CLabel load_match(a);
         a->Branch(a->WordEqual(result, null), &if_didnotmatch, &load_match);
 
         a->Bind(&load_match);
         {
           CLabel fast_result(a), slow_result(a);
           BranchIfFastRegExpResult(a, context, a->LoadMap(result), &fast_result,
                                    &slow_result);
 
           a->Bind(&fast_result);
           {
             Node* const result_fixed_array = a->LoadElements(result);
-            const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-            Node* const match =
-                a->LoadFixedArrayElement(result_fixed_array, int_zero, 0, mode);
+            Node* const match = a->LoadFixedArrayElement(result_fixed_array, 0);
 
             // The match is guaranteed to be a string on the fast path.
             CSA_ASSERT(a, a->IsStringInstanceType(a->LoadInstanceType(match)));
 
             var_match.Bind(match);
             a->Goto(&if_didmatch);
           }
 
           a->Bind(&slow_result);
           {
@@ skipping 97 matching lines @@
   CLabel if_didnotmatch(a);
   Node* const match_indices = RegExpPrototypeExecBodyWithoutResult(
       a, context, receiver, string, &if_didnotmatch, true);
 
   // Successful match.
   {
     // Reset last index.
     FastStoreLastIndex(a, receiver, previous_last_index);
 
     // Return the index of the match.
-    Node* const index = LoadMatchInfoField(a, match_indices,
-                                           RegExpMatchInfo::kFirstCaptureIndex);
+    Node* const index = a->LoadFixedArrayElement(
+        match_indices, RegExpMatchInfo::kFirstCaptureIndex);
     a->Return(index);
   }
 
   a->Bind(&if_didnotmatch);
   {
     // Reset last index and return -1.
     FastStoreLastIndex(a, receiver, previous_last_index);
     a->Return(a->SmiConstant(-1));
   }
 }
@@ skipping 207 matching lines @@
         a->CallStub(exec_callable, context, regexp, string, next_search_from,
                     last_match_info);
 
     // We're done if no match was found.
     {
       CLabel next(a);
       a->Branch(a->WordEqual(match_indices, null), &push_suffix_and_out, &next);
       a->Bind(&next);
     }
 
-    Node* const match_from = LoadMatchInfoField(
-        a, match_indices, RegExpMatchInfo::kFirstCaptureIndex);
+    Node* const match_from = a->LoadFixedArrayElement(
+        match_indices, RegExpMatchInfo::kFirstCaptureIndex);
 
     // We're done if the match starts beyond the string.
     {
       CLabel next(a);
       a->Branch(a->WordEqual(match_from, string_length), &push_suffix_and_out,
                 &next);
       a->Bind(&next);
     }
 
-    Node* const match_to = LoadMatchInfoField(
-        a, match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
+    Node* const match_to = a->LoadFixedArrayElement(
+        match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
     // Advance index and continue if the match is empty.
     {
       CLabel next(a);
 
       a->GotoUnless(a->SmiEqual(match_to, next_search_from), &next);
       a->GotoUnless(a->SmiEqual(match_to, last_matched_until), &next);
 
       Node* const is_unicode = FastFlagGetter(a, regexp, JSRegExp::kUnicode);
       Node* const new_next_search_from =
@@ skipping 10 matching lines @@
       Node* const to = match_from;
 
       Node* const substr = a->SubString(context, string, from, to);
       array.Push(substr);
 
       a->GotoIf(a->WordEqual(array.length(), int_limit), &out);
     }
 
     // Add all captures to the array.
     {
-      Node* const num_registers = LoadMatchInfoField(
-          a, match_indices, RegExpMatchInfo::kNumberOfCapturesIndex);
+      Node* const num_registers = a->LoadFixedArrayElement(
+          match_indices, RegExpMatchInfo::kNumberOfCapturesIndex);
       Node* const int_num_registers = a->SmiUntag(num_registers);
 
       CVariable var_reg(a, MachineType::PointerRepresentation());
       var_reg.Bind(a->IntPtrConstant(2));
 
       CVariable* vars[] = {array.var_array(), array.var_length(),
                            array.var_capacity(), &var_reg};
       const int vars_count = sizeof(vars) / sizeof(vars[0]);
       CLabel nested_loop(a, vars_count, vars), nested_loop_out(a);
       a->Branch(a->IntPtrLessThan(var_reg.value(), int_num_registers),
@@ skipping 197 matching lines @@
   a->GotoIf(a->WordEqual(res, null), &out);
 
   // Reload last match info since it might have changed.
   last_match_info = a->LoadContextElement(
       native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
   Node* const res_length = a->LoadJSArrayLength(res);
   Node* const res_elems = a->LoadElements(res);
   CSA_ASSERT(a, a->HasInstanceType(res_elems, FIXED_ARRAY_TYPE));
 
-  Node* const num_capture_registers = LoadMatchInfoField(
-      a, last_match_info, RegExpMatchInfo::kNumberOfCapturesIndex);
+  Node* const num_capture_registers = a->LoadFixedArrayElement(
+      last_match_info, RegExpMatchInfo::kNumberOfCapturesIndex);
 
   CLabel if_hasexplicitcaptures(a), if_noexplicitcaptures(a), create_result(a);
   a->Branch(a->SmiEqual(num_capture_registers, a->SmiConstant(Smi::FromInt(2))),
             &if_noexplicitcaptures, &if_hasexplicitcaptures);
 
   a->Bind(&if_noexplicitcaptures);
   {
     // If the number of captures is two then there are no explicit captures in
     // the regexp, just the implicit capture that captures the whole match. In
     // this case we can simplify quite a bit and end up with something faster.
@@ skipping 194 matching lines @@
     a->Bind(&if_didnotmatch);
     {
       FastStoreLastIndex(a, regexp, smi_zero);
       var_result.Bind(subject_string);
       a->Goto(&out);
     }
 
     a->Bind(&if_matched);
     {
       Node* const subject_start = smi_zero;
-      Node* const match_start = LoadMatchInfoField(
-          a, match_indices, RegExpMatchInfo::kFirstCaptureIndex);
-      Node* const match_end = LoadMatchInfoField(
-          a, match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
+      Node* const match_start = a->LoadFixedArrayElement(
+          match_indices, RegExpMatchInfo::kFirstCaptureIndex);
+      Node* const match_end = a->LoadFixedArrayElement(
+          match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
       Node* const subject_end = a->LoadStringLength(subject_string);
 
       CLabel if_replaceisempty(a), if_replaceisnotempty(a);
       Node* const replace_length = a->LoadStringLength(replace_string);
       a->Branch(a->SmiEqual(replace_length, smi_zero), &if_replaceisempty,
                 &if_replaceisnotempty);
 
       a->Bind(&if_replaceisempty);
       {
         // TODO(jgruber): We could skip many of the checks that using SubString
@@ skipping 154 matching lines @@
   a.Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, &a, context,
                                                    match_indices, string);
     a.Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8