[regexp] Port RegExpConstructResultStub to TurboFan

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"
 
@@ skipping 74 matching lines @@
                                                 CodeStubAssembler* a,
                                                 compiler::Node* context,
                                                 compiler::Node* match_elements,
                                                 compiler::Node* string) {
   typedef CodeStubAssembler::Variable Variable;
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Label out(a);
 
-  Callable constructresult_callable =
-      CodeFactory::RegExpConstructResult(isolate);
-
   CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* const num_indices = a->SmiUntag(a->LoadFixedArrayElement(
       match_elements, a->IntPtrConstant(RegExpImpl::kLastCaptureCount), 0,
       mode));
   Node* const num_results = a->SmiTag(a->WordShr(num_indices, 1));
   Node* const start = a->LoadFixedArrayElement(
       match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture), 0, mode);
   Node* const end = a->LoadFixedArrayElement(
       match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture + 1), 0,
       mode);
 
   // Calculate the substring of the first match before creating the result array
   // to avoid an unnecessary write barrier storing the first result.
   Node* const first = a->SubString(context, string, start, end);
 
-  Node* const result = a->CallStub(constructresult_callable, context,
-                                   num_results, start, string);
+  Node* const result =
+      a->AllocateRegExpResult(context, num_results, start, string);
   Node* const result_elements = a->LoadElements(result);
 
   a->StoreFixedArrayElement(result_elements, a->IntPtrConstant(0), first,
                             SKIP_WRITE_BARRIER);
 
   a->GotoIf(a->SmiEqual(num_results, a->SmiConstant(Smi::FromInt(1))), &out);
 
   // Store all remaining captures.
   Node* const limit =
       a->IntPtrAdd(a->IntPtrConstant(RegExpImpl::kFirstCapture), num_indices);
@@ skipping 163 matching lines @@
     {
       Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                      match_elements, string);
       a->Return(result);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8