[csa] Replace remaining old-style GetProperty calls

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 16 matching lines @@
 
 Node* RegExpBuiltinsAssembler::FastLoadLastIndex(Node* regexp) {
   // Load the in-object field.
   static const int field_offset =
       JSRegExp::kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
   return LoadObjectField(regexp, field_offset);
 }
 
 Node* RegExpBuiltinsAssembler::SlowLoadLastIndex(Node* context, Node* regexp) {
   // Load through the GetProperty stub.
-  Node* const name = HeapConstant(isolate()->factory()->lastIndex_string());
-  Callable getproperty_callable = CodeFactory::GetProperty(isolate());
-  return CallStub(getproperty_callable, context, regexp, name);
+  return GetProperty(context, regexp, isolate()->factory()->lastIndex_string());
 }
 
 Node* RegExpBuiltinsAssembler::LoadLastIndex(Node* context, Node* regexp,
                                              bool is_fastpath) {
   return is_fastpath ? FastLoadLastIndex(regexp)
                      : SlowLoadLastIndex(context, regexp);
 }
 
 // The fast-path of StoreLastIndex when regexp is guaranteed to be an unmodified
 // JSRegExp instance.
@@ skipping 773 matching lines @@
     CASE_FOR_FLAG(JSRegExp::kMultiline);
     CASE_FOR_FLAG(JSRegExp::kUnicode);
     CASE_FOR_FLAG(JSRegExp::kSticky);
 #undef CASE_FOR_FLAG
   } else {
     DCHECK(!is_fastpath);
 
     // Fall back to GetProperty stub on the slow-path.
     var_flags.Bind(int_zero);
 
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-
-#define CASE_FOR_FLAG(NAME, FLAG)                                             \
-  do {                                                                        \
-    Label next(this);                                                         \
-    Node* const name =                                                        \
-        HeapConstant(isolate->factory()->InternalizeUtf8String(NAME));        \
-    Node* const flag = CallStub(getproperty_callable, context, regexp, name); \
-    Label if_isflagset(this);                                                 \
-    BranchIfToBooleanIsTrue(flag, &if_isflagset, &next);                      \
-    Bind(&if_isflagset);                                                      \
-    var_length.Bind(IntPtrAdd(var_length.value(), int_one));                  \
-    var_flags.Bind(WordOr(var_flags.value(), IntPtrConstant(FLAG)));          \
-    Goto(&next);                                                              \
-    Bind(&next);                                                              \
+#define CASE_FOR_FLAG(NAME, FLAG)                                          \
+  do {                                                                     \
+    Label next(this);                                                      \
+    Node* const flag = GetProperty(                                        \
+        context, regexp, isolate->factory()->InternalizeUtf8String(NAME)); \
+    Label if_isflagset(this);                                              \
+    BranchIfToBooleanIsTrue(flag, &if_isflagset, &next);                   \
+    Bind(&if_isflagset);                                                   \
+    var_length.Bind(IntPtrAdd(var_length.value(), int_one));               \
+    var_flags.Bind(WordOr(var_flags.value(), IntPtrConstant(FLAG)));       \
+    Goto(&next);                                                           \
+    Bind(&next);                                                           \
   } while (false)
 
     CASE_FOR_FLAG("global", JSRegExp::kGlobal);
     CASE_FOR_FLAG("ignoreCase", JSRegExp::kIgnoreCase);
     CASE_FOR_FLAG("multiline", JSRegExp::kMultiline);
     CASE_FOR_FLAG("unicode", JSRegExp::kUnicode);
     CASE_FOR_FLAG("sticky", JSRegExp::kSticky);
 #undef CASE_FOR_FLAG
   }
 
@@ skipping 38 matching lines @@
 
   Variable var_result(this, MachineRepresentation::kWord32, Int32Constant(0));
 
   GotoIf(TaggedIsSmi(maybe_receiver), &out);
   GotoIfNot(IsJSReceiver(maybe_receiver), &out);
 
   Node* const receiver = maybe_receiver;
 
   // Check @@match.
   {
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate());
-    Node* const name = HeapConstant(isolate()->factory()->match_symbol());
-    Node* const value = CallStub(getproperty_callable, context, receiver, name);
+    Node* const value =
+        GetProperty(context, receiver, isolate()->factory()->match_symbol());
 
     Label match_isundefined(this), match_isnotundefined(this);
     Branch(IsUndefined(value), &match_isundefined, &match_isnotundefined);
 
     Bind(&match_isundefined);
     Branch(HasInstanceType(receiver, JS_REGEXP_TYPE), &if_isregexp, &out);
 
     Bind(&match_isnotundefined);
     BranchIfToBooleanIsTrue(value, &if_isregexp, &out);
   }
