[regexp] Add stub for RegExpExec instead of inlining

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-regexp.h"
 
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 322 matching lines @@
         match_indices, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
     StoreLastIndex(context, regexp, new_lastindex, is_fastpath);
     Goto(&out);
   }
 
   Bind(&out);
   return var_result.value();
 }
 
+// Wrapper around RegExpPrototypeExecBody to reduce code duplication.
+TF_BUILTIN(RegExpExecInternalFast, RegExpBuiltinsAssembler) {
+  typedef RegExpExecInternalDescriptor Descriptor;
+
+  Node* const regexp = Parameter(Descriptor::kReceiver);
+  Node* const string = Parameter(Descriptor::kString);
+  Node* const context = Parameter(Descriptor::kContext);
+
+  CSA_ASSERT(this, HasInstanceType(regexp, JS_REGEXP_TYPE));
+  CSA_ASSERT(this, IsString(string));
+
+  Return(RegExpPrototypeExecBody(context, regexp, string, true));
+}
+
+// Wrapper around RegExpPrototypeExecBody to reduce code duplication.
+TF_BUILTIN(RegExpExecInternalSlow, RegExpBuiltinsAssembler) {
+  typedef RegExpExecInternalDescriptor Descriptor;
+
+  Node* const regexp = Parameter(Descriptor::kReceiver);
+  Node* const string = Parameter(Descriptor::kString);
+  Node* const context = Parameter(Descriptor::kContext);
+
+  CSA_ASSERT(this, IsString(string));
+
+  Return(RegExpPrototypeExecBody(context, regexp, string, false));
+}
+
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
 Node* RegExpBuiltinsAssembler::RegExpPrototypeExecBody(Node* const context,
                                                        Node* const regexp,
                                                        Node* const string,
                                                        const bool is_fastpath) {
   Node* const null = NullConstant();
 
   Variable var_result(this, MachineRepresentation::kTagged);
 
@@ skipping 138 matching lines @@
 
   // Convert {maybe_string} to a String.
   Node* const string = ToString(context, maybe_string);
 
   Label if_isfastpath(this), if_isslowpath(this);
   Branch(IsInitialRegExpMap(context, regexp_map), &if_isfastpath,
          &if_isslowpath);
 
   Bind(&if_isfastpath);
   {
-    Node* const result =
-        RegExpPrototypeExecBody(context, receiver, string, true);
-    Return(result);
+    Callable exec_callable = CodeFactory::RegExpExecInternal(isolate(), true);
+    Return(CallStub(exec_callable, context, receiver, string));
   }
 
   Bind(&if_isslowpath);
   {
-    Node* const result =
-        RegExpPrototypeExecBody(context, receiver, string, false);
-    Return(result);
+    Callable exec_callable = CodeFactory::RegExpExecInternal(isolate(), false);
+    Return(CallStub(exec_callable, context, receiver, string));
   }
 }
 
 Node* RegExpBuiltinsAssembler::FlagsGetter(Node* const context,
                                            Node* const regexp,
                                            bool is_fastpath) {
   Isolate* isolate = this->isolate();
 
   Node* const int_zero = IntPtrConstant(0);
   Node* const int_one = IntPtrConstant(1);
@@ skipping 696 matching lines @@
   Node* const null = NullConstant();
 
   Variable var_result(this, MachineRepresentation::kTagged);
   Label out(this), if_isfastpath(this), if_isslowpath(this);
 
   Node* const map = LoadMap(regexp);
   BranchIfFastRegExp(context, map, &if_isfastpath, &if_isslowpath);
 
   Bind(&if_isfastpath);
   {
-    Node* const result = RegExpPrototypeExecBody(context, regexp, string, true);
+    Callable exec_callable = CodeFactory::RegExpExecInternal(isolate, true);
+    Node* const result = CallStub(exec_callable, context, regexp, string);
     var_result.Bind(result);
     Goto(&out);
   }
 
   Bind(&if_isslowpath);
   {
     // Take the slow path of fetching the exec property, calling it, and
     // verifying its return value.
 
     // Get the exec property.
@@ skipping 21 matching lines @@
                            MessageTemplate::kInvalidRegExpExecResult, "unused");
 
       Goto(&out);
     }
 
     Bind(&if_isnotcallable);
     {
       ThrowIfNotInstanceType(context, regexp, JS_REGEXP_TYPE,
                              "RegExp.prototype.exec");
 
-      Node* const result =
-          RegExpPrototypeExecBody(context, regexp, string, false);
+      Callable exec_callable = CodeFactory::RegExpExecInternal(isolate, false);
+      Node* const result = CallStub(exec_callable, context, regexp, string);
       var_result.Bind(result);
       Goto(&out);
     }
   }
 
   Bind(&out);
   return var_result.value();
 }
 
 // ES#sec-regexp.prototype.test
@@ skipping 236 matching lines @@
   Node* const smi_zero = SmiConstant(Smi::kZero);
 
   Node* const is_global =
       FlagGetter(context, regexp, JSRegExp::kGlobal, is_fastpath);
 
   Label if_isglobal(this), if_isnotglobal(this);
   Branch(is_global, &if_isglobal, &if_isnotglobal);
 
   Bind(&if_isnotglobal);
   {
-    Node* const result =
-        is_fastpath ? RegExpPrototypeExecBody(context, regexp, string, true)
-                    : RegExpExec(context, regexp, string);
-    Return(result);
+    if (is_fastpath) {
+      Callable exec_callable = CodeFactory::RegExpExecInternal(isolate, true);
+      Return(CallStub(exec_callable, context, regexp, string));
+    } else {
+      Return(RegExpExec(context, regexp, string));
+    }
   }
 
   Bind(&if_isglobal);
   {
     Node* const is_unicode =
         FlagGetter(context, regexp, JSRegExp::kUnicode, is_fastpath);
 
     StoreLastIndex(context, regexp, smi_zero, is_fastpath);
 
     // Allocate an array to store the resulting match strings.
@@ skipping 1015 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8