| blob | fbbd79cc9724f8ea05fc88c1ea9b06519ea09972 |
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/. */
7 /*
8 * JS bytecode generation.
9 */
22 #include <algorithm>
23 #include <iterator>
24 #include <string.h>
29 #include "frontend/BytecodeControlStructures.h" // NestableControl, BreakableControl, LabelControl, LoopControl, TryFinallyControl
40 #include "frontend/FunctionEmitter.h" // FunctionEmitter, FunctionScriptEmitter, FunctionParamsEmitter
65 #include "vm/BytecodeUtil.h" // JOF_*, IsArgOp, IsLocalOp, SET_UINT24, SET_ICINDEX, BytecodeFallsThrough, BytecodeIsJumpTarget
89 // The few node types listed below are exceptions to the usual
90 // location-source-note-emitting code in BytecodeEmitter::emitTree().
91 // Single-line `while` loops and C-style `for` loops require careful
92 // handling to avoid strange stepping behavior.
93 // Functions usually shouldn't have location information (bug 1431202).
98 }
101 // For the purposes of bytecode emission, StaticClassBlocks are treated as if
102 // they were static initializers.
106 }
111 }
116 }
120 // Suppress for all self-hosting code.
123 }
125 // Suppress for synthesized class constructors.
129 }
132 }
138 EmitterMode emitterMode)
150 }
159 EmitterMode emitterMode)
161 emitterMode) {
163 }
168 }
174 }
175 }
177 }
182 }
187 }
192 }
196 }
202 }
207 }
215 }
217 }
222 }
226 }
228 // We track the location of the most recent separator for use in
229 // markSimpleBreakpoint. Note that this means that the position must already
230 // be set before markStepBreakpoint is called.
234 }
239 }
241 // If a breakable call ends up being the same location as the most recent
242 // expression start, we need to skip marking it breakable in order to avoid
243 // having two breakpoints with the same line/column position.
244 // Note: This assumes that the position for the call has already been set.
248 }
249 }
252 }
263 }
267 }
270 // Even if every bytecode op is a JOF_IC op and the function has ARGC_LIMIT
271 // arguments, numICEntries cannot overflow.
275 }
278 }
280 #ifdef DEBUG
284 }
287 }
289 }
290 #endif
295 BytecodeOffset offset;
298 }
304 }
309 BytecodeOffset offset;
312 }
319 }
324 /* These should filter through emitVarOp. */
328 BytecodeOffset offset;
331 }
339 }
345 BytecodeOffset off;
348 }
352 /* The remaining |extra| bytes are set by the caller */
354 /*
355 * Don't updateDepth if op's use-count comes from the immediate
356 * operand yet to be stored in the extra bytes after op.
357 */
360 }
364 }
366 }
371 // Record the current IC-entry index at start of this op.
379 }
383 }
388 // Alias consecutive jump targets.
394 }
399 BytecodeOffset opOff;
401 }
404 BytecodeOffset offset;
407 }
416 }
421 }
423 JumpTarget fallthrough;
426 }
427 }
429 }
442 }
447 }
448 JumpTarget target;
451 }
454 }
461 }
462 }
464 }
468 }
476 }
480 }
485 }
488 BytecodeOffset off;
491 }
495 }
498 }
505 }
507 // 2 JSOp::Pop instructions (2 bytes) are shorter than JSOp::PopN (3 bytes).
510 }
513 }
520 }
523 }
530 }
533 }
537 }
541 }
543 /* Updates line number notes, not column notes. */
547 }
555 }
563 // If we use a `SetLine` note below, we want it to be relative to the
564 // scripts initial line number for better chance of sharing.
568 /*
569 * Encode any change in the current source line number by using
570 * either several SrcNoteType::NewLine notes or just one
571 * SrcNoteType::SetLine note, whichever consumes less space.
572 *
573 * NB: We handle backward line number deltas (possible with for
574 * loops where the update part is emitted after the body, but its
575 * line number is <= any line number in the body) here by letting
576 * unsigned delta_ wrap to a very large number, which triggers a
577 * SrcNoteType::SetLine.
578 */
584 }
589 }
591 }
594 }
596 }
598 /* Updates the line number and column number information in the source notes. */
602 }
606 }
611 // Assert colspan is always representable.
629 }
634 }
635 }
640 }
641 }
644 }
646 }
651 }
653 }
656 // Try to give the JSOp::LoopHead the same line number as the next
657 // instruction. nextpn is often a block, in which case the next instruction
658 // typically comes from the first statement inside.
661 }
665 }
666 }
669 }
675 }
677 }
680 BytecodeOffset off;
683 }
686 }
693 }
697 }
701 }
709 BytecodeOffset offset;
712 }
719 }
724 // .generator lookups should be emitted as JSOp::GetAliasedVar instead of
725 // JSOp::GetName etc, to bypass |with| objects on the scope chain.
726 // It's safe to emit .this lookups though because |with| objects skip
727 // those.
731 GCThingIndex index;
734 }
737 }
741 #ifdef DEBUG
744 #endif
746 }
750 GCThingIndex index;
753 }
756 }
761 }
767 }
773 }
777 }
783 BytecodeOffset off;
786 }
790 }
794 BytecodeOffset off;
797 }
801 }
810 BytecodeOffset off;
813 }
821 }
828 }
833 }
836 }
838 }
844 }
846 restart:
849 // Trivial cases with no side effects.
863 // ParseNodeKind::Name
885 // |this| can throw in derived class constructors, including nested arrow
886 // functions or eval.
892 // |new.target| doesn't have any side-effects.
897 }
899 // Trivial binary nodes with more token pos holders.
906 }
923 // Watch out for getters!
930 // Unary cases with side effects only if the child has them.
936 // Even if the name expression is effect-free, performing ToPropertyKey on
937 // it might not be effect-free:
938 //
939 // RegExp.prototype.toString = () => { throw 42; };
940 // ({ [/regex/]: 0 }); // ToPropertyKey(/regex/) throws 42
941 //
942 // function Q() {
943 // ({ [new.target]: 0 });
944 // }
945 // Q.toString = () => { throw 17; };
946 // new Q; // new.target will be Q, ToPropertyKey(Q) throws 17
952 // Looking up or evaluating the associated name could throw.
958 // This unary case has side effects on the enclosing object, sure. But
959 // that's not the question this function answers: it's whether the
960 // operation may have a side effect on something *other* than the result
961 // of the overall operation in which it's embedded. The answer to that
962 // is no, because an object literal having a mutated prototype only
963 // produces a value, without affecting anything else.
967 // Unary cases with obvious side effects.
977 // These might invoke valueOf/toString, even with a subexpression without
978 // side effects! Consider |+{ valueOf: null, toString: null }|.
986 // This invokes the (user-controllable) iterator protocol.
1000 // Deletion generally has side effects, even if isolated cases have none.
1009 // Deletion of a non-Reference expression has side effects only through
1010 // evaluating the expression.
1014 }
1019 // Binary cases with obvious side effects.
1050 // Strict equality operations and short circuit operators are well-behaved
1051 // and perform no conversions.
1057 // Any subexpression of a comma expression could be effectful.
1061 // Subcomponents of a literal may be effectful.
1067 }
1070 }
1071 }
1074 #ifdef ENABLE_RECORD_TUPLE
1078 #endif
1080 #ifdef ENABLE_DECORATORS
1083 #endif
1085 // Most other binary operations (parsed as lists in SpiderMonkey) may
1086 // perform conversions triggering side effects. Math operations perform
1087 // ToNumber and may fail invoking invalid user-defined toString/valueOf:
1088 // |5 < { toString: null }|. |instanceof| throws if provided a
1089 // non-object constructor: |null instanceof null|. |in| throws if given
1090 // a non-object RHS: |5 in null|.
1121 }
1124 }
1126 }
1128 // More getters.
1135 // Throws if the operand is not of the right class. Can also call a private
1136 // getter.
1142 // These affect visible names in this code, or in other code.
1150 // Likewise.
1162 // Every part of a loop might be effect-free, but looping infinitely *is*
1163 // an effect. (Language lawyer trivia: C++ says threads can be assumed
1164 // to exit or have side effects, C++14 [intro.multithread]p27, so a C++
1165 // implementation's equivalent of the below could set |*answer = false;|
1166 // if all loop sub-nodes set |*answer = false|!)
1174 // Declarations affect the name set of the relevant scope.
1187 }
1190 }
1193 }
1196 }
1199 }
1201 }
1203 // Function calls can invoke non-local code.
1213 // Function arg lists can contain arbitrary expressions. Technically
1214 // this only causes side-effects if one of the arguments does, but since
1215 // the call being made will always trigger side-effects, it isn't needed.
1226 // Classes typically introduce names. Even if no name is introduced,
1227 // the heritage and/or class body (through computed property names)
1228 // usually have effects.
1234 // |with| calls |ToObject| on its expression and so throws if that value
1235 // is null/undefined.
1251 // Shorthands could trigger getters: the |x| in the object literal in
1252 // |with ({ get x() { throw 42; } }) ({ x });|, for example, triggers
1253 // one. (Of course, it isn't necessary to use |with| for a shorthand to
1254 // trigger a getter.)
1262 /*
1263 * A named function, contrary to ES3, is no longer effectful, because
1264 * we bind its name lexically (using JSOp::Callee) instead of creating
1265 * an Object instance and binding a readonly, permanent property in it
1266 * (the object and binding can be detected and hijacked or captured).
1267 * This is a bug fix to ES3; it is fixed in ES3.1 drafts.
1268 */
1280 }
1283 }
1287 }
1290 }
1291 }
1295 }
1296 }
1298 }
1305 }
1308 }
1309 }
1311 }
1317 }
1320 }
1328 // We could methodically check every interpolated expression, but it's
1329 // probably not worth the trouble. Treat template strings as effect-free
1330 // only if they don't contain any substitutions.
1335 "template strings must alternate template and substitution "
1339 }
1341 // This should be unreachable but is left as-is for now.
1375 }
1378 "invalid, unenumerated ParseNodeKind value encountered in "
1380 }
1384 }
1389 }
1392 // Short-circuit if there is an enclosing 'with' scope.
1395 }
1397 // Otherwise see if the current point is under a 'with'.
1402 }
1403 }
1406 }
1416 // The Parser is responsible for marking the environment as either
1417 // closed-over or used-by-eval which ensure that is must exist.
1420 }
1421 }
1423 numHops++;
1424 }
1425 }
1426 }
1428 // The "this" environment exists outside of the compilation, but the
1429 // `ScopeContext` recorded the number of additional hops needed, so add
1430 // those in now.
1434 }
1437 // Get the innermost enclosing function that has a |this| binding.
1439 // Directly load callee from the frame if possible.
1442 }
1444 // We have to load the callee from the environment chain.
1454 }
1459 }
1462 }
1474 }
1484 }
1490 }
1497 }
1504 }
1510 }
1513 }
1518 ObjLiteralWriter writer;
1525 }
1530 }
1532 GCThingIndex shape;
1535 }
1538 }
1543 }
1546 }
1549 }
1551 }
1558 }
1561 }
1567 }
1572 }
1575 // The parser ensures the private name is present on the environment chain,
1576 // but its location can be Dynamic or Global when emitting debugger
1577 // eval-in-frame code.
1585 }
1589 ValueIsOnStack isOnStack) {
1590 // Dynamic accesses have TDZ checks built into their VM code and should
1591 // never emit explicit TDZ checks.
1595 // Private names are implemented as lexical bindings, but it's just an
1596 // implementation detail. Per spec there's no TDZ check when using them.
1599 }
1605 }
1607 // We've already emitted a check in this basic block.
1610 }
1612 // If the value is not on the stack, we have to load it first.
1617 }
1621 }
1622 }
1623 }
1625 // Emit the lexical check.
1629 }
1634 }
1635 }
1637 // Pop the value if needed.
1641 }
1642 }
1645 }
1653 // The non-optimized case.
1655 }
1657 // If the object operand is also a dotted property reference, reverse the
1658 // list linked via expression() temporarily so we can iterate over it from
1659 // the bottom up (reversing again as we go), to avoid excessive recursion.
1664 // Reverse pndot->expression() to point up, not down.
1670 }
1673 }
1675 // pndown is a primary expression, not a dotted property reference.
1678 }
1681 // Walk back up the list, emitting annotated name ops.
1684 }
1686 // Reverse the pndot->expression() link again.
1692 }
1694 }
1696 }
1714 }
1718 // [stack] THIS
1720 }
1723 // [stack] OBJ
1725 }
1726 }
1728 // [stack] RESULT
1730 }
1733 }
1750 }
1753 }
1759 // [stack]
1761 }
1764 // [stack] THIS
1766 }
1768 // [stack] THIS
1770 }
1772 // [stack] THIS KEY
1774 }
1777 }
1780 // [stack]
1782 }
1784 // [stack] OBJ
1786 }
1788 // [stack] OBJ? OBJ
1790 }
1792 // [stack] OBJ? OBJ KEY
1794 }
1797 }
1802 }
1805 }
1811 }
1825 }
1826 }
1840 }
1841 }
1852 // [stack] # if Super
1853 // [stack] THIS KEY
1854 // [stack] # otherwise
1855 // [stack] OBJ KEY
1857 }
1859 // [stack] RESULT
1861 }
1864 }
1875 // [stack] CALLRESULT
1877 }
1879 // [stack] N
1881 }
1883 // The increment/decrement has no side effects, so proceed to throw for
1884 // invalid assignment target.
1886 }
1889 ValueUsage valueUsage) {
1895 // [stack] OBJ
1897 }
1899 // [stack] OBJ NAME
1901 }
1903 // [stack] RESULT
1905 }
1908 }
1911 BytecodeOffset offset;
1914 }
1921 }
1928 }
1931 }
1934 }
1940 }
1942 BytecodeOffset off;
1945 }
1948 BytecodeOffset off;
1951 }
1953 }
1955 }
1958 }
1960 /*
1961 * Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047.
1962 * LLVM is deciding to inline this function which uses a lot of stack space
1963 * into emitTree which is recursive and uses relatively little stack space.
1964 */
1974 }
1978 }
1981 }
1983 // Enter the scope before pushing the switch BreakableControl since all
1984 // breaks are under this scope.
1989 }
1991 // A switch statement may contain hoisted functions inside its
1992 // cases. The hasTopLevelFunctionDeclarations flag is propagated from the
1993 // StatementList bodies of the cases to the case list.
2001 }
2002 }
2003 }
2004 }
2007 }
2018 }
2025 }
2031 }
2035 }
2036 }
2039 }
2043 }
2049 }
2053 }
2055 // Emit code for evaluating cases and jumping to case statements.
2060 }
2064 }
2067 // If the expression is a literal, suppress line number emission so
2068 // that debugging works more naturally.
2073 }
2077 }
2078 }
2079 }
2081 // Emit code for each case's statements.
2087 }
2094 #ifdef DEBUG
2095 // Use NumberEqualsInt32 here because switches compare using
2096 // strict equality, which will equate -0 and +0. In contrast
2097 // NumberIsInt32 would return false for -0.
2100 #endif
2105 }
2109 }
2110 }
2111 }
2115 }
2116 }
2120 }
2123 }
2131 "resumeIndex should not include magic AbstractGeneratorObject "
2135 "resumeIndex * sizeof(uintptr_t) must fit in an int32. JIT code relies "
2142 }
2145 }
2155 }
2158 }
2159 }
2162 }
2167 }
2172 BytecodeOffset off;
2175 }
2179 }
2184 }
2188 BytecodeOffset unusedOffset;
2190 }
2194 }
2197 // ParseNodeKind::SetThis is used to update |this| after a super() call
2198 // in a derived class constructor.
2205 // The 'this' binding is not lexical, but due to super() semantics this
2206 // initialization needs to be treated as a lexical one.
2208 NameLocation lexicalLoc;
2219 }
2223 // [stack]
2225 }
2227 // Emit the new |this| value.
2229 // [stack] NEWTHIS
2231 }
2233 // Get the original |this| and throw if we already initialized
2234 // it. Do *not* use the NameLocation argument, as that's the special
2235 // lexical location below to deal with super() semantics.
2237 // [stack] NEWTHIS THIS
2239 }
2241 // [stack] NEWTHIS THIS
2243 }
2245 // [stack] NEWTHIS
2247 }
2249 // [stack] NEWTHIS
2251 }
2255 }
2258 }
2268 }
2272 }
2275 }
2277 // For Global and sloppy-Eval scripts, this performs most of the steps of the
2278 // spec's [GlobalDeclarationInstantiation] and [EvalDeclarationInstantiation]
2279 // operations.
2280 //
2281 // Note that while strict-Eval is handled in the same part of the spec, it never
2282 // fails for global-redeclaration checks so those scripts initialize directly in
2283 // their bytecode.
2286 // ES Modules have dedicated variable and lexial environments and therefore
2287 // do not have to perform redeclaration checks. We initialize their bindings
2288 // elsewhere in bytecode.
2290 }
2293 // Strict Eval has a dedicated variables (and lexical) environment and
2294 // therefore does not have to perform redeclaration checks. We initialize
2295 // their bindings elsewhere in the bytecode.
2297 }
2299 // If we have no variables bindings, then we are done!
2303 }
2309 }
2310 }
2312 #if DEBUG
2313 // There should be no emitted functions yet.
2316 }
2317 #endif
2319 // Emit the hoisted functions to gc-things list. There is no bytecode
2320 // generated yet to bind them.
2323 }
2325 // Save the last GCThingIndex emitted. The hoisted functions are contained in
2326 // the gc-things list up until this point. This set of gc-things also contain
2327 // initial scopes (of which there must be at least one).
2329 GCThingIndex lastFun =
2332 #if DEBUG
2336 }
2337 #endif
2339 // Check for declaration conflicts and initialize the bindings.
2340 // NOTE: The self-hosting top-level script should not populate the builtins
2341 // directly on the GlobalObject (and instead uses JSOp::GetIntrinsic for
2342 // lookups).
2346 }
2347 }
2350 }
2363 }
2367 }
2372 }
2375 }
2376 }
2383 // Sloppy eval scripts may emit hoisted functions bindings with a
2384 // `JSOp::GlobalOrEvalDeclInstantiation` opcode below. If this eval needs a
2385 // top-level lexical environment, we must ensure that environment is created
2386 // before those functions are created and bound.
2387 //
2388 // This differs from the global-script case below because the global-lexical
2389 // environment exists outside the script itself. In the case of strict eval
2390 // scripts, the `emitterScope` above is already sufficient.
2397 }
2401 }
2408 }
2412 }
2416 }
2420 }
2424 }
2425 }
2432 }
2433 }
2436 // [stack]
2438 }
2442 }
2443 }
2448 }
2449 }
2453 }
2457 }
2461 }
2465 }
2467 // Create a Stencil and convert it into a JSScript.
2469 }
2476 }
2483 // Add fields to the property count estimate.
2485 propertyCountEstimate +=
2487 }
2496 }
2504 }
2507 }
2516 // [stack]
2521 // [stack]
2523 }
2526 // [stack]
2528 }
2531 // [stack]
2533 }
2536 // [stack]
2538 }
2541 // [stack]
2543 }
2548 }
2549 }
2552 }
2556 #ifdef DEBUG
2558 #endif
2564 // No need to recurse into ParseNodeKind::Array and ParseNodeKind::Object
2565 // subpatterns here, since emitSetOrInitializeDestructuring does the
2566 // recursion when setting or initializing the value. Getting reference
2567 // doesn't recurse.
2579 }
2583 // [stack] THIS SUPERBASE
2585 }
2588 // [stack] OBJ
2590 }
2591 }
2593 // [stack] # if Super
2594 // [stack] THIS SUPERBASE
2595 // [stack] # otherwise
2596 // [stack] OBJ
2598 }
2600 // SUPERBASE was pushed onto THIS in poe.prepareForRhs above.
2603 }
2613 // [stack] # if Super
2614 // [stack] THIS KEY
2615 // [stack] # otherwise
2616 // [stack] OBJ KEY
2618 }
2620 // [stack] # if Super
2621 // [stack] THIS KEY SUPERBASE
2622 // [stack] # otherwise
2623 // [stack] OBJ KEY
2625 }
2627 // SUPERBASE was pushed onto KEY in eoe.prepareForRhs above.
2630 }
2637 // [stack] OBJ
2639 }
2641 // [stack] OBJ NAME
2643 }
2646 }
2650 "Parser::reportIfNotValidSimpleAssignmentTarget "
2651 "rejects function calls as assignment "
2657 }
2662 }
2666 // Now emit the lvalue opcode sequence. If the lvalue is a nested
2667 // destructuring initialiser-form, call ourselves to handle it, then pop
2668 // the matched value. Otherwise emit an lvalue bytecode sequence followed
2669 // by an assignment op.
2676 }
2677 // emitDestructuringOps leaves the assigned (to-be-destructured) value on
2678 // top of the stack.
2693 }
2697 // [stack] V ENV?
2699 }
2701 // This is like ordinary assignment, but with one difference.
2702 //
2703 // In `a = b`, we first determine a binding for `a` (using
2704 // JSOp::BindName or JSOp::BindGName), then we evaluate `b`, then
2705 // a JSOp::SetName instruction.
2706 //
2707 // In `[a] = [b]`, per spec, `b` is evaluated first, then we
2708 // determine a binding for `a`. Then we need to do assignment--
2709 // but the operands are on the stack in the wrong order for
2710 // JSOp::SetProp, so we have to add a JSOp::Swap.
2711 //
2712 // In the cases where we are emitting a name op, emit a swap
2713 // because of this.
2715 // [stack] ENV V
2717 }
2719 // In cases of emitting a frame slot or environment slot,
2720 // nothing needs be done.
2721 }
2723 // [stack] V
2725 }
2728 }
2731 // The reference is already pushed by emitDestructuringLHSRef.
2732 // [stack] # if Super
2733 // [stack] THIS SUPERBASE VAL
2734 // [stack] # otherwise
2735 // [stack] OBJ VAL
2743 }
2744 // [stack] # VAL
2747 }
2749 }
2752 // The reference is already pushed by emitDestructuringLHSRef.
2753 // [stack] # if Super
2754 // [stack] THIS KEY SUPERBASE VAL
2755 // [stack] # otherwise
2756 // [stack] OBJ KEY VAL
2765 }
2767 // [stack] VAL
2769 }
2771 }
2774 // The reference is already pushed by emitDestructuringLHSRef.
2775 // [stack] OBJ NAME VAL
2781 }
2783 // [stack] VAL
2785 }
2787 }
2791 "Parser::reportIfNotValidSimpleAssignmentTarget "
2792 "rejects function calls as assignment "
2798 }
2800 // Pop the assigned value.
2802 // [stack] # empty
2804 }
2807 }
2810 SelfHostedIter selfHostedIter) {
2821 }
2822 }
2825 }
2833 ".next() iteration is prohibited in self-hosted code because it"
2836 // [stack] ... NEXT ITER
2840 callSourceCoordOffset)) {
2841 // [stack] ... RESULT
2843 }
2847 // [stack] ... RESULT
2849 }
2850 }
2853 // [stack] ... RESULT
2855 }
2857 }
2866 ".close() on iterators is prohibited in self-hosted code because "
2871 }
2873 // Generate inline logic corresponding to IteratorClose (ES2021 7.4.6) and
2874 // AsyncIteratorClose (ES2021 7.4.7). Steps numbers apply to both operations.
2875 //
2876 // Callers need to ensure that the iterator object is at the top of the
2877 // stack.
2879 // For non-Throw completions, we emit the equivalent of:
2880 //
2881 // var returnMethod = GetMethod(iterator, "return");
2882 // if (returnMethod !== undefined) {
2883 // var innerResult = [Await] Call(returnMethod, iterator);
2884 // CheckIsObj(innerResult);
2885 // }
2886 //
2887 // Whereas for Throw completions, we emit:
2888 //
2889 // try {
2890 // var returnMethod = GetMethod(iterator, "return");
2891 // if (returnMethod !== undefined) {
2892 // [Await] Call(returnMethod, iterator);
2893 // }
2894 // } catch {}
2903 // [stack] ... ITER
2905 }
2906 }
2909 // [stack] ... ITER ITER
2911 }
2913 // Steps 1-2 are assertions, step 3 is implicit.
2915 // Step 4.
2916 //
2917 // Get the "return" method.
2919 // [stack] ... ITER RET
2921 }
2923 // Step 5.
2924 //
2925 // Do nothing if "return" is undefined or null.
2928 // [stack] ... ITER RET NULL-OR-UNDEF
2930 }
2934 // [stack] ... ITER RET
2936 }
2938 // Steps 5.c, 7.
2939 //
2940 // Call the "return" method.
2942 // [stack] ... RET ITER
2944 }
2947 // [stack] ... RESULT
2949 }
2951 // 7.4.7 AsyncIteratorClose, step 5.d.
2954 // Await clobbers rval, so save the current rval.
2956 // [stack] ... RESULT RVAL
2958 }
2960 // [stack] ... RVAL RESULT
2962 }
2963 }
2966 // [stack] ... RVAL? RESULT
2968 }
2972 // [stack] ... RESULT RVAL
2974 }
2976 // [stack] ... RESULT
2978 }
2979 }
2980 }
2982 // Step 6 (Handled in caller).
2984 // Step 8.
2986 // Check that the "return" result is an object.
2988 // [stack] ... RESULT
2990 }
2991 }
2994 // [stack] ... ITER RET
2996 }
2999 // [stack] ... ITER
3001 }
3005 }
3009 // [stack] ... ITER EXC
3011 }
3013 // Just ignore the exception thrown by call and await.
3015 // [stack] ... ITER
3017 }
3020 // [stack] ... ITER
3022 }
3023 }
3025 // Step 9 (Handled in caller).
3028 // [stack] ...
3029 }
3033 InnerEmitter emitter) {
3036 // Pad a nop at the beginning of the bytecode covered by the trynote so
3037 // that when unwinding environments, we may unwind to the scope
3038 // corresponding to the pc *before* the start, in case the first bytecode
3039 // emitted by |emitter| is the start of an inner scope. See comment above
3040 // UnwindEnvironmentToTryPc.
3043 }
3048 }
3052 }
3054 }
3057 // [stack] VALUE
3061 // [stack]
3063 }
3065 // [stack] DEFAULTVALUE
3067 }
3069 // [stack] VALUE/DEFAULTVALUE
3071 }
3073 }
3080 // Function doesn't have 'name' property at this point.
3081 // Set function's name at compile time.
3084 }
3087 }
3092 }
3100 // [stack] NAME FUN
3102 }
3104 // [stack] NAME FUN NAME
3106 }
3108 // [stack] NAME FUN
3110 }
3112 }
3118 }
3121 TaggedParserAtomIndex name) {
3122 // The inferred name may already be set if this function is an interpreted
3123 // lazy function and we OOM'ed after we set the inferred name the first
3124 // time.
3130 }
3134 }
3143 }
3147 }
3148 }
3151 }
3154 DestructuringFlavor flav) {
3156 "array destructuring is prohibited in self-hosted code because it"
3161 // Here's pseudo code for |let [a, b, , c=y, ...d] = x;|
3162 //
3163 // Lines that are annotated "covered by trynote" mean that upon throwing
3164 // an exception, IteratorClose is called on iter only if done is false.
3165 //
3166 // let x, y;
3167 // let a, b, c, d;
3168 // let iter, next, lref, result, done, value; // stack values
3169 //
3170 // // NOTE: the fast path for this example is not applicable, because of
3171 // // the spread and the assignment |c=y|, but it is documented here for a
3172 // // simpler example, |let [a,b] = x;|
3173 // //
3174 // // if (IsOptimizableArray(x)) {
3175 // // a = x[0];
3176 // // b = x[1];
3177 // // goto end: // (skip everything below)
3178 // // }
3179 //
3180 // iter = x[Symbol.iterator]();
3181 // next = iter.next;
3182 //
3183 // // ==== emitted by loop for a ====
3184 // lref = GetReference(a); // covered by trynote
3185 //
3186 // result = Call(next, iter);
3187 // done = result.done;
3188 //
3189 // if (done)
3190 // value = undefined;
3191 // else
3192 // value = result.value;
3193 //
3194 // SetOrInitialize(lref, value); // covered by trynote
3195 //
3196 // // ==== emitted by loop for b ====
3197 // lref = GetReference(b); // covered by trynote
3198 //
3199 // if (done) {
3200 // value = undefined;
3201 // } else {
3202 // result = Call(next, iter);
3203 // done = result.done;
3204 // if (done)
3205 // value = undefined;
3206 // else
3207 // value = result.value;
3208 // }
3209 //
3210 // SetOrInitialize(lref, value); // covered by trynote
3211 //
3212 // // ==== emitted by loop for elision ====
3213 // if (done) {
3214 // value = undefined;
3215 // } else {
3216 // result = Call(next, iter);
3217 // done = result.done;
3218 // if (done)
3219 // value = undefined;
3220 // else
3221 // value = result.value;
3222 // }
3223 //
3224 // // ==== emitted by loop for c ====
3225 // lref = GetReference(c); // covered by trynote
3226 //
3227 // if (done) {
3228 // value = undefined;
3229 // } else {
3230 // result = Call(next, iter);
3231 // done = result.done;
3232 // if (done)
3233 // value = undefined;
3234 // else
3235 // value = result.value;
3236 // }
3237 //
3238 // if (value === undefined)
3239 // value = y; // covered by trynote
3240 //
3241 // SetOrInitialize(lref, value); // covered by trynote
3242 //
3243 // // ==== emitted by loop for d ====
3244 // lref = GetReference(d); // covered by trynote
3245 //
3246 // if (done)
3247 // value = [];
3248 // else
3249 // value = [...iter];
3250 //
3251 // SetOrInitialize(lref, value); // covered by trynote
3252 //
3253 // // === emitted after loop ===
3254 // if (!done)
3255 // IteratorClose(iter);
3256 //
3257 // end:
3271 }
3273 }
3275 // Unfortunately we can't handle any recursive destructuring,
3276 // because we can't guarantee that the recursed-into parts
3277 // won't run code which invalidates our constraints. We also
3278 // cannot handle ParseNodeKind::AssignExpr for similar reasons.
3281 }
3284 }
3285 }
3287 // Use an iterator to destructure the RHS, instead of index lookup. We
3288 // must leave the *original* value on the stack.
3290 // [stack] ... OBJ OBJ
3292 }
3301 // [stack] OBJ OBJ
3303 }
3306 // [stack] OBJ OBJ IS_OPTIMIZABLE
3308 }
3311 // [stack] OBJ OBJ
3313 }
3317 // [stack] OBJ LENGTH
3319 }
3322 // [stack] LENGTH OBJ
3324 }
3331 }
3334 // [stack] LENGTH OBJ OBJ
3336 }
3339 // [stack] LENGTH OBJ OBJ IDX
3341 }
3344 // [stack] LENGTH OBJ OBJ IDX IDX
3346 }
3349 // [stack] LENGTH OBJ OBJ IDX IDX LENGTH
3351 }
3354 // [stack] LENGTH OBJ OBJ IDX IS_IN_DENSE_BOUNDS
3356 }
3360 // [stack] LENGTH OBJ OBJ IDX
3362 }
3365 // [stack] LENGTH OBJ VALUE
3367 }
3370 // [stack] LENGTH OBJ OBJ IDX
3372 }
3375 // [stack] LENGTH OBJ
3377 }
3380 // [stack] LENGTH OBJ UNDEFINED
3382 }
3385 // [stack] LENGTH OBJ VALUE|UNDEFINED
3387 }
3390 // [stack] LENGTH OBJ
3392 }
3395 }
3398 // [stack] OBJ LENGTH
3400 }
3403 // [stack] OBJ
3405 }
3408 // [stack] OBJ OBJ
3410 }
3411 }
3414 // [stack] ... OBJ NEXT ITER
3416 }
3418 // For an empty pattern [], call IteratorClose unconditionally. Nothing
3419 // else needs to be done.
3422 // [stack] ... OBJ ITER NEXT
3424 }
3426 // [stack] ... OBJ ITER
3428 }
3431 // [stack] ... OBJ
3433 }
3437 // [stack] OBJ
3439 }
3440 }
3443 }
3445 // Push an initial FALSE value for DONE.
3447 // [stack] ... OBJ NEXT ITER FALSE
3449 }
3451 // TryNoteKind::Destructuring expects the iterator and the done value
3452 // to be the second to top and the top of the stack, respectively.
3453 // IteratorClose is called upon exception only if done is false.
3467 }
3474 }
3476 // Number of stack slots emitted for the LHS reference.
3479 // Spec requires LHS reference to be evaluated first.
3484 // [stack] ... OBJ NEXT ITER DONE LREF*
3485 };
3488 }
3489 }
3491 // Pick the DONE value to the top of the stack.
3494 // [stack] ... OBJ NEXT ITER LREF* DONE
3496 }
3497 }
3500 // If this element is the first, DONE is always FALSE, so pop it.
3501 //
3502 // Non-first elements should emit if-else depending on the
3503 // member pattern, below.
3505 // [stack] ... OBJ NEXT ITER LREF*
3507 }
3508 }
3513 // If spread is not the first element of the pattern,
3514 // iterator can already be completed.
3515 // [stack] ... OBJ NEXT ITER LREF* DONE
3518 // [stack] ... OBJ NEXT ITER LREF*
3520 }
3523 // [stack] ... OBJ NEXT ITER LREF* ARRAY
3525 }
3527 // [stack] ... OBJ NEXT ITER LREF*
3529 }
3530 }
3532 // If iterator is not completed, create a new array with the rest
3533 // of the iterator.
3535 // [stack] ... OBJ NEXT ITER LREF* NEXT ITER
3537 }
3539 // [stack] ... OBJ NEXT ITER LREF* NEXT ITER ARRAY
3541 }
3543 // [stack] ... OBJ NEXT ITER LREF* NEXT ITER ARRAY INDEX
3545 }
3547 // [stack] ... OBJ NEXT ITER LREF* ARRAY INDEX
3549 }
3551 // [stack] ... OBJ NEXT ITER LREF* ARRAY
3553 }
3558 }
3560 }
3562 // At this point the iterator is done. Unpick a TRUE value for DONE above
3563 // ITER.
3565 // [stack] ... OBJ NEXT ITER LREF* ARRAY TRUE
3567 }
3569 // [stack] ... OBJ NEXT ITER TRUE LREF* ARRAY
3571 }
3575 // [stack] ... OBJ NEXT ITER TRUE
3576 };
3579 }
3583 }
3587 // [stack] ... OBJ NEXT ITER LREF* DONE
3590 // [stack] ... OBJ NEXT ITER LREF*
3592 }
3595 // [stack] ... OBJ NEXT ITER LREF* UNDEF
3597 }
3599 // [stack] ... OBJ NEXT ITER LREF* UNDEF
3601 }
3603 // The iterator is done. Unpick a TRUE value for DONE above ITER.
3605 // [stack] ... OBJ NEXT ITER LREF* UNDEF TRUE
3607 }
3609 // [stack] ... OBJ NEXT ITER TRUE LREF* UNDEF
3611 }
3614 // [stack] ... OBJ NEXT ITER LREF*
3616 }
3617 }
3620 // [stack] ... OBJ NEXT ITER LREF* NEXT
3622 }
3624 // [stack] ... OBJ NEXT ITER LREF* RESULT
3626 }
3628 // [stack] ... OBJ NEXT ITER LREF* RESULT RESULT
3630 }
3632 // [stack] ... OBJ NEXT ITER LREF* RESULT DONE
3634 }
3637 // [stack] ... OBJ NEXT ITER LREF* RESULT DONE DONE
3639 }
3641 // [stack] ... OBJ NEXT ITER DONE LREF* RESULT DONE
3643 }
3647 // [stack] ... OBJ NEXT ITER DONE LREF* RESULT
3649 }
3652 // [stack] ... OBJ NEXT ITER DONE LREF*
3654 }
3656 // [stack] ... OBJ NEXT ITER DONE LREF* UNDEF
3658 }
3660 // [stack] ... OBJ NEXT ITER DONE LREF* UNDEF
3662 }
3665 // [stack] ... OBJ NEXT ITER DONE LREF* RESULT
3667 }
3670 // [stack] ... OBJ NEXT ITER DONE LREF* VALUE
3672 }
3676 }
3682 }
3684 }
3689 // [stack] ... OBJ NEXT ITER DONE LREF* VALUE
3690 };
3694 }
3695 }
3700 // [stack] ... OBJ NEXT ITER DONE
3701 };
3705 }
3708 // [stack] ... OBJ NEXT ITER DONE
3710 }
3711 }
3712 }
3714 // The last DONE value is on top of the stack. If not DONE, call
3715 // IteratorClose.
3716 // [stack] ... OBJ NEXT ITER DONE
3720 // [stack] ... OBJ NEXT ITER
3722 }
3724 // [stack] ... OBJ
3726 }
3728 // [stack] ... OBJ NEXT ITER
3730 }
3732 // [stack] ... OBJ ITER NEXT
3734 }
3736 // [stack] ... OBJ ITER
3738 }
3740 // [stack] ... OBJ
3742 }
3745 }
3749 // [stack] OBJ
3751 }
3752 }
3755 }
3760 }
3763 DestructuringFlavor flav) {
3766 // [stack] ... RHS
3770 // [stack] ... RHS
3772 }
3778 // [stack] ... RHS SET
3780 }
3783 // [stack] ... SET RHS
3785 }
3786 }
3800 }
3807 }
3809 // Number of stack slots emitted for the LHS reference.
3812 // Spec requires LHS reference to be evaluated first.
3814 // [stack] ... SET? RHS LREF*
3816 }
3818 // Duplicate the value being destructured to use as a reference base.
3820 // [stack] ... SET? RHS LREF* RHS
3822 }
3827 }
3830 // [stack] ... SET? RHS LREF* RHS TARGET
3832 }
3834 // [stack] ... SET? RHS LREF* RHS TARGET TARGET
3836 }
3838 // [stack] ... SET? RHS LREF* TARGET TARGET RHS
3840 }
3844 // [stack] ... RHS LREF* TARGET TARGET RHS SET
3846 }
3847 }
3852 // [stack] ... RHS LREF* TARGET
3854 }
3856 // Destructure TARGET per this member's lhs.
3858 // [stack] ... RHS
3860 }
3864 }
3866 // Now push the property value currently being matched, which is the value
3867 // of the current property name "label" on the left of a colon in the object
3868 // initialiser.
3872 // [stack] ... SET? RHS LREF* PROP
3874 }
3883 // [stack] ... SET? RHS LREF* PROP
3885 }
3889 // [stack]... SET? RHS LREF* RHS KEY
3891 }
3893 // Otherwise this is a computed property name. BigInt keys are parsed
3894 // as (synthetic) computed property names, too.
3898 // [stack] ... SET? RHS LREF* RHS KEY
3900 }
3902 // Add the computed property key to the exclusion set.
3905 // [stack] ... SET RHS LREF* RHS KEY SET
3907 }
3909 // [stack] ... SET RHS LREF* RHS KEY SET KEY
3911 }
3913 // [stack] ... SET RHS LREF* RHS KEY SET KEY UNDEFINED
3915 }
3917 // [stack] ... SET RHS LREF* RHS KEY SET
3919 }
3921 // [stack] ... SET RHS LREF* RHS KEY
3923 }
3924 }
3925 }
3927 // Get the property value.
3929 // [stack] ... SET? RHS LREF* PROP
3931 }
3932 }
3933 }
3937 // [stack] ... SET? RHS LREF* VALUE
3939 }
3940 }
3942 // Destructure PROP per this member's lhs.
3944 // [stack] ... SET? RHS
3946 }
3947 }
3950 }
3959 }
3961 propCount++;
3965 }
3971 }
3973 // Number and BigInt keys aren't yet supported. Computed property names need
3974 // to be added dynamically.
3979 }
3982 // JSOp::NewObject cannot accept dictionary-mode objects.
3984 }
3987 }
3993 // See if we can use ObjLiteral to construct the exclusion set object.
3996 // [stack] OBJ
3998 }
4000 // Take the slow but sure way and start off with a blank object.
4002 // [stack] OBJ
4004 }
4005 }
4011 }
4013 TaggedParserAtomIndex pnatom;
4024 }
4026 // Otherwise this is a computed property name which needs to be added
4027 // dynamically. BigInt keys are parsed as (synthetic) computed property
4028 // names, too.
4031 }
4032 }
4034 // Initialize elements with |undefined|.
4037 }
4042 }
4046 }
4047 }
4048 }
4051 }
4054 DestructuringFlavor flav) {
4057 }
4059 }
4068 // Skip empty strings. These are very common: a template string like
4069 // `${a}${b}` has three empty strings and without this optimization
4070 // we'd emit four JSOp::Add operations instead of just one.
4074 }
4077 // We update source notes before emitting the expression
4080 }
4081 }
4085 }
4088 // We need to convert the expression to a string
4091 }
4092 }
4095 // We've pushed two strings onto the stack. Add them together, leaving
4096 // just one.
4099 }
4102 }
4103 }
4106 // All strings were empty, this can happen for something like `${""}`.
4107 // Just push an empty string.
4111 }
4112 }
4115 }
4128 }
4131 // initializer can be null here.
4133 initializer)) {
4135 }
4143 }
4146 }
4149 }
4154 }
4158 }
4159 }
4160 }
4162 }
4168 // Nothing to do for initializer-less 'var' declarations, as there's no TDZ.
4171 }
4176 // [stack] ENV?
4178 }
4180 // Lexical declarations are initialized to undefined without an
4181 // initializer.
4183 "var declarations without initializers handled above, "
4186 // [stack] ENV? UNDEF
4188 }
4194 }
4197 }
4199 // [stack] ENV? V
4201 }
4202 }
4204 // [stack] V
4206 }
4208 // [stack]
4210 }
4213 }
4220 }
4222 }
4224 }
4226 // The RHS value to assign is already on the stack, i.e., the next enumeration
4227 // value in a for-in or for-of loop. Offset is the location in the stack of the
4228 // already-emitted rhs. If we emitted a JSOp::BindName or JSOp::BindGName, then
4229 // the scope is on the top of the stack and we need to dig one deeper to get
4230 // the right RHS value.
4234 }
4237 }
4272 // Short-circuit assignment operators are handled elsewhere.
4276 }
4277 }
4285 // We estimate the number of properties this could create
4286 // if used as constructor merely by counting this.foo = assignment
4287 // or init expressions;
4288 //
4289 // This currently doesn't handle this[x] = foo;
4294 propertyAdditionEstimate++;
4295 }
4296 }
4297 }
4303 // |name| is used within NameOpEmitter, so its lifetime must surpass |noe|.
4304 TaggedParserAtomIndex name;
4311 // Deal with non-name assignments.
4314 // Purpose of anonFunctionName:
4315 //
4316 // In normal name assignments (`f = function(){}`), an anonymous function gets
4317 // an inferred name based on the left-hand side name node.
4318 //
4319 // In normal property assignments (`obj.x = function(){}`), the anonymous
4320 // function does not have a computed name, and rhs->isDirectRHSAnonFunction()
4321 // will be false (and anonFunctionName will not be used). However, in field
4322 // initializers (`class C { x = function(){} }`), field initialization is
4323 // implemented via a property or elem assignment (where we are now), and
4324 // rhs->isDirectRHSAnonFunction() is set - so we'll assign the name of the
4325 // function.
4326 TaggedParserAtomIndex anonFunctionName;
4336 }
4348 }
4353 // [stack] THIS SUPERBASE
4355 }
4356 // SUPERBASE is pushed onto THIS later in poe->emitGet below.
4360 // [stack] OBJ
4362 }
4364 }
4366 }
4378 // [stack] # if Super
4379 // [stack] THIS KEY
4380 // [stack] # otherwise
4381 // [stack] OBJ KEY
4383 }
4385 // SUPERBASE is pushed onto KEY in eoe->emitGet below.
4389 }
4391 }
4400 // [stack] OBJ
4402 }
4404 // [stack] OBJ KEY
4406 }
4409 }
4416 }
4418 // Assignment to function calls is forbidden, but we have to make the
4419 // call first. Now we can throw.
4422 }
4424 // Rebalance the stack to placate stack-depth assertions.
4427 }
4431 }
4439 // [stack] # if Super
4440 // [stack] THIS SUPERBASE PROP
4441 // [stack] # otherwise
4442 // [stack] OBJ PROP
4444 }
4446 }
4449 // [stack] KEY THIS OBJ ELEM
4451 }
4453 }
4456 // [stack] OBJ KEY VALUE
4458 }
4460 }
4462 // We just emitted a JSOp::ThrowMsg and popped the call's return
4463 // value. Push a random value to make sure the stack depth is
4464 // correct.
4466 // [stack] NULL
4468 }
4471 }
4472 }
4477 // [stack] ENV? VAL?
4479 }
4484 // [stack] # if Simple Assignment with Super
4485 // [stack] THIS SUPERBASE
4486 // [stack] # if Simple Assignment with other
4487 // [stack] OBJ
4488 // [stack] # if Compound Assignment with Super
4489 // [stack] THIS SUPERBASE PROP
4490 // [stack] # if Compound Assignment with other
4491 // [stack] OBJ PROP
4493 }
4497 // [stack] # if Simple Assignment with Super
4498 // [stack] THIS KEY SUPERBASE
4499 // [stack] # if Simple Assignment with other
4500 // [stack] OBJ KEY
4501 // [stack] # if Compound Assignment with Super
4502 // [stack] THIS KEY SUPERBASE ELEM
4503 // [stack] # if Compound Assignment with other
4504 // [stack] OBJ KEY ELEM
4506 }
4509 // no stack adjustment needed
4513 }
4517 // [stack] ... VAL? RHS
4519 }
4521 // Assumption: Things with pre-emitted RHS values never need to be named.
4523 // [stack] ... VAL? RHS
4525 }
4526 }
4528 /* If += etc., emit the binary operator with a hint for the decompiler. */
4531 // [stack] ... VAL
4533 }
4535 // [stack] ... VAL
4537 }
4538 }
4540 /* Finally, emit the specialized assignment bytecode. */
4544 // [stack] VAL
4546 }
4548 }
4552 // [stack] VAL
4554 }
4556 }
4558 // We threw above, so nothing to do here.
4562 // [stack] VAL
4564 }
4566 }
4569 // [stack] VAL
4571 }
4578 }
4582 }
4584 }
4589 JSOp op;
4602 }
4607 // |name| is used within NameOpEmitter, so its lifetime must surpass |noe|.
4608 TaggedParserAtomIndex name;
4610 // Select the appropriate emitter based on the left-hand side.
4618 // Number of values pushed onto the stack in addition to the lhs value.
4621 // Evaluate the left-hand side expression and compute any stack values needed
4622 // for the assignment.
4629 // [stack] ENV? LHS
4631 }
4635 }
4647 }
4652 // [stack] THIS SUPERBASE
4654 }
4657 // [stack] OBJ
4659 }
4660 }
4663 // [stack] # if Super
4664 // [stack] THIS SUPERBASE LHS
4665 // [stack] # otherwise
4666 // [stack] OBJ LHS
4668 }
4671 // [stack] # if Super
4672 // [stack] THIS SUPERBASE LHS
4673 // [stack] # otherwise
4674 // [stack] OBJ LHS
4676 }
4680 }
4691 // [stack] # if Super
4692 // [stack] THIS KEY
4693 // [stack] # otherwise
4694 // [stack] OBJ KEY
4696 }
4699 // [stack] # if Super
4700 // [stack] THIS KEY SUPERBASE LHS
4701 // [stack] # otherwise
4702 // [stack] OBJ KEY LHS
4704 }
4707 // [stack] # if Super
4708 // [stack] THIS KEY SUPERBASE LHS
4709 // [stack] # otherwise
4710 // [stack] OBJ KEY LHS
4712 }
4716 }
4723 // [stack] OBJ
4725 }
4727 // [stack] OBJ NAME
4729 }
4731 // [stack] OBJ NAME LHS
4733 }
4736 }
4740 }
4744 // Test for the short-circuit condition.
4745 JumpList jump;
4747 // [stack] ... LHS
4749 }
4751 // The short-circuit condition wasn't fulfilled, pop the left-hand side value
4752 // which was kept on the stack.
4754 // [stack] ...
4756 }
4759 // [stack] ... RHS
4761 }
4763 // Perform the actual assignment.
4767 // [stack] RHS
4769 }
4771 }
4777 // [stack] RHS
4779 }
4781 }
4785 // [stack] RHS
4787 }
4789 }
4793 // [stack] RHS
4795 }
4800 }
4804 // Join with the short-circuit jump and pop anything left on the stack.
4806 JumpList jumpAroundPop;
4808 // [stack] RHS
4810 }
4813 // [stack] ... LHS
4815 }
4817 // Reconstruct the stack depth after the jump.
4820 // Move the left-hand side value to the bottom and pop the rest.
4822 // [stack] LHS ...
4824 }
4826 // [stack] LHS
4828 }
4831 // [stack] LHS | RHS
4833 }
4836 // [stack] LHS | RHS
4838 }
4839 }
4844 }
4856 }
4857 idx++;
4858 }
4862 }
4867 // The first element of a call-site node is the raw-values list. Skip over it.
4875 ObjLiteralWriter writer;
4879 // Write elements of the two arrays: the 'cooked' values followed by the
4880 // 'raw' values.
4885 }
4888 }
4890 GCThingIndex cookedIndex;
4893 }
4898 }
4901 // We must be nested under a try-finally statement.
4906 // Catch parameter was omitted; just discard the exception.
4909 }
4917 }
4920 }
4926 }
4929 }
4934 }
4935 }
4937 /* Emit the catch body. */
4939 }
4941 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See the
4942 // comment on EmitSwitch.
4953 }
4957 }
4962 }
4966 }
4968 // If this try has a catch block, emit it.
4970 // The emitted code for a catch block looks like:
4971 //
4972 // [pushlexicalenv] only if any local aliased
4973 // exception
4974 // setlocal 0; pop assign or possibly destructure exception
4975 // < catch block contents >
4976 // debugleaveblock
4977 // [poplexicalenv] only if any local aliased
4978 // if there is a finally block:
4979 // goto <finally>
4980 // [jump target for returning from finally]
4981 // goto <after finally>
4984 }
4986 // Emit the lexical scope and catch body.
4989 }
4990 }
4992 // Emit the finally handler, if there is one.
4996 }
5000 }
5001 }
5005 }
5008 }
5012 // Push the continuation index.
5015 }
5017 // Push |throwing|.
5020 }
5022 // Jump to the finally block.
5025 }
5028 }
5035 }
5037 if_again:
5043 }
5047 }
5049 // Emit code for the condition before pushing stmtInfo.
5050 // NOTE: NotExpr of testNode may be unwrapped, and in that case the negation
5051 // is handled by conditionKind.
5054 }
5060 }
5064 }
5065 }
5067 /* Emit code for the then part. */
5070 }
5078 }
5081 }
5085 }
5087 /* Emit code for the else part. */
5090 }
5091 }
5095 }
5098 }
5103 // We can call this multiple times for sloppy eval scopes.
5106 }
5116 }
5117 }
5123 }
5124 }
5125 }
5128 }
5134 // This block contains function statements whose definitions are
5135 // hoisted to the top of the block. Emit these as a separate pass
5136 // before the rest of the block.
5139 }
5140 }
5142 // Line notes were updated by emitLexicalScope or emitScript.
5144 }
5146 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
5147 // the comment on emitSwitch.
5156 }
5160 }
5164 }
5167 }
5169 // We are about to emit some bytecode for what the spec calls "declaration
5170 // instantiation". Assign these instructions to the opening `{` of the
5171 // block. (Using the location of each declaration we're instantiating is
5172 // too weird when stepping in the debugger.)
5176 }
5177 }
5179 ScopeKind kind;
5182 kind =
5188 }
5192 }
5195 // for loops need to emit JSOp::FreshenLexicalEnv/JSOp::RecreateLexicalEnv
5196 // if there are lexical declarations in the head. Signal this by passing a
5197 // non-nullptr lexical scope.
5200 }
5204 }
5205 }
5209 }
5211 }
5214 // Ensure that the column of the 'with' is set properly.
5217 }
5221 }
5225 }
5230 }
5234 }
5237 }
5245 // [stack] TARGET SOURCE SET
5250 // [stack] TARGET SOURCE SET COPYDATAPROPERTIES
5252 }
5255 // [stack] TARGET SOURCE
5261 // [stack] TARGET SOURCE COPYDATAPROPERTIES
5263 }
5264 }
5267 // [stack] TARGET SOURCE SET? COPYDATAPROPERTIES
5268 // UNDEFINED
5270 }
5272 // [stack] SOURCE SET? COPYDATAPROPERTIES UNDEFINED
5273 // TARGET
5275 }
5277 // [stack] SET? COPYDATAPROPERTIES UNDEFINED TARGET
5278 // SOURCE
5280 }
5283 // [stack] COPYDATAPROPERTIES UNDEFINED TARGET SOURCE SET
5285 }
5286 }
5287 // Callee is always self-hosted instrinsic, and cannot be content function.
5289 // [stack] IGNORED
5291 }
5294 // [stack]
5296 }
5300 }
5303 GCThingIndex index;
5306 }
5308 }
5311 SelfHostedIter selfHostedIter,
5312 IteratorKind iterKind) {
5316 // [stack] ITERABLE
5318 }
5323 // [stack] ITERABLE
5327 // This is the following case:
5328 //
5329 // for (const nextValue of allowContentIterWith(items, usingIterator)) {
5330 //
5331 // `items` is emitted by `emitTree(value)` above, and the result is on the
5332 // stack as ITERABLE.
5333 // `usingIterator` is the value of `items[Symbol.iterator]`, that's
5334 // already retrieved.
5340 // [stack] ITERABLE ITERFN
5342 }
5344 // Async iterator has two possible iterators: An async iterator and a sync
5345 // iterator.
5348 // [stack] ITERABLE ASYNC_ITERFN SYNC_ITERFN
5350 }
5351 }
5353 // [stack] ITERABLE ASYNC_ITERFN? SYNC_ITERFN
5355 }
5358 // This is the following case:
5359 //
5360 // for (const nextValue of allowContentIterWithNext(iterator, next)) {
5361 //
5362 // `iterator` is emitted by `emitTree(value)` above, and the result is on
5363 // the stack as ITER.
5364 // `next` is the value of `iterator.next`, that's already retrieved.
5369 // [stack] ITER NEXT
5371 }
5374 // [stack] NEXT ITER
5376 }
5378 // [stack] NEXT ITER
5380 }
5381 }
5384 }
5389 "[Symbol.iterator]() call is prohibited in self-hosted code "
5393 // [stack] NEXT ITER
5395 // Nothing to do, stack already contains the iterator and its `next` method.
5397 }
5400 // [stack] OBJ
5402 // Convert iterable to iterator.
5404 // [stack] OBJ OBJ
5406 }
5408 // [stack] OBJ OBJ @@ITERATOR
5410 }
5412 // [stack] OBJ ITERFN
5414 }
5415 }
5418 // [stack] ITERFN OBJ
5420 }
5422 // [stack] ITER
5424 }
5426 // [stack] ITER
5428 }
5430 // [stack] ITER ITER
5432 }
5434 // [stack] ITER NEXT
5436 }
5438 // [stack] NEXT ITER
5440 }
5442 }
5448 "[Symbol.asyncIterator]() call is prohibited in self-hosted code "
5452 // [stack] OBJ
5454 // Convert iterable to iterator.
5456 // [stack] OBJ OBJ
5458 }
5460 // [stack] OBJ OBJ @@ASYNCITERATOR
5462 }
5464 // [stack] OBJ ASYNC_ITERFN
5466 }
5468 // [stack] OBJ ASYNC_ITERFN SYNC_ITERFN
5471 // [stack] OBJ SYNC_ITERFN ASYNC_ITERFN
5473 }
5474 }
5478 // [stack] OBJ SYNC_ITERFN? ASYNC_ITERFN NULL-OR-UNDEF
5480 }
5482 // [stack] OBJ SYNC_ITERFN? ASYNC_ITERFN
5484 }
5487 // [stack] OBJ SYNC_ITERFN?
5489 }
5493 // [stack] OBJ OBJ
5495 }
5497 // [stack] OBJ OBJ @@ITERATOR
5499 }
5501 // [stack] OBJ SYNC_ITERFN
5503 }
5505 // [stack] OBJ SYNC_ITERFN
5506 }
5509 // [stack] SYNC_ITERFN OBJ
5511 }
5513 // [stack] ITER
5515 }
5517 // [stack] ITER
5519 }
5522 // [stack] ITER ITER
5524 }
5526 // [stack] ITER SYNCNEXT
5528 }
5531 // [stack] ITER
5533 }
5536 // [stack] OBJ SYNC_ITERFN? ASYNC_ITERFN
5538 }
5542 // [stack] OBJ ASYNC_ITERFN SYNC_ITERFN
5544 }
5546 // [stack] OBJ ASYNC_ITERFN
5548 }
5549 }
5552 // [stack] ASYNC_ITERFN OBJ
5554 }
5556 // [stack] ITER
5558 }
5560 // [stack] ITER
5562 }
5565 // [stack] ITER
5567 }
5570 // [stack] ITER ITER
5572 }
5574 // [stack] ITER NEXT
5576 }
5578 // [stack] NEXT ITER
5580 }
5583 }
5586 // [stack] NEXT ITER ARR I
5588 // [stack] ARR FINAL_INDEX
5589 }
5594 // In the [stack] annotations, (spreadee) can be "ARR I" (when spreading
5595 // into an array or into call parameters, or "TUPLE" (when spreading into a
5596 // tuple)
5599 // [stack] NEXT ITER (spreadee)
5601 }
5603 {
5604 #ifdef DEBUG
5606 #endif
5608 // Spread operations can't contain |continue|, so don't bother setting loop
5609 // and enclosing "update" offsets, as we do with for-loops.
5612 // [stack] NEXT ITER (spreadee) NEXT ITER
5614 }
5616 // [stack] NEXT ITER (spreadee) RESULT
5618 }
5620 // [stack] NEXT ITER (spreadee) RESULT RESULT
5622 }
5624 // [stack] NEXT ITER (spreadee) RESULT DONE
5626 }
5628 // [stack] NEXT ITER (spreadee) RESULT
5630 }
5632 // Emit code to assign result.value to the iteration variable.
5634 // [stack] NEXT ITER (spreadee) VALUE
5636 }
5638 // [stack] NEXT ITER (spreadee)
5640 }
5643 // [stack] NEXT ITER (spreadee)
5645 }
5648 }
5650 // When we leave the loop body and jump to this point, the result value is
5651 // still on the stack. Account for that by updating the stack depth
5652 // manually.
5655 // No continues should occur in spreads.
5659 // [stack] ITER (spreadee) RESULT NEXT
5661 }
5663 // [stack] (spreadee) RESULT NEXT ITER
5665 }
5668 // [stack] (spreadee)
5669 }
5681 // If the for-in/of loop didn't have a variable declaration, per-loop
5682 // initialization is just assigning the iteration value to a target
5683 // expression.
5686 // [stack] ... ITERVAL
5687 }
5689 // Otherwise, per-loop initialization is (possibly) declaration
5690 // initialization. If the declaration is a lexical declaration, it must be
5691 // initialized. If the declaration is a variable declaration, an
5692 // assignment to that name (which does *not* necessarily assign to the
5693 // variable!) must be generated.
5698 }
5709 }
5710 }
5717 }
5719 // Per-iteration initialization in for-in/of loops computes the
5720 // iteration value *before* initializing. Thus the initializing
5721 // value may be buried under a bind-specific value on the stack.
5722 // Swap it to the top of the stack.
5726 }
5728 // In cases of emitting a frame slot or environment slot,
5729 // nothing needs be done.
5731 }
5734 }
5736 // The caller handles removing the iteration value from the stack.
5738 }
5748 }
5758 IteratorKind iterKind =
5766 // Certain builtins (e.g. Array.from) are implemented in self-hosting
5767 // as for-of loops.
5772 // [stack]
5774 }
5778 }
5781 }
5783 // [stack] ITERABLE
5785 }
5791 }
5794 // [stack] NEXT ITER VALUE
5796 }
5799 // [stack] NEXT ITER VALUE
5801 }
5804 // [stack] NEXT ITER UNDEF
5806 }
5808 // Perform the loop body.
5811 // [stack] NEXT ITER UNDEF
5813 }
5816 // [stack]
5818 }
5821 }
5830 // Annex B: Evaluate the var-initializer expression if present.
5831 // |for (var i = initializer in expr) { ... }|
5848 }
5854 }
5857 }
5860 }
5862 // Pop the initializer.
5865 }
5866 }
5867 }
5868 }
5871 // [stack]
5873 }
5875 // Evaluate the expression being iterated.
5880 }
5883 }
5885 // [stack] EXPR
5887 }
5896 // [stack] ITER ITERVAL
5898 }
5901 // [stack] ITER ITERVAL
5903 }
5906 // [stack] ITER ITERVAL
5908 }
5910 // Perform the loop body.
5913 // [stack] ITER ITERVAL
5915 }
5918 // [stack]
5920 }
5923 }
5925 /* C-style `for (init; cond; update) ...` loop. */
5938 // [stack]
5940 }
5942 // If the head of this for-loop declared any lexical variables, the parser
5943 // wrapped this ParseNodeKind::For node in a ParseNodeKind::LexicalScope
5944 // representing the implicit scope of those variables. By the time we get
5945 // here, we have already entered that scope. So far, so good.
5947 // Emit the `init` clause, whether it's an expression or a variable
5948 // declaration. (The loop variables were hoisted into an enclosing
5949 // scope, but we still need to emit code for the initializers.)
5954 // [stack]
5956 }
5960 }
5963 }
5965 // 'init' is an expression, not a declaration. emitTree left its
5966 // value on the stack.
5968 // [stack] VAL
5970 }
5972 // [stack]
5974 }
5975 }
5976 }
5979 // [stack]
5981 }
5986 }
5989 }
5991 // [stack] VAL
5993 }
5994 }
5998 // [stack]
6000 }
6003 // [stack]
6005 }
6010 // [stack]
6012 }
6014 // Check for update code to do before the condition (if any).
6018 }
6021 }
6023 // [stack] VAL
6025 }
6026 }
6029 // [stack]
6031 }
6034 }
6040 }
6044 }
6048 }
6052 }
6058 // [stack]
6065 // |wasEmittedByEnclosingScript| flag is set to true once the function has
6066 // been emitted. Function definitions that need hoisting to the top of the
6067 // function will be seen by emitFunction in two places.
6070 // [stack]
6072 }
6077 // [stack] FUN?
6078 }
6081 // [stack]
6083 }
6088 }
6090 /* We measured the max scope depth when we parsed the function. */
6093 }
6096 // [stack] FUN?
6098 }
6101 // [stack]
6103 }
6104 }
6106 // Track the last emitted top-level self-hosted function, so that intrinsics
6107 // can adjust attributes at parse time.
6108 //
6109 // NOTE: We also disallow lambda functions in the top-level body. This is done
6110 // to simplify handling of the self-hosted stencil. Within normal function
6111 // declarations there are no such restrictions.
6117 }
6118 }
6121 }
6129 }
6133 }
6137 }
6142 }
6145 }
6148 }
6152 }
6155 }
6166 }
6170 }
6173 }
6176 }
6180 }
6183 }
6187 }
6190 }
6195 // Any statement with the matching label may be the break target.
6198 };
6203 };
6205 }
6208 }
6213 // Find the loop statement enclosed by the matching label.
6219 }
6221 }
6224 }
6226 }
6234 }
6237 // [stack] THIS
6239 }
6242 // [stack] THIS
6244 }
6245 }
6248 }
6254 // [stack] THIS
6255 }
6261 // [stack] THIS
6262 }
6266 // [stack] UNDEF
6267 }
6275 // [stack] THIS
6276 }
6279 // [stack] THIS
6280 }
6287 }
6290 }
6293 }
6295 }
6301 // [stack] NEW.TARGET
6303 }
6305 }
6312 }
6318 // The parser is responsible for marking the "new.target" binding as being
6319 // implicitly used in super() calls.
6321 }
6326 }
6330 }
6332 /* Push a return value */
6336 }
6342 }
6343 }
6345 /* No explicit return value provided */
6348 }
6349 }
6351 // We know functionBodyEndPos is set because "return" is only
6352 // valid in a function, and so we've passed through
6353 // emitFunctionScript.
6356 }
6358 /*
6359 * The return value is currently on the stack. We would like to
6360 * generate JSOp::Return, but if we have work to do before returning,
6361 * we will instead generate JSOp::SetRval / JSOp::RetRval.
6362 *
6363 * We don't know whether we will need fixup code until after calling
6364 * prepareForNonLocalJumpToOutermost, so we start by generating
6365 * JSOp::SetRval, then mutate it to JSOp::Return in finishReturn if it
6366 * wasn't needed.
6367 */
6371 }
6375 }
6378 // The return value is currently in rval. Depending on the current function,
6379 // we may have to do additional work before returning:
6380 // - Derived class constructors must check if the return value is an object.
6381 // - Generators and async functions must do a final yield.
6382 // - Non-async generators must return the value as an iterator result:
6383 // { value: <rval>, done: true }
6384 // - Non-generator async functions must resolve the function's result promise
6385 // with the value.
6386 //
6387 // If we have not generated any code since the SetRval that stored the return
6388 // value, we can also optimize the bytecode by rewriting that SetRval as a
6389 // JSOp::Return. See |emitReturn| above.
6404 }
6406 }
6411 }
6413 }
6420 }
6422 // Nothing special needs to be done.
6424 }
6433 }
6438 }
6443 }
6446 // [stack] RVAL GENERATOR RESUMEKIND
6448 }
6450 // [stack] RVAL
6452 }
6454 // [stack]
6456 }
6459 }
6469 // [stack] ITEROBJ
6471 }
6472 }
6475 // [stack] ITEROBJ? VAL
6477 }
6480 // [stack] ITEROBJ? UNDEFINED
6482 }
6483 }
6488 // [stack] RESULT
6490 }
6491 }
6495 // [stack] ITEROBJ
6497 }
6498 }
6501 // [stack] # if needsIteratorResult
6502 // [stack] ITEROBJ .GENERATOR
6503 // [stack] # else
6504 // [stack] RESULT .GENERATOR
6506 }
6509 // [stack] YIELDRESULT GENERATOR RESUMEKIND
6511 }
6514 // [stack] YIELDRESULT
6516 }
6519 }
6527 }
6529 }
6533 // [stack] VALUE CANSKIP
6535 }
6538 // [stack] VALUE_OR_RESOLVED CANSKIP
6540 }
6544 // [stack] VALUE_OR_RESOLVED
6546 }
6550 // [stack] VALUE GENERATOR
6552 }
6554 // [stack] PROMISE
6556 }
6557 }
6560 // [stack] VALUE|PROMISE GENERATOR
6562 }
6564 // [stack] RESOLVED GENERATOR RESUMEKIND
6566 }
6568 // [stack] RESOLVED
6570 }
6574 }
6579 }
6581 // ES2019 draft rev 49b781ec80117b60f73327ef3054703a3111e40c
6582 // 14.4.14 Runtime Semantics: Evaluation
6583 // YieldExpression : yield* AssignmentExpression
6586 "yield* is prohibited in self-hosted code because it can run "
6592 // Step 1.
6598 // Steps 2-5.
6600 // [stack] ITERABLE
6602 }
6605 // [stack] NEXT ITER
6607 }
6610 // [stack] NEXT ITER
6612 }
6613 }
6615 // Step 6.
6616 // Start with NormalCompletion(undefined).
6618 // [stack] NEXT ITER RECEIVED
6620 }
6622 // [stack] NEXT ITER RECEIVED RESUMEKIND
6624 }
6629 // Step 7 is a loop.
6632 // [stack] NEXT ITER RECEIVED RESUMEKIND
6634 }
6636 // Step 7.a. Check for Normal completion.
6638 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND
6640 }
6642 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND NORMAL
6644 }
6646 // [stack] NEXT ITER RECEIVED RESUMEKIND IS_NORMAL
6648 }
6652 // [stack] NEXT ITER RECEIVED RESUMEKIND
6654 }
6655 {
6657 // [stack] NEXT ITER RECEIVED
6659 }
6661 // Step 7.a.i.
6662 // result = iter.next(received)
6664 // [stack] RECEIVED NEXT ITER
6666 }
6668 // [stack] RECEIVED NEXT ITER NEXT ITER
6670 }
6672 // [stack] NEXT ITER NEXT ITER RECEIVED
6674 }
6676 // [stack] NEXT ITER RESULT
6678 }
6680 // Step 7.a.ii.
6683 // [stack] NEXT ITER RESULT
6685 }
6686 }
6688 // Step 7.a.iii.
6690 // [stack] NEXT ITER RESULT
6692 }
6694 // Bytecode for steps 7.a.iv-vii is emitted after the ifKind if-else because
6695 // it's shared with other branches.
6696 }
6698 // Step 7.b. Check for Throw completion.
6700 // [stack] NEXT ITER RECEIVED RESUMEKIND
6702 }
6704 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND
6706 }
6708 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND THROW
6710 }
6712 // [stack] NEXT ITER RECEIVED RESUMEKIND IS_THROW
6714 }
6716 // [stack] NEXT ITER RECEIVED RESUMEKIND
6718 }
6719 {
6721 // [stack] NEXT ITER RECEIVED
6723 }
6724 // Step 7.b.i.
6726 // [stack] NEXT ITER RECEIVED ITER
6728 }
6730 // [stack] NEXT ITER RECEIVED ITER ITER
6732 }
6735 // [stack] NEXT ITER RECEIVED ITER THROW
6737 }
6739 // Step 7.b.ii.
6742 // [stack] NEXT ITER RECEIVED ITER THROW NULL-OR-UNDEF
6744 }
6748 // [stack] NEXT ITER RECEIVED ITER THROW
6750 }
6752 // Step 7.b.ii.1.
6753 // RESULT = ITER.throw(EXCEPTION)
6755 // [stack] NEXT ITER RECEIVED THROW ITER
6757 }
6759 // [stack] NEXT ITER THROW ITER RECEIVED
6761 }
6763 // [stack] NEXT ITER RESULT
6765 }
6767 // Step 7.b.ii.2.
6770 // [stack] NEXT ITER RESULT
6772 }
6773 }
6775 // Step 7.b.ii.4.
6777 // [stack] NEXT ITER RESULT
6779 }
6781 // Bytecode for steps 7.b.ii.5-8 is emitted after the ifKind if-else because
6782 // it's shared with other branches.
6784 // Step 7.b.iii.
6786 // [stack] NEXT ITER RECEIVED ITER THROW
6788 }
6790 // [stack] NEXT ITER RECEIVED ITER
6792 }
6794 // Steps 7.b.iii.1-4.
6795 //
6796 // If the iterator does not have a "throw" method, it calls IteratorClose
6797 // and then throws a TypeError.
6799 // [stack] NEXT ITER RECEIVED ITER
6801 }
6802 // Steps 7.b.iii.5-6.
6804 // [stack] NEXT ITER RECEIVED ITER
6805 // [stack] # throw
6807 }
6811 }
6812 }
6814 // Step 7.c. It must be a Return completion.
6816 // [stack] NEXT ITER RECEIVED RESUMEKIND
6818 }
6819 {
6821 // [stack] NEXT ITER RECEIVED
6823 }
6825 // Step 7.c.i.
6826 //
6827 // Call iterator.return() for receiving a "forced return" completion from
6828 // the generator.
6830 // Step 7.c.ii.
6831 //
6832 // Get the "return" method.
6834 // [stack] NEXT ITER RECEIVED ITER
6836 }
6838 // [stack] NEXT ITER RECEIVED ITER ITER
6840 }
6843 // [stack] NEXT ITER RECEIVED ITER RET
6845 }
6847 // Step 7.c.iii.
6848 //
6849 // Do nothing if "return" is undefined or null.
6852 // [stack] NEXT ITER RECEIVED ITER RET NULL-OR-UNDEF
6854 }
6856 // Step 7.c.iv.
6857 //
6858 // Call "return" with the argument passed to Generator.prototype.return.
6861 // [stack] NEXT ITER RECEIVED ITER RET
6863 }
6865 // [stack] NEXT ITER RECEIVED RET ITER
6867 }
6869 // [stack] NEXT ITER RET ITER RECEIVED
6871 }
6875 // [stack] NEXT ITER RET ITER VAL
6877 }
6878 }
6880 // [stack] NEXT ITER RESULT
6882 }
6884 // Step 7.c.v.
6887 // [stack] NEXT ITER RESULT
6889 }
6890 }
6892 // Step 7.c.vi.
6894 // [stack] NEXT ITER RESULT
6896 }
6898 // Check if the returned object from iterator.return() is done. If not,
6899 // continue yielding.
6901 // Steps 7.c.vii-viii.
6904 // [stack] NEXT ITER RESULT RESULT
6906 }
6908 // [stack] NEXT ITER RESULT DONE
6910 }
6912 // [stack] NEXT ITER RESULT
6914 }
6916 // Step 7.c.viii.1.
6918 // [stack] NEXT ITER VALUE
6920 }
6923 // [stack] NEXT ITER VALUE RESULT
6925 }
6927 // [stack] NEXT ITER RESULT VALUE
6929 }
6931 // [stack] NEXT ITER RESULT
6933 }
6934 }
6937 // [stack] NEXT ITER RESULT
6939 }
6941 // Jump to continue label for steps 7.c.ix-x.
6943 // [stack] NEXT ITER RESULT
6945 }
6948 // [stack] NEXT ITER RESULT
6950 }
6952 // Step 7.c.iii.
6954 // [stack] NEXT ITER RECEIVED ITER RET
6956 }
6958 // [stack] NEXT ITER RECEIVED
6960 }
6962 // Step 7.c.iii.1.
6964 // [stack] NEXT ITER RECEIVED
6966 }
6967 }
6969 // [stack] NEXT ITER RECEIVED
6971 }
6973 // Perform a "forced generator return".
6974 //
6975 // Step 7.c.iii.2.
6976 // Step 7.c.viii.2.
6978 // [stack] NEXT ITER RESULT GENOBJ
6980 }
6982 // [stack] NEXT ITER RESULT GENOBJ RESUMEKIND
6984 }
6986 // [stack] NEXT ITER RESULT GENOBJ RESUMEKIND
6988 }
6989 }
6992 // [stack] NEXT ITER RESULT
6994 }
6996 // Shared tail for Normal/Throw completions.
6997 //
6998 // Steps 7.a.iv-v.
6999 // Steps 7.b.ii.5-6.
7000 //
7001 // [stack] NEXT ITER RESULT
7003 // if (result.done) break;
7005 // [stack] NEXT ITER RESULT RESULT
7007 }
7009 // [stack] NEXT ITER RESULT DONE
7011 }
7013 // [stack] NEXT ITER RESULT
7015 }
7017 // Steps 7.a.vi-vii.
7018 // Steps 7.b.ii.7-8.
7019 // Steps 7.c.ix-x.
7021 // [stack] NEXT ITER RESULT
7023 }
7026 // [stack] NEXT ITER RESULT
7028 }
7029 }
7031 // [stack] NEXT ITER RESULT GENOBJ
7033 }
7035 // [stack] NEXT ITER RVAL GENOBJ RESUMEKIND
7037 }
7039 // [stack] NEXT ITER RVAL RESUMEKIND GENOBJ
7041 }
7043 // [stack] NEXT ITER RVAL RESUMEKIND
7045 }
7047 // [stack] NEXT ITER RVAL RESUMEKIND
7049 }
7051 // Jumps to this point have 3 (instead of 4) values on the stack.
7055 // [stack] NEXT ITER RESULT
7057 // Step 7.a.v.1.
7058 // Step 7.b.ii.6.a.
7059 //
7060 // result.value
7062 // [stack] RESULT NEXT ITER
7064 }
7066 // [stack] RESULT
7068 }
7070 // [stack] VALUE
7072 }
7077 }
7083 }
7084 }
7086 }
7091 /*
7092 * Top-level or called-from-a-native JS_Execute/EvaluateScript,
7093 * debugger, and eval frames may need the value of the ultimate
7094 * expression statement as the script's result, despite the fact
7095 * that it appears useless to the compiler.
7096 *
7097 * API users may also set the ReadOnlyCompileOptions::noScriptRval option when
7098 * calling JS_Compile* to suppress JSOp::SetRval.
7099 */
7104 }
7106 /* Don't eliminate expressions with side effects. */
7111 }
7113 /*
7114 * Don't eliminate apparently useless expressions if they are labeled
7115 * expression statements. The startOffset() test catches the case
7116 * where we are nesting in emitTree for a labeled compound statement.
7117 */
7123 }
7124 }
7127 ValueUsage valueUsage =
7132 }
7135 }
7138 }
7141 }
7142 }
7145 }
7154 }
7165 // The expression |delete super.foo;| has to evaluate |super.foo|,
7166 // which could throw if |this| hasn't yet been set by a |super(...)|
7167 // call or the super-base is not an object, before throwing a
7168 // ReferenceError for attempting to delete a super-reference.
7171 // [stack] THIS
7173 }
7177 }
7179 // [stack] OBJ
7181 }
7182 }
7185 // [stack] # if Super
7186 // [stack] THIS
7187 // [stack] # otherwise
7188 // [stack] SUCCEEDED
7190 }
7193 }
7207 // The expression |delete super[foo];| has to evaluate |super[foo]|,
7208 // which could throw if |this| hasn't yet been set by a |super(...)|
7209 // call, or trigger side-effects when evaluating ToPropertyKey(foo),
7210 // or also throw when the super-base is not an object, before throwing
7211 // a ReferenceError for attempting to delete a super-reference.
7213 // [stack]
7215 }
7219 // [stack] THIS
7221 }
7223 // [stack] THIS
7225 }
7227 // [stack] THIS KEY
7229 }
7232 // [stack] OBJ KEY
7234 }
7235 }
7237 // [stack] # if Super
7238 // [stack] THIS
7239 // [stack] # otherwise
7240 // [stack] SUCCEEDED
7242 }
7245 }
7252 // If useless, just emit JSOp::True; otherwise convert |delete <expr>| to
7253 // effectively |<expr>, true|.
7257 }
7262 }
7265 }
7266 }
7269 }
7282 // [stack] # If shortcircuit
7283 // [stack] UNDEFINED-OR-NULL
7284 // [stack] # otherwise
7285 // [stack] SUCCEEDED
7287 }
7290 }
7295 // [stack] # If shortcircuit
7296 // [stack] UNDEFINED-OR-NULL
7297 // [stack] # otherwise
7298 // [stack] SUCCEEDED
7300 }
7302 }
7305 }
7308 // [stack] # If shortcircuit
7309 // [stack] TRUE
7310 // [stack] # otherwise
7311 // [stack] SUCCEEDED
7313 }
7316 }
7326 // [stack]
7328 }
7330 // [stack] OBJ
7332 }
7335 // [stack] # if Jump
7336 // [stack] UNDEFINED-OR-NULL
7337 // [stack] # otherwise
7338 // [stack] OBJ
7340 }
7341 }
7344 // [stack] SUCCEEDED
7346 }
7349 }
7359 // [stack]
7361 }
7364 // [stack] OBJ
7366 }
7370 // [stack] # if Jump
7371 // [stack] UNDEFINED-OR-NULL
7372 // [stack] # otherwise
7373 // [stack] OBJ
7375 }
7376 }
7379 // [stack] OBJ
7381 }
7384 // [stack] OBJ KEY
7386 }
7389 // [stack] SUCCEEDED
7391 }
7394 }
7397 // [stack] CALLEE
7399 #ifdef DEBUG
7401 // [stack] CALLEE
7403 }
7404 #endif
7407 }
7410 // Special-casing of callFunction to emit bytecode that directly
7411 // invokes the callee with the correct |this| object and arguments.
7412 // callFunction(fun, thisArg, arg0, arg1) thus becomes:
7413 // - emit lookup for fun
7414 // - emit lookup for thisArg
7415 // - emit lookups for arg0, arg1
7416 //
7417 // argc is set to the amount of actually emitted args and the
7418 // emitting of args below is disabled by setting emitArgs to false.
7432 // [stack] CALLEE
7434 }
7436 #ifdef DEBUG
7441 // [stack] CALLEE
7443 }
7444 }
7445 #endif
7449 // Save off the new.target value, but here emit a proper |this| for a
7450 // constructing call.
7452 // [stack] CALLEE IS_CONSTRUCTING
7454 }
7456 // It's |this|, emit it.
7458 // [stack] CALLEE THIS
7460 }
7461 }
7465 // [stack] CALLEE ... ARGS...
7467 }
7468 }
7472 // [stack] CALLEE IS_CONSTRUCTING ARGS... NEW.TARGET
7474 }
7475 }
7479 // [stack] RVAL
7481 }
7484 }
7489 // Syntax: resumeGenerator(gen, value, 'next'|'throw'|'return')
7494 // [stack] GENERATOR
7496 }
7500 // [stack] GENERATOR VALUE
7502 }
7506 GeneratorResumeKind kind =
7511 // [stack] GENERATOR VALUE RESUMEKIND
7513 }
7516 // [stack] RVAL
7518 }
7521 }
7524 // JSScript::hasForceInterpreterOp() relies on JSOp::ForceInterpreter being
7525 // the first bytecode op in the script.
7530 }
7533 }
7536 }
7543 // We're just here as a sentinel. Pass the value through directly.
7545 }
7552 // We're just here as a sentinel. Pass the value through directly.
7554 }
7562 // We're just here as a sentinel. Pass the value through directly.
7564 }
7569 // Only optimize when 3 arguments are passed.
7575 }
7580 }
7585 }
7587 // This will leave the object on the stack instead of pushing |undefined|,
7588 // but that's fine because the self-hosted code doesn't use the return
7589 // value.
7591 }
7601 }
7606 }
7609 }
7622 }
7626 }
7630 }
7633 }
7644 }
7647 }
7658 }
7661 }
7671 // [stack] ARG
7673 }
7675 // [stack] ARG IS_NULL_OR_UNDEF
7677 }
7679 // [stack] IS_NULL_OR_UNDEF ARG
7681 }
7683 // [stack] IS_NULL_OR_UNDEF
7685 }
7687 }
7695 // [stack] ARG
7697 }
7700 // [stack]
7702 }
7704 // This is still a call node, so we must generate a stack value.
7706 // [stack] RVAL
7708 }
7711 }
7725 }
7729 BuiltinObjectKind kind;
7734 }
7740 }
7743 }
7748 }
7753 }
7756 // NOTE: This is a linear search, but the set of entries is quite small and
7757 // this is only used for initial self-hosted parse.
7758 #define MATCH_WELL_KNOWN_SYMBOL(NAME) \
7759 if (atom == TaggedParserAtomIndex::WellKnown::NAME()) { \
7760 return JS::SymbolCode::NAME; \
7761 }
7763 #undef MATCH_WELL_KNOWN_SYMBOL
7766 }
7779 }
7788 }
7791 }
7800 }
7812 }
7815 }
7817 #ifdef DEBUG
7819 // The function argument is expected to be a simple binding/function name.
7820 // Eg. `function foo() { }; SpecialIntrinsic(foo)`
7825 // The special intrinsics must follow the target functions definition. A
7826 // simple assert is fine here since any hoisted function will cause a non-null
7827 // value to be set here.
7830 // The target function must match the most recently defined top-level
7831 // self-hosted function.
7834 }
7835 #endif
7839 #ifdef DEBUG
7845 #endif
7850 // This is still a call node, so we must generate a stack value.
7852 }
7859 #ifdef DEBUG
7861 #endif
7866 // Canonical name must be atomized.
7870 // Store the canonical name for instantiation.
7872 specName);
7875 }
7877 #ifdef DEBUG
7885 // Ensure that the slot argument is fixed, this is required by the JITs.
7888 }
7897 // Ensure that the slot argument is fixed, this is required by the JITs.
7900 }
7901 #endif
7903 /* A version of emitCalleeAndThis for the optional cases:
7904 * * a?.()
7905 * * a?.b()
7906 * * a?.["b"]()
7907 * * (a?.b)()
7908 * * a?.#b()
7909 *
7910 * See emitCallOrNew and emitOptionalCall for more context.
7911 */
7919 }
7925 // [stack] CALLEE THIS
7927 }
7929 }
7938 // [stack] CALLEE THIS
7940 }
7942 }
7950 // [stack] CALLEE THIS
7952 }
7954 }
7962 // [stack] CALLEE THIS
7964 }
7966 }
7973 // [stack] CALLEE THIS
7975 }
7977 }
7986 // [stack] CALLEE THIS
7988 }
7990 }
7995 }
7997 // [stack] CALLEE
7999 }
8004 cone);
8005 }
8012 }
8014 // [stack] CALLEE
8016 }
8018 }
8021 // [stack] CALLEE THIS
8023 }
8026 }
8036 // [stack] CALLEE THIS?
8038 }
8040 }
8049 }
8053 // [stack] THIS
8055 }
8058 // [stack] OBJ
8060 }
8061 }
8063 // [stack] CALLEE THIS?
8065 }
8068 }
8076 // [stack] # if Super
8077 // [stack] THIS? THIS KEY
8078 // [stack] # otherwise
8079 // [stack] OBJ? OBJ KEY
8081 }
8083 // [stack] CALLEE THIS?
8085 }
8088 }
8096 // [stack] OBJ
8098 }
8100 // [stack] OBJ NAME
8102 }
8104 // [stack] CALLEE THIS
8106 }
8109 }
8113 }
8115 // [stack] CALLEE
8117 }
8123 // [stack] CALLEE IsConstructing
8125 }
8129 cone);
8130 }
8134 }
8137 }
8139 }
8142 // [stack] CALLEE THIS
8144 }
8147 }
8154 // Default to using the location of the `(` itself.
8155 // obj[expr]() // expression
8156 // ^ // column coord
8161 // Use the position of a property access identifier.
8162 //
8163 // obj().aprop() // expression
8164 // ^ // column coord
8165 //
8166 // Note: Because of the constant folding logic in FoldElement,
8167 // this case also applies for constant string properties.
8168 //
8169 // obj()['aprop']() // expression
8170 // ^ // column coord
8174 // Use the start of callee name unless it is at a separator
8175 // or has no args.
8176 //
8177 // 2 + obj() // expression
8178 // ^ // column coord
8179 //
8182 // Use the start of callee names.
8184 }
8186 }
8190 }
8191 }
8193 }
8202 }
8205 // [stack] CALLEE THIS
8207 }
8211 }
8213 // [stack] CALLEE THIS ARG*
8215 }
8216 }
8221 }
8223 // [stack] CALLEE THIS ARG0
8225 }
8228 // [stack] CALLEE THIS ARG0
8230 }
8234 // [stack] CALLEE THIS ARR
8236 }
8237 }
8240 // [stack] CALLEE THIS ARR
8242 }
8245 // [stack] CALLEE THIS
8247 }
8249 // [stack] CALLEE THIS ARR
8251 }
8252 }
8255 }
8258 ValueUsage valueUsage) {
8259 /*
8260 * A modified version of emitCallOrNew that handles optional calls.
8261 *
8262 * These include the following:
8263 * a?.()
8264 * a.b?.()
8265 * a.["b"]?.()
8266 * (a?.b)?.()
8267 *
8268 * See CallOrNewEmitter for more context.
8269 */
8278 isOptimizableSpread
8281 valueUsage);
8286 // [stack] CALLEE THIS
8288 }
8292 // [stack] CALLEE THIS
8294 }
8295 }
8298 // [stack] CALLEE THIS ARGS...
8300 }
8303 // [stack] RVAL
8305 }
8308 }
8311 /*
8312 * Emit callable invocation or operator new (constructor call) code.
8313 * First, emit code for the left operand to evaluate the callable or
8314 * constructable object expression.
8315 *
8316 * Then (or in a call case that has no explicit reference-base
8317 * object) we emit JSOp::Undefined to produce the undefined |this|
8318 * value required for calls (which non-strict mode functions
8319 * will box into the global object).
8320 */
8329 // Calls to "forceInterpreter", "callFunction",
8330 // "callContentFunction", or "resumeGenerator" in self-hosted
8331 // code generate inline bytecode.
8332 //
8333 // NOTE: The list of special instruction names has to be kept in sync with
8334 // "js/src/builtin/.eslintrc.js".
8338 }
8341 }
8345 }
8348 }
8351 }
8354 }
8358 }
8362 }
8366 }
8369 }
8372 }
8375 }
8378 }
8382 }
8385 }
8388 }
8391 }
8394 }
8398 }
8401 }
8404 }
8407 }
8408 #ifdef DEBUG
8417 // Make sure that this call is correct, but don't emit any special code.
8419 }
8422 // Make sure that this call is correct, but don't emit any special code.
8424 }
8425 #endif
8426 // Fall through
8427 }
8438 isOptimizableSpread
8439 ? isDefaultDerivedClassConstructor
8443 valueUsage);
8446 // [stack] CALLEE THIS
8448 }
8450 // [stack] CALLEE THIS ARGS...
8452 }
8454 // Push new.target for construct calls.
8458 // [stack] CALLEE THIS ARGS.. NEW.TARGET
8460 }
8462 // Repush the callee as new.target
8465 // [stack] CALLEE THIS ARGS.. CALLEE
8467 }
8468 }
8469 }
8474 // [stack] RVAL
8476 }
8479 }
8481 // This list must be kept in the same order in several places:
8482 // - The binary operators in ParseNode.h ,
8483 // - the binary operators in TokenKind.h
8484 // - the precedence list in Parser.cpp
8486 // Some binary ops require special code generation (PrivateIn);
8487 // these should not use BinaryOpParseNodeKindToJSOp. This table fills those
8488 // slots with Nops to make the rest of the table lookup work.
8500 #ifdef DEBUG
8505 // Ensure we don't use this to find an op for a parse node
8506 // requiring special emission rules.
8508 #endif
8510 }
8513 // ** is the only right-associative operator.
8516 // Right-associative operator chain.
8520 }
8523 }
8524 }
8528 }
8529 }
8531 }
8534 // Left-associative operator chain.
8537 }
8543 }
8546 }
8549 }
8552 }
8561 privateName);
8567 // [stack] OBJ
8569 }
8572 // [stack] OBJ BRAND if private method
8573 // [stack] OBJ NAME if private field or accessor.
8575 }
8578 // [stack] OBJ BRAND BOOL if private method
8579 // [stack] OBJ NAME BOOL if private field or accessor.
8581 }
8584 // [stack] BOOL OBJ BRAND if private method
8585 // [stack] BOOL OBJ NAME if private field or accessor.
8587 }
8590 // [stack] BOOL
8592 }
8595 }
8597 /*
8598 * Special `emitTree` for Optional Chaining case.
8599 * Examples of this are `emitOptionalChain`, `emitDeleteOptionalChain` and
8600 * `emitCalleeAndThisForOptionalChain`.
8601 */
8608 }
8618 }
8620 }
8629 }
8631 }
8642 }
8644 }
8655 }
8657 }
8665 }
8667 }
8672 }
8674 // List of accepted ParseNodeKinds that might appear only at the beginning
8675 // of an Optional Chain.
8676 // For example, a taggedTemplateExpr node might occur if we have
8677 // `test`?.b, with `test` as the taggedTemplateExpr ParseNode.
8679 #ifdef DEBUG
8680 // https://tc39.es/ecma262/#sec-primary-expression
8697 // https://tc39.es/ecma262/#sec-left-hand-side-expressions
8709 #endif
8711 }
8713 }
8715 // Handle the case of a call made on a OptionalChainParseNode.
8716 // For example `(a?.b)()` and `(a?.b)?.()`.
8721 // Create a new OptionalEmitter, in order to emit the right bytecode
8722 // in isolation.
8726 // [stack] CALLEE THIS
8728 }
8730 // complete the jump if necessary. This will set both the "this" value
8731 // and the "callee" value to undefined, if the callee is undefined. It
8732 // does not matter much what the this value is, the function call will
8733 // fail if it is not optional, and be set to undefined otherwise.
8736 // [stack] # If shortcircuit
8737 // [stack] UNDEFINED UNDEFINED
8738 // [stack] # otherwise
8739 // [stack] CALLEE THIS
8741 }
8743 }
8746 ValueUsage valueUsage) {
8752 // [stack] VAL
8754 }
8757 // [stack] # If shortcircuit
8758 // [stack] UNDEFINED
8759 // [stack] # otherwise
8760 // [stack] VAL
8762 }
8765 }
8772 // [stack]
8774 }
8779 // [stack] OBJ
8781 }
8784 // [stack] OBJ
8786 }
8787 }
8792 // [stack] # if Jump
8793 // [stack] UNDEFINED-OR-NULL
8794 // [stack] # otherwise
8795 // [stack] OBJ
8797 }
8798 }
8801 // [stack] PROP
8803 }
8806 }
8813 // [stack]
8815 }
8820 // [stack] OBJ
8822 }
8825 // [stack] OBJ
8827 }
8828 }
8833 // [stack] # if Jump
8834 // [stack] UNDEFINED-OR-NULL
8835 // [stack] # otherwise
8836 // [stack] OBJ
8838 }
8839 }
8842 // [stack] OBJ? OBJ
8844 }
8847 // [stack] OBJ? OBJ KEY
8849 }
8852 // [stack] ELEM
8854 }
8857 }
8863 // [stack] OBJ
8865 }
8869 // [stack] # if Jump
8870 // [stack] UNDEFINED-OR-NULL
8871 // [stack] # otherwise
8872 // [stack] OBJ
8874 }
8875 }
8878 // [stack] OBJ NAME
8880 }
8882 // [stack] CALLEE THIS # if call
8883 // [stack] VALUE # otherwise
8885 }
8888 }
8895 /*
8896 * JSOp::Or converts the operand on the stack to boolean, leaves the original
8897 * value on the stack and jumps if true; otherwise it falls into the next
8898 * bytecode, which pops the left operand and then evaluates the right operand.
8899 * The jump goes around the right operand evaluation.
8900 *
8901 * JSOp::And converts the operand on the stack to boolean and jumps if false;
8902 * otherwise it falls into the right operand's bytecode.
8903 */
8907 JSOp op;
8920 }
8922 JumpList jump;
8924 // Left-associative operator chain: avoid too much recursion.
8925 //
8926 // Emit all nodes but the last.
8930 }
8933 }
8936 }
8937 }
8939 // Emit the last node
8942 }
8946 }
8948 }
8954 }
8957 }
8960 }
8961 }
8966 }
8969 }
8971 }
8973 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
8974 // the comment on emitSwitch.
8976 ValueUsage valueUsage) {
8988 }
8989 }
8991 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
8992 // the comment on emitSwitch.
9002 }
9005 }
9008 }
9015 }
9022 }
9024 // NOTE: NotExpr of conditionNode may be unwrapped, and in that case the
9025 // negation is handled by conditionKind.
9028 }
9032 }
9036 }
9040 }
9044 }
9048 }
9052 }
9054 // Check for an object-literal property list that can be handled by the
9055 // ObjLiteral writer. We ensure that for each `prop: value` pair, the key is a
9056 // constant name or numeric index, there is no accessor specified, and the value
9057 // can be encoded by an ObjLiteral instruction (constant number, string,
9058 // boolean, null/undefined).
9070 }
9071 propCount++;
9077 // Computed keys not OK (ObjLiteral data stores constant keys).
9081 }
9083 // BigIntExprs should have been lowered to computed names at parse
9084 // time, and so should be excluded above.
9087 // Numeric keys OK as long as they are integers and in range.
9094 }
9098 }
9099 }
9105 AccessorType accessorType =
9112 }
9116 }
9117 }
9120 // JSOp::NewObject cannot accept dictionary-mode objects.
9122 }
9126 }
9132 }
9135 }
9136 }
9138 }
9141 PropListType type) {
9142 // [stack] CTOR? OBJ
9149 // Only handle computing field keys here: the .initializers lambda array
9150 // is created elsewhere.
9158 // [stack] CTOR OBJ ARRAY
9160 }
9165 // [stack] CTOR OBJ ARRAY KEY
9167 }
9170 // [stack] CTOR OBJ ARRAY KEY
9172 }
9179 }
9182 // [stack] CTOR OBJ ARRAY
9184 }
9187 // [stack] CTOR OBJ
9189 }
9190 }
9192 }
9195 // Static class blocks are emitted as part of
9196 // emitCreateMemberInitializers.
9198 }
9201 // Constructors are sometimes wrapped in LexicalScopeNodes. As we
9202 // already handled emitting the constructor, skip it.
9206 }
9208 // Handle __proto__: v specially because *only* this form, and no other
9209 // involving "__proto__", performs [[Prototype]] mutation.
9211 // [stack] OBJ
9214 // [stack] OBJ
9216 }
9218 // [stack] OBJ PROTO
9220 }
9222 // [stack] OBJ
9224 }
9226 }
9230 // [stack] OBJ
9232 // [stack] OBJ OBJ
9234 }
9236 // [stack] OBJ OBJ VAL
9238 }
9240 // [stack] OBJ
9242 }
9244 }
9249 AccessorType accessorType;
9256 // Private non-static accessors are stamped onto instances from
9257 // initializers; see emitCreateMemberInitializers.
9259 }
9264 }
9267 // [stack] CTOR? OBJ CTOR? KEY?
9271 // The following branches except for the last `else` clause emit the
9272 // cases handled in NameResolver::resolveFun (see NameFunctions.cpp)
9278 // [stack] CTOR? OBJ CTOR? VAL
9280 }
9287 }
9289 // [stack] CTOR? OBJ CTOR? KEY VAL
9291 }
9304 }
9306 // [stack] CTOR? OBJ CTOR? KEY VAL
9308 }
9313 // [stack] CTOR? OBJ CTOR? KEY VAL
9315 }
9316 }
9318 // Either a proper computed property name or a synthetic computed
9319 // property name for BigInt keys.
9322 FunctionPrefixKind prefix =
9328 // [stack] CTOR? OBJ CTOR? KEY VAL
9330 }
9331 }
9334 // [stack] CTOR? OBJ CTOR? KEY? VAL
9336 }
9337 }
9342 // [stack] CTOR? OBJ CTOR? KEY? FUN
9344 }
9345 }
9347 #ifdef ENABLE_DECORATORS
9362 }
9364 // The decorators are applied to the current value on the stack,
9365 // possibly replacing it.
9369 // [stack] CTOR? OBJ CTOR? KEY? VAL
9371 }
9372 }
9373 }
9374 #endif
9377 };
9385 // [stack] CTOR? OBJ
9389 // emitClass took care of constructor already.
9394 }
9397 // [stack] CTOR? OBJ CTOR?
9399 }
9402 // [stack] CTOR? OBJ CTOR? VAL
9404 }
9407 // [stack] CTOR? OBJ
9409 }
9412 }
9415 // [stack] CTOR? OBJ
9417 // [stack] CTOR? OBJ CTOR?
9419 }
9421 // [stack] CTOR? OBJ CTOR? KEY
9423 }
9425 // [stack] CTOR? OBJ CTOR? KEY
9427 }
9429 // [stack] CTOR? OBJ CTOR? KEY VAL
9431 }
9434 // [stack] CTOR? OBJ
9436 }
9439 }
9442 // Either a proper computed property name or a synthetic computed property
9443 // name for BigInt keys.
9445 // [stack] CTOR? OBJ
9448 // [stack] CTOR? OBJ CTOR?
9450 }
9452 // [stack] CTOR? OBJ CTOR? KEY
9454 }
9456 // [stack] CTOR? OBJ CTOR? KEY
9458 }
9460 // [stack] CTOR? OBJ CTOR? KEY VAL
9462 }
9465 // [stack] CTOR? OBJ
9467 }
9470 }
9480 // [stack] CTOR OBJ
9482 }
9486 // Ensure the NameOp emitter doesn't push an environment onto the stack,
9487 // because that would change the stack location of the home object.
9492 // [stack] CTOR OBJ
9494 }
9496 // [stack] CTOR OBJ METHOD
9498 }
9500 // [stack] CTOR OBJ METHOD
9502 }
9504 // [stack] CTOR OBJ
9506 }
9508 // [stack] CTOR OBJ
9510 }
9512 }
9516 // [stack] CTOR OBJ
9519 // [stack] CTOR OBJ CTOR
9521 }
9523 // [stack] CTOR OBJ CTOR KEY
9525 }
9527 // [stack] CTOR OBJ CTOR KEY VAL
9529 }
9532 // [stack] CTOR OBJ
9534 }
9538 // [stack] CTOR OBJ CTOR
9540 }
9542 // [stack] CTOR OBJ CTOR NAME
9544 }
9547 // [stack] CTOR OBJ CTOR NAME FUN
9549 }
9551 // [stack] CTOR OBJ CTOR
9553 }
9555 // [stack] CTOR OBJ
9557 }
9558 }
9559 }
9562 }
9566 ObjLiteralWriter writer;
9568 #ifdef DEBUG
9569 // In self-hosted JS, we check duplication only on debug build.
9572 selfHostedPropNames;
9575 }
9576 #endif
9583 }
9592 #ifdef DEBUG
9593 // Self-hosted JS shouldn't contain duplicate properties.
9599 }
9600 #endif
9605 }
9606 }
9616 // Ignore indexed properties if we're not storing property values, and
9617 // rely on InitElem ops to define those. These properties will be either
9618 // dense elements (not possible to represent in the literal's shape) or
9619 // sparse elements (enumerated separately, so this doesn't affect property
9620 // iteration order).
9623 }
9626 }
9633 }
9637 }
9638 }
9639 }
9641 GCThingIndex index;
9644 }
9646 // JSOp::Object may only be used by (top-level) run-once scripts.
9651 // [stack] OBJ
9653 }
9656 }
9660 // Note: if we want to squeeze out a little more performance, we could switch
9661 // to the `JSOp::Object` opcode, because the exclusion set object is never
9662 // exposed to the user, so it's safe to bake the object into the bytecode.
9665 ObjLiteralWriter writer;
9672 }
9674 TaggedParserAtomIndex atom;
9680 }
9684 }
9688 }
9689 }
9691 GCThingIndex index;
9694 }
9697 // [stack] OBJ
9699 }
9702 }
9709 ObjLiteralWriter writer;
9716 }
9717 }
9719 GCThingIndex index;
9722 }
9725 // [stack] OBJ
9727 }
9730 }
9740 }
9753 }
9756 }
9760 }
9764 }
9768 }
9772 }
9778 }
9781 }
9783 }
9789 }
9800 numFields++;
9802 numPrivateInitializers++;
9806 }
9807 }
9809 // If there are more initializers than can be represented, return invalid.
9813 }
9816 }
9818 // Purpose of .fieldKeys:
9819 // Computed field names (`["x"] = 2;`) must be ran at class-evaluation time,
9820 // not object construction time. The transformation to do so is roughly as
9821 // follows:
9822 //
9823 // class C {
9824 // [keyExpr] = valueExpr;
9825 // }
9826 // -->
9827 // let .fieldKeys = [keyExpr];
9828 // let .initializers = [
9829 // () => {
9830 // this[.fieldKeys[0]] = valueExpr;
9831 // }
9832 // ];
9833 // class C {
9834 // constructor() {
9835 // .initializers[0]();
9836 // }
9837 // }
9838 //
9839 // BytecodeEmitter::emitCreateFieldKeys does `let .fieldKeys = [...];`
9840 // BytecodeEmitter::emitPropertyList fills in the elements of the array.
9841 // See GeneralParser::fieldInitializer for the `this[.fieldKeys[0]]` part.
9843 FieldPlacement placement) {
9850 };
9856 }
9864 }
9867 // [stack] ARRAY
9869 }
9872 // [stack] ARRAY
9874 }
9877 // [stack]
9879 }
9882 }
9888 }
9895 }
9901 }
9905 FieldPlacement placement
9906 #ifdef ENABLE_DECORATORS
9907 ,
9908 bool hasHeritage
9909 #endif
9910 ) {
9911 // FieldPlacement::Instance, hasHeritage == false
9912 // [stack] HOMEOBJ
9913 //
9914 // FieldPlacement::Instance, hasHeritage == true
9915 // [stack] HOMEOBJ HERITAGE
9916 //
9917 // FieldPlacement::Static
9918 // [stack] CTOR HOMEOBJ
9919 #ifdef ENABLE_DECORATORS
9921 #endif
9927 }
9932 }
9936 // [stack] HOMEOBJ HERITAGE? ARRAY
9937 // or:
9938 // [stack] CTOR HOMEOBJ ARRAY
9940 }
9942 // Private accessors could be used in the field initializers, so make sure
9943 // accessor initializers appear earlier in the .initializers array so they
9944 // run first. Static private methods are not initialized using initializers
9945 // (emitPropertyList emits bytecode to stamp them onto the constructor), so
9946 // skip this step if isStatic.
9950 }
9951 }
9956 }
9962 }
9964 // [stack] HOMEOBJ HERITAGE? ARRAY LAMBDA
9965 // or:
9966 // [stack] CTOR HOMEOBJ ARRAY LAMBDA
9968 }
9972 // [stack] HOMEOBJ HERITAGE? ARRAY LAMBDA
9973 // or:
9974 // [stack] CTOR HOMEOBJ ARRAY LAMBDA
9976 }
9977 }
9979 // [stack] HOMEOBJ HERITAGE? ARRAY
9980 // or:
9981 // [stack] CTOR HOMEOBJ ARRAY
9983 }
9984 }
9986 #ifdef ENABLE_DECORATORS
9987 // Index to use to append new initializers returned by decorators to the array
9989 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX
9990 // or:
9991 // [stack] CTOR HOMEOBJ ARRAY INDEX
9993 }
9998 }
10002 }
10008 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS
10009 // or:
10010 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS
10012 }
10022 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER
10023 // or:
10024 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER
10026 }
10028 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER SETTER
10029 // or:
10030 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER SETTER
10032 }
10038 // [stack]
10040 // Synthesize a name for the lexical variable that will store the
10041 // private method body.
10042 TaggedParserAtomIndex name =
10048 }
10053 }
10057 }
10060 // [stack] ACCESSOR
10061 };
10064 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER
10065 // or:
10066 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER
10068 };
10071 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER SETTER
10072 // or:
10073 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER SETTER
10075 };
10076 }
10080 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER SETTER INITS
10081 // or:
10082 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER SETTER INITS
10084 }
10087 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER SETTER
10088 // or:
10089 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER SETTER
10091 }
10096 // [stack] HERITAGE? ARRAY INDEX INITS GETTER SETTER HOMEOBJ
10098 }
10101 // [stack] HOMEOBJ ARRAY INDEX INITS GETTER SETTER CTOR
10103 }
10105 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ
10107 }
10108 }
10118 // [stack] HERITAGE? ARRAY INDEX INITS GETTER SETTER HOMEOBJ
10119 // or:
10120 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ CTOR
10122 }
10124 // [stack] HERITAGE? ARRAY INDEX INITS GETTER HOMEOBJ SETTER
10125 // or:
10126 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR SETTER
10128 }
10130 // [stack] HERITAGE? ARRAY INDEX INITS GETTER HOMEOBJ
10131 // or:
10132 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ
10134 }
10137 // [stack] HERITAGE? ARRAY INDEX INITS GETTER HOMEOBJ
10138 // or:
10139 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR
10141 }
10143 // [stack] HERITAGE? ARRAY INDEX INITS HOMEOBJ GETTER
10144 // or:
10145 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ CTOR GETTER
10147 }
10149 // [stack] HERITAGE? ARRAY INDEX INITS HOMEOBJ
10150 // or:
10151 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ
10153 }
10156 // The getter and setter share the same name.
10158 accessorSetterKeyAtom)) {
10160 }
10162 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ CTOR
10164 }
10167 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ CTOR
10168 // KEY
10170 }
10172 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR KEY
10173 // SETTER
10175 }
10177 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ
10179 }
10182 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR
10184 }
10187 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR KEY
10189 }
10191 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ CTOR KEY GETTER
10193 }
10195 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ
10197 }
10198 }
10202 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS
10204 }
10207 // [stack] HOMEOBJ ARRAY INDEX INITS CTOR
10209 }
10211 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS
10213 }
10214 }
10219 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER SETTER
10220 // or:
10221 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER SETTER
10223 }
10226 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER
10227 // or:
10228 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER
10230 }
10233 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER
10234 // or:
10235 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER
10237 }
10240 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS
10241 // or:
10242 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS
10244 }
10245 }
10246 }
10248 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX
10249 // or:
10250 // [stack] CTOR HOMEOBJ ARRAY INDEX
10252 }
10253 }
10254 }
10256 // Pop INDEX
10258 // [stack] HOMEOBJ HERITAGE? ARRAY
10259 // or:
10260 // [stack] CTOR HOMEOBJ ARRAY
10262 }
10263 #endif
10266 // [stack] HOMEOBJ HERITAGE?
10267 // or:
10268 // [stack] CTOR HOMEOBJ
10270 }
10273 }
10280 }
10283 // Skip over anything which isn't a private instance accessor.
10286 }
10289 // [stack] HOMEOBJ HERITAGE? ARRAY
10290 // or:
10291 // [stack] CTOR HOMEOBJ ARRAY
10293 }
10295 // Synthesize a name for the lexical variable that will store the
10296 // private method body.
10302 }
10306 }
10310 // Emit the private method body and store it as a lexical var.
10312 // [stack] HOMEOBJ HERITAGE? ARRAY METHOD
10313 // or:
10314 // [stack] CTOR HOMEOBJ ARRAY METHOD
10316 }
10317 // The private method body needs to access the home object,
10318 // and the CE knows where that is on the stack.
10321 // [stack] HOMEOBJ HERITAGE? ARRAY METHOD
10322 // or:
10323 // [stack] CTOR HOMEOBJ ARRAY METHOD
10325 }
10326 }
10328 // [stack] HOMEOBJ HERITAGE? ARRAY METHOD
10329 // or:
10330 // [stack] CTOR HOMEOBJ ARRAY METHOD
10332 }
10334 // [stack] HOMEOBJ HERITAGE? ARRAY
10335 // or:
10336 // [stack] CTOR HOMEOBJ ARRAY
10338 }
10341 // [stack] HOMEOBJ HERITAGE? ARRAY
10342 // or:
10343 // [stack] CTOR HOMEOBJ ARRAY
10345 }
10347 // Store the emitted initializer function into the .initializers array.
10349 // [stack] HOMEOBJ HERITAGE? ARRAY
10350 // or:
10351 // [stack] CTOR HOMEOBJ ARRAY
10353 }
10354 }
10357 }
10365 // Emit the synthesized initializer function.
10372 // [stack]
10374 }
10379 }
10383 // [stack]
10385 }
10387 // [stack]
10389 }
10391 // [stack]
10393 }
10396 // [stack] THIS
10398 }
10400 // [stack] THIS NAME
10402 }
10404 // [stack] THIS NAME METHOD
10406 }
10411 // [stack] THIS
10413 }
10415 // [stack] THIS NAME
10417 }
10421 // [stack] THIS NAME FUN
10423 }
10425 // [stack] THIS
10427 }
10433 // [stack] THIS
10435 }
10438 // [stack] THIS
10440 }
10441 }
10445 }
10447 // Pop remaining THIS.
10449 // [stack]
10451 }
10454 // [stack]
10456 }
10459 }
10462 // [stack] HOMEOBJ HERITAGE? ARRAY FUN
10463 // or:
10464 // [stack] CTOR HOMEOBJ ARRAY FUN
10466 }
10469 }
10478 }
10480 // If we found a non-arrow / non-constructor we were never allowed to
10481 // expect fields in the first place.
10486 }
10487 }
10491 }
10500 // This is guaranteed to run after super(), so we don't need TDZ checks.
10502 // [stack] THIS
10504 }
10506 // [stack] THIS BRAND
10508 }
10512 // [stack] THIS BRAND BOOL
10514 }
10516 // [stack] THIS BRAND
10518 }
10519 }
10521 // [stack] THIS BRAND NULL
10523 }
10525 // [stack] THIS
10527 }
10529 // [stack]
10531 }
10532 }
10537 // [stack] ARRAY
10539 }
10543 // We Dup to keep the array around (it is consumed in the bytecode
10544 // below) for next iterations of this loop, except for the last
10545 // iteration, which avoids an extra Pop at the end of the loop.
10547 // [stack] ARRAY ARRAY
10549 }
10550 }
10553 // [stack] ARRAY? ARRAY INDEX
10555 }
10558 // [stack] ARRAY? FUNC
10560 }
10562 // This is guaranteed to run after super(), so we don't need TDZ checks.
10564 // [stack] ARRAY? FUNC THIS
10566 }
10568 // Callee is always internal function.
10570 // [stack] ARRAY? RVAL
10572 }
10575 // [stack] ARRAY?
10577 }
10578 }
10579 #ifdef ENABLE_DECORATORS
10580 // Decorators Proposal
10581 // https://arai-a.github.io/ecma262-compare/?pr=2417&id=sec-initializeinstanceelements
10582 // 4. For each element e of elements, do
10583 // 4.a. If elementRecord.[[Kind]] is field or accessor, then
10584 // 4.a.i. Perform ? InitializeFieldOrAccessor(O, elementRecord).
10585 //
10587 // TODO: (See Bug 1817993) At the moment, we're applying the initialization
10588 // logic in two steps. The pre-decorator initialization code runs, stores
10589 // the initial value, and then we retrieve it here and apply the
10590 // initializers added by decorators. We should unify these two steps.
10592 // [stack] ARRAY
10594 }
10597 // [stack] ARRAY ARRAY
10599 }
10603 // [stack] ARRAY LENGTH
10605 }
10608 // [stack] ARRAY LENGTH INDEX
10610 }
10613 // At this point, we have no context to determine offsets in the
10614 // code for this while statement. Ideally, it would correspond to
10615 // the field we're initializing.
10617 // [stack] ARRAY LENGTH INDEX
10619 }
10622 // [stack] ARRAY LENGTH INDEX INDEX
10624 }
10627 // [stack] ARRAY LENGTH INDEX INDEX LENGTH
10629 }
10632 // [stack] ARRAY LENGTH INDEX BOOL
10634 }
10637 // [stack] ARRAY LENGTH INDEX
10639 }
10642 // [stack] ARRAY LENGTH INDEX ARRAY
10644 }
10647 // [stack] ARRAY LENGTH INDEX ARRAY INDEX
10649 }
10651 // Retrieve initializers for this field
10653 // [stack] ARRAY LENGTH INDEX INITIALIZERS
10655 }
10657 // This is guaranteed to run after super(), so we don't need TDZ checks.
10659 // [stack] ARRAY LENGTH INDEX INITIALIZERS THIS
10661 }
10664 // [stack] ARRAY LENGTH INDEX THIS INITIALIZERS
10666 }
10670 // [stack] ARRAY LENGTH INDEX
10672 }
10675 // [stack] ARRAY LENGTH INDEX
10677 }
10680 // [stack] ARRAY LENGTH INDEX
10682 }
10685 // [stack]
10687 }
10688 // 5. Return unused.
10689 #endif
10690 }
10692 }
10697 };
10704 }
10708 // [stack] CTOR ARRAY
10710 }
10715 // We Dup to keep the array around (it is consumed in the bytecode below)
10716 // for next iterations of this loop, except for the last iteration, which
10717 // avoids an extra Pop at the end of the loop.
10719 // [stack] CTOR ARRAY ARRAY
10721 }
10722 }
10725 // [stack] CTOR ARRAY? ARRAY INDEX
10727 }
10730 // [stack] CTOR ARRAY? FUNC
10732 }
10735 // [stack] CTOR ARRAY? FUNC CTOR
10737 }
10739 // Callee is always internal function.
10741 // [stack] CTOR ARRAY? RVAL
10743 }
10746 // [stack] CTOR ARRAY?
10748 }
10749 }
10751 #ifdef ENABLE_DECORATORS
10752 // Decorators Proposal
10753 // https://arai-a.github.io/ecma262-compare/?pr=2417&id=sec-initializeinstanceelements
10754 // 4. For each element e of elements, do
10755 // 4.a. If elementRecord.[[Kind]] is field or accessor, then
10756 // 4.a.i. Perform ? InitializeFieldOrAccessor(O, elementRecord).
10757 //
10759 // TODO: (See Bug 1817993) At the moment, we're applying the initialization
10760 // logic in two steps. The pre-decorator initialization code runs, stores
10761 // the initial value, and then we retrieve it here and apply the
10762 // initializers added by decorators. We should unify these two steps.
10765 // [stack] CTOR ARRAY
10767 }
10770 // [stack] CTOR ARRAY ARRAY
10772 }
10775 // [stack] CTOR ARRAY LENGTH
10777 }
10780 // [stack] CTOR ARRAY LENGTH INDEX
10782 }
10785 // At this point, we have no context to determine offsets in the
10786 // code for this while statement. Ideally, it would correspond to
10787 // the field we're initializing.
10789 // [stack] CTOR ARRAY LENGTH INDEX
10791 }
10794 // [stack] CTOR ARRAY LENGTH INDEX INDEX
10796 }
10799 // [stack] CTOR ARRAY LENGTH INDEX INDEX LENGTH
10801 }
10804 // [stack] CTOR ARRAY LENGTH INDEX BOOL
10806 }
10809 // [stack] CTOR ARRAY LENGTH INDEX
10811 }
10814 // [stack] CTOR ARRAY LENGTH INDEX ARRAY
10816 }
10819 // [stack] CTOR ARRAY LENGTH INDEX ARRAY INDEX
10821 }
10823 // Retrieve initializers for this field
10825 // [stack] CTOR ARRAY LENGTH INDEX INITIALIZERS
10827 }
10830 // [stack] CTOR ARRAY LENGTH INDEX INITIALIZERS CTOR
10832 }
10835 // [stack] CTOR ARRAY LENGTH INDEX CTOR INITIALIZERS
10837 }
10841 // [stack] CTOR ARRAY LENGTH INDEX
10843 }
10846 // [stack] CTOR ARRAY LENGTH INDEX
10848 }
10851 // [stack] CTOR ARRAY LENGTH INDEX
10853 }
10856 // [stack] CTOR
10858 }
10859 // 5. Return unused.
10860 #endif
10862 // Overwrite |.staticInitializers| and |.staticFieldKeys| with undefined to
10863 // avoid keeping the arrays alive indefinitely.
10867 // [stack] ENV? VAL?
10869 }
10872 // [stack] ENV? VAL? UNDEFINED
10874 }
10877 // [stack] VAL
10879 }
10882 // [stack]
10884 }
10887 };
10892 }
10898 };
10902 isStaticFieldWithComputedName)) {
10906 }
10907 }
10910 }
10912 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
10913 // the comment on emitSwitch.
10915 // Note: this method uses the ObjLiteralWriter and emits ObjLiteralStencil
10916 // objects into the GCThingList, which will evaluate them into real GC objects
10917 // or shapes during JSScript::fullyInitFromEmitter. Eventually we want
10918 // JSOp::Object to be a real opcode, but for now, performance constraints
10919 // limit us to evaluating object literals at the end of parse, when we're
10920 // allowed to allocate GC things.
10921 //
10922 // There are four cases here, in descending order of preference:
10923 //
10924 // 1. The list of property names is "normal" and constant (no computed
10925 // values, no integer indices), the values are all simple constants
10926 // (numbers, booleans, strings), *and* this occurs in a run-once
10927 // (singleton) context. In this case, we can emit ObjLiteral
10928 // instructions to build an object with values, and the object will be
10929 // attached to a JSOp::Object opcode, whose semantics are for the backend
10930 // to simply steal the object from the script.
10931 //
10932 // 2. The list of property names is "normal" and constant as above, *and* this
10933 // occurs in a run-once (singleton) context, but some values are complex
10934 // (computed expressions, sub-objects, functions, etc.). In this case, we
10935 // can still use JSOp::Object (because singleton context), but the object
10936 // has |undefined| property values and InitProp ops are emitted to set the
10937 // values.
10938 //
10939 // 3. The list of property names is "normal" and constant as above, but this
10940 // occurs in a non-run-once (non-singleton) context. In this case, we can
10941 // use the ObjLiteral functionality to describe an *empty* object (all
10942 // values left undefined) with the right fields, which will become a
10943 // JSOp::NewObject opcode using the object's shape to speed up the creation
10944 // of the object each time it executes. The emitted bytecode still needs
10945 // InitProp ops to set the values in this case.
10946 //
10947 // 4. Any other case. As a fallback, we use NewInit to create a new, empty
10948 // object (i.e., `{}`) and then emit bytecode to initialize its properties
10949 // one-by-one.
10956 // [stack]
10957 //
10962 JSOp op;
10964 // Case 1 or 2.
10967 // Case 3.
10970 }
10972 // Use an ObjLiteral op. This will record ObjLiteral insns in the
10973 // objLiteralWriter's buffer and add a fixup to the list of ObjLiteral
10974 // fixups so that at GC-publish time at the end of parse, the full object
10975 // (case 1 or 2) or shape (case 3) can be allocated and the bytecode can be
10976 // patched to refer to it.
10978 // [stack] OBJ
10980 }
10981 // Put the ObjectEmitter in the right state. This tells it that there will
10982 // already be an object on the stack as a result of the (eventual)
10983 // NewObject or Object op, and prepares it to emit values if needed.
10985 // [stack] OBJ
10987 }
10989 // Case 2 or 3 above: we still need to emit bytecode to fill in the
10990 // object's property values.
10992 // [stack] OBJ
10994 }
10995 }
10997 // Case 4 above: no ObjLiteral use, just bytecode to build the object from
10998 // scratch.
11000 // [stack] OBJ
11002 }
11004 // [stack] OBJ
11006 }
11007 }
11010 // [stack] OBJ
11012 }
11015 }
11018 // Emit JSOp::Object if the array consists entirely of primitive values and we
11019 // are in a singleton context.
11023 }
11026 }
11029 /*
11030 * Emit code for [a, b, c] that is equivalent to constructing a new
11031 * array and in source order evaluating each element value and adding
11032 * it to the array, without invoking latent setters. We use the
11033 * JSOp::NewInit and JSOp::InitElemArray bytecodes to ignore setters and
11034 * to avoid dup'ing and popping the array as each element is added, as
11035 * JSOp::SetElem/JSOp::SetProp would do.
11036 */
11041 nspread++;
11042 }
11043 }
11045 // Array literal's length is limited to NELEMENTS_LIMIT in parser.
11047 "array literals' maximum length must not exceed limits "
11048 "required by BaselineCompiler::emit_NewArray, "
11049 "BaselineCompiler::emit_InitElemArray, "
11055 "the parser must throw an error if the array exceeds maximum "
11058 // For arrays with spread, this is a very pessimistic allocation, the
11059 // minimum possible final size.
11061 // [stack] ARRAY
11063 }
11072 // [stack] ARRAY INDEX
11074 }
11075 }
11082 }
11084 // [stack] ARRAY INDEX ITERABLE
11086 }
11088 // [stack] ARRAY INDEX NEXT ITER
11090 }
11092 // [stack] INDEX NEXT ITER ARRAY
11094 }
11096 // [stack] NEXT ITER ARRAY INDEX
11098 }
11100 // [stack] ARRAY INDEX
11102 }
11106 }
11110 }
11113 // [stack] ARRAY INDEX? VALUE
11115 }
11116 }
11120 // [stack] ARRAY (INDEX+1)
11122 }
11125 // [stack] ARRAY
11127 }
11128 }
11129 }
11131 index++;
11132 }
11136 // [stack] ARRAY
11138 }
11139 }
11141 }
11147 // [stack] VALUE
11149 }
11156 // [stack] NEXT ITER
11158 }
11161 // [stack] NEXT ITER ARRAY
11163 }
11166 // [stack] NEXT ITER ARRAY INDEX
11168 }
11171 // [stack] ARRAY INDEX
11173 }
11176 // [stack] ARRAY
11178 }
11180 }
11182 #ifdef ENABLE_RECORD_TUPLE
11185 // [stack] RECORD
11187 }
11192 // [stack] RECORD SPREADEE
11194 }
11196 // [stack] RECORD
11198 }
11209 }
11214 }
11222 }
11224 }
11225 // [stack] RECORD KEY
11228 // [stack] RECORD KEY VALUE
11230 }
11233 // [stack] RECORD
11235 }
11236 }
11237 }
11240 // [stack] RECORD
11242 }
11245 }
11249 // [stack] TUPLE
11251 }
11259 // [stack] TUPLE ITERABLE
11261 }
11263 // [stack] TUPLE NEXT ITER
11265 }
11267 // [stack] NEXT ITER TUPLE
11269 }
11272 // [stack] TUPLE
11274 }
11276 // Update location to throw errors about non-primitive elements
11277 // in the correct position.
11280 }
11283 // [stack] TUPLE VALUE
11285 }
11288 // [stack] TUPLE
11290 }
11291 }
11292 }
11295 // [stack] TUPLE
11297 }
11300 }
11301 #endif
11319 }
11320 }
11325 }
11328 ValueUsage valueUsage =
11332 }
11334 }
11341 }
11345 }
11348 }
11362 }
11368 // Left-hand sides are either simple names or destructuring patterns.
11374 // [stack]
11377 // [stack] DEFAULT
11379 }
11381 };
11384 // [stack] ARG
11388 // [stack] ARG
11390 }
11393 };
11398 // [stack]
11400 }
11402 // [stack]
11404 }
11406 // [stack]
11408 }
11412 // [stack]
11414 }
11415 }
11418 }
11423 // [stack]
11425 }
11427 // [stack]
11429 }
11431 // [stack]
11433 }
11435 // [stack]
11437 }
11439 // [stack]
11441 }
11444 // [stack]
11446 }
11448 // [stack]
11450 }
11452 // [stack]
11454 }
11455 }
11458 }
11462 // [stack]
11464 }
11466 // [stack]
11468 }
11471 // [stack]
11473 }
11476 }
11480 // [stack]
11482 }
11483 }
11486 }
11491 // [stack]
11495 // A special name must be slotful, either on the frame or on the
11496 // call environment.
11501 // [stack]
11503 }
11505 // [stack] THIS/ARGUMENTS/NEW.TARGET
11507 }
11509 // [stack] THIS/ARGUMENTS/NEW.TARGET
11511 }
11513 // [stack]
11515 }
11518 };
11520 // Do nothing if the function doesn't have an arguments binding.
11522 // Self-hosted code should use the more efficient ArgumentsLength and
11523 // GetArgument intrinsics instead of `arguments`.
11528 // [stack]
11530 }
11531 }
11533 // Do nothing if the function doesn't have a this-binding (this
11534 // happens for instance if it doesn't use this/eval or if it's an
11535 // arrow function).
11541 }
11542 }
11544 // Do nothing if the function doesn't have a new.target-binding (this happens
11545 // for instance if it doesn't use new.target/eval or if it's an arrow
11546 // function).
11552 }
11553 }
11555 // Do nothing if the function doesn't implicitly return a promise result.
11560 // [stack]
11562 }
11563 }
11565 }
11569 }
11575 }
11577 // The caller has pushed the RHS to the top of the stack. Assert that the
11578 // binding can be initialized without a binding object on the stack, and that
11579 // no JSOp::BindName or JSOp::BindGName ops were emitted.
11586 }
11589 }
11596 }
11606 }
11607 }
11608 }
11610 }
11613 TaggedParserAtomIndex symbolName) {
11615 // [stack] HERITAGE PRIVATENAME
11617 }
11619 // Add a binding for #name => privatename
11621 // [stack] HERITAGE PRIVATENAME
11623 }
11625 // Pop Private name off the stack.
11627 // [stack] HERITAGE
11629 }
11632 }
11646 }
11650 }
11652 // Non-static private methods' private names are optimized away.
11660 }
11661 }
11667 }
11668 }
11669 }
11672 // We don't make a private name for every optimized method, but we need one
11673 // private name per class, the `.privateBrand`.
11676 privateBrandName)) {
11678 }
11679 }
11681 }
11683 // This follows ES6 14.5.14 (ClassDefinitionEvaluation) and ES6 14.5.15
11684 // (BindingClassDeclarationEvaluation).
11688 TaggedParserAtomIndex
11697 // If |nameKind != ClassNameKind::ComputedName|
11698 // [stack]
11699 // Else
11700 // [stack] NAME
11703 TaggedParserAtomIndex innerName;
11714 }
11715 }
11719 // [stack]
11721 }
11722 }
11728 }
11731 }
11733 // [stack] HERITAGE
11735 }
11736 }
11738 // The class body scope holds any private names. Those mustn't be visible in
11739 // the heritage expression and hence the scope must be emitted after the
11740 // heritage expression.
11743 // [stack] HERITAGE
11745 }
11747 // The spec does not say anything about private brands being symbols. It's
11748 // an implementation detail. So we can give the special private brand
11749 // symbol any description we want and users won't normally see it. For
11750 // debugging, use the class name.
11753 privateBrandName = nameForAnonymousClass
11754 ? nameForAnonymousClass
11756 }
11759 }
11760 }
11765 hasNameOnStack)) {
11766 // [stack] HERITAGE HOMEOBJ
11768 }
11771 // [stack] HOMEOBJ
11773 }
11774 }
11776 // Stack currently has HOMEOBJ followed by optional HERITAGE. When HERITAGE
11777 // is not used, an implicit value of %FunctionPrototype% is implied.
11779 // See |Parser::classMember(...)| for the reason why |.initializers| is
11780 // created within its own scope.
11786 // The constructor scope should only contain the |.initializers| binding.
11796 };
11798 // As an optimization omit the |.initializers| binding when no instance
11799 // fields or private methods are present.
11808 }
11810 // Any class with field initializers will have a constructor
11813 #ifdef ENABLE_DECORATORS
11814 ,
11815 isDerived
11816 #endif
11817 )) {
11819 }
11820 }
11824 // The |.initializers| binding is never emitted when in self-hosting mode.
11827 }
11830 // HERITAGE is consumed inside emitFunction.
11834 }
11835 }
11837 // [stack] HOMEOBJ CTOR
11839 }
11843 }
11845 }
11847 // [stack] CTOR HOMEOBJ
11849 }
11853 }
11856 #ifdef ENABLE_DECORATORS
11857 ,
11858 false
11859 #endif
11860 )) {
11862 }
11866 }
11869 // [stack] CTOR HOMEOBJ
11871 }
11874 // [stack] CTOR
11876 }
11879 // [stack] CTOR
11881 }
11883 #if ENABLE_DECORATORS
11890 // [stack] CTOR
11892 }
11893 }
11894 #endif
11897 // [stack] # class declaration
11898 // [stack]
11899 // [stack] # class expression
11900 // [stack] CTOR
11902 }
11905 }
11917 }
11921 }
11922 }
11927 }
11931 }
11932 }
11935 }
11943 }
11945 /* Emit notes to tell the current bytecode's source line number.
11946 However, a couple trees require special treatment; see the
11947 relevant emitter functions for details. */
11952 }
11953 }
11959 }
11970 }
11976 }
11982 }
11988 }
11994 }
11998 // Ensure that the column of the 'break' is set properly.
12001 }
12004 }
12008 }
12012 // Ensure that the column of the 'continue' is set properly.
12015 }
12018 }
12022 }
12028 }
12034 }
12040 }
12046 }
12052 }
12058 }
12064 }
12070 }
12076 }
12082 }
12088 }
12097 }
12103 }
12109 }
12130 }
12132 }
12139 }
12144 valueUsage)) {
12146 }
12154 }
12180 }
12186 }
12192 }
12198 }
12204 }
12210 }
12213 }
12222 }
12231 }
12237 }
12243 }
12249 }
12255 }
12261 }
12267 }
12278 }
12282 // [stack] THIS
12284 }
12287 // [stack] OBJ
12289 }
12290 }
12292 // [stack] PROP
12294 }
12296 }
12306 // [stack] # if Super
12307 // [stack] THIS KEY
12308 // [stack] # otherwise
12309 // [stack] OBJ KEY
12311 }
12313 // [stack] ELEM
12315 }
12318 }
12325 // [stack] OBJ
12327 }
12329 // [stack] OBJ NAME
12331 }
12333 // [stack] VALUE
12335 }
12338 }
12346 }
12352 }
12359 }
12373 }
12374 }
12376 }
12382 }
12392 }
12398 }
12404 }
12410 }
12416 }
12422 }
12429 }
12435 }
12441 }
12445 GCThingIndex index;
12449 }
12452 }
12454 }
12459 }
12464 }
12469 }
12474 }
12480 }
12486 }
12489 }
12492 }
12498 }
12504 }
12510 }
12517 // [stack] specifier
12519 }
12522 // [stack] specifier options
12525 }
12527 // [stack] specifier undefined
12530 }
12531 }
12535 }
12538 }
12543 }
12546 #ifdef ENABLE_RECORD_TUPLE
12550 }
12556 }
12558 #endif
12567 }
12570 }
12579 }
12583 }
12587 }
12593 }
12599 /*
12600 * Compute delta from the last annotated bytecode's offset. If it's too
12601 * big to fit in sn, allocate one or more xdelta notes and reset sn.
12602 */
12610 }
12612 };
12616 }
12620 }
12626 }
12629 }
12636 }
12639 }
12642 }
12644 }
12656 }
12660 }
12665 // The Line operand is either 1 byte or 4 bytes.
12674 }
12678 }
12684 }
12692 }
12694 };
12697 }
12704 }
12712 }
12714 // Hand over the ImmutableScriptData instance generated by BCE.
12719 }
12721 // De-duplicate the bytecode within the runtime.
12724 }
12729 // Update flags specific to functions.
12738 }
12741 }
12749 }
12753 }
12757 }
12758 }
12761 }
12763 #if defined(DEBUG) || defined(JS_JITSPEW)
12766 }
12767 #endif