[csa] Add CSA::CallBuiltin and Builtins::CallableFor

src/builtins/builtins-regexp-gen.cc

 // Copyright 2017 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-gen.h"
 
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 458 matching lines @@
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
 // Implements the core of RegExp.prototype.exec but without actually
 // constructing the JSRegExpResult. Returns either null (if the RegExp did not
 // match) or a fixed array containing match indices as returned by
 // RegExpExecStub.
 Node* RegExpBuiltinsAssembler::RegExpPrototypeExecBodyWithoutResult(
     Node* const context, Node* const regexp, Node* const string,
     Label* if_didnotmatch, const bool is_fastpath) {
-  Isolate* const isolate = this->isolate();
-
   Node* const null = NullConstant();
   Node* const int_zero = IntPtrConstant(0);
   Node* const smi_zero = SmiConstant(Smi::kZero);
 
   if (!is_fastpath) {
     ThrowIfNotInstanceType(context, regexp, JS_REGEXP_TYPE,
                            "RegExp.prototype.exec");
   }
 
   CSA_ASSERT(this, IsStringInstanceType(LoadInstanceType(string)));
   CSA_ASSERT(this, HasInstanceType(regexp, JS_REGEXP_TYPE));
 
   Variable var_result(this, MachineRepresentation::kTagged);
   Label out(this);
 
   // Load lastIndex.
   Variable var_lastindex(this, MachineRepresentation::kTagged);
   {
     Node* const regexp_lastindex = LoadLastIndex(context, regexp, is_fastpath);
     var_lastindex.Bind(regexp_lastindex);
 
     // Omit ToLength if lastindex is a non-negative smi.
     Label call_tolength(this, Label::kDeferred), next(this);
     Branch(TaggedIsPositiveSmi(regexp_lastindex), &next, &call_tolength);
 
     Bind(&call_tolength);
     {
-      Callable tolength_callable = CodeFactory::ToLength(isolate);
       var_lastindex.Bind(
-          CallStub(tolength_callable, context, regexp_lastindex));
+          CallBuiltin(Builtins::kToLength, context, regexp_lastindex));
       Goto(&next);
     }
 
     Bind(&next);
   }
 
   // Check whether the regexp is global or sticky, which determines whether we
   // update last index later on.
   Node* const flags = LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const is_global_or_sticky = WordAnd(
@@ skipping 119 matching lines @@
 
   Branch(IsJSReceiverInstanceType(value_instance_type), &out, &throw_exception);
 
   // The {value} is not a compatible receiver for this method.
   Bind(&throw_exception);
   {
     Node* const message_id = SmiConstant(Smi::FromInt(msg_template));
     Node* const method_name_str = HeapConstant(
         isolate()->factory()->NewStringFromAsciiChecked(method_name, TENURED));
 
-    Callable callable = CodeFactory::ToString(isolate());
-    Node* const value_str = CallStub(callable, context, maybe_receiver);
+    Node* const value_str =
+        CallBuiltin(Builtins::kToString, context, maybe_receiver);
 
     CallRuntime(Runtime::kThrowTypeError, context, message_id, method_name_str,
                 value_str);
     Unreachable();
   }
 
   Bind(&out);
   return var_value_map.value();
 }
 
@@ skipping 962 matching lines @@
   Variable var_length_;
   Variable var_capacity_;
 };
 
 }  // namespace
 
 void RegExpBuiltinsAssembler::RegExpPrototypeMatchBody(Node* const context,
                                                        Node* const regexp,
                                                        Node* const string,
                                                        const bool is_fastpath) {
-  Isolate* const isolate = this->isolate();
-
   Node* const null = NullConstant();
   Node* const int_zero = IntPtrConstant(0);
   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);
 
@@ skipping 92 matching lines @@
 
         // 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 = LoadStringLength(match);
         GotoIfNot(SmiEqual(match_length, smi_zero), &loop);
 
