js/src/jsapi.h

   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 /* JavaScript API. */
   8
   9 #ifndef jsapi_h
  10 #define jsapi_h
  11
  12 #include "mozilla/AlreadyAddRefed.h"
  13 #include "mozilla/FloatingPoint.h"
  14 #include "mozilla/Maybe.h"
  15 #include "mozilla/MemoryReporting.h"
  16 #include "mozilla/RangedPtr.h"
  17 #include "mozilla/RefPtr.h"
  18 #include "mozilla/TimeStamp.h"
  19 #include "mozilla/Utf8.h"
  20 #include "mozilla/Variant.h"
  21
  22 #include <stdarg.h>
  23 #include <stddef.h>
  24 #include <stdint.h>
  25 #include <stdio.h>
  26
  27 #include "jspubtd.h"
  28
  29 #include "js/AllocPolicy.h"
  30 #include "js/CallAndConstruct.h"  // JS::Call, JS_CallFunction, JS_CallFunctionName, JS_CallFunctionValue
  31 #include "js/CallArgs.h"
  32 #include "js/CharacterEncoding.h"
  33 #include "js/Class.h"
  34 #include "js/CompileOptions.h"
  35 #include "js/Context.h"
  36 #include "js/Debug.h"
  37 #include "js/ErrorInterceptor.h"
  38 #include "js/ErrorReport.h"
  39 #include "js/Exception.h"
  40 #include "js/GCAPI.h"
  41 #include "js/GCVector.h"
  42 #include "js/GlobalObject.h"
  43 #include "js/HashTable.h"
  44 #include "js/Id.h"
  45 #include "js/Interrupt.h"
  46 #include "js/MapAndSet.h"
  47 #include "js/MemoryCallbacks.h"
  48 #include "js/MemoryFunctions.h"
  49 #include "js/OffThreadScriptCompilation.h"
  50 #include "js/Principals.h"
  51 #include "js/PropertyAndElement.h"  // JS_Enumerate
  52 #include "js/PropertyDescriptor.h"
  53 #include "js/PropertySpec.h"
  54 #include "js/Realm.h"
  55 #include "js/RealmIterators.h"
  56 #include "js/RealmOptions.h"
  57 #include "js/RefCounted.h"
  58 #include "js/RootingAPI.h"
  59 #include "js/ScriptPrivate.h"
  60 #include "js/Stack.h"
  61 #include "js/StreamConsumer.h"
  62 #include "js/String.h"
  63 #include "js/TelemetryTimers.h"
  64 #include "js/TracingAPI.h"
  65 #include "js/Transcoding.h"
  66 #include "js/UniquePtr.h"
  67 #include "js/Utility.h"
  68 #include "js/Value.h"
  69 #include "js/ValueArray.h"
  70 #include "js/Vector.h"
  71 #include "js/WaitCallbacks.h"
  72 #include "js/WeakMap.h"
  73 #include "js/WrapperCallbacks.h"
  74 #include "js/Zone.h"
  75
  76 /************************************************************************/
  77
  78 namespace JS {
  79 /**
  80  * Tell JS engine whether to use fdlibm for Math.sin, Math.cos, and Math.tan.
  81  * Using fdlibm ensures that we don't expose a math fingerprint.
  82  */
  83 extern JS_PUBLIC_API void SetUseFdlibmForSinCosTan(bool value);
  84 }  // namespace JS
  85
  86 /************************************************************************/
  87
  88 struct JSFunctionSpec;
  89 struct JSPropertySpec;
  90
  91 namespace JS {
  92
  93 template <typename UnitT>
  94 class SourceText;
  95
  96 class TwoByteChars;
  97
  98 using ValueVector = JS::GCVector<JS::Value>;
  99 using IdVector = JS::GCVector<jsid>;
 100 using ScriptVector = JS::GCVector<JSScript*>;
 101 using StringVector = JS::GCVector<JSString*>;
 102
 103 } /* namespace JS */
 104
 105 /************************************************************************/
 106
 107 static MOZ_ALWAYS_INLINE JS::Value JS_NumberValue(double d) {
 108   int32_t i;
 109   d = JS::CanonicalizeNaN(d);
 110   if (mozilla::NumberIsInt32(d, &i)) {
 111     return JS::Int32Value(i);
 112   }
 113   return JS::DoubleValue(d);
 114 }
 115
 116 /************************************************************************/
 117
 118 JS_PUBLIC_API bool JS_StringHasBeenPinned(JSContext* cx, JSString* str);
 119
 120 /************************************************************************/
 121
 122 /** Microseconds since the epoch, midnight, January 1, 1970 UTC. */
 123 extern JS_PUBLIC_API int64_t JS_Now(void);
 124
 125 extern JS_PUBLIC_API bool JS_ValueToObject(JSContext* cx, JS::HandleValue v,
 126                                            JS::MutableHandleObject objp);
 127
 128 extern JS_PUBLIC_API JSFunction* JS_ValueToFunction(JSContext* cx,
 129                                                     JS::HandleValue v);
 130
 131 extern JS_PUBLIC_API JSFunction* JS_ValueToConstructor(JSContext* cx,
 132                                                        JS::HandleValue v);
 133
 134 extern JS_PUBLIC_API JSString* JS_ValueToSource(JSContext* cx,
 135                                                 JS::Handle<JS::Value> v);
 136
 137 extern JS_PUBLIC_API bool JS_DoubleIsInt32(double d, int32_t* ip);
 138
 139 extern JS_PUBLIC_API JSType JS_TypeOfValue(JSContext* cx,
 140                                            JS::Handle<JS::Value> v);
 141
 142 namespace JS {
 143
 144 extern JS_PUBLIC_API const char* InformalValueTypeName(const JS::Value& v);
 145
 146 } /* namespace JS */
 147
 148 /** True iff fun is the global eval function. */
 149 extern JS_PUBLIC_API bool JS_IsBuiltinEvalFunction(JSFunction* fun);
 150
 151 /** True iff fun is the Function constructor. */
 152 extern JS_PUBLIC_API bool JS_IsBuiltinFunctionConstructor(JSFunction* fun);
 153
 154 extern JS_PUBLIC_API const char* JS_GetImplementationVersion(void);
 155
 156 extern JS_PUBLIC_API void JS_SetWrapObjectCallbacks(
 157     JSContext* cx, const JSWrapObjectCallbacks* callbacks);
 158
 159 // Examine a value to determine if it is one of the built-in Error types.
 160 // If so, return the error type.
 161 extern JS_PUBLIC_API mozilla::Maybe<JSExnType> JS_GetErrorType(
 162     const JS::Value& val);
 163
 164 extern JS_PUBLIC_API bool JS_WrapObject(JSContext* cx,
 165                                         JS::MutableHandleObject objp);
 166
 167 extern JS_PUBLIC_API bool JS_WrapValue(JSContext* cx,
 168                                        JS::MutableHandleValue vp);
 169
 170 extern JS_PUBLIC_API JSObject* JS_TransplantObject(JSContext* cx,
 171                                                    JS::HandleObject origobj,
 172                                                    JS::HandleObject target);
 173
 174 /**
 175  * Resolve id, which must contain either a string or an int, to a standard
 176  * class name in obj if possible, defining the class's constructor and/or
 177  * prototype and storing true in *resolved.  If id does not name a standard
 178  * class or a top-level property induced by initializing a standard class,
 179  * store false in *resolved and just return true.  Return false on error,
 180  * as usual for bool result-typed API entry points.
 181  *
 182  * This API can be called directly from a global object class's resolve op,
 183  * to define standard classes lazily. The class should either have an enumerate
 184  * hook that calls JS_EnumerateStandardClasses, or a newEnumerate hook that
 185  * calls JS_NewEnumerateStandardClasses. newEnumerate is preferred because it's
 186  * faster (does not define all standard classes).
 187  */
 188 extern JS_PUBLIC_API bool JS_ResolveStandardClass(JSContext* cx,
 189                                                   JS::HandleObject obj,
 190                                                   JS::HandleId id,
 191                                                   bool* resolved);
 192
 193 extern JS_PUBLIC_API bool JS_MayResolveStandardClass(const JSAtomState& names,
 194                                                      jsid id,
 195                                                      JSObject* maybeObj);
 196
 197 extern JS_PUBLIC_API bool JS_EnumerateStandardClasses(JSContext* cx,
 198                                                       JS::HandleObject obj);
 199
 200 /**
 201  * Fill "properties" with a list of standard class names that have not yet been
 202  * resolved on "obj".  This can be used as (part of) a newEnumerate class hook
 203  * on a global.  Already-resolved things are excluded because they might have
 204  * been deleted by script after being resolved and enumeration considers
 205  * already-defined properties anyway.
 206  */
 207 extern JS_PUBLIC_API bool JS_NewEnumerateStandardClasses(
 208     JSContext* cx, JS::HandleObject obj, JS::MutableHandleIdVector properties,
 209     bool enumerableOnly);
 210
 211 /**
 212  * Fill "properties" with a list of standard class names.  This can be used for
 213  * proxies that want to define behavior that looks like enumerating a global
 214  * without touching the global itself.
 215  */
 216 extern JS_PUBLIC_API bool JS_NewEnumerateStandardClassesIncludingResolved(
 217     JSContext* cx, JS::HandleObject obj, JS::MutableHandleIdVector properties,
 218     bool enumerableOnly);
 219
 220 extern JS_PUBLIC_API bool JS_GetClassObject(JSContext* cx, JSProtoKey key,
 221                                             JS::MutableHandle<JSObject*> objp);
 222
 223 extern JS_PUBLIC_API bool JS_GetClassPrototype(
 224     JSContext* cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);
 225
 226 namespace JS {
 227
 228 /*
 229  * Determine if the given object is an instance/prototype/constructor for a
 230  * standard class. If so, return the associated JSProtoKey. If not, return
 231  * JSProto_Null.
 232  */
 233
 234 extern JS_PUBLIC_API JSProtoKey IdentifyStandardInstance(JSObject* obj);
 235
 236 extern JS_PUBLIC_API JSProtoKey IdentifyStandardPrototype(JSObject* obj);
 237
 238 extern JS_PUBLIC_API JSProtoKey
 239 IdentifyStandardInstanceOrPrototype(JSObject* obj);
 240
 241 extern JS_PUBLIC_API JSProtoKey IdentifyStandardConstructor(JSObject* obj);
 242
 243 extern JS_PUBLIC_API void ProtoKeyToId(JSContext* cx, JSProtoKey key,
 244                                        JS::MutableHandleId idp);
 245
 246 } /* namespace JS */
 247
 248 extern JS_PUBLIC_API JSProtoKey JS_IdToProtoKey(JSContext* cx, JS::HandleId id);
 249
 250 extern JS_PUBLIC_API JSObject* JS_GlobalLexicalEnvironment(JSObject* obj);
 251
 252 extern JS_PUBLIC_API bool JS_HasExtensibleLexicalEnvironment(JSObject* obj);
 253
 254 extern JS_PUBLIC_API JSObject* JS_ExtensibleLexicalEnvironment(JSObject* obj);
 255
 256 /**
 257  * Add 'Reflect.parse', a SpiderMonkey extension, to the Reflect object on the
 258  * given global.
 259  */
 260 extern JS_PUBLIC_API bool JS_InitReflectParse(JSContext* cx,
 261                                               JS::HandleObject global);
 262
 263 /**
 264  * Add various profiling-related functions as properties of the given object.
 265  * Defined in builtin/Profilers.cpp.
 266  */
 267 extern JS_PUBLIC_API bool JS_DefineProfilingFunctions(JSContext* cx,
 268                                                       JS::HandleObject obj);
 269
 270 namespace JS {
 271
 272 /**
 273  * Tell JS engine whether Profile Timeline Recording is enabled or not.
 274  * If Profile Timeline Recording is enabled, data shown there like stack won't
 275  * be optimized out.
 276  * This is global state and not associated with specific runtime or context.
 277  */
 278 extern JS_PUBLIC_API void SetProfileTimelineRecordingEnabled(bool enabled);
 279
 280 extern JS_PUBLIC_API bool IsProfileTimelineRecordingEnabled();
 281
 282 }  // namespace JS
 283
 284 /************************************************************************/
 285
 286 extern JS_PUBLIC_API bool JS_ValueToId(JSContext* cx, JS::HandleValue v,
 287                                        JS::MutableHandleId idp);
 288
 289 extern JS_PUBLIC_API bool JS_StringToId(JSContext* cx, JS::HandleString s,
 290                                         JS::MutableHandleId idp);
 291
 292 extern JS_PUBLIC_API bool JS_IdToValue(JSContext* cx, jsid id,
 293                                        JS::MutableHandle<JS::Value> vp);
 294
 295 namespace JS {
 296
 297 /**
 298  * Convert obj to a primitive value. On success, store the result in vp and
 299  * return true.
 300  *
 301  * The hint argument must be JSTYPE_STRING, JSTYPE_NUMBER, or
 302  * JSTYPE_UNDEFINED (no hint).
 303  *
 304  * Implements: ES6 7.1.1 ToPrimitive(input, [PreferredType]).
 305  */
 306 extern JS_PUBLIC_API bool ToPrimitive(JSContext* cx, JS::HandleObject obj,
 307                                       JSType hint, JS::MutableHandleValue vp);
 308
 309 /**
 310  * If args.get(0) is one of the strings "string", "number", or "default", set
 311  * result to JSTYPE_STRING, JSTYPE_NUMBER, or JSTYPE_UNDEFINED accordingly and
 312  * return true. Otherwise, return false with a TypeError pending.
 313  *
 314  * This can be useful in implementing a @@toPrimitive method.
 315  */
 316 extern JS_PUBLIC_API bool GetFirstArgumentAsTypeHint(JSContext* cx,
 317                                                      CallArgs args,
 318                                                      JSType* result);
 319
 320 } /* namespace JS */
 321
 322 extern JS_PUBLIC_API JSObject* JS_InitClass(
 323     JSContext* cx, JS::HandleObject obj, JS::HandleObject parent_proto,
 324     const JSClass* clasp, JSNative constructor, unsigned nargs,
 325     const JSPropertySpec* ps, const JSFunctionSpec* fs,
 326     const JSPropertySpec* static_ps, const JSFunctionSpec* static_fs);
 327
 328 /**
 329  * Set up ctor.prototype = proto and proto.constructor = ctor with the
 330  * right property flags.
 331  */
 332 extern JS_PUBLIC_API bool JS_LinkConstructorAndPrototype(
 333     JSContext* cx, JS::Handle<JSObject*> ctor, JS::Handle<JSObject*> proto);
 334
 335 extern JS_PUBLIC_API bool JS_InstanceOf(JSContext* cx,
 336                                         JS::Handle<JSObject*> obj,
 337                                         const JSClass* clasp,
 338                                         JS::CallArgs* args);
 339
 340 extern JS_PUBLIC_API bool JS_HasInstance(JSContext* cx,
 341                                          JS::Handle<JSObject*> obj,
 342                                          JS::Handle<JS::Value> v, bool* bp);
 343
 344 namespace JS {
 345
 346 // Implementation of
 347 // http://www.ecma-international.org/ecma-262/6.0/#sec-ordinaryhasinstance.  If
 348 // you're looking for the equivalent of "instanceof", you want JS_HasInstance,
 349 // not this function.
 350 extern JS_PUBLIC_API bool OrdinaryHasInstance(JSContext* cx,
 351                                               HandleObject objArg,
 352                                               HandleValue v, bool* bp);
 353
 354 // Implementation of
 355 // https://www.ecma-international.org/ecma-262/6.0/#sec-instanceofoperator
 356 // This is almost identical to JS_HasInstance, except the latter may call a
 357 // custom hasInstance class op instead of InstanceofOperator.
 358 extern JS_PUBLIC_API bool InstanceofOperator(JSContext* cx, HandleObject obj,
 359                                              HandleValue v, bool* bp);
 360
 361 }  // namespace JS
 362
 363 extern JS_PUBLIC_API JSObject* JS_GetConstructor(JSContext* cx,
 364                                                  JS::Handle<JSObject*> proto);
 365
 366 extern JS_PUBLIC_API JSObject* JS_NewObject(JSContext* cx,
 367                                             const JSClass* clasp);
 368
 369 extern JS_PUBLIC_API bool JS_IsNative(JSObject* obj);
 370
 371 /**
 372  * Unlike JS_NewObject, JS_NewObjectWithGivenProto does not compute a default
 373  * proto. If proto is nullptr, the JS object will have `null` as [[Prototype]].
 374  */
 375 extern JS_PUBLIC_API JSObject* JS_NewObjectWithGivenProto(
 376     JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
 377
 378 /**
 379  * Creates a new plain object, like `new Object()`, with Object.prototype as
 380  * [[Prototype]].
 381  */
 382 extern JS_PUBLIC_API JSObject* JS_NewPlainObject(JSContext* cx);
 383
 384 /**
 385  * Freeze obj, and all objects it refers to, recursively. This will not recurse
 386  * through non-extensible objects, on the assumption that those are already
 387  * deep-frozen.
 388  */
 389 extern JS_PUBLIC_API bool JS_DeepFreezeObject(JSContext* cx,
 390                                               JS::Handle<JSObject*> obj);
 391
 392 /**
 393  * Freezes an object; see ES5's Object.freeze(obj) method.
 394  */
 395 extern JS_PUBLIC_API bool JS_FreezeObject(JSContext* cx,
 396                                           JS::Handle<JSObject*> obj);
 397
 398 /*** Standard internal methods **********************************************
 399  *
 400  * The functions below are the fundamental operations on objects.
 401  *
 402  * ES6 specifies 14 internal methods that define how objects behave.  The
 403  * standard is actually quite good on this topic, though you may have to read
 404  * it a few times. See ES6 sections 6.1.7.2 and 6.1.7.3.
 405  *
 406  * When 'obj' is an ordinary object, these functions have boring standard
 407  * behavior as specified by ES6 section 9.1; see the section about internal
 408  * methods in js/src/vm/NativeObject.h.
 409  *
 410  * Proxies override the behavior of internal methods. So when 'obj' is a proxy,
 411  * any one of the functions below could do just about anything. See
 412  * js/public/Proxy.h.
 413  */
 414
 415 /**
 416  * Get the prototype of |obj|, storing it in |proto|.
 417  *
 418  * Implements: ES6 [[GetPrototypeOf]] internal method.
 419  */
 420 extern JS_PUBLIC_API bool JS_GetPrototype(JSContext* cx, JS::HandleObject obj,
 421                                           JS::MutableHandleObject result);
 422
 423 /**
 424  * If |obj| (underneath any functionally-transparent wrapper proxies) has as
 425  * its [[GetPrototypeOf]] trap the ordinary [[GetPrototypeOf]] behavior defined
 426  * for ordinary objects, set |*isOrdinary = true| and store |obj|'s prototype
 427  * in |result|.  Otherwise set |*isOrdinary = false|.  In case of error, both
 428  * outparams have unspecified value.
 429  */
 430 extern JS_PUBLIC_API bool JS_GetPrototypeIfOrdinary(
 431     JSContext* cx, JS::HandleObject obj, bool* isOrdinary,
 432     JS::MutableHandleObject result);
 433
 434 /**
 435  * Change the prototype of obj.
 436  *
 437  * Implements: ES6 [[SetPrototypeOf]] internal method.
 438  *
 439  * In cases where ES6 [[SetPrototypeOf]] returns false without an exception,
 440  * JS_SetPrototype throws a TypeError and returns false.
 441  *
 442  * Performance warning: JS_SetPrototype is very bad for performance. It may
 443  * cause compiled jit-code to be invalidated. It also causes not only obj but
 444  * all other objects in the same "group" as obj to be permanently deoptimized.
 445  * It's better to create the object with the right prototype from the start.
 446  */
 447 extern JS_PUBLIC_API bool JS_SetPrototype(JSContext* cx, JS::HandleObject obj,
 448                                           JS::HandleObject proto);
 449
 450 /**
 451  * Determine whether obj is extensible. Extensible objects can have new
 452  * properties defined on them. Inextensible objects can't, and their
 453  * [[Prototype]] slot is fixed as well.
 454  *
 455  * Implements: ES6 [[IsExtensible]] internal method.
 456  */
 457 extern JS_PUBLIC_API bool JS_IsExtensible(JSContext* cx, JS::HandleObject obj,
 458                                           bool* extensible);
 459
 460 /**
 461  * Attempt to make |obj| non-extensible.
 462  *
 463  * Not all failures are treated as errors. See the comment on
 464  * JS::ObjectOpResult in js/public/Class.h.
 465  *
 466  * Implements: ES6 [[PreventExtensions]] internal method.
 467  */
 468 extern JS_PUBLIC_API bool JS_PreventExtensions(JSContext* cx,
 469                                                JS::HandleObject obj,
 470                                                JS::ObjectOpResult& result);
 471
 472 /**
 473  * Attempt to make the [[Prototype]] of |obj| immutable, such that any attempt
 474  * to modify it will fail.  If an error occurs during the attempt, return false
 475  * (with a pending exception set, depending upon the nature of the error).  If
 476  * no error occurs, return true with |*succeeded| set to indicate whether the
 477  * attempt successfully made the [[Prototype]] immutable.
 478  *
 479  * This is a nonstandard internal method.
 480  */
 481 extern JS_PUBLIC_API bool JS_SetImmutablePrototype(JSContext* cx,
 482                                                    JS::HandleObject obj,
 483                                                    bool* succeeded);
 484
 485 /**
 486  * Equivalent to `Object.assign(target, src)`: Copies the properties from the
 487  * `src` object (which must not be null) to `target` (which also must not be
 488  * null).
 489  */
 490 extern JS_PUBLIC_API bool JS_AssignObject(JSContext* cx,
 491                                           JS::HandleObject target,
 492                                           JS::HandleObject src);
 493
 494 namespace JS {
 495
 496 /**
 497  * On success, returns true, setting |*isMap| to true if |obj| is a Map object
 498  * or a wrapper around one, or to false if not.  Returns false on failure.
 499  *
 500  * This method returns true with |*isMap == false| when passed an ES6 proxy
 501  * whose target is a Map, or when passed a revoked proxy.
 502  */
 503 extern JS_PUBLIC_API bool IsMapObject(JSContext* cx, JS::HandleObject obj,
 504                                       bool* isMap);
 505
 506 /**
 507  * On success, returns true, setting |*isSet| to true if |obj| is a Set object
 508  * or a wrapper around one, or to false if not.  Returns false on failure.
 509  *
 510  * This method returns true with |*isSet == false| when passed an ES6 proxy
 511  * whose target is a Set, or when passed a revoked proxy.
 512  */
 513 extern JS_PUBLIC_API bool IsSetObject(JSContext* cx, JS::HandleObject obj,
 514                                       bool* isSet);
 515
 516 } /* namespace JS */
 517
 518 /**
 519  * Assign 'undefined' to all of the object's non-reserved slots. Note: this is
 520  * done for all slots, regardless of the associated property descriptor.
 521  */
 522 JS_PUBLIC_API void JS_SetAllNonReservedSlotsToUndefined(JS::HandleObject obj);
 523
 524 extern JS_PUBLIC_API void JS_SetReservedSlot(JSObject* obj, uint32_t index,
 525                                              const JS::Value& v);
 526
 527 extern JS_PUBLIC_API void JS_InitReservedSlot(JSObject* obj, uint32_t index,
 528                                               void* ptr, size_t nbytes,
 529                                               JS::MemoryUse use);
 530
 531 template <typename T>
 532 void JS_InitReservedSlot(JSObject* obj, uint32_t index, T* ptr,
 533                          JS::MemoryUse use) {
 534   JS_InitReservedSlot(obj, index, ptr, sizeof(T), use);
 535 }
 536
 537 /************************************************************************/
 538
 539 /* native that can be called as a ctor */
 540 static constexpr unsigned JSFUN_CONSTRUCTOR = 0x400;
 541
 542 /* | of all the JSFUN_* flags */
 543 static constexpr unsigned JSFUN_FLAGS_MASK = 0x400;
 544
 545 static_assert((JSPROP_FLAGS_MASK & JSFUN_FLAGS_MASK) == 0,
 546               "JSFUN_* flags do not overlap JSPROP_* flags, because bits from "
 547               "the two flag-sets appear in the same flag in some APIs");
 548
 549 /*
 550  * Functions and scripts.
 551  */
 552 extern JS_PUBLIC_API JSFunction* JS_NewFunction(JSContext* cx, JSNative call,
 553                                                 unsigned nargs, unsigned flags,
 554                                                 const char* name);
 555
 556 namespace JS {
 557
 558 extern JS_PUBLIC_API JSFunction* GetSelfHostedFunction(
 559     JSContext* cx, const char* selfHostedName, HandleId id, unsigned nargs);
 560
 561 /**
 562  * Create a new function based on the given JSFunctionSpec, *fs.
 563  * id is the result of a successful call to
 564  * `PropertySpecNameToId(cx, fs->name, &id)` or
 565    `PropertySpecNameToPermanentId(cx, fs->name, &id)`.
 566  *
 567  * Unlike JS_DefineFunctions, this does not treat fs as an array.
 568  * *fs must not be JS_FS_END.
 569  */
 570 extern JS_PUBLIC_API JSFunction* NewFunctionFromSpec(JSContext* cx,
 571                                                      const JSFunctionSpec* fs,
 572                                                      HandleId id);
 573
 574 /**
 575  * Same as above, but without an id arg, for callers who don't have
 576  * the id already.
 577  */
 578 extern JS_PUBLIC_API JSFunction* NewFunctionFromSpec(JSContext* cx,
 579                                                      const JSFunctionSpec* fs);
 580
 581 } /* namespace JS */
 582
 583 extern JS_PUBLIC_API JSObject* JS_GetFunctionObject(JSFunction* fun);
 584
 585 /**
 586  * Return the function's identifier as a JSString, or null if fun is unnamed.
 587  * The returned string lives as long as fun, so you don't need to root a saved
 588  * reference to it if fun is well-connected or rooted, and provided you bound
 589  * the use of the saved reference by fun's lifetime.
 590  */
 591 extern JS_PUBLIC_API JSString* JS_GetFunctionId(JSFunction* fun);
 592
 593 /**
 594  * Return a function's display name. This is the defined name if one was given
 595  * where the function was defined, or it could be an inferred name by the JS
 596  * engine in the case that the function was defined to be anonymous. This can
 597  * still return nullptr if a useful display name could not be inferred. The
 598  * same restrictions on rooting as those in JS_GetFunctionId apply.
 599  */
 600 extern JS_PUBLIC_API JSString* JS_GetFunctionDisplayId(JSFunction* fun);
 601
 602 /*
 603  * Return the arity of fun, which includes default parameters and rest
 604  * parameter.  This can be used as `nargs` parameter for other functions.
 605  */
 606 extern JS_PUBLIC_API uint16_t JS_GetFunctionArity(JSFunction* fun);
 607
 608 /*
 609  * Return the length of fun, which is the original value of .length property.
 610  */
 611 JS_PUBLIC_API bool JS_GetFunctionLength(JSContext* cx, JS::HandleFunction fun,
 612                                         uint16_t* length);
 613
 614 /**
 615  * Infallible predicate to test whether obj is a function object (faster than
 616  * comparing obj's class name to "Function", but equivalent unless someone has
 617  * overwritten the "Function" identifier with a different constructor and then
 618  * created instances using that constructor that might be passed in as obj).
 619  */
 620 extern JS_PUBLIC_API bool JS_ObjectIsFunction(JSObject* obj);
 621
 622 extern JS_PUBLIC_API bool JS_IsNativeFunction(JSObject* funobj, JSNative call);
 623
 624 /** Return whether the given function is a valid constructor. */
 625 extern JS_PUBLIC_API bool JS_IsConstructor(JSFunction* fun);
 626
 627 extern JS_PUBLIC_API bool JS_IsFunctionBound(JSFunction* fun);
 628
 629 extern JS_PUBLIC_API JSObject* JS_GetBoundFunctionTarget(JSFunction* fun);
 630
 631 extern JS_PUBLIC_API JSObject* JS_GetGlobalFromScript(JSScript* script);
 632
 633 extern JS_PUBLIC_API const char* JS_GetScriptFilename(JSScript* script);
 634
 635 extern JS_PUBLIC_API unsigned JS_GetScriptBaseLineNumber(JSContext* cx,
 636                                                          JSScript* script);
 637
 638 extern JS_PUBLIC_API JSScript* JS_GetFunctionScript(JSContext* cx,
 639                                                     JS::HandleFunction fun);
 640
 641 extern JS_PUBLIC_API JSString* JS_DecompileScript(JSContext* cx,
 642                                                   JS::Handle<JSScript*> script);
 643
 644 extern JS_PUBLIC_API JSString* JS_DecompileFunction(
 645     JSContext* cx, JS::Handle<JSFunction*> fun);
 646
 647 namespace JS {
 648
 649 /**
 650  * Supply an alternative stack to incorporate into captured SavedFrame
 651  * backtraces as the imputed caller of asynchronous JavaScript calls, like async
 652  * function resumptions and DOM callbacks.
 653  *
 654  * When one async function awaits the result of another, it's natural to think
 655  * of that as a sort of function call: just as execution resumes from an
 656  * ordinary call expression when the callee returns, with the return value
 657  * providing the value of the call expression, execution resumes from an 'await'
 658  * expression after the awaited asynchronous function call returns, passing the
 659  * return value along.
 660  *
 661  * Call the two async functions in such a situation the 'awaiter' and the
 662  * 'awaitee'.
 663  *
 664  * As an async function, the awaitee contains 'await' expressions of its own.
 665  * Whenever it executes after its first 'await', there are never any actual
 666  * frames on the JavaScript stack under it; its awaiter is certainly not there.
 667  * An await expression's continuation is invoked as a promise callback, and
 668  * those are always called directly from the event loop in their own microtick.
 669  * (Ignore unusual cases like nested event loops.)
 670  *
 671  * But because await expressions bear such a strong resemblance to calls (and
 672  * deliberately so!), it would be unhelpful for stacks captured within the
 673  * awaitee to be empty; instead, they should present the awaiter as the caller.
 674  *
 675  * The AutoSetAsyncStackForNewCalls RAII class supplies a SavedFrame stack to
 676  * treat as the caller of any JavaScript invocations that occur within its
 677  * lifetime. Any SavedFrame stack captured during such an invocation uses the
 678  * SavedFrame passed to the constructor's 'stack' parameter as the 'asyncParent'
 679  * property of the SavedFrame for the invocation's oldest frame. Its 'parent'
 680  * property will be null, so stack-walking code can distinguish this
 681  * awaiter/awaitee transition from an ordinary caller/callee transition.
 682  *
 683  * The constructor's 'asyncCause' parameter supplies a string explaining what
 684  * sort of asynchronous call caused 'stack' to be spliced into the backtrace;
 685  * for example, async function resumptions use the string "async". This appears
 686  * as the 'asyncCause' property of the 'asyncParent' SavedFrame.
 687  *
 688  * Async callers are distinguished in the string form of a SavedFrame chain by
 689  * including the 'asyncCause' string in the frame. It appears before the
 690  * function name, with the two separated by a '*'.
 691  *
 692  * Note that, as each compartment has its own set of SavedFrames, the
 693  * 'asyncParent' may actually point to a copy of 'stack', rather than the exact
 694  * SavedFrame object passed.
 695  *
 696  * The youngest frame of 'stack' is not mutated to take the asyncCause string as
 697  * its 'asyncCause' property; SavedFrame objects are immutable. Rather, a fresh
 698  * clone of the frame is created with the needed 'asyncCause' property.
 699  *
 700  * The 'kind' argument specifies how aggressively 'stack' supplants any
 701  * JavaScript frames older than this AutoSetAsyncStackForNewCalls object. If
 702  * 'kind' is 'EXPLICIT', then all captured SavedFrame chains take on 'stack' as
 703  * their 'asyncParent' where the chain crosses this object's scope. If 'kind' is
 704  * 'IMPLICIT', then 'stack' is only included in captured chains if there are no
 705  * other JavaScript frames on the stack --- that is, only if the stack would
 706  * otherwise end at that point.
 707  *
 708  * AutoSetAsyncStackForNewCalls affects only SavedFrame chains; it does not
 709  * affect Debugger.Frame or js::FrameIter. SavedFrame chains are used for
 710  * Error.stack, allocation profiling, Promise debugging, and so on.
 711  *
 712  * See also `js/src/doc/SavedFrame/SavedFrame.md` for documentation on async
 713  * stack frames.
 714  */
 715 class MOZ_STACK_CLASS JS_PUBLIC_API AutoSetAsyncStackForNewCalls {
 716   JSContext* cx;
 717   RootedObject oldAsyncStack;
 718   const char* oldAsyncCause;
 719   bool oldAsyncCallIsExplicit;
 720
 721  public:
 722   enum class AsyncCallKind {
 723     // The ordinary kind of call, where we may apply an async
 724     // parent if there is no ordinary parent.
 725     IMPLICIT,
 726     // An explicit async parent, e.g., callFunctionWithAsyncStack,
 727     // where we always want to override any ordinary parent.
 728     EXPLICIT
 729   };
 730
 731   // The stack parameter cannot be null by design, because it would be
 732   // ambiguous whether that would clear any scheduled async stack and make the
 733   // normal stack reappear in the new call, or just keep the async stack
 734   // already scheduled for the new call, if any.
 735   //
 736   // asyncCause is owned by the caller and its lifetime must outlive the
 737   // lifetime of the AutoSetAsyncStackForNewCalls object. It is strongly
 738   // encouraged that asyncCause be a string constant or similar statically
 739   // allocated string.
 740   AutoSetAsyncStackForNewCalls(JSContext* cx, HandleObject stack,
 741                                const char* asyncCause,
 742                                AsyncCallKind kind = AsyncCallKind::IMPLICIT);
 743   ~AutoSetAsyncStackForNewCalls();
 744 };
 745
 746 }  // namespace JS
 747
 748 /************************************************************************/
 749
 750 namespace JS {
 751
 752 JS_PUBLIC_API bool PropertySpecNameEqualsId(JSPropertySpec::Name name,
 753                                             HandleId id);
 754
 755 /**
 756  * Create a jsid that does not need to be marked for GC.
 757  *
 758  * 'name' is a JSPropertySpec::name or JSFunctionSpec::name value. The
 759  * resulting jsid, on success, is either an interned string or a well-known
 760  * symbol; either way it is immune to GC so there is no need to visit *idp
 761  * during GC marking.
 762  */
 763 JS_PUBLIC_API bool PropertySpecNameToPermanentId(JSContext* cx,
 764                                                  JSPropertySpec::Name name,
 765                                                  jsid* idp);
 766
 767 } /* namespace JS */
 768
 769 /************************************************************************/
 770
 771 /**
 772  * A JS context always has an "owner thread". The owner thread is set when the
 773  * context is created (to the current thread) and practically all entry points
 774  * into the JS engine check that a context (or anything contained in the
 775  * context: runtime, compartment, object, etc) is only touched by its owner
 776  * thread. Embeddings may check this invariant outside the JS engine by calling
 777  * JS_AbortIfWrongThread (which will abort if not on the owner thread, even for
 778  * non-debug builds).
 779  */
 780
 781 extern JS_PUBLIC_API void JS_AbortIfWrongThread(JSContext* cx);
 782
 783 /************************************************************************/
 784
 785 /**
 786  * A constructor can request that the JS engine create a default new 'this'
 787  * object of the given class, using the callee to determine parentage and
 788  * [[Prototype]].
 789  */
 790 extern JS_PUBLIC_API JSObject* JS_NewObjectForConstructor(
 791     JSContext* cx, const JSClass* clasp, const JS::CallArgs& args);
 792
 793 /************************************************************************/
 794
 795 extern JS_PUBLIC_API void JS_SetParallelParsingEnabled(JSContext* cx,
 796                                                        bool enabled);
 797
 798 extern JS_PUBLIC_API void JS_SetOffthreadIonCompilationEnabled(JSContext* cx,
 799                                                                bool enabled);
 800
 801 // clang-format off
 802 #define JIT_COMPILER_OPTIONS(Register) \
 803   Register(BASELINE_INTERPRETER_WARMUP_TRIGGER, "blinterp.warmup.trigger") \
 804   Register(BASELINE_WARMUP_TRIGGER, "baseline.warmup.trigger") \
 805   Register(IC_FORCE_MEGAMORPHIC, "ic.force-megamorphic") \
 806   Register(ION_NORMAL_WARMUP_TRIGGER, "ion.warmup.trigger") \
 807   Register(ION_GVN_ENABLE, "ion.gvn.enable") \
 808   Register(ION_FORCE_IC, "ion.forceinlineCaches") \
 809   Register(ION_ENABLE, "ion.enable") \
 810   Register(JIT_TRUSTEDPRINCIPALS_ENABLE, "jit_trustedprincipals.enable") \
 811   Register(ION_CHECK_RANGE_ANALYSIS, "ion.check-range-analysis") \
 812   Register(ION_FREQUENT_BAILOUT_THRESHOLD, "ion.frequent-bailout-threshold") \
 813   Register(INLINING_BYTECODE_MAX_LENGTH, "inlining.bytecode-max-length") \
 814   Register(BASELINE_INTERPRETER_ENABLE, "blinterp.enable") \
 815   Register(BASELINE_ENABLE, "baseline.enable") \
 816   Register(OFFTHREAD_COMPILATION_ENABLE, "offthread-compilation.enable")  \
 817   Register(FULL_DEBUG_CHECKS, "jit.full-debug-checks") \
 818   Register(JUMP_THRESHOLD, "jump-threshold") \
 819   Register(NATIVE_REGEXP_ENABLE, "native_regexp.enable") \
 820   Register(SIMULATOR_ALWAYS_INTERRUPT, "simulator.always-interrupt")      \
 821   Register(SPECTRE_INDEX_MASKING, "spectre.index-masking") \
 822   Register(SPECTRE_OBJECT_MITIGATIONS, "spectre.object-mitigations") \
 823   Register(SPECTRE_STRING_MITIGATIONS, "spectre.string-mitigations") \
 824   Register(SPECTRE_VALUE_MASKING, "spectre.value-masking") \
 825   Register(SPECTRE_JIT_TO_CXX_CALLS, "spectre.jit-to-cxx-calls") \
 826   Register(WASM_FOLD_OFFSETS, "wasm.fold-offsets") \
 827   Register(WASM_DELAY_TIER2, "wasm.delay-tier2") \
 828   Register(WASM_JIT_BASELINE, "wasm.baseline") \
 829   Register(WASM_JIT_OPTIMIZING, "wasm.optimizing") \
 830 // clang-format on
 831
 832 typedef enum JSJitCompilerOption {
 833 #define JIT_COMPILER_DECLARE(key, str) JSJITCOMPILER_##key,
 834
 835   JIT_COMPILER_OPTIONS(JIT_COMPILER_DECLARE)
 836 #undef JIT_COMPILER_DECLARE
 837
 838       JSJITCOMPILER_NOT_AN_OPTION
 839 } JSJitCompilerOption;
 840
 841 extern JS_PUBLIC_API void JS_SetGlobalJitCompilerOption(JSContext* cx,
 842                                                         JSJitCompilerOption opt,
 843                                                         uint32_t value);
 844 extern JS_PUBLIC_API bool JS_GetGlobalJitCompilerOption(JSContext* cx,
 845                                                         JSJitCompilerOption opt,
 846                                                         uint32_t* valueOut);
 847
 848 /**
 849  * Convert a uint32_t index into a jsid.
 850  */
 851 extern JS_PUBLIC_API bool JS_IndexToId(JSContext* cx, uint32_t index,
 852                                        JS::MutableHandleId);
 853
 854 /**
 855  * Convert chars into a jsid.
 856  *
 857  * |chars| may not be an index.
 858  */
 859 extern JS_PUBLIC_API bool JS_CharsToId(JSContext* cx, JS::TwoByteChars chars,
 860                                        JS::MutableHandleId);
 861
 862 /**
 863  *  Test if the given string is a valid ECMAScript identifier
 864  */
 865 extern JS_PUBLIC_API bool JS_IsIdentifier(JSContext* cx, JS::HandleString str,
 866                                           bool* isIdentifier);
 867
 868 /**
 869  * Test whether the given chars + length are a valid ECMAScript identifier.
 870  * This version is infallible, so just returns whether the chars are an
 871  * identifier.
 872  */
 873 extern JS_PUBLIC_API bool JS_IsIdentifier(const char16_t* chars, size_t length);
 874
 875 namespace js {
 876 class ScriptSource;
 877 }  // namespace js
 878
 879 namespace JS {
 880
 881 class MOZ_RAII JS_PUBLIC_API AutoFilename {
 882  private:
 883   js::ScriptSource* ss_;
 884   mozilla::Variant<const char*, UniqueChars> filename_;
 885
 886   AutoFilename(const AutoFilename&) = delete;
 887   AutoFilename& operator=(const AutoFilename&) = delete;
 888
 889  public:
 890   AutoFilename()
 891       : ss_(nullptr), filename_(mozilla::AsVariant<const char*>(nullptr)) {}
 892
 893   ~AutoFilename() { reset(); }
 894
 895   void reset();
 896
 897   void setOwned(UniqueChars&& filename);
 898   void setUnowned(const char* filename);
 899   void setScriptSource(js::ScriptSource* ss);
 900
 901   const char* get() const;
 902 };
 903
 904 /**
 905  * Return the current filename, line number and column number of the most
 906  * currently running frame. Returns true if a scripted frame was found, false
 907  * otherwise.
 908  *
 909  * If a the embedding has hidden the scripted caller for the topmost activation
 910  * record, this will also return false.
 911  */
 912 extern JS_PUBLIC_API bool DescribeScriptedCaller(
 913     JSContext* cx, AutoFilename* filename = nullptr, unsigned* lineno = nullptr,
 914     unsigned* column = nullptr);
 915
 916 extern JS_PUBLIC_API JSObject* GetScriptedCallerGlobal(JSContext* cx);
 917
 918 /**
 919  * Informs the JS engine that the scripted caller should be hidden. This can be
 920  * used by the embedding to maintain an override of the scripted caller in its
 921  * calculations, by hiding the scripted caller in the JS engine and pushing data
 922  * onto a separate stack, which it inspects when DescribeScriptedCaller returns
 923  * null.
 924  *
 925  * We maintain a counter on each activation record. Add() increments the counter
 926  * of the topmost activation, and Remove() decrements it. The count may never
 927  * drop below zero, and must always be exactly zero when the activation is
 928  * popped from the stack.
 929  */
 930 extern JS_PUBLIC_API void HideScriptedCaller(JSContext* cx);
 931
 932 extern JS_PUBLIC_API void UnhideScriptedCaller(JSContext* cx);
 933
 934 class MOZ_RAII AutoHideScriptedCaller {
 935  public:
 936   explicit AutoHideScriptedCaller(JSContext* cx) : mContext(cx) {
 937     HideScriptedCaller(mContext);
 938   }
 939   ~AutoHideScriptedCaller() { UnhideScriptedCaller(mContext); }
 940
 941  protected:
 942   JSContext* mContext;
 943 };
 944
 945 /**
 946  * Attempt to disable Wasm's usage of reserving a large virtual memory
 947  * allocation to avoid bounds checking overhead. This must be called before any
 948  * Wasm module or memory is created in this process, or else this function will
 949  * fail.
 950  */
 951 [[nodiscard]] extern JS_PUBLIC_API bool DisableWasmHugeMemory();
 952
 953 /**
 954  * Return true iff the given object is either a SavedFrame object or wrapper
 955  * around a SavedFrame object, and it is not the SavedFrame.prototype object.
 956  */
 957 extern JS_PUBLIC_API bool IsMaybeWrappedSavedFrame(JSObject* obj);
 958
 959 /**
 960  * Return true iff the given object is a SavedFrame object and not the
 961  * SavedFrame.prototype object.
 962  */
 963 extern JS_PUBLIC_API bool IsUnwrappedSavedFrame(JSObject* obj);
 964
 965 } /* namespace JS */
 966
 967 namespace js {
 968
 969 /**
 970  * Hint that we expect a crash. Currently, the only thing that cares is the
 971  * breakpad injector, which (if loaded) will suppress minidump generation.
 972  */
 973 extern JS_PUBLIC_API void NoteIntentionalCrash();
 974
 975 } /* namespace js */
 976
 977 #ifdef DEBUG
 978 namespace JS {
 979
 980 extern JS_PUBLIC_API void SetSupportDifferentialTesting(bool value);
 981
 982 }
 983 #endif /* DEBUG */
 984
 985 #endif /* jsapi_h */