[promises] Port CreateResolvingFunctions to TF

src/code-stub-assembler.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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
+#include "src/promise-utils.h"
 
 namespace v8 {
 namespace internal {
 
 using compiler::Node;
 
 void CodeStubAssembler::Assert(const NodeGenerator& codition_body,
                                const char* message, const char* file,
                                int line) {
 #if defined(DEBUG)
@@ skipping 8197 matching lines @@
 }
 
 Node* CodeStubAssembler::IsPromiseHookEnabled() {
   Node* const is_promisehook_enabled =
       Load(MachineType::Uint8(),
            ExternalConstant(
                ExternalReference::is_promisehook_enabled_address(isolate())));
   return WordNotEqual(is_promisehook_enabled, Int32Constant(0));
 }
 
+Node* CodeStubAssembler::AllocateFunctionWithMapAndContext(Node* map,
+                                                           Node* shared_info,
+                                                           Node* context) {
+  Node* const code =
+      LoadObjectField(shared_info, SharedFunctionInfo::kCodeOffset);
+  Node* const code_entry =
+      IntPtrAdd(code, IntPtrConstant(Code::kHeaderSize - kHeapObjectTag));
+
+  Node* const fun = Allocate(JSFunction::kSize);
+  StoreMapNoWriteBarrier(fun, map);
+  StoreObjectFieldRoot(fun, JSObject::kPropertiesOffset,
+                       Heap::kEmptyFixedArrayRootIndex);
+  StoreObjectFieldRoot(fun, JSObject::kElementsOffset,
+                       Heap::kEmptyFixedArrayRootIndex);
+  StoreObjectFieldRoot(fun, JSFunction::kLiteralsOffset,
+                       Heap::kEmptyLiteralsArrayRootIndex);
+  StoreObjectFieldRoot(fun, JSFunction::kPrototypeOrInitialMapOffset,
+                       Heap::kTheHoleValueRootIndex);
+  StoreObjectFieldNoWriteBarrier(fun, JSFunction::kSharedFunctionInfoOffset,
+                                 shared_info);
+  StoreObjectFieldNoWriteBarrier(fun, JSFunction::kContextOffset, context);
+  StoreObjectFieldNoWriteBarrier(fun, JSFunction::kCodeEntryOffset, code_entry);
+  StoreObjectFieldRoot(fun, JSFunction::kNextFunctionLinkOffset,
+                       Heap::kUndefinedValueRootIndex);
+
+  return fun;
+}
+
+Node* CodeStubAssembler::CreatePromiseResolvingFunctionsContext(
+    Node* promise, Node* debug_event, Node* native_context) {
+  Node* const context =
+      Allocate(FixedArray::SizeFor(PromiseUtils::kPromiseContextLength));
+  Node* const map = HeapConstant(isolate()->factory()->function_context_map());
+  StoreMapNoWriteBarrier(context, map);

[Igor Sheludko, 2016/12/13 23:42:34]

StoreMapNoWriteBarrier(context, Heap::kFunctionContextMapRootIndex);

[gsathya, 2016/12/19 20:12:43]

Done.

+  StoreObjectFieldNoWriteBarrier(
+      context, FixedArray::kLengthOffset,
+      SmiConstant(PromiseUtils::kPromiseContextLength));
+
+  Node* const empty_fn =
+      LoadContextElement(native_context, Context::CLOSURE_INDEX);
+  StoreContextElement(context, Context::CLOSURE_INDEX, empty_fn);

[Igor Sheludko, 2016/12/13 23:42:34]

We can skip write barriers here and below since the new context is guaranteed to
be small enough to be allocated in new space. Maybe add
StoreContextElementNoWriteBarrier().

[gsathya, 2016/12/19 20:12:43]

Done.

+  StoreContextElement(context, Context::PREVIOUS_INDEX, UndefinedConstant());
+  StoreContextElement(context, Context::EXTENSION_INDEX, TheHoleConstant());
+  StoreContextElement(context, Context::NATIVE_CONTEXT_INDEX, native_context);
+  StoreContextElement(context, PromiseUtils::kAlreadyVisitedSlot,
+                      SmiConstant(0));
+  StoreContextElement(context, PromiseUtils::kPromiseSlot, promise);
+  StoreContextElement(context, PromiseUtils::kDebugEventSlot, debug_event);
+  return context;
+}
+
+std::pair<Node*, Node*> CodeStubAssembler::CreatePromiseResolvingFunctions(
+    Node* promise, Node* debug_event, Node* native_context) {
+  Node* const promise_context = CreatePromiseResolvingFunctionsContext(
+      promise, debug_event, native_context);
+  Node* const resolve_info =
+      LoadContextElement(native_context, Context::PROMISE_RESOLVE_SHARED_FUN);

[Igor Sheludko, 2016/12/13 23:42:34]

Please move the load before the call to respective allocate to make one live
value less.

[gsathya, 2016/12/19 20:12:43]

Done.

+  Node* const reject_info =
+      LoadContextElement(native_context, Context::PROMISE_REJECT_SHARED_FUN);

[Igor Sheludko, 2016/12/13 23:42:35]

Same here.

[gsathya, 2016/12/19 20:12:43]

Done.

+
+  Node* const map = LoadContextElement(
+      native_context, Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX);
+  Node* const resolve =
+      AllocateFunctionWithMapAndContext(map, resolve_info, promise_context);
+  Node* const reject =
+      AllocateFunctionWithMapAndContext(map, reject_info, promise_context);
+
+  return std::make_pair(resolve, reject);
+}
+
 Node* CodeStubAssembler::AllocateJSPromise(Node* context) {
   Node* const native_context = LoadNativeContext(context);
   Node* const promise_fun =
       LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX);
   Node* const initial_map =
       LoadObjectField(promise_fun, JSFunction::kPrototypeOrInitialMapOffset);
   Node* const instance = AllocateJSObjectFromMap(initial_map);
 
   return instance;
 }
 
 void CodeStubAssembler::PromiseInit(Node* promise) {
   StoreObjectField(promise, JSPromise::kStatusOffset,
                    SmiConstant(kPromisePending));
   StoreObjectField(promise, JSPromise::kFlagsOffset, SmiConstant(0));
 }
 
 void CodeStubAssembler::PromiseSet(Node* promise, Node* status, Node* result) {
   CSA_ASSERT(this, TaggedIsSmi(status));
   StoreObjectField(promise, JSPromise::kStatusOffset, status);
   StoreObjectField(promise, JSPromise::kResultOffset, result);
   StoreObjectField(promise, JSPromise::kFlagsOffset, SmiConstant(0));
 }
 
 }  // namespace internal
 }  // namespace v8