[regexp] Extract implementation of RE.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 305 matching lines @@
     a->Bind(&next_iter);
     var_from_cursor.Bind(a->IntPtrAdd(from_cursor, a->IntPtrConstant(2)));
     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;
 }
 
-}  // namespace
-
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
-void Builtins::Generate_RegExpPrototypeExec(CodeStubAssembler* a) {
+compiler::Node* RegExpPrototypeExecInternal(CodeStubAssembler* a,
+                                            compiler::Node* context,
+                                            compiler::Node* maybe_receiver,
+                                            compiler::Node* maybe_string) {
   typedef CodeStubAssembler::Variable Variable;
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Isolate* const isolate = a->isolate();
 
-  Node* const receiver = a->Parameter(0);
-  Node* const maybe_string = a->Parameter(1);
-  Node* const context = a->Parameter(4);
-
   Node* const null = a->NullConstant();
   Node* const int_zero = a->IntPtrConstant(0);
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
-  // Ensure {receiver} is a JSRegExp.
+  Variable var_result(a, MachineRepresentation::kTagged);
+  Label out(a);
+
+  // Ensure {maybe_receiver} is a JSRegExp.
   Node* const regexp_map = a->ThrowIfNotInstanceType(
-      context, receiver, JS_REGEXP_TYPE, "RegExp.prototype.exec");
-  Node* const regexp = receiver;
+      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.
@@ skipping 28 matching lines @@
       var_lastindex.Bind(lastindex);
 
       Label if_isoob(a, Label::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);
-        a->Return(null);
+        var_result.Bind(null);
+        a->Goto(&out);
       }
     }
 
     a->Bind(&if_dontupdate);
     {
       var_lastindex.Bind(smi_zero);
       a->Goto(&run_exec);
     }
   }
 
@@ skipping 14 matching lines @@
     // Return early if exec failed, possibly updating last index.
     a->GotoUnless(a->WordEqual(match_indices, null), &successful_match);
 
     Label return_null(a);
     a->GotoUnless(should_update_last_index, &return_null);
 
     StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
     a->Goto(&return_null);
 
     a->Bind(&return_null);
-    a->Return(null);
+    var_result.Bind(null);
+    a->Goto(&out);
   }
 
   Label construct_result(a);
   a->Bind(&successful_match);
   {
     a->GotoUnless(should_update_last_index, &construct_result);
 
     // 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);
 
     a->Bind(&construct_result);
     {
       Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                      match_indices, string);
-      a->Return(result);
+      var_result.Bind(result);
+      a->Goto(&out);
     }
   }
+
+  a->Bind(&out);
+  return var_result.value();
+}
+
+}  // namespace
+
+// ES#sec-regexp.prototype.exec
+// RegExp.prototype.exec ( string )
+void Builtins::Generate_RegExpPrototypeExec(CodeStubAssembler* a) {
+  typedef compiler::Node Node;
+
+  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 {
 
 compiler::Node* ThrowIfNotJSReceiver(CodeStubAssembler* a, Isolate* isolate,
                                      compiler::Node* context,
                                      compiler::Node* value,
                                      MessageTemplate::Template msg_template,
                                      char const* method_name) {
   typedef compiler::Node Node;
@@ skipping 1442 matching lines @@
   a->Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                    match_indices, string);
     a->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8