summaryrefslogtreecommitdiffstats
path: root/js/src/vm/SharedStencil.h
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/vm/SharedStencil.h')
-rw-r--r--js/src/vm/SharedStencil.h849
1 files changed, 849 insertions, 0 deletions
diff --git a/js/src/vm/SharedStencil.h b/js/src/vm/SharedStencil.h
new file mode 100644
index 0000000000..f4787c1451
--- /dev/null
+++ b/js/src/vm/SharedStencil.h
@@ -0,0 +1,849 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef vm_SharedStencil_h
+#define vm_SharedStencil_h
+
+#include "mozilla/Assertions.h" // MOZ_ASSERT, MOZ_CRASH
+#include "mozilla/Atomics.h" // mozilla::{Atomic, SequentiallyConsistent}
+#include "mozilla/CheckedInt.h" // mozilla::CheckedInt
+#include "mozilla/HashFunctions.h" // mozilla::HahNumber, mozilla::HashBytes
+#include "mozilla/HashTable.h" // mozilla::HashSet
+#include "mozilla/MemoryReporting.h" // mozilla::MallocSizeOf
+#include "mozilla/RefPtr.h" // RefPtr
+#include "mozilla/Span.h" // mozilla::Span
+
+#include <stddef.h> // size_t
+#include <stdint.h> // uint8_t, uint16_t, uint32_t
+
+#include "frontend/SourceNotes.h" // js::SrcNote
+#include "frontend/TypedIndex.h" // js::frontend::TypedIndex
+
+#include "js/AllocPolicy.h" // js::SystemAllocPolicy
+#include "js/TypeDecls.h" // JSContext,jsbytecode
+#include "js/UniquePtr.h" // js::UniquePtr
+#include "js/Vector.h" // js::Vector
+#include "util/EnumFlags.h" // js::EnumFlags
+#include "util/TrailingArray.h" // js::TrailingArray
+#include "vm/GeneratorAndAsyncKind.h" // GeneratorKind, FunctionAsyncKind
+#include "vm/StencilEnums.h" // js::{TryNoteKind,ImmutableScriptFlagsEnum,MutableScriptFlagsEnum}
+
+//
+// Data structures shared between Stencil and the VM.
+//
+
+namespace js {
+
+class FrontendContext;
+
+namespace frontend {
+class StencilXDR;
+} // namespace frontend
+
+// Index into gcthings array.
+class GCThingIndexType;
+class GCThingIndex : public frontend::TypedIndex<GCThingIndexType> {
+ // Delegate constructors;
+ using Base = frontend::TypedIndex<GCThingIndexType>;
+ using Base::Base;
+
+ public:
+ static constexpr GCThingIndex outermostScopeIndex() {
+ return GCThingIndex(0);
+ }
+
+ static constexpr GCThingIndex invalid() { return GCThingIndex(UINT32_MAX); }
+
+ GCThingIndex next() const { return GCThingIndex(index + 1); }
+};
+
+/*
+ * Exception handling record.
+ */
+struct TryNote {
+ uint32_t kind_; /* one of TryNoteKind */
+ uint32_t stackDepth; /* stack depth upon exception handler entry */
+ uint32_t start; /* start of the try statement or loop relative
+ to script->code() */
+ uint32_t length; /* length of the try statement or loop */
+
+ TryNote(uint32_t kind, uint32_t stackDepth, uint32_t start, uint32_t length)
+ : kind_(kind), stackDepth(stackDepth), start(start), length(length) {}
+
+ TryNote() = default;
+
+ TryNoteKind kind() const { return TryNoteKind(kind_); }
+
+ bool isLoop() const {
+ switch (kind()) {
+ case TryNoteKind::Loop:
+ case TryNoteKind::ForIn:
+ case TryNoteKind::ForOf:
+ return true;
+ case TryNoteKind::Catch:
+ case TryNoteKind::Finally:
+ case TryNoteKind::ForOfIterClose:
+ case TryNoteKind::Destructuring:
+ return false;
+ }
+ MOZ_CRASH("Unexpected try note kind");
+ }
+};
+
+// A block scope has a range in bytecode: it is entered at some offset, and left
+// at some later offset. Scopes can be nested. Given an offset, the
+// ScopeNote containing that offset whose with the highest start value
+// indicates the block scope. The block scope list is sorted by increasing
+// start value.
+//
+// It is possible to leave a scope nonlocally, for example via a "break"
+// statement, so there may be short bytecode ranges in a block scope in which we
+// are popping the block chain in preparation for a goto. These exits are also
+// nested with respect to outer scopes. The scopes in these exits are indicated
+// by the "index" field, just like any other block. If a nonlocal exit pops the
+// last block scope, the index will be NoScopeIndex.
+//
+struct ScopeNote {
+ // Sentinel index for no Scope.
+ static constexpr GCThingIndex NoScopeIndex = GCThingIndex::invalid();
+
+ // Sentinel index for no ScopeNote.
+ static const uint32_t NoScopeNoteIndex = UINT32_MAX;
+
+ // Index of the js::Scope in the script's gcthings array, or NoScopeIndex if
+ // there is no block scope in this range.
+ GCThingIndex index;
+
+ // Bytecode offset at which this scope starts relative to script->code().
+ uint32_t start = 0;
+
+ // Length of bytecode span this scope covers.
+ uint32_t length = 0;
+
+ // Index of parent block scope in notes, or NoScopeNoteIndex.
+ uint32_t parent = 0;
+};
+
+// Range of characters in scriptSource which contains a script's source,
+// that is, the range used by the Parser to produce a script.
+//
+// For most functions the fields point to the following locations.
+//
+// function * foo(a, b) { return a + b; }
+// ^ ^ ^
+// | | |
+// | sourceStart sourceEnd
+// | |
+// toStringStart toStringEnd
+//
+// For the special case of class constructors, the spec requires us to use an
+// alternate definition of toStringStart / toStringEnd.
+//
+// class C { constructor() { this.field = 42; } }
+// ^ ^ ^ ^
+// | | | |
+// | sourceStart sourceEnd |
+// | |
+// toStringStart toStringEnd
+//
+// Implicit class constructors use the following definitions.
+//
+// class C { someMethod() { } }
+// ^ ^
+// | |
+// sourceStart sourceEnd
+// | |
+// toStringStart toStringEnd
+//
+// Field initializer lambdas are internal details of the engine, but we still
+// provide a sensible definition of these values.
+//
+// class C { static field = 1 }
+// class C { field = 1 }
+// class C { somefield }
+// ^ ^
+// | |
+// sourceStart sourceEnd
+//
+// The non-static private class methods (including getters and setters) ALSO
+// create a hidden initializer lambda in addition to the method itself. These
+// lambdas are not exposed directly to script.
+//
+// class C { #field() { } }
+// class C { get #field() { } }
+// class C { async #field() { } }
+// class C { * #field() { } }
+// ^ ^
+// | |
+// sourceStart sourceEnd
+//
+// NOTE: These are counted in Code Units from the start of the script source.
+//
+// Also included in the SourceExtent is the line and column numbers of the
+// sourceStart position. Compilation options may specify the initial line and
+// column number.
+//
+// NOTE: Column number may saturate and must not be used as unique identifier.
+struct SourceExtent {
+ SourceExtent() = default;
+
+ SourceExtent(uint32_t sourceStart, uint32_t sourceEnd, uint32_t toStringStart,
+ uint32_t toStringEnd, uint32_t lineno, uint32_t column)
+ : sourceStart(sourceStart),
+ sourceEnd(sourceEnd),
+ toStringStart(toStringStart),
+ toStringEnd(toStringEnd),
+ lineno(lineno),
+ column(column) {}
+
+ static SourceExtent makeGlobalExtent(uint32_t len) {
+ return SourceExtent(0, len, 0, len, 1, 0);
+ }
+
+ static SourceExtent makeGlobalExtent(uint32_t len, uint32_t lineno,
+ uint32_t column) {
+ return SourceExtent(0, len, 0, len, lineno, column);
+ }
+
+ // FunctionKey is an encoded position of a function within the source text
+ // that is unique and reproducible.
+ using FunctionKey = uint32_t;
+ static constexpr FunctionKey NullFunctionKey = 0;
+
+ uint32_t sourceStart = 0;
+ uint32_t sourceEnd = 0;
+ uint32_t toStringStart = 0;
+ uint32_t toStringEnd = 0;
+
+ // Line and column of |sourceStart_| position.
+ uint32_t lineno = 1; // 1-indexed.
+ uint32_t column = 0; // Count of Code Points
+
+ FunctionKey toFunctionKey() const {
+ // In eval("x=>1"), the arrow function will have a sourceStart of 0 which
+ // conflicts with the NullFunctionKey, so shift all keys by 1 instead.
+ auto result = sourceStart + 1;
+ MOZ_ASSERT(result != NullFunctionKey);
+ return result;
+ }
+};
+
+class ImmutableScriptFlags : public EnumFlags<ImmutableScriptFlagsEnum> {
+ public:
+ ImmutableScriptFlags() = default;
+
+ explicit ImmutableScriptFlags(FieldType rawFlags) : EnumFlags(rawFlags) {}
+
+ operator FieldType() const { return flags_; }
+};
+
+class MutableScriptFlags : public EnumFlags<MutableScriptFlagsEnum> {
+ public:
+ MutableScriptFlags() = default;
+
+ MutableScriptFlags& operator&=(const FieldType rhs) {
+ flags_ &= rhs;
+ return *this;
+ }
+
+ MutableScriptFlags& operator|=(const FieldType rhs) {
+ flags_ |= rhs;
+ return *this;
+ }
+
+ operator FieldType() const { return flags_; }
+};
+
+#define GENERIC_FLAGS_READ_ONLY(Field, Enum) \
+ [[nodiscard]] bool hasFlag(Enum flag) const { return Field.hasFlag(flag); }
+
+#define GENERIC_FLAGS_READ_WRITE(Field, Enum) \
+ [[nodiscard]] bool hasFlag(Enum flag) const { return Field.hasFlag(flag); } \
+ void setFlag(Enum flag, bool b = true) { Field.setFlag(flag, b); } \
+ void clearFlag(Enum flag) { Field.clearFlag(flag); }
+
+#define GENERIC_FLAG_GETTER(enumName, lowerName, name) \
+ bool lowerName() const { return hasFlag(enumName::name); }
+
+#define GENERIC_FLAG_GETTER_SETTER(enumName, lowerName, name) \
+ GENERIC_FLAG_GETTER(enumName, lowerName, name) \
+ void set##name() { setFlag(enumName::name); } \
+ void set##name(bool b) { setFlag(enumName::name, b); } \
+ void clear##name() { clearFlag(enumName::name); }
+
+#define IMMUTABLE_SCRIPT_FLAGS_WITH_ACCESSORS(_) \
+ _(ImmutableFlags, isForEval, IsForEval) \
+ _(ImmutableFlags, isModule, IsModule) \
+ _(ImmutableFlags, isFunction, IsFunction) \
+ _(ImmutableFlags, selfHosted, SelfHosted) \
+ _(ImmutableFlags, forceStrict, ForceStrict) \
+ _(ImmutableFlags, hasNonSyntacticScope, HasNonSyntacticScope) \
+ _(ImmutableFlags, noScriptRval, NoScriptRval) \
+ _(ImmutableFlags, treatAsRunOnce, TreatAsRunOnce) \
+ _(ImmutableFlags, strict, Strict) \
+ _(ImmutableFlags, hasModuleGoal, HasModuleGoal) \
+ _(ImmutableFlags, hasInnerFunctions, HasInnerFunctions) \
+ _(ImmutableFlags, hasDirectEval, HasDirectEval) \
+ _(ImmutableFlags, bindingsAccessedDynamically, BindingsAccessedDynamically) \
+ _(ImmutableFlags, hasCallSiteObj, HasCallSiteObj) \
+ _(ImmutableFlags, isAsync, IsAsync) \
+ _(ImmutableFlags, isGenerator, IsGenerator) \
+ _(ImmutableFlags, funHasExtensibleScope, FunHasExtensibleScope) \
+ _(ImmutableFlags, functionHasThisBinding, FunctionHasThisBinding) \
+ _(ImmutableFlags, needsHomeObject, NeedsHomeObject) \
+ _(ImmutableFlags, isDerivedClassConstructor, IsDerivedClassConstructor) \
+ _(ImmutableFlags, isSyntheticFunction, IsSyntheticFunction) \
+ _(ImmutableFlags, useMemberInitializers, UseMemberInitializers) \
+ _(ImmutableFlags, hasRest, HasRest) \
+ _(ImmutableFlags, needsFunctionEnvironmentObjects, \
+ NeedsFunctionEnvironmentObjects) \
+ _(ImmutableFlags, functionHasExtraBodyVarScope, \
+ FunctionHasExtraBodyVarScope) \
+ _(ImmutableFlags, shouldDeclareArguments, ShouldDeclareArguments) \
+ _(ImmutableFlags, needsArgsObj, NeedsArgsObj) \
+ _(ImmutableFlags, hasMappedArgsObj, HasMappedArgsObj) \
+ _(ImmutableFlags, isInlinableLargeFunction, IsInlinableLargeFunction) \
+ _(ImmutableFlags, functionHasNewTargetBinding, FunctionHasNewTargetBinding) \
+ _(ImmutableFlags, usesArgumentsIntrinsics, UsesArgumentsIntrinsics) \
+ \
+ GeneratorKind generatorKind() const { \
+ return isGenerator() ? GeneratorKind::Generator \
+ : GeneratorKind::NotGenerator; \
+ } \
+ \
+ FunctionAsyncKind asyncKind() const { \
+ return isAsync() ? FunctionAsyncKind::AsyncFunction \
+ : FunctionAsyncKind::SyncFunction; \
+ } \
+ \
+ bool isRelazifiable() const { \
+ /* \
+ ** A script may not be relazifiable if parts of it can be entrained in \
+ ** interesting ways: \
+ ** - Scripts with inner-functions or direct-eval (which can add \
+ ** inner-functions) should not be relazified as their Scopes may be \
+ ** part of another scope-chain. \
+ ** - Generators and async functions may be re-entered in complex ways so \
+ ** don't discard bytecode. The JIT resume code assumes this. \
+ ** - Functions with template literals must always return the same object \
+ ** instance so must not discard it by relazifying. \
+ */ \
+ return !hasInnerFunctions() && !hasDirectEval() && !isGenerator() && \
+ !isAsync() && !hasCallSiteObj(); \
+ }
+
+#define RO_IMMUTABLE_SCRIPT_FLAGS(Field) \
+ using ImmutableFlags = ImmutableScriptFlagsEnum; \
+ \
+ GENERIC_FLAGS_READ_ONLY(Field, ImmutableFlags) \
+ IMMUTABLE_SCRIPT_FLAGS_WITH_ACCESSORS(GENERIC_FLAG_GETTER)
+
+#define MUTABLE_SCRIPT_FLAGS_WITH_ACCESSORS(_) \
+ _(MutableFlags, hasRunOnce, HasRunOnce) \
+ _(MutableFlags, hasScriptCounts, HasScriptCounts) \
+ _(MutableFlags, hasDebugScript, HasDebugScript) \
+ _(MutableFlags, allowRelazify, AllowRelazify) \
+ _(MutableFlags, spewEnabled, SpewEnabled) \
+ _(MutableFlags, needsFinalWarmUpCount, NeedsFinalWarmUpCount) \
+ _(MutableFlags, failedBoundsCheck, FailedBoundsCheck) \
+ _(MutableFlags, hadLICMInvalidation, HadLICMInvalidation) \
+ _(MutableFlags, hadReorderingBailout, HadReorderingBailout) \
+ _(MutableFlags, hadEagerTruncationBailout, HadEagerTruncationBailout) \
+ _(MutableFlags, hadUnboxFoldingBailout, HadUnboxFoldingBailout) \
+ _(MutableFlags, baselineDisabled, BaselineDisabled) \
+ _(MutableFlags, ionDisabled, IonDisabled) \
+ _(MutableFlags, uninlineable, Uninlineable) \
+ _(MutableFlags, noEagerBaselineHint, NoEagerBaselineHint) \
+ _(MutableFlags, failedLexicalCheck, FailedLexicalCheck) \
+ _(MutableFlags, hadSpeculativePhiBailout, HadSpeculativePhiBailout)
+
+#define RW_MUTABLE_SCRIPT_FLAGS(Field) \
+ using MutableFlags = MutableScriptFlagsEnum; \
+ \
+ GENERIC_FLAGS_READ_WRITE(Field, MutableFlags) \
+ MUTABLE_SCRIPT_FLAGS_WITH_ACCESSORS(GENERIC_FLAG_GETTER_SETTER)
+
+// [SMDOC] JSScript data layout (immutable)
+//
+// ImmutableScriptData stores variable-length script data that may be shared
+// between scripts with the same bytecode, even across different GC Zones.
+// Abstractly this structure consists of multiple (optional) arrays that are
+// exposed as mozilla::Span<T>. These arrays exist in a single heap allocation.
+//
+// Under the hood, ImmutableScriptData is a fixed-size header class followed
+// the various array bodies interleaved with metadata to compactly encode the
+// bounds. These arrays have varying requirements for alignment, performance,
+// and jit-friendliness which leads to the complex indexing system below.
+//
+// Note: The '----' separators are for readability only.
+//
+// ----
+// <ImmutableScriptData itself>
+// ----
+// (REQUIRED) Flags structure
+// (REQUIRED) Array of jsbytecode constituting code()
+// (REQUIRED) Array of SrcNote constituting notes()
+// ----
+// (OPTIONAL) Array of uint32_t optional-offsets
+// optArrayOffset:
+// ----
+// L0:
+// (OPTIONAL) Array of uint32_t constituting resumeOffsets()
+// L1:
+// (OPTIONAL) Array of ScopeNote constituting scopeNotes()
+// L2:
+// (OPTIONAL) Array of TryNote constituting tryNotes()
+// L3:
+// ----
+//
+// NOTE: The notes() array must have been null-padded such that
+// flags/code/notes together have uint32_t alignment.
+//
+// The labels shown are recorded as byte-offsets relative to 'this'. This is to
+// reduce memory as well as make ImmutableScriptData easier to share across
+// processes.
+//
+// The L0/L1/L2/L3 labels indicate the start and end of the optional arrays.
+// Some of these labels may refer to the same location if the array between
+// them is empty. Each unique label position has an offset stored in the
+// optional-offsets table. Note that we also avoid entries for labels that
+// match 'optArrayOffset'. This saves memory when arrays are empty.
+//
+// The flags() data indicates (for each optional array) which entry from the
+// optional-offsets table marks the *end* of array. The array starts where the
+// previous array ends (with the first array beginning at 'optArrayOffset').
+// The optional-offset table is addressed at negative indices from
+// 'optArrayOffset'.
+//
+// In general, the length of each array is computed from subtracting the start
+// offset of the array from the start offset of the subsequent array. The
+// notable exception is that bytecode length is stored explicitly.
+class alignas(uint32_t) ImmutableScriptData final : public TrailingArray {
+ private:
+ Offset optArrayOffset_ = 0;
+
+ // Length of bytecode
+ uint32_t codeLength_ = 0;
+
+ public:
+ // Offset of main entry point from code, after predef'ing prologue.
+ uint32_t mainOffset = 0;
+
+ // Fixed frame slots.
+ uint32_t nfixed = 0;
+
+ // Slots plus maximum stack depth.
+ uint32_t nslots = 0;
+
+ // Index into the gcthings array of the body scope.
+ GCThingIndex bodyScopeIndex;
+
+ // Number of IC entries to allocate in JitScript for Baseline ICs.
+ uint32_t numICEntries = 0;
+
+ // ES6 function length.
+ uint16_t funLength = 0;
+
+ // Property Count estimate
+ uint16_t propertyCountEstimate = 0;
+
+ // NOTE: The raw bytes of this structure are used for hashing so use explicit
+ // padding values as needed for predicatable results across compilers
+
+ private:
+ struct Flags {
+ uint8_t resumeOffsetsEndIndex : 2;
+ uint8_t scopeNotesEndIndex : 2;
+ uint8_t tryNotesEndIndex : 2;
+ uint8_t _unused : 2;
+ };
+ static_assert(sizeof(Flags) == sizeof(uint8_t),
+ "Structure packing is broken");
+
+ // Offsets (in bytes) from 'this' to each component array. The delta between
+ // each offset and the next offset is the size of each array and is defined
+ // even if an array is empty.
+ Offset flagOffset() const { return offsetOfCode() - sizeof(Flags); }
+ Offset codeOffset() const { return offsetOfCode(); }
+ Offset noteOffset() const { return offsetOfCode() + codeLength_; }
+ Offset optionalOffsetsOffset() const {
+ // Determine the location to beginning of optional-offsets array by looking
+ // at index for try-notes.
+ //
+ // optionalOffsetsOffset():
+ // (OPTIONAL) tryNotesEndOffset
+ // (OPTIONAL) scopeNotesEndOffset
+ // (OPTIONAL) resumeOffsetsEndOffset
+ // optArrayOffset_:
+ // ....
+ unsigned numOffsets = flags().tryNotesEndIndex;
+ MOZ_ASSERT(numOffsets >= flags().scopeNotesEndIndex);
+ MOZ_ASSERT(numOffsets >= flags().resumeOffsetsEndIndex);
+
+ return optArrayOffset_ - (numOffsets * sizeof(Offset));
+ }
+ Offset resumeOffsetsOffset() const { return optArrayOffset_; }
+ Offset scopeNotesOffset() const {
+ return getOptionalOffset(flags().resumeOffsetsEndIndex);
+ }
+ Offset tryNotesOffset() const {
+ return getOptionalOffset(flags().scopeNotesEndIndex);
+ }
+ Offset endOffset() const {
+ return getOptionalOffset(flags().tryNotesEndIndex);
+ }
+
+ void initOptionalArrays(Offset* cursor, uint32_t numResumeOffsets,
+ uint32_t numScopeNotes, uint32_t numTryNotes);
+
+ // Initialize to GC-safe state
+ ImmutableScriptData(uint32_t codeLength, uint32_t noteLength,
+ uint32_t numResumeOffsets, uint32_t numScopeNotes,
+ uint32_t numTryNotes);
+
+ void setOptionalOffset(int index, Offset offset) {
+ MOZ_ASSERT(index > 0);
+ MOZ_ASSERT(offset != optArrayOffset_, "Do not store implicit offset");
+ offsetToPointer<Offset>(optArrayOffset_)[-index] = offset;
+ }
+ Offset getOptionalOffset(int index) const {
+ // The index 0 represents (implicitly) the offset 'optArrayOffset_'.
+ if (index == 0) {
+ return optArrayOffset_;
+ }
+
+ ImmutableScriptData* this_ = const_cast<ImmutableScriptData*>(this);
+ return this_->offsetToPointer<Offset>(optArrayOffset_)[-index];
+ }
+
+ public:
+ static js::UniquePtr<ImmutableScriptData> new_(
+ FrontendContext* fc, uint32_t mainOffset, uint32_t nfixed,
+ uint32_t nslots, GCThingIndex bodyScopeIndex, uint32_t numICEntries,
+ bool isFunction, uint16_t funLength, uint16_t propertyCountEstimate,
+ mozilla::Span<const jsbytecode> code, mozilla::Span<const SrcNote> notes,
+ mozilla::Span<const uint32_t> resumeOffsets,
+ mozilla::Span<const ScopeNote> scopeNotes,
+ mozilla::Span<const TryNote> tryNotes);
+
+ static js::UniquePtr<ImmutableScriptData> new_(
+ FrontendContext* fc, uint32_t codeLength, uint32_t noteLength,
+ uint32_t numResumeOffsets, uint32_t numScopeNotes, uint32_t numTryNotes);
+
+ static js::UniquePtr<ImmutableScriptData> new_(FrontendContext* fc,
+ uint32_t totalSize);
+
+ // Validate internal offsets of the data structure seems reasonable. This is
+ // for diagnositic purposes only to detect severe corruption. This is not a
+ // security boundary!
+ bool validateLayout(uint32_t expectedSize);
+
+ private:
+ static mozilla::CheckedInt<uint32_t> sizeFor(uint32_t codeLength,
+ uint32_t noteLength,
+ uint32_t numResumeOffsets,
+ uint32_t numScopeNotes,
+ uint32_t numTryNotes);
+
+ public:
+ // The code() and note() arrays together maintain an target alignment by
+ // padding the source notes with null. This allows arrays with stricter
+ // alignment requirements to follow them.
+ static constexpr size_t CodeNoteAlign = sizeof(uint32_t);
+
+ // Compute number of null notes to pad out source notes with.
+ static uint32_t ComputeNotePadding(uint32_t codeLength, uint32_t noteLength) {
+ uint32_t flagLength = sizeof(Flags);
+ uint32_t nullLength =
+ CodeNoteAlign - (flagLength + codeLength + noteLength) % CodeNoteAlign;
+
+ // The source notes must have at least one null-terminator.
+ MOZ_ASSERT(nullLength >= 1);
+
+ return nullLength;
+ }
+
+ // Span over all raw bytes in this struct and its trailing arrays.
+ mozilla::Span<const uint8_t> immutableData() const {
+ size_t allocSize = endOffset();
+ return mozilla::Span{reinterpret_cast<const uint8_t*>(this), allocSize};
+ }
+
+ private:
+ Flags& flagsRef() { return *offsetToPointer<Flags>(flagOffset()); }
+ const Flags& flags() const {
+ return const_cast<ImmutableScriptData*>(this)->flagsRef();
+ }
+
+ public:
+ uint32_t codeLength() const { return codeLength_; }
+ jsbytecode* code() { return offsetToPointer<jsbytecode>(codeOffset()); }
+ mozilla::Span<jsbytecode> codeSpan() { return {code(), codeLength()}; }
+
+ uint32_t noteLength() const {
+ return numElements<SrcNote>(noteOffset(), optionalOffsetsOffset());
+ }
+ SrcNote* notes() { return offsetToPointer<SrcNote>(noteOffset()); }
+ mozilla::Span<SrcNote> notesSpan() { return {notes(), noteLength()}; }
+
+ mozilla::Span<uint32_t> resumeOffsets() {
+ return mozilla::Span{offsetToPointer<uint32_t>(resumeOffsetsOffset()),
+ offsetToPointer<uint32_t>(scopeNotesOffset())};
+ }
+ mozilla::Span<ScopeNote> scopeNotes() {
+ return mozilla::Span{offsetToPointer<ScopeNote>(scopeNotesOffset()),
+ offsetToPointer<ScopeNote>(tryNotesOffset())};
+ }
+ mozilla::Span<TryNote> tryNotes() {
+ return mozilla::Span{offsetToPointer<TryNote>(tryNotesOffset()),
+ offsetToPointer<TryNote>(endOffset())};
+ }
+
+ // Expose offsets to the JITs.
+ static constexpr size_t offsetOfCode() {
+ return sizeof(ImmutableScriptData) + sizeof(Flags);
+ }
+ static constexpr size_t offsetOfResumeOffsetsOffset() {
+ // Resume-offsets are the first optional array if they exist. Locate the
+ // array with the 'optArrayOffset_' field.
+ static_assert(sizeof(Offset) == sizeof(uint32_t),
+ "JIT expect Offset to be uint32_t");
+ return offsetof(ImmutableScriptData, optArrayOffset_);
+ }
+ static constexpr size_t offsetOfNfixed() {
+ return offsetof(ImmutableScriptData, nfixed);
+ }
+ static constexpr size_t offsetOfNslots() {
+ return offsetof(ImmutableScriptData, nslots);
+ }
+ static constexpr size_t offsetOfFunLength() {
+ return offsetof(ImmutableScriptData, funLength);
+ }
+
+ // ImmutableScriptData has trailing data so isn't copyable or movable.
+ ImmutableScriptData(const ImmutableScriptData&) = delete;
+ ImmutableScriptData& operator=(const ImmutableScriptData&) = delete;
+};
+
+// Wrapper type for ImmutableScriptData to allow sharing across a JSRuntime.
+//
+// Note: This is distinct from ImmutableScriptData because it contains a mutable
+// ref-count while the ImmutableScriptData may live in read-only memory.
+//
+// Note: This is *not* directly inlined into the SharedImmutableScriptDataTable
+// because scripts point directly to object and table resizing moves
+// entries. This allows for fast finalization by decrementing the
+// ref-count directly without doing a hash-table lookup.
+class SharedImmutableScriptData {
+ static constexpr uint32_t IsExternalFlag = 0x80000000;
+ static constexpr uint32_t RefCountBits = 0x7FFFFFFF;
+
+ // This class is reference counted as follows: each pointer from a JSScript
+ // counts as one reference plus there may be one reference from the shared
+ // script data table.
+ mozilla::Atomic<uint32_t, mozilla::SequentiallyConsistent>
+ refCountAndExternalFlags_ = {};
+
+ mozilla::HashNumber hash_;
+ ImmutableScriptData* isd_ = nullptr;
+
+ // End of fields.
+
+ friend class ::JSScript;
+ friend class js::frontend::StencilXDR;
+
+ public:
+ SharedImmutableScriptData() = default;
+
+ ~SharedImmutableScriptData() { reset(); }
+
+ private:
+ bool isExternal() const { return refCountAndExternalFlags_ & IsExternalFlag; }
+ void setIsExternal() { refCountAndExternalFlags_ |= IsExternalFlag; }
+ void unsetIsExternal() { refCountAndExternalFlags_ &= RefCountBits; }
+
+ void reset() {
+ if (isd_ && !isExternal()) {
+ js_delete(isd_);
+ }
+ isd_ = nullptr;
+ }
+
+ mozilla::HashNumber calculateHash() const {
+ mozilla::Span<const uint8_t> immutableData = isd_->immutableData();
+ return mozilla::HashBytes(immutableData.data(), immutableData.size());
+ }
+
+ public:
+ // Hash over the contents of SharedImmutableScriptData and its
+ // ImmutableScriptData.
+ struct Hasher;
+
+ uint32_t refCount() const { return refCountAndExternalFlags_ & RefCountBits; }
+ void AddRef() { refCountAndExternalFlags_++; }
+
+ private:
+ uint32_t decrementRef() {
+ MOZ_ASSERT(refCount() != 0);
+ return --refCountAndExternalFlags_ & RefCountBits;
+ }
+
+ public:
+ void Release() {
+ uint32_t remain = decrementRef();
+ if (remain == 0) {
+ reset();
+ js_free(this);
+ }
+ }
+
+ static constexpr size_t offsetOfISD() {
+ return offsetof(SharedImmutableScriptData, isd_);
+ }
+
+ private:
+ static SharedImmutableScriptData* create(FrontendContext* fc);
+
+ public:
+ static SharedImmutableScriptData* createWith(
+ FrontendContext* fc, js::UniquePtr<ImmutableScriptData>&& isd);
+
+ size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) {
+ size_t isdSize = isExternal() ? 0 : mallocSizeOf(isd_);
+ return mallocSizeOf(this) + isdSize;
+ }
+
+ // SharedImmutableScriptData has trailing data so isn't copyable or movable.
+ SharedImmutableScriptData(const SharedImmutableScriptData&) = delete;
+ SharedImmutableScriptData& operator=(const SharedImmutableScriptData&) =
+ delete;
+
+ static bool shareScriptData(FrontendContext* fc,
+ RefPtr<SharedImmutableScriptData>& sisd);
+
+ size_t immutableDataLength() const { return isd_->immutableData().Length(); }
+ uint32_t nfixed() const { return isd_->nfixed; }
+
+ ImmutableScriptData* get() { return isd_; }
+ mozilla::HashNumber hash() const { return hash_; }
+
+ void setOwn(js::UniquePtr<ImmutableScriptData>&& isd) {
+ MOZ_ASSERT(!isd_);
+ isd_ = isd.release();
+ unsetIsExternal();
+
+ hash_ = calculateHash();
+ }
+
+ void setOwn(js::UniquePtr<ImmutableScriptData>&& isd,
+ mozilla::HashNumber hash) {
+ MOZ_ASSERT(!isd_);
+ isd_ = isd.release();
+ unsetIsExternal();
+
+ MOZ_ASSERT(hash == calculateHash());
+ hash_ = hash;
+ }
+
+ void setExternal(ImmutableScriptData* isd) {
+ MOZ_ASSERT(!isd_);
+ isd_ = isd;
+ setIsExternal();
+
+ hash_ = calculateHash();
+ }
+
+ void setExternal(ImmutableScriptData* isd, mozilla::HashNumber hash) {
+ MOZ_ASSERT(!isd_);
+ isd_ = isd;
+ setIsExternal();
+
+ MOZ_ASSERT(hash == calculateHash());
+ hash_ = hash;
+ }
+};
+
+// Matches SharedImmutableScriptData objects that have the same atoms as well as
+// contain the same bytes in their ImmutableScriptData.
+struct SharedImmutableScriptData::Hasher {
+ using Lookup = RefPtr<SharedImmutableScriptData>;
+
+ static mozilla::HashNumber hash(const Lookup& l) { return l->hash(); }
+
+ static bool match(SharedImmutableScriptData* entry, const Lookup& lookup) {
+ return (entry->isd_->immutableData() == lookup->isd_->immutableData());
+ }
+};
+
+using SharedImmutableScriptDataTable =
+ mozilla::HashSet<SharedImmutableScriptData*,
+ SharedImmutableScriptData::Hasher, SystemAllocPolicy>;
+
+struct MemberInitializers {
+ static constexpr size_t NumBits = 31;
+ static constexpr uint32_t MaxInitializers = BitMask(NumBits);
+
+#ifdef DEBUG
+ bool valid = false;
+#endif
+
+ bool hasPrivateBrand : 1;
+
+ // This struct will eventually have a vector of constant values for optimizing
+ // field initializers.
+ uint32_t numMemberInitializers : NumBits;
+
+ MemberInitializers(bool hasPrivateBrand, uint32_t numMemberInitializers)
+ :
+#ifdef DEBUG
+ valid(true),
+#endif
+ hasPrivateBrand(hasPrivateBrand),
+ numMemberInitializers(numMemberInitializers) {
+ MOZ_ASSERT(
+ this->numMemberInitializers == numMemberInitializers,
+ "numMemberInitializers should easily fit in the 31-bit bitfield");
+ }
+
+ static MemberInitializers Invalid() { return MemberInitializers(); }
+
+ // Singleton to use for class constructors that do not have to initialize any
+ // fields. This is used when we elide the trivial data but still need a valid
+ // set to stop scope walking.
+ static const MemberInitializers& Empty() {
+ static const MemberInitializers zeroInitializers(false, 0);
+ return zeroInitializers;
+ }
+
+ uint32_t serialize() const {
+ return (hasPrivateBrand << NumBits) | numMemberInitializers;
+ }
+
+ static MemberInitializers deserialize(uint32_t bits) {
+ return MemberInitializers((bits & Bit(NumBits)) != 0,
+ bits & BitMask(NumBits));
+ }
+
+ private:
+ MemberInitializers()
+ :
+#ifdef DEBUG
+ valid(false),
+#endif
+ hasPrivateBrand(false),
+ numMemberInitializers(0) {
+ }
+};
+
+// See JSOp::Lambda for interepretation of this index.
+using FunctionDeclaration = GCThingIndex;
+// Defined here to avoid #include cycle with Stencil.h.
+using FunctionDeclarationVector =
+ Vector<FunctionDeclaration, 0, js::SystemAllocPolicy>;
+
+} // namespace js
+
+#endif /* vm_SharedStencil_h */