[builtins] Port some RegExp functions to Torque

RegExpPrototypeExecBody, RegExpPrototypeExecBodyWithoutResultFast

Bug: v8:8976
Change-Id: I79f4d3e27baf5ff7aec9538fa463d810dbb75e4e
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1866957
Commit-Queue: Z Nguyen-Huu <duongn@microsoft.com>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64495}

src/builtins/builtins-regexp-gen.cc

@@ -699,7 +699,7 @@ TNode<HeapObject> RegExpBuiltinsAssembler::RegExpExecInternal(
 TNode<RegExpMatchInfo>
 RegExpBuiltinsAssembler::RegExpPrototypeExecBodyWithoutResult(
     TNode<Context> context, TNode<JSReceiver> maybe_regexp,
-    TNode<String> string, Label* if_didnotmatch, const bool is_fastpath) {
+    TNode<String> string, const bool is_fastpath, Label* if_didnotmatch) {
   if (!is_fastpath) {
     ThrowIfNotInstanceType(context, maybe_regexp, JS_REG_EXP_TYPE,
                            "RegExp.prototype.exec");
@@ -814,42 +814,6 @@ RegExpBuiltinsAssembler::RegExpPrototypeExecBodyWithoutResult(
   return CAST(var_result.value());
 }
 
-TNode<RegExpMatchInfo>
-RegExpBuiltinsAssembler::RegExpPrototypeExecBodyWithoutResultFast(
-    TNode<Context> context, TNode<JSRegExp> maybe_regexp, TNode<String> string,
-    Label* if_didnotmatch) {
-  return RegExpPrototypeExecBodyWithoutResult(context, maybe_regexp, string,
-                                              if_didnotmatch, true);
-}
-
-// ES#sec-regexp.prototype.exec
-// RegExp.prototype.exec ( string )
-TNode<HeapObject> RegExpBuiltinsAssembler::RegExpPrototypeExecBody(
-    TNode<Context> context, TNode<JSReceiver> maybe_regexp,
-    TNode<String> string, const bool is_fastpath) {
-  TVARIABLE(HeapObject, var_result);
-
-  Label if_didnotmatch(this), out(this);
-  TNode<RegExpMatchInfo> match_indices = RegExpPrototypeExecBodyWithoutResult(
-      context, maybe_regexp, string, &if_didnotmatch, is_fastpath);
-
-  // Successful match.
-  {
-    var_result = ConstructNewResultFromMatchInfo(context, maybe_regexp,
-                                                 match_indices, string);
-    Goto(&out);
-  }
-
-  BIND(&if_didnotmatch);
-  {
-    var_result = NullConstant();
-    Goto(&out);
-  }
-
-  BIND(&out);
-  return var_result.value();
-}
-
 TNode<BoolT> RegExpBuiltinsAssembler::IsFastRegExpNoPrototype(
     TNode<Context> context, TNode<Object> object, TNode<Map> map) {
   Label out(this);
@@ -1529,9 +1493,9 @@ TNode<Object> RegExpBuiltinsAssembler::RegExpPrototypeMatchBody(
 
   BIND(&if_isnotglobal);
   {
-    var_result = is_fastpath ? RegExpPrototypeExecBody(context, CAST(regexp),
-                                                       string, true)
-                             : RegExpExec(context, CAST(regexp), string);
+    var_result =
+        is_fastpath ? RegExpPrototypeExecBodyFast(context, CAST(regexp), string)
+                    : RegExpExec(context, CAST(regexp), string);
     Goto(&done);
   }
 
@@ -1580,7 +1544,7 @@ TNode<Object> RegExpBuiltinsAssembler::RegExpPrototypeMatchBody(
         // array.
         TNode<RegExpMatchInfo> match_indices =
             RegExpPrototypeExecBodyWithoutResult(context, CAST(regexp), string,
-                                                 &if_didnotmatch, true);
+                                                 true, &if_didnotmatch);
         Label dosubstring(this), donotsubstring(this);
         Branch(var_atom.value(), &donotsubstring, &dosubstring);
 

src/builtins/builtins-regexp-gen.h

@@ -67,15 +67,7 @@ class RegExpBuiltinsAssembler : public CodeStubAssembler {
 
   TNode<RegExpMatchInfo> RegExpPrototypeExecBodyWithoutResult(
       TNode<Context> context, TNode<JSReceiver> maybe_regexp,
-      TNode<String> string, Label* if_didnotmatch, const bool is_fastpath);
-  TNode<RegExpMatchInfo> RegExpPrototypeExecBodyWithoutResultFast(
-      TNode<Context> context, TNode<JSRegExp> maybe_regexp,
-      TNode<String> string, Label* if_didnotmatch);
-
-  TNode<HeapObject> RegExpPrototypeExecBody(TNode<Context> context,
-                                            TNode<JSReceiver> maybe_regexp,
-                                            TNode<String> string,
-                                            const bool is_fastpath);
+      TNode<String> string, const bool is_fastpath, Label* if_didnotmatch);
 
   // Fast path check logic.
   //

src/builtins/regexp-exec.tq

@@ -6,9 +6,7 @@
 
 namespace regexp {
 
-  extern transitioning macro RegExpBuiltinsAssembler::RegExpPrototypeExecBody(
-      implicit context: Context)(JSReceiver, String, constexpr bool): JSAny;
-
+  @export
   transitioning macro RegExpPrototypeExecBodyFast(implicit context: Context)(
       receiver: JSReceiver, string: String): JSAny {
     return RegExpPrototypeExecBody(receiver, string, true);

src/builtins/regexp-match-all.tq

@@ -131,10 +131,6 @@ namespace regexp {
     iterator.flags = newFlags;
   }
 
-  extern macro RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
-      implicit context: Context)(JSReceiver, RegExpMatchInfo, String):
-      JSRegExpResult;
-
   // https://tc39.github.io/proposal-string-matchall/
   // %RegExpStringIteratorPrototype%.next ( )
   transitioning javascript builtin RegExpStringIteratorPrototypeNext(

src/builtins/regexp-replace.tq

@@ -121,7 +121,7 @@ namespace regexp {
   }
 
   transitioning macro RegExpReplaceFastString(implicit context: Context)(
-      regexp: FastJSRegExp, string: String, replaceString: String): String {
+      regexp: JSRegExp, string: String, replaceString: String): String {
     // The fast path is reached only if {receiver} is an unmodified JSRegExp
     // instance, {replace_value} is non-callable, and ToString({replace_value})
     // does not contain '$', i.e. we're doing a simple string replacement.
@@ -129,16 +129,17 @@ namespace regexp {
     let lastMatchEnd: Smi = 0;
     let unicode: bool = false;
     const replaceLength: Smi = replaceString.length_smi;
-    const global: bool = regexp.global;
+    const fastRegexp = UnsafeCast<FastJSRegExp>(regexp);
+    const global: bool = fastRegexp.global;
 
     if (global) {
-      unicode = regexp.unicode;
-      regexp.lastIndex = 0;
+      unicode = fastRegexp.unicode;
+      fastRegexp.lastIndex = 0;
     }
 
     while (true) {
       const match: RegExpMatchInfo =
-          regexp::RegExpPrototypeExecBodyWithoutResultFast(regexp, string)
+          RegExpPrototypeExecBodyWithoutResultFast(regexp, string)
           otherwise break;
       const matchStart: Smi = match.GetStartOfCapture(0);
       const matchEnd: Smi = match.GetEndOfCapture(0);
@@ -155,8 +156,19 @@ namespace regexp {
 
       // If match is the empty string, we have to increment lastIndex.
       if (matchEnd == matchStart) {
-        regexp.lastIndex =
-            AdvanceStringIndexFast(string, regexp.lastIndex, unicode);
+        typeswitch (regexp) {
+          case (fastRegexp: FastJSRegExp): {
+            fastRegexp.lastIndex =
+                AdvanceStringIndexFast(string, fastRegexp.lastIndex, unicode);
+          }
+          case (Object): {
+            const lastIndex: JSAny = SlowLoadLastIndex(regexp);
+            const thisIndex: Number = ToLength_Inline(context, lastIndex);
+            const nextIndex: Number =
+                AdvanceStringIndexSlow(string, thisIndex, unicode);
+            SlowStoreLastIndex(regexp, nextIndex);
+          }
+        }
       }
     }
 

src/builtins/regexp.tq

@@ -51,11 +51,32 @@ namespace regexp {
     }
   }
 
-  extern macro
-  RegExpBuiltinsAssembler::RegExpPrototypeExecBodyWithoutResultFast(
-      implicit context: Context)(JSRegExp, String):
+  extern macro RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
+      implicit context: Context)(JSReceiver, RegExpMatchInfo, String):
+      JSRegExpResult;
+
+  extern transitioning macro
+  RegExpBuiltinsAssembler::RegExpPrototypeExecBodyWithoutResult(
+      implicit context: Context)(JSReceiver, String, constexpr bool):
       RegExpMatchInfo labels IfDidNotMatch;
 
+  transitioning macro RegExpPrototypeExecBodyWithoutResultFast(
+      implicit context: Context)(regexp: JSRegExp, string: String):
+      RegExpMatchInfo labels IfDidNotMatch {
+    return RegExpPrototypeExecBodyWithoutResult(regexp, string, true)
+        otherwise IfDidNotMatch;
+  }
+
+  // ES#sec-regexp.prototype.exec
+  // RegExp.prototype.exec ( string )
+  transitioning macro RegExpPrototypeExecBody(implicit context: Context)(
+      maybeRegexp: JSReceiver, string: String,
+      isFastPath: constexpr bool): JSAny {
+    const matchIndices: RegExpMatchInfo = RegExpPrototypeExecBodyWithoutResult(
+        maybeRegexp, string, isFastPath) otherwise return Null;
+    return ConstructNewResultFromMatchInfo(maybeRegexp, matchIndices, string);
+  }
+
   macro IsReceiverInitialRegExpPrototype(implicit context:
                                              Context)(receiver: Object): bool {
     const nativeContext: NativeContext = LoadNativeContext(context);