[promises] allow allocation in large object space

src/builtins/builtins-promise.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/code-stub-assembler.h"
 #include "src/promise-utils.h"
 
@@ skipping 360 matching lines @@
                            compiler::Node* promise, compiler::Node* value) {
   typedef compiler::Node Node;
 
   Node* elements = a->LoadObjectField(promise, offset);
   Node* length = a->LoadFixedArrayBaseLength(elements);
   CodeStubAssembler::ParameterMode mode = a->OptimalParameterMode();
   length = a->UntagParameter(length, mode);
 
   Node* delta = a->IntPtrOrSmiConstant(1, mode);
   Node* new_capacity = a->IntPtrAdd(length, delta);
-  ElementsKind kind = FAST_ELEMENTS;
 
-  Node* new_elements = a->AllocateFixedArray(kind, new_capacity, mode);
+  const ElementsKind kind = FAST_ELEMENTS;
+  const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
+  const CodeStubAssembler::AllocationFlags flags =
+      CodeStubAssembler::kAllowLargeObjectAllocation;
+  int additional_offset = 0;
 
-  a->CopyFixedArrayElements(kind, elements, new_elements, length,
-                            UPDATE_WRITE_BARRIER, mode);
-  a->StoreFixedArrayElement(new_elements, length, value, UPDATE_WRITE_BARRIER,
-                            0, mode);
+  Node* new_elements = a->AllocateFixedArray(kind, new_capacity, mode, flags);
+
+  a->CopyFixedArrayElements(kind, elements, new_elements, length, barrier_mode,
+                            mode);
+  a->StoreFixedArrayElement(new_elements, length, value, barrier_mode,
+                            additional_offset, mode);
 
   a->StoreObjectField(promise, offset, new_elements);
 }
 
 compiler::Node* InternalPerformPromiseThen(CodeStubAssembler* a,
                                            compiler::Node* context,
                                            compiler::Node* promise,
                                            compiler::Node* on_resolve,
                                            compiler::Node* on_reject,
                                            compiler::Node* deferred) {
@@ skipping 259 matching lines @@
   // 5. Return PerformPromiseThen(promise, onFulfilled, onRejected,
   //    resultCapability).
   a.Bind(&perform_promise_then);
   Node* const result = InternalPerformPromiseThen(
       &a, context, promise, on_resolve, on_reject, var_deferred.value());
   a.Return(result);
 }
 
 }  // namespace internal
 }  // namespace v8