js/src/vm/JSContext.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 /*
   8  * JS execution context.
   9  */
  10
  11 #include "vm/JSContext-inl.h"
  12
  13 #include "mozilla/CheckedInt.h"
  14 #include "mozilla/DebugOnly.h"
  15 #include "mozilla/MemoryReporting.h"
  16 #include "mozilla/Sprintf.h"
  17 #include "mozilla/Utf8.h"  // mozilla::ConvertUtf16ToUtf8
  18
  19 #include <string.h>
  20 #ifdef ANDROID
  21 #  include <android/log.h>
  22 #  include <fstream>
  23 #  include <string>
  24 #endif  // ANDROID
  25 #ifdef XP_WIN
  26 #  include <processthreadsapi.h>
  27 #endif  // XP_WIN
  28
  29 #include "jsapi.h"  // JS_SetNativeStackQuota
  30 #include "jsexn.h"
  31 #include "jstypes.h"
  32
  33 #include "builtin/RegExp.h"  // js::RegExpSearcherLastLimitSentinel
  34 #include "frontend/FrontendContext.h"
  35 #include "gc/GC.h"
  36 #include "irregexp/RegExpAPI.h"
  37 #include "jit/Simulator.h"
  38 #include "js/CallAndConstruct.h"  // JS::Call
  39 #include "js/CharacterEncoding.h"
  40 #include "js/ContextOptions.h"        // JS::ContextOptions
  41 #include "js/ErrorInterceptor.h"      // JSErrorInterceptor
  42 #include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
  43 #include "js/friend/StackLimits.h"    // js::ReportOverRecursed
  44 #include "js/MemoryCallbacks.h"
  45 #include "js/Printf.h"
  46 #include "js/PropertyAndElement.h"  // JS_GetProperty
  47 #include "js/Stack.h"  // JS::NativeStackSize, JS::NativeStackLimit, JS::NativeStackLimitMin
  48 #include "util/DiagnosticAssertions.h"
  49 #include "util/DifferentialTesting.h"
  50 #include "util/DoubleToString.h"
  51 #include "util/NativeStack.h"
  52 #include "util/Text.h"
  53 #include "util/WindowsWrapper.h"
  54 #include "vm/BytecodeUtil.h"  // JSDVG_IGNORE_STACK
  55 #include "vm/ErrorObject.h"
  56 #include "vm/ErrorReporting.h"
  57 #include "vm/JSFunction.h"
  58 #include "vm/JSObject.h"
  59 #include "vm/PlainObject.h"  // js::PlainObject
  60 #include "vm/Realm.h"
  61 #include "vm/StringType.h"  // StringToNewUTF8CharsZ
  62 #include "vm/ToSource.h"    // js::ValueToSource
  63
  64 #include "vm/Compartment-inl.h"
  65 #include "vm/Stack-inl.h"
  66
  67 using namespace js;
  68
  69 #ifdef DEBUG
  70 JSContext* js::MaybeGetJSContext() {
  71   if (!TlsContext.init()) {
  72     return nullptr;
  73   }
  74   return TlsContext.get();
  75 }
  76 #endif
  77
  78 bool js::AutoCycleDetector::init() {
  79   MOZ_ASSERT(cyclic);
  80
  81   AutoCycleDetector::Vector& vector = cx->cycleDetectorVector();
  82
  83   for (JSObject* obj2 : vector) {
  84     if (MOZ_UNLIKELY(obj == obj2)) {
  85       return true;
  86     }
  87   }
  88
  89   if (!vector.append(obj)) {
  90     return false;
  91   }
  92
  93   cyclic = false;
  94   return true;
  95 }
  96
  97 js::AutoCycleDetector::~AutoCycleDetector() {
  98   if (MOZ_LIKELY(!cyclic)) {
  99     AutoCycleDetector::Vector& vec = cx->cycleDetectorVector();
 100     MOZ_ASSERT(vec.back() == obj);
 101     if (vec.length() > 1) {
 102       vec.popBack();
 103     } else {
 104       // Avoid holding on to unused heap allocations.
 105       vec.clearAndFree();
 106     }
 107   }
 108 }
 109
 110 bool JSContext::init() {
 111   TlsContext.set(this);
 112   nativeStackBase_.emplace(GetNativeStackBase());
 113
 114   if (!fx.initInstance()) {
 115     return false;
 116   }
 117
 118 #ifdef JS_SIMULATOR
 119   simulator_ = jit::Simulator::Create();
 120   if (!simulator_) {
 121     return false;
 122   }
 123 #endif
 124
 125   isolate = irregexp::CreateIsolate(this);
 126   if (!isolate) {
 127     return false;
 128   }
 129
 130 #ifdef DEBUG
 131   // Set the initialized_ last, so that ProtectedData checks will allow us to
 132   // initialize this context before it becomes the runtime's active context.
 133   initialized_ = true;
 134 #endif
 135
 136   return true;
 137 }
 138
 139 static void InitDefaultStackQuota(JSContext* cx) {
 140   // Initialize stack quota to a reasonable default. Embedders can override this
 141   // by calling JS_SetNativeStackQuota.
 142   //
 143   // NOTE: Firefox overrides these values. For the main thread this happens in
 144   // XPCJSContext::Initialize.
 145
 146 #if defined(MOZ_ASAN) || (defined(DEBUG) && !defined(XP_WIN))
 147   static constexpr JS::NativeStackSize MaxStackSize =
 148       2 * 128 * sizeof(size_t) * 1024;
 149 #else
 150   static constexpr JS::NativeStackSize MaxStackSize =
 151       128 * sizeof(size_t) * 1024;
 152 #endif
 153   JS_SetNativeStackQuota(cx, MaxStackSize);
 154 }
 155
 156 JSContext* js::NewContext(uint32_t maxBytes, JSRuntime* parentRuntime) {
 157   AutoNoteSingleThreadedRegion anstr;
 158
 159   MOZ_RELEASE_ASSERT(!TlsContext.get());
 160
 161 #if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
 162   js::oom::SetThreadType(!parentRuntime ? js::THREAD_TYPE_MAIN
 163                                         : js::THREAD_TYPE_WORKER);
 164 #endif
 165
 166   JSRuntime* runtime = js_new<JSRuntime>(parentRuntime);
 167   if (!runtime) {
 168     return nullptr;
 169   }
 170
 171   JSContext* cx = js_new<JSContext>(runtime, JS::ContextOptions());
 172   if (!cx) {
 173     js_delete(runtime);
 174     return nullptr;
 175   }
 176
 177   if (!cx->init()) {
 178     js_delete(cx);
 179     js_delete(runtime);
 180     return nullptr;
 181   }
 182
 183   if (!runtime->init(cx, maxBytes)) {
 184     runtime->destroyRuntime();
 185     js_delete(cx);
 186     js_delete(runtime);
 187     return nullptr;
 188   }
 189
 190   // Initialize stack quota last because simulators rely on the JSRuntime having
 191   // been initialized.
 192   InitDefaultStackQuota(cx);
 193
 194   return cx;
 195 }
 196
 197 void js::DestroyContext(JSContext* cx) {
 198   JS_AbortIfWrongThread(cx);
 199
 200   MOZ_ASSERT(!cx->realm(), "Shouldn't destroy context with active realm");
 201   MOZ_ASSERT(!cx->activation(), "Shouldn't destroy context with activations");
 202
 203   cx->checkNoGCRooters();
 204
 205   // Cancel all off thread Ion compiles. Completed Ion compiles may try to
 206   // interrupt this context. See HelperThread::handleIonWorkload.
 207   CancelOffThreadIonCompile(cx->runtime());
 208
 209   cx->jobQueue = nullptr;
 210   cx->internalJobQueue = nullptr;
 211   SetContextProfilingStack(cx, nullptr);
 212
 213   JSRuntime* rt = cx->runtime();
 214
 215   // Flush promise tasks executing in helper threads early, before any parts
 216   // of the JSRuntime that might be visible to helper threads are torn down.
 217   rt->offThreadPromiseState.ref().shutdown(cx);
 218
 219   // Destroy the runtime along with its last context.
 220   js::AutoNoteSingleThreadedRegion nochecks;
 221   rt->destroyRuntime();
 222   js_delete_poison(cx);
 223   js_delete_poison(rt);
 224 }
 225
 226 void JS::RootingContext::checkNoGCRooters() {
 227 #ifdef DEBUG
 228   for (auto const& stackRootPtr : stackRoots_) {
 229     MOZ_ASSERT(stackRootPtr == nullptr);
 230   }
 231 #endif
 232 }
 233
 234 bool AutoResolving::alreadyStartedSlow() const {
 235   MOZ_ASSERT(link);
 236   AutoResolving* cursor = link;
 237   do {
 238     MOZ_ASSERT(this != cursor);
 239     if (object.get() == cursor->object && id.get() == cursor->id &&
 240         kind == cursor->kind) {
 241       return true;
 242     }
 243   } while (!!(cursor = cursor->link));
 244   return false;
 245 }
 246
 247 static void MaybeReportOutOfMemoryForDifferentialTesting() {
 248   /*
 249    * OOMs are non-deterministic, especially across different execution modes
 250    * (e.g. interpreter vs JIT). When doing differential testing, print to stderr
 251    * so that the fuzzers can detect this.
 252    */
 253   if (js::SupportDifferentialTesting()) {
 254     fprintf(stderr, "ReportOutOfMemory called\n");
 255   }
 256 }
 257
 258 /*
 259  * Since memory has been exhausted, avoid the normal error-handling path which
 260  * allocates an error object, report and callstack. Instead simply throw the
 261  * static atom "out of memory".
 262  *
 263  * Furthermore, callers of ReportOutOfMemory (viz., malloc) assume a GC does
 264  * not occur, so GC must be avoided or suppressed.
 265  */
 266 void JSContext::onOutOfMemory() {
 267   runtime()->hadOutOfMemory = true;
 268   gc::AutoSuppressGC suppressGC(this);
 269
 270   /* Report the oom. */
 271   if (JS::OutOfMemoryCallback oomCallback = runtime()->oomCallback) {
 272     oomCallback(this, runtime()->oomCallbackData);
 273   }
 274
 275   // If we OOM early in process startup, this may be unavailable so just return
 276   // instead of crashing unexpectedly.
 277   if (MOZ_UNLIKELY(!runtime()->hasInitializedSelfHosting())) {
 278     return;
 279   }
 280
 281   RootedValue oomMessage(this, StringValue(names().out_of_memory_));
 282   setPendingException(oomMessage, nullptr);
 283   MOZ_ASSERT(status == JS::ExceptionStatus::Throwing);
 284   status = JS::ExceptionStatus::OutOfMemory;
 285
 286   reportResourceExhaustion();
 287 }
 288
 289 JS_PUBLIC_API void js::ReportOutOfMemory(JSContext* cx) {
 290   MaybeReportOutOfMemoryForDifferentialTesting();
 291
 292   cx->onOutOfMemory();
 293 }
 294
 295 JS_PUBLIC_API void js::ReportLargeOutOfMemory(JSContext* cx) {
 296   js::ReportOutOfMemory(cx);
 297 }
 298
 299 JS_PUBLIC_API void js::ReportOutOfMemory(FrontendContext* fc) {
 300   MaybeReportOutOfMemoryForDifferentialTesting();
 301
 302   fc->onOutOfMemory();
 303 }
 304
 305 static void MaybeReportOverRecursedForDifferentialTesting() {
 306   /*
 307    * We cannot make stack depth deterministic across different
 308    * implementations (e.g. JIT vs. interpreter will differ in
 309    * their maximum stack depth).
 310    * However, we can detect externally when we hit the maximum
 311    * stack depth which is useful for external testing programs
 312    * like fuzzers.
 313    */
 314   if (js::SupportDifferentialTesting()) {
 315     fprintf(stderr, "ReportOverRecursed called\n");
 316   }
 317 }
 318
 319 void JSContext::onOverRecursed() {
 320   // Try to construct an over-recursed error and then update the exception
 321   // status to `OverRecursed`. Creating the error can fail, so check there
 322   // is a reasonable looking exception pending before updating status.
 323   JS_ReportErrorNumberASCII(this, GetErrorMessage, nullptr,
 324                             JSMSG_OVER_RECURSED);
 325   if (isExceptionPending() && !isThrowingOutOfMemory()) {
 326     MOZ_ASSERT(unwrappedException().isObject());
 327     MOZ_ASSERT(status == JS::ExceptionStatus::Throwing);
 328     status = JS::ExceptionStatus::OverRecursed;
 329   }
 330
 331   reportResourceExhaustion();
 332 }
 333
 334 JS_PUBLIC_API void js::ReportOverRecursed(JSContext* maybecx) {
 335   MaybeReportOverRecursedForDifferentialTesting();
 336
 337   if (!maybecx) {
 338     return;
 339   }
 340
 341   maybecx->onOverRecursed();
 342 }
 343
 344 JS_PUBLIC_API void js::ReportOverRecursed(FrontendContext* fc) {
 345   MaybeReportOverRecursedForDifferentialTesting();
 346
 347   fc->onOverRecursed();
 348 }
 349
 350 void js::ReportOversizedAllocation(JSContext* cx, const unsigned errorNumber) {
 351   // The JIT may optimize away allocations if it determines that they aren't
 352   // used. This can affect whether we throw an exception when the size of an
 353   // allocation exceeds implementation-defined limits (eg JSString::MAX_LENGTH).
 354   // These errors aren't interesting for the purposes of differential fuzzing.
 355   // We print a message so that fuzzers can detect this case. To simplify
 356   // tooling updates, we use the same message as ReportOutOfMemory.
 357   if (js::SupportDifferentialTesting()) {
 358     fprintf(stderr, "ReportOutOfMemory called\n");
 359   }
 360
 361   gc::AutoSuppressGC suppressGC(cx);
 362   JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, errorNumber);
 363
 364   cx->reportResourceExhaustion();
 365 }
 366
 367 void js::ReportAllocationOverflow(JSContext* cx) {
 368   if (js::SupportDifferentialTesting()) {
 369     fprintf(stderr, "ReportAllocationOverflow called\n");
 370   }
 371
 372   if (!cx) {
 373     return;
 374   }
 375
 376   cx->reportAllocationOverflow();
 377 }
 378
 379 void js::ReportAllocationOverflow(FrontendContext* fc) {
 380   fc->onAllocationOverflow();
 381 }
 382
 383 /* |callee| requires a usage string provided by JS_DefineFunctionsWithHelp. */
 384 void js::ReportUsageErrorASCII(JSContext* cx, HandleObject callee,
 385                                const char* msg) {
 386   RootedValue usage(cx);
 387   if (!JS_GetProperty(cx, callee, "usage", &usage)) {
 388     return;
 389   }
 390
 391   if (!usage.isString()) {
 392     JS_ReportErrorASCII(cx, "%s", msg);
 393   } else {
 394     RootedString usageStr(cx, usage.toString());
 395     UniqueChars str = JS_EncodeStringToUTF8(cx, usageStr);
 396     if (!str) {
 397       return;
 398     }
 399     JS_ReportErrorUTF8(cx, "%s. Usage: %s", msg, str.get());
 400   }
 401 }
 402
 403 enum class PrintErrorKind { Error, Warning, Note };
 404
 405 static void PrintErrorLine(FILE* file, const char* prefix,
 406                            JSErrorReport* report) {
 407   if (const char16_t* linebuf = report->linebuf()) {
 408     UniqueChars line;
 409     size_t n;
 410     {
 411       size_t linebufLen = report->linebufLength();
 412
 413       // This function is only used for shell command-line sorts of stuff where
 414       // performance doesn't really matter, so just encode into max-sized
 415       // memory.
 416       mozilla::CheckedInt<size_t> utf8Len(linebufLen);
 417       utf8Len *= 3;
 418       if (utf8Len.isValid()) {
 419         line = UniqueChars(js_pod_malloc<char>(utf8Len.value()));
 420         if (line) {
 421           n = mozilla::ConvertUtf16toUtf8({linebuf, linebufLen},
 422                                           {line.get(), utf8Len.value()});
 423         }
 424       }
 425     }
 426
 427     const char* utf8buf;
 428     if (line) {
 429       utf8buf = line.get();
 430     } else {
 431       static const char unavailableStr[] = "<context unavailable>";
 432       utf8buf = unavailableStr;
 433       n = js_strlen(unavailableStr);
 434     }
 435
 436     fputs(":\n", file);
 437     if (prefix) {
 438       fputs(prefix, file);
 439     }
 440
 441     for (size_t i = 0; i < n; i++) {
 442       fputc(utf8buf[i], file);
 443     }
 444
 445     // linebuf/utf8buf usually ends with a newline. If not, add one here.
 446     if (n == 0 || utf8buf[n - 1] != '\n') {
 447       fputc('\n', file);
 448     }
 449
 450     if (prefix) {
 451       fputs(prefix, file);
 452     }
 453
 454     n = report->tokenOffset();
 455     for (size_t i = 0, j = 0; i < n; i++) {
 456       if (utf8buf[i] == '\t') {
 457         for (size_t k = (j + 8) & ~7; j < k; j++) {
 458           fputc('.', file);
 459         }
 460         continue;
 461       }
 462       fputc('.', file);
 463       j++;
 464     }
 465     fputc('^', file);
 466   }
 467 }
 468
 469 static void PrintErrorLine(FILE* file, const char* prefix,
 470                            JSErrorNotes::Note* note) {}
 471
 472 template <typename T>
 473 static void PrintSingleError(FILE* file, JS::ConstUTF8CharsZ toStringResult,
 474                              T* report, PrintErrorKind kind) {
 475   UniqueChars prefix;
 476   if (report->filename) {
 477     prefix = JS_smprintf("%s:", report->filename.c_str());
 478   }
 479
 480   if (report->lineno) {
 481     prefix = JS_smprintf("%s%u:%u ", prefix ? prefix.get() : "", report->lineno,
 482                          report->column.oneOriginValue());
 483   }
 484
 485   if (kind != PrintErrorKind::Error) {
 486     const char* kindPrefix = nullptr;
 487     switch (kind) {
 488       case PrintErrorKind::Error:
 489         MOZ_CRASH("unreachable");
 490       case PrintErrorKind::Warning:
 491         kindPrefix = "warning";
 492         break;
 493       case PrintErrorKind::Note:
 494         kindPrefix = "note";
 495         break;
 496     }
 497
 498     prefix = JS_smprintf("%s%s: ", prefix ? prefix.get() : "", kindPrefix);
 499   }
 500
 501   const char* message =
 502       toStringResult ? toStringResult.c_str() : report->message().c_str();
 503
 504   /* embedded newlines -- argh! */
 505   const char* ctmp;
 506   while ((ctmp = strchr(message, '\n')) != 0) {
 507     ctmp++;
 508     if (prefix) {
 509       fputs(prefix.get(), file);
 510     }
 511     (void)fwrite(message, 1, ctmp - message, file);
 512     message = ctmp;
 513   }
 514
 515   /* If there were no filename or lineno, the prefix might be empty */
 516   if (prefix) {
 517     fputs(prefix.get(), file);
 518   }
 519   fputs(message, file);
 520
 521   PrintErrorLine(file, prefix.get(), report);
 522   fputc('\n', file);
 523
 524   fflush(file);
 525 }
 526
 527 static void PrintErrorImpl(FILE* file, JS::ConstUTF8CharsZ toStringResult,
 528                            JSErrorReport* report, bool reportWarnings) {
 529   MOZ_ASSERT(report);
 530
 531   /* Conditionally ignore reported warnings. */
 532   if (report->isWarning() && !reportWarnings) {
 533     return;
 534   }
 535
 536   PrintErrorKind kind = PrintErrorKind::Error;
 537   if (report->isWarning()) {
 538     kind = PrintErrorKind::Warning;
 539   }
 540   PrintSingleError(file, toStringResult, report, kind);
 541
 542   if (report->notes) {
 543     for (auto&& note : *report->notes) {
 544       PrintSingleError(file, JS::ConstUTF8CharsZ(), note.get(),
 545                        PrintErrorKind::Note);
 546     }
 547   }
 548 }
 549
 550 JS_PUBLIC_API void JS::PrintError(FILE* file, JSErrorReport* report,
 551                                   bool reportWarnings) {
 552   PrintErrorImpl(file, JS::ConstUTF8CharsZ(), report, reportWarnings);
 553 }
 554
 555 JS_PUBLIC_API void JS::PrintError(FILE* file,
 556                                   const JS::ErrorReportBuilder& builder,
 557                                   bool reportWarnings) {
 558   PrintErrorImpl(file, builder.toStringResult(), builder.report(),
 559                  reportWarnings);
 560 }
 561
 562 void js::ReportIsNotDefined(JSContext* cx, HandleId id) {
 563   if (UniqueChars printable =
 564           IdToPrintableUTF8(cx, id, IdToPrintableBehavior::IdIsIdentifier)) {
 565     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_NOT_DEFINED,
 566                              printable.get());
 567   }
 568 }
 569
 570 void js::ReportIsNotDefined(JSContext* cx, Handle<PropertyName*> name) {
 571   RootedId id(cx, NameToId(name));
 572   ReportIsNotDefined(cx, id);
 573 }
 574
 575 const char* NullOrUndefinedToCharZ(HandleValue v) {
 576   MOZ_ASSERT(v.isNullOrUndefined());
 577   return v.isNull() ? "null" : "undefined";
 578 }
 579
 580 void js::ReportIsNullOrUndefinedForPropertyAccess(JSContext* cx, HandleValue v,
 581                                                   int vIndex) {
 582   MOZ_ASSERT(v.isNullOrUndefined());
 583
 584   if (vIndex == JSDVG_IGNORE_STACK) {
 585     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
 586                               JSMSG_CANT_CONVERT_TO, NullOrUndefinedToCharZ(v),
 587                               "object");
 588     return;
 589   }
 590
 591   UniqueChars bytes = DecompileValueGenerator(cx, vIndex, v, nullptr);
 592   if (!bytes) {
 593     return;
 594   }
 595
 596   if (strcmp(bytes.get(), "undefined") == 0 ||
 597       strcmp(bytes.get(), "null") == 0) {
 598     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_NO_PROPERTIES,
 599                              bytes.get());
 600   } else {
 601     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
 602                              JSMSG_UNEXPECTED_TYPE, bytes.get(),
 603                              NullOrUndefinedToCharZ(v));
 604   }
 605 }
 606
 607 void js::ReportIsNullOrUndefinedForPropertyAccess(JSContext* cx, HandleValue v,
 608                                                   int vIndex, HandleId key) {
 609   MOZ_ASSERT(v.isNullOrUndefined());
 610
 611   if (!cx->realm()->creationOptions().getPropertyErrorMessageFixEnabled()) {
 612     ReportIsNullOrUndefinedForPropertyAccess(cx, v, vIndex);
 613     return;
 614   }
 615
 616   RootedValue idVal(cx, IdToValue(key));
 617   RootedString idStr(cx, ValueToSource(cx, idVal));
 618   if (!idStr) {
 619     return;
 620   }
 621
 622   UniqueChars keyStr = StringToNewUTF8CharsZ(cx, *idStr);
 623   if (!keyStr) {
 624     return;
 625   }
 626
 627   if (vIndex == JSDVG_IGNORE_STACK) {
 628     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_PROPERTY_FAIL,
 629                              keyStr.get(), NullOrUndefinedToCharZ(v));
 630     return;
 631   }
 632
 633   UniqueChars bytes = DecompileValueGenerator(cx, vIndex, v, nullptr);
 634   if (!bytes) {
 635     return;
 636   }
 637
 638   if (strcmp(bytes.get(), "undefined") == 0 ||
 639       strcmp(bytes.get(), "null") == 0) {
 640     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_PROPERTY_FAIL,
 641                              keyStr.get(), bytes.get());
 642     return;
 643   }
 644
 645   JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
 646                            JSMSG_PROPERTY_FAIL_EXPR, keyStr.get(), bytes.get(),
 647                            NullOrUndefinedToCharZ(v));
 648 }
 649
 650 bool js::ReportValueError(JSContext* cx, const unsigned errorNumber,
 651                           int spindex, HandleValue v, HandleString fallback,
 652                           const char* arg1, const char* arg2) {
 653   MOZ_ASSERT(js_ErrorFormatString[errorNumber].argCount >= 1);
 654   MOZ_ASSERT(js_ErrorFormatString[errorNumber].argCount <= 3);
 655   UniqueChars bytes = DecompileValueGenerator(cx, spindex, v, fallback);
 656   if (!bytes) {
 657     return false;
 658   }
 659
 660   JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, errorNumber,
 661                            bytes.get(), arg1, arg2);
 662   return false;
 663 }
 664
 665 JSObject* js::CreateErrorNotesArray(JSContext* cx, JSErrorReport* report) {
 666   Rooted<ArrayObject*> notesArray(cx, NewDenseEmptyArray(cx));
 667   if (!notesArray) {
 668     return nullptr;
 669   }
 670
 671   if (!report->notes) {
 672     return notesArray;
 673   }
 674
 675   for (auto&& note : *report->notes) {
 676     Rooted<PlainObject*> noteObj(cx, NewPlainObject(cx));
 677     if (!noteObj) {
 678       return nullptr;
 679     }
 680
 681     RootedString messageStr(cx, note->newMessageString(cx));
 682     if (!messageStr) {
 683       return nullptr;
 684     }
 685     RootedValue messageVal(cx, StringValue(messageStr));
 686     if (!DefineDataProperty(cx, noteObj, cx->names().message, messageVal)) {
 687       return nullptr;
 688     }
 689
 690     RootedValue filenameVal(cx);
 691     if (const char* filename = note->filename.c_str()) {
 692       JS::UTF8Chars utf8chars(filename, strlen(filename));
 693       Rooted<JSString*> filenameStr(cx, NewStringCopyUTF8N(cx, utf8chars));
 694       if (!filenameStr) {
 695         return nullptr;
 696       }
 697       filenameVal = StringValue(filenameStr);
 698     }
 699     if (!DefineDataProperty(cx, noteObj, cx->names().fileName, filenameVal)) {
 700       return nullptr;
 701     }
 702
 703     RootedValue linenoVal(cx, Int32Value(note->lineno));
 704     if (!DefineDataProperty(cx, noteObj, cx->names().lineNumber, linenoVal)) {
 705       return nullptr;
 706     }
 707     RootedValue columnVal(cx, Int32Value(note->column.oneOriginValue()));
 708     if (!DefineDataProperty(cx, noteObj, cx->names().columnNumber, columnVal)) {
 709       return nullptr;
 710     }
 711
 712     if (!NewbornArrayPush(cx, notesArray, ObjectValue(*noteObj))) {
 713       return nullptr;
 714     }
 715   }
 716
 717   return notesArray;
 718 }
 719
 720 void JSContext::recoverFromOutOfMemory() {
 721   if (isExceptionPending()) {
 722     MOZ_ASSERT(isThrowingOutOfMemory());
 723     clearPendingException();
 724   }
 725 }
 726
 727 void JSContext::reportAllocationOverflow() {
 728   gc::AutoSuppressGC suppressGC(this);
 729   JS_ReportErrorNumberASCII(this, GetErrorMessage, nullptr,
 730                             JSMSG_ALLOC_OVERFLOW);
 731 }
 732
 733 JS::StackKind JSContext::stackKindForCurrentPrincipal() {
 734   return runningWithTrustedPrincipals() ? JS::StackForTrustedScript
 735                                         : JS::StackForUntrustedScript;
 736 }
 737
 738 JS::NativeStackLimit JSContext::stackLimitForCurrentPrincipal() {
 739   return stackLimit(stackKindForCurrentPrincipal());
 740 }
 741
 742 JS_PUBLIC_API bool js::UseInternalJobQueues(JSContext* cx) {
 743   // Internal job queue handling must be set up very early. Self-hosting
 744   // initialization is as good a marker for that as any.
 745   MOZ_RELEASE_ASSERT(
 746       !cx->runtime()->hasInitializedSelfHosting(),
 747       "js::UseInternalJobQueues must be called early during runtime startup.");
 748   MOZ_ASSERT(!cx->jobQueue);
 749   auto queue = MakeUnique<InternalJobQueue>(cx);
 750   if (!queue) {
 751     return false;
 752   }
 753
 754   cx->internalJobQueue = std::move(queue);
 755   cx->jobQueue = cx->internalJobQueue.ref().get();
 756
 757   cx->runtime()->offThreadPromiseState.ref().initInternalDispatchQueue();
 758   MOZ_ASSERT(cx->runtime()->offThreadPromiseState.ref().initialized());
 759
 760   return true;
 761 }
 762
 763 #ifdef DEBUG
 764 JSObject* InternalJobQueue::copyJobs(JSContext* cx) {
 765   Rooted<ArrayObject*> jobs(cx, NewDenseEmptyArray(cx));
 766   if (!jobs) {
 767     return nullptr;
 768   }
 769
 770   for (const JSObject* unwrappedJob : queue.get()) {
 771     RootedObject job(cx, const_cast<JSObject*>(unwrappedJob));
 772     if (!cx->compartment()->wrap(cx, &job)) {
 773       return nullptr;
 774     }
 775
 776     if (!NewbornArrayPush(cx, jobs, ObjectValue(*job))) {
 777       return nullptr;
 778     }
 779   }
 780
 781   return jobs;
 782 }
 783
 784 JS_PUBLIC_API JSObject* js::GetJobsInInternalJobQueue(JSContext* cx) {
 785   MOZ_ASSERT(cx->internalJobQueue.ref());
 786   return cx->internalJobQueue->copyJobs(cx);
 787 }
 788 #endif
 789
 790 JS_PUBLIC_API bool js::EnqueueJob(JSContext* cx, JS::HandleObject job) {
 791   MOZ_ASSERT(cx->jobQueue);
 792   return cx->jobQueue->enqueuePromiseJob(cx, nullptr, job, nullptr, nullptr);
 793 }
 794
 795 JS_PUBLIC_API void js::StopDrainingJobQueue(JSContext* cx) {
 796   MOZ_ASSERT(cx->internalJobQueue.ref());
 797   cx->internalJobQueue->interrupt();
 798 }
 799
 800 JS_PUBLIC_API void js::RunJobs(JSContext* cx) {
 801   MOZ_ASSERT(cx->jobQueue);
 802   cx->jobQueue->runJobs(cx);
 803   JS::ClearKeptObjects(cx);
 804 }
 805
 806 JSObject* InternalJobQueue::getIncumbentGlobal(JSContext* cx) {
 807   if (!cx->compartment()) {
 808     return nullptr;
 809   }
 810   return cx->global();
 811 }
 812
 813 bool InternalJobQueue::enqueuePromiseJob(JSContext* cx,
 814                                          JS::HandleObject promise,
 815                                          JS::HandleObject job,
 816                                          JS::HandleObject allocationSite,
 817                                          JS::HandleObject incumbentGlobal) {
 818   MOZ_ASSERT(job);
 819   if (!queue.pushBack(job)) {
 820     ReportOutOfMemory(cx);
 821     return false;
 822   }
 823
 824   JS::JobQueueMayNotBeEmpty(cx);
 825   return true;
 826 }
 827
 828 void InternalJobQueue::runJobs(JSContext* cx) {
 829   if (draining_ || interrupted_) {
 830     return;
 831   }
 832
 833   while (true) {
 834     cx->runtime()->offThreadPromiseState.ref().internalDrain(cx);
 835
 836     // It doesn't make sense for job queue draining to be reentrant. At the
 837     // same time we don't want to assert against it, because that'd make
 838     // drainJobQueue unsafe for fuzzers. We do want fuzzers to test this,
 839     // so we simply ignore nested calls of drainJobQueue.
 840     draining_ = true;
 841
 842     RootedObject job(cx);
 843     JS::HandleValueArray args(JS::HandleValueArray::empty());
 844     RootedValue rval(cx);
 845
 846     // Execute jobs in a loop until we've reached the end of the queue.
 847     while (!queue.empty()) {
 848       // A previous job might have set this flag. E.g., the js shell
 849       // sets it if the `quit` builtin function is called.
 850       if (interrupted_) {
 851         break;
 852       }
 853
 854       job = queue.front();
 855       queue.popFront();
 856
 857       // If the next job is the last job in the job queue, allow
 858       // skipping the standard job queuing behavior.
 859       if (queue.empty()) {
 860         JS::JobQueueIsEmpty(cx);
 861       }
 862
 863       AutoRealm ar(cx, &job->as<JSFunction>());
 864       {
 865         if (!JS::Call(cx, UndefinedHandleValue, job, args, &rval)) {
 866           // Nothing we can do about uncatchable exceptions.
 867           if (!cx->isExceptionPending()) {
 868             continue;
 869           }
 870           RootedValue exn(cx);
 871           if (cx->getPendingException(&exn)) {
 872             /*
 873              * Clear the exception, because
 874              * PrepareScriptEnvironmentAndInvoke will assert that we don't
 875              * have one.
 876              */
 877             cx->clearPendingException();
 878             js::ReportExceptionClosure reportExn(exn);
 879             PrepareScriptEnvironmentAndInvoke(cx, cx->global(), reportExn);
 880           }
 881         }
 882       }
 883     }
 884
 885     draining_ = false;
 886
 887     if (interrupted_) {
 888       interrupted_ = false;
 889       break;
 890     }
 891
 892     queue.clear();
 893
 894     // It's possible a job added a new off-thread promise task.
 895     if (!cx->runtime()->offThreadPromiseState.ref().internalHasPending()) {
 896       break;
 897     }
 898   }
 899 }
 900
 901 bool InternalJobQueue::empty() const { return queue.empty(); }
 902
 903 JSObject* InternalJobQueue::maybeFront() const {
 904   if (queue.empty()) {
 905     return nullptr;
 906   }
 907
 908   return queue.get().front();
 909 }
 910
 911 class js::InternalJobQueue::SavedQueue : public JobQueue::SavedJobQueue {
 912  public:
 913   SavedQueue(JSContext* cx, Queue&& saved, bool draining)
 914       : cx(cx), saved(cx, std::move(saved)), draining_(draining) {
 915     MOZ_ASSERT(cx->internalJobQueue.ref());
 916   }
 917
 918   ~SavedQueue() {
 919     MOZ_ASSERT(cx->internalJobQueue.ref());
 920     cx->internalJobQueue->queue = std::move(saved.get());
 921     cx->internalJobQueue->draining_ = draining_;
 922   }
 923
 924  private:
 925   JSContext* cx;
 926   PersistentRooted<Queue> saved;
 927   bool draining_;
 928 };
 929
 930 js::UniquePtr<JS::JobQueue::SavedJobQueue> InternalJobQueue::saveJobQueue(
 931     JSContext* cx) {
 932   auto saved =
 933       js::MakeUnique<SavedQueue>(cx, std::move(queue.get()), draining_);
 934   if (!saved) {
 935     // When MakeUnique's allocation fails, the SavedQueue constructor is never
 936     // called, so this->queue is still initialized. (The move doesn't occur
 937     // until the constructor gets called.)
 938     ReportOutOfMemory(cx);
 939     return nullptr;
 940   }
 941
 942   queue = Queue(SystemAllocPolicy());
 943   draining_ = false;
 944   return saved;
 945 }
 946
 947 mozilla::GenericErrorResult<OOM> JSContext::alreadyReportedOOM() {
 948   MOZ_ASSERT(isThrowingOutOfMemory());
 949   return mozilla::Err(JS::OOM());
 950 }
 951
 952 mozilla::GenericErrorResult<JS::Error> JSContext::alreadyReportedError() {
 953   return mozilla::Err(JS::Error());
 954 }
 955
 956 JSContext::JSContext(JSRuntime* runtime, const JS::ContextOptions& options)
 957     : RootingContext(runtime ? &runtime->gc.nursery() : nullptr),
 958       runtime_(runtime),
 959       options_(this, options),
 960       measuringExecutionTime_(this, false),
 961       jitActivation(this, nullptr),
 962       isolate(this, nullptr),
 963       activation_(this, nullptr),
 964       profilingActivation_(nullptr),
 965       entryMonitor(this, nullptr),
 966       noExecuteDebuggerTop(this, nullptr),
 967 #ifdef DEBUG
 968       inUnsafeCallWithABI(this, false),
 969       hasAutoUnsafeCallWithABI(this, false),
 970 #endif
 971 #ifdef JS_SIMULATOR
 972       simulator_(this, nullptr),
 973 #endif
 974       dtoaState(this, nullptr),
 975       suppressGC(this, 0),
 976 #ifdef FUZZING_JS_FUZZILLI
 977       executionHash(1),
 978       executionHashInputs(0),
 979 #endif
 980 #ifdef DEBUG
 981       noNurseryAllocationCheck(this, 0),
 982       disableStrictProxyCheckingCount(this, 0),
 983 #endif
 984 #if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
 985       runningOOMTest(this, false),
 986 #endif
 987       inUnsafeRegion(this, 0),
 988       generationalDisabled(this, 0),
 989       compactingDisabledCount(this, 0),
 990 #ifdef DEBUG
 991       regExpSearcherLastLimit(this, RegExpSearcherLastLimitSentinel),
 992 #else
 993       regExpSearcherLastLimit(this, 0),
 994 #endif
 995       frontendCollectionPool_(this),
 996       suppressProfilerSampling(false),
 997       tempLifoAlloc_(this, (size_t)TEMP_LIFO_ALLOC_PRIMARY_CHUNK_SIZE),
 998       debuggerMutations(this, 0),
 999       ionPcScriptCache(this, nullptr),
