js/src/frontend/AsyncEmitter.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "frontend/AsyncEmitter.h"
   8
   9 #include "mozilla/Assertions.h"  // MOZ_ASSERT
  10
  11 #include "frontend/BytecodeEmitter.h"     // BytecodeEmitter
  12 #include "frontend/NameOpEmitter.h"       // NameOpEmitter
  13 #include "frontend/ParserAtom.h"          // TaggedParserAtomIndex
  14 #include "vm/AsyncFunctionResolveKind.h"  // AsyncFunctionResolveKind
  15 #include "vm/Opcodes.h"                   // JSOp
  16
  17 using namespace js;
  18 using namespace js::frontend;
  19
  20 bool AsyncEmitter::prepareForParamsWithExpressionOrDestructuring() {
  21   MOZ_ASSERT(state_ == State::Start);
  22 #ifdef DEBUG
  23   state_ = State::Parameters;
  24 #endif
  25
  26   rejectTryCatch_.emplace(bce_, TryEmitter::Kind::TryCatch,
  27                           TryEmitter::ControlKind::NonSyntactic);
  28   return rejectTryCatch_->emitTry();
  29 }
  30
  31 bool AsyncEmitter::prepareForParamsWithoutExpressionOrDestructuring() {
  32   MOZ_ASSERT(state_ == State::Start);
  33 #ifdef DEBUG
  34   state_ = State::Parameters;
  35 #endif
  36   return true;
  37 }
  38
  39 bool AsyncEmitter::emitParamsEpilogue() {
  40   MOZ_ASSERT(state_ == State::Parameters);
  41
  42   if (rejectTryCatch_) {
  43     // If we get here, we need to reset the TryEmitter. Parameters can't reuse
  44     // the reject try-catch block from the function body, because the body
  45     // may have pushed an additional var-environment. This messes up scope
  46     // resolution for the |.generator| variable, because we'd need different
  47     // hops to reach |.generator| depending on whether the error was thrown
  48     // from the parameters or the function body.
  49     if (!emitRejectCatch()) {
  50       return false;
  51     }
  52   }
  53
  54 #ifdef DEBUG
  55   state_ = State::PostParams;
  56 #endif
  57   return true;
  58 }
  59
  60 bool AsyncEmitter::prepareForModule() {
  61   // Unlike functions, modules do not have params that we need to worry about.
  62   // Instead, this code is for setting up the required generator that will be
  63   // used for top level await. Before we can start using top-level await in
  64   // modules, we need to emit a
  65   // |.generator| which we can use to pause and resume execution.
  66   MOZ_ASSERT(state_ == State::Start);
  67   MOZ_ASSERT(
  68       bce_->lookupName(TaggedParserAtomIndex::WellKnown::dot_generator_())
  69           .hasKnownSlot());
  70
  71   NameOpEmitter noe(bce_, TaggedParserAtomIndex::WellKnown::dot_generator_(),
  72                     NameOpEmitter::Kind::Initialize);
  73   if (!noe.prepareForRhs()) {
  74     //              [stack]
  75     return false;
  76   }
  77   if (!bce_->emit1(JSOp::Generator)) {
  78     //              [stack] GEN
  79     return false;
  80   }
  81   if (!noe.emitAssignment()) {
  82     //              [stack] GEN
  83     return false;
  84   }
  85   if (!bce_->emit1(JSOp::Pop)) {
  86     //              [stack]
  87     return false;
  88   }
  89
  90 #ifdef DEBUG
  91   state_ = State::ModulePrologue;
  92 #endif
  93
  94   return true;
  95 }
  96
  97 bool AsyncEmitter::prepareForBody() {
  98   MOZ_ASSERT(state_ == State::PostParams || state_ == State::ModulePrologue);
  99
 100   rejectTryCatch_.emplace(bce_, TryEmitter::Kind::TryCatch,
 101                           TryEmitter::ControlKind::NonSyntactic);
 102 #ifdef DEBUG
 103   state_ = State::Body;
 104 #endif
 105   return rejectTryCatch_->emitTry();
 106 }
 107
 108 bool AsyncEmitter::emitEndFunction() {
 109 #ifdef DEBUG
 110   MOZ_ASSERT(state_ == State::Body);
 111 #endif
 112
 113   // The final yield has already been emitted
 114   // by FunctionScriptEmitter::emitEndBody().
 115
 116   if (!emitRejectCatch()) {
 117     return false;
 118   }
 119
 120 #ifdef DEBUG
 121   state_ = State::End;
 122 #endif
 123   return true;
 124 }
 125
 126 bool AsyncEmitter::emitEndModule() {
 127 #ifdef DEBUG
 128   MOZ_ASSERT(state_ == State::Body);
 129 #endif
 130
 131   if (!emitFinalYield()) {
 132     return false;
 133   }
 134
 135   if (!emitRejectCatch()) {
 136     return false;
 137   }
 138
 139 #ifdef DEBUG
 140   state_ = State::End;
 141 #endif
 142   return true;
 143 }
 144
 145 bool AsyncEmitter::emitFinalYield() {
 146   if (!bce_->emit1(JSOp::Undefined)) {
 147     //              [stack] UNDEF
 148     return false;
 149   }
 150
 151   if (!bce_->emitGetDotGeneratorInInnermostScope()) {
 152     //              [stack] UNDEF GEN
 153     return false;
 154   }
 155
 156   if (!bce_->emit2(JSOp::AsyncResolve,
 157                    uint8_t(AsyncFunctionResolveKind::Fulfill))) {
 158     //              [stack] PROMISE
 159     return false;
 160   }
 161
 162   if (!bce_->emit1(JSOp::SetRval)) {
 163     //              [stack]
 164     return false;
 165   }
 166
 167   if (!bce_->emitGetDotGeneratorInInnermostScope()) {
 168     //              [stack] GEN
 169     return false;
 170   }
 171
 172   if (!bce_->emitYieldOp(JSOp::FinalYieldRval)) {
 173     //              [stack]
 174     return false;
 175   }
 176
 177   return true;
 178 }
 179
 180 bool AsyncEmitter::emitRejectCatch() {
 181   if (!rejectTryCatch_->emitCatch()) {
 182     //              [stack] EXC
 183     return false;
 184   }
 185
 186   if (!bce_->emitGetDotGeneratorInInnermostScope()) {
 187     //              [stack] EXC GEN
 188     return false;
 189   }
 190
 191   if (!bce_->emit2(JSOp::AsyncResolve,
 192                    uint8_t(AsyncFunctionResolveKind::Reject))) {
 193     //              [stack] PROMISE
 194     return false;
 195   }
 196
 197   if (!bce_->emit1(JSOp::SetRval)) {
 198     //              [stack]
 199     return false;
 200   }
 201
 202   if (!bce_->emitGetDotGeneratorInInnermostScope()) {
 203     //              [stack] GEN
 204     return false;
 205   }
 206
 207   if (!bce_->emitYieldOp(JSOp::FinalYieldRval)) {
 208     //              [stack]
 209     return false;
 210   }
 211
 212   if (!rejectTryCatch_->emitEnd()) {
 213     return false;
 214   }
 215
 216   rejectTryCatch_.reset();
 217   return true;
 218 }