Name Description Size
Activation-inl.h static 4850
Activation.cpp 2934
Activation.h 23501
ArgumentsObject-inl.h namespace js 1673
ArgumentsObject.cpp static 38607
ArgumentsObject.h This array holds either the current argument value or the magic forwarding value. The latter means that the function has both a CallObject and an ArgumentsObject AND the particular formal variable is aliased by the CallObject. In such cases, the CallObject holds the canonical value so any element access to the arguments object should load the value out of the CallObject (which is pointed to by MAYBE_CALL_SLOT). 21275
ArrayBufferObject-inl.h 1718
ArrayBufferObject.cpp 87353
ArrayBufferObject.h 25409
ArrayBufferObjectMaybeShared.cpp 2716
ArrayBufferViewObject.cpp static 13369
ArrayBufferViewObject.h ArrayBufferViewObject Common base class for all array buffer views (DataViewObject and TypedArrayObject). 6293
ArrayObject-inl.h static 2665
ArrayObject.h 2268
AsyncFunction.cpp ES2022 draft rev d03c1ec6e235a5180fa772b6178727c17974cb14 Await in async function Unified implementation of Step 3. fulfilledClosure Abstract Closure. Step 5. rejectedClosure Abstract Closure. 12571
AsyncFunction.h 12315
AsyncFunctionResolveKind.h vm_AsyncFunctionResolveKind_h 578
AsyncIteration.cpp static 53673
AsyncIteration.h 20465
AtomsTable.h Implementation details of the atoms table. 3619
BigIntType.cpp 121421
BigIntType.h 20989
BindingKind.h 2859
BooleanObject-inl.h = nullptr 785
BooleanObject.h Stores this Boolean object's [[PrimitiveValue]]. 1304
BoundFunctionObject.cpp 17031
BoundFunctionObject.h 6119
BuildId.cpp SpiderMonkey buildId-related functionality. 1006
BuiltinObjectKind.cpp 6746
BuiltinObjectKind.h Built-in objects used by the GetBuiltinConstructor and GetBuiltinPrototype self-hosted intrinsics. 2064
BytecodeFormatFlags.h [SMDOC] Bytecode Format flags (JOF_*) 3091
BytecodeIterator-inl.h 1070
BytecodeIterator.h 2305
BytecodeLocation-inl.h 3651
BytecodeLocation.cpp 925
BytecodeLocation.h 10483
BytecodeUtil-inl.h Add an extra pushed value for Or/And opcodes, so that they are included in the pushed array of stack values for type inference. 7222
BytecodeUtil.cpp JS bytecode descriptors, disassemblers, and (expression) decompilers. 82978
BytecodeUtil.h JS bytecode definitions. 19762
Caches.h 17117
CallAndConstruct.cpp 5855
CallNonGenericMethod.cpp 1070
CharacterEncoding.cpp nbytes sets 1 length since this is surrogate pair. 29614
CheckIsObjectKind.h vm_CheckIsObjectKind_h 671
CodeCoverage.cpp 19218
CodeCoverage.h 5269
CommonPropertyNames.h A higher-order macro for enumerating all cached property names. 50893
Compartment-inl.h Only GC things have to be wrapped or copied. 14358
Compartment.cpp Directly allocate the copy in the destination compartment, rather than first flattening it (and possibly allocating in source compartment), because we don't know whether the flattening will pay off later. 18888
Compartment.h 17747
CompilationAndEvaluation.cpp Same-thread compilation and evaluation APIs. 20584
CompletionKind.h 509
Compression.cpp 7694
Compression.h Compress some of the input. Return true if it should be called again. 3943
ConcurrentDelazification.cpp 11011
ConcurrentDelazification.h 6079
DateObject.h Cached slots holding local properties of the date. These are undefined until the first actual lookup occurs and are reset to undefined whenever the date's time is modified. 3610
DateTime.cpp !defined(XP_WIN) 27131
DateTime.h Constants defined by ES5 15148
EnvironmentObject-inl.h namespace js 2850
EnvironmentObject.cpp / SharedShape* js::EnvironmentCoordinateToEnvironmentShape(JSScript* script, jsbytecode* pc) { MOZ_ASSERT(JOF_OPTYPE(JSOp(*pc)) == JOF_ENVCOORD); ScopeIter si(script->innermostScope(pc)); uint32_t hops = EnvironmentCoordinate(pc).hops(); while (true) { MOZ_ASSERT(!si.done()); if (si.hasSyntacticEnvironment()) { if (!hops) { break; } hops--; } si++; } return si.environmentShape(); } PropertyName* js::EnvironmentCoordinateNameSlow(JSScript* script, jsbytecode* pc) { SharedShape* shape = EnvironmentCoordinateToEnvironmentShape(script, pc); EnvironmentCoordinate ec(pc); SharedShapePropertyIter<NoGC> iter(shape); while (iter->slot() != ec.slot()) { iter++; } jsid id = iter->key(); /* Beware nameless destructuring formal. 146155
EnvironmentObject.h Return a shape representing the static scope containing the variable accessed by the ALIASEDVAR op at 'pc'. 60768
EqualityOperations.cpp 11074
EqualityOperations.h The equality comparisons of js/Equality.h, but with extra efficiency for SpiderMonkey-internal callers. These functions, assuming they're passed C++-valid arguments, are identical to the same-named JS::-namespaced functions -- just with hidden linkage (so they're more efficient to call), and without various external-caller-focused JSAPI-usage assertions performed that SpiderMonkey users never come close to failing. 2587
ErrorMessages.cpp SpiderMonkey-internal error-reporting formatting functionality. 995
ErrorObject-inl.h vm_ErrorObject_inl_h 1572
ErrorObject.cpp 27012
ErrorObject.h Assign the initial error shape to the empty object. (This shape does *not* include .message, which must be added separately if needed; see ErrorObject::init.) 6133
ErrorReporting.cpp 21282
ErrorReporting.h Use this type instead of JSContext when the object is only used for its ability to allocate memory (via its MallocProvider methods). 8435
Exception.cpp 1879
ForOfIterator.cpp 5838
FrameIter-inl.h 1934
FrameIter.cpp 28140
FrameIter.h 17655
FunctionFlags.cpp 688
FunctionFlags.h 15959
FunctionPrefixKind.h vm_FunctionPrefixKind_h 553
GeckoProfiler-inl.h This class is used to suppress profiler sampling during critical sections where stack state is not valid. 4273
GeckoProfiler.cpp Ensure all future generated code will be instrumented, or that all currently instrumented code is discarded 18010
GeckoProfiler.h 10213
GeneratorAndAsyncKind.h namespace js 601
GeneratorObject.cpp 17614
GeneratorObject.h 9174
GeneratorResumeKind.h vm_GeneratorResumeKind_h 562
GetterSetter.cpp 934
GetterSetter.h 3983
GlobalObject-inl.h static 1011
GlobalObject.cpp static 36354
GlobalObject.h 41824
HelperThreads.cpp 55089
HelperThreads.h API for managing off-thread work. 7906
HelperThreadState.h Definitions for managing off-thread work using a process wide list of worklist items and pool of threads. Worklist items are engine internal, and are distinct from e.g. web workers. 23769
HelperThreadTask.h vm_HelperThreadTask_h 1857
Id.cpp static 1492
Initialization.cpp SpiderMonkey initialization and shutdown code. 9938
InlineCharBuffer-inl.h 5422
InternalThreadPool.cpp The profiling thread for this helper thread, which can be used to push and pop label frames. This field being non-null indicates that this thread has been registered and needs to be unregistered at shutdown. 8821
InternalThreadPool.h An internal thread pool, used for the shell and when JS::SetHelperThreadTaskCallback not called. 2132
Interpreter-inl.h Per ES6, lexical declarations may not be accessed in any fashion until they are initialized (i.e., until the actual declaring statement is executed). The various LEXICAL opcodes need to check if the slot is an uninitialized let declaration, represented by the magic value JS_UNINITIALIZED_LEXICAL. 31057
Interpreter.cpp JavaScript bytecode interpreter. 162384
Interpreter.h JS interpreter interface. 27233
IsGivenTypeObject-inl.h 949
Iteration.cpp JavaScript iterators. 70388
Iteration.h JavaScript iterators. 27874
Iterator.cpp 3396
JitActivation.cpp 8567
JitActivation.h 10026
JSAtomState.h Various built-in or commonly-used names pinned on first context. 2138
JSAtomUtils-inl.h Write out character representing |index| to the memory just before |end|. Thus |*end| is not touched, but |end[-1]| and earlier are modified as appropriate. There must be at least js::UINT32_CHAR_BUFFER_LENGTH elements before |end| to avoid buffer underflow. The start of the characters written is returned and is necessarily before |end|. 4498
JSAtomUtils.cpp JS atom table. 35675
JSAtomUtils.h Return a printable, lossless char[] representation of a string-type atom. The returned string is guaranteed to contain only ASCII characters. 3347
JSContext-inl.h Set a breakpoint here (break js::ContextChecks::fail) to debug realm/compartment/zone mismatches. 10783
JSContext.cpp JS execution context. 39178
JSContext.h JS execution context. 37522
JSFunction-inl.h namespace js 4716
JSFunction.cpp JS function support. 61129
JSFunction.h JS function definitions. 34863
JSObject-inl.h static 21013
JSObject.cpp JS object implementation. 110355
JSObject.h / class GlobalObject; class NativeObject; enum class IntegrityLevel { Sealed, Frozen }; /* The NewObjectKind allows an allocation site to specify the lifetime requirements that must be fixed at allocation time. 39751
JSONParser.cpp JSONString: /^"([^\u0000-\u001F"\\]|\\(["/\\bfnrt]|u[0-9a-fA-F]{4}))*"$/ 33766
JSONParser.h 15850
JSONPrinter.cpp 5975
JSONPrinter.h vm_JSONPrinter_h 2800 11575
JSScript-inl.h A JSScript always marks its realm's global so we can assert it's non-null here. We don't need a read barrier here for the same reason JSObject::nonCCWGlobal doesn't need one. 7811
JSScript.cpp JS script operations. 118505
JSScript.h JS script descriptor. 79646
List-inl.h static 3606
List.cpp 419
List.h The List specification type, ECMA-262 6.2.1. <> Lists are simple mutable sequences of values. Many standards use them. Abstractly, they're not objects; they don't have properties or prototypes; they're for internal specification use only. ListObject is our most direct implementation of a List: store the values in the slots of a JSObject. We often implement Lists in other ways. For example, builtin/Utilities.js contains a completely unrelated List constructor that's used in self-hosted code. And AsyncGeneratorObject optimizes away the ListObject in the common case where its internal queue never holds more than one element. ListObjects must not be exposed to content scripts. 3013 Usage: python This script generates SpiderMonkey bytecode documentation from js/src/vm/Opcodes.h. Output is written to stdout and should be pasted into the following MDN page: 5538
MallocProvider.h Hierarchy of SpiderMonkey system memory allocators: - System {m,c,re}alloc/new/free: Overridden by jemalloc in most environments. Do not use these functions directly. - js_{m,c,re}alloc/new/free: Wraps the system allocators and adds a failure injection framework for use by the fuzzers as well as templated, typesafe variants. See js/public/Utility.h. - AllocPolicy: An interface for the js allocators, for use with templates. These allocators are for system memory whose lifetime is not associated with a GC thing. See js/public/AllocPolicy.h. - SystemAllocPolicy: No extra functionality over bare allocators. - TempAllocPolicy: Adds automatic error reporting to the provided JSContext when allocations fail. - ZoneAllocPolicy: Forwards to the Zone MallocProvider. - MallocProvider. A mixin base class that handles automatically updating the GC's state in response to allocations that are tied to a GC lifetime or are for a particular GC purpose. These allocators must only be used for memory that will be freed when a GC thing is swept. - gc::Zone: Automatically triggers zone GC. - JSRuntime: Automatically triggers full GC. - JSContext: Dispatches directly to the runtime. 8098
MatchPairs.h RegExp match results are succinctly represented by pairs of integer indices delimiting (start, limit] segments of the input string. The pair count for a given RegExp match is the capturing parentheses count plus one for the "0 capturing paren" whole text match. 3789
MemoryMetrics.cpp static 29183
ModuleBuilder.h 4389
Modules.cpp JavaScript modules (as in, the syntactic construct) implementation. 66609
Modules.h 1511
Monitor.h vm_Monitor_h 1889
MutexIDs.h 2922
NativeObject-inl.h 28632
NativeObject.cpp Objects with no elements share one empty set of elements. 98881
NativeObject.h To really poison a set of values, using 'magic' or 'undefined' isn't good enough since often these will just be ignored by buggy code (see bug 629974) in debug builds and crash in release builds. Instead, we use a safe-for-crash pointer. 72278
NumberObject-inl.h = nullptr 816
NumberObject.h Stores this Number object's [[PrimitiveValue]]. 1283
ObjectFlags-inl.h vm_ObjectFlags_inl_h 3321
ObjectFlags.h vm_ObjectFlags_h 3693
ObjectOperations-inl.h Fundamental operations on objects. 13942
ObjectOperations.h Fundamental operations on objects. 13185
OffThreadPromiseRuntimeState.cpp 10457
OffThreadPromiseRuntimeState.h 9601
Opcodes.h 141410
PIC.cpp 12855
PIC.h The basic PICStub just has a pointer to the next stub. 7903
PlainObject-inl.h static 3383
PlainObject.cpp JS object implementation. 11095
PlainObject.h Return the allocKind we would use if we were to tenure this object. 4352
PortableBaselineInterpret.cpp JavaScript "portable baseline interpreter": an interpreter that is capable of running ICs, but without any native code. See the [SMDOC] in vm/PortableBaselineInterpret.h for a high-level overview. 176453
PortableBaselineInterpret.h 17098
Printer.cpp 14885
Probes-inl.h Many probe handlers are implemented inline for minimal performance impact, especially important when no backends are enabled. 2362
Probes.cpp These functions call the DTrace macros for the JavaScript USDT probes. Originally this code was inlined in the JavaScript code; however since a number of operations are called, these have been placed into functions to reduce any negative compiler optimization effect that the addition of a number of usually unused lines of code would cause. 2208
Probes.h Static probes The probe points defined in this file are scattered around the SpiderMonkey source tree. The presence of probes::SomeEvent() means that someEvent is about to happen or has happened. To the extent possible, probes should be inserted in all paths associated with a given event, regardless of the active runmode (interpreter/traceJIT/methodJIT/ionJIT). When a probe fires, it is handled by any probe handling backends that have been compiled in. By default, most probes do nothing or at least do nothing expensive, so the presence of the probe should have negligible effect on running time. (Probes in slow paths may do something by default, as long as there is no noticeable slowdown.) For some probes, the mere existence of the probe is too expensive even if it does nothing when called. For example, just having consistent information available for a function call entry/exit probe causes the JITs to de-optimize function calls. In those cases, the JITs may query at compile time whether a probe is desired, and omit the probe invocation if not. If a probe is runtime-disabled at compilation time, it is not guaranteed to fire within a compiled function if it is later enabled. Not all backends handle all of the probes listed here. 4338
ProfilingStack.cpp 1613
PromiseLookup.cpp 9540
PromiseLookup.h A PromiseLookup holds the following: Promise's shape (promiseConstructorShape_) To ensure that Promise has not been modified. Promise.prototype's shape (promiseProtoShape_) To ensure that Promise.prototype has not been modified. Promise's slot number for the @@species getter (promiseSpeciesGetterSlot_) To quickly retrieve the @@species getter for Promise. Promise's slot number for resolve (promiseResolveSlot_) To quickly retrieve the Promise.resolve function. Promise.prototype's slot number for constructor (promiseProtoConstructorSlot_) To quickly retrieve the Promise.prototype.constructor property. Promise.prototype's slot number for then (promiseProtoThenSlot_) To quickly retrieve the Promise.prototype.then function. MOZ_INIT_OUTSIDE_CTOR fields below are set in |initialize()|. The constructor only initializes a |state_| field, that defines whether the other fields are accessible. 6019
PromiseObject.h 9601
PropertyAndElement.cpp 38888
PropertyDescriptor.cpp 3352
PropertyInfo.h Limit on the number of slotful properties in an object. 7272
PropertyKey.h vm_PropertyKey_h 1732
PropertyResult.h vm_PropertyResult_h 2898
PropMap-inl.h 7507
PropMap.cpp prev = 39165
PropMap.h 40751
ProxyObject.cpp static 6717
ProxyObject.h This is the base class for the various kinds of proxy objects. It's never instantiated. Proxy objects use their shape primarily to record flags. Property information, &c. is all dynamically computed. There is no class_ member to force specialization of JSObject::is<T>(). The implementation in JSObject is incorrect for proxies since it doesn't take account of the handler type. 5764
Realm-inl.h static 3373
Realm.cpp As a hack, we clear our timezone cache every time we create a new realm. This ensures that the cache is always relatively fresh, but shouldn't interfere with benchmarks that create tons of date objects (unless they also create tons of iframes, which seems unlikely). 23790
Realm.h A single-entry cache for some base-10 double-to-string conversions. This helps date-format-xparb.js. It also avoids skewing the results for v8-splay.js when measured by the SunSpider harness, where the splay tree initialization (which includes many repeated double-to-string conversions) is erroneously included in the measurement; see bug 562553. 31176
RecordTupleShared.cpp 3816
RecordTupleShared.h 1102
RecordType.cpp 14465
RecordType.h 2380
RegExpObject.cpp = nullptr 37021
RegExpObject.h JavaScript RegExp objects. 8044
RegExpShared.h The compiled representation of a RegExp, potentially shared among RegExp instances created during separate evaluations of a single RegExp literal in source code. 15523
RegExpStatics.cpp Retrieve or create the RegExpShared in this zone. 1744
RegExpStatics.h The latest RegExp output, set after execution. 8843
Runtime.cpp static 25818
Runtime.h namespace js 39376
SavedFrame.h 10074
SavedStacks-inl.h 1271
SavedStacks.cpp Maximum number of saved frames returned for an async stack. 73024
SavedStacks.h 15102
Scope.cpp 58647
Scope.h 59322
ScopeKind.h 889
SelfHosting.cpp 103425
SelfHosting.h 11022
Shape-inl.h static 3200
Shape.cpp static 48684
Shape.h 32289
ShapeZone.cpp JS symbol tables. 4921
ShapeZone.h 8422
SharedArrayObject.cpp isWasm = 21362
SharedArrayObject.h SharedArrayRawBuffer A bookkeeping object always stored before the raw buffer. The buffer itself is refcounted. SharedArrayBufferObjects and structured clone objects may hold references. WasmSharedArrayRawBuffer is a derived class that's used for Wasm buffers. - Non-Wasm buffers are allocated with a single calloc allocation, like this: |<------ sizeof ------>|<- length ->| | SharedArrayRawBuffer | data array | - Wasm buffers are allocated with MapBufferMemory (mmap), like this: |<-------- sizeof -------->|<- length ->| | waste | WasmSharedArrayRawBuffer | data array | waste | Observe that if we want to map the data array on a specific address, such as absolute zero (bug 1056027), then the {Wasm}SharedArrayRawBuffer cannot be prefixed to the data array, it has to be a separate object, also in shared memory. (That would get rid of ~4KB of waste, as well.) Very little else would have to change throughout the engine, the SARB would point to the data array using a constant pointer, instead of computing its address. For Wasm buffers, length_ can change following initialization; it may grow toward sourceMaxPages_. See extensive comments above WasmArrayRawBuffer in ArrayBufferObject.cpp. length_ only grows when the lock is held. 11609
SharedImmutableStringsCache-inl.h 2667
SharedImmutableStringsCache.cpp static 4119
SharedImmutableStringsCache.h The `SharedImmutableStringsCache` allows safely sharing and deduplicating immutable strings (either `const char*` [any encoding, not restricted to only Latin-1 or only UTF-8] or `const char16_t*`) between threads. The locking mechanism is dead-simple and coarse grained: a single lock guards all of the internal table itself, the table's entries, and the entries' reference counts. It is only safe to perform any mutation on the cache or any data stored within the cache when this lock is acquired. 13750
SharedMem.h 4993
SharedScriptDataTableHolder.cpp 722
SharedScriptDataTableHolder.h namespace js 2753
SharedStencil.h Exception handling record. 33587
SourceHook.cpp 903
Stack-inl.h Initialize stack frame members. 24972
Stack.cpp 23796
Stack.h / namespace js { namespace jit { class BaselineFrame; class RematerializedFrame; } // namespace jit /** Pointer to a live JS or WASM stack frame. 33599
StaticStrings.cpp 2803
StaticStrings.h We keep these public for the JITs. 8697
StencilCache.cpp static 2131
StencilCache.h namespace frontend 7720
StencilEnums.h 13149
StencilObject.cpp static 5086
StencilObject.h namespace js 2013
StringObject-inl.h static 1629
StringObject.h Creates a new String object boxing the given string. The object's [[Prototype]] is determined from context. 2231
StringType-inl.h Don't bother trying to find a static atom; measurement shows that not many get here (for one, Atomize is catching them). 24245
StringType.cpp 77303
StringType.h The buffer length required to contain any unsigned 32-bit integer. 75518
StructuredClone.cpp This file implements the structured data algorithms of The spec is in two parts: - StructuredSerialize examines a JS value and produces a graph of Records. - StructuredDeserialize walks the Records and produces a new JS value. The differences between our implementation and the spec are minor: - We call the two phases "write" and "read". - Our algorithms use an explicit work stack, rather than recursion. - Serialized data is a flat array of bytes, not a (possibly cyclic) graph of "Records". - As a consequence, we handle non-treelike object graphs differently. We serialize objects that appear in multiple places in the input as backreferences, using sequential integer indexes. See `JSStructuredCloneReader::allObjs`, our take on the "memory" map in the spec's StructuredDeserialize. 129691
SymbolType.cpp 4001
SymbolType.h namespace JS 5287
TaggedProto.cpp static 1235
TaggedProto.h Skip nullptr and LazyProto. 5214
ThrowMsgKind.cpp 1337
ThrowMsgKind.h vm_ThrowMsgKind_h 964
Time.cpp PR time code. 6666
Time.h Broken down form of 64 bit time value. 5043
ToSource.cpp Convert a JSString to its source expression; returns null after reporting an error, otherwise returns a new string reference. No Handle needed since the input is dead after the GC. 7450
ToSource.h 817
TupleType.cpp Step 1. 17964
TupleType.h 3061
TypedArrayObject-inl.h Utilities and common inline code for TypedArray 23622
TypedArrayObject.cpp TypedArrayObject The non-templated base class for the specific typed implementations. This class holds all the member variables that are used by the subclasses. 102712
TypedArrayObject.h TypedArrayObject The non-templated base class for the specific typed implementations. This class holds all the member variables that are used by the subclasses. 9692
UbiNode.cpp 16030
UbiNodeCensus.cpp Count Types *********************************************************** 40510
UbiNodeShortestPaths.cpp = 10 2566
Uint8Clamped.h Note that we can't use std::numeric_limits here due to uint8_clamped. 3027
UsageStatistics.cpp 798
Value.cpp 1524
Warnings.cpp 3187
Warnings.h vm_Warnings_h 839
Watchtower.cpp 8955
Watchtower.h vm_Watchtower_h 4614
WellKnownAtom.cpp 1015
WellKnownAtom.h namespace js 1579
WindowProxy.cpp WindowProxy and Window implementation, for the web browser embedding. 2266
WrapperObject.h vm_WrapperObject_h 1075
Xdr.cpp 5353
Xdr.h 12252