js/src/frontend/BytecodeControlStructures.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/BytecodeControlStructures.h"
   8
   9 #include "frontend/BytecodeEmitter.h"   // BytecodeEmitter
  10 #include "frontend/EmitterScope.h"      // EmitterScope
  11 #include "frontend/ForOfLoopControl.h"  // ForOfLoopControl
  12 #include "frontend/SwitchEmitter.h"     // SwitchEmitter
  13 #include "vm/Opcodes.h"                 // JSOp
  14
  15 using namespace js;
  16 using namespace js::frontend;
  17
  18 using mozilla::Maybe;
  19
  20 NestableControl::NestableControl(BytecodeEmitter* bce, StatementKind kind)
  21     : Nestable<NestableControl>(&bce->innermostNestableControl),
  22       kind_(kind),
  23       emitterScope_(bce->innermostEmitterScopeNoCheck()) {}
  24
  25 BreakableControl::BreakableControl(BytecodeEmitter* bce, StatementKind kind)
  26     : NestableControl(bce, kind) {
  27   MOZ_ASSERT(is<BreakableControl>());
  28 }
  29
  30 bool BreakableControl::patchBreaks(BytecodeEmitter* bce) {
  31   return bce->emitJumpTargetAndPatch(breaks);
  32 }
  33
  34 LabelControl::LabelControl(BytecodeEmitter* bce, TaggedParserAtomIndex label,
  35                            BytecodeOffset startOffset)
  36     : BreakableControl(bce, StatementKind::Label),
  37       label_(label),
  38       startOffset_(startOffset) {}
  39
  40 LoopControl::LoopControl(BytecodeEmitter* bce, StatementKind loopKind)
  41     : BreakableControl(bce, loopKind), tdzCache_(bce) {
  42   MOZ_ASSERT(is<LoopControl>());
  43
  44   LoopControl* enclosingLoop = findNearest<LoopControl>(enclosing());
  45
  46   stackDepth_ = bce->bytecodeSection().stackDepth();
  47   loopDepth_ = enclosingLoop ? enclosingLoop->loopDepth_ + 1 : 1;
  48 }
  49
  50 bool LoopControl::emitContinueTarget(BytecodeEmitter* bce) {
  51   // Note: this is always called after emitting the loop body so we must have
  52   // emitted all 'continues' by now.
  53   return bce->emitJumpTargetAndPatch(continues);
  54 }
  55
  56 bool LoopControl::emitLoopHead(BytecodeEmitter* bce,
  57                                const Maybe<uint32_t>& nextPos) {
  58   // Insert a Nop if needed to ensure the script does not start with a
  59   // JSOp::LoopHead. This avoids JIT issues with prologue code + try notes
  60   // or OSR. See bug 1602390 and bug 1602681.
  61   if (bce->bytecodeSection().offset().toUint32() == 0) {
  62     if (!bce->emit1(JSOp::Nop)) {
  63       return false;
  64     }
  65   }
  66
  67   if (nextPos) {
  68     if (!bce->updateSourceCoordNotes(*nextPos)) {
  69       return false;
  70     }
  71   }
  72
  73   MOZ_ASSERT(loopDepth_ > 0);
  74
  75   head_ = {bce->bytecodeSection().offset()};
  76
  77   BytecodeOffset off;
  78   if (!bce->emitJumpTargetOp(JSOp::LoopHead, &off)) {
  79     return false;
  80   }
  81   SetLoopHeadDepthHint(bce->bytecodeSection().code(off), loopDepth_);
  82
  83   return true;
  84 }
  85
  86 bool LoopControl::emitLoopEnd(BytecodeEmitter* bce, JSOp op,
  87                               TryNoteKind tryNoteKind) {
  88   JumpList jump;
  89   if (!bce->emitJumpNoFallthrough(op, &jump)) {
  90     return false;
  91   }
  92   bce->patchJumpsToTarget(jump, head_);
  93
  94   // Create a fallthrough for closing iterators, and as a target for break
  95   // statements.
  96   JumpTarget breakTarget;
  97   if (!bce->emitJumpTarget(&breakTarget)) {
  98     return false;
  99   }
 100   if (!patchBreaks(bce)) {
 101     return false;
 102   }
 103   if (!bce->addTryNote(tryNoteKind, bce->bytecodeSection().stackDepth(),
 104                        headOffset(), breakTarget.offset)) {
 105     return false;
 106   }
 107   return true;
 108 }
 109
 110 TryFinallyControl::TryFinallyControl(BytecodeEmitter* bce, StatementKind kind)
 111     : NestableControl(bce, kind) {
 112   MOZ_ASSERT(is<TryFinallyControl>());
 113 }
 114
 115 bool TryFinallyControl::allocateContinuation(NestableControl* target,
 116                                              NonLocalExitKind kind,
 117                                              uint32_t* idx) {
 118   for (uint32_t i = 0; i < continuations_.length(); i++) {
 119     if (continuations_[i].target_ == target &&
 120         continuations_[i].kind_ == kind) {
 121       *idx = i + SpecialContinuations::Count;
 122       return true;
 123     }
 124   }
 125   *idx = continuations_.length() + SpecialContinuations::Count;
 126   return continuations_.emplaceBack(target, kind);
 127 }
 128
 129 bool TryFinallyControl::emitContinuations(BytecodeEmitter* bce) {
 130   SwitchEmitter::TableGenerator tableGen(bce);
 131   for (uint32_t i = 0; i < continuations_.length(); i++) {
 132     if (!tableGen.addNumber(i + SpecialContinuations::Count)) {
 133       return false;
 134     }
 135   }
 136   tableGen.finish(continuations_.length());
 137   MOZ_RELEASE_ASSERT(tableGen.isValid());
 138
 139   InternalSwitchEmitter se(bce);
 140   if (!se.validateCaseCount(continuations_.length())) {
 141     return false;
 142   }
 143   if (!se.emitTable(tableGen)) {
 144     return false;
 145   }
 146
 147   // Continuation index 0 is special-cased to be the fallthrough block.
 148   // Non-default switch cases are numbered 1-N.
 149   uint32_t caseIdx = SpecialContinuations::Count;
 150   for (TryFinallyContinuation& continuation : continuations_) {
 151     if (!se.emitCaseBody(caseIdx++, tableGen)) {
 152       return false;
 153     }
 154     // Resume the non-local control flow that was intercepted by
 155     // this finally.
 156     NonLocalExitControl nle(bce, continuation.kind_);
 157     if (!nle.emitNonLocalJump(continuation.target_, this)) {
 158       return false;
 159     }
 160   }
 161
 162   // The only unhandled case is the fallthrough case, which is handled
 163   // by the switch default.
 164   if (!se.emitDefaultBody()) {
 165     return false;
 166   }
 167   if (!se.emitEnd()) {
 168     return false;
 169   }
 170   return true;
 171 }
 172
 173 NonLocalExitControl::NonLocalExitControl(BytecodeEmitter* bce,
 174                                          NonLocalExitKind kind)
 175     : bce_(bce),
 176       savedScopeNoteIndex_(bce->bytecodeSection().scopeNoteList().length()),
 177       savedDepth_(bce->bytecodeSection().stackDepth()),
 178       openScopeNoteIndex_(bce->innermostEmitterScope()->noteIndex()),
 179       kind_(kind) {}
 180
 181 NonLocalExitControl::~NonLocalExitControl() {
 182   for (uint32_t n = savedScopeNoteIndex_;
 183        n < bce_->bytecodeSection().scopeNoteList().length(); n++) {
 184     bce_->bytecodeSection().scopeNoteList().recordEnd(
 185         n, bce_->bytecodeSection().offset());
 186   }
 187   bce_->bytecodeSection().setStackDepth(savedDepth_);
 188 }
 189
 190 bool NonLocalExitControl::emitReturn(BytecodeOffset setRvalOffset) {
 191   MOZ_ASSERT(kind_ == NonLocalExitKind::Return);
 192   setRvalOffset_ = setRvalOffset;
 193   return emitNonLocalJump(nullptr);
 194 }
 195
 196 bool NonLocalExitControl::leaveScope(EmitterScope* es) {
 197   if (!es->leave(bce_, /* nonLocal = */ true)) {
 198     return false;
 199   }
 200
 201   // As we pop each scope due to the non-local jump, emit notes that
 202   // record the extent of the enclosing scope. These notes will have
 203   // their ends recorded in ~NonLocalExitControl().
 204   GCThingIndex enclosingScopeIndex = ScopeNote::NoScopeIndex;
 205   if (es->enclosingInFrame()) {
 206     enclosingScopeIndex = es->enclosingInFrame()->index();
 207   }
 208   if (!bce_->bytecodeSection().scopeNoteList().append(
 209           enclosingScopeIndex, bce_->bytecodeSection().offset(),
 210           openScopeNoteIndex_)) {
 211     return false;
 212   }
 213   openScopeNoteIndex_ = bce_->bytecodeSection().scopeNoteList().length() - 1;
 214
 215   return true;
 216 }
 217
 218 /*
 219  * Emit additional bytecode(s) for non-local jumps.
 220  */
 221 bool NonLocalExitControl::emitNonLocalJump(NestableControl* target,
 222                                            NestableControl* startingAfter) {
 223   NestableControl* startingControl = startingAfter
 224                                          ? startingAfter->enclosing()
 225                                          : bce_->innermostNestableControl;
 226   EmitterScope* es = startingAfter ? startingAfter->emitterScope()
 227                                    : bce_->innermostEmitterScope();
 228
 229   int npops = 0;
 230
 231   AutoCheckUnstableEmitterScope cues(bce_);
 232
 233   // We emit IteratorClose bytecode inline. 'continue' statements do
 234   // not call IteratorClose for the loop they are continuing.
 235   bool emitIteratorCloseAtTarget = kind_ != NonLocalExitKind::Continue;
 236
 237   auto flushPops = [&npops](BytecodeEmitter* bce) {
 238     if (npops && !bce->emitPopN(npops)) {
 239       return false;
 240     }
 241     npops = 0;
 242     return true;
 243   };
 244
 245   // If we are closing multiple for-of loops, the resulting
 246   // TryNoteKind::ForOfIterClose trynotes must be appropriately nested. Each
 247   // TryNoteKind::ForOfIterClose starts when we close the corresponding for-of
 248   // iterator, and continues until the actual jump.
 249   Vector<BytecodeOffset, 4> forOfIterCloseScopeStarts(bce_->fc);
 250
 251   // If we have to execute a finally block, then we will jump there now and
 252   // continue the non-local jump from the end of the finally block.
 253   bool jumpingToFinally = false;
 254
 255   // Walk the nestable control stack and patch jumps.
 256   for (NestableControl* control = startingControl;
 257        control != target && !jumpingToFinally; control = control->enclosing()) {
 258     // Walk the scope stack and leave the scopes we entered. Leaving a scope
 259     // may emit administrative ops like JSOp::PopLexicalEnv but never anything
 260     // that manipulates the stack.
 261     for (; es != control->emitterScope(); es = es->enclosingInFrame()) {
 262       if (!leaveScope(es)) {
 263         return false;
 264       }
 265     }
 266
 267     switch (control->kind()) {
 268       case StatementKind::Finally: {
 269         TryFinallyControl& finallyControl = control->as<TryFinallyControl>();
 270         if (finallyControl.emittingSubroutine()) {
 271           /*
 272            * There's a [resume-index-or-exception, throwing] pair on
 273            * the stack that we need to pop. If the script is not a
 274            * noScriptRval script, we also need to pop the cached rval.
 275            */
 276           if (bce_->sc->noScriptRval()) {
 277             npops += 2;
 278           } else {
 279             npops += 3;
 280           }
 281         } else {
 282           jumpingToFinally = true;
 283
 284           if (!flushPops(bce_)) {
 285             return false;
 286           }
 287           uint32_t idx;
 288           if (!finallyControl.allocateContinuation(target, kind_, &idx)) {
 289             return false;
 290           }
 291           if (!bce_->emitJumpToFinally(&finallyControl.finallyJumps_, idx)) {
 292             return false;
 293           }
 294         }
 295         break;
 296       }
 297
 298       case StatementKind::ForOfLoop: {
 299         if (!flushPops(bce_)) {
 300           return false;
 301         }
 302         BytecodeOffset tryNoteStart;
 303         ForOfLoopControl& loopinfo = control->as<ForOfLoopControl>();
 304         if (!loopinfo.emitPrepareForNonLocalJumpFromScope(
 305                 bce_, *es,
 306                 /* isTarget = */ false, &tryNoteStart)) {
 307           //      [stack] ...
 308           return false;
 309         }
 310         if (!forOfIterCloseScopeStarts.append(tryNoteStart)) {
 311           return false;
 312         }
 313         break;
 314       }
 315
 316       case StatementKind::ForInLoop:
 317         if (!flushPops(bce_)) {
 318           return false;
 319         }
 320
 321         // The iterator and the current value are on the stack.
 322         if (!bce_->emit1(JSOp::EndIter)) {
 323           //        [stack] ...
 324           return false;
 325         }
 326         break;
 327
 328       default:
 329         break;
 330     }
 331   }
 332
 333   if (!flushPops(bce_)) {
 334     return false;
 335   }
 336
 337   if (!jumpingToFinally) {
 338     if (target && emitIteratorCloseAtTarget && target->is<ForOfLoopControl>()) {
 339       BytecodeOffset tryNoteStart;
 340       ForOfLoopControl& loopinfo = target->as<ForOfLoopControl>();
 341       if (!loopinfo.emitPrepareForNonLocalJumpFromScope(bce_, *es,
 342                                                         /* isTarget = */ true,
 343                                                         &tryNoteStart)) {
 344         //            [stack] ... UNDEF UNDEF UNDEF
 345         return false;
 346       }
 347       if (!forOfIterCloseScopeStarts.append(tryNoteStart)) {
 348         return false;
 349       }
 350     }
 351
 352     EmitterScope* targetEmitterScope =
 353         target ? target->emitterScope() : bce_->varEmitterScope;
 354     for (; es != targetEmitterScope; es = es->enclosingInFrame()) {
 355       if (!leaveScope(es)) {
 356         return false;
 357       }
 358     }
 359     switch (kind_) {
 360       case NonLocalExitKind::Continue: {
 361         LoopControl* loop = &target->as<LoopControl>();
 362         if (!bce_->emitJump(JSOp::Goto, &loop->continues)) {
 363           return false;
 364         }
 365         break;
 366       }
 367       case NonLocalExitKind::Break: {
 368         BreakableControl* breakable = &target->as<BreakableControl>();
 369         if (!bce_->emitJump(JSOp::Goto, &breakable->breaks)) {
 370           return false;
 371         }
 372         break;
 373       }
 374       case NonLocalExitKind::Return:
 375         MOZ_ASSERT(!target);
 376         if (!bce_->finishReturn(setRvalOffset_)) {
 377           return false;
 378         }
 379         break;
 380     }
 381   }
 382
 383   // Close TryNoteKind::ForOfIterClose trynotes.
 384   BytecodeOffset end = bce_->bytecodeSection().offset();
 385   for (BytecodeOffset start : forOfIterCloseScopeStarts) {
 386     if (!bce_->addTryNote(TryNoteKind::ForOfIterClose, 0, start, end)) {
 387       return false;
 388     }
 389   }
 390
 391   return true;
 392 }