1000       status(this, JS::ExceptionStatus::None),
1001       unwrappedException_(this),
1002       unwrappedExceptionStack_(this),
1003 #ifdef DEBUG
1004       hadResourceExhaustion_(this, false),
1005 #endif
1006       reportGranularity(this, JS_DEFAULT_JITREPORT_GRANULARITY),
1007       resolvingList(this, nullptr),
1008 #ifdef DEBUG
1009       enteredPolicy(this, nullptr),
1010 #endif
1011       generatingError(this, false),
1012       cycleDetectorVector_(this, this),
1013       data(nullptr),
1014       asyncStackForNewActivations_(this),
1015       asyncCauseForNewActivations(this, nullptr),
1016       asyncCallIsExplicit(this, false),
1017       interruptCallbacks_(this),
1018       interruptCallbackDisabled(this, false),
1019       interruptBits_(0),
1020       inlinedICScript_(this, nullptr),
1021       jitStackLimit(JS::NativeStackLimitMin),
1022       jitStackLimitNoInterrupt(this, JS::NativeStackLimitMin),
1023       jobQueue(this, nullptr),
1024       internalJobQueue(this),
1025       canSkipEnqueuingJobs(this, false),
1026       promiseRejectionTrackerCallback(this, nullptr),
1027       promiseRejectionTrackerCallbackData(this, nullptr),
1028       insideDebuggerEvaluationWithOnNativeCallHook(this, nullptr) {
1029   MOZ_ASSERT(static_cast<JS::RootingContext*>(this) ==
1030              JS::RootingContext::get(this));
1031 }
1032
1033 JSContext::~JSContext() {
1034 #ifdef DEBUG
1035   // Clear the initialized_ first, so that ProtectedData checks will allow us to
1036   // destroy this context even if the runtime is already gone.
1037   initialized_ = false;
1038 #endif
1039
1040   /* Free the stuff hanging off of cx. */
1041   MOZ_ASSERT(!resolvingList);
1042
1043   if (dtoaState) {
1044     DestroyDtoaState(dtoaState);
1045   }
1046
1047   fx.destroyInstance();
1048
1049 #ifdef JS_SIMULATOR
1050   js::jit::Simulator::Destroy(simulator_);
1051 #endif
1052
1053   if (isolate) {
1054     irregexp::DestroyIsolate(isolate.ref());
1055   }
1056
1057   TlsContext.set(nullptr);
1058 }
1059
1060 void JSContext::setRuntime(JSRuntime* rt) {
1061   MOZ_ASSERT(!resolvingList);
1062   MOZ_ASSERT(!compartment());
1063   MOZ_ASSERT(!activation());
1064   MOZ_ASSERT(!unwrappedException_.ref().initialized());
1065   MOZ_ASSERT(!unwrappedExceptionStack_.ref().initialized());
1066   MOZ_ASSERT(!asyncStackForNewActivations_.ref().initialized());
1067
1068   runtime_ = rt;
1069 }
1070
1071 #if defined(NIGHTLY_BUILD)
1072 static bool IsOutOfMemoryException(JSContext* cx, const Value& v) {
1073   return v == StringValue(cx->names().out_of_memory_);
1074 }
1075 #endif
1076
1077 void JSContext::setPendingException(HandleValue v, Handle<SavedFrame*> stack) {
1078 #if defined(NIGHTLY_BUILD)
1079   do {
1080     // Do not intercept exceptions if we are already
1081     // in the exception interceptor. That would lead
1082     // to infinite recursion.
1083     if (this->runtime()->errorInterception.isExecuting) {
1084       break;
1085     }
1086
1087     // Check whether we have an interceptor at all.
1088     if (!this->runtime()->errorInterception.interceptor) {
1089       break;
1090     }
1091
1092     // Don't report OOM exceptions. The interceptor isn't interested in those
1093     // and they can confuse the interceptor because OOM can be thrown when we
1094     // are not in a realm (atom allocation, for example).
1095     if (IsOutOfMemoryException(this, v)) {
1096       break;
1097     }
1098
1099     // Make sure that we do not call the interceptor from within
1100     // the interceptor.
1101     this->runtime()->errorInterception.isExecuting = true;
1102
1103     // The interceptor must be infallible.
1104     const mozilla::DebugOnly<bool> wasExceptionPending =
1105         this->isExceptionPending();
1106     this->runtime()->errorInterception.interceptor->interceptError(this, v);
1107     MOZ_ASSERT(wasExceptionPending == this->isExceptionPending());
1108
1109     this->runtime()->errorInterception.isExecuting = false;
1110   } while (false);
1111 #endif  // defined(NIGHTLY_BUILD)
1112
1113   // overRecursed_ is set after the fact by ReportOverRecursed.
1114   this->status = JS::ExceptionStatus::Throwing;
1115   this->unwrappedException() = v;
1116   this->unwrappedExceptionStack() = stack;
1117 }
1118
1119 void JSContext::setPendingException(HandleValue value,
1120                                     ShouldCaptureStack captureStack) {
1121   Rooted<SavedFrame*> nstack(this);
1122   if (captureStack == ShouldCaptureStack::Always ||
1123       realm()->shouldCaptureStackForThrow()) {
1124     RootedObject stack(this);
1125     if (!CaptureStack(this, &stack)) {
1126       clearPendingException();
1127     }
1128     if (stack) {
1129       nstack = &stack->as<SavedFrame>();
1130     }
1131   }
1132   setPendingException(value, nstack);
1133 }
1134
1135 bool JSContext::getPendingException(MutableHandleValue rval) {
1136   MOZ_ASSERT(isExceptionPending());
1137
1138   RootedValue exception(this, unwrappedException());
1139   if (zone()->isAtomsZone()) {
1140     rval.set(exception);
1141     return true;
1142   }
1143
1144   Rooted<SavedFrame*> stack(this, unwrappedExceptionStack());
1145   JS::ExceptionStatus prevStatus = status;
1146   clearPendingException();
1147   if (!compartment()->wrap(this, &exception)) {
1148     return false;
1149   }
1150   this->check(exception);
1151   setPendingException(exception, stack);
1152   status = prevStatus;
1153
1154   rval.set(exception);
1155   return true;
1156 }
1157
1158 SavedFrame* JSContext::getPendingExceptionStack() {
1159   return unwrappedExceptionStack();
1160 }
1161
1162 bool JSContext::isClosingGenerator() {
1163   return isExceptionPending() &&
1164          unwrappedException().isMagic(JS_GENERATOR_CLOSING);
1165 }
1166
1167 bool JSContext::isThrowingDebuggeeWouldRun() {
1168   return isExceptionPending() && unwrappedException().isObject() &&
1169          unwrappedException().toObject().is<ErrorObject>() &&
1170          unwrappedException().toObject().as<ErrorObject>().type() ==
1171              JSEXN_DEBUGGEEWOULDRUN;
1172 }
1173
1174 bool JSContext::isRuntimeCodeGenEnabled(JS::RuntimeCode kind,
1175                                         HandleString code) {
1176   // Make sure that the CSP callback is installed and that it permits runtime
1177   // code generation.
1178   if (JSCSPEvalChecker allows =
1179           runtime()->securityCallbacks->contentSecurityPolicyAllows) {
1180     return allows(this, kind, code);
1181   }
1182
1183   return true;
1184 }
1185
1186 size_t JSContext::sizeOfExcludingThis(
1187     mozilla::MallocSizeOf mallocSizeOf) const {
1188   /*
1189    * There are other JSContext members that could be measured; the following
1190    * ones have been found by DMD to be worth measuring.  More stuff may be
1191    * added later.
1192    */
1193   return cycleDetectorVector().sizeOfExcludingThis(mallocSizeOf) +
1194          irregexp::IsolateSizeOfIncludingThis(isolate, mallocSizeOf);
1195 }
1196
1197 size_t JSContext::sizeOfIncludingThis(
1198     mozilla::MallocSizeOf mallocSizeOf) const {
1199   return mallocSizeOf(this) + sizeOfExcludingThis(mallocSizeOf);
1200 }
1201
1202 #ifdef DEBUG
1203 bool JSContext::inAtomsZone() const { return zone_->isAtomsZone(); }
1204 #endif
1205
1206 void JSContext::trace(JSTracer* trc) {
1207   cycleDetectorVector().trace(trc);
1208   geckoProfiler().trace(trc);
1209   if (isolate) {
1210     irregexp::TraceIsolate(trc, isolate.ref());
1211   }
1212 }
1213
1214 JS::NativeStackLimit JSContext::stackLimitForJitCode(JS::StackKind kind) {
1215 #ifdef JS_SIMULATOR
1216   return simulator()->stackLimit();
1217 #else
1218   return stackLimit(kind);
1219 #endif
1220 }
1221
1222 void JSContext::resetJitStackLimit() {
1223   // Note that, for now, we use the untrusted limit for ion. This is fine,
1224   // because it's the most conservative limit, and if we hit it, we'll bail
1225   // out of ion into the interpreter, which will do a proper recursion check.
1226 #ifdef JS_SIMULATOR
1227   jitStackLimit = jit::Simulator::StackLimit();
1228 #else
1229   jitStackLimit = nativeStackLimit[JS::StackForUntrustedScript];
1230 #endif
1231   jitStackLimitNoInterrupt = jitStackLimit;
1232 }
1233
1234 void JSContext::initJitStackLimit() { resetJitStackLimit(); }
1235
1236 #ifdef JS_CRASH_DIAGNOSTICS
1237 void ContextChecks::check(AbstractFramePtr frame, int argIndex) {
1238   if (frame) {
1239     check(frame.realm(), argIndex);
1240   }
1241 }
1242 #endif
1243
1244 void AutoEnterOOMUnsafeRegion::crash_impl(const char* reason) {
1245   char msgbuf[1024];
1246   js::NoteIntentionalCrash();
1247   SprintfLiteral(msgbuf, "[unhandlable oom] %s", reason);
1248 #ifndef DEBUG
1249   // In non-DEBUG builds MOZ_CRASH normally doesn't print to stderr so we have
1250   // to do this explicitly (the jit-test allow-unhandlable-oom annotation and
1251   // fuzzers depend on it).
1252   fprintf(stderr, "Hit MOZ_CRASH(%s) at %s:%d\n", msgbuf, __FILE__, __LINE__);
1253 #endif
1254   MOZ_CRASH_UNSAFE(msgbuf);
1255 }
1256
1257 mozilla::Atomic<AutoEnterOOMUnsafeRegion::AnnotateOOMAllocationSizeCallback,
1258                 mozilla::Relaxed>
1259     AutoEnterOOMUnsafeRegion::annotateOOMSizeCallback(nullptr);
1260
1261 void AutoEnterOOMUnsafeRegion::crash_impl(size_t size, const char* reason) {
1262   {
1263     JS::AutoSuppressGCAnalysis suppress;
1264     if (annotateOOMSizeCallback) {
1265       annotateOOMSizeCallback(size);
1266     }
1267   }
1268   crash_impl(reason);
1269 }
1270
1271 void ExternalValueArray::trace(JSTracer* trc) {
1272   if (Value* vp = begin()) {
1273     TraceRootRange(trc, length(), vp, "js::ExternalValueArray");
1274   }
1275 }
1276
1277 #ifdef DEBUG
1278 AutoUnsafeCallWithABI::AutoUnsafeCallWithABI(UnsafeABIStrictness strictness)
1279     : cx_(TlsContext.get()),
1280       nested_(cx_ ? cx_->hasAutoUnsafeCallWithABI : false),
1281       nogc(cx_) {
1282   if (!cx_) {
1283     // This is a helper thread doing Ion or Wasm compilation - nothing to do.
1284     return;
1285   }
1286   switch (strictness) {
1287     case UnsafeABIStrictness::NoExceptions:
1288       MOZ_ASSERT(!JS_IsExceptionPending(cx_));
1289       checkForPendingException_ = true;
1290       break;
1291     case UnsafeABIStrictness::AllowPendingExceptions:
1292       checkForPendingException_ = !JS_IsExceptionPending(cx_);
1293       break;
1294     case UnsafeABIStrictness::AllowThrownExceptions:
1295       checkForPendingException_ = false;
1296       break;
1297   }
1298
1299   cx_->hasAutoUnsafeCallWithABI = true;
1300 }
1301
1302 AutoUnsafeCallWithABI::~AutoUnsafeCallWithABI() {
1303   if (!cx_) {
1304     return;
1305   }
1306   MOZ_ASSERT(cx_->hasAutoUnsafeCallWithABI);
1307   if (!nested_) {
1308     cx_->hasAutoUnsafeCallWithABI = false;
1309     cx_->inUnsafeCallWithABI = false;
1310   }
1311   MOZ_ASSERT_IF(checkForPendingException_, !JS_IsExceptionPending(cx_));
1312 }
1313 #endif
1314
1315 #ifdef __wasi__
1316 JS_PUBLIC_API void js::IncWasiRecursionDepth(JSContext* cx) {
1317   ++JS::RootingContext::get(cx)->wasiRecursionDepth;
1318 }
1319
1320 JS_PUBLIC_API void js::DecWasiRecursionDepth(JSContext* cx) {
1321   MOZ_ASSERT(JS::RootingContext::get(cx)->wasiRecursionDepth > 0);
1322   --JS::RootingContext::get(cx)->wasiRecursionDepth;
1323 }
1324
1325 JS_PUBLIC_API bool js::CheckWasiRecursionLimit(JSContext* cx) {
1326   // WASI has two limits:
1327   // 1) The stack pointer in linear memory that grows to zero. See
1328   //    --stack-first in js/src/shell/moz.build.
1329   // 2) The JS::RootingContext::wasiRecursionDepth that counts recursion depth.
1330   //    Here we should check both.
1331   if (JS::RootingContext::get(cx)->wasiRecursionDepth >=
1332       JS::RootingContext::wasiRecursionDepthLimit) {
1333     return false;
1334   }
1335   return true;
1336 }
1337 #endif  // __wasi__