[regexp] RegExp.prototype.replace fast-paths

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 732 matching lines @@
 }
 
 // ES6 21.2.4.2.
 BUILTIN(RegExpPrototypeSpeciesGetter) {
   HandleScope scope(isolate);
   return *args.receiver();
 }
 
 namespace {
 
+// Fast-path implementation for flag checks on an unmodified JSRegExp instance.
+compiler::Node* FastFlagGetter(CodeStubAssembler* a,
+                               compiler::Node* const regexp,
+                               JSRegExp::Flag flag) {
+  typedef compiler::Node Node;
+
+  Node* const smi_zero = a->SmiConstant(Smi::kZero);
+  Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
+  Node* const mask = a->SmiConstant(Smi::FromInt(flag));
+  Node* const is_flag_set = a->WordNotEqual(a->WordAnd(flags, mask), smi_zero);
+
+  return is_flag_set;
+}
+
 void Generate_FlagGetter(CodeStubAssembler* a, JSRegExp::Flag flag,
                          v8::Isolate::UseCounterFeature counter,
                          const char* method_name) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* const receiver = a->Parameter(0);
   Node* const context = a->Parameter(3);
 
   Isolate* isolate = a->isolate();
-  Node* const int_zero = a->IntPtrConstant(0);
 
   // Check whether we have an unmodified regexp instance.
   Label if_isunmodifiedjsregexp(a),
       if_isnotunmodifiedjsregexp(a, Label::kDeferred);
 
   a->GotoIf(a->TaggedIsSmi(receiver), &if_isnotunmodifiedjsregexp);
 
   Node* const receiver_map = a->LoadMap(receiver);
   Node* const instance_type = a->LoadMapInstanceType(receiver_map);
 
   a->Branch(a->Word32Equal(instance_type, a->Int32Constant(JS_REGEXP_TYPE)),
             &if_isunmodifiedjsregexp, &if_isnotunmodifiedjsregexp);
 
   a->Bind(&if_isunmodifiedjsregexp);
   {
     // Refer to JSRegExp's flag property on the fast-path.
-    Node* const flags_smi =
-        a->LoadObjectField(receiver, JSRegExp::kFlagsOffset);
-    Node* const flags_intptr = a->SmiUntag(flags_smi);
-    Node* const mask = a->IntPtrConstant(flag);
-    Node* const is_global =
-        a->WordNotEqual(a->WordAnd(flags_intptr, mask), int_zero);
-    a->Return(a->Select(is_global, a->TrueConstant(), a->FalseConstant()));
+    Node* const is_flag_set = FastFlagGetter(a, receiver, flag);
+    a->Return(a->Select(is_flag_set, a->TrueConstant(), a->FalseConstant()));

[jgruber, 2016/10/15 18:23:18]

TODO(me): Is this equivalent to a->Return(is_flag_set)?

[Yang, 2016/10/17 13:30:54]

Pretty sure you need to use Select, which turns the condition into branches.

   }
 
   a->Bind(&if_isnotunmodifiedjsregexp);
   {
     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 initial_prototype = a->LoadMapPrototype(initial_map);
@@ skipping 768 matching lines @@
   typedef compiler::Node Node;
 
   Isolate* const isolate = a->isolate();
 
   Node* const maybe_receiver = a->Parameter(0);
   Node* const maybe_string = a->Parameter(1);
   Node* const replace_value = a->Parameter(2);
   Node* const context = a->Parameter(5);
 
   Node* const int_zero = a->IntPtrConstant(0);
+  Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
   // Ensure {receiver} is a JSReceiver.
   Node* const map =
       ThrowIfNotJSReceiver(a, isolate, context, maybe_receiver,
                            MessageTemplate::kIncompatibleMethodReceiver,
                            "RegExp.prototype.@@replace");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Callable tostring_callable = CodeFactory::ToString(isolate);
   Node* const string = a->CallStub(tostring_callable, context, maybe_string);
 
   // Fast-path checks: 1. Is the {receiver} an unmodified JSRegExp instance?
   Label checkreplacecallable(a), runtime(a, Label::kDeferred), fastpath(a);
   BranchIfFastPath(a, context, map, &checkreplacecallable, &runtime);
 
   a->Bind(&checkreplacecallable);
   Node* const regexp = receiver;
 
   // 2. Is {replace_value} callable?
-  Label checkreplacestring(a);
+  Label checkreplacestring(a), if_iscallable(a, Label::kDeferred);
   a->GotoIf(a->TaggedIsSmi(replace_value), &checkreplacestring);
 
   Node* const replace_value_map = a->LoadMap(replace_value);
   a->Branch(
       a->Word32Equal(a->Word32And(a->LoadMapBitField(replace_value_map),
                                   a->Int32Constant(1 << Map::kIsCallable)),
                      a->Int32Constant(0)),
-      &checkreplacestring, &runtime);
+      &checkreplacestring, &if_iscallable);
 
   // 3. Does ToString({replace_value}) contain '$'?
   a->Bind(&checkreplacestring);
   {
     Node* const replace_string =
         a->CallStub(tostring_callable, context, replace_value);
 
     Node* const dollar_char = a->IntPtrConstant('$');
     Node* const smi_minusone = a->SmiConstant(Smi::FromInt(-1));
     a->GotoUnless(a->SmiEqual(a->StringIndexOfChar(context, replace_string,
                                                    dollar_char, int_zero),
                               smi_minusone),
                   &runtime);
 
     a->Return(ReplaceFastPath(a, context, regexp, string, replace_string));
   }
 
+  // {regexp} is unmodified and {replace_value} is callable.
+  a->Bind(&if_iscallable);
+  {
+    Node* const replace_callable = replace_value;
+
+    // Check if the {regexp} is global.
+    Label if_isglobal(a), if_isnotglobal(a);
+    Node* const is_global = FastFlagGetter(a, regexp, JSRegExp::kGlobal);
+    a->Branch(is_global, &if_isglobal, &if_isnotglobal);
+
+    a->Bind(&if_isglobal);
+    {
+      FastStoreLastIndex(a, context, regexp, smi_zero);
+      Node* const result =
+          a->CallRuntime(Runtime::kStringReplaceGlobalRegExpWithFunction,
+                         context, string, regexp, replace_callable);
+      a->Return(result);
+    }
+
+    a->Bind(&if_isnotglobal);
+    {
+      Node* const result =
+          a->CallRuntime(Runtime::kStringReplaceNonGlobalRegExpWithFunction,
+                         context, string, regexp, replace_callable);
+      a->Return(result);
+    }
+  }
+
   a->Bind(&runtime);
   {
     Node* const result = a->CallRuntime(Runtime::kRegExpReplace, context,
                                         receiver, string, replace_value);
     a->Return(result);
   }
 }
 
 // Simple string matching functionality for internal use which does not modify
 // the last match info.
@@ skipping 27 matching lines @@
   a->Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                    match_indices, string);
     a->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8