js/src/vm/FunctionFlags.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 #ifndef vm_FunctionFlags_h
   8 #define vm_FunctionFlags_h
   9
  10 #include "mozilla/Assertions.h"  // MOZ_ASSERT, MOZ_ASSERT_IF
  11 #include "mozilla/Attributes.h"  // MOZ_IMPLICIT
  12
  13 #include <stdint.h>  // uint8_t, uint16_t
  14
  15 #include "jstypes.h"  // JS_PUBLIC_API
  16
  17 class JS_PUBLIC_API JSAtom;
  18
  19 namespace js {
  20
  21 class FunctionFlags {
  22  public:
  23   // Syntactic characteristics of a function.
  24   enum FunctionKind : uint8_t {
  25     // Regular function that doesn't match any of the other kinds.
  26     //
  27     // This kind is used by the following scipted functions:
  28     //   * FunctionDeclaration
  29     //   * FunctionExpression
  30     //   * Function created from Function() call or its variants
  31     //
  32     // Also all native functions excluding AsmJS and Wasm use this kind.
  33     NormalFunction = 0,
  34
  35     // ES6 '(args) => body' syntax.
  36     // This kind is used only by scripted function.
  37     Arrow,
  38
  39     // ES6 MethodDefinition syntax.
  40     // This kind is used only by scripted function.
  41     Method,
  42
  43     // Class constructor syntax, or default constructor.
  44     // This kind is used only by scripted function and default constructor.
  45     //
  46     // WARNING: This is independent from Flags::CONSTRUCTOR.
  47     ClassConstructor,
  48
  49     // Getter and setter syntax in objects or classes, or
  50     // native getter and setter created from JSPropertySpec.
  51     // This kind is used both by scripted functions and native functions.
  52     Getter,
  53     Setter,
  54
  55     // An asm.js module or exported function.
  56     //
  57     // This kind is used only by scripted function, and used only when the
  58     // asm.js module is created.
  59     //
  60     // "use asm" directive itself doesn't necessarily imply this kind.
  61     // e.g. arrow function with "use asm" becomes Arrow kind,
  62     //
  63     // See EstablishPreconditions in js/src/wasm/AsmJS.cpp
  64     AsmJS,
  65
  66     // An exported WebAssembly function.
  67     Wasm,
  68
  69     FunctionKindLimit
  70   };
  71
  72   enum Flags : uint16_t {
  73     // FunctionKind enum value.
  74     FUNCTION_KIND_SHIFT = 0,
  75     FUNCTION_KIND_MASK = 0x0007,
  76
  77     // The AllocKind used was FunctionExtended and extra slots were allocated.
  78     // These slots may be used by the engine or the embedding so care must be
  79     // taken to avoid conflicts.
  80     //
  81     // This flag is used both by scripted functions and native functions.
  82     EXTENDED = 1 << 3,
  83
  84     // Set if function is a self-hosted builtin or intrinsic. An 'intrinsic'
  85     // here means a native function used inside self-hosted code. In general, a
  86     // self-hosted function should appear to script as though it were a native
  87     // builtin.
  88     SELF_HOSTED = 1 << 4,
  89
  90     // An interpreted function has or may-have bytecode and an environment. Only
  91     // one of these flags may be used at a time. As a memory optimization, the
  92     // SELFHOSTLAZY flag indicates there is no js::BaseScript at all and we must
  93     // clone from the self-hosted realm in order to get bytecode.
  94     BASESCRIPT = 1 << 5,
  95     SELFHOSTLAZY = 1 << 6,
  96
  97     // Function may be called as a constructor. This corresponds in the spec as
  98     // having a [[Construct]] internal method.
  99     //
 100     // e.g. FunctionDeclaration has this flag, but GeneratorDeclaration doesn't
 101     //      have this flag.
 102     //
 103     // This flag is used both by scripted functions and native functions.
 104     //
 105     // WARNING: This is independent from FunctionKind::ClassConstructor.
 106     CONSTRUCTOR = 1 << 7,
 107
 108     // Function is either getter or setter, with "get " or "set " prefix,
 109     // but JSFunction::AtomSlot contains unprefixed name, and the function name
 110     // is lazily constructed on the first access.
 111     LAZY_ACCESSOR_NAME = 1 << 8,
 112
 113     // Function comes from a FunctionExpression, ArrowFunction, or Function()
 114     // call (not a FunctionDeclaration).
 115     //
 116     // This flag is used only by scripted functions and AsmJS.
 117     LAMBDA = 1 << 9,
 118
 119     // The WASM function has a JIT entry which emulates the
 120     // js::BaseScript::jitCodeRaw mechanism.
 121     WASM_JIT_ENTRY = 1 << 10,
 122
 123     // Function had no explicit name, but a name was set by SetFunctionName at
 124     // compile time or SetFunctionName at runtime.
 125     //
 126     // This flag can be used both by scripted functions and native functions.
 127     HAS_INFERRED_NAME = 1 << 11,
 128
 129     // Function had no explicit name, but a name was guessed for it anyway.
 130     //
 131     // This flag is used only by scripted function.
 132     HAS_GUESSED_ATOM = 1 << 12,
 133
 134     // The 'length' or 'name property has been resolved. See fun_resolve.
 135     //
 136     // These flags are used both by scripted functions and native functions.
 137     RESOLVED_NAME = 1 << 13,
 138     RESOLVED_LENGTH = 1 << 14,
 139
 140     // This function is kept only for skipping it over during delazification.
 141     //
 142     // This function is inside arrow function's parameter expression, and
 143     // parsed twice, once before finding "=>" token, and once after finding
 144     // "=>" and rewinding to the beginning of the parameters.
 145     // ScriptStencil is created for both case, and the first one is kept only
 146     // for delazification, to make sure delazification sees the same sequence
 147     // of inner function to skip over.
 148     //
 149     // We call the first one "ghost".
 150     // It should be kept lazy, and shouldn't be exposed to debugger.
 151     //
 152     // This flag is used only by scripted functions.
 153     GHOST_FUNCTION = 1 << 15,
 154
 155     // Shifted form of FunctionKinds.
 156     NORMAL_KIND = NormalFunction << FUNCTION_KIND_SHIFT,
 157     ASMJS_KIND = AsmJS << FUNCTION_KIND_SHIFT,
 158     WASM_KIND = Wasm << FUNCTION_KIND_SHIFT,
 159     ARROW_KIND = Arrow << FUNCTION_KIND_SHIFT,
 160     METHOD_KIND = Method << FUNCTION_KIND_SHIFT,
 161     CLASSCONSTRUCTOR_KIND = ClassConstructor << FUNCTION_KIND_SHIFT,
 162     GETTER_KIND = Getter << FUNCTION_KIND_SHIFT,
 163     SETTER_KIND = Setter << FUNCTION_KIND_SHIFT,
 164
 165     // Derived Flags combinations to use when creating functions.
 166     NATIVE_FUN = NORMAL_KIND,
 167     NATIVE_CTOR = CONSTRUCTOR | NORMAL_KIND,
 168     NATIVE_GETTER_WITH_LAZY_NAME = LAZY_ACCESSOR_NAME | GETTER_KIND,
 169     NATIVE_SETTER_WITH_LAZY_NAME = LAZY_ACCESSOR_NAME | SETTER_KIND,
 170     ASMJS_CTOR = CONSTRUCTOR | ASMJS_KIND,
 171     ASMJS_LAMBDA_CTOR = CONSTRUCTOR | LAMBDA | ASMJS_KIND,
 172     WASM = WASM_KIND,
 173     INTERPRETED_NORMAL = BASESCRIPT | CONSTRUCTOR | NORMAL_KIND,
 174     INTERPRETED_CLASS_CTOR = BASESCRIPT | CONSTRUCTOR | CLASSCONSTRUCTOR_KIND,
 175     INTERPRETED_GENERATOR_OR_ASYNC = BASESCRIPT | NORMAL_KIND,
 176     INTERPRETED_LAMBDA = BASESCRIPT | LAMBDA | CONSTRUCTOR | NORMAL_KIND,
 177     INTERPRETED_LAMBDA_ARROW = BASESCRIPT | LAMBDA | ARROW_KIND,
 178     INTERPRETED_LAMBDA_GENERATOR_OR_ASYNC = BASESCRIPT | LAMBDA | NORMAL_KIND,
 179     INTERPRETED_GETTER = BASESCRIPT | GETTER_KIND,
 180     INTERPRETED_SETTER = BASESCRIPT | SETTER_KIND,
 181     INTERPRETED_METHOD = BASESCRIPT | METHOD_KIND,
 182
 183     // Flags that XDR ignores. See also: js::BaseScript::MutableFlags.
 184     MUTABLE_FLAGS = RESOLVED_NAME | RESOLVED_LENGTH,
 185
 186     // Flags preserved when cloning a function.
 187     STABLE_ACROSS_CLONES =
 188         CONSTRUCTOR | LAMBDA | SELF_HOSTED | FUNCTION_KIND_MASK | GHOST_FUNCTION
 189   };
 190
 191   uint16_t flags_;
 192
 193  public:
 194   FunctionFlags() : flags_() {
 195     static_assert(sizeof(FunctionFlags) == sizeof(flags_),
 196                   "No extra members allowed is it'll grow JSFunction");
 197     static_assert(offsetof(FunctionFlags, flags_) == 0,
 198                   "Required for JIT flag access");
 199   }
 200
 201   explicit FunctionFlags(uint16_t flags) : flags_(flags) {}
 202   MOZ_IMPLICIT FunctionFlags(Flags f) : flags_(f) {}
 203
 204   static_assert(((FunctionKindLimit - 1) << FUNCTION_KIND_SHIFT) <=
 205                     FUNCTION_KIND_MASK,
 206                 "FunctionKind doesn't fit into flags_");
 207
 208   uint16_t toRaw() const { return flags_; }
 209
 210   uint16_t stableAcrossClones() const { return flags_ & STABLE_ACROSS_CLONES; }
 211
 212   // For flag combinations the type is int.
 213   bool hasFlags(uint16_t flags) const { return flags_ & flags; }
 214   FunctionFlags& setFlags(uint16_t flags) {
 215     flags_ |= flags;
 216     return *this;
 217   }
 218   FunctionFlags& clearFlags(uint16_t flags) {
 219     flags_ &= ~flags;
 220     return *this;
 221   }
 222   FunctionFlags& setFlags(uint16_t flags, bool set) {
 223     if (set) {
 224       setFlags(flags);
 225     } else {
 226       clearFlags(flags);
 227     }
 228     return *this;
 229   }
 230
 231   FunctionKind kind() const {
 232     return static_cast<FunctionKind>((flags_ & FUNCTION_KIND_MASK) >>
 233                                      FUNCTION_KIND_SHIFT);
 234   }
 235
 236 #ifdef DEBUG
 237   void assertFunctionKindIntegrity() {
 238     switch (kind()) {
 239       case FunctionKind::NormalFunction:
 240         MOZ_ASSERT(!hasFlags(LAZY_ACCESSOR_NAME));
 241         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 242         break;
 243
 244       case FunctionKind::Arrow:
 245         MOZ_ASSERT(hasFlags(BASESCRIPT) || hasFlags(SELFHOSTLAZY));
 246         MOZ_ASSERT(!hasFlags(CONSTRUCTOR));
 247         MOZ_ASSERT(!hasFlags(LAZY_ACCESSOR_NAME));
 248         MOZ_ASSERT(hasFlags(LAMBDA));
 249         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 250         break;
 251       case FunctionKind::Method:
 252         MOZ_ASSERT(hasFlags(BASESCRIPT) || hasFlags(SELFHOSTLAZY));
 253         MOZ_ASSERT(!hasFlags(CONSTRUCTOR));
 254         MOZ_ASSERT(!hasFlags(LAZY_ACCESSOR_NAME));
 255         MOZ_ASSERT(!hasFlags(LAMBDA));
 256         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 257         break;
 258       case FunctionKind::ClassConstructor:
 259         MOZ_ASSERT(hasFlags(BASESCRIPT) || hasFlags(SELFHOSTLAZY));
 260         MOZ_ASSERT(hasFlags(CONSTRUCTOR));
 261         MOZ_ASSERT(!hasFlags(LAZY_ACCESSOR_NAME));
 262         MOZ_ASSERT(!hasFlags(LAMBDA));
 263         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 264         break;
 265       case FunctionKind::Getter:
 266         MOZ_ASSERT(!hasFlags(CONSTRUCTOR));
 267         MOZ_ASSERT(!hasFlags(LAMBDA));
 268         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 269         break;
 270       case FunctionKind::Setter:
 271         MOZ_ASSERT(!hasFlags(CONSTRUCTOR));
 272         MOZ_ASSERT(!hasFlags(LAMBDA));
 273         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 274         break;
 275
 276       case FunctionKind::AsmJS:
 277         MOZ_ASSERT(!hasFlags(BASESCRIPT));
 278         MOZ_ASSERT(!hasFlags(SELFHOSTLAZY));
 279         MOZ_ASSERT(!hasFlags(LAZY_ACCESSOR_NAME));
 280         MOZ_ASSERT(!hasFlags(WASM_JIT_ENTRY));
 281         break;
 282       case FunctionKind::Wasm:
 283         MOZ_ASSERT(!hasFlags(BASESCRIPT));
 284         MOZ_ASSERT(!hasFlags(SELFHOSTLAZY));
 285         MOZ_ASSERT(!hasFlags(CONSTRUCTOR));
 286         MOZ_ASSERT(!hasFlags(LAZY_ACCESSOR_NAME));
 287         MOZ_ASSERT(!hasFlags(LAMBDA));
 288         break;
 289       default:
 290         break;
 291     }
 292   }
 293 #endif
 294
 295   /* A function can be classified as either native (C++) or interpreted (JS): */
 296   bool isInterpreted() const {
 297     return hasFlags(BASESCRIPT) || hasFlags(SELFHOSTLAZY);
 298   }
 299   bool isNativeFun() const { return !isInterpreted(); }
 300
 301   bool isConstructor() const { return hasFlags(CONSTRUCTOR); }
 302
 303   bool isNonBuiltinConstructor() const {
 304     // Note: keep this in sync with branchIfNotFunctionIsNonBuiltinCtor in
 305     // MacroAssembler.cpp.
 306     return hasFlags(BASESCRIPT) && hasFlags(CONSTRUCTOR) &&
 307            !hasFlags(SELF_HOSTED);
 308   }
 309
 310   /* Possible attributes of a native function: */
 311   bool isAsmJSNative() const {
 312     MOZ_ASSERT_IF(kind() == AsmJS, isNativeFun());
 313     return kind() == AsmJS;
 314   }
 315   bool isWasm() const {
 316     MOZ_ASSERT_IF(kind() == Wasm, isNativeFun());
 317     return kind() == Wasm;
 318   }
 319   bool isWasmWithJitEntry() const {
 320     MOZ_ASSERT_IF(hasFlags(WASM_JIT_ENTRY), isWasm());
 321     return hasFlags(WASM_JIT_ENTRY);
 322   }
 323   bool isNativeWithoutJitEntry() const {
 324     MOZ_ASSERT_IF(!hasJitEntry(), isNativeFun());
 325     return !hasJitEntry();
 326   }
 327   bool isBuiltinNative() const {
 328     return isNativeFun() && !isAsmJSNative() && !isWasm();
 329   }
 330   bool hasJitEntry() const {
 331     return hasBaseScript() || hasSelfHostedLazyScript() || isWasmWithJitEntry();
 332   }
 333
 334   /* Possible attributes of an interpreted function: */
 335   bool hasInferredName() const { return hasFlags(HAS_INFERRED_NAME); }
 336   bool hasGuessedAtom() const { return hasFlags(HAS_GUESSED_ATOM); }
 337   bool isLambda() const { return hasFlags(LAMBDA); }
 338
 339   bool isNamedLambda(bool hasName) const {
 340     return hasName && isLambda() && !hasInferredName() && !hasGuessedAtom();
 341   }
 342
 343   // These methods determine which of the u.scripted.s union arms are active.
 344   // For live JSFunctions the pointer values will always be non-null, but due
 345   // to partial initialization the GC (and other features that scan the heap
 346   // directly) may still return a null pointer.
 347   bool hasBaseScript() const { return hasFlags(BASESCRIPT); }
 348   bool hasSelfHostedLazyScript() const { return hasFlags(SELFHOSTLAZY); }
 349
 350   // Arrow functions store their lexical new.target in the first extended slot.
 351   bool isArrow() const { return kind() == Arrow; }
 352   // Every class-constructor is also a method.
 353   bool isMethod() const {
 354     return kind() == Method || kind() == ClassConstructor;
 355   }
 356   bool isClassConstructor() const { return kind() == ClassConstructor; }
 357
 358   bool isGetter() const { return kind() == Getter; }
 359   bool isSetter() const { return kind() == Setter; }
 360
 361   bool isAccessorWithLazyName() const { return hasFlags(LAZY_ACCESSOR_NAME); }
 362
 363   bool allowSuperProperty() const {
 364     return isMethod() || isGetter() || isSetter();
 365   }
 366
 367   bool hasResolvedLength() const { return hasFlags(RESOLVED_LENGTH); }
 368   bool hasResolvedName() const { return hasFlags(RESOLVED_NAME); }
 369
 370   bool isSelfHostedOrIntrinsic() const { return hasFlags(SELF_HOSTED); }
 371   bool isSelfHostedBuiltin() const {
 372     return isSelfHostedOrIntrinsic() && !isNativeFun();
 373   }
 374   bool isIntrinsic() const {
 375     return isSelfHostedOrIntrinsic() && isNativeFun();
 376   }
 377
 378   FunctionFlags& setKind(FunctionKind kind) {
 379     this->flags_ &= ~FUNCTION_KIND_MASK;
 380     this->flags_ |= static_cast<uint16_t>(kind) << FUNCTION_KIND_SHIFT;
 381     return *this;
 382   }
 383
 384   // Make the function constructible.
 385   FunctionFlags& setIsConstructor() {
 386     MOZ_ASSERT(!isConstructor());
 387     MOZ_ASSERT(isSelfHostedBuiltin());
 388     return setFlags(CONSTRUCTOR);
 389   }
 390
 391   FunctionFlags& setIsSelfHostedBuiltin() {
 392     MOZ_ASSERT(isInterpreted());
 393     MOZ_ASSERT(!isSelfHostedBuiltin());
 394     setFlags(SELF_HOSTED);
 395     // Self-hosted functions should not be constructable.
 396     return clearFlags(CONSTRUCTOR);
 397   }
 398   FunctionFlags& setIsIntrinsic() {
 399     MOZ_ASSERT(isNativeFun());
 400     MOZ_ASSERT(!isIntrinsic());
 401     return setFlags(SELF_HOSTED);
 402   }
 403
 404   FunctionFlags& setResolvedLength() { return setFlags(RESOLVED_LENGTH); }
 405   FunctionFlags& setResolvedName() { return setFlags(RESOLVED_NAME); }
 406
 407   FunctionFlags& setInferredName() { return setFlags(HAS_INFERRED_NAME); }
 408
 409   FunctionFlags& setGuessedAtom() { return setFlags(HAS_GUESSED_ATOM); }
 410
 411   FunctionFlags& setSelfHostedLazy() { return setFlags(SELFHOSTLAZY); }
 412   FunctionFlags& clearSelfHostedLazy() { return clearFlags(SELFHOSTLAZY); }
 413   FunctionFlags& setBaseScript() { return setFlags(BASESCRIPT); }
 414   FunctionFlags& clearBaseScript() { return clearFlags(BASESCRIPT); }
 415
 416   FunctionFlags& clearLazyAccessorName() {
 417     return clearFlags(LAZY_ACCESSOR_NAME);
 418   }
 419
 420   FunctionFlags& setWasmJitEntry() { return setFlags(WASM_JIT_ENTRY); }
 421
 422   bool isExtended() const { return hasFlags(EXTENDED); }
 423   FunctionFlags& setIsExtended() { return setFlags(EXTENDED); }
 424
 425   bool isNativeConstructor() const { return hasFlags(NATIVE_CTOR); }
 426
 427   FunctionFlags& setIsGhost() { return setFlags(GHOST_FUNCTION); }
 428   bool isGhost() const { return hasFlags(GHOST_FUNCTION); }
 429
 430   static uint16_t HasJitEntryFlags(bool isConstructing) {
 431     uint16_t flags = BASESCRIPT | SELFHOSTLAZY;
 432     if (!isConstructing) {
 433       flags |= WASM_JIT_ENTRY;
 434     }
 435     return flags;
 436   }
 437
 438   static FunctionFlags clearMutableflags(FunctionFlags flags) {
 439     return FunctionFlags(flags.toRaw() & ~FunctionFlags::MUTABLE_FLAGS);
 440   }
 441 };
 442
 443 } /* namespace js */
 444
 445 #endif /* vm_FunctionFlags_h */