@@ skipping 71 matching lines @@
 
   {
     Label next(this);
 
     GotoIfNot(IsUndefined(new_target), &next);
     var_new_target.Bind(regexp_function);
 
     GotoIfNot(pattern_is_regexp, &next);
     GotoIfNot(IsUndefined(flags), &next);
 
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-    Node* const name = HeapConstant(isolate->factory()->constructor_string());
-    Node* const value = CallStub(getproperty_callable, context, pattern, name);
+    Node* const value =
+        GetProperty(context, pattern, isolate->factory()->constructor_string());
 
     GotoIfNot(WordEqual(value, regexp_function), &next);
     Return(pattern);
 
     Bind(&next);
   }
 
   {
     Label next(this), if_patternisfastregexp(this),
         if_patternisslowregexp(this);
@@ skipping 17 matching lines @@
         Goto(&inner_next);
 
         Bind(&inner_next);
       }
 
       Goto(&next);
     }
 
     Bind(&if_patternisslowregexp);
     {
-      Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-
       {
-        Node* const name = HeapConstant(isolate->factory()->source_string());
         Node* const value =
-            CallStub(getproperty_callable, context, pattern, name);
+            GetProperty(context, pattern, isolate->factory()->source_string());
         var_pattern.Bind(value);
       }
 
       {
         Label inner_next(this);
         GotoIfNot(IsUndefined(flags), &inner_next);
 
-        Node* const name = HeapConstant(isolate->factory()->flags_string());
         Node* const value =
-            CallStub(getproperty_callable, context, pattern, name);
+            GetProperty(context, pattern, isolate->factory()->flags_string());
         var_flags.Bind(value);
         Goto(&inner_next);
 
         Bind(&inner_next);
       }
 
       Goto(&next);
     }
 
     Bind(&next);
@@ skipping 190 matching lines @@
 
 // Load through the GetProperty stub.
 Node* RegExpBuiltinsAssembler::SlowFlagGetter(Node* const context,
                                               Node* const regexp,
                                               JSRegExp::Flag flag) {
   Factory* factory = isolate()->factory();
 
   Label out(this);
   Variable var_result(this, MachineRepresentation::kWord32);
 
-  Node* name;
-
+  Handle<String> name;
   switch (flag) {
     case JSRegExp::kGlobal:
-      name = HeapConstant(factory->global_string());
+      name = factory->global_string();
       break;
     case JSRegExp::kIgnoreCase:
-      name = HeapConstant(factory->ignoreCase_string());
+      name = factory->ignoreCase_string();
       break;
     case JSRegExp::kMultiline:
-      name = HeapConstant(factory->multiline_string());
+      name = factory->multiline_string();
       break;
     case JSRegExp::kSticky:
-      name = HeapConstant(factory->sticky_string());
+      name = factory->sticky_string();
       break;
     case JSRegExp::kUnicode:
-      name = HeapConstant(factory->unicode_string());
+      name = factory->unicode_string();
       break;
     default:
       UNREACHABLE();
   }
 
-  Callable getproperty_callable = CodeFactory::GetProperty(isolate());
-  Node* const value = CallStub(getproperty_callable, context, regexp, name);
+  Node* const value = GetProperty(context, regexp, name);
 
   Label if_true(this), if_false(this);
   BranchIfToBooleanIsTrue(value, &if_true, &if_false);
 
   Bind(&if_true);
   {
     var_result.Bind(Int32Constant(1));
     Goto(&out);
   }
 
@@ skipping 207 matching lines @@
     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.
-    Node* const name = HeapConstant(isolate->factory()->exec_string());
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-    Node* const exec = CallStub(getproperty_callable, context, regexp, name);
+    Node* const exec =
+        GetProperty(context, regexp, isolate->factory()->exec_string());
 
     // Is {exec} callable?
     Label if_iscallable(this), if_isnotcallable(this);
 
     GotoIf(TaggedIsSmi(exec), &if_isnotcallable);
 
     Node* const exec_map = LoadMap(exec);
     Branch(IsCallableMap(exec_map), &if_iscallable, &if_isnotcallable);
 
     Bind(&if_iscallable);
@@ skipping 339 matching lines @@
             // The match is guaranteed to be a string on the fast path.
             CSA_ASSERT(this, IsStringInstanceType(LoadInstanceType(match)));
 
             var_match.Bind(match);
             Goto(&if_didmatch);
           }
 
           Bind(&slow_result);
           {
             // TODO(ishell): Use GetElement stub once it's available.
-            Node* const name = smi_zero;
-            Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-            Node* const match =
-                CallStub(getproperty_callable, context, result, name);
-
+            Node* const match = GetProperty(context, result, smi_zero);
             var_match.Bind(ToString(context, match));
             Goto(&if_didmatch);
           }
         }
       }
 
       Bind(&if_didnotmatch);
       {
         // Return null if there were no matches, otherwise just exit the loop.
         GotoIfNot(IntPtrEqual(array.length(), int_zero), &out);
@@ skipping 146 matching lines @@
 
     Bind(&fast_result);
     {
       Node* const index =
           LoadObjectField(exec_result, JSRegExpResult::kIndexOffset);
       Return(index);
     }
 
     Bind(&slow_result);
     {
-      Node* const name = HeapConstant(isolate->factory()->index_string());
-      Callable getproperty_callable = CodeFactory::GetProperty(isolate);
-      Node* const index =
-          CallStub(getproperty_callable, context, exec_result, name);
-      Return(index);
+      Return(GetProperty(context, exec_result,
+                         isolate->factory()->index_string()));
     }
   }
 }
 
 // ES#sec-regexp.prototype-@@search
 // RegExp.prototype [ @@search ] ( string )
 TF_BUILTIN(RegExpPrototypeSearch, RegExpBuiltinsAssembler) {
   Node* const maybe_receiver = Parameter(0);
   Node* const maybe_string = Parameter(1);
   Node* const context = Parameter(4);
@@ skipping 776 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8