Line data    Source code

       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : #include "src/runtime/runtime-utils.h"
       5             : 
       6             : #include "src/arguments.h"
       7             : #include "src/counters.h"
       8             : #include "src/debug/debug.h"
       9             : #include "src/elements.h"
      10             : #include "src/objects-inl.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : namespace {
      16             : 
      17        1454 : void PromiseRejectEvent(Isolate* isolate, Handle<JSPromise> promise,
      18             :                         Handle<Object> rejected_promise, Handle<Object> value,
      19             :                         bool debug_event) {
      20             :   isolate->RunPromiseHook(PromiseHookType::kResolve, promise,
      21         727 :                           isolate->factory()->undefined_value());
      22             : 
      23         727 :   if (isolate->debug()->is_active() && debug_event) {
      24         290 :     isolate->debug()->OnPromiseReject(rejected_promise, value);
      25             :   }
      26             : 
      27             :   // Report only if we don't actually have a handler.
      28         727 :   if (!promise->has_handler()) {
      29             :     isolate->ReportPromiseReject(promise, value,
      30         727 :                                  v8::kPromiseRejectWithNoHandler);
      31             :   }
      32         727 : }
      33             : 
      34             : }  // namespace
      35             : 
      36        2761 : RUNTIME_FUNCTION(Runtime_PromiseRejectEventFromStack) {
      37             :   DCHECK_EQ(2, args.length());
      38         727 :   HandleScope scope(isolate);
      39        1454 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
      40         727 :   CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
      41             : 
      42             :   Handle<Object> rejected_promise = promise;
      43         727 :   if (isolate->debug()->is_active()) {
      44             :     // If the Promise.reject call is caught, then this will return
      45             :     // undefined, which will be interpreted by PromiseRejectEvent
      46             :     // as being a caught exception event.
      47         290 :     rejected_promise = isolate->GetPromiseOnStackOnThrow();
      48             :     isolate->debug()->OnAsyncTaskEvent(
      49             :         debug::kDebugEnqueuePromiseReject,
      50         580 :         isolate->debug()->NextAsyncTaskId(promise), 0);
      51             :   }
      52         727 :   PromiseRejectEvent(isolate, promise, rejected_promise, value, true);
      53         727 :   return isolate->heap()->undefined_value();
      54             : }
      55             : 
      56       24182 : RUNTIME_FUNCTION(Runtime_ReportPromiseReject) {
      57             :   DCHECK_EQ(2, args.length());
      58       12091 :   HandleScope scope(isolate);
      59       24182 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
      60       12091 :   CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
      61       12091 :   isolate->ReportPromiseReject(promise, value, v8::kPromiseRejectWithNoHandler);
      62       12091 :   return isolate->heap()->undefined_value();
      63             : }
      64             : 
      65        9734 : RUNTIME_FUNCTION(Runtime_PromiseRevokeReject) {
      66             :   DCHECK_EQ(1, args.length());
      67        4867 :   HandleScope scope(isolate);
      68        9734 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
      69             :   // At this point, no revocation has been issued before
      70        4867 :   CHECK(!promise->has_handler());
      71             :   isolate->ReportPromiseReject(promise, Handle<Object>(),
      72        4867 :                                v8::kPromiseHandlerAddedAfterReject);
      73        4867 :   return isolate->heap()->undefined_value();
      74             : }
      75             : 
      76      351116 : RUNTIME_FUNCTION(Runtime_EnqueuePromiseReactionJob) {
      77      175558 :   HandleScope scope(isolate);
      78             :   DCHECK_EQ(1, args.length());
      79      351116 :   CONVERT_ARG_HANDLE_CHECKED(PromiseReactionJobInfo, info, 0);
      80      175558 :   isolate->EnqueueMicrotask(info);
      81      175558 :   return isolate->heap()->undefined_value();
      82             : }
      83             : 
      84       51324 : RUNTIME_FUNCTION(Runtime_EnqueuePromiseResolveThenableJob) {
      85       25662 :   HandleScope scope(isolate);
      86             :   DCHECK_EQ(args.length(), 1);
      87       51324 :   CONVERT_ARG_HANDLE_CHECKED(PromiseResolveThenableJobInfo, info, 0);
      88       25662 :   isolate->EnqueueMicrotask(info);
      89       25662 :   return isolate->heap()->undefined_value();
      90             : }
      91             : 
      92         566 : RUNTIME_FUNCTION(Runtime_EnqueueMicrotask) {
      93         283 :   HandleScope scope(isolate);
      94             :   DCHECK_EQ(1, args.length());
      95         566 :   CONVERT_ARG_HANDLE_CHECKED(JSFunction, microtask, 0);
      96         283 :   isolate->EnqueueMicrotask(microtask);
      97         283 :   return isolate->heap()->undefined_value();
      98             : }
      99             : 
     100       15348 : RUNTIME_FUNCTION(Runtime_RunMicrotasks) {
     101        7674 :   HandleScope scope(isolate);
     102             :   DCHECK_EQ(0, args.length());
     103        7674 :   isolate->RunMicrotasks();
     104        7674 :   return isolate->heap()->undefined_value();
     105             : }
     106             : 
     107          30 : RUNTIME_FUNCTION(Runtime_PromiseStatus) {
     108          15 :   HandleScope scope(isolate);
     109             :   DCHECK_EQ(1, args.length());
     110          30 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
     111             : 
     112          15 :   return Smi::FromInt(promise->status());
     113             : }
     114             : 
     115           0 : RUNTIME_FUNCTION(Runtime_PromiseResult) {
     116           0 :   HandleScope scope(isolate);
     117             :   DCHECK_EQ(1, args.length());
     118           0 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
     119           0 :   return promise->result();
     120             : }
     121             : 
     122          10 : RUNTIME_FUNCTION(Runtime_PromiseMarkAsHandled) {
     123             :   SealHandleScope shs(isolate);
     124             :   DCHECK_EQ(1, args.length());
     125          10 :   CONVERT_ARG_CHECKED(JSPromise, promise, 0);
     126             : 
     127           5 :   promise->set_has_handler(true);
     128           5 :   return isolate->heap()->undefined_value();
     129             : }
     130             : 
     131       86176 : RUNTIME_FUNCTION(Runtime_PromiseHookInit) {
     132       43088 :   HandleScope scope(isolate);
     133             :   DCHECK_EQ(2, args.length());
     134       86176 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
     135       43088 :   CONVERT_ARG_HANDLE_CHECKED(Object, parent, 1);
     136       43088 :   isolate->RunPromiseHook(PromiseHookType::kInit, promise, parent);
     137       43088 :   return isolate->heap()->undefined_value();
     138             : }
     139             : 
     140       93774 : RUNTIME_FUNCTION(Runtime_PromiseHookResolve) {
     141       46887 :   HandleScope scope(isolate);
     142             :   DCHECK_EQ(1, args.length());
     143       93774 :   CONVERT_ARG_HANDLE_CHECKED(JSPromise, promise, 0);
     144             :   isolate->RunPromiseHook(PromiseHookType::kResolve, promise,
     145       93774 :                           isolate->factory()->undefined_value());
     146       46887 :   return isolate->heap()->undefined_value();
     147             : }
     148             : 
     149       27114 : RUNTIME_FUNCTION(Runtime_PromiseHookBefore) {
     150       13557 :   HandleScope scope(isolate);
     151             :   DCHECK_EQ(1, args.length());
     152       27114 :   CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
     153       13557 :   if (promise->IsJSPromise()) {
     154             :     isolate->RunPromiseHook(PromiseHookType::kBefore,
     155             :                             Handle<JSPromise>::cast(promise),
     156       27096 :                             isolate->factory()->undefined_value());
     157             :   }
     158       13557 :   return isolate->heap()->undefined_value();
     159             : }
     160             : 
     161       27086 : RUNTIME_FUNCTION(Runtime_PromiseHookAfter) {
     162       13543 :   HandleScope scope(isolate);
     163             :   DCHECK_EQ(1, args.length());
     164       27086 :   CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
     165       13543 :   if (promise->IsJSPromise()) {
     166             :     isolate->RunPromiseHook(PromiseHookType::kAfter,
     167             :                             Handle<JSPromise>::cast(promise),
     168       27086 :                             isolate->factory()->undefined_value());
     169             :   }
     170       13543 :   return isolate->heap()->undefined_value();
     171             : }
     172             : 
     173             : }  // namespace internal
     174             : }  // namespace v8