Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sw=2 et tw=0 ft=c:
*
* 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
#ifndef frontend_ObjLiteral_h
#define frontend_ObjLiteral_h
#include "mozilla/BloomFilter.h" // mozilla::BitBloomFilter
#include "mozilla/Span.h"
#include "frontend/ParserAtom.h" // ParserAtomsTable, TaggedParserAtomIndex, ParserAtom
#include "js/AllocPolicy.h"
#include "js/Value.h"
#include "js/Vector.h"
#include "util/EnumFlags.h"
#include "vm/BytecodeUtil.h"
#include "vm/Opcodes.h"
/*
* [SMDOC] ObjLiteral (Object Literal) Handling
* ============================================
*
* The `ObjLiteral*` family of classes defines an infastructure to handle
* object literals as they are encountered at parse time and translate them
* into objects or shapes that are attached to the bytecode.
*
* The object-literal "instructions", whose opcodes are defined in
* `ObjLiteralOpcode` below, each specify one key (atom property name, or
* numeric index) and one value. An `ObjLiteralWriter` buffers a linear
* sequence of such instructions, along with a side-table of atom references.
* The writer stores a compact binary format that is then interpreted by the
* `ObjLiteralReader` to construct an object or shape according to the
* instructions.
*
* This may seem like an odd dance: create an intermediate data structure that
* specifies key/value pairs, then later build the object/shape. Why not just do
* so directly, as we parse? In fact, we used to do this. However, for several
* good reasons, we want to avoid allocating or touching GC things at all
* *during* the parse. We thus use a sequence of ObjLiteral instructions as an
* intermediate data structure to carry object literal contents from parse to
* the time at which we *can* allocate GC things.
*
* (The original intent was to allow for ObjLiteral instructions to actually be
* invoked by a new JS opcode, JSOp::ObjLiteral, thus replacing the more
* general opcode sequences sometimes generated to fill in objects and removing
* the need to attach actual objects to JSOp::Object or JSOp::NewObject.
* However, this was far too invasive and led to performance regressions, so
* currently ObjLiteral only carries literals as far as the end of the parse
* pipeline, when all GC things are allocated.)
*
* ObjLiteral data structures are used to represent object literals whenever
* they are "compatible". See
* BytecodeEmitter::isPropertyListObjLiteralCompatible for the precise
* conditions; in brief, we can represent object literals with "primitive"
* (numeric, boolean, string, null/undefined) values, and "normal"
* (non-computed) object names. We can also represent arrays with the same
* value restrictions. We cannot represent nested objects. We use ObjLiteral in
* two different ways:
*
* - To build a template shape, when we can support the property keys but not
* the property values.
* - To build the actual result object, when we support the property keys and
* the values and this is a JSOp::Object case (see below).
*
* Design and Performance Considerations
* -------------------------------------
*
* As a brief overview, there are a number of opcodes that allocate objects:
*
* - JSOp::NewInit allocates a new empty `{}` object.
*
* - JSOp::NewObject, with a shape as an argument (held by the script data
* side-tables), allocates a new object with the given `shape` (property keys)
* and `undefined` property values.
*
* - JSOp::Object, with an object as argument, instructs the runtime to
* literally return the object argument as the result. This is thus only an
* "allocation" in the sense that the object was originally allocated when
* the script data / bytecode was created. It is only used when we know for
* sure that the script, and this program point within the script, will run
* *once*. (See the `treatAsRunOnce` flag on JSScript.)
*
* An operation occurs in a "singleton context", according to the parser, if it
* will only ever execute once. In particular, this happens when (i) the script
* is a "run-once" script, which is usually the case for e.g. top-level scripts
* of web-pages (they run on page load, but no function or handle wraps or
* refers to the script so it can't be invoked again), and (ii) the operation
* itself is not within a loop or function in that run-once script.
*
* When we encounter an object literal, we decide which opcode to use, and we
* construct the ObjLiteral and the bytecode using its result appropriately:
*
* - If in a singleton context, and if we support the values, we use
* JSOp::Object and we build the ObjLiteral instructions with values.
* - Otherwise, if we support the keys but not the values, or if we are not
* in a singleton context, we use JSOp::NewObject. In this case, the initial
* opcode only creates an object with empty values, so BytecodeEmitter then
* generates bytecode to set the values appropriately.
* - Otherwise, we generate JSOp::NewInit and bytecode to add properties one at
* a time. This will always work, but is the slowest and least
* memory-efficient option.
*/
namespace js {
class FrontendContext;
class JSONPrinter;
class LifoAlloc;
namespace frontend {
struct CompilationAtomCache;
struct CompilationStencil;
class StencilXDR;
} // namespace frontend
// Object-literal instruction opcodes. An object literal is constructed by a
// straight-line sequence of these ops, each adding one property to the
// object.
enum class ObjLiteralOpcode : uint8_t {
INVALID = 0,
ConstValue = 1, // numeric types only.
ConstString = 2,
Null = 3,
Undefined = 4,
True = 5,
False = 6,
MAX = False,
};
// The kind of GC thing constructed by the ObjLiteral framework and stored in
// the script data.
enum class ObjLiteralKind : uint8_t {
// Construct an ArrayObject from a list of dense elements.
Array,
// Construct an ArrayObject (the call site object) for a tagged template call
// from a list of dense elements for the cooked array followed by the dense
// elements for the `.raw` array.
CallSiteObj,
// Construct a PlainObject from a list of property keys/values.
Object,
// Construct a PlainObject Shape from a list of property keys.
Shape,
// Invalid sentinel value. Must be the last enum value.
Invalid
};
// Flags that are associated with a sequence of object-literal instructions.
// (These become bitflags by wrapping with EnumSet below.)
enum class ObjLiteralFlag : uint8_t {
// If set, this object contains index property, or duplicate non-index
// property.
// This flag is valid only if the ObjLiteralKind is not Array.
HasIndexOrDuplicatePropName = 1 << 0,
// Note: at most 6 flags are currently supported. See ObjLiteralKindAndFlags.
};
using ObjLiteralFlags = EnumFlags<ObjLiteralFlag>;
// Helper class to encode ObjLiteralKind and ObjLiteralFlags in a single byte.
class ObjLiteralKindAndFlags {
uint8_t bits_ = 0;
static constexpr size_t KindBits = 3;
static constexpr size_t KindMask = BitMask(KindBits);
static_assert(size_t(ObjLiteralKind::Invalid) <= KindMask,
"ObjLiteralKind needs more bits");
public:
ObjLiteralKindAndFlags() = default;
ObjLiteralKindAndFlags(ObjLiteralKind kind, ObjLiteralFlags flags)
: bits_(size_t(kind) | (flags.toRaw() << KindBits)) {
MOZ_ASSERT(this->kind() == kind);
MOZ_ASSERT(this->flags() == flags);
}
ObjLiteralKind kind() const { return ObjLiteralKind(bits_ & KindMask); }
ObjLiteralFlags flags() const {
ObjLiteralFlags res;
res.setRaw(bits_ >> KindBits);
return res;
}
uint8_t toRaw() const { return bits_; }
void setRaw(uint8_t bits) { bits_ = bits; }
};
inline bool ObjLiteralOpcodeHasValueArg(ObjLiteralOpcode op) {
return op == ObjLiteralOpcode::ConstValue;
}
inline bool ObjLiteralOpcodeHasAtomArg(ObjLiteralOpcode op) {
return op == ObjLiteralOpcode::ConstString;
}
struct ObjLiteralReaderBase;
// Property name (as TaggedParserAtomIndex) or an integer index. Only used for
// object-type literals; array literals do not require the index (the sequence
// is always dense, with no holes, so the index is implicit). For the latter
// case, we have a `None` placeholder.
struct ObjLiteralKey {
private:
uint32_t value_;
enum ObjLiteralKeyType {
None,
AtomIndex,
ArrayIndex,
};
ObjLiteralKeyType type_;
ObjLiteralKey(uint32_t value, ObjLiteralKeyType ty)
: value_(value), type_(ty) {}
public:
ObjLiteralKey() : ObjLiteralKey(0, None) {}
ObjLiteralKey(uint32_t value, bool isArrayIndex)
: ObjLiteralKey(value, isArrayIndex ? ArrayIndex : AtomIndex) {}
ObjLiteralKey(const ObjLiteralKey& other) = default;
static ObjLiteralKey fromPropName(frontend::TaggedParserAtomIndex atomIndex) {
return ObjLiteralKey(atomIndex.rawData(), false);
}
static ObjLiteralKey fromArrayIndex(uint32_t index) {
return ObjLiteralKey(index, true);
}
static ObjLiteralKey none() { return ObjLiteralKey(); }
bool isNone() const { return type_ == None; }
bool isAtomIndex() const { return type_ == AtomIndex; }
bool isArrayIndex() const { return type_ == ArrayIndex; }
frontend::TaggedParserAtomIndex getAtomIndex() const {
MOZ_ASSERT(isAtomIndex());
return frontend::TaggedParserAtomIndex::fromRaw(value_);
}
uint32_t getArrayIndex() const {
MOZ_ASSERT(isArrayIndex());
return value_;
}
uint32_t rawIndex() const { return value_; }
};
struct ObjLiteralWriterBase {
protected:
friend struct ObjLiteralReaderBase; // for access to mask and shift.
static const uint32_t ATOM_INDEX_MASK = 0x7fffffff;
// If set, the atom index field is an array index, not an atom index.
static const uint32_t INDEXED_PROP = 0x80000000;
public:
using CodeVector = Vector<uint8_t, 64, js::SystemAllocPolicy>;
protected:
CodeVector code_;
public:
ObjLiteralWriterBase() = default;
uint32_t curOffset() const { return code_.length(); }
private:
[[nodiscard]] bool pushByte(FrontendContext* fc, uint8_t data) {
if (!code_.append(data)) {
js::ReportOutOfMemory(fc);
return false;
}
return true;
}
[[nodiscard]] bool prepareBytes(FrontendContext* fc, size_t len,
uint8_t** p) {
size_t offset = code_.length();
if (!code_.growByUninitialized(len)) {
js::ReportOutOfMemory(fc);
return false;
}
*p = &code_[offset];
return true;
}
template <typename T>
[[nodiscard]] bool pushRawData(FrontendContext* fc, T data) {
uint8_t* p = nullptr;
if (!prepareBytes(fc, sizeof(T), &p)) {
return false;
}
memcpy(p, &data, sizeof(T));
return true;
}
protected:
[[nodiscard]] bool pushOpAndName(FrontendContext* fc, ObjLiteralOpcode op,
ObjLiteralKey key) {
uint8_t opdata = static_cast<uint8_t>(op);
uint32_t data = key.rawIndex() | (key.isArrayIndex() ? INDEXED_PROP : 0);
return pushByte(fc, opdata) && pushRawData(fc, data);
}
[[nodiscard]] bool pushValueArg(FrontendContext* fc, const JS::Value& value) {
MOZ_ASSERT(value.isNumber() || value.isNullOrUndefined() ||
value.isBoolean());
uint64_t data = value.asRawBits();
return pushRawData(fc, data);
}
[[nodiscard]] bool pushAtomArg(FrontendContext* fc,
frontend::TaggedParserAtomIndex atomIndex) {
return pushRawData(fc, atomIndex.rawData());
}
};
// An object-literal instruction writer. This class, held by the bytecode
// emitter, keeps a sequence of object-literal instructions emitted as object
// literal expressions are parsed. It allows the user to 'begin' and 'end'
// straight-line sequences, returning the offsets for this range of instructions
// within the writer.
struct ObjLiteralWriter : private ObjLiteralWriterBase {
public:
ObjLiteralWriter() = default;
void clear() { code_.clear(); }
using CodeVector = typename ObjLiteralWriterBase::CodeVector;
bool checkForDuplicatedNames(FrontendContext* fc);
mozilla::Span<const uint8_t> getCode() const { return code_; }
ObjLiteralKind getKind() const { return kind_; }
ObjLiteralFlags getFlags() const { return flags_; }
uint32_t getPropertyCount() const { return propertyCount_; }
void beginArray(JSOp op) {
MOZ_ASSERT(JOF_OPTYPE(op) == JOF_OBJECT);
MOZ_ASSERT(op == JSOp::Object);
kind_ = ObjLiteralKind::Array;
}
void beginCallSiteObj(JSOp op) {
MOZ_ASSERT(JOF_OPTYPE(op) == JOF_OBJECT);
MOZ_ASSERT(op == JSOp::CallSiteObj);
kind_ = ObjLiteralKind::CallSiteObj;
}
void beginObject(JSOp op) {
MOZ_ASSERT(JOF_OPTYPE(op) == JOF_OBJECT);
MOZ_ASSERT(op == JSOp::Object);
kind_ = ObjLiteralKind::Object;
}
void beginShape(JSOp op) {
MOZ_ASSERT(JOF_OPTYPE(op) == JOF_SHAPE);
MOZ_ASSERT(op == JSOp::NewObject);
kind_ = ObjLiteralKind::Shape;
}
bool setPropName(frontend::ParserAtomsTable& parserAtoms,
const frontend::TaggedParserAtomIndex propName) {
// Only valid in object-mode.
setPropNameNoDuplicateCheck(parserAtoms, propName);
if (flags_.hasFlag(ObjLiteralFlag::HasIndexOrDuplicatePropName)) {
return true;
}
// OK to early return if we've already discovered a potential duplicate.
if (mightContainDuplicatePropertyNames_) {
return true;
}
// Check bloom filter for duplicate, and add if not already represented.
if (propNamesFilter_.mightContain(propName.rawData())) {
mightContainDuplicatePropertyNames_ = true;
} else {
propNamesFilter_.add(propName.rawData());
}
return true;
}
void setPropNameNoDuplicateCheck(
frontend::ParserAtomsTable& parserAtoms,
const frontend::TaggedParserAtomIndex propName) {
MOZ_ASSERT(kind_ == ObjLiteralKind::Object ||
kind_ == ObjLiteralKind::Shape);
parserAtoms.markUsedByStencil(propName, frontend::ParserAtom::Atomize::Yes);
nextKey_ = ObjLiteralKey::fromPropName(propName);
}
void setPropIndex(uint32_t propIndex) {
MOZ_ASSERT(kind_ == ObjLiteralKind::Object);
MOZ_ASSERT(propIndex <= ATOM_INDEX_MASK);
nextKey_ = ObjLiteralKey::fromArrayIndex(propIndex);
flags_.setFlag(ObjLiteralFlag::HasIndexOrDuplicatePropName);
}
void beginDenseArrayElements() {
MOZ_ASSERT(kind_ == ObjLiteralKind::Array ||
kind_ == ObjLiteralKind::CallSiteObj);
// Dense array element sequences do not use the keys; the indices are
// implicit.
nextKey_ = ObjLiteralKey::none();
}
[[nodiscard]] bool propWithConstNumericValue(FrontendContext* fc,
const JS::Value& value) {
MOZ_ASSERT(kind_ != ObjLiteralKind::Shape);
propertyCount_++;
MOZ_ASSERT(value.isNumber());
return pushOpAndName(fc, ObjLiteralOpcode::ConstValue, nextKey_) &&
pushValueArg(fc, value);
}
[[nodiscard]] bool propWithAtomValue(
FrontendContext* fc, frontend::ParserAtomsTable& parserAtoms,
const frontend::TaggedParserAtomIndex value) {
MOZ_ASSERT(kind_ != ObjLiteralKind::Shape);
propertyCount_++;
parserAtoms.markUsedByStencil(value, frontend::ParserAtom::Atomize::No);
return pushOpAndName(fc, ObjLiteralOpcode::ConstString, nextKey_) &&
pushAtomArg(fc, value);
}
[[nodiscard]] bool propWithNullValue(FrontendContext* fc) {
MOZ_ASSERT(kind_ != ObjLiteralKind::Shape);
propertyCount_++;
return pushOpAndName(fc, ObjLiteralOpcode::Null, nextKey_);
}
[[nodiscard]] bool propWithUndefinedValue(FrontendContext* fc) {
propertyCount_++;
return pushOpAndName(fc, ObjLiteralOpcode::Undefined, nextKey_);
}
[[nodiscard]] bool propWithTrueValue(FrontendContext* fc) {
MOZ_ASSERT(kind_ != ObjLiteralKind::Shape);
propertyCount_++;
return pushOpAndName(fc, ObjLiteralOpcode::True, nextKey_);
}
[[nodiscard]] bool propWithFalseValue(FrontendContext* fc) {
MOZ_ASSERT(kind_ != ObjLiteralKind::Shape);
propertyCount_++;
return pushOpAndName(fc, ObjLiteralOpcode::False, nextKey_);
}
static bool arrayIndexInRange(int32_t i) {
return i >= 0 && static_cast<uint32_t>(i) <= ATOM_INDEX_MASK;
}
#if defined(DEBUG) || defined(JS_JITSPEW)
void dump() const;
void dump(JSONPrinter& json,
const frontend::CompilationStencil* stencil) const;
void dumpFields(JSONPrinter& json,
const frontend::CompilationStencil* stencil) const;
#endif
private:
// Set to true if we've found possible duplicate names while building.
// This field is placed next to `flags_` field, to reduce padding.
bool mightContainDuplicatePropertyNames_ = false;
ObjLiteralKind kind_ = ObjLiteralKind::Invalid;
ObjLiteralFlags flags_;
ObjLiteralKey nextKey_;
uint32_t propertyCount_ = 0;
// Duplicate property names detection is performed in the following way:
// * while emitting code, add each property names with
// `propNamesFilter_`
// * if possible duplicate property name is detected, set
// `mightContainDuplicatePropertyNames_` to true
// * in `checkForDuplicatedNames` method,
// if `mightContainDuplicatePropertyNames_` is true,
// check the duplicate property names with `HashSet`, and if it exists,
// set HasIndexOrDuplicatePropName flag.
mozilla::BitBloomFilter<12, frontend::TaggedParserAtomIndex> propNamesFilter_;
};
struct ObjLiteralReaderBase {
private:
mozilla::Span<const uint8_t> data_;
size_t cursor_;
[[nodiscard]] bool readByte(uint8_t* b) {
if (cursor_ + 1 > data_.Length()) {
return false;
}
*b = *data_.From(cursor_).data();
cursor_ += 1;
return true;
}
[[nodiscard]] bool readBytes(size_t size, const uint8_t** p) {
if (cursor_ + size > data_.Length()) {
return false;
}
*p = data_.From(cursor_).data();
cursor_ += size;
return true;
}
template <typename T>
[[nodiscard]] bool readRawData(T* data) {
const uint8_t* p = nullptr;
if (!readBytes(sizeof(T), &p)) {
return false;
}
memcpy(data, p, sizeof(T));
return true;
}
public:
explicit ObjLiteralReaderBase(mozilla::Span<const uint8_t> data)
: data_(data), cursor_(0) {}
[[nodiscard]] bool readOpAndKey(ObjLiteralOpcode* op, ObjLiteralKey* key) {
uint8_t opbyte;
if (!readByte(&opbyte)) {
return false;
}
if (MOZ_UNLIKELY(opbyte > static_cast<uint8_t>(ObjLiteralOpcode::MAX))) {
return false;
}
*op = static_cast<ObjLiteralOpcode>(opbyte);
uint32_t data;
if (!readRawData(&data)) {
return false;
}
bool isArray = data & ObjLiteralWriterBase::INDEXED_PROP;
uint32_t rawIndex = data & ~ObjLiteralWriterBase::INDEXED_PROP;
*key = ObjLiteralKey(rawIndex, isArray);
return true;
}
[[nodiscard]] bool readValueArg(JS::Value* value) {
uint64_t data;
if (!readRawData(&data)) {
return false;
}
*value = JS::Value::fromRawBits(data);
return true;
}
[[nodiscard]] bool readAtomArg(frontend::TaggedParserAtomIndex* atomIndex) {
return readRawData(atomIndex->rawDataRef());
}
size_t cursor() const { return cursor_; }
};
// A single object-literal instruction, creating one property on an object.
struct ObjLiteralInsn {
private:
ObjLiteralOpcode op_;
ObjLiteralKey key_;
union Arg {
explicit Arg(uint64_t raw_) : raw(raw_) {}
JS::Value constValue;
frontend::TaggedParserAtomIndex atomIndex;
uint64_t raw;
} arg_;
public:
ObjLiteralInsn() : op_(ObjLiteralOpcode::INVALID), arg_(0) {}
ObjLiteralInsn(ObjLiteralOpcode op, ObjLiteralKey key)
: op_(op), key_(key), arg_(0) {
MOZ_ASSERT(!hasConstValue());
MOZ_ASSERT(!hasAtomIndex());
}
ObjLiteralInsn(ObjLiteralOpcode op, ObjLiteralKey key, const JS::Value& value)
: op_(op), key_(key), arg_(0) {
MOZ_ASSERT(hasConstValue());
MOZ_ASSERT(!hasAtomIndex());
arg_.constValue = value;
}
ObjLiteralInsn(ObjLiteralOpcode op, ObjLiteralKey key,
frontend::TaggedParserAtomIndex atomIndex)
: op_(op), key_(key), arg_(0) {
MOZ_ASSERT(!hasConstValue());
MOZ_ASSERT(hasAtomIndex());
arg_.atomIndex = atomIndex;
}
ObjLiteralInsn(const ObjLiteralInsn& other) : ObjLiteralInsn() {
*this = other;
}
ObjLiteralInsn& operator=(const ObjLiteralInsn& other) {
op_ = other.op_;
key_ = other.key_;
arg_.raw = other.arg_.raw;
return *this;
}
bool isValid() const {
return op_ > ObjLiteralOpcode::INVALID && op_ <= ObjLiteralOpcode::MAX;
}
ObjLiteralOpcode getOp() const {
MOZ_ASSERT(isValid());
return op_;
}
const ObjLiteralKey& getKey() const {
MOZ_ASSERT(isValid());
return key_;
}
bool hasConstValue() const {
MOZ_ASSERT(isValid());
return ObjLiteralOpcodeHasValueArg(op_);
}
bool hasAtomIndex() const {
MOZ_ASSERT(isValid());
return ObjLiteralOpcodeHasAtomArg(op_);
}
JS::Value getConstValue() const {
MOZ_ASSERT(isValid());
MOZ_ASSERT(hasConstValue());
return arg_.constValue;
}
frontend::TaggedParserAtomIndex getAtomIndex() const {
MOZ_ASSERT(isValid());
MOZ_ASSERT(hasAtomIndex());
return arg_.atomIndex;
};
};
// A reader that parses a sequence of object-literal instructions out of the
// encoded form.
struct ObjLiteralReader : private ObjLiteralReaderBase {
public:
explicit ObjLiteralReader(mozilla::Span<const uint8_t> data)
: ObjLiteralReaderBase(data) {}
[[nodiscard]] bool readInsn(ObjLiteralInsn* insn) {
ObjLiteralOpcode op;
ObjLiteralKey key;
if (!readOpAndKey(&op, &key)) {
return false;
}
if (ObjLiteralOpcodeHasValueArg(op)) {
JS::Value value;
if (!readValueArg(&value)) {
return false;
}
*insn = ObjLiteralInsn(op, key, value);
return true;
}
if (ObjLiteralOpcodeHasAtomArg(op)) {
frontend::TaggedParserAtomIndex atomIndex;
if (!readAtomArg(&atomIndex)) {
return false;
}
*insn = ObjLiteralInsn(op, key, atomIndex);
return true;
}
*insn = ObjLiteralInsn(op, key);
return true;
}
};
// A class to modify the code, while keeping the structure.
struct ObjLiteralModifier : private ObjLiteralReaderBase {
mozilla::Span<uint8_t> mutableData_;
public:
explicit ObjLiteralModifier(mozilla::Span<uint8_t> data)
: ObjLiteralReaderBase(data), mutableData_(data) {}
private:
// Map `atom` with `map`, and write to `atomCursor` of `mutableData_`.
template <typename MapT>
void mapOneAtom(MapT map, frontend::TaggedParserAtomIndex atom,
size_t atomCursor) {
auto atomIndex = map(atom);
memcpy(mutableData_.data() + atomCursor, atomIndex.rawDataRef(),
sizeof(frontend::TaggedParserAtomIndex));
}
// Map atoms in single instruction.
// Return true if it successfully maps.
// Return false if there's no more instruction.
template <typename MapT>
bool mapInsnAtom(MapT map) {
ObjLiteralOpcode op;
ObjLiteralKey key;
size_t opCursor = cursor();
if (!readOpAndKey(&op, &key)) {
return false;
}
if (key.isAtomIndex()) {
static constexpr size_t OpLength = 1;
size_t atomCursor = opCursor + OpLength;
mapOneAtom(map, key.getAtomIndex(), atomCursor);
}
if (ObjLiteralOpcodeHasValueArg(op)) {
JS::Value value;
if (!readValueArg(&value)) {
return false;
}
} else if (ObjLiteralOpcodeHasAtomArg(op)) {
size_t atomCursor = cursor();
frontend::TaggedParserAtomIndex atomIndex;
if (!readAtomArg(&atomIndex)) {
return false;
}
mapOneAtom(map, atomIndex, atomCursor);
}
return true;
}
public:
// Map TaggedParserAtomIndex inside the code in place, with given function.
template <typename MapT>
void mapAtom(MapT map) {
while (mapInsnAtom(map)) {
}
}
};
class ObjLiteralStencil {
friend class frontend::StencilXDR;
// CompilationStencil::clone has to update the code pointer.
friend struct frontend::CompilationStencil;
mozilla::Span<uint8_t> code_;
ObjLiteralKindAndFlags kindAndFlags_;
uint32_t propertyCount_ = 0;
public:
ObjLiteralStencil() = default;
ObjLiteralStencil(uint8_t* code, size_t length, ObjLiteralKind kind,
const ObjLiteralFlags& flags, uint32_t propertyCount)
: code_(mozilla::Span(code, length)),
kindAndFlags_(kind, flags),
propertyCount_(propertyCount) {}
JS::GCCellPtr create(JSContext* cx,
const frontend::CompilationAtomCache& atomCache) const;
mozilla::Span<const uint8_t> code() const { return code_; }
ObjLiteralKind kind() const { return kindAndFlags_.kind(); }
ObjLiteralFlags flags() const { return kindAndFlags_.flags(); }
uint32_t propertyCount() const { return propertyCount_; }
#ifdef DEBUG
bool isContainedIn(const LifoAlloc& alloc) const;
#endif
#if defined(DEBUG) || defined(JS_JITSPEW)
void dump() const;
void dump(JSONPrinter& json,
const frontend::CompilationStencil* stencil) const;
void dumpFields(JSONPrinter& json,
const frontend::CompilationStencil* stencil) const;
#endif
};
} // namespace js
#endif // frontend_ObjLiteral_h