diff options
Diffstat (limited to 'js/src/vm/StencilEnums.h')
| -rw-r--r-- | js/src/vm/StencilEnums.h | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/js/src/vm/StencilEnums.h b/js/src/vm/StencilEnums.h new file mode 100644 index 0000000000..23099aa80d --- /dev/null +++ b/js/src/vm/StencilEnums.h @@ -0,0 +1,346 @@ +/* -*- 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_StencilEnums_h +#define vm_StencilEnums_h + +#include <stdint.h> // uint8_t + +// +// Enum definitions shared between frontend, stencil, and the VM. +// + +namespace js { + +// [SMDOC] Try Notes +// +// Trynotes are attached to regions that are involved with +// exception unwinding. They can be broken up into four categories: +// +// 1. Catch and Finally: Basic exception handling. A Catch trynote +// covers the range of the associated try. A Finally trynote covers +// the try and the catch. +// +// 2. ForIn and Destructuring: These operations create an iterator +// which must be cleaned up (by calling IteratorClose) during +// exception unwinding. +// +// 3. ForOf and ForOfIterclose: For-of loops handle unwinding using +// catch blocks. These trynotes are used for for-of breaks/returns, +// which create regions that are lexically within a for-of block, +// but logically outside of it. See TryNoteIter::settle for more +// details. +// +// 4. Loop: This represents normal for/while/do-while loops. It is +// unnecessary for exception unwinding, but storing the boundaries +// of loops here is helpful for heuristics that need to know +// whether a given op is inside a loop. +enum class TryNoteKind : uint8_t { + Catch, + Finally, + ForIn, + Destructuring, + ForOf, + ForOfIterClose, + Loop +}; + +// [SMDOC] Script Flags +// +// Interpreted scripts represented by the BaseScript type use two flag words to +// encode an assortment of conditions and attributes about the script. +// +// The "immutable" flags are a combination of input flags describing aspects of +// the execution context that affect parsing (such as if we are an ES module or +// normal script), and flags derived from source text. These flags are preserved +// during cloning and serializing. As well, they should never change after the +// BaseScript is created (although there are currently a few exceptions for +// de-/re-lazification that remain). +// +// The "mutable" flags are temporary flags that are used by subsystems in the +// engine such as the debugger or JITs. These flags are not preserved through +// serialization or cloning since the attributes are generally associated with +// one specific instance of a BaseScript. + +enum class ImmutableScriptFlagsEnum : uint32_t { + // Input Flags + // + // These flags are from CompileOptions or the Parser entry point. They + // generally cannot be derived from the source text alone. + // ---- + + // A script may have one of the following kinds: Global, Eval, Module, + // Function. At most one flag can be set, with a default of Global. + IsForEval = 1 << 0, + IsModule = 1 << 1, + IsFunction = 1 << 2, + + // The script is compiled as engine-internal self-hosted JavaScript. This mode + // is used to implement certain library functions and has special parse, + // bytecode, and runtime behaviour that differs from normal script. + SelfHosted = 1 << 3, + + // The script was compiled with the default mode set to strict mode. Note that + // this tracks the default value, while the actual mode used (after processing + // source and its directives) is the `Strict` flag below. + ForceStrict = 1 << 4, + + // The script has a non-syntactic scope on its environment chain. That is, + // there may be objects about which we know nothing between the outermost + // syntactic scope and the global. + HasNonSyntacticScope = 1 << 5, + + // The script return value will not be used and simplified code will be + // generated. This can only be applied to top-level scripts. The value this + // script returns will be UndefinedValue instead of what the spec normally + // prescribes. + NoScriptRval = 1 << 6, + + // TreatAsRunOnce roughly indicates that a script is expected to be run no + // more than once. This affects optimizations and heuristics. + // + // On top-level global/eval/module scripts, this is set when the embedding + // ensures this script will not be re-used. In this case, parser literals may + // be exposed directly instead of being cloned. + TreatAsRunOnce = 1 << 7, + // ---- + + // Parser Flags + // + // Flags computed by the Parser from the source text and input flags. + // ---- + + // Generated code will execute in strict mode. This is due to either the + // ForceStrict flag being specified above, or due to source text itself (such + // as "use strict" directives). + Strict = 1 << 8, + + // Script is parsed with a top-level goal of Module. This may be a top-level + // or an inner-function script. + HasModuleGoal = 1 << 9, + + // Script contains inner functions. + // + // Note: This prevents relazification since inner function close-over the + // current scripts scopes. + HasInnerFunctions = 1 << 10, + + // There is a direct eval statement in this script OR in any of its inner + // functions. + // + // Note: This prevents relazification since it can introduce inner functions. + HasDirectEval = 1 << 11, + + // The (static) bindings of this script must support dynamic name access for + // read/write. The environment chain is used to do these dynamic lookups and + // optimizations to avoid allocating environments are suppressed. + // + // This includes direct-eval, `with`, and `delete` in this script OR in any of + // its inner functions. + // + // Note: Access through the arguments object is not considered dynamic binding + // access since it does not go through the normal name lookup mechanism. + BindingsAccessedDynamically = 1 << 12, + + // A tagged template exists in the body (which will use JSOp::CallSiteObj in + // bytecode). + // + // Note: This prevents relazification since the template's object is + // observable to the user and cannot be recreated. + HasCallSiteObj = 1 << 13, + + // Parser Flags for Functions + // ---- + + // This function's initial prototype is one of Function, GeneratorFunction, + // AsyncFunction, or AsyncGeneratorFunction as indicated by these flags. + // + // If either of these flags is set, the script may suspend and resume as it + // executes. Stack frames for this script also have a generator object. + IsAsync = 1 << 14, + IsGenerator = 1 << 15, + + // This function's body serves as the `var` environment for a non-strict + // direct eval. This matters because it's the only way bindings can be + // dynamically added to a local environment, possibly shadowing other + // variables. + FunHasExtensibleScope = 1 << 16, + + // This function has an internal .this binding and we need to emit + // JSOp::FunctionThis in the prologue to initialize it. This binding may be + // used directly for "this", or indirectly (such as class constructors). + FunctionHasThisBinding = 1 << 17, + + // This function is a class method that must uses an internal [[HomeObject]] + // slot. This slot is initialized when the class definition is executed in the + // enclosing function. + NeedsHomeObject = 1 << 18, + + // This function is a constructor for a derived class. This is a class that + // uses the `extends` syntax. + IsDerivedClassConstructor = 1 << 19, + + // This function is synthesized by the Parser. This is used for field + // initializer lambdas and missing constructors for classes. These functions + // have unusual source coordinates and may be hidden from things like + // Reflect.parse. + IsSyntheticFunction = 1 << 20, + + // This function is a class constructor that has MemberInitializer data + // associated with it. + UseMemberInitializers = 1 << 21, + + // This function has a rest (`...`) parameter. + HasRest = 1 << 22, + + // This function needs a call object or named lambda environment to be created + // in order to execute the function. This is done in the Stack or JIT frame + // setup code _before_ the bytecode prologue starts. + NeedsFunctionEnvironmentObjects = 1 << 23, + + // An extra VarScope is used as the body scope instead of the normal + // FunctionScope. This is needed when parameter expressions are used AND the + // function has var bindings or a sloppy-direct-eval. For example, + // `function(x = eval("")) { var y; }` + FunctionHasExtraBodyVarScope = 1 << 24, + + // This function must define the implicit `arguments` binding on the function + // scope. If there are no free uses or an appropriate explicit binding exists, + // then this flag is unset. + // + // Note: Parameter expressions will not see an explicit `var arguments;` + // binding in the body and an implicit binding on the function-scope must + // still be used in that case. + ShouldDeclareArguments = 1 << 25, + + // This function has a local (implicit or explicit) `arguments` binding. This + // binding is initialized by the JSOp::Arguments bytecode. + // + // Technically, every function has a binding named `arguments`. Internally, + // this binding is only added when `arguments` is mentioned by the function + // body. + // + // Examples: + // ``` + // // Explicit definition + // function f() { var arguments; return arguments; } + // + // // Implicit use + // function f() { return arguments; } + // + // // Implicit use in arrow function + // function f() { return () => arguments; } + // + // // Implicit use in parameter expression + // function f(a = arguments) { return a; } + // ``` + NeedsArgsObj = 1 << 26, + + // This function must use the "mapped" form of an arguments object. This flag + // is set independently of whether we actually use an `arguments` binding. The + // conditions are specified in the ECMAScript spec. + HasMappedArgsObj = 1 << 27, + + // Large self-hosted methods that should be inlined anyway by the JIT for + // performance reasons can be marked with this flag. + IsInlinableLargeFunction = 1 << 28, + + // This function has an internal .newTarget binding and we need to emit + // JSOp::NewTarget in the prologue to initialize it. This binding may be + // used directly for "new.target", or indirectly (e.g. in super() calls). + FunctionHasNewTargetBinding = 1 << 29, + + // Whether this is a self-hosted function that uses the ArgumentsLength or + // GetArgument intrinsic. + UsesArgumentsIntrinsics = 1 << 30, +}; + +enum class MutableScriptFlagsEnum : uint32_t { + // Number of times the |warmUpCount| was forcibly discarded. The counter is + // reset when a script is successfully jit-compiled. + WarmupResets_MASK = 0xFF, + + // If treatAsRunOnce, whether script has executed. + HasRunOnce = 1 << 8, + + // Script has been reused for a clone. + HasBeenCloned = 1 << 9, + + // Script has an entry in Realm::scriptCountsMap. + HasScriptCounts = 1 << 10, + + // Script has an entry in Realm::debugScriptMap. + HasDebugScript = 1 << 11, + + // (1 << 12) is unused. + // (1 << 13) is unused. + + // Script supports relazification where it releases bytecode and gcthings to + // save memory. This process is opt-in since various complexities may disallow + // this for some scripts. + // NOTE: Must check for isRelazifiable() before setting this flag. + AllowRelazify = 1 << 14, + + // Set if the script has opted into spew. + SpewEnabled = 1 << 15, + + // Set if we care about a script's final warmup count. + NeedsFinalWarmUpCount = 1 << 16, + + // + // IonMonkey compilation hints. + // + + // Whether Baseline or Ion compilation has been disabled for this script. + // IonDisabled is equivalent to |jitScript->canIonCompile() == false| but + // JitScript can be discarded on GC and we don't want this to affect + // observable behavior (see ArgumentsGetterImpl comment). + BaselineDisabled = 1 << 17, + IonDisabled = 1 << 18, + + // This script should not be inlined into others. This happens after inlining + // has failed. + Uninlineable = 1 << 19, + + // Indicates that this script has no eager baseline hint available + // in the cache, used to prevent further lookups. + NoEagerBaselineHint = 1 << 20, + + // ***************************************************************** + // The flags below are set when we bail out and invalidate a script. + // When we recompile, we will be more conservative. + // ***************************************************************** + + // A hoisted bounds check bailed out. + FailedBoundsCheck = 1 << 21, + + // An instruction hoisted by LICM bailed out. + HadLICMInvalidation = 1 << 22, + + // An instruction hoisted by InstructionReordering bailed out. + HadReorderingBailout = 1 << 23, + + // An instruction inserted or truncated by Range Analysis bailed out. + HadEagerTruncationBailout = 1 << 24, + + // A lexical check bailed out. + FailedLexicalCheck = 1 << 25, + + // A guard inserted by phi specialization bailed out. + HadSpeculativePhiBailout = 1 << 26, + + // An unbox folded with a load bailed out. + HadUnboxFoldingBailout = 1 << 27, +}; + +// Retrievable source can be retrieved using the source hook (and therefore +// need not be XDR'd, can be discarded if desired because it can always be +// reconstituted later, etc.). +enum class SourceRetrievable { No = 0, Yes }; + +} // namespace js + +#endif /* vm_StencilEnums_h */ |