[regexp] Skip result construction in test, @@match, @@search

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);
 
-  ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-  Node* const num_indices = a->SmiUntag(a->LoadFixedArrayElement(
-      match_info, a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0,
-      mode));
+  Node* const num_indices = a->SmiUntag(LoadMatchInfoField(
+      a, match_info, RegExpMatchInfo::kNumberOfCapturesIndex));
   Node* const num_results = a->SmiTag(a->WordShr(num_indices, 1));
-  Node* const start = a->LoadFixedArrayElement(
-      match_info, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex), 0,
-      mode);
-  Node* const end = a->LoadFixedArrayElement(
-      match_info, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1), 0,
-      mode);
+  Node* const start =
+      LoadMatchInfoField(a, match_info, RegExpMatchInfo::kFirstCaptureIndex);
+  Node* const end = LoadMatchInfoField(a, 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 = a->LoadFixedArrayElement(
-        match_indices,
-        a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1));
+    Node* const new_lastindex = LoadMatchInfoField(
+        a, 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 22 matching lines @@
   a->Bind(&if_didnotmatch);
   {
     var_result.Bind(null);
     a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
-}  // namespace
-
-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);
 
   // Load the instance type of the {value}.
@@ skipping 650 matching lines @@
 void Builtins::Generate_RegExpPrototypeTest(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Isolate* const isolate = a.isolate();
 
   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 JSReceiver.
-  ThrowIfNotJSReceiver(&a, isolate, context, maybe_receiver,
-                       MessageTemplate::kIncompatibleMethodReceiver,
-                       "RegExp.prototype.test");
+  Node* const map = ThrowIfNotJSReceiver(
+      &a, isolate, context, maybe_receiver,
+      MessageTemplate::kIncompatibleMethodReceiver, "RegExp.prototype.test");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Node* const string = a.ToString(context, maybe_string);
 
-  // Call exec.
-  Node* const match_indices = RegExpExec(&a, context, receiver, string);
+  CLabel fast_path(&a), slow_path(&a);
+  BranchIfFastPath(&a, context, map, &fast_path, &slow_path);
 
-  // Return true iff exec matched successfully.
-  Node* const result = a.Select(a.WordEqual(match_indices, a.NullConstant()),
-                                a.FalseConstant(), a.TrueConstant());
-  a.Return(result);
+  a.Bind(&fast_path);
+  {
+    CLabel if_didnotmatch(&a);
+    RegExpPrototypeExecBodyWithoutResult(&a, context, receiver, string,
+                                         &if_didnotmatch, true);
+    a.Return(a.TrueConstant());
+
+    a.Bind(&if_didnotmatch);
+    a.Return(a.FalseConstant());
+  }
+
+  a.Bind(&slow_path);
+  {
+    // Call exec.
+    Node* const match_indices = RegExpExec(&a, context, receiver, string);
+
+    // Return true iff exec matched successfully.
+    Node* const result = a.Select(a.WordEqual(match_indices, a.NullConstant()),
+                                  a.FalseConstant(), a.TrueConstant());
+    a.Return(result);
+  }
 }
 
 namespace {
 
 Node* AdvanceStringIndex(CodeStubAssembler* a, Node* const string,
                          Node* const index, Node* const is_unicode) {
   CVariable var_result(a, MachineRepresentation::kTagged);
 
   // Default to last_index + 1.
   Node* const index_plus_one = a->SmiAdd(index, a->SmiConstant(1));
@@ skipping 149 matching lines @@
     return to_array;
   }
 
  private:
   CodeStubAssembler* const assembler_;
   CVariable var_array_;
   CVariable var_length_;
   CVariable var_capacity_;
 };
 
-void Generate_RegExpPrototypeMatchBody(CodeStubAssembler* a,
-                                       Node* const receiver, Node* const string,
-                                       Node* const context,
-                                       const bool is_fastpath) {
+void RegExpPrototypeMatchBody(CodeStubAssembler* a, Node* const receiver,
+                              Node* const string, Node* const context,
+                              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);
 
   Node* const regexp = receiver;
   Node* const is_global =
       FlagGetter(a, context, regexp, JSRegExp::kGlobal, is_fastpath);
 
@@ skipping 22 matching lines @@
     // 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 ? RegExpPrototypeExecBody(
-                                             a, context, regexp, string, true)
-                                       : RegExpExec(a, context, regexp, string);
+      CVariable var_match(a, MachineRepresentation::kTagged);
 
       CLabel if_didmatch(a), if_didnotmatch(a);
