[regexp] Refactor RegExp.prototype.exec

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 158 matching lines @@
       isolate, regexp, RegExpInitialize(isolate, regexp, pattern, flags));
 
   // Return undefined for compatibility with JSC.
   // See http://crbug.com/585775 for web compat details.
 
   return isolate->heap()->undefined_value();
 }
 
 namespace {
 
-Node* FastLoadLastIndex(CodeStubAssembler* a, Node* context, Node* regexp) {
+Node* FastLoadLastIndex(CodeStubAssembler* a, Node* regexp) {
   // Load the in-object field.
   static const int field_offset =
       JSRegExp::kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
   return a->LoadObjectField(regexp, field_offset);
 }
 
 Node* SlowLoadLastIndex(CodeStubAssembler* a, Node* context, Node* regexp) {
   // Load through the GetProperty stub.
   Node* const name =
       a->HeapConstant(a->isolate()->factory()->lastIndex_string());
   Callable getproperty_callable = CodeFactory::GetProperty(a->isolate());
   return a->CallStub(getproperty_callable, context, regexp, name);
 }
 
-Node* LoadLastIndex(CodeStubAssembler* a, Node* context, Node* has_initialmap,
-                    Node* regexp) {
-  CVariable var_value(a, MachineRepresentation::kTagged);
-
-  CLabel out(a), if_unmodified(a), if_modified(a);
-  a->Branch(has_initialmap, &if_unmodified, &if_modified);
-
-  a->Bind(&if_unmodified);
-  {
-    var_value.Bind(FastLoadLastIndex(a, context, regexp));
-    a->Goto(&out);
-  }
-
-  a->Bind(&if_modified);
-  {
-    var_value.Bind(SlowLoadLastIndex(a, context, regexp));
-    a->Goto(&out);
-  }
-
-  a->Bind(&out);
-  return var_value.value();
+Node* LoadLastIndex(CodeStubAssembler* a, Node* context, Node* regexp,
+                    bool is_fastpath) {
+  return is_fastpath ? FastLoadLastIndex(a, regexp)
+                     : SlowLoadLastIndex(a, context, regexp);
 }
 
 // The fast-path of StoreLastIndex when regexp is guaranteed to be an unmodified
 // JSRegExp instance.
-void FastStoreLastIndex(CodeStubAssembler* a, Node* context, Node* regexp,
-                        Node* value) {
+void FastStoreLastIndex(CodeStubAssembler* a, Node* regexp, Node* value) {
   // Store the in-object field.
   static const int field_offset =
       JSRegExp::kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
   a->StoreObjectField(regexp, field_offset, value);
 }
 
 void SlowStoreLastIndex(CodeStubAssembler* a, Node* context, Node* regexp,
                         Node* value) {
   // Store through runtime.
   // TODO(ishell): Use SetPropertyStub here once available.
   Node* const name =
       a->HeapConstant(a->isolate()->factory()->lastIndex_string());
   Node* const language_mode = a->SmiConstant(Smi::FromInt(STRICT));
   a->CallRuntime(Runtime::kSetProperty, context, regexp, name, value,
                  language_mode);
 }
 
-void StoreLastIndex(CodeStubAssembler* a, Node* context, Node* has_initialmap,
-                    Node* regexp, Node* value) {
-  CLabel out(a), if_unmodified(a), if_modified(a);
-  a->Branch(has_initialmap, &if_unmodified, &if_modified);
-
-  a->Bind(&if_unmodified);
-  {
-    FastStoreLastIndex(a, context, regexp, value);
-    a->Goto(&out);
+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);
   }
-
-  a->Bind(&if_modified);
-  {
-    SlowStoreLastIndex(a, context, regexp, value);
-    a->Goto(&out);
-  }
-
-  a->Bind(&out);
 }
 
 Node* ConstructNewResultFromMatchInfo(Isolate* isolate, CodeStubAssembler* a,
                                       Node* context, Node* match_info,
                                       Node* string) {
   CLabel out(a);
 
   ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* const num_indices = a->SmiUntag(a->LoadFixedArrayElement(
       match_info, a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0,
@@ skipping 55 matching lines @@
     var_to_cursor.Bind(a->IntPtrAdd(to_cursor, a->IntPtrConstant(1)));
     a->Branch(a->UintPtrLessThan(var_from_cursor.value(), limit), &loop, &out);
   }
 
   a->Bind(&out);
   return result;
 }
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
-Node* RegExpPrototypeExecInternal(CodeStubAssembler* a, Node* context,
-                                  Node* maybe_receiver, Node* maybe_string) {
+// Implements the core of RegExp.prototype.exec but without actually
+// constructing the JSRegExpResult. Returns either null (if the RegExp did not
+// match) or a fixed array containing match indices as returned by
+// RegExpExecStub.
+Node* RegExpPrototypeExecBodyWithoutResult(
+    CodeStubAssembler* a, Node* const context, Node* const regexp,
+    Node* const string, CLabel* if_didnotmatch, const bool is_fastpath) {
   Isolate* const isolate = a->isolate();
 
   Node* const null = a->NullConstant();
   Node* const int_zero = a->IntPtrConstant(0);
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
+  if (!is_fastpath) {
+    a->ThrowIfNotInstanceType(context, regexp, JS_REGEXP_TYPE,
+                              "RegExp.prototype.exec");
+  }
+
+  CSA_ASSERT(a, a->IsStringInstanceType(a->LoadInstanceType(string)));
+  CSA_ASSERT(a, a->HasInstanceType(regexp, JS_REGEXP_TYPE));
+
   CVariable var_result(a, MachineRepresentation::kTagged);
   CLabel out(a);
 
-  // Ensure {maybe_receiver} is a JSRegExp.
-  Node* const regexp_map = a->ThrowIfNotInstanceType(
-      context, maybe_receiver, JS_REGEXP_TYPE, "RegExp.prototype.exec");
-  Node* const regexp = maybe_receiver;
-
-  // Check whether the regexp instance is unmodified.
   Node* const native_context = a->LoadNativeContext(context);
-  Node* const regexp_fun =
-      a->LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX);
-  Node* const initial_map =
-      a->LoadObjectField(regexp_fun, JSFunction::kPrototypeOrInitialMapOffset);
-  Node* const has_initialmap = a->WordEqual(regexp_map, initial_map);
-
-  // Convert {maybe_string} to a string.
-  Callable tostring_callable = CodeFactory::ToString(isolate);
-  Node* const string = a->CallStub(tostring_callable, context, maybe_string);
   Node* const string_length = a->LoadStringLength(string);
 
   // Check whether the regexp is global or sticky, which determines whether we
   // update last index later on.
   Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const is_global_or_sticky =
       a->WordAnd(a->SmiUntag(flags),
                  a->IntPtrConstant(JSRegExp::kGlobal | JSRegExp::kSticky));
   Node* const should_update_last_index =
       a->WordNotEqual(is_global_or_sticky, int_zero);
 
   // Grab and possibly update last index.
   CLabel run_exec(a);
   CVariable var_lastindex(a, MachineRepresentation::kTagged);
   {
     CLabel if_doupdate(a), if_dontupdate(a);
     a->Branch(should_update_last_index, &if_doupdate, &if_dontupdate);
 
     a->Bind(&if_doupdate);
     {
       Node* const regexp_lastindex =
-          LoadLastIndex(a, context, has_initialmap, regexp);
+          LoadLastIndex(a, context, regexp, is_fastpath);
+      var_lastindex.Bind(regexp_lastindex);
 
-      Callable tolength_callable = CodeFactory::ToLength(isolate);
-      Node* const lastindex =
-          a->CallStub(tolength_callable, context, regexp_lastindex);
-      var_lastindex.Bind(lastindex);
+      // Omit ToLength if lastindex is a non-negative smi.
+      {
+        CLabel call_tolength(a, CLabel::kDeferred), next(a);
+        a->Branch(a->WordIsPositiveSmi(regexp_lastindex), &next,
+                  &call_tolength);
+
+        a->Bind(&call_tolength);
+        {
+          Callable tolength_callable = CodeFactory::ToLength(isolate);
+          var_lastindex.Bind(
+              a->CallStub(tolength_callable, context, regexp_lastindex));
+          a->Goto(&next);
+        }
+
+        a->Bind(&next);
+      }
+
+      Node* const lastindex = var_lastindex.value();
 
       CLabel if_isoob(a, CLabel::kDeferred);
       a->GotoUnless(a->TaggedIsSmi(lastindex), &if_isoob);
       a->GotoUnless(a->SmiLessThanOrEqual(lastindex, string_length), &if_isoob);
       a->Goto(&run_exec);
 
       a->Bind(&if_isoob);
       {
-        StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
+        StoreLastIndex(a, context, regexp, smi_zero, is_fastpath);
         var_result.Bind(null);
-        a->Goto(&out);
+        a->Goto(if_didnotmatch);
       }
     }
 
     a->Bind(&if_dontupdate);
     {
       var_lastindex.Bind(smi_zero);
       a->Goto(&run_exec);
     }
   }
 
   Node* match_indices;
   CLabel successful_match(a);
   a->Bind(&run_exec);
   {
     // Get last match info from the context.
     Node* const last_match_info = a->LoadContextElement(
         native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
     // Call the exec stub.
     Callable exec_callable = CodeFactory::RegExpExec(isolate);
     match_indices = a->CallStub(exec_callable, context, regexp, string,
                                 var_lastindex.value(), last_match_info);
+    var_result.Bind(match_indices);
 
     // {match_indices} is either null or the RegExpMatchInfo array.
     // Return early if exec failed, possibly updating last index.
     a->GotoUnless(a->WordEqual(match_indices, null), &successful_match);
 
-    CLabel return_null(a);
-    a->GotoUnless(should_update_last_index, &return_null);
+    a->GotoUnless(should_update_last_index, if_didnotmatch);
 
-    StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
-    a->Goto(&return_null);
-
-    a->Bind(&return_null);
-    var_result.Bind(null);
-    a->Goto(&out);
+    StoreLastIndex(a, context, regexp, smi_zero, is_fastpath);
+    a->Goto(if_didnotmatch);
   }
 
-  CLabel construct_result(a);
   a->Bind(&successful_match);
   {
-    a->GotoUnless(should_update_last_index, &construct_result);
+    a->GotoUnless(should_update_last_index, &out);
 
     // Update the new last index from {match_indices}.
     Node* const new_lastindex = a->LoadFixedArrayElement(
         match_indices,
         a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1));
 
-    StoreLastIndex(a, context, has_initialmap, regexp, new_lastindex);
-    a->Goto(&construct_result);
+    StoreLastIndex(a, context, regexp, new_lastindex, is_fastpath);
+    a->Goto(&out);
+  }
 
-    a->Bind(&construct_result);
-    {
-      Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
-                                                     match_indices, string);
-      var_result.Bind(result);
-      a->Goto(&out);
-    }
+  a->Bind(&out);
+  return var_result.value();
+}
+
+// ES#sec-regexp.prototype.exec
+// RegExp.prototype.exec ( string )
+Node* RegExpPrototypeExecBody(CodeStubAssembler* a, Node* const context,
+                              Node* const regexp, Node* const string,
+                              const bool is_fastpath) {
+  Isolate* const isolate = a->isolate();
+  Node* const null = a->NullConstant();
+
+  CVariable var_result(a, MachineRepresentation::kTagged);
+
+  CLabel if_didnotmatch(a), out(a);
+  Node* const indices_or_null = RegExpPrototypeExecBodyWithoutResult(
+      a, context, regexp, string, &if_didnotmatch, is_fastpath);
+
+  // Successful match.
+  {
+    Node* const match_indices = indices_or_null;
+    Node* const result = ConstructNewResultFromMatchInfo(isolate, a, context,
+                                                         match_indices, string);
+    var_result.Bind(result);
+    a->Goto(&out);
+  }
+
+  a->Bind(&if_didnotmatch);
+  {
+    var_result.Bind(null);
+    a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 }  // namespace
 
-// ES#sec-regexp.prototype.exec
-// RegExp.prototype.exec ( string )
-void Builtins::Generate_RegExpPrototypeExec(CodeAssemblerState* state) {
-  CodeStubAssembler a(state);
-
-  Node* const maybe_receiver = a.Parameter(0);
-  Node* const maybe_string = a.Parameter(1);
-  Node* const context = a.Parameter(4);
-
-  Node* const result =
-      RegExpPrototypeExecInternal(&a, context, maybe_receiver, maybe_string);
-  a.Return(result);
-}
-
 namespace {
 
 Node* ThrowIfNotJSReceiver(CodeStubAssembler* a, Isolate* isolate,
                            Node* context, Node* value,
                            MessageTemplate::Template msg_template,
                            char const* method_name) {
   CLabel out(a), throw_exception(a, CLabel::kDeferred);
   CVariable var_value_map(a, MachineRepresentation::kTagged);
 
   a->GotoIf(a->TaggedIsSmi(value), &throw_exception);
@@ skipping 69 matching lines @@
   Node* const native_context = a->LoadNativeContext(context);
   Node* const initial_regexp_result_map =
       a->LoadContextElement(native_context, Context::REGEXP_RESULT_MAP_INDEX);
 
   a->Branch(a->WordEqual(map, initial_regexp_result_map), if_isunmodified,
             if_ismodified);
 }
 
 }  // namespace
 
+// ES#sec-regexp.prototype.exec
+// RegExp.prototype.exec ( string )
+void Builtins::Generate_RegExpPrototypeExec(CodeAssemblerState* state) {
+  CodeStubAssembler a(state);
+
+  Node* const maybe_receiver = a.Parameter(0);
+  Node* const maybe_string = a.Parameter(1);
+  Node* const context = a.Parameter(4);
+
+  // Ensure {maybe_receiver} is a JSRegExp.
+  Node* const regexp_map = a.ThrowIfNotInstanceType(
+      context, maybe_receiver, JS_REGEXP_TYPE, "RegExp.prototype.exec");
+  Node* const receiver = maybe_receiver;
+
+  // Convert {maybe_string} to a String.
+  Node* const string = a.ToString(context, maybe_string);
+
+  CLabel if_isfastpath(&a), if_isslowpath(&a);
+  a.Branch(IsInitialRegExpMap(&a, context, regexp_map), &if_isfastpath,
+           &if_isslowpath);
+
+  a.Bind(&if_isfastpath);
+  {
+    Node* const result =
+        RegExpPrototypeExecBody(&a, context, receiver, string, true);
+    a.Return(result);
+  }
+
+  a.Bind(&if_isslowpath);
+  {
+    Node* const result =
+        RegExpPrototypeExecBody(&a, context, receiver, string, false);
+    a.Return(result);
+  }
+}
+
 void Builtins::Generate_RegExpPrototypeFlagsGetter(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Node* const receiver = a.Parameter(0);
   Node* const context = a.Parameter(3);
 
   Isolate* isolate = a.isolate();
   Node* const int_zero = a.IntPtrConstant(0);
   Node* const int_one = a.IntPtrConstant(1);
 
@@ skipping 451 matching lines @@
 namespace {
 
 // ES#sec-regexpexec Runtime Semantics: RegExpExec ( R, S )
 Node* RegExpExec(CodeStubAssembler* a, Node* context, Node* recv,
                  Node* string) {
   Isolate* isolate = a->isolate();
 
   Node* const null = a->NullConstant();
 
   CVariable var_result(a, MachineRepresentation::kTagged);
-  CLabel out(a), call_builtin_exec(a), slow_path(a, CLabel::kDeferred);
+  CLabel out(a), if_isfastpath(a), if_isslowpath(a);
 
   Node* const map = a->LoadMap(recv);
-  BranchIfFastPath(a, context, map, &call_builtin_exec, &slow_path);
+  BranchIfFastPath(a, context, map, &if_isfastpath, &if_isslowpath);
 
-  a->Bind(&call_builtin_exec);
+  a->Bind(&if_isfastpath);
   {
-    Node* const result = RegExpPrototypeExecInternal(a, context, recv, string);
+    Node* const result =
+        RegExpPrototypeExecBody(a, context, recv, string, true);
     var_result.Bind(result);
     a->Goto(&out);
   }
 
-  a->Bind(&slow_path);
+  a->Bind(&if_isslowpath);
   {
     // Take the slow path of fetching the exec property, calling it, and
     // verifying its return value.
 
     // Get the exec property.
     Node* const name = a->HeapConstant(isolate->factory()->exec_string());
     Callable getproperty_callable = CodeFactory::GetProperty(a->isolate());
     Node* const exec = a->CallStub(getproperty_callable, context, recv, name);
 
     // Is {exec} callable?
@@ skipping 16 matching lines @@
       ThrowIfNotJSReceiver(a, isolate, context, result,
                            MessageTemplate::kInvalidRegExpExecResult, "unused");
 
       a->Goto(&out);
     }
 
     a->Bind(&if_isnotcallable);
     {
       a->ThrowIfNotInstanceType(context, recv, JS_REGEXP_TYPE,
                                 "RegExp.prototype.exec");
-      a->Goto(&call_builtin_exec);
+
+      Node* const result =
+          RegExpPrototypeExecBody(a, context, recv, string, false);
+      var_result.Bind(result);
+      a->Goto(&out);
     }
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 }  // namespace
 
 // ES#sec-regexp.prototype.test
@@ skipping 205 matching lines @@
   Node* const regexp = receiver;
   Node* const is_global =
       FlagGetter(a, context, regexp, JSRegExp::kGlobal, is_fastpath);
 
   CLabel if_isglobal(a), if_isnotglobal(a);
   a->Branch(is_global, &if_isglobal, &if_isnotglobal);
 
   a->Bind(&if_isnotglobal);
   {
     Node* const result =
-        is_fastpath ? RegExpPrototypeExecInternal(a, context, regexp, string)
+        is_fastpath ? RegExpPrototypeExecBody(a, context, regexp, string, true)
                     : RegExpExec(a, context, regexp, string);
     a->Return(result);
   }
 
   a->Bind(&if_isglobal);
   {
     Node* const is_unicode =
         FlagGetter(a, context, regexp, JSRegExp::kUnicode, is_fastpath);
 
-    if (is_fastpath) {
-      FastStoreLastIndex(a, context, regexp, smi_zero);
-    } else {
-      SlowStoreLastIndex(a, context, regexp, smi_zero);
-    }
+    StoreLastIndex(a, context, regexp, smi_zero, is_fastpath);
 
     // Allocate an array to store the resulting match strings.
 
     GrowableFixedArray array(a);
 
     // Loop preparations. Within the loop, collect results from RegExpExec
     // and store match strings in the array.
 
     CVariable* vars[] = {array.var_array(), array.var_length(),
                          array.var_capacity()};
     CLabel loop(a, 3, vars), out(a);
     a->Goto(&loop);
 
     a->Bind(&loop);
     {
-      Node* const result =
-          is_fastpath ? RegExpPrototypeExecInternal(a, context, regexp, string)
-                      : RegExpExec(a, context, regexp, string);
+      Node* const result = is_fastpath ? RegExpPrototypeExecBody(
+                                             a, context, regexp, string, true)
+                                       : RegExpExec(a, context, regexp, string);
 
       CLabel if_didmatch(a), if_didnotmatch(a);
       a->Branch(a->WordEqual(result, null), &if_didnotmatch, &if_didmatch);
 
       a->Bind(&if_didnotmatch);
       {
         // Return null if there were no matches, otherwise just exit the loop.
         a->GotoUnless(a->IntPtrEqual(array.length(), int_zero), &out);
         a->Return(null);
       }
@@ skipping 54 matching lines @@
 
         // Store the match, growing the fixed array if needed.
 
         array.Push(match);
 
         // Advance last index if the match is the empty string.
 
         Node* const match_length = a->LoadStringLength(match);
         a->GotoUnless(a->SmiEqual(match_length, smi_zero), &loop);
 
-        Node* last_index = is_fastpath ? FastLoadLastIndex(a, context, regexp)
-                                       : SlowLoadLastIndex(a, context, regexp);
+        Node* last_index = LoadLastIndex(a, context, regexp, is_fastpath);
 
         Callable tolength_callable = CodeFactory::ToLength(isolate);
         last_index = a->CallStub(tolength_callable, context, last_index);
 
         Node* const new_last_index =
             AdvanceStringIndex(a, string, last_index, is_unicode);
 
-        if (is_fastpath) {
-          FastStoreLastIndex(a, context, regexp, new_last_index);
-        } else {
-          SlowStoreLastIndex(a, context, regexp, new_last_index);
-        }
+        StoreLastIndex(a, context, regexp, new_last_index, is_fastpath);
 
         a->Goto(&loop);
       }
     }
 
     a->Bind(&out);
     {
       // Wrap the match in a JSArray.
 
       Node* const result = array.ToJSArray(context);
@@ skipping 37 matching lines @@
 void Generate_RegExpPrototypeSearchBody(CodeStubAssembler* a,
                                         Node* const receiver,
                                         Node* const string, Node* const context,
                                         bool is_fastpath) {
   Isolate* const isolate = a->isolate();
 
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
   // Grab the initial value of last index.
   Node* const previous_last_index =
-      is_fastpath ? FastLoadLastIndex(a, context, receiver)
-                  : SlowLoadLastIndex(a, context, receiver);
+      LoadLastIndex(a, context, receiver, is_fastpath);
 
   // Ensure last index is 0.
   if (is_fastpath) {
-    FastStoreLastIndex(a, context, receiver, smi_zero);
+    FastStoreLastIndex(a, receiver, smi_zero);
   } else {
     CLabel next(a);
     a->GotoIf(a->SameValue(previous_last_index, smi_zero, context), &next);
 
     SlowStoreLastIndex(a, context, receiver, smi_zero);
     a->Goto(&next);
     a->Bind(&next);
   }
 
   // Call exec.
   Node* const match_indices =
-      is_fastpath ? RegExpPrototypeExecInternal(a, context, receiver, string)
+      is_fastpath ? RegExpPrototypeExecBody(a, context, receiver, string, true)
                   : RegExpExec(a, context, receiver, string);
 
   // Reset last index if necessary.
   if (is_fastpath) {
-    FastStoreLastIndex(a, context, receiver, previous_last_index);
+    FastStoreLastIndex(a, receiver, previous_last_index);
   } else {
     CLabel next(a);
     Node* const current_last_index = SlowLoadLastIndex(a, context, receiver);
 
     a->GotoIf(a->SameValue(current_last_index, previous_last_index, context),
               &next);
 
     SlowStoreLastIndex(a, context, receiver, previous_last_index);
     a->Goto(&next);
     a->Bind(&next);
@@ skipping 406 matching lines @@
   Node* const int_zero = a->IntPtrConstant(0);
   Node* const int_one = a->IntPtrConstant(1);
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
   Node* const native_context = a->LoadNativeContext(context);
 
   CLabel out(a);
   CVariable var_result(a, MachineRepresentation::kTagged);
 
   // Set last index to 0.
-  FastStoreLastIndex(a, context, regexp, smi_zero);
+  FastStoreLastIndex(a, regexp, smi_zero);
 
   // Allocate {result_array}.
   Node* result_array;
   {
     ElementsKind kind = FAST_ELEMENTS;
     Node* const array_map = a->LoadJSArrayElementsMap(kind, native_context);
     Node* const capacity = a->IntPtrConstant(16);
     Node* const length = smi_zero;
     Node* const allocation_site = nullptr;
     ParameterMode capacity_mode = CodeStubAssembler::INTPTR_PARAMETERS;
 
     result_array = a->AllocateJSArray(kind, array_map, capacity, length,
                                       allocation_site, capacity_mode);
   }
 
   // Call into runtime for RegExpExecMultiple.
   Node* last_match_info = a->LoadContextElement(
       native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
   Node* const res =
       a->CallRuntime(Runtime::kRegExpExecMultiple, context, regexp,
                      subject_string, last_match_info, result_array);
 
   // Reset last index to 0.
-  FastStoreLastIndex(a, context, regexp, smi_zero);
+  FastStoreLastIndex(a, regexp, smi_zero);
 
   // If no matches, return the subject string.
   var_result.Bind(subject_string);
   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);
@@ skipping 182 matching lines @@
   // Is {regexp} global?
   CLabel if_isglobal(a), if_isnonglobal(a);
   Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const is_global =
       a->WordAnd(a->SmiUntag(flags), a->IntPtrConstant(JSRegExp::kGlobal));
   a->Branch(a->WordEqual(is_global, int_zero), &if_isnonglobal, &if_isglobal);
 
   a->Bind(&if_isglobal);
   {
     // Hand off global regexps to runtime.
-    FastStoreLastIndex(a, context, regexp, smi_zero);
+    FastStoreLastIndex(a, regexp, smi_zero);
     Node* const result =
         a->CallRuntime(Runtime::kStringReplaceGlobalRegExpWithString, context,
                        subject_string, regexp, replace_string, last_match_info);
     var_result.Bind(result);
     a->Goto(&out);
   }
 
   a->Bind(&if_isnonglobal);
   {
     // Run exec, then manually construct the resulting string.
     Callable exec_callable = CodeFactory::RegExpExec(isolate);
     Node* const match_indices =
         a->CallStub(exec_callable, context, regexp, subject_string, smi_zero,
                     last_match_info);
 
     CLabel if_matched(a), if_didnotmatch(a);
     a->Branch(a->WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
 
     a->Bind(&if_didnotmatch);
     {
-      FastStoreLastIndex(a, context, regexp, smi_zero);
+      FastStoreLastIndex(a, regexp, smi_zero);
       var_result.Bind(subject_string);
       a->Goto(&out);
     }
 
     a->Bind(&if_matched);
     {
       ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
 
       Node* const subject_start = smi_zero;
       Node* const match_start = a->LoadFixedArrayElement(
@@ skipping 169 matching lines @@
   a.Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, &a, context,
                                                    match_indices, string);
     a.Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8