[csa] Add ToLength and ToString variants with inlined fast checks

src/builtins/builtins-string-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-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/objects.h"
@@ skipping 714 matching lines @@
 
   // Check that {receiver} is coercible to Object and convert it to a String.
   receiver = ToThisString(context, receiver, "String.prototype.concat");
 
   // Concatenate all the arguments passed to this builtin.
   VARIABLE(var_result, MachineRepresentation::kTagged);
   var_result.Bind(receiver);
   arguments.ForEach(
       CodeStubAssembler::VariableList({&var_result}, zone()),
       [this, context, &var_result](Node* arg) {
-        arg = CallStub(CodeFactory::ToString(isolate()), context, arg);
+        arg = ToString_Inline(context, arg);
         var_result.Bind(CallStub(CodeFactory::StringAdd(isolate()), context,
                                  var_result.value(), arg));
       });
   arguments.PopAndReturn(var_result.value());
 }
 
 void StringBuiltinsAssembler::StringIndexOf(
     Node* const subject_string, Node* const subject_instance_type,
     Node* const search_string, Node* const search_instance_type,
     Node* const position, std::function<void(Node*)> f_return) {
@@ skipping 396 matching lines @@
 
   Node* const smi_zero = SmiConstant(0);
 
   RequireObjectCoercible(context, receiver, "String.prototype.replace");
 
   // Redirect to replacer method if {search[@@replace]} is not undefined.
 
   MaybeCallFunctionAtSymbol(
       context, search, isolate()->factory()->replace_symbol(),
       [=]() {
-        Callable tostring_callable = CodeFactory::ToString(isolate());
-        Node* const subject_string =
-            CallStub(tostring_callable, context, receiver);
+        Node* const subject_string = ToString_Inline(context, receiver);
 
         Callable replace_callable = CodeFactory::RegExpReplace(isolate());
         return CallStub(replace_callable, context, search, subject_string,
                         replace);
       },
       [=](Node* fn) {
         Callable call_callable = CodeFactory::Call(isolate());
         return CallJS(call_callable, context, fn, search, receiver, replace);
       });
 
   // Convert {receiver} and {search} to strings.
 
-  Callable tostring_callable = CodeFactory::ToString(isolate());
   Callable indexof_callable = CodeFactory::StringIndexOf(isolate());
 
-  Node* const subject_string = CallStub(tostring_callable, context, receiver);
-  Node* const search_string = CallStub(tostring_callable, context, search);
+  Node* const subject_string = ToString_Inline(context, receiver);
+  Node* const search_string = ToString_Inline(context, search);
 
   Node* const subject_length = LoadStringLength(subject_string);
   Node* const search_length = LoadStringLength(search_string);
 
   // Fast-path single-char {search}, long cons {receiver}, and simple string
   // {replace}.
   {
     Label next(this);
 
     GotoIfNot(SmiEqual(search_length, SmiConstant(1)), &next);
@@ skipping 33 matching lines @@
 
     // The spec requires to perform ToString(replace) if the {replace} is not
     // callable even if we are going to exit here.
     // Since ToString() being applied to Smi does not have side effects for
     // numbers we can skip it.
     GotoIf(TaggedIsSmi(replace), &return_subject);
     GotoIf(IsCallableMap(LoadMap(replace)), &return_subject);
 
     // TODO(jgruber): Could introduce ToStringSideeffectsStub which only
     // performs observable parts of ToString.
-    CallStub(tostring_callable, context, replace);
+    ToString_Inline(context, replace);
     Goto(&return_subject);
 
     BIND(&return_subject);
     Return(subject_string);
 
     BIND(&next);
   }
 
   Node* const match_end_index = SmiAdd(match_start_index, search_length);
 
@@ skipping 22 matching lines @@
   GotoIf(TaggedIsSmi(replace), &if_notcallablereplace);
   Branch(IsCallableMap(LoadMap(replace)), &if_iscallablereplace,
          &if_notcallablereplace);
 
   BIND(&if_iscallablereplace);
   {
     Callable call_callable = CodeFactory::Call(isolate());
     Node* const replacement =
         CallJS(call_callable, context, replace, UndefinedConstant(),
                search_string, match_start_index, subject_string);
-    Node* const replacement_string =
-        CallStub(tostring_callable, context, replacement);
+    Node* const replacement_string = ToString_Inline(context, replacement);
     var_result.Bind(CallStub(stringadd_callable, context, var_result.value(),
                              replacement_string));
     Goto(&out);
   }
 
   BIND(&if_notcallablereplace);
   {
-    Node* const replace_string = CallStub(tostring_callable, context, replace);
+    Node* const replace_string = ToString_Inline(context, replace);
     Node* const replacement =
         GetSubstitution(context, subject_string, match_start_index,
                         match_end_index, replace_string);
     var_result.Bind(
         CallStub(stringadd_callable, context, var_result.value(), replacement));
     Goto(&out);
   }
 
   BIND(&out);
   {
@@ skipping 16 matching lines @@
 
   Node* const smi_zero = SmiConstant(0);
 
   RequireObjectCoercible(context, receiver, "String.prototype.split");
 
   // Redirect to splitter method if {separator[@@split]} is not undefined.
 
   MaybeCallFunctionAtSymbol(
       context, separator, isolate()->factory()->split_symbol(),
       [=]() {
-        Callable tostring_callable = CodeFactory::ToString(isolate());
-        Node* const subject_string =
-            CallStub(tostring_callable, context, receiver);
+        Node* const subject_string = ToString_Inline(context, receiver);
 
         Callable split_callable = CodeFactory::RegExpSplit(isolate());
         return CallStub(split_callable, context, separator, subject_string,
                         limit);
       },
       [=](Node* fn) {
         Callable call_callable = CodeFactory::Call(isolate());
         return CallJS(call_callable, context, fn, separator, receiver, limit);
       });
 
   // String and integer conversions.
   // TODO(jgruber): The old implementation used Uint32Max instead of SmiMax -
   // but AFAIK there should not be a difference since arrays are capped at Smi
   // lengths.
 
-  Callable tostring_callable = CodeFactory::ToString(isolate());
-  Node* const subject_string = CallStub(tostring_callable, context, receiver);
+  Node* const subject_string = ToString_Inline(context, receiver);
   Node* const limit_number =
       Select(IsUndefined(limit), [=]() { return SmiConstant(Smi::kMaxValue); },
              [=]() { return ToUint32(context, limit); },
              MachineRepresentation::kTagged);
-  Node* const separator_string =
-      CallStub(tostring_callable, context, separator);
+  Node* const separator_string = ToString_Inline(context, separator);
 
   // Shortcut for {limit} == 0.
   {
     Label next(this);
     GotoIfNot(SmiEqual(limit_number, smi_zero), &next);
 
     const ElementsKind kind = FAST_ELEMENTS;
     Node* const native_context = LoadNativeContext(context);
     Node* const array_map = LoadJSArrayElementsMap(kind, native_context);
 
@@ skipping 435 matching lines @@
     CallRuntime(Runtime::kThrowIncompatibleMethodReceiver, context,
                 HeapConstant(factory()->NewStringFromAsciiChecked(
                     "String Iterator.prototype.next", TENURED)),
                 iterator);
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8