-      a->Branch(a->WordEqual(result, null), &if_didnotmatch, &if_didmatch);
+      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);
 
-      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);
-      }
+        Node* const match_from = LoadMatchInfoField(
+            a, match_indices, RegExpMatchInfo::kFirstCaptureIndex);
+        Node* const match_to = LoadMatchInfoField(
+            a, match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
-      a->Bind(&if_didmatch);
-      {
-        Node* match = nullptr;
-        if (is_fastpath) {
-          // TODO(jgruber): We could optimize further here and in other
-          // methods (e.g. @@search) by bypassing RegExp result construction.
-          Node* const result_fixed_array = a->LoadElements(result);
-          const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-          match =
-              a->LoadFixedArrayElement(result_fixed_array, int_zero, 0, mode);
+        Node* match = a->SubString(context, string, match_from, match_to);
+        var_match.Bind(match);
 
-          // The match is guaranteed to be a string on the fast path.
-          CSA_ASSERT(a, a->IsStringInstanceType(a->LoadInstanceType(match)));
-        } else {
-          DCHECK(!is_fastpath);
+        a->Goto(&if_didmatch);
+      } else {
+        DCHECK(!is_fastpath);
+        Node* const result = RegExpExec(a, context, regexp, string);
 
-          CVariable var_match(a, MachineRepresentation::kTagged);
-          CLabel fast_result(a), slow_result(a), match_loaded(a);
+        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);
           {
-            // TODO(jgruber): We could optimize further here and in other
-            // methods (e.g. @@search) by bypassing RegExp result construction.
             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);
 
             // 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(&match_loaded);
+            a->Goto(&if_didmatch);
           }
 
           a->Bind(&slow_result);
           {
             // TODO(ishell): Use GetElement stub once it's available.
             Node* const name = smi_zero;
             Callable getproperty_callable = CodeFactory::GetProperty(isolate);
             Node* const match =
                 a->CallStub(getproperty_callable, context, result, name);
 
-            var_match.Bind(match);
-            a->Goto(&match_loaded);
+            var_match.Bind(a->ToString(context, match));
+            a->Goto(&if_didmatch);
           }
+        }
+      }
 
-          a->Bind(&match_loaded);
-          match = a->ToString(context, var_match.value());
-        }
-        DCHECK(match != nullptr);
+      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);
+      }
+
+      a->Bind(&if_didmatch);
+      {
+        Node* match = var_match.value();
 
         // 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);
 
@@ skipping 38 matching lines @@
       MessageTemplate::kIncompatibleMethodReceiver, "RegExp.prototype.@@match");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Node* const string = a.ToString(context, maybe_string);
 
   CLabel fast_path(&a), slow_path(&a);
   BranchIfFastPath(&a, context, map, &fast_path, &slow_path);
 
   a.Bind(&fast_path);
-  Generate_RegExpPrototypeMatchBody(&a, receiver, string, context, true);
+  RegExpPrototypeMatchBody(&a, receiver, string, context, true);
 
   a.Bind(&slow_path);
