[regexp] Add slow exec stub to reduce code size

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 437 matching lines @@
     Node* const pending_exception =
         Load(MachineType::AnyTagged(), pending_exception_address);
 
     // If there is no pending exception, a
     // stack overflow (on the backtrack stack) was detected in RegExp code.
 
     Label stack_overflow(this), rethrow(this);
     Branch(IsTheHole(pending_exception), &stack_overflow, &rethrow);
 
     Bind(&stack_overflow);
-    TailCallRuntime(Runtime::kThrowStackOverflow, context);
+    CallRuntime(Runtime::kThrowStackOverflow, context);
+    Unreachable();
 
     Bind(&rethrow);
-    TailCallRuntime(Runtime::kRegExpExecReThrow, context);
+    CallRuntime(Runtime::kRegExpExecReThrow, context);
+    Unreachable();
   }
 
   Bind(&runtime);
   {
     Node* const result = CallRuntime(Runtime::kRegExpExec, context, regexp,
                                      string, last_index, match_info);
     var_result.Bind(result);
     Goto(&out);
   }
 
@@ skipping 257 matching lines @@
                                                        Label* if_isunmodified,
                                                        Label* if_ismodified) {
   Node* const native_context = LoadNativeContext(context);
   Node* const initial_regexp_result_map =
       LoadContextElement(native_context, Context::REGEXP_RESULT_MAP_INDEX);
 
   Branch(WordEqual(map, initial_regexp_result_map), if_isunmodified,
          if_ismodified);
 }
 
+// Slow path stub for RegExpPrototypeExec to decrease code size.
+TF_BUILTIN(RegExpPrototypeExecSlow, RegExpBuiltinsAssembler) {
+  typedef GenericTagged2Descriptor Descriptor;
+
+  Node* const regexp = Parameter(Descriptor::kFirst);
+  Node* const string = Parameter(Descriptor::kSecond);
+  Node* const context = Parameter(Descriptor::kContext);
+
+  Return(RegExpPrototypeExecBody(context, regexp, string, false));
+}
+
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
 TF_BUILTIN(RegExpPrototypeExec, RegExpBuiltinsAssembler) {
   Node* const maybe_receiver = Parameter(0);
   Node* const maybe_string = Parameter(1);
   Node* const context = Parameter(4);
 
   // Ensure {maybe_receiver} is a JSRegExp.
   Node* const regexp_map = ThrowIfNotInstanceType(
       context, maybe_receiver, JS_REGEXP_TYPE, "RegExp.prototype.exec");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Node* const string = ToString(context, maybe_string);
 
   Label if_isfastpath(this), if_isslowpath(this);
   Branch(IsInitialRegExpMap(context, regexp_map), &if_isfastpath,
          &if_isslowpath);
 
   Bind(&if_isfastpath);
   {
     Node* const result =
         RegExpPrototypeExecBody(context, receiver, string, true);
     Return(result);
   }
 
   Bind(&if_isslowpath);
   {
-    Node* const result =
-        RegExpPrototypeExecBody(context, receiver, string, false);
+    Handle<Code> code = isolate()->builtins()->RegExpPrototypeExecSlow();
+    const auto desc = GenericTagged2Descriptor(isolate());
+    Callable callable(code, desc);
+
+    Node* const result = CallStub(callable, context, receiver, string);
     Return(result);
   }
 }
 
 Node* RegExpBuiltinsAssembler::FlagsGetter(Node* const context,
                                            Node* const regexp,
                                            bool is_fastpath) {
   Isolate* isolate = this->isolate();
 
   Node* const int_zero = IntPtrConstant(0);
@@ skipping 693 matching lines @@
 Node* RegExpBuiltinsAssembler::RegExpExec(Node* context, Node* regexp,
                                           Node* string) {
   Isolate* isolate = this->isolate();
 
   Node* const null = NullConstant();
 
   Variable var_result(this, MachineRepresentation::kTagged);
   Label out(this), if_isfastpath(this), if_isslowpath(this);
 
   Node* const map = LoadMap(regexp);
   BranchIfFastRegExp(context, map, &if_isfastpath, &if_isslowpath);

[Igor Sheludko, 2017/03/13 16:30:32]

I guess it's better to skip this check and jump directly to slow path.

[jgruber, 2017/03/17 09:51:22]

Done.

 
   Bind(&if_isfastpath);
-  {
-    Node* const result = RegExpPrototypeExecBody(context, regexp, string, true);
-    var_result.Bind(result);
-    Goto(&out);
-  }
+  Unreachable();
 
   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);
@@ skipping 18 matching lines @@
                            MessageTemplate::kInvalidRegExpExecResult, "unused");
 
       Goto(&out);
     }
 
     Bind(&if_isnotcallable);
     {
       ThrowIfNotInstanceType(context, regexp, JS_REGEXP_TYPE,
                              "RegExp.prototype.exec");
 
-      Node* const result =
-          RegExpPrototypeExecBody(context, regexp, string, false);
+      Handle<Code> code = isolate->builtins()->RegExpPrototypeExecSlow();
+      const auto desc = GenericTagged2Descriptor(isolate);
+      Callable callable(code, desc);
+
+      Node* const result = CallStub(callable, context, regexp, string);
       var_result.Bind(result);
       Goto(&out);
     }
   }
 
   Bind(&out);
   return var_result.value();
 }
 
 // ES#sec-regexp.prototype.test
@@ skipping 1281 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8