js/src/jsexn.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 standard exception implementation.
   9  */
  10
  11 #include "jsexn.h"
  12
  13 #include "mozilla/Assertions.h"
  14 #include "mozilla/Maybe.h"
  15 #include "mozilla/ScopeExit.h"
  16
  17 #include <new>
  18 #include <stdarg.h>
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <utility>
  23
  24 #include "jsapi.h"
  25 #include "jsfriendapi.h"
  26 #include "jstypes.h"
  27
  28 #include "frontend/FrontendContext.h"  // AutoReportFrontendContext
  29 #include "js/CharacterEncoding.h"
  30 #include "js/Class.h"
  31 #include "js/Conversions.h"
  32 #include "js/ErrorReport.h"             // JS::PrintError
  33 #include "js/Exception.h"               // JS::ExceptionStack
  34 #include "js/experimental/TypedData.h"  // JS_IsArrayBufferViewObject
  35 #include "js/friend/ErrorMessages.h"  // JSErrNum, js::GetErrorMessage, JSMSG_*
  36 #include "js/Object.h"                // JS::GetBuiltinClass
  37 #include "js/PropertyAndElement.h"    // JS_GetProperty, JS_HasProperty
  38 #include "js/SavedFrameAPI.h"
  39 #include "js/Stack.h"
  40 #include "js/UniquePtr.h"
  41 #include "js/Value.h"
  42 #include "js/Warnings.h"  // JS::{,Set}WarningReporter
  43 #include "js/Wrapper.h"
  44 #include "util/Memory.h"
  45 #include "util/StringBuffer.h"
  46 #include "vm/Compartment.h"
  47 #include "vm/ErrorObject.h"
  48 #include "vm/FrameIter.h"  // js::NonBuiltinFrameIter
  49 #include "vm/JSAtom.h"
  50 #include "vm/JSContext.h"
  51 #include "vm/JSObject.h"
  52 #include "vm/JSScript.h"
  53 #include "vm/Realm.h"
  54 #include "vm/SavedFrame.h"
  55 #include "vm/SavedStacks.h"
  56 #include "vm/SelfHosting.h"
  57 #include "vm/Stack.h"
  58 #include "vm/StringType.h"
  59 #include "vm/SymbolType.h"
  60 #include "vm/WellKnownAtom.h"  // js_*_str
  61 #include "wasm/WasmJS.h"       // WasmExceptionObject
  62
  63 #include "vm/Compartment-inl.h"
  64 #include "vm/ErrorObject-inl.h"
  65 #include "vm/JSContext-inl.h"
  66 #include "vm/JSObject-inl.h"
  67 #include "vm/ObjectOperations-inl.h"  // js::GetProperty
  68 #include "vm/SavedStacks-inl.h"
  69
  70 using namespace js;
  71
  72 using JS::SavedFrameSelfHosted;
  73
  74 size_t ExtraMallocSize(JSErrorReport* report) {
  75   if (report->linebuf()) {
  76     /*
  77      * Count with null terminator and alignment.
  78      * See CopyExtraData for the details about alignment.
  79      */
  80     return (report->linebufLength() + 1) * sizeof(char16_t) + 1;
  81   }
  82
  83   return 0;
  84 }
  85
  86 size_t ExtraMallocSize(JSErrorNotes::Note* note) { return 0; }
  87
  88 bool CopyExtraData(JSContext* cx, uint8_t** cursor, JSErrorReport* copy,
  89                    JSErrorReport* report) {
  90   if (report->linebuf()) {
  91     /*
  92      * Make sure cursor is properly aligned for char16_t for platforms
  93      * which need it and it's at the end of the buffer on exit.
  94      */
  95     size_t alignment_backlog = 0;
  96     if (size_t(*cursor) % 2) {
  97       (*cursor)++;
  98     } else {
  99       alignment_backlog = 1;
 100     }
 101
 102     size_t linebufSize = (report->linebufLength() + 1) * sizeof(char16_t);
 103     const char16_t* linebufCopy = (const char16_t*)(*cursor);
 104     js_memcpy(*cursor, report->linebuf(), linebufSize);
 105     *cursor += linebufSize + alignment_backlog;
 106     copy->initBorrowedLinebuf(linebufCopy, report->linebufLength(),
 107                               report->tokenOffset());
 108   }
 109
 110   /* Copy non-pointer members. */
 111   copy->isMuted = report->isMuted;
 112   copy->exnType = report->exnType;
 113   copy->isWarning_ = report->isWarning_;
 114
 115   /* Deep copy notes. */
 116   if (report->notes) {
 117     auto copiedNotes = report->notes->copy(cx);
 118     if (!copiedNotes) {
 119       return false;
 120     }
 121     copy->notes = std::move(copiedNotes);
 122   } else {
 123     copy->notes.reset(nullptr);
 124   }
 125
 126   return true;
 127 }
 128
 129 bool CopyExtraData(JSContext* cx, uint8_t** cursor, JSErrorNotes::Note* copy,
 130                    JSErrorNotes::Note* report) {
 131   return true;
 132 }
 133
 134 template <typename T>
 135 static UniquePtr<T> CopyErrorHelper(JSContext* cx, T* report) {
 136   /*
 137    * We use a single malloc block to make a deep copy of JSErrorReport or
 138    * JSErrorNotes::Note, except JSErrorNotes linked from JSErrorReport with
 139    * the following layout:
 140    *   JSErrorReport or JSErrorNotes::Note
 141    *   char array with characters for message_
 142    *   char array with characters for filename
 143    *   char16_t array with characters for linebuf (only for JSErrorReport)
 144    * Such layout together with the properties enforced by the following
 145    * asserts does not need any extra alignment padding.
 146    */
 147   static_assert(sizeof(T) % sizeof(const char*) == 0);
 148   static_assert(sizeof(const char*) % sizeof(char16_t) == 0);
 149
 150   size_t filenameSize = report->filename ? strlen(report->filename) + 1 : 0;
 151   size_t messageSize = 0;
 152   if (report->message()) {
 153     messageSize = strlen(report->message().c_str()) + 1;
 154   }
 155
 156   /*
 157    * The mallocSize can not overflow since it represents the sum of the
 158    * sizes of already allocated objects.
 159    */
 160   size_t mallocSize =
 161       sizeof(T) + messageSize + filenameSize + ExtraMallocSize(report);
 162   uint8_t* cursor = cx->pod_calloc<uint8_t>(mallocSize);
 163   if (!cursor) {
 164     return nullptr;
 165   }
 166
 167   UniquePtr<T> copy(new (cursor) T());
 168   cursor += sizeof(T);
 169
 170   if (report->message()) {
 171     copy->initBorrowedMessage((const char*)cursor);
 172     js_memcpy(cursor, report->message().c_str(), messageSize);
 173     cursor += messageSize;
 174   }
 175
 176   if (report->filename) {
 177     copy->filename = (const char*)cursor;
 178     js_memcpy(cursor, report->filename, filenameSize);
 179     cursor += filenameSize;
 180   }
 181
 182   if (!CopyExtraData(cx, &cursor, copy.get(), report)) {
 183     return nullptr;
 184   }
 185
 186   MOZ_ASSERT(cursor == (uint8_t*)copy.get() + mallocSize);
 187
 188   // errorMessageName should be static.
 189   copy->errorMessageName = report->errorMessageName;
 190
 191   /* Copy non-pointer members. */
 192   copy->sourceId = report->sourceId;
 193   copy->lineno = report->lineno;
 194   copy->column = report->column;
 195   copy->errorNumber = report->errorNumber;
 196
 197   return copy;
 198 }
 199
 200 UniquePtr<JSErrorNotes::Note> js::CopyErrorNote(JSContext* cx,
 201                                                 JSErrorNotes::Note* note) {
 202   return CopyErrorHelper(cx, note);
 203 }
 204
 205 UniquePtr<JSErrorReport> js::CopyErrorReport(JSContext* cx,
 206                                              JSErrorReport* report) {
 207   return CopyErrorHelper(cx, report);
 208 }
 209
 210 struct SuppressErrorsGuard {
 211   JSContext* cx;
 212   JS::WarningReporter prevReporter;
 213   JS::AutoSaveExceptionState prevState;
 214
 215   explicit SuppressErrorsGuard(JSContext* cx)
 216       : cx(cx),
 217         prevReporter(JS::SetWarningReporter(cx, nullptr)),
 218         prevState(cx) {}
 219
 220   ~SuppressErrorsGuard() { JS::SetWarningReporter(cx, prevReporter); }
 221 };
 222
 223 // Cut off the stack if it gets too deep (most commonly for infinite recursion
 224 // errors).
 225 static const size_t MAX_REPORTED_STACK_DEPTH = 1u << 7;
 226
 227 bool js::CaptureStack(JSContext* cx, MutableHandleObject stack) {
 228   return CaptureCurrentStack(
 229       cx, stack, JS::StackCapture(JS::MaxFrames(MAX_REPORTED_STACK_DEPTH)));
 230 }
 231
 232 JSString* js::ComputeStackString(JSContext* cx) {
 233   SuppressErrorsGuard seg(cx);
 234
 235   RootedObject stack(cx);
 236   if (!CaptureStack(cx, &stack)) {
 237     return nullptr;
 238   }
 239
 240   RootedString str(cx);
 241   if (!BuildStackString(cx, cx->realm()->principals(), stack, &str)) {
 242     return nullptr;
 243   }
 244
 245   return str.get();
 246 }
 247
 248 JSErrorReport* js::ErrorFromException(JSContext* cx, HandleObject objArg) {
 249   // It's ok to UncheckedUnwrap here, since all we do is get the
 250   // JSErrorReport, and consumers are careful with the information they get
 251   // from that anyway.  Anyone doing things that would expose anything in the
 252   // JSErrorReport to page script either does a security check on the
 253   // JSErrorReport's principal or also tries to do toString on our object and
 254   // will fail if they can't unwrap it.
 255   RootedObject obj(cx, UncheckedUnwrap(objArg));
 256   if (!obj->is<ErrorObject>()) {
 257     return nullptr;
 258   }
 259
 260   JSErrorReport* report = obj->as<ErrorObject>().getOrCreateErrorReport(cx);
 261   if (!report) {
 262     MOZ_ASSERT(cx->isThrowingOutOfMemory());
 263     cx->recoverFromOutOfMemory();
 264   }
 265
 266   return report;
 267 }
 268
 269 JS_PUBLIC_API JSObject* JS::ExceptionStackOrNull(HandleObject objArg) {
 270   ErrorObject* errorObject = objArg->maybeUnwrapIf<ErrorObject>();
 271   if (errorObject) {
 272     return errorObject->stack();
 273   }
 274
 275   WasmExceptionObject* wasmObject =
 276       objArg->maybeUnwrapIf<WasmExceptionObject>();
 277   if (wasmObject) {
 278     return wasmObject->stack();
 279   }
 280
 281   return nullptr;
 282 }
 283
 284 JS_PUBLIC_API JSLinearString* js::GetErrorTypeName(JSContext* cx,
 285                                                    int16_t exnType) {
 286   /*
 287    * JSEXN_INTERNALERR returns null to prevent that "InternalError: "
 288    * is prepended before "uncaught exception: "
 289    */
 290   if (exnType < 0 || exnType >= JSEXN_LIMIT || exnType == JSEXN_INTERNALERR ||
 291       exnType == JSEXN_WARN || exnType == JSEXN_NOTE) {
 292     return nullptr;
 293   }
 294   JSProtoKey key = GetExceptionProtoKey(JSExnType(exnType));
 295   return ClassName(key, cx);
 296 }
 297
 298 void js::ErrorToException(JSContext* cx, JSErrorReport* reportp,
 299                           JSErrorCallback callback, void* userRef) {
 300   MOZ_ASSERT(!reportp->isWarning());
 301
 302   // Find the exception index associated with this error.
 303   JSErrNum errorNumber = static_cast<JSErrNum>(reportp->errorNumber);
 304   if (!callback) {
 305     callback = GetErrorMessage;
 306   }
 307   const JSErrorFormatString* errorString = callback(userRef, errorNumber);
 308   JSExnType exnType =
 309       errorString ? static_cast<JSExnType>(errorString->exnType) : JSEXN_ERR;
 310   MOZ_ASSERT(exnType < JSEXN_ERROR_LIMIT);
 311
 312   // Prevent infinite recursion.
 313   if (cx->generatingError) {
 314     return;
 315   }
 316
 317   cx->generatingError = true;
 318   auto restore = mozilla::MakeScopeExit([cx] { cx->generatingError = false; });
 319
 320   // Create an exception object.
 321   RootedString messageStr(cx, reportp->newMessageString(cx));
 322   if (!messageStr) {
 323     return;
 324   }
 325
 326   RootedString fileName(cx, JS_NewStringCopyZ(cx, reportp->filename));
 327   if (!fileName) {
 328     return;
 329   }
 330
 331   uint32_t sourceId = reportp->sourceId;
 332   uint32_t lineNumber = reportp->lineno;
 333   uint32_t columnNumber = reportp->column;
 334
 335   // Error reports don't provide a |cause|, so we default to |Nothing| here.
 336   auto cause = JS::NothingHandleValue;
 337
 338   RootedObject stack(cx);
 339   if (!CaptureStack(cx, &stack)) {
 340     return;
 341   }
 342
 343   UniquePtr<JSErrorReport> report = CopyErrorReport(cx, reportp);
 344   if (!report) {
 345     return;
 346   }
 347
 348   ErrorObject* errObject =
 349       ErrorObject::create(cx, exnType, stack, fileName, sourceId, lineNumber,
 350                           columnNumber, std::move(report), messageStr, cause);
 351   if (!errObject) {
 352     return;
 353   }
 354
 355   // Throw it.
 356   RootedValue errValue(cx, ObjectValue(*errObject));
 357   Rooted<SavedFrame*> nstack(cx);
 358   if (stack) {
 359     nstack = &stack->as<SavedFrame>();
 360   }
 361   cx->setPendingException(errValue, nstack);
 362 }
 363
 364 using SniffingBehavior = JS::ErrorReportBuilder::SniffingBehavior;
 365
 366 static bool IsDuckTypedErrorObject(JSContext* cx, HandleObject exnObject,
 367                                    const char** filename_strp) {
 368   /*
 369    * This function is called from ErrorReport::init and so should not generate
 370    * any new exceptions.
 371    */
 372   AutoClearPendingException acpe(cx);
 373
 374   bool found;
 375   if (!JS_HasProperty(cx, exnObject, js_message_str, &found) || !found) {
 376     return false;
 377   }
 378
 379   // First try "filename".
 380   const char* filename_str = *filename_strp;
 381   if (!JS_HasProperty(cx, exnObject, filename_str, &found)) {
 382     return false;
 383   }
 384   if (!found) {
 385     // If that doesn't work, try "fileName".
 386     filename_str = js_fileName_str;
 387     if (!JS_HasProperty(cx, exnObject, filename_str, &found) || !found) {
 388       return false;
 389     }
 390   }
 391
 392   if (!JS_HasProperty(cx, exnObject, js_lineNumber_str, &found) || !found) {
 393     return false;
 394   }
 395
 396   *filename_strp = filename_str;
 397   return true;
 398 }
 399
 400 static bool GetPropertyNoException(JSContext* cx, HandleObject obj,
 401                                    SniffingBehavior behavior,
 402                                    Handle<PropertyName*> name,
 403                                    MutableHandleValue vp) {
 404   // This function has no side-effects so always use it.
 405   if (GetPropertyPure(cx, obj, NameToId(name), vp.address())) {
 406     return true;
 407   }
 408
 409   if (behavior == SniffingBehavior::WithSideEffects) {
 410     AutoClearPendingException acpe(cx);
 411     return GetProperty(cx, obj, obj, name, vp);
 412   }
 413
 414   return false;
 415 }
 416
 417 // Create a new error message similar to what Error.prototype.toString would
 418 // produce when called on an object with those property values for name and
 419 // message.
 420 static JSString* FormatErrorMessage(JSContext* cx, HandleString name,
 421                                     HandleString message) {
 422   if (name && message) {
 423     AutoClearPendingException acpe(cx);
 424     JSStringBuilder sb(cx);
 425
 426     // Prefix the message with the error type, if it exists.
 427     if (!sb.append(name) || !sb.append(": ") || !sb.append(message)) {
 428       return nullptr;
 429     }
 430
 431     return sb.finishString();
 432   }
 433
 434   return name ? name : message;
 435 }
 436
 437 static JSString* ErrorReportToString(JSContext* cx, HandleObject exn,
 438                                      JSErrorReport* reportp,
 439                                      SniffingBehavior behavior) {
 440   // The error object might have custom `name` overwriting the exnType in the
 441   // error report. Try getting that property and use the exnType as a fallback.
 442   RootedString name(cx);
 443   RootedValue nameV(cx);
 444   if (GetPropertyNoException(cx, exn, behavior, cx->names().name, &nameV) &&
 445       nameV.isString()) {
 446     name = nameV.toString();
 447   }
 448
 449   // We do NOT want to use GetErrorTypeName() here because it will not do the
 450   // "right thing" for JSEXN_INTERNALERR.  That is, the caller of this API
 451   // expects that "InternalError: " will be prepended but GetErrorTypeName
 452   // goes out of its way to avoid this.
 453   if (!name) {
 454     JSExnType type = static_cast<JSExnType>(reportp->exnType);
 455     if (type != JSEXN_WARN && type != JSEXN_NOTE) {
 456       name = ClassName(GetExceptionProtoKey(type), cx);
 457     }
 458   }
 459
 460   RootedString message(cx);
 461   RootedValue messageV(cx);
 462   if (GetPropertyNoException(cx, exn, behavior, cx->names().message,
 463                              &messageV) &&
 464       messageV.isString()) {
 465     message = messageV.toString();
 466   }
 467
 468   if (!message) {
 469     message = reportp->newMessageString(cx);
 470     if (!message) {
 471       return nullptr;
 472     }
 473   }
 474
 475   return FormatErrorMessage(cx, name, message);
 476 }
 477
 478 JS::ErrorReportBuilder::ErrorReportBuilder(JSContext* cx)
 479     : reportp(nullptr), exnObject(cx) {}
 480
 481 JS::ErrorReportBuilder::~ErrorReportBuilder() = default;
 482
 483 bool JS::ErrorReportBuilder::init(JSContext* cx,
 484                                   const JS::ExceptionStack& exnStack,
 485                                   SniffingBehavior sniffingBehavior) {
 486   MOZ_ASSERT(!cx->isExceptionPending());
 487   MOZ_ASSERT(!reportp);
 488
 489   if (exnStack.exception().isObject()) {
 490     // Because ToString below could error and an exception object could become
 491     // unrooted, we must root our exception object, if any.
 492     exnObject = &exnStack.exception().toObject();
 493     reportp = ErrorFromException(cx, exnObject);
 494   }
 495
 496   // Be careful not to invoke ToString if we've already successfully extracted
 497   // an error report, since the exception might be wrapped in a security
 498   // wrapper, and ToString-ing it might throw.
 499   RootedString str(cx);
 500   if (reportp) {
 501     str = ErrorReportToString(cx, exnObject, reportp, sniffingBehavior);
 502   } else if (exnStack.exception().isSymbol()) {
 503     RootedValue strVal(cx);
 504     if (js::SymbolDescriptiveString(cx, exnStack.exception().toSymbol(),
 505                                     &strVal)) {
 506       str = strVal.toString();
 507     } else {
 508       str = nullptr;
 509     }
 510   } else if (exnObject && sniffingBehavior == NoSideEffects) {
 511     str = cx->names().Object;
 512   } else {
 513     str = js::ToString<CanGC>(cx, exnStack.exception());
 514   }
 515
 516   if (!str) {
 517     cx->clearPendingException();
 518   }
 519
 520   // If ErrorFromException didn't get us a JSErrorReport, then the object
 521   // was not an ErrorObject, security-wrapped or otherwise. However, it might
 522   // still quack like one. Give duck-typing a chance.  We start by looking for
 523   // "filename" (all lowercase), since that's where DOMExceptions store their
 524   // filename.  Then we check "fileName", which is where Errors store it.  We
 525   // have to do it in that order, because DOMExceptions have Error.prototype
 526   // on their proto chain, and hence also have a "fileName" property, but its
 527   // value is "".
 528   const char* filename_str = "filename";
 529   if (!reportp && exnObject && sniffingBehavior == WithSideEffects &&
 530       IsDuckTypedErrorObject(cx, exnObject, &filename_str)) {
 531     // Temporary value for pulling properties off of duck-typed objects.
 532     RootedValue val(cx);
 533
 534     RootedString name(cx);
 535     if (JS_GetProperty(cx, exnObject, js_name_str, &val) && val.isString()) {
 536       name = val.toString();
 537     } else {
 538       cx->clearPendingException();
 539     }
 540
 541     RootedString msg(cx);
 542     if (JS_GetProperty(cx, exnObject, js_message_str, &val) && val.isString()) {
 543       msg = val.toString();
 544     } else {
 545       cx->clearPendingException();
 546     }
 547
 548     // If we have the right fields, override the ToString we performed on
 549     // the exception object above with something built out of its quacks
 550     // (i.e. as much of |NameQuack: MessageQuack| as we can make).
 551     str = FormatErrorMessage(cx, name, msg);
 552
 553     {
 554       AutoClearPendingException acpe(cx);
 555       if (JS_GetProperty(cx, exnObject, filename_str, &val)) {
 556         RootedString tmp(cx, js::ToString<CanGC>(cx, val));
 557         if (tmp) {
 558           filename = JS_EncodeStringToUTF8(cx, tmp);
 559         }
 560       }
 561     }
 562     if (!filename) {
 563       filename = DuplicateString("");
 564       if (!filename) {
 565         ReportOutOfMemory(cx);
 566         return false;
 567       }
 568     }
 569
 570     uint32_t lineno;
 571     if (!JS_GetProperty(cx, exnObject, js_lineNumber_str, &val) ||
 572         !ToUint32(cx, val, &lineno)) {
 573       cx->clearPendingException();
 574       lineno = 0;
 575     }
 576
 577     uint32_t column;
 578     if (!JS_GetProperty(cx, exnObject, js_columnNumber_str, &val) ||
 579         !ToUint32(cx, val, &column)) {
 580       cx->clearPendingException();
 581       column = 0;
 582     }
 583
 584     reportp = &ownedReport;
 585     new (reportp) JSErrorReport();
 586     ownedReport.filename = filename.get();
 587     ownedReport.lineno = lineno;
 588     ownedReport.exnType = JSEXN_INTERNALERR;
 589     ownedReport.column = column;
 590
 591     if (str) {
 592       // Note that using |str| for |message_| here is kind of wrong,
 593       // because |str| is supposed to be of the format
 594       // |ErrorName: ErrorMessage|, and |message_| is supposed to
 595       // correspond to |ErrorMessage|. But this is what we've
 596       // historically done for duck-typed error objects.
 597       //
 598       // If only this stuff could get specced one day...
 599       if (auto utf8 = JS_EncodeStringToUTF8(cx, str)) {
 600         ownedReport.initOwnedMessage(utf8.release());
 601       } else {
 602         cx->clearPendingException();
 603         str = nullptr;
 604       }
 605     }
 606   }
 607
 608   const char* utf8Message = nullptr;
 609   if (str) {
 610     toStringResultBytesStorage = JS_EncodeStringToUTF8(cx, str);
 611     utf8Message = toStringResultBytesStorage.get();
 612     if (!utf8Message) {
 613       cx->clearPendingException();
 614     }
 615   }
 616   if (!utf8Message) {
 617     utf8Message = "unknown (can't convert to string)";
 618   }
 619
 620   if (!reportp) {
 621     // This is basically an inlined version of
 622     //
 623     //   JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
 624     //                            JSMSG_UNCAUGHT_EXCEPTION, utf8Message);
 625     //
 626     // but without the reporting bits.  Instead it just puts all
 627     // the stuff we care about in our ownedReport and message_.
 628     if (!populateUncaughtExceptionReportUTF8(cx, exnStack.stack(),
 629                                              utf8Message)) {
 630       // Just give up.  We're out of memory or something; not much we can
 631       // do here.
 632       return false;
 633     }
 634   } else {
 635     toStringResult_ = JS::ConstUTF8CharsZ(utf8Message, strlen(utf8Message));
 636   }
 637
 638   return true;
 639 }
 640
 641 bool JS::ErrorReportBuilder::populateUncaughtExceptionReportUTF8(
 642     JSContext* cx, HandleObject stack, ...) {
 643   va_list ap;
 644   va_start(ap, stack);
 645   bool ok = populateUncaughtExceptionReportUTF8VA(cx, stack, ap);
 646   va_end(ap);
 647   return ok;
 648 }
 649
 650 bool JS::ErrorReportBuilder::populateUncaughtExceptionReportUTF8VA(
 651     JSContext* cx, HandleObject stack, va_list ap) {
 652   new (&ownedReport) JSErrorReport();
 653   ownedReport.isWarning_ = false;
 654   ownedReport.errorNumber = JSMSG_UNCAUGHT_EXCEPTION;
 655
 656   bool skippedAsync;
 657   Rooted<SavedFrame*> frame(
 658       cx, UnwrapSavedFrame(cx, cx->realm()->principals(), stack,
 659                            SavedFrameSelfHosted::Exclude, skippedAsync));
 660   if (frame) {
 661     filename = StringToNewUTF8CharsZ(cx, *frame->getSource());
 662     if (!filename) {
 663       return false;
 664     }
 665
 666     // |ownedReport.filename| inherits the lifetime of |ErrorReport::filename|.
 667     ownedReport.filename = filename.get();
 668     ownedReport.sourceId = frame->getSourceId();
 669     ownedReport.lineno = frame->getLine();
 670     // Follow FixupColumnForDisplay and set column to 1 for WASM.
 671     ownedReport.column = frame->isWasm() ? 1 : frame->getColumn();
 672     ownedReport.isMuted = frame->getMutedErrors();
 673   } else {
 674     // XXXbz this assumes the stack we have right now is still
 675     // related to our exception object.
 676     NonBuiltinFrameIter iter(cx, cx->realm()->principals());
 677     if (!iter.done()) {
 678       ownedReport.filename = iter.filename();
 679       uint32_t column;
 680       ownedReport.sourceId =
 681           iter.hasScript() ? iter.script()->scriptSource()->id() : 0;
 682       ownedReport.lineno = iter.computeLine(&column);
 683       ownedReport.column = FixupColumnForDisplay(column);
 684       ownedReport.isMuted = iter.mutedErrors();
 685     }
 686   }
 687
 688   AutoReportFrontendContext fc(cx);
 689   if (!ExpandErrorArgumentsVA(&fc, GetErrorMessage, nullptr,
 690                               JSMSG_UNCAUGHT_EXCEPTION, ArgumentsAreUTF8,
 691                               &ownedReport, ap)) {
 692     return false;
 693   }
 694
 695   toStringResult_ = ownedReport.message();
 696   reportp = &ownedReport;
 697   return true;
 698 }
 699
 700 JSObject* js::CopyErrorObject(JSContext* cx, Handle<ErrorObject*> err) {
 701   UniquePtr<JSErrorReport> copyReport;
 702   if (JSErrorReport* errorReport = err->getErrorReport()) {
 703     copyReport = CopyErrorReport(cx, errorReport);
 704     if (!copyReport) {
 705       return nullptr;
 706     }
 707   }
 708
 709   RootedString message(cx, err->getMessage());
 710   if (message && !cx->compartment()->wrap(cx, &message)) {
 711     return nullptr;
 712   }
 713   RootedString fileName(cx, err->fileName(cx));
 714   if (!cx->compartment()->wrap(cx, &fileName)) {
 715     return nullptr;
 716   }
 717   RootedObject stack(cx, err->stack());
 718   if (!cx->compartment()->wrap(cx, &stack)) {
 719     return nullptr;
 720   }
 721   if (stack && JS_IsDeadWrapper(stack)) {
 722     // ErrorObject::create expects |stack| to be either nullptr or a (possibly
 723     // wrapped) SavedFrame instance.
 724     stack = nullptr;
 725   }
 726   Rooted<mozilla::Maybe<Value>> cause(cx, mozilla::Nothing());
 727   if (auto maybeCause = err->getCause()) {
 728     RootedValue errorCause(cx, maybeCause.value());
 729     if (!cx->compartment()->wrap(cx, &errorCause)) {
 730       return nullptr;
 731     }
 732     cause = mozilla::Some(errorCause.get());
 733   }
 734   uint32_t sourceId = err->sourceId();
 735   uint32_t lineNumber = err->lineNumber();
 736   uint32_t columnNumber = err->columnNumber();
 737   JSExnType errorType = err->type();
 738
 739   // Create the Error object.
 740   return ErrorObject::create(cx, errorType, stack, fileName, sourceId,
 741                              lineNumber, columnNumber, std::move(copyReport),
 742                              message, cause);
 743 }
 744
 745 JS_PUBLIC_API bool JS::CreateError(JSContext* cx, JSExnType type,
 746                                    HandleObject stack, HandleString fileName,
 747                                    uint32_t lineNumber, uint32_t columnNumber,
 748                                    JSErrorReport* report, HandleString message,
 749                                    Handle<mozilla::Maybe<Value>> cause,
 750                                    MutableHandleValue rval) {
 751   cx->check(stack, fileName, message);
 752   AssertObjectIsSavedFrameOrWrapper(cx, stack);
 753
 754   js::UniquePtr<JSErrorReport> rep;
 755   if (report) {
 756     rep = CopyErrorReport(cx, report);
 757     if (!rep) {
 758       return false;
 759     }
 760   }
 761
 762   JSObject* obj =
 763       js::ErrorObject::create(cx, type, stack, fileName, 0, lineNumber,
 764                               columnNumber, std::move(rep), message, cause);
 765   if (!obj) {
 766     return false;
 767   }
 768
 769   rval.setObject(*obj);
 770   return true;
 771 }
 772
 773 const char* js::ValueToSourceForError(JSContext* cx, HandleValue val,
 774                                       UniqueChars& bytes) {
 775   if (val.isUndefined()) {
 776     return "undefined";
 777   }
 778
 779   if (val.isNull()) {
 780     return "null";
 781   }
 782
 783   AutoClearPendingException acpe(cx);
 784
 785   RootedString str(cx, JS_ValueToSource(cx, val));
 786   if (!str) {
 787     return "<<error converting value to string>>";
 788   }
 789
 790   JSStringBuilder sb(cx);
 791   if (val.hasObjectPayload()) {
 792     RootedObject valObj(cx, &val.getObjectPayload());
 793     ESClass cls;
 794     if (!JS::GetBuiltinClass(cx, valObj, &cls)) {
 795       return "<<error determining class of value>>";
 796     }
 797     const char* s;
 798     if (cls == ESClass::Array) {
 799       s = "the array ";
 800     } else if (cls == ESClass::ArrayBuffer) {
 801       s = "the array buffer ";
 802     } else if (JS_IsArrayBufferViewObject(valObj)) {
 803       s = "the typed array ";
 804 #ifdef ENABLE_RECORD_TUPLE
 805     } else if (cls == ESClass::Record) {
 806       s = "the record ";
 807     } else if (cls == ESClass::Tuple) {
 808       s = "the tuple ";
 809 #endif
 810     } else {
 811       s = "the object ";
 812     }
 813     if (!sb.append(s, strlen(s))) {
 814       return "<<error converting value to string>>";
 815     }
 816   } else if (val.isNumber()) {
 817     if (!sb.append("the number ")) {
 818       return "<<error converting value to string>>";
 819     }
 820   } else if (val.isString()) {
 821     if (!sb.append("the string ")) {
 822       return "<<error converting value to string>>";
 823     }
 824   } else if (val.isBigInt()) {
 825     if (!sb.append("the BigInt ")) {
 826       return "<<error converting value to string>>";
 827     }
 828   } else {
 829     MOZ_ASSERT(val.isBoolean() || val.isSymbol());
 830     bytes = StringToNewUTF8CharsZ(cx, *str);
 831     return bytes.get();
 832   }
 833   if (!sb.append(str)) {
 834     return "<<error converting value to string>>";
 835   }
 836   str = sb.finishString();
 837   if (!str) {
 838     return "<<error converting value to string>>";
 839   }
 840   bytes = StringToNewUTF8CharsZ(cx, *str);
 841   return bytes.get();
 842 }
 843
 844 bool js::GetInternalError(JSContext* cx, unsigned errorNumber,
 845                           MutableHandleValue error) {
 846   FixedInvokeArgs<1> args(cx);
 847   args[0].set(Int32Value(errorNumber));
 848   return CallSelfHostedFunction(cx, cx->names().GetInternalError,
 849                                 NullHandleValue, args, error);
 850 }
 851
 852 bool js::GetTypeError(JSContext* cx, unsigned errorNumber,
 853                       MutableHandleValue error) {
 854   FixedInvokeArgs<1> args(cx);
 855   args[0].set(Int32Value(errorNumber));
 856   return CallSelfHostedFunction(cx, cx->names().GetTypeError, NullHandleValue,
 857                                 args, error);
 858 }
 859
 860 bool js::GetAggregateError(JSContext* cx, unsigned errorNumber,
 861                            MutableHandleValue error) {
 862   FixedInvokeArgs<1> args(cx);
 863   args[0].set(Int32Value(errorNumber));
 864   return CallSelfHostedFunction(cx, cx->names().GetAggregateError,
 865                                 NullHandleValue, args, error);
 866 }
 867
 868 JS_PUBLIC_API mozilla::Maybe<Value> JS::GetExceptionCause(JSObject* exc) {
 869   if (!exc->is<ErrorObject>()) {
 870     return mozilla::Nothing();
 871   }
 872   auto& error = exc->as<ErrorObject>();
 873   return error.getCause();
 874 }