[Interpreter] Inline FastCloneRegExpStub to CreateRegExpLiteral bytecode handler.

src/code-stubs.cc

 // Copyright 2012 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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 4597 matching lines @@
 void FastNewFunctionContextStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* function = assembler->Parameter(Descriptor::kFunction);
   Node* slots = assembler->Parameter(FastNewFunctionContextDescriptor::kSlots);
   Node* context = assembler->Parameter(Descriptor::kContext);
 
   assembler->Return(Generate(assembler, function, slots, context));
 }
 
-void FastCloneRegExpStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+// static
+compiler::Node* FastCloneRegExpStub::Generate(CodeStubAssembler* assembler,
+                                              compiler::Node* closure,
+                                              compiler::Node* literal_index,
+                                              compiler::Node* pattern,
+                                              compiler::Node* flags,
+                                              compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
+  typedef CodeStubAssembler::Variable Variable;
   typedef compiler::Node Node;
 
-  Label call_runtime(assembler, Label::kDeferred);
+  Label call_runtime(assembler, Label::kDeferred), end(assembler);
 
-  Node* closure = assembler->Parameter(Descriptor::kClosure);
-  Node* literal_index = assembler->Parameter(Descriptor::kLiteralIndex);
+  Variable result(assembler, MachineRepresentation::kTagged);
 
   Node* undefined = assembler->UndefinedConstant();
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* boilerplate = assembler->LoadFixedArrayElement(
       literals_array, literal_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize,
       CodeStubAssembler::SMI_PARAMETERS);
   assembler->GotoIf(assembler->WordEqual(boilerplate, undefined),
                     &call_runtime);
 
   {
     int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
     Node* copy = assembler->Allocate(size);
     for (int offset = 0; offset < size; offset += kPointerSize) {
       Node* value = assembler->LoadObjectField(boilerplate, offset);
       assembler->StoreObjectFieldNoWriteBarrier(copy, offset, value);
     }
-    assembler->Return(copy);
+    result.Bind(copy);
+    assembler->Goto(&end);
   }
 
   assembler->Bind(&call_runtime);
   {
-    Node* context = assembler->Parameter(Descriptor::kContext);
-    Node* pattern = assembler->Parameter(Descriptor::kPattern);
-    Node* flags = assembler->Parameter(Descriptor::kFlags);
-    assembler->TailCallRuntime(Runtime::kCreateRegExpLiteral, context, closure,
-                               literal_index, pattern, flags);
+    result.Bind(assembler->CallRuntime(Runtime::kCreateRegExpLiteral, context,
+                                       closure, literal_index, pattern, flags));
+    assembler->Goto(&end);
   }
+
+  assembler->Bind(&end);
+  return result.value();
+}
+
+void FastCloneRegExpStub::GenerateAssembly(CodeStubAssembler* assembler) const {
+  typedef compiler::Node Node;
+  Node* closure = assembler->Parameter(Descriptor::kClosure);
+  Node* literal_index = assembler->Parameter(Descriptor::kLiteralIndex);
+  Node* pattern = assembler->Parameter(Descriptor::kPattern);
+  Node* flags = assembler->Parameter(Descriptor::kFlags);
+  Node* context = assembler->Parameter(Descriptor::kContext);
+
+  assembler->Return(
+      Generate(assembler, closure, literal_index, pattern, flags, context));
 }
 
 void CreateAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateAllocationSiteStub stub(isolate);
   stub.GetCode();
 }
 
 
 void CreateWeakCellStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateWeakCellStub stub(isolate);
@@ skipping 389 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8