-  Generate_RegExpPrototypeMatchBody(&a, receiver, string, context, false);
+  RegExpPrototypeMatchBody(&a, receiver, string, context, false);
 }
 
 namespace {
 
-void Generate_RegExpPrototypeSearchBody(CodeStubAssembler* a,
-                                        Node* const receiver,
-                                        Node* const string, Node* const context,
-                                        bool is_fastpath) {
+void RegExpPrototypeSearchBodyFast(CodeStubAssembler* a, Node* const receiver,
+                                   Node* const string, Node* const context) {
+  // Grab the initial value of last index.
+  Node* const previous_last_index = FastLoadLastIndex(a, receiver);
+
+  // Ensure last index is 0.
+  FastStoreLastIndex(a, receiver, a->SmiConstant(Smi::kZero));
+
+  // Call exec.
+  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);
+    a->Return(index);
+  }
+
+  a->Bind(&if_didnotmatch);
+  {
+    // Reset last index and return -1.
+    FastStoreLastIndex(a, receiver, previous_last_index);
+    a->Return(a->SmiConstant(-1));
+  }
+}
+
+void RegExpPrototypeSearchBodySlow(CodeStubAssembler* a, Node* const receiver,
+                                   Node* const string, Node* const context) {
   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 =
-      LoadLastIndex(a, context, receiver, is_fastpath);
+  Node* const previous_last_index = SlowLoadLastIndex(a, context, receiver);
 
   // Ensure last index is 0.
-  if (is_fastpath) {
-    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 ? RegExpPrototypeExecBody(a, context, receiver, string, true)
-                  : RegExpExec(a, context, receiver, string);
+  Node* const exec_result = RegExpExec(a, context, receiver, string);
 
   // Reset last index if necessary.
-  if (is_fastpath) {
-    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);
   }
 
   // Return -1 if no match was found.
   {
     CLabel next(a);
-    a->GotoUnless(a->WordEqual(match_indices, a->NullConstant()), &next);
+    a->GotoUnless(a->WordEqual(exec_result, a->NullConstant()), &next);
     a->Return(a->SmiConstant(-1));
     a->Bind(&next);
   }
 
   // Return the index of the match.
-  if (is_fastpath) {
-    Node* const index = a->LoadObjectField(
-        match_indices, JSRegExpResult::kIndexOffset, MachineType::AnyTagged());
-    a->Return(index);
-  } else {
-    DCHECK(!is_fastpath);
-
+  {
     CLabel fast_result(a), slow_result(a, CLabel::kDeferred);
-    BranchIfFastRegExpResult(a, context, a->LoadMap(match_indices),
-                             &fast_result, &slow_result);
+    BranchIfFastRegExpResult(a, context, a->LoadMap(exec_result), &fast_result,
+                             &slow_result);
 
     a->Bind(&fast_result);
     {
       Node* const index =
-          a->LoadObjectField(match_indices, JSRegExpResult::kIndexOffset,
-                             MachineType::AnyTagged());
+          a->LoadObjectField(exec_result, JSRegExpResult::kIndexOffset);
       a->Return(index);
     }
 
     a->Bind(&slow_result);
     {
       Node* const name = a->HeapConstant(isolate->factory()->index_string());
       Callable getproperty_callable = CodeFactory::GetProperty(a->isolate());
       Node* const index =
-          a->CallStub(getproperty_callable, context, match_indices, name);
+          a->CallStub(getproperty_callable, context, exec_result, name);
       a->Return(index);
     }
   }
 }
 
 }  // namespace
 
 // ES#sec-regexp.prototype-@@search
 // RegExp.prototype [ @@search ] ( string )
 void Builtins::Generate_RegExpPrototypeSearch(CodeAssemblerState* state) {
@@ skipping 12 matching lines @@
                            "RegExp.prototype.@@search");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Node* const string = a.ToString(context, maybe_string);
 
   CLabel fast_path(&a), slow_path(&a);
   BranchIfFastPath(&a, context, map, &fast_path, &slow_path);
 
   a.Bind(&fast_path);
-  Generate_RegExpPrototypeSearchBody(&a, receiver, string, context, true);
+  RegExpPrototypeSearchBodyFast(&a, receiver, string, context);
 
   a.Bind(&slow_path);
-  Generate_RegExpPrototypeSearchBody(&a, receiver, string, context, false);
+  RegExpPrototypeSearchBodySlow(&a, receiver, string, context);
 }
 
 namespace {
 
 // Generates the fast path for @@split. {regexp} is an unmodified JSRegExp,
 // {string} is a String, and {limit} is a Smi.
 void Generate_RegExpPrototypeSplitBody(CodeStubAssembler* a, Node* const regexp,
                                        Node* const string, Node* const limit,
                                        Node* const context) {
   Isolate* isolate = a->isolate();
@@ skipping 97 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 = a->LoadFixedArrayElement(
-        match_indices, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex),
-        0, mode);
+    Node* const match_from = LoadMatchInfoField(
+        a, 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 = a->LoadFixedArrayElement(
-        match_indices,
-        a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1), 0, mode);
+    Node* const match_to = LoadMatchInfoField(
+        a, 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 = a->LoadFixedArrayElement(
-          match_indices,
-          a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0, mode);
+      Node* const num_registers = LoadMatchInfoField(
+          a, 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));
 
-  ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
-  Node* const num_capture_registers = a->LoadFixedArrayElement(
-      last_match_info,
-      a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0, mode);
+  Node* const num_capture_registers = LoadMatchInfoField(
+      a, 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 193 matching lines @@
 
     a->Bind(&if_didnotmatch);
     {
       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(
-          match_indices, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex),
-          0, mode);
-      Node* const match_end = a->LoadFixedArrayElement(
-          match_indices,
-          a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1), 0, mode);
+      Node* const match_start = LoadMatchInfoField(
+          a, match_indices, RegExpMatchInfo::kFirstCaptureIndex);
+      Node* const match_end = LoadMatchInfoField(
+          a, 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