[regexp] Move source and species getter to TF

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 680 matching lines @@
     CASE_FOR_FLAG(JSRegExp::kUnicode, 'u', label_unicode, label_sticky);
     CASE_FOR_FLAG(JSRegExp::kSticky, 'y', label_sticky, out);
 #undef CASE_FOR_FLAG
 
     a.Bind(&out);
     a.Return(result);
   }
 }
 
 // ES6 21.2.5.10.
-BUILTIN(RegExpPrototypeSourceGetter) {
-  HandleScope scope(isolate);
+void Builtins::Generate_RegExpPrototypeSourceGetter(CodeAssemblerState* state) {
+  CodeStubAssembler a(state);
+  Node* const receiver = a.Parameter(0);
+  Node* const context = a.Parameter(3);
 
-  Handle<Object> recv = args.receiver();
-  if (!recv->IsJSRegExp()) {
-    Handle<JSFunction> regexp_fun = isolate->regexp_function();
-    if (*recv == regexp_fun->prototype()) {
-      isolate->CountUsage(v8::Isolate::kRegExpPrototypeSourceGetter);
-      return *isolate->factory()->NewStringFromAsciiChecked("(?:)");
-    }
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kRegExpNonRegExp,
-                              isolate->factory()->NewStringFromAsciiChecked(
-                                  "RegExp.prototype.source")));
+  // Check whether we have an unmodified regexp instance.
+  CLabel if_isjsregexp(&a), if_isnotjsregexp(&a, CLabel::kDeferred);
+
+  a.GotoIf(a.TaggedIsSmi(receiver), &if_isnotjsregexp);
+  a.Branch(a.HasInstanceType(receiver, JS_REGEXP_TYPE), &if_isjsregexp,
+           &if_isnotjsregexp);
+
+  a.Bind(&if_isjsregexp);
+  {
+    Node* const source = a.LoadObjectField(receiver, JSRegExp::kSourceOffset);
+    a.Return(source);
   }
 
-  Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(recv);
-  return regexp->source();
+  a.Bind(&if_isnotjsregexp);
+  {
+    Isolate* isolate = a.isolate();
+    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);
+
+    CLabel if_isprototype(&a), if_isnotprototype(&a);
+    a.Branch(a.WordEqual(receiver, initial_prototype), &if_isprototype,
+             &if_isnotprototype);
+
+    a.Bind(&if_isprototype);
+    {
+      const int counter = v8::Isolate::kRegExpPrototypeSourceGetter;
+      Node* const counter_smi = a.SmiConstant(counter);
+      a.CallRuntime(Runtime::kIncrementUseCounter, context, counter_smi);
+
+      Node* const result =
+          a.HeapConstant(isolate->factory()->NewStringFromAsciiChecked("(?:)"));
+      a.Return(result);
+    }
+
+    a.Bind(&if_isnotprototype);
+    {
+      Node* const message_id =
+          a.SmiConstant(Smi::FromInt(MessageTemplate::kRegExpNonRegExp));
+      Node* const method_name_str =
+          a.HeapConstant(isolate->factory()->NewStringFromAsciiChecked(
+              "RegExp.prototype.source"));
+      a.TailCallRuntime(Runtime::kThrowTypeError, context, message_id,
+                        method_name_str);
+    }
+  }
 }
 
 BUILTIN(RegExpPrototypeToString) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSReceiver, recv, "RegExp.prototype.toString");
 
   if (*recv == isolate->regexp_function()->prototype()) {
     isolate->CountUsage(v8::Isolate::kRegExpPrototypeToString);
   }
 
@@ skipping 20 matching lines @@
     Handle<String> flags_str;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, flags_str,
                                        Object::ToString(isolate, flags));
     builder.AppendString(flags_str);
   }
 
   RETURN_RESULT_OR_FAILURE(isolate, builder.Finish());
 }
 
 // ES6 21.2.4.2.
-BUILTIN(RegExpPrototypeSpeciesGetter) {
-  HandleScope scope(isolate);
-  return *args.receiver();
+void Builtins::Generate_RegExpPrototypeSpeciesGetter(
+    CodeAssemblerState* state) {
+  CodeStubAssembler a(state);
+  Node* const receiver = a.Parameter(0);
+  a.Return(receiver);
 }
 
 namespace {
 
 // Fast-path implementation for flag checks on an unmodified JSRegExp instance.
 Node* FastFlagGetter(CodeStubAssembler* a, Node* const regexp,
                      JSRegExp::Flag flag) {
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
   Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const mask = a->SmiConstant(Smi::FromInt(flag));
@@ skipping 1594 matching lines @@
   a.Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, &a, context,
                                                    match_indices, string);
     a.Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8