-        Node* last_index = LoadLastIndex(context, regexp, is_fastpath);
-
-        Callable tolength_callable = CodeFactory::ToLength(isolate);
-        last_index = CallStub(tolength_callable, context, last_index);
-
+        Node* const last_index =
+            CallBuiltin(Builtins::kToLength, context,
+                        LoadLastIndex(context, regexp, is_fastpath));
         Node* const new_last_index =
             AdvanceStringIndex(string, last_index, is_unicode);
 
         StoreLastIndex(context, regexp, new_last_index, is_fastpath);
 
         Goto(&loop);
       }
     }
 
     Bind(&out);
@@ skipping 455 matching lines @@
       "RegExp.prototype.@@split");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Node* const string = ToString(context, maybe_string);
 
   Label stub(this), runtime(this, Label::kDeferred);
   BranchIfFastRegExp(context, map, &stub, &runtime);
 
   Bind(&stub);
-  Callable split_callable = CodeFactory::RegExpSplit(isolate());
-  Return(CallStub(split_callable, context, receiver, string, maybe_limit));
+  Return(CallBuiltin(Builtins::kRegExpSplit, context, receiver, string,
+                     maybe_limit));
 
   Bind(&runtime);
   Return(CallRuntime(Runtime::kRegExpSplit, context, receiver, string,
                      maybe_limit));
 }
 
 Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
     Node* context, Node* regexp, Node* string, Node* replace_callable) {
   // The fast path is reached only if {receiver} is a global unmodified
   // JSRegExp instance and {replace_callable} is callable.
@@ skipping 317 matching lines @@
       runtime(this, Label::kDeferred);
 
   // 2. Is {replace_value} callable?
   GotoIf(TaggedIsSmi(replace_value), &checkreplacestring);
   Branch(IsCallableMap(LoadMap(replace_value)), &if_iscallable,
          &checkreplacestring);
 
   // 3. Does ToString({replace_value}) contain '$'?
   Bind(&checkreplacestring);
   {
-    Callable tostring_callable = CodeFactory::ToString(isolate());
     Node* const replace_string =
-        CallStub(tostring_callable, context, replace_value);
+        CallBuiltin(Builtins::kToString, context, replace_value);
 
-    Callable indexof_callable = CodeFactory::StringIndexOf(isolate());
     Node* const dollar_string = HeapConstant(
         isolate()->factory()->LookupSingleCharacterStringFromCode('$'));
-    Node* const dollar_ix = CallStub(indexof_callable, context, replace_string,
-                                     dollar_string, SmiConstant(0));
+    Node* const dollar_ix =
+        CallBuiltin(Builtins::kStringIndexOf, context, replace_string,
+                    dollar_string, SmiConstant(0));
     GotoIfNot(SmiEqual(dollar_ix, SmiConstant(-1)), &runtime);
 
     Return(
         ReplaceSimpleStringFastPath(context, regexp, string, replace_string));
   }
 
   // {regexp} is unmodified and {replace_value} is callable.
   Bind(&if_iscallable);
   {
     Node* const replace_fn = replace_value;
@@ skipping 43 matching lines @@
   //   }
   // }
 
   // Ensure {maybe_receiver} is a JSReceiver.
   Node* const map = ThrowIfNotJSReceiver(
       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 = CallStub(tostring_callable, context, maybe_string);
+  Node* const string = CallBuiltin(Builtins::kToString, context, maybe_string);
 
   // Fast-path checks: 1. Is the {receiver} an unmodified JSRegExp instance?
   Label stub(this), runtime(this, Label::kDeferred);
   BranchIfFastRegExp(context, map, &stub, &runtime);
 
   Bind(&stub);
-  Callable replace_callable = CodeFactory::RegExpReplace(isolate());
-  Return(CallStub(replace_callable, context, receiver, string, replace_value));
+  Return(CallBuiltin(Builtins::kRegExpReplace, context, receiver, string,
+                     replace_value));
 
   Bind(&runtime);
   Return(CallRuntime(Runtime::kRegExpReplace, context, receiver, string,
                      replace_value));
 }
 
 // Simple string matching functionality for internal use which does not modify
 // the last match info.
 TF_BUILTIN(RegExpInternalMatch, RegExpBuiltinsAssembler) {
   Node* const regexp = Parameter(1);
@@ skipping 19 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8