| blob | a6a6cf916a7736a01a94f9e6cbfb2e016eb5f065 |
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)
151 }
160 EmitterMode emitterMode)
162 emitterMode) {
164 }
169 }
175 }
176 }
178 }
183 }
188 }
193 }
197 }
203 }
208 }
216 }
218 }
223 }
227 }
229 // We track the location of the most recent separator for use in
230 // markSimpleBreakpoint. Note that this means that the position must already
231 // be set before markStepBreakpoint is called.
235 }
240 }
242 // If a breakable call ends up being the same location as the most recent
243 // expression start, we need to skip marking it breakable in order to avoid
244 // having two breakpoints with the same line/column position.
245 // Note: This assumes that the position for the call has already been set.
249 }
250 }
253 }
264 }
268 }
271 // Even if every bytecode op is a JOF_IC op and the function has ARGC_LIMIT
272 // arguments, numICEntries cannot overflow.
276 }
279 }
281 #ifdef DEBUG
285 }
288 }
290 }
291 #endif
296 BytecodeOffset offset;
299 }
305 }
310 BytecodeOffset offset;
313 }
320 }
325 /* These should filter through emitVarOp. */
329 BytecodeOffset offset;
332 }
340 }
346 BytecodeOffset off;
349 }
353 /* The remaining |extra| bytes are set by the caller */
355 /*
356 * Don't updateDepth if op's use-count comes from the immediate
357 * operand yet to be stored in the extra bytes after op.
358 */
361 }
365 }
367 }
372 // Record the current IC-entry index at start of this op.
380 }
384 }
389 // Alias consecutive jump targets.
395 }
400 BytecodeOffset opOff;
402 }
405 BytecodeOffset offset;
408 }
417 }
422 }
424 JumpTarget fallthrough;
427 }
428 }
430 }
443 }
448 }
449 JumpTarget target;
452 }
455 }
462 }
463 }
465 }
469 }
477 }
481 }
486 }
489 BytecodeOffset off;
492 }
496 }
499 }
506 }
508 // 2 JSOp::Pop instructions (2 bytes) are shorter than JSOp::PopN (3 bytes).
511 }
514 }
521 }
524 }
531 }
534 }
538 }
542 }
544 /* Updates line number notes, not column notes. */
548 }
556 }
564 // If we use a `SetLine` note below, we want it to be relative to the
565 // scripts initial line number for better chance of sharing.
569 /*
570 * Encode any change in the current source line number by using
571 * either several SrcNoteType::NewLine notes or just one
572 * SrcNoteType::SetLine note, whichever consumes less space.
573 *
574 * NB: We handle backward line number deltas (possible with for
575 * loops where the update part is emitted after the body, but its
576 * line number is <= any line number in the body) here by letting
577 * unsigned delta_ wrap to a very large number, which triggers a
578 * SrcNoteType::SetLine.
579 */
585 }
590 }
592 }
595 }
597 }
599 /* Updates the line number and column number information in the source notes. */
603 }
607 }
612 // Assert colspan is always representable.
630 }
635 }
636 }
641 }
642 }
645 }
647 }
652 }
654 }
657 // Try to give the JSOp::LoopHead the same line number as the next
658 // instruction. nextpn is often a block, in which case the next instruction
659 // typically comes from the first statement inside.
662 }
666 }
667 }
670 }
676 }
678 }
681 BytecodeOffset off;
684 }
687 }
694 }
698 }
702 }
710 BytecodeOffset offset;
713 }
720 }
725 // .generator lookups should be emitted as JSOp::GetAliasedVar instead of
726 // JSOp::GetName etc, to bypass |with| objects on the scope chain.
727 // It's safe to emit .this lookups though because |with| objects skip
728 // those.
732 GCThingIndex index;
735 }
738 }
742 #ifdef DEBUG
745 #endif
747 }
751 GCThingIndex index;
754 }
757 }
762 }
768 }
774 }
778 }
784 BytecodeOffset off;
787 }
791 }
795 BytecodeOffset off;
798 }
802 }
811 BytecodeOffset off;
814 }
822 }
829 }
834 }
837 }
839 }
845 }
847 restart:
850 // Trivial cases with no side effects.
864 // ParseNodeKind::Name
886 // |this| can throw in derived class constructors, including nested arrow
887 // functions or eval.
893 // |new.target| doesn't have any side-effects.
898 }
900 // Trivial binary nodes with more token pos holders.
907 }
924 // Watch out for getters!
931 // Unary cases with side effects only if the child has them.
937 // Even if the name expression is effect-free, performing ToPropertyKey on
938 // it might not be effect-free:
939 //
940 // RegExp.prototype.toString = () => { throw 42; };
941 // ({ [/regex/]: 0 }); // ToPropertyKey(/regex/) throws 42
942 //
943 // function Q() {
944 // ({ [new.target]: 0 });
945 // }
946 // Q.toString = () => { throw 17; };
947 // new Q; // new.target will be Q, ToPropertyKey(Q) throws 17
953 // Looking up or evaluating the associated name could throw.
959 // This unary case has side effects on the enclosing object, sure. But
960 // that's not the question this function answers: it's whether the
961 // operation may have a side effect on something *other* than the result
962 // of the overall operation in which it's embedded. The answer to that
963 // is no, because an object literal having a mutated prototype only
964 // produces a value, without affecting anything else.
968 // Unary cases with obvious side effects.
978 // These might invoke valueOf/toString, even with a subexpression without
979 // side effects! Consider |+{ valueOf: null, toString: null }|.
987 // This invokes the (user-controllable) iterator protocol.
1001 // Deletion generally has side effects, even if isolated cases have none.
1010 // Deletion of a non-Reference expression has side effects only through
1011 // evaluating the expression.
1015 }
1020 // Binary cases with obvious side effects.
1051 // Strict equality operations and short circuit operators are well-behaved
1052 // and perform no conversions.
1058 // Any subexpression of a comma expression could be effectful.
1062 // Subcomponents of a literal may be effectful.
1068 }
1071 }
1072 }
1075 #ifdef ENABLE_RECORD_TUPLE
1079 #endif
1081 #ifdef ENABLE_DECORATORS
1084 #endif
1086 // Most other binary operations (parsed as lists in SpiderMonkey) may
1087 // perform conversions triggering side effects. Math operations perform
1088 // ToNumber and may fail invoking invalid user-defined toString/valueOf:
1089 // |5 < { toString: null }|. |instanceof| throws if provided a
1090 // non-object constructor: |null instanceof null|. |in| throws if given
1091 // a non-object RHS: |5 in null|.
1122 }
1125 }
1127 }
1129 // More getters.
1136 // Throws if the operand is not of the right class. Can also call a private
1137 // getter.
1143 // These affect visible names in this code, or in other code.
1151 // Likewise.
1163 // Every part of a loop might be effect-free, but looping infinitely *is*
1164 // an effect. (Language lawyer trivia: C++ says threads can be assumed
1165 // to exit or have side effects, C++14 [intro.multithread]p27, so a C++
1166 // implementation's equivalent of the below could set |*answer = false;|
1167 // if all loop sub-nodes set |*answer = false|!)
1175 // Declarations affect the name set of the relevant scope.
1188 }
1191 }
1194 }
1197 }
1200 }
1202 }
1204 // Function calls can invoke non-local code.
1214 // Function arg lists can contain arbitrary expressions. Technically
1215 // this only causes side-effects if one of the arguments does, but since
1216 // the call being made will always trigger side-effects, it isn't needed.
1227 // Classes typically introduce names. Even if no name is introduced,
1228 // the heritage and/or class body (through computed property names)
1229 // usually have effects.
1235 // |with| calls |ToObject| on its expression and so throws if that value
1236 // is null/undefined.
1252 // Shorthands could trigger getters: the |x| in the object literal in
1253 // |with ({ get x() { throw 42; } }) ({ x });|, for example, triggers
1254 // one. (Of course, it isn't necessary to use |with| for a shorthand to
1255 // trigger a getter.)
1263 /*
1264 * A named function, contrary to ES3, is no longer effectful, because
1265 * we bind its name lexically (using JSOp::Callee) instead of creating
1266 * an Object instance and binding a readonly, permanent property in it
1267 * (the object and binding can be detected and hijacked or captured).
1268 * This is a bug fix to ES3; it is fixed in ES3.1 drafts.
1269 */
1281 }
1284 }
1288 }
1291 }
1292 }
1296 }
1297 }
1299 }
1306 }
1309 }
1310 }
1312 }
1318 }
1321 }
1329 // We could methodically check every interpolated expression, but it's
1330 // probably not worth the trouble. Treat template strings as effect-free
1331 // only if they don't contain any substitutions.
1336 "template strings must alternate template and substitution "
1340 }
1342 // This should be unreachable but is left as-is for now.
1376 }
1379 "invalid, unenumerated ParseNodeKind value encountered in "
1381 }
1385 }
1390 }
1393 // Short-circuit if there is an enclosing 'with' scope.
1396 }
1398 // Otherwise see if the current point is under a 'with'.
1403 }
1404 }
1407 }
1417 // The Parser is responsible for marking the environment as either
1418 // closed-over or used-by-eval which ensure that is must exist.
1421 }
1422 }
1424 numHops++;
1425 }
1426 }
1427 }
1429 // The "this" environment exists outside of the compilation, but the
1430 // `ScopeContext` recorded the number of additional hops needed, so add
1431 // those in now.
1435 }
1438 // Get the innermost enclosing function that has a |this| binding.
1440 // Directly load callee from the frame if possible.
1443 }
1445 // We have to load the callee from the environment chain.
1455 }
1460 }
1463 }
1475 }
1485 }
1491 }
1498 }
1505 }
1511 }
1514 }
1519 ObjLiteralWriter writer;
1526 }
1531 }
1533 GCThingIndex shape;
1536 }
1539 }
1544 }
1547 }
1550 }
1552 }
1559 }
1562 }
1568 }
1573 }
1576 // The parser ensures the private name is present on the environment chain,
1577 // but its location can be Dynamic or Global when emitting debugger
1578 // eval-in-frame code.
1586 }
1590 ValueIsOnStack isOnStack) {
1591 // Dynamic accesses have TDZ checks built into their VM code and should
1592 // never emit explicit TDZ checks.
1596 // Private names are implemented as lexical bindings, but it's just an
1597 // implementation detail. Per spec there's no TDZ check when using them.
1600 }
1606 }
1608 // We've already emitted a check in this basic block.
1611 }
1613 // If the value is not on the stack, we have to load it first.
1618 }
1622 }
1623 }
1624 }
1626 // Emit the lexical check.
1630 }
1635 }
1636 }
1638 // Pop the value if needed.
1642 }
1643 }
1646 }
1654 // The non-optimized case.
1656 }
1658 // If the object operand is also a dotted property reference, reverse the
1659 // list linked via expression() temporarily so we can iterate over it from
1660 // the bottom up (reversing again as we go), to avoid excessive recursion.
1665 // Reverse pndot->expression() to point up, not down.
1671 }
1674 }
1676 // pndown is a primary expression, not a dotted property reference.
1679 }
1682 // Walk back up the list, emitting annotated name ops.
1685 }
1687 // Reverse the pndot->expression() link again.
1693 }
1695 }
1697 }
1715 }
1719 // [stack] THIS
1721 }
1724 // [stack] OBJ
1726 }
1727 }
1729 // [stack] RESULT
1731 }
1734 }
1751 }
1754 }
1760 // [stack]
1762 }
1765 // [stack] THIS
1767 }
1769 // [stack] THIS
1771 }
1773 // [stack] THIS KEY
1775 }
1778 }
1781 // [stack]
1783 }
1785 // [stack] OBJ
1787 }
1789 // [stack] OBJ? OBJ
1791 }
1793 // [stack] OBJ? OBJ KEY
1795 }
1798 }
1803 }
1806 }
1812 }
1826 }
1827 }
1841 }
1842 }
1853 // [stack] # if Super
1854 // [stack] THIS KEY
1855 // [stack] # otherwise
1856 // [stack] OBJ KEY
1858 }
1860 // [stack] RESULT
1862 }
1865 }
1876 // [stack] CALLRESULT
1878 }
1880 // [stack] N
1882 }
1884 // The increment/decrement has no side effects, so proceed to throw for
1885 // invalid assignment target.
1887 }
1890 ValueUsage valueUsage) {
1896 // [stack] OBJ
1898 }
1900 // [stack] OBJ NAME
1902 }
1904 // [stack] RESULT
1906 }
1909 }
1912 BytecodeOffset offset;
1915 }
1922 }
1929 }
1932 }
1935 }
1941 }
1943 BytecodeOffset off;
1946 }
1949 BytecodeOffset off;
1952 }
1954 }
1956 }
1959 }
1961 /*
1962 * Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047.
1963 * LLVM is deciding to inline this function which uses a lot of stack space
1964 * into emitTree which is recursive and uses relatively little stack space.
1965 */
1975 }
1979 }
1982 }
1984 // Enter the scope before pushing the switch BreakableControl since all
1985 // breaks are under this scope.
1990 }
1992 // A switch statement may contain hoisted functions inside its
1993 // cases. The hasTopLevelFunctionDeclarations flag is propagated from the
1994 // StatementList bodies of the cases to the case list.
2002 }
2003 }
2004 }
2005 }
2008 }
2019 }
2026 }
2032 }
2036 }
2037 }
2040 }
2044 }
2050 }
2054 }
2056 // Emit code for evaluating cases and jumping to case statements.
2061 }
2065 }
2068 // If the expression is a literal, suppress line number emission so
2069 // that debugging works more naturally.
2074 }
2078 }
2079 }
2080 }
2082 // Emit code for each case's statements.
2088 }
2095 #ifdef DEBUG
2096 // Use NumberEqualsInt32 here because switches compare using
2097 // strict equality, which will equate -0 and +0. In contrast
2098 // NumberIsInt32 would return false for -0.
2101 #endif
2106 }
2110 }
2111 }
2112 }
2116 }
2117 }
2121 }
2124 }
2132 "resumeIndex should not include magic AbstractGeneratorObject "
2136 "resumeIndex * sizeof(uintptr_t) must fit in an int32. JIT code relies "
2143 }
2146 }
2156 }
2159 }
2160 }
2163 }
2168 }
2173 BytecodeOffset off;
2176 }
2180 }
2185 }
2189 BytecodeOffset unusedOffset;
2191 }
2195 }
2198 // ParseNodeKind::SetThis is used to update |this| after a super() call
2199 // in a derived class constructor.
2206 // The 'this' binding is not lexical, but due to super() semantics this
2207 // initialization needs to be treated as a lexical one.
2209 NameLocation lexicalLoc;
2220 }
2224 // [stack]
2226 }
2228 // Emit the new |this| value.
2230 // [stack] NEWTHIS
2232 }
2234 // Get the original |this| and throw if we already initialized
2235 // it. Do *not* use the NameLocation argument, as that's the special
2236 // lexical location below to deal with super() semantics.
2238 // [stack] NEWTHIS THIS
2240 }
2242 // [stack] NEWTHIS THIS
2244 }
2246 // [stack] NEWTHIS
2248 }
2250 // [stack] NEWTHIS
2252 }
2256 }
2259 }
2269 }
2273 }
2276 }
2278 // For Global and sloppy-Eval scripts, this performs most of the steps of the
2279 // spec's [GlobalDeclarationInstantiation] and [EvalDeclarationInstantiation]
2280 // operations.
2281 //
2282 // Note that while strict-Eval is handled in the same part of the spec, it never
2283 // fails for global-redeclaration checks so those scripts initialize directly in
2284 // their bytecode.
2287 // ES Modules have dedicated variable and lexial environments and therefore
2288 // do not have to perform redeclaration checks. We initialize their bindings
2289 // elsewhere in bytecode.
2291 }
2294 // Strict Eval has a dedicated variables (and lexical) environment and
2295 // therefore does not have to perform redeclaration checks. We initialize
2296 // their bindings elsewhere in the bytecode.
2298 }
2300 // If we have no variables bindings, then we are done!
2304 }
2310 }
2311 }
2313 #if DEBUG
2314 // There should be no emitted functions yet.
2317 }
2318 #endif
2320 // Emit the hoisted functions to gc-things list. There is no bytecode
2321 // generated yet to bind them.
2324 }
2326 // Save the last GCThingIndex emitted. The hoisted functions are contained in
2327 // the gc-things list up until this point. This set of gc-things also contain
2328 // initial scopes (of which there must be at least one).
2330 GCThingIndex lastFun =
2333 #if DEBUG
2337 }
2338 #endif
2340 // Check for declaration conflicts and initialize the bindings.
2341 // NOTE: The self-hosting top-level script should not populate the builtins
2342 // directly on the GlobalObject (and instead uses JSOp::GetIntrinsic for
2343 // lookups).
2347 }
2348 }
2351 }
2364 }
2368 }
2373 }
2376 }
2377 }
2384 // Sloppy eval scripts may emit hoisted functions bindings with a
2385 // `JSOp::GlobalOrEvalDeclInstantiation` opcode below. If this eval needs a
2386 // top-level lexical environment, we must ensure that environment is created
2387 // before those functions are created and bound.
2388 //
2389 // This differs from the global-script case below because the global-lexical
2390 // environment exists outside the script itself. In the case of strict eval
2391 // scripts, the `emitterScope` above is already sufficient.
2398 }
2402 }
2409 }
2413 }
2417 }
2421 }
2425 }
2426 }
2433 }
2434 }
2437 // [stack]
2439 }
2443 }
2444 }
2449 }
2450 }
2454 }
2458 }
2462 }
2466 }
2468 // Create a Stencil and convert it into a JSScript.
2470 }
2477 }
2484 // Add fields to the property count estimate.
2486 propertyCountEstimate +=
2488 }
2497 }
2505 }
2508 }
2517 // [stack]
2522 // [stack]
2524 }
2527 // [stack]
2529 }
2532 // [stack]
2534 }
2537 // [stack]
2539 }
2542 // [stack]
2544 }
2549 }
2550 }
2553 }
2557 #ifdef DEBUG
2559 #endif
2565 // No need to recurse into ParseNodeKind::Array and ParseNodeKind::Object
2566 // subpatterns here, since emitSetOrInitializeDestructuring does the
2567 // recursion when setting or initializing the value. Getting reference
2568 // doesn't recurse.
2580 }
2584 // [stack] THIS SUPERBASE
2586 }
2589 // [stack] OBJ
2591 }
2592 }
2594 // [stack] # if Super
2595 // [stack] THIS SUPERBASE
2596 // [stack] # otherwise
2597 // [stack] OBJ
2599 }
2601 // SUPERBASE was pushed onto THIS in poe.prepareForRhs above.
2604 }
2614 // [stack] # if Super
2615 // [stack] THIS KEY
2616 // [stack] # otherwise
2617 // [stack] OBJ KEY
2619 }
2621 // [stack] # if Super
2622 // [stack] THIS KEY SUPERBASE
2623 // [stack] # otherwise
2624 // [stack] OBJ KEY
2626 }
2628 // SUPERBASE was pushed onto KEY in eoe.prepareForRhs above.
2631 }
2638 // [stack] OBJ
2640 }
2642 // [stack] OBJ NAME
2644 }
2647 }
2651 "Parser::reportIfNotValidSimpleAssignmentTarget "
2652 "rejects function calls as assignment "
2658 }
2663 }
2667 // Now emit the lvalue opcode sequence. If the lvalue is a nested
2668 // destructuring initialiser-form, call ourselves to handle it, then pop
2669 // the matched value. Otherwise emit an lvalue bytecode sequence followed
2670 // by an assignment op.
2677 }
2678 // emitDestructuringOps leaves the assigned (to-be-destructured) value on
2679 // top of the stack.
2694 }
2698 // [stack] V ENV?
2700 }
2702 // This is like ordinary assignment, but with one difference.
2703 //
2704 // In `a = b`, we first determine a binding for `a` (using
2705 // JSOp::BindName or JSOp::BindGName), then we evaluate `b`, then
2706 // a JSOp::SetName instruction.
2707 //
2708 // In `[a] = [b]`, per spec, `b` is evaluated first, then we
2709 // determine a binding for `a`. Then we need to do assignment--
2710 // but the operands are on the stack in the wrong order for
2711 // JSOp::SetProp, so we have to add a JSOp::Swap.
2712 //
2713 // In the cases where we are emitting a name op, emit a swap
2714 // because of this.
2716 // [stack] ENV V
2718 }
2720 // In cases of emitting a frame slot or environment slot,
2721 // nothing needs be done.
2722 }
2724 // [stack] V
2726 }
2729 }
2732 // The reference is already pushed by emitDestructuringLHSRef.
2733 // [stack] # if Super
2734 // [stack] THIS SUPERBASE VAL
2735 // [stack] # otherwise
2736 // [stack] OBJ VAL
2744 }
2745 // [stack] # VAL
2748 }
2750 }
2753 // The reference is already pushed by emitDestructuringLHSRef.
2754 // [stack] # if Super
2755 // [stack] THIS KEY SUPERBASE VAL
2756 // [stack] # otherwise
2757 // [stack] OBJ KEY VAL
2766 }
2768 // [stack] VAL
2770 }
2772 }
2775 // The reference is already pushed by emitDestructuringLHSRef.
2776 // [stack] OBJ NAME VAL
2782 }
2784 // [stack] VAL
2786 }
2788 }
2792 "Parser::reportIfNotValidSimpleAssignmentTarget "
2793 "rejects function calls as assignment "
2799 }
2801 // Pop the assigned value.
2803 // [stack] # empty
2805 }
2808 }
2811 SelfHostedIter selfHostedIter) {
2822 }
2823 }
2826 }
2834 ".next() iteration is prohibited in self-hosted code because it"
2837 // [stack] ... NEXT ITER
2841 callSourceCoordOffset)) {
2842 // [stack] ... RESULT
2844 }
2848 // [stack] ... RESULT
2850 }
2851 }
2854 // [stack] ... RESULT
2856 }
2858 }
2867 ".close() on iterators is prohibited in self-hosted code because "
2872 }
2874 // Generate inline logic corresponding to IteratorClose (ES2021 7.4.6) and
2875 // AsyncIteratorClose (ES2021 7.4.7). Steps numbers apply to both operations.
2876 //
2877 // Callers need to ensure that the iterator object is at the top of the
2878 // stack.
2880 // For non-Throw completions, we emit the equivalent of:
2881 //
2882 // var returnMethod = GetMethod(iterator, "return");
2883 // if (returnMethod !== undefined) {
2884 // var innerResult = [Await] Call(returnMethod, iterator);
2885 // CheckIsObj(innerResult);
2886 // }
2887 //
2888 // Whereas for Throw completions, we emit:
2889 //
2890 // try {
2891 // var returnMethod = GetMethod(iterator, "return");
2892 // if (returnMethod !== undefined) {
2893 // [Await] Call(returnMethod, iterator);
2894 // }
2895 // } catch {}
2904 // [stack] ... ITER
2906 }
2907 }
2910 // [stack] ... ITER ITER
2912 }
2914 // Steps 1-2 are assertions, step 3 is implicit.
2916 // Step 4.
2917 //
2918 // Get the "return" method.
2920 // [stack] ... ITER RET
2922 }
2924 // Step 5.
2925 //
2926 // Do nothing if "return" is undefined or null.
2929 // [stack] ... ITER RET NULL-OR-UNDEF
2931 }
2935 // [stack] ... ITER RET
2937 }
2939 // Steps 5.c, 7.
2940 //
2941 // Call the "return" method.
2943 // [stack] ... RET ITER
2945 }
2948 // [stack] ... RESULT
2950 }
2952 // 7.4.7 AsyncIteratorClose, step 5.d.
2955 // Await clobbers rval, so save the current rval.
2957 // [stack] ... RESULT RVAL
2959 }
2961 // [stack] ... RVAL RESULT
2963 }
2964 }
2967 // [stack] ... RVAL? RESULT
2969 }
2973 // [stack] ... RESULT RVAL
2975 }
2977 // [stack] ... RESULT
2979 }
2980 }
2981 }
2983 // Step 6 (Handled in caller).
2985 // Step 8.
2987 // Check that the "return" result is an object.
2989 // [stack] ... RESULT
2991 }
2992 }
2995 // [stack] ... ITER RET
2997 }
3000 // [stack] ... ITER
3002 }
3006 }
3010 // [stack] ... ITER EXC
3012 }
3014 // Just ignore the exception thrown by call and await.
3016 // [stack] ... ITER
3018 }
3021 // [stack] ... ITER
3023 }
3024 }
3026 // Step 9 (Handled in caller).
3029 // [stack] ...
3030 }
3034 InnerEmitter emitter) {
3037 // Pad a nop at the beginning of the bytecode covered by the trynote so
3038 // that when unwinding environments, we may unwind to the scope
3039 // corresponding to the pc *before* the start, in case the first bytecode
3040 // emitted by |emitter| is the start of an inner scope. See comment above
3041 // UnwindEnvironmentToTryPc.
3044 }
3049 }
3053 }
3055 }
3058 // [stack] VALUE
3062 // [stack]
3064 }
3066 // [stack] DEFAULTVALUE
3068 }
3070 // [stack] VALUE/DEFAULTVALUE
3072 }
3074 }
3081 // Function doesn't have 'name' property at this point.
3082 // Set function's name at compile time.
3085 }
3088 }
3093 }
3101 // [stack] NAME FUN
3103 }
3105 // [stack] NAME FUN NAME
3107 }
3109 // [stack] NAME FUN
3111 }
3113 }
3119 }
3122 TaggedParserAtomIndex name) {
3123 // The inferred name may already be set if this function is an interpreted
3124 // lazy function and we OOM'ed after we set the inferred name the first
3125 // time.
3131 }
3135 }
3144 }
3148 }
3149 }
3152 }
3155 DestructuringFlavor flav) {
3157 "array destructuring is prohibited in self-hosted code because it"
3162 // Here's pseudo code for |let [a, b, , c=y, ...d] = x;|
3163 //
3164 // Lines that are annotated "covered by trynote" mean that upon throwing
3165 // an exception, IteratorClose is called on iter only if done is false.
3166 //
3167 // let x, y;
3168 // let a, b, c, d;
3169 // let iter, next, lref, result, done, value; // stack values
3170 //
3171 // // NOTE: the fast path for this example is not applicable, because of
3172 // // the spread and the assignment |c=y|, but it is documented here for a
3173 // // simpler example, |let [a,b] = x;|
3174 // //
3175 // // if (IsOptimizableArray(x)) {
3176 // // a = x[0];
3177 // // b = x[1];
3178 // // goto end: // (skip everything below)
3179 // // }
3180 //
3181 // iter = x[Symbol.iterator]();
3182 // next = iter.next;
3183 //
3184 // // ==== emitted by loop for a ====
3185 // lref = GetReference(a); // covered by trynote
3186 //
3187 // result = Call(next, iter);
3188 // done = result.done;
3189 //
3190 // if (done)
3191 // value = undefined;
3192 // else
3193 // value = result.value;
3194 //
3195 // SetOrInitialize(lref, value); // covered by trynote
3196 //
3197 // // ==== emitted by loop for b ====
3198 // lref = GetReference(b); // covered by trynote
3199 //
3200 // if (done) {
3201 // value = undefined;
3202 // } else {
3203 // result = Call(next, iter);
3204 // done = result.done;
3205 // if (done)
3206 // value = undefined;
3207 // else
3208 // value = result.value;
3209 // }
3210 //
3211 // SetOrInitialize(lref, value); // covered by trynote
3212 //
3213 // // ==== emitted by loop for elision ====
3214 // if (done) {
3215 // value = undefined;
3216 // } else {
3217 // result = Call(next, iter);
3218 // done = result.done;
3219 // if (done)
3220 // value = undefined;
3221 // else
3222 // value = result.value;
3223 // }
3224 //
3225 // // ==== emitted by loop for c ====
3226 // lref = GetReference(c); // covered by trynote
3227 //
3228 // if (done) {
3229 // value = undefined;
3230 // } else {
3231 // result = Call(next, iter);
3232 // done = result.done;
3233 // if (done)
3234 // value = undefined;
3235 // else
3236 // value = result.value;
3237 // }
3238 //
3239 // if (value === undefined)
3240 // value = y; // covered by trynote
3241 //
3242 // SetOrInitialize(lref, value); // covered by trynote
3243 //
3244 // // ==== emitted by loop for d ====
3245 // lref = GetReference(d); // covered by trynote
3246 //
3247 // if (done)
3248 // value = [];
3249 // else
3250 // value = [...iter];
3251 //
3252 // SetOrInitialize(lref, value); // covered by trynote
3253 //
3254 // // === emitted after loop ===
3255 // if (!done)
3256 // IteratorClose(iter);
3257 //
3258 // end:
3272 }
3274 }
3276 // Unfortunately we can't handle any recursive destructuring,
3277 // because we can't guarantee that the recursed-into parts
3278 // won't run code which invalidates our constraints. We also
3279 // cannot handle ParseNodeKind::AssignExpr for similar reasons.
3282 }
3285 }
3286 }
3288 // Use an iterator to destructure the RHS, instead of index lookup. We
3289 // must leave the *original* value on the stack.
3291 // [stack] ... OBJ OBJ
3293 }
3302 // [stack] OBJ OBJ
3304 }
3307 // [stack] OBJ OBJ IS_OPTIMIZABLE
3309 }
3312 // [stack] OBJ OBJ
3314 }
3318 // [stack] OBJ LENGTH
3320 }
3323 // [stack] LENGTH OBJ
3325 }
3332 }
3335 // [stack] LENGTH OBJ OBJ
3337 }
3340 // [stack] LENGTH OBJ OBJ IDX
3342 }
3345 // [stack] LENGTH OBJ OBJ IDX IDX
3347 }
3350 // [stack] LENGTH OBJ OBJ IDX IDX LENGTH
3352 }
3355 // [stack] LENGTH OBJ OBJ IDX IS_IN_DENSE_BOUNDS
3357 }
3361 // [stack] LENGTH OBJ OBJ IDX
3363 }
3366 // [stack] LENGTH OBJ VALUE
3368 }
3371 // [stack] LENGTH OBJ OBJ IDX
3373 }
3376 // [stack] LENGTH OBJ
3378 }
3381 // [stack] LENGTH OBJ UNDEFINED
3383 }
3386 // [stack] LENGTH OBJ VALUE|UNDEFINED
3388 }
3391 // [stack] LENGTH OBJ
3393 }
3396 }
3399 // [stack] OBJ LENGTH
3401 }
3404 // [stack] OBJ
3406 }
3409 // [stack] OBJ OBJ
3411 }
3412 }
3415 // [stack] ... OBJ NEXT ITER
3417 }
3419 // For an empty pattern [], call IteratorClose unconditionally. Nothing
3420 // else needs to be done.
3423 // [stack] ... OBJ ITER NEXT
3425 }
3427 // [stack] ... OBJ ITER
3429 }
3432 // [stack] ... OBJ
3434 }
3438 // [stack] OBJ
3440 }
3441 }
3444 }
3446 // Push an initial FALSE value for DONE.
3448 // [stack] ... OBJ NEXT ITER FALSE
3450 }
3452 // TryNoteKind::Destructuring expects the iterator and the done value
3453 // to be the second to top and the top of the stack, respectively.
3454 // IteratorClose is called upon exception only if done is false.
3468 }
3475 }
3477 // Number of stack slots emitted for the LHS reference.
3480 // Spec requires LHS reference to be evaluated first.
3485 // [stack] ... OBJ NEXT ITER DONE LREF*
3486 };
3489 }
3490 }
3492 // Pick the DONE value to the top of the stack.
3495 // [stack] ... OBJ NEXT ITER LREF* DONE
3497 }
3498 }
3501 // If this element is the first, DONE is always FALSE, so pop it.
3502 //
3503 // Non-first elements should emit if-else depending on the
3504 // member pattern, below.
3506 // [stack] ... OBJ NEXT ITER LREF*
3508 }
3509 }
3514 // If spread is not the first element of the pattern,
3515 // iterator can already be completed.
3516 // [stack] ... OBJ NEXT ITER LREF* DONE
3519 // [stack] ... OBJ NEXT ITER LREF*
3521 }
3524 // [stack] ... OBJ NEXT ITER LREF* ARRAY
3526 }
3528 // [stack] ... OBJ NEXT ITER LREF*
3530 }
3531 }
3533 // If iterator is not completed, create a new array with the rest
3534 // of the iterator.
3536 // [stack] ... OBJ NEXT ITER LREF* NEXT ITER
3538 }
3540 // [stack] ... OBJ NEXT ITER LREF* NEXT ITER ARRAY
3542 }
3544 // [stack] ... OBJ NEXT ITER LREF* NEXT ITER ARRAY INDEX
3546 }
3548 // [stack] ... OBJ NEXT ITER LREF* ARRAY INDEX
3550 }
3552 // [stack] ... OBJ NEXT ITER LREF* ARRAY
3554 }
3559 }
3561 }
3563 // At this point the iterator is done. Unpick a TRUE value for DONE above
3564 // ITER.
3566 // [stack] ... OBJ NEXT ITER LREF* ARRAY TRUE
3568 }
3570 // [stack] ... OBJ NEXT ITER TRUE LREF* ARRAY
3572 }
3576 // [stack] ... OBJ NEXT ITER TRUE
3577 };
3580 }
3584 }
3588 // [stack] ... OBJ NEXT ITER LREF* DONE
3591 // [stack] ... OBJ NEXT ITER LREF*
3593 }
3596 // [stack] ... OBJ NEXT ITER LREF* UNDEF
3598 }
3600 // [stack] ... OBJ NEXT ITER LREF* UNDEF
3602 }
3604 // The iterator is done. Unpick a TRUE value for DONE above ITER.
3606 // [stack] ... OBJ NEXT ITER LREF* UNDEF TRUE
3608 }
3610 // [stack] ... OBJ NEXT ITER TRUE LREF* UNDEF
3612 }
3615 // [stack] ... OBJ NEXT ITER LREF*
3617 }
3618 }
3621 // [stack] ... OBJ NEXT ITER LREF* NEXT
3623 }
3625 // [stack] ... OBJ NEXT ITER LREF* RESULT
3627 }
3629 // [stack] ... OBJ NEXT ITER LREF* RESULT RESULT
3631 }
3633 // [stack] ... OBJ NEXT ITER LREF* RESULT DONE
3635 }
3638 // [stack] ... OBJ NEXT ITER LREF* RESULT DONE DONE
3640 }
3642 // [stack] ... OBJ NEXT ITER DONE LREF* RESULT DONE
3644 }
3648 // [stack] ... OBJ NEXT ITER DONE LREF* RESULT
3650 }
3653 // [stack] ... OBJ NEXT ITER DONE LREF*
3655 }
3657 // [stack] ... OBJ NEXT ITER DONE LREF* UNDEF
3659 }
3661 // [stack] ... OBJ NEXT ITER DONE LREF* UNDEF
3663 }
3666 // [stack] ... OBJ NEXT ITER DONE LREF* RESULT
3668 }
3671 // [stack] ... OBJ NEXT ITER DONE LREF* VALUE
3673 }
3677 }
3683 }
3685 }
3690 // [stack] ... OBJ NEXT ITER DONE LREF* VALUE
3691 };
3695 }
3696 }
3701 // [stack] ... OBJ NEXT ITER DONE
3702 };
3706 }
3709 // [stack] ... OBJ NEXT ITER DONE
3711 }
3712 }
3713 }
3715 // The last DONE value is on top of the stack. If not DONE, call
3716 // IteratorClose.
3717 // [stack] ... OBJ NEXT ITER DONE
3721 // [stack] ... OBJ NEXT ITER
3723 }
3725 // [stack] ... OBJ
3727 }
3729 // [stack] ... OBJ NEXT ITER
3731 }
3733 // [stack] ... OBJ ITER NEXT
3735 }
3737 // [stack] ... OBJ ITER
3739 }
3741 // [stack] ... OBJ
3743 }
3746 }
3750 // [stack] OBJ
3752 }
3753 }
3756 }
3761 }
3764 DestructuringFlavor flav) {
3767 // [stack] ... RHS
3771 // [stack] ... RHS
3773 }
3779 // [stack] ... RHS SET
3781 }
3784 // [stack] ... SET RHS
3786 }
3787 }
3801 }
3808 }
3810 // Number of stack slots emitted for the LHS reference.
3813 // Spec requires LHS reference to be evaluated first.
3815 // [stack] ... SET? RHS LREF*
3817 }
3819 // Duplicate the value being destructured to use as a reference base.
3821 // [stack] ... SET? RHS LREF* RHS
3823 }
3828 }
3831 // [stack] ... SET? RHS LREF* RHS TARGET
3833 }
3835 // [stack] ... SET? RHS LREF* RHS TARGET TARGET
3837 }
3839 // [stack] ... SET? RHS LREF* TARGET TARGET RHS
3841 }
3845 // [stack] ... RHS LREF* TARGET TARGET RHS SET
3847 }
3848 }
3853 // [stack] ... RHS LREF* TARGET
3855 }
3857 // Destructure TARGET per this member's lhs.
3859 // [stack] ... RHS
3861 }
3865 }
3867 // Now push the property value currently being matched, which is the value
3868 // of the current property name "label" on the left of a colon in the object
3869 // initialiser.
3873 // [stack] ... SET? RHS LREF* PROP
3875 }
3884 // [stack] ... SET? RHS LREF* PROP
3886 }
3890 // [stack]... SET? RHS LREF* RHS KEY
3892 }
3894 // Otherwise this is a computed property name. BigInt keys are parsed
3895 // as (synthetic) computed property names, too.
3899 // [stack] ... SET? RHS LREF* RHS KEY
3901 }
3903 // Add the computed property key to the exclusion set.
3906 // [stack] ... SET RHS LREF* RHS KEY SET
3908 }
3910 // [stack] ... SET RHS LREF* RHS KEY SET KEY
3912 }
3914 // [stack] ... SET RHS LREF* RHS KEY SET KEY UNDEFINED
3916 }
3918 // [stack] ... SET RHS LREF* RHS KEY SET
3920 }
3922 // [stack] ... SET RHS LREF* RHS KEY
3924 }
3925 }
3926 }
3928 // Get the property value.
3930 // [stack] ... SET? RHS LREF* PROP
3932 }
3933 }
3934 }
3938 // [stack] ... SET? RHS LREF* VALUE
3940 }
3941 }
3943 // Destructure PROP per this member's lhs.
3945 // [stack] ... SET? RHS
3947 }
3948 }
3951 }
3960 }
3962 propCount++;
3966 }
3972 }
3974 // Number and BigInt keys aren't yet supported. Computed property names need
3975 // to be added dynamically.
3980 }
3983 // JSOp::NewObject cannot accept dictionary-mode objects.
3985 }
3988 }
3994 // See if we can use ObjLiteral to construct the exclusion set object.
3997 // [stack] OBJ
3999 }
4001 // Take the slow but sure way and start off with a blank object.
4003 // [stack] OBJ
4005 }
4006 }
4012 }
4014 TaggedParserAtomIndex pnatom;
4025 }
4027 // Otherwise this is a computed property name which needs to be added
4028 // dynamically. BigInt keys are parsed as (synthetic) computed property
4029 // names, too.
4032 }
4033 }
4035 // Initialize elements with |undefined|.
4038 }
4043 }
4047 }
4048 }
4049 }
4052 }
4055 DestructuringFlavor flav) {
4058 }
4060 }
4069 // Skip empty strings. These are very common: a template string like
4070 // `${a}${b}` has three empty strings and without this optimization
4071 // we'd emit four JSOp::Add operations instead of just one.
4075 }
4078 // We update source notes before emitting the expression
4081 }
4082 }
4086 }
4089 // We need to convert the expression to a string
4092 }
4093 }
4096 // We've pushed two strings onto the stack. Add them together, leaving
4097 // just one.
4100 }
4103 }
4104 }
4107 // All strings were empty, this can happen for something like `${""}`.
4108 // Just push an empty string.
4112 }
4113 }
4116 }
4129 }
4132 // initializer can be null here.
4134 initializer)) {
4136 }
4144 }
4147 }
4150 }
4155 }
4159 }
4160 }
4161 }
4163 }
4169 // Nothing to do for initializer-less 'var' declarations, as there's no TDZ.
4172 }
4177 // [stack] ENV?
4179 }
4181 // Lexical declarations are initialized to undefined without an
4182 // initializer.
4184 "var declarations without initializers handled above, "
4187 // [stack] ENV? UNDEF
4189 }
4195 }
4198 }
4200 // [stack] ENV? V
4202 }
4203 }
4205 // [stack] V
4207 }
4209 // [stack]
4211 }
4214 }
4221 }
4223 }
4225 }
4227 // The RHS value to assign is already on the stack, i.e., the next enumeration
4228 // value in a for-in or for-of loop. Offset is the location in the stack of the
4229 // already-emitted rhs. If we emitted a JSOp::BindName or JSOp::BindGName, then
4230 // the scope is on the top of the stack and we need to dig one deeper to get
4231 // the right RHS value.
4235 }
4238 }
4273 // Short-circuit assignment operators are handled elsewhere.
4277 }
4278 }
4286 // We estimate the number of properties this could create
4287 // if used as constructor merely by counting this.foo = assignment
4288 // or init expressions;
4289 //
4290 // This currently doesn't handle this[x] = foo;
4295 propertyAdditionEstimate++;
4296 }
4297 }
4298 }
4304 // |name| is used within NameOpEmitter, so its lifetime must surpass |noe|.
4305 TaggedParserAtomIndex name;
4312 // Deal with non-name assignments.
4315 // Purpose of anonFunctionName:
4316 //
4317 // In normal name assignments (`f = function(){}`), an anonymous function gets
4318 // an inferred name based on the left-hand side name node.
4319 //
4320 // In normal property assignments (`obj.x = function(){}`), the anonymous
4321 // function does not have a computed name, and rhs->isDirectRHSAnonFunction()
4322 // will be false (and anonFunctionName will not be used). However, in field
4323 // initializers (`class C { x = function(){} }`), field initialization is
4324 // implemented via a property or elem assignment (where we are now), and
4325 // rhs->isDirectRHSAnonFunction() is set - so we'll assign the name of the
4326 // function.
4327 TaggedParserAtomIndex anonFunctionName;
4337 }
4349 }
4354 // [stack] THIS SUPERBASE
4356 }
4357 // SUPERBASE is pushed onto THIS later in poe->emitGet below.
4361 // [stack] OBJ
4363 }
4365 }
4367 }
4379 // [stack] # if Super
4380 // [stack] THIS KEY
4381 // [stack] # otherwise
4382 // [stack] OBJ KEY
4384 }
4386 // SUPERBASE is pushed onto KEY in eoe->emitGet below.
4390 }
4392 }
4401 // [stack] OBJ
4403 }
4405 // [stack] OBJ KEY
4407 }
4410 }
4417 }
4419 // Assignment to function calls is forbidden, but we have to make the
4420 // call first. Now we can throw.
4423 }
4425 // Rebalance the stack to placate stack-depth assertions.
4428 }
4432 }
4440 // [stack] # if Super
4441 // [stack] THIS SUPERBASE PROP
4442 // [stack] # otherwise
4443 // [stack] OBJ PROP
4445 }
4447 }
4450 // [stack] KEY THIS OBJ ELEM
4452 }
4454 }
4457 // [stack] OBJ KEY VALUE
4459 }
4461 }
4463 // We just emitted a JSOp::ThrowMsg and popped the call's return
4464 // value. Push a random value to make sure the stack depth is
4465 // correct.
4467 // [stack] NULL
4469 }
4472 }
4473 }
4478 // [stack] ENV? VAL?
4480 }
4485 // [stack] # if Simple Assignment with Super
4486 // [stack] THIS SUPERBASE
4487 // [stack] # if Simple Assignment with other
4488 // [stack] OBJ
4489 // [stack] # if Compound Assignment with Super
4490 // [stack] THIS SUPERBASE PROP
4491 // [stack] # if Compound Assignment with other
4492 // [stack] OBJ PROP
4494 }
4498 // [stack] # if Simple Assignment with Super
4499 // [stack] THIS KEY SUPERBASE
4500 // [stack] # if Simple Assignment with other
4501 // [stack] OBJ KEY
4502 // [stack] # if Compound Assignment with Super
4503 // [stack] THIS KEY SUPERBASE ELEM
4504 // [stack] # if Compound Assignment with other
4505 // [stack] OBJ KEY ELEM
4507 }
4510 // no stack adjustment needed
4514 }
4518 // [stack] ... VAL? RHS
4520 }
4522 // Assumption: Things with pre-emitted RHS values never need to be named.
4524 // [stack] ... VAL? RHS
4526 }
4527 }
4529 /* If += etc., emit the binary operator with a hint for the decompiler. */
4532 // [stack] ... VAL
4534 }
4536 // [stack] ... VAL
4538 }
4539 }
4541 /* Finally, emit the specialized assignment bytecode. */
4545 // [stack] VAL
4547 }
4549 }
4553 // [stack] VAL
4555 }
4557 }
4559 // We threw above, so nothing to do here.
4563 // [stack] VAL
4565 }
4567 }
4570 // [stack] VAL
4572 }
4579 }
4583 }
4585 }
4590 JSOp op;
4603 }
4608 // |name| is used within NameOpEmitter, so its lifetime must surpass |noe|.
4609 TaggedParserAtomIndex name;
4611 // Select the appropriate emitter based on the left-hand side.
4619 // Number of values pushed onto the stack in addition to the lhs value.
4622 // Evaluate the left-hand side expression and compute any stack values needed
4623 // for the assignment.
4630 // [stack] ENV? LHS
4632 }
4636 }
4648 }
4653 // [stack] THIS SUPERBASE
4655 }
4658 // [stack] OBJ
4660 }
4661 }
4664 // [stack] # if Super
4665 // [stack] THIS SUPERBASE LHS
4666 // [stack] # otherwise
4667 // [stack] OBJ LHS
4669 }
4672 // [stack] # if Super
4673 // [stack] THIS SUPERBASE LHS
4674 // [stack] # otherwise
4675 // [stack] OBJ LHS
4677 }
4681 }
4692 // [stack] # if Super
4693 // [stack] THIS KEY
4694 // [stack] # otherwise
4695 // [stack] OBJ KEY
4697 }
4700 // [stack] # if Super
4701 // [stack] THIS KEY SUPERBASE LHS
4702 // [stack] # otherwise
4703 // [stack] OBJ KEY LHS
4705 }
4708 // [stack] # if Super
4709 // [stack] THIS KEY SUPERBASE LHS
4710 // [stack] # otherwise
4711 // [stack] OBJ KEY LHS
4713 }
4717 }
4724 // [stack] OBJ
4726 }
4728 // [stack] OBJ NAME
4730 }
4732 // [stack] OBJ NAME LHS
4734 }
4737 }
4741 }
4745 // Test for the short-circuit condition.
4746 JumpList jump;
4748 // [stack] ... LHS
4750 }
4752 // The short-circuit condition wasn't fulfilled, pop the left-hand side value
4753 // which was kept on the stack.
4755 // [stack] ...
4757 }
4760 // [stack] ... RHS
4762 }
4764 // Perform the actual assignment.
4768 // [stack] RHS
4770 }
4772 }
4778 // [stack] RHS
4780 }
4782 }
4786 // [stack] RHS
4788 }
4790 }
4794 // [stack] RHS
4796 }
4801 }
4805 // Join with the short-circuit jump and pop anything left on the stack.
4807 JumpList jumpAroundPop;
4809 // [stack] RHS
4811 }
4814 // [stack] ... LHS
4816 }
4818 // Reconstruct the stack depth after the jump.
4821 // Move the left-hand side value to the bottom and pop the rest.
4823 // [stack] LHS ...
4825 }
4827 // [stack] LHS
4829 }
4832 // [stack] LHS | RHS
4834 }
4837 // [stack] LHS | RHS
4839 }
4840 }
4845 }
4857 }
4858 idx++;
4859 }
4863 }
4868 // The first element of a call-site node is the raw-values list. Skip over it.
4876 ObjLiteralWriter writer;
4880 // Write elements of the two arrays: the 'cooked' values followed by the
4881 // 'raw' values.
4886 }
4889 }
4891 GCThingIndex cookedIndex;
4894 }
4899 }
4902 // We must be nested under a try-finally statement.
4907 // Catch parameter was omitted; just discard the exception.
4910 }
4918 }
4921 }
4927 }
4930 }
4935 }
4936 }
4938 /* Emit the catch body. */
4940 }
4942 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See the
4943 // comment on EmitSwitch.
4954 }
4958 }
4963 }
4967 }
4969 // If this try has a catch block, emit it.
4971 // The emitted code for a catch block looks like:
4972 //
4973 // [pushlexicalenv] only if any local aliased
4974 // exception
4975 // setlocal 0; pop assign or possibly destructure exception
4976 // < catch block contents >
4977 // debugleaveblock
4978 // [poplexicalenv] only if any local aliased
4979 // if there is a finally block:
4980 // goto <finally>
4981 // [jump target for returning from finally]
4982 // goto <after finally>
4985 }
4987 // Emit the lexical scope and catch body.
4990 }
4991 }
4993 // Emit the finally handler, if there is one.
4997 }
5001 }
5002 }
5006 }
5009 }
5013 // Push the continuation index.
5016 }
5018 // Push |throwing|.
5021 }
5023 // Jump to the finally block.
5026 }
5029 }
5036 }
5038 if_again:
5044 }
5048 }
5050 // Emit code for the condition before pushing stmtInfo.
5051 // NOTE: NotExpr of testNode may be unwrapped, and in that case the negation
5052 // is handled by conditionKind.
5055 }
5061 }
5065 }
5066 }
5068 /* Emit code for the then part. */
5071 }
5079 }
5082 }
5086 }
5088 /* Emit code for the else part. */
5091 }
5092 }
5096 }
5099 }
5104 // We can call this multiple times for sloppy eval scopes.
5107 }
5117 }
5118 }
5124 }
5125 }
5126 }
5129 }
5135 // This block contains function statements whose definitions are
5136 // hoisted to the top of the block. Emit these as a separate pass
5137 // before the rest of the block.
5140 }
5141 }
5143 // Line notes were updated by emitLexicalScope or emitScript.
5145 }
5147 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
5148 // the comment on emitSwitch.
5157 }
5161 }
5165 }
5168 }
5170 // We are about to emit some bytecode for what the spec calls "declaration
5171 // instantiation". Assign these instructions to the opening `{` of the
5172 // block. (Using the location of each declaration we're instantiating is
5173 // too weird when stepping in the debugger.)
5177 }
5178 }
5180 ScopeKind kind;
5183 kind =
5189 }
5193 }
5196 // for loops need to emit JSOp::FreshenLexicalEnv/JSOp::RecreateLexicalEnv
5197 // if there are lexical declarations in the head. Signal this by passing a
5198 // non-nullptr lexical scope.
5201 }
5205 }
5206 }
5210 }
5212 }
5215 // Ensure that the column of the 'with' is set properly.
5218 }
5222 }
5226 }
5231 }
5235 }
5238 }
5246 // [stack] TARGET SOURCE SET
5251 // [stack] TARGET SOURCE SET COPYDATAPROPERTIES
5253 }
5256 // [stack] TARGET SOURCE
5262 // [stack] TARGET SOURCE COPYDATAPROPERTIES
5264 }
5265 }
5268 // [stack] TARGET SOURCE SET? COPYDATAPROPERTIES
5269 // UNDEFINED
5271 }
5273 // [stack] SOURCE SET? COPYDATAPROPERTIES UNDEFINED
5274 // TARGET
5276 }
5278 // [stack] SET? COPYDATAPROPERTIES UNDEFINED TARGET
5279 // SOURCE
5281 }
5284 // [stack] COPYDATAPROPERTIES UNDEFINED TARGET SOURCE SET
5286 }
5287 }
5288 // Callee is always self-hosted instrinsic, and cannot be content function.
5290 // [stack] IGNORED
5292 }
5295 // [stack]
5297 }
5301 }
5304 GCThingIndex index;
5307 }
5309 }
5312 SelfHostedIter selfHostedIter,
5313 IteratorKind iterKind) {
5317 // [stack] ITERABLE
5319 }
5324 // [stack] ITERABLE
5328 // This is the following case:
5329 //
5330 // for (const nextValue of allowContentIterWith(items, usingIterator)) {
5331 //
5332 // `items` is emitted by `emitTree(value)` above, and the result is on the
5333 // stack as ITERABLE.
5334 // `usingIterator` is the value of `items[Symbol.iterator]`, that's
5335 // already retrieved.
5341 // [stack] ITERABLE ITERFN
5343 }
5345 // Async iterator has two possible iterators: An async iterator and a sync
5346 // iterator.
5349 // [stack] ITERABLE ASYNC_ITERFN SYNC_ITERFN
5351 }
5352 }
5354 // [stack] ITERABLE ASYNC_ITERFN? SYNC_ITERFN
5356 }
5359 // This is the following case:
5360 //
5361 // for (const nextValue of allowContentIterWithNext(iterator, next)) {
5362 //
5363 // `iterator` is emitted by `emitTree(value)` above, and the result is on
5364 // the stack as ITER.
5365 // `next` is the value of `iterator.next`, that's already retrieved.
5370 // [stack] ITER NEXT
5372 }
5375 // [stack] NEXT ITER
5377 }
5379 // [stack] NEXT ITER
5381 }
5382 }
5385 }
5390 "[Symbol.iterator]() call is prohibited in self-hosted code "
5394 // [stack] NEXT ITER
5396 // Nothing to do, stack already contains the iterator and its `next` method.
5398 }
5401 // [stack] OBJ
5403 // Convert iterable to iterator.
5405 // [stack] OBJ OBJ
5407 }
5409 // [stack] OBJ OBJ @@ITERATOR
5411 }
5413 // [stack] OBJ ITERFN
5415 }
5416 }
5419 // [stack] ITERFN OBJ
5421 }
5423 // [stack] ITER
5425 }
5427 // [stack] ITER
5429 }
5431 // [stack] ITER ITER
5433 }
5435 // [stack] ITER NEXT
5437 }
5439 // [stack] NEXT ITER
5441 }
5443 }
5449 "[Symbol.asyncIterator]() call is prohibited in self-hosted code "
5453 // [stack] OBJ
5455 // Convert iterable to iterator.
5457 // [stack] OBJ OBJ
5459 }
5461 // [stack] OBJ OBJ @@ASYNCITERATOR
5463 }
5465 // [stack] OBJ ASYNC_ITERFN
5467 }
5469 // [stack] OBJ ASYNC_ITERFN SYNC_ITERFN
5472 // [stack] OBJ SYNC_ITERFN ASYNC_ITERFN
5474 }
5475 }
5479 // [stack] OBJ SYNC_ITERFN? ASYNC_ITERFN NULL-OR-UNDEF
5481 }
5483 // [stack] OBJ SYNC_ITERFN? ASYNC_ITERFN
5485 }
5488 // [stack] OBJ SYNC_ITERFN?
5490 }
5494 // [stack] OBJ OBJ
5496 }
5498 // [stack] OBJ OBJ @@ITERATOR
5500 }
5502 // [stack] OBJ SYNC_ITERFN
5504 }
5506 // [stack] OBJ SYNC_ITERFN
5507 }
5510 // [stack] SYNC_ITERFN OBJ
5512 }
5514 // [stack] ITER
5516 }
5518 // [stack] ITER
5520 }
5523 // [stack] ITER ITER
5525 }
5527 // [stack] ITER SYNCNEXT
5529 }
5532 // [stack] ITER
5534 }
5537 // [stack] OBJ SYNC_ITERFN? ASYNC_ITERFN
5539 }
5543 // [stack] OBJ ASYNC_ITERFN SYNC_ITERFN
5545 }
5547 // [stack] OBJ ASYNC_ITERFN
5549 }
5550 }
5553 // [stack] ASYNC_ITERFN OBJ
5555 }
5557 // [stack] ITER
5559 }
5561 // [stack] ITER
5563 }
5566 // [stack] ITER
5568 }
5571 // [stack] ITER ITER
5573 }
5575 // [stack] ITER NEXT
5577 }
5579 // [stack] NEXT ITER
5581 }
5584 }
5587 // [stack] NEXT ITER ARR I
5589 // [stack] ARR FINAL_INDEX
5590 }
5595 // In the [stack] annotations, (spreadee) can be "ARR I" (when spreading
5596 // into an array or into call parameters, or "TUPLE" (when spreading into a
5597 // tuple)
5600 // [stack] NEXT ITER (spreadee)
5602 }
5604 {
5605 #ifdef DEBUG
5607 #endif
5609 // Spread operations can't contain |continue|, so don't bother setting loop
5610 // and enclosing "update" offsets, as we do with for-loops.
5613 // [stack] NEXT ITER (spreadee) NEXT ITER
5615 }
5617 // [stack] NEXT ITER (spreadee) RESULT
5619 }
5621 // [stack] NEXT ITER (spreadee) RESULT RESULT
5623 }
5625 // [stack] NEXT ITER (spreadee) RESULT DONE
5627 }
5629 // [stack] NEXT ITER (spreadee) RESULT
5631 }
5633 // Emit code to assign result.value to the iteration variable.
5635 // [stack] NEXT ITER (spreadee) VALUE
5637 }
5639 // [stack] NEXT ITER (spreadee)
5641 }
5644 // [stack] NEXT ITER (spreadee)
5646 }
5649 }
5651 // When we leave the loop body and jump to this point, the result value is
5652 // still on the stack. Account for that by updating the stack depth
5653 // manually.
5656 // No continues should occur in spreads.
5660 // [stack] ITER (spreadee) RESULT NEXT
5662 }
5664 // [stack] (spreadee) RESULT NEXT ITER
5666 }
5669 // [stack] (spreadee)
5670 }
5682 // If the for-in/of loop didn't have a variable declaration, per-loop
5683 // initialization is just assigning the iteration value to a target
5684 // expression.
5687 // [stack] ... ITERVAL
5688 }
5690 // Otherwise, per-loop initialization is (possibly) declaration
5691 // initialization. If the declaration is a lexical declaration, it must be
5692 // initialized. If the declaration is a variable declaration, an
5693 // assignment to that name (which does *not* necessarily assign to the
5694 // variable!) must be generated.
5699 }
5710 }
5711 }
5718 }
5720 // Per-iteration initialization in for-in/of loops computes the
5721 // iteration value *before* initializing. Thus the initializing
5722 // value may be buried under a bind-specific value on the stack.
5723 // Swap it to the top of the stack.
5727 }
5729 // In cases of emitting a frame slot or environment slot,
5730 // nothing needs be done.
5732 }
5735 }
5737 // The caller handles removing the iteration value from the stack.
5739 }
5749 }
5759 IteratorKind iterKind =
5767 // Certain builtins (e.g. Array.from) are implemented in self-hosting
5768 // as for-of loops.
5773 // [stack]
5775 }
5779 }
5782 }
5784 // [stack] ITERABLE
5786 }
5792 }
5795 // [stack] NEXT ITER VALUE
5797 }
5800 // [stack] NEXT ITER VALUE
5802 }
5805 // [stack] NEXT ITER UNDEF
5807 }
5809 // Perform the loop body.
5812 // [stack] NEXT ITER UNDEF
5814 }
5817 // [stack]
5819 }
5822 }
5831 // Annex B: Evaluate the var-initializer expression if present.
5832 // |for (var i = initializer in expr) { ... }|
5849 }
5855 }
5858 }
5861 }
5863 // Pop the initializer.
5866 }
5867 }
5868 }
5869 }
5872 // [stack]
5874 }
5876 // Evaluate the expression being iterated.
5881 }
5884 }
5886 // [stack] EXPR
5888 }
5897 // [stack] ITER ITERVAL
5899 }
5902 // [stack] ITER ITERVAL
5904 }
5907 // [stack] ITER ITERVAL
5909 }
5911 // Perform the loop body.
5914 // [stack] ITER ITERVAL
5916 }
5919 // [stack]
5921 }
5924 }
5926 /* C-style `for (init; cond; update) ...` loop. */
5939 // [stack]
5941 }
5943 // If the head of this for-loop declared any lexical variables, the parser
5944 // wrapped this ParseNodeKind::For node in a ParseNodeKind::LexicalScope
5945 // representing the implicit scope of those variables. By the time we get
5946 // here, we have already entered that scope. So far, so good.
5948 // Emit the `init` clause, whether it's an expression or a variable
5949 // declaration. (The loop variables were hoisted into an enclosing
5950 // scope, but we still need to emit code for the initializers.)
5955 // [stack]
5957 }
5961 }
5964 }
5966 // 'init' is an expression, not a declaration. emitTree left its
5967 // value on the stack.
5969 // [stack] VAL
5971 }
5973 // [stack]
5975 }
5976 }
5977 }
5980 // [stack]
5982 }
5987 }
5990 }
5992 // [stack] VAL
5994 }
5995 }
5999 // [stack]
6001 }
6004 // [stack]
6006 }
6011 // [stack]
6013 }
6015 // Check for update code to do before the condition (if any).
6019 }
6022 }
6024 // [stack] VAL
6026 }
6027 }
6030 // [stack]
6032 }
6035 }
6041 }
6045 }
6049 }
6053 }
6059 // [stack]
6066 // |wasEmittedByEnclosingScript| flag is set to true once the function has
6067 // been emitted. Function definitions that need hoisting to the top of the
6068 // function will be seen by emitFunction in two places.
6071 // [stack]
6073 }
6078 // [stack] FUN?
6079 }
6082 // [stack]
6084 }
6089 }
6091 /* We measured the max scope depth when we parsed the function. */
6094 }
6097 // [stack] FUN?
6099 }
6102 // [stack]
6104 }
6105 }
6107 // Track the last emitted top-level self-hosted function, so that intrinsics
6108 // can adjust attributes at parse time.
6109 //
6110 // NOTE: We also disallow lambda functions in the top-level body. This is done
6111 // to simplify handling of the self-hosted stencil. Within normal function
6112 // declarations there are no such restrictions.
6118 }
6119 }
6122 }
6130 }
6134 }
6138 }
6143 }
6146 }
6149 }
6153 }
6156 }
6167 }
6171 }
6174 }
6177 }
6181 }
6184 }
6188 }
6191 }
6196 // Any statement with the matching label may be the break target.
6199 };
6204 };
6206 }
6209 }
6214 // Find the loop statement enclosed by the matching label.
6220 }
6222 }
6225 }
6227 }
6235 }
6238 // [stack] THIS
6240 }
6243 // [stack] THIS
6245 }
6246 }
6249 }
6255 // [stack] THIS
6256 }
6262 // [stack] THIS
6263 }
6267 // [stack] UNDEF
6268 }
6276 // [stack] THIS
6277 }
6280 // [stack] THIS
6281 }
6288 }
6291 }
6294 }
6296 }
6302 // [stack] NEW.TARGET
6304 }
6306 }
6313 }
6319 // The parser is responsible for marking the "new.target" binding as being
6320 // implicitly used in super() calls.
6322 }
6327 }
6331 }
6333 /* Push a return value */
6337 }
6343 }
6344 }
6346 /* No explicit return value provided */
6349 }
6350 }
6352 // We know functionBodyEndPos is set because "return" is only
6353 // valid in a function, and so we've passed through
6354 // emitFunctionScript.
6357 }
6359 /*
6360 * The return value is currently on the stack. We would like to
6361 * generate JSOp::Return, but if we have work to do before returning,
6362 * we will instead generate JSOp::SetRval / JSOp::RetRval.
6363 *
6364 * We don't know whether we will need fixup code until after calling
6365 * prepareForNonLocalJumpToOutermost, so we start by generating
6366 * JSOp::SetRval, then mutate it to JSOp::Return in finishReturn if it
6367 * wasn't needed.
6368 */
6372 }
6376 }
6379 // The return value is currently in rval. Depending on the current function,
6380 // we may have to do additional work before returning:
6381 // - Derived class constructors must check if the return value is an object.
6382 // - Generators and async functions must do a final yield.
6383 // - Non-async generators must return the value as an iterator result:
6384 // { value: <rval>, done: true }
6385 // - Non-generator async functions must resolve the function's result promise
6386 // with the value.
6387 //
6388 // If we have not generated any code since the SetRval that stored the return
6389 // value, we can also optimize the bytecode by rewriting that SetRval as a
6390 // JSOp::Return. See |emitReturn| above.
6405 }
6407 }
6412 }
6414 }
6421 }
6423 // Nothing special needs to be done.
6425 }
6434 }
6439 }
6444 }
6447 // [stack] RVAL GENERATOR RESUMEKIND
6449 }
6451 // [stack] RVAL
6453 }
6455 // [stack]
6457 }
6460 }
6470 // [stack] ITEROBJ
6472 }
6473 }
6476 // [stack] ITEROBJ? VAL
6478 }
6481 // [stack] ITEROBJ? UNDEFINED
6483 }
6484 }
6489 // [stack] RESULT
6491 }
6492 }
6496 // [stack] ITEROBJ
6498 }
6499 }
6502 // [stack] # if needsIteratorResult
6503 // [stack] ITEROBJ .GENERATOR
6504 // [stack] # else
6505 // [stack] RESULT .GENERATOR
6507 }
6510 // [stack] YIELDRESULT GENERATOR RESUMEKIND
6512 }
6515 // [stack] YIELDRESULT
6517 }
6520 }
6528 }
6530 }
6534 // [stack] VALUE CANSKIP
6536 }
6539 // [stack] VALUE_OR_RESOLVED CANSKIP
6541 }
6545 // [stack] VALUE_OR_RESOLVED
6547 }
6551 // [stack] VALUE GENERATOR
6553 }
6555 // [stack] PROMISE
6557 }
6558 }
6561 // [stack] VALUE|PROMISE GENERATOR
6563 }
6565 // [stack] RESOLVED GENERATOR RESUMEKIND
6567 }
6569 // [stack] RESOLVED
6571 }
6575 }
6580 }
6582 // ES2019 draft rev 49b781ec80117b60f73327ef3054703a3111e40c
6583 // 14.4.14 Runtime Semantics: Evaluation
6584 // YieldExpression : yield* AssignmentExpression
6587 "yield* is prohibited in self-hosted code because it can run "
6593 // Step 1.
6599 // Steps 2-5.
6601 // [stack] ITERABLE
6603 }
6606 // [stack] NEXT ITER
6608 }
6611 // [stack] NEXT ITER
6613 }
6614 }
6616 // Step 6.
6617 // Start with NormalCompletion(undefined).
6619 // [stack] NEXT ITER RECEIVED
6621 }
6623 // [stack] NEXT ITER RECEIVED RESUMEKIND
6625 }
6630 // Step 7 is a loop.
6633 // [stack] NEXT ITER RECEIVED RESUMEKIND
6635 }
6637 // Step 7.a. Check for Normal completion.
6639 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND
6641 }
6643 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND NORMAL
6645 }
6647 // [stack] NEXT ITER RECEIVED RESUMEKIND IS_NORMAL
6649 }
6653 // [stack] NEXT ITER RECEIVED RESUMEKIND
6655 }
6656 {
6658 // [stack] NEXT ITER RECEIVED
6660 }
6662 // Step 7.a.i.
6663 // result = iter.next(received)
6665 // [stack] RECEIVED NEXT ITER
6667 }
6669 // [stack] RECEIVED NEXT ITER NEXT ITER
6671 }
6673 // [stack] NEXT ITER NEXT ITER RECEIVED
6675 }
6677 // [stack] NEXT ITER RESULT
6679 }
6681 // Step 7.a.ii.
6684 // [stack] NEXT ITER RESULT
6686 }
6687 }
6689 // Step 7.a.iii.
6691 // [stack] NEXT ITER RESULT
6693 }
6695 // Bytecode for steps 7.a.iv-vii is emitted after the ifKind if-else because
6696 // it's shared with other branches.
6697 }
6699 // Step 7.b. Check for Throw completion.
6701 // [stack] NEXT ITER RECEIVED RESUMEKIND
6703 }
6705 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND
6707 }
6709 // [stack] NEXT ITER RECEIVED RESUMEKIND RESUMEKIND THROW
6711 }
6713 // [stack] NEXT ITER RECEIVED RESUMEKIND IS_THROW
6715 }
6717 // [stack] NEXT ITER RECEIVED RESUMEKIND
6719 }
6720 {
6722 // [stack] NEXT ITER RECEIVED
6724 }
6725 // Step 7.b.i.
6727 // [stack] NEXT ITER RECEIVED ITER
6729 }
6731 // [stack] NEXT ITER RECEIVED ITER ITER
6733 }
6736 // [stack] NEXT ITER RECEIVED ITER THROW
6738 }
6740 // Step 7.b.ii.
6743 // [stack] NEXT ITER RECEIVED ITER THROW NULL-OR-UNDEF
6745 }
6749 // [stack] NEXT ITER RECEIVED ITER THROW
6751 }
6753 // Step 7.b.ii.1.
6754 // RESULT = ITER.throw(EXCEPTION)
6756 // [stack] NEXT ITER RECEIVED THROW ITER
6758 }
6760 // [stack] NEXT ITER THROW ITER RECEIVED
6762 }
6764 // [stack] NEXT ITER RESULT
6766 }
6768 // Step 7.b.ii.2.
6771 // [stack] NEXT ITER RESULT
6773 }
6774 }
6776 // Step 7.b.ii.4.
6778 // [stack] NEXT ITER RESULT
6780 }
6782 // Bytecode for steps 7.b.ii.5-8 is emitted after the ifKind if-else because
6783 // it's shared with other branches.
6785 // Step 7.b.iii.
6787 // [stack] NEXT ITER RECEIVED ITER THROW
6789 }
6791 // [stack] NEXT ITER RECEIVED ITER
6793 }
6795 // Steps 7.b.iii.1-4.
6796 //
6797 // If the iterator does not have a "throw" method, it calls IteratorClose
6798 // and then throws a TypeError.
6800 // [stack] NEXT ITER RECEIVED ITER
6802 }
6803 // Steps 7.b.iii.5-6.
6805 // [stack] NEXT ITER RECEIVED ITER
6806 // [stack] # throw
6808 }
6812 }
6813 }
6815 // Step 7.c. It must be a Return completion.
6817 // [stack] NEXT ITER RECEIVED RESUMEKIND
6819 }
6820 {
6822 // [stack] NEXT ITER RECEIVED
6824 }
6826 // Step 7.c.i.
6827 //
6828 // Call iterator.return() for receiving a "forced return" completion from
6829 // the generator.
6831 // Step 7.c.ii.
6832 //
6833 // Get the "return" method.
6835 // [stack] NEXT ITER RECEIVED ITER
6837 }
6839 // [stack] NEXT ITER RECEIVED ITER ITER
6841 }
6844 // [stack] NEXT ITER RECEIVED ITER RET
6846 }
6848 // Step 7.c.iii.
6849 //
6850 // Do nothing if "return" is undefined or null.
6853 // [stack] NEXT ITER RECEIVED ITER RET NULL-OR-UNDEF
6855 }
6857 // Step 7.c.iv.
6858 //
6859 // Call "return" with the argument passed to Generator.prototype.return.
6862 // [stack] NEXT ITER RECEIVED ITER RET
6864 }
6866 // [stack] NEXT ITER RECEIVED RET ITER
6868 }
6870 // [stack] NEXT ITER RET ITER RECEIVED
6872 }
6876 // [stack] NEXT ITER RET ITER VAL
6878 }
6879 }
6881 // [stack] NEXT ITER RESULT
6883 }
6885 // Step 7.c.v.
6888 // [stack] NEXT ITER RESULT
6890 }
6891 }
6893 // Step 7.c.vi.
6895 // [stack] NEXT ITER RESULT
6897 }
6899 // Check if the returned object from iterator.return() is done. If not,
6900 // continue yielding.
6902 // Steps 7.c.vii-viii.
6905 // [stack] NEXT ITER RESULT RESULT
6907 }
6909 // [stack] NEXT ITER RESULT DONE
6911 }
6913 // [stack] NEXT ITER RESULT
6915 }
6917 // Step 7.c.viii.1.
6919 // [stack] NEXT ITER VALUE
6921 }
6924 // [stack] NEXT ITER VALUE RESULT
6926 }
6928 // [stack] NEXT ITER RESULT VALUE
6930 }
6932 // [stack] NEXT ITER RESULT
6934 }
6935 }
6938 // [stack] NEXT ITER RESULT
6940 }
6942 // Jump to continue label for steps 7.c.ix-x.
6944 // [stack] NEXT ITER RESULT
6946 }
6949 // [stack] NEXT ITER RESULT
6951 }
6953 // Step 7.c.iii.
6955 // [stack] NEXT ITER RECEIVED ITER RET
6957 }
6959 // [stack] NEXT ITER RECEIVED
6961 }
6963 // Step 7.c.iii.1.
6965 // [stack] NEXT ITER RECEIVED
6967 }
6968 }
6970 // [stack] NEXT ITER RECEIVED
6972 }
6974 // Perform a "forced generator return".
6975 //
6976 // Step 7.c.iii.2.
6977 // Step 7.c.viii.2.
6979 // [stack] NEXT ITER RESULT GENOBJ
6981 }
6983 // [stack] NEXT ITER RESULT GENOBJ RESUMEKIND
6985 }
6987 // [stack] NEXT ITER RESULT GENOBJ RESUMEKIND
6989 }
6990 }
6993 // [stack] NEXT ITER RESULT
6995 }
6997 // Shared tail for Normal/Throw completions.
6998 //
6999 // Steps 7.a.iv-v.
7000 // Steps 7.b.ii.5-6.
7001 //
7002 // [stack] NEXT ITER RESULT
7004 // if (result.done) break;
7006 // [stack] NEXT ITER RESULT RESULT
7008 }
7010 // [stack] NEXT ITER RESULT DONE
7012 }
7014 // [stack] NEXT ITER RESULT
7016 }
7018 // Steps 7.a.vi-vii.
7019 // Steps 7.b.ii.7-8.
7020 // Steps 7.c.ix-x.
7022 // [stack] NEXT ITER RESULT
7024 }
7027 // [stack] NEXT ITER RESULT
7029 }
7030 }
7032 // [stack] NEXT ITER RESULT GENOBJ
7034 }
7036 // [stack] NEXT ITER RVAL GENOBJ RESUMEKIND
7038 }
7040 // [stack] NEXT ITER RVAL RESUMEKIND GENOBJ
7042 }
7044 // [stack] NEXT ITER RVAL RESUMEKIND
7046 }
7048 // [stack] NEXT ITER RVAL RESUMEKIND
7050 }
7052 // Jumps to this point have 3 (instead of 4) values on the stack.
7056 // [stack] NEXT ITER RESULT
7058 // Step 7.a.v.1.
7059 // Step 7.b.ii.6.a.
7060 //
7061 // result.value
7063 // [stack] RESULT NEXT ITER
7065 }
7067 // [stack] RESULT
7069 }
7071 // [stack] VALUE
7073 }
7078 }
7084 }
7085 }
7087 }
7092 /*
7093 * Top-level or called-from-a-native JS_Execute/EvaluateScript,
7094 * debugger, and eval frames may need the value of the ultimate
7095 * expression statement as the script's result, despite the fact
7096 * that it appears useless to the compiler.
7097 *
7098 * API users may also set the ReadOnlyCompileOptions::noScriptRval option when
7099 * calling JS_Compile* to suppress JSOp::SetRval.
7100 */
7105 }
7107 /* Don't eliminate expressions with side effects. */
7112 }
7114 /*
7115 * Don't eliminate apparently useless expressions if they are labeled
7116 * expression statements. The startOffset() test catches the case
7117 * where we are nesting in emitTree for a labeled compound statement.
7118 */
7124 }
7125 }
7128 ValueUsage valueUsage =
7133 }
7136 }
7139 }
7142 }
7143 }
7146 }
7155 }
7166 // The expression |delete super.foo;| has to evaluate |super.foo|,
7167 // which could throw if |this| hasn't yet been set by a |super(...)|
7168 // call or the super-base is not an object, before throwing a
7169 // ReferenceError for attempting to delete a super-reference.
7172 // [stack] THIS
7174 }
7178 }
7180 // [stack] OBJ
7182 }
7183 }
7186 // [stack] # if Super
7187 // [stack] THIS
7188 // [stack] # otherwise
7189 // [stack] SUCCEEDED
7191 }
7194 }
7208 // The expression |delete super[foo];| has to evaluate |super[foo]|,
7209 // which could throw if |this| hasn't yet been set by a |super(...)|
7210 // call, or trigger side-effects when evaluating ToPropertyKey(foo),
7211 // or also throw when the super-base is not an object, before throwing
7212 // a ReferenceError for attempting to delete a super-reference.
7214 // [stack]
7216 }
7220 // [stack] THIS
7222 }
7224 // [stack] THIS
7226 }
7228 // [stack] THIS KEY
7230 }
7233 // [stack] OBJ KEY
7235 }
7236 }
7238 // [stack] # if Super
7239 // [stack] THIS
7240 // [stack] # otherwise
7241 // [stack] SUCCEEDED
7243 }
7246 }
7253 // If useless, just emit JSOp::True; otherwise convert |delete <expr>| to
7254 // effectively |<expr>, true|.
7258 }
7263 }
7266 }
7267 }
7270 }
7283 // [stack] # If shortcircuit
7284 // [stack] UNDEFINED-OR-NULL
7285 // [stack] # otherwise
7286 // [stack] SUCCEEDED
7288 }
7291 }
7296 // [stack] # If shortcircuit
7297 // [stack] UNDEFINED-OR-NULL
7298 // [stack] # otherwise
7299 // [stack] SUCCEEDED
7301 }
7303 }
7306 }
7309 // [stack] # If shortcircuit
7310 // [stack] TRUE
7311 // [stack] # otherwise
7312 // [stack] SUCCEEDED
7314 }
7317 }
7327 // [stack]
7329 }
7331 // [stack] OBJ
7333 }
7336 // [stack] # if Jump
7337 // [stack] UNDEFINED-OR-NULL
7338 // [stack] # otherwise
7339 // [stack] OBJ
7341 }
7342 }
7345 // [stack] SUCCEEDED
7347 }
7350 }
7360 // [stack]
7362 }
7365 // [stack] OBJ
7367 }
7371 // [stack] # if Jump
7372 // [stack] UNDEFINED-OR-NULL
7373 // [stack] # otherwise
7374 // [stack] OBJ
7376 }
7377 }
7380 // [stack] OBJ
7382 }
7385 // [stack] OBJ KEY
7387 }
7390 // [stack] SUCCEEDED
7392 }
7395 }
7398 // [stack] CALLEE
7400 #ifdef DEBUG
7402 // [stack] CALLEE
7404 }
7405 #endif
7408 }
7411 // Special-casing of callFunction to emit bytecode that directly
7412 // invokes the callee with the correct |this| object and arguments.
7413 // callFunction(fun, thisArg, arg0, arg1) thus becomes:
7414 // - emit lookup for fun
7415 // - emit lookup for thisArg
7416 // - emit lookups for arg0, arg1
7417 //
7418 // argc is set to the amount of actually emitted args and the
7419 // emitting of args below is disabled by setting emitArgs to false.
7433 // [stack] CALLEE
7435 }
7437 #ifdef DEBUG
7442 // [stack] CALLEE
7444 }
7445 }
7446 #endif
7450 // Save off the new.target value, but here emit a proper |this| for a
7451 // constructing call.
7453 // [stack] CALLEE IS_CONSTRUCTING
7455 }
7457 // It's |this|, emit it.
7459 // [stack] CALLEE THIS
7461 }
7462 }
7466 // [stack] CALLEE ... ARGS...
7468 }
7469 }
7473 // [stack] CALLEE IS_CONSTRUCTING ARGS... NEW.TARGET
7475 }
7476 }
7480 // [stack] RVAL
7482 }
7485 }
7490 // Syntax: resumeGenerator(gen, value, 'next'|'throw'|'return')
7495 // [stack] GENERATOR
7497 }
7501 // [stack] GENERATOR VALUE
7503 }
7507 GeneratorResumeKind kind =
7512 // [stack] GENERATOR VALUE RESUMEKIND
7514 }
7517 // [stack] RVAL
7519 }
7522 }
7525 // JSScript::hasForceInterpreterOp() relies on JSOp::ForceInterpreter being
7526 // the first bytecode op in the script.
7531 }
7534 }
7537 }
7544 // We're just here as a sentinel. Pass the value through directly.
7546 }
7553 // We're just here as a sentinel. Pass the value through directly.
7555 }
7563 // We're just here as a sentinel. Pass the value through directly.
7565 }
7570 // Only optimize when 3 arguments are passed.
7576 }
7581 }
7586 }
7588 // This will leave the object on the stack instead of pushing |undefined|,
7589 // but that's fine because the self-hosted code doesn't use the return
7590 // value.
7592 }
7602 }
7607 }
7610 }
7623 }
7627 }
7631 }
7634 }
7645 }
7648 }
7659 }
7662 }
7672 // [stack] ARG
7674 }
7676 // [stack] ARG IS_NULL_OR_UNDEF
7678 }
7680 // [stack] IS_NULL_OR_UNDEF ARG
7682 }
7684 // [stack] IS_NULL_OR_UNDEF
7686 }
7688 }
7696 // [stack] ARG
7698 }
7701 // [stack]
7703 }
7705 // This is still a call node, so we must generate a stack value.
7707 // [stack] RVAL
7709 }
7712 }
7726 }
7730 BuiltinObjectKind kind;
7735 }
7741 }
7744 }
7749 }
7754 }
7757 // NOTE: This is a linear search, but the set of entries is quite small and
7758 // this is only used for initial self-hosted parse.
7759 #define MATCH_WELL_KNOWN_SYMBOL(NAME) \
7760 if (atom == TaggedParserAtomIndex::WellKnown::NAME()) { \
7761 return JS::SymbolCode::NAME; \
7762 }
7764 #undef MATCH_WELL_KNOWN_SYMBOL
7767 }
7780 }
7789 }
7792 }
7801 }
7813 }
7816 }
7818 #ifdef DEBUG
7820 // The function argument is expected to be a simple binding/function name.
7821 // Eg. `function foo() { }; SpecialIntrinsic(foo)`
7826 // The special intrinsics must follow the target functions definition. A
7827 // simple assert is fine here since any hoisted function will cause a non-null
7828 // value to be set here.
7831 // The target function must match the most recently defined top-level
7832 // self-hosted function.
7835 }
7836 #endif
7840 #ifdef DEBUG
7846 #endif
7851 // This is still a call node, so we must generate a stack value.
7853 }
7860 #ifdef DEBUG
7862 #endif
7867 // Canonical name must be atomized.
7871 // Store the canonical name for instantiation.
7873 specName);
7876 }
7878 #ifdef DEBUG
7886 // Ensure that the slot argument is fixed, this is required by the JITs.
7889 }
7898 // Ensure that the slot argument is fixed, this is required by the JITs.
7901 }
7902 #endif
7904 /* A version of emitCalleeAndThis for the optional cases:
7905 * * a?.()
7906 * * a?.b()
7907 * * a?.["b"]()
7908 * * (a?.b)()
7909 * * a?.#b()
7910 *
7911 * See emitCallOrNew and emitOptionalCall for more context.
7912 */
7920 }
7926 // [stack] CALLEE THIS
7928 }
7930 }
7939 // [stack] CALLEE THIS
7941 }
7943 }
7951 // [stack] CALLEE THIS
7953 }
7955 }
7963 // [stack] CALLEE THIS
7965 }
7967 }
7974 // [stack] CALLEE THIS
7976 }
7978 }
7987 // [stack] CALLEE THIS
7989 }
7991 }
7996 }
7998 // [stack] CALLEE
8000 }
8005 cone);
8006 }
8013 }
8015 // [stack] CALLEE
8017 }
8019 }
8022 // [stack] CALLEE THIS
8024 }
8027 }
8037 // [stack] CALLEE THIS?
8039 }
8041 }
8050 }
8054 // [stack] THIS
8056 }
8059 // [stack] OBJ
8061 }
8062 }
8064 // [stack] CALLEE THIS?
8066 }
8069 }
8077 // [stack] # if Super
8078 // [stack] THIS? THIS KEY
8079 // [stack] # otherwise
8080 // [stack] OBJ? OBJ KEY
8082 }
8084 // [stack] CALLEE THIS?
8086 }
8089 }
8097 // [stack] OBJ
8099 }
8101 // [stack] OBJ NAME
8103 }
8105 // [stack] CALLEE THIS
8107 }
8110 }
8114 }
8116 // [stack] CALLEE
8118 }
8125 // [stack] CALLEE IsConstructing
8127 }
8133 }
8137 }
8140 }
8142 }
8145 // [stack] CALLEE THIS
8147 }
8150 }
8157 // Default to using the location of the `(` itself.
8158 // obj[expr]() // expression
8159 // ^ // column coord
8164 // Use the position of a property access identifier.
8165 //
8166 // obj().aprop() // expression
8167 // ^ // column coord
8168 //
8169 // Note: Because of the constant folding logic in FoldElement,
8170 // this case also applies for constant string properties.
8171 //
8172 // obj()['aprop']() // expression
8173 // ^ // column coord
8177 // Use the start of callee name unless it is at a separator
8178 // or has no args.
8179 //
8180 // 2 + obj() // expression
8181 // ^ // column coord
8182 //
8185 // Use the start of callee names.
8187 }
8189 }
8193 }
8194 }
8196 }
8205 }
8208 // [stack] CALLEE THIS
8210 }
8214 }
8216 // [stack] CALLEE THIS ARG*
8218 }
8219 }
8224 }
8226 // [stack] CALLEE THIS ARG0
8228 }
8231 // [stack] CALLEE THIS ARG0
8233 }
8237 // [stack] CALLEE THIS ARR
8239 }
8240 }
8243 // [stack] CALLEE THIS ARR
8245 }
8248 // [stack] CALLEE THIS
8250 }
8252 // [stack] CALLEE THIS ARR
8254 }
8255 }
8258 }
8261 ValueUsage valueUsage) {
8262 /*
8263 * A modified version of emitCallOrNew that handles optional calls.
8264 *
8265 * These include the following:
8266 * a?.()
8267 * a.b?.()
8268 * a.["b"]?.()
8269 * (a?.b)?.()
8270 *
8271 * See CallOrNewEmitter for more context.
8272 */
8281 isOptimizableSpread
8284 valueUsage);
8289 // [stack] CALLEE THIS
8291 }
8295 // [stack] CALLEE THIS
8297 }
8298 }
8301 // [stack] CALLEE THIS ARGS...
8303 }
8306 // [stack] RVAL
8308 }
8311 }
8314 /*
8315 * Emit callable invocation or operator new (constructor call) code.
8316 * First, emit code for the left operand to evaluate the callable or
8317 * constructable object expression.
8318 *
8319 * Then (or in a call case that has no explicit reference-base
8320 * object) we emit JSOp::Undefined to produce the undefined |this|
8321 * value required for calls (which non-strict mode functions
8322 * will box into the global object).
8323 */
8332 // Calls to "forceInterpreter", "callFunction",
8333 // "callContentFunction", or "resumeGenerator" in self-hosted
8334 // code generate inline bytecode.
8335 //
8336 // NOTE: The list of special instruction names has to be kept in sync with
8337 // "js/src/builtin/.eslintrc.js".
8341 }
8344 }
8348 }
8351 }
8354 }
8357 }
8361 }
8365 }
8369 }
8372 }
8375 }
8378 }
8381 }
8385 }
8388 }
8391 }
8394 }
8397 }
8401 }
8404 }
8407 }
8410 }
8411 #ifdef DEBUG
8420 // Make sure that this call is correct, but don't emit any special code.
8422 }
8425 // Make sure that this call is correct, but don't emit any special code.
8427 }
8428 #endif
8429 // Fall through
8430 }
8441 isOptimizableSpread
8442 ? isDefaultDerivedClassConstructor
8446 valueUsage);
8449 // [stack] CALLEE THIS
8451 }
8453 // [stack] CALLEE THIS ARGS...
8455 }
8457 // Push new.target for construct calls.
8461 // [stack] CALLEE THIS ARGS.. NEW.TARGET
8463 }
8465 // Repush the callee as new.target
8468 // [stack] CALLEE THIS ARGS.. CALLEE
8470 }
8471 }
8472 }
8477 // [stack] RVAL
8479 }
8482 }
8484 // This list must be kept in the same order in several places:
8485 // - The binary operators in ParseNode.h ,
8486 // - the binary operators in TokenKind.h
8487 // - the precedence list in Parser.cpp
8489 // Some binary ops require special code generation (PrivateIn);
8490 // these should not use BinaryOpParseNodeKindToJSOp. This table fills those
8491 // slots with Nops to make the rest of the table lookup work.
8503 #ifdef DEBUG
8508 // Ensure we don't use this to find an op for a parse node
8509 // requiring special emission rules.
8511 #endif
8513 }
8516 // ** is the only right-associative operator.
8519 // Right-associative operator chain.
8523 }
8526 }
8527 }
8531 }
8532 }
8534 }
8537 // Left-associative operator chain.
8540 }
8546 }
8549 }
8552 }
8555 }
8564 privateName);
8570 // [stack] OBJ
8572 }
8575 // [stack] OBJ BRAND if private method
8576 // [stack] OBJ NAME if private field or accessor.
8578 }
8581 // [stack] OBJ BRAND BOOL if private method
8582 // [stack] OBJ NAME BOOL if private field or accessor.
8584 }
8587 // [stack] BOOL OBJ BRAND if private method
8588 // [stack] BOOL OBJ NAME if private field or accessor.
8590 }
8593 // [stack] BOOL
8595 }
8598 }
8600 /*
8601 * Special `emitTree` for Optional Chaining case.
8602 * Examples of this are `emitOptionalChain`, `emitDeleteOptionalChain` and
8603 * `emitCalleeAndThisForOptionalChain`.
8604 */
8611 }
8621 }
8623 }
8632 }
8634 }
8645 }
8647 }
8658 }
8660 }
8668 }
8670 }
8675 }
8677 // List of accepted ParseNodeKinds that might appear only at the beginning
8678 // of an Optional Chain.
8679 // For example, a taggedTemplateExpr node might occur if we have
8680 // `test`?.b, with `test` as the taggedTemplateExpr ParseNode.
8682 #ifdef DEBUG
8683 // https://tc39.es/ecma262/#sec-primary-expression
8700 // https://tc39.es/ecma262/#sec-left-hand-side-expressions
8712 #endif
8714 }
8716 }
8718 // Handle the case of a call made on a OptionalChainParseNode.
8719 // For example `(a?.b)()` and `(a?.b)?.()`.
8724 // Create a new OptionalEmitter, in order to emit the right bytecode
8725 // in isolation.
8729 // [stack] CALLEE THIS
8731 }
8733 // complete the jump if necessary. This will set both the "this" value
8734 // and the "callee" value to undefined, if the callee is undefined. It
8735 // does not matter much what the this value is, the function call will
8736 // fail if it is not optional, and be set to undefined otherwise.
8739 // [stack] # If shortcircuit
8740 // [stack] UNDEFINED UNDEFINED
8741 // [stack] # otherwise
8742 // [stack] CALLEE THIS
8744 }
8746 }
8749 ValueUsage valueUsage) {
8755 // [stack] VAL
8757 }
8760 // [stack] # If shortcircuit
8761 // [stack] UNDEFINED
8762 // [stack] # otherwise
8763 // [stack] VAL
8765 }
8768 }
8775 // [stack]
8777 }
8782 // [stack] OBJ
8784 }
8787 // [stack] OBJ
8789 }
8790 }
8795 // [stack] # if Jump
8796 // [stack] UNDEFINED-OR-NULL
8797 // [stack] # otherwise
8798 // [stack] OBJ
8800 }
8801 }
8804 // [stack] PROP
8806 }
8809 }
8816 // [stack]
8818 }
8823 // [stack] OBJ
8825 }
8828 // [stack] OBJ
8830 }
8831 }
8836 // [stack] # if Jump
8837 // [stack] UNDEFINED-OR-NULL
8838 // [stack] # otherwise
8839 // [stack] OBJ
8841 }
8842 }
8845 // [stack] OBJ? OBJ
8847 }
8850 // [stack] OBJ? OBJ KEY
8852 }
8855 // [stack] ELEM
8857 }
8860 }
8866 // [stack] OBJ
8868 }
8872 // [stack] # if Jump
8873 // [stack] UNDEFINED-OR-NULL
8874 // [stack] # otherwise
8875 // [stack] OBJ
8877 }
8878 }
8881 // [stack] OBJ NAME
8883 }
8885 // [stack] CALLEE THIS # if call
8886 // [stack] VALUE # otherwise
8888 }
8891 }
8898 /*
8899 * JSOp::Or converts the operand on the stack to boolean, leaves the original
8900 * value on the stack and jumps if true; otherwise it falls into the next
8901 * bytecode, which pops the left operand and then evaluates the right operand.
8902 * The jump goes around the right operand evaluation.
8903 *
8904 * JSOp::And converts the operand on the stack to boolean and jumps if false;
8905 * otherwise it falls into the right operand's bytecode.
8906 */
8910 JSOp op;
8923 }
8925 JumpList jump;
8927 // Left-associative operator chain: avoid too much recursion.
8928 //
8929 // Emit all nodes but the last.
8933 }
8936 }
8939 }
8940 }
8942 // Emit the last node
8945 }
8949 }
8951 }
8957 }
8960 }
8963 }
8964 }
8969 }
8972 }
8974 }
8976 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
8977 // the comment on emitSwitch.
8979 ValueUsage valueUsage) {
8991 }
8992 }
8994 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
8995 // the comment on emitSwitch.
9005 }
9008 }
9011 }
9018 }
9025 }
9027 // NOTE: NotExpr of conditionNode may be unwrapped, and in that case the
9028 // negation is handled by conditionKind.
9031 }
9035 }
9039 }
9043 }
9047 }
9051 }
9055 }
9057 // Check for an object-literal property list that can be handled by the
9058 // ObjLiteral writer. We ensure that for each `prop: value` pair, the key is a
9059 // constant name or numeric index, there is no accessor specified, and the value
9060 // can be encoded by an ObjLiteral instruction (constant number, string,
9061 // boolean, null/undefined).
9073 }
9074 propCount++;
9080 // Computed keys not OK (ObjLiteral data stores constant keys).
9084 }
9086 // BigIntExprs should have been lowered to computed names at parse
9087 // time, and so should be excluded above.
9090 // Numeric keys OK as long as they are integers and in range.
9097 }
9101 }
9102 }
9108 AccessorType accessorType =
9115 }
9119 }
9120 }
9123 // JSOp::NewObject cannot accept dictionary-mode objects.
9125 }
9129 }
9135 }
9138 }
9139 }
9141 }
9144 PropListType type) {
9145 // [stack] CTOR? OBJ
9152 // Only handle computing field keys here: the .initializers lambda array
9153 // is created elsewhere.
9161 // [stack] CTOR OBJ ARRAY
9163 }
9168 // [stack] CTOR OBJ ARRAY KEY
9170 }
9173 // [stack] CTOR OBJ ARRAY KEY
9175 }
9182 }
9185 // [stack] CTOR OBJ ARRAY
9187 }
9190 // [stack] CTOR OBJ
9192 }
9193 }
9195 }
9198 // Static class blocks are emitted as part of
9199 // emitCreateMemberInitializers.
9201 }
9204 // Constructors are sometimes wrapped in LexicalScopeNodes. As we
9205 // already handled emitting the constructor, skip it.
9209 }
9211 // Handle __proto__: v specially because *only* this form, and no other
9212 // involving "__proto__", performs [[Prototype]] mutation.
9214 // [stack] OBJ
9217 // [stack] OBJ
9219 }
9221 // [stack] OBJ PROTO
9223 }
9225 // [stack] OBJ
9227 }
9229 }
9233 // [stack] OBJ
9235 // [stack] OBJ OBJ
9237 }
9239 // [stack] OBJ OBJ VAL
9241 }
9243 // [stack] OBJ
9245 }
9247 }
9252 AccessorType accessorType;
9259 // Private non-static accessors are stamped onto instances from
9260 // initializers; see emitCreateMemberInitializers.
9262 }
9267 }
9270 // [stack] CTOR? OBJ CTOR? KEY?
9274 // The following branches except for the last `else` clause emit the
9275 // cases handled in NameResolver::resolveFun (see NameFunctions.cpp)
9281 // [stack] CTOR? OBJ CTOR? VAL
9283 }
9290 }
9292 // [stack] CTOR? OBJ CTOR? KEY VAL
9294 }
9307 }
9309 // [stack] CTOR? OBJ CTOR? KEY VAL
9311 }
9316 // [stack] CTOR? OBJ CTOR? KEY VAL
9318 }
9319 }
9321 // Either a proper computed property name or a synthetic computed
9322 // property name for BigInt keys.
9325 FunctionPrefixKind prefix =
9331 // [stack] CTOR? OBJ CTOR? KEY VAL
9333 }
9334 }
9337 // [stack] CTOR? OBJ CTOR? KEY? VAL
9339 }
9340 }
9345 // [stack] CTOR? OBJ CTOR? KEY? FUN
9347 }
9348 }
9350 #ifdef ENABLE_DECORATORS
9365 }
9367 // The decorators are applied to the current value on the stack,
9368 // possibly replacing it.
9372 // [stack] CTOR? OBJ CTOR? KEY? VAL
9374 }
9375 }
9376 }
9377 #endif
9380 };
9388 // [stack] CTOR? OBJ
9392 // emitClass took care of constructor already.
9397 }
9400 // [stack] CTOR? OBJ CTOR?
9402 }
9405 // [stack] CTOR? OBJ CTOR? VAL
9407 }
9410 // [stack] CTOR? OBJ
9412 }
9415 }
9418 // [stack] CTOR? OBJ
9420 // [stack] CTOR? OBJ CTOR?
9422 }
9424 // [stack] CTOR? OBJ CTOR? KEY
9426 }
9428 // [stack] CTOR? OBJ CTOR? KEY
9430 }
9432 // [stack] CTOR? OBJ CTOR? KEY VAL
9434 }
9437 // [stack] CTOR? OBJ
9439 }
9442 }
9445 // Either a proper computed property name or a synthetic computed property
9446 // name for BigInt keys.
9448 // [stack] CTOR? OBJ
9451 // [stack] CTOR? OBJ CTOR?
9453 }
9455 // [stack] CTOR? OBJ CTOR? KEY
9457 }
9459 // [stack] CTOR? OBJ CTOR? KEY
9461 }
9463 // [stack] CTOR? OBJ CTOR? KEY VAL
9465 }
9468 // [stack] CTOR? OBJ
9470 }
9473 }
9483 // [stack] CTOR OBJ
9485 }
9489 // Ensure the NameOp emitter doesn't push an environment onto the stack,
9490 // because that would change the stack location of the home object.
9495 // [stack] CTOR OBJ
9497 }
9499 // [stack] CTOR OBJ METHOD
9501 }
9503 // [stack] CTOR OBJ METHOD
9505 }
9507 // [stack] CTOR OBJ
9509 }
9511 // [stack] CTOR OBJ
9513 }
9515 }
9519 // [stack] CTOR OBJ
9522 // [stack] CTOR OBJ CTOR
9524 }
9526 // [stack] CTOR OBJ CTOR KEY
9528 }
9530 // [stack] CTOR OBJ CTOR KEY VAL
9532 }
9535 // [stack] CTOR OBJ
9537 }
9541 // [stack] CTOR OBJ CTOR
9543 }
9545 // [stack] CTOR OBJ CTOR NAME
9547 }
9550 // [stack] CTOR OBJ CTOR NAME FUN
9552 }
9554 // [stack] CTOR OBJ CTOR
9556 }
9558 // [stack] CTOR OBJ
9560 }
9561 }
9562 }
9565 }
9569 ObjLiteralWriter writer;
9571 #ifdef DEBUG
9572 // In self-hosted JS, we check duplication only on debug build.
9575 selfHostedPropNames;
9578 }
9579 #endif
9586 }
9595 #ifdef DEBUG
9596 // Self-hosted JS shouldn't contain duplicate properties.
9602 }
9603 #endif
9608 }
9609 }
9619 // Ignore indexed properties if we're not storing property values, and
9620 // rely on InitElem ops to define those. These properties will be either
9621 // dense elements (not possible to represent in the literal's shape) or
9622 // sparse elements (enumerated separately, so this doesn't affect property
9623 // iteration order).
9626 }
9629 }
9636 }
9640 }
9641 }
9642 }
9644 GCThingIndex index;
9647 }
9649 // JSOp::Object may only be used by (top-level) run-once scripts.
9654 // [stack] OBJ
9656 }
9659 }
9663 // Note: if we want to squeeze out a little more performance, we could switch
9664 // to the `JSOp::Object` opcode, because the exclusion set object is never
9665 // exposed to the user, so it's safe to bake the object into the bytecode.
9668 ObjLiteralWriter writer;
9675 }
9677 TaggedParserAtomIndex atom;
9683 }
9687 }
9691 }
9692 }
9694 GCThingIndex index;
9697 }
9700 // [stack] OBJ
9702 }
9705 }
9712 ObjLiteralWriter writer;
9719 }
9720 }
9722 GCThingIndex index;
9725 }
9728 // [stack] OBJ
9730 }
9733 }
9743 }
9756 }
9759 }
9763 }
9767 }
9771 }
9775 }
9781 }
9784 }
9786 }
9792 }
9803 numFields++;
9805 numPrivateInitializers++;
9809 }
9810 }
9812 // If there are more initializers than can be represented, return invalid.
9816 }
9819 }
9821 // Purpose of .fieldKeys:
9822 // Computed field names (`["x"] = 2;`) must be ran at class-evaluation time,
9823 // not object construction time. The transformation to do so is roughly as
9824 // follows:
9825 //
9826 // class C {
9827 // [keyExpr] = valueExpr;
9828 // }
9829 // -->
9830 // let .fieldKeys = [keyExpr];
9831 // let .initializers = [
9832 // () => {
9833 // this[.fieldKeys[0]] = valueExpr;
9834 // }
9835 // ];
9836 // class C {
9837 // constructor() {
9838 // .initializers[0]();
9839 // }
9840 // }
9841 //
9842 // BytecodeEmitter::emitCreateFieldKeys does `let .fieldKeys = [...];`
9843 // BytecodeEmitter::emitPropertyList fills in the elements of the array.
9844 // See GeneralParser::fieldInitializer for the `this[.fieldKeys[0]]` part.
9846 FieldPlacement placement) {
9853 };
9859 }
9867 }
9870 // [stack] ARRAY
9872 }
9875 // [stack] ARRAY
9877 }
9880 // [stack]
9882 }
9885 }
9891 }
9898 }
9904 }
9908 FieldPlacement placement
9909 #ifdef ENABLE_DECORATORS
9910 ,
9911 bool hasHeritage
9912 #endif
9913 ) {
9914 // FieldPlacement::Instance, hasHeritage == false
9915 // [stack] HOMEOBJ
9916 //
9917 // FieldPlacement::Instance, hasHeritage == true
9918 // [stack] HOMEOBJ HERITAGE
9919 //
9920 // FieldPlacement::Static
9921 // [stack] CTOR HOMEOBJ
9922 #ifdef ENABLE_DECORATORS
9924 #endif
9930 }
9935 }
9939 // [stack] HOMEOBJ HERITAGE? ARRAY
9940 // or:
9941 // [stack] CTOR HOMEOBJ ARRAY
9943 }
9945 // Private accessors could be used in the field initializers, so make sure
9946 // accessor initializers appear earlier in the .initializers array so they
9947 // run first. Static private methods are not initialized using initializers
9948 // (emitPropertyList emits bytecode to stamp them onto the constructor), so
9949 // skip this step if isStatic.
9953 }
9954 }
9959 }
9965 }
9967 // [stack] HOMEOBJ HERITAGE? ARRAY LAMBDA
9968 // or:
9969 // [stack] CTOR HOMEOBJ ARRAY LAMBDA
9971 }
9975 // [stack] HOMEOBJ HERITAGE? ARRAY LAMBDA
9976 // or:
9977 // [stack] CTOR HOMEOBJ ARRAY LAMBDA
9979 }
9980 }
9982 // [stack] HOMEOBJ HERITAGE? ARRAY
9983 // or:
9984 // [stack] CTOR HOMEOBJ ARRAY
9986 }
9987 }
9989 #ifdef ENABLE_DECORATORS
9990 // Index to use to append new initializers returned by decorators to the array
9992 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX
9993 // or:
9994 // [stack] CTOR HOMEOBJ ARRAY INDEX
9996 }
10001 }
10005 }
10011 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS
10012 // or:
10013 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS
10015 }
10025 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER
10026 // or:
10027 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER
10029 }
10031 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER SETTER
10032 // or:
10033 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER SETTER
10035 }
10041 // [stack]
10043 // Synthesize a name for the lexical variable that will store the
10044 // private method body.
10045 TaggedParserAtomIndex name =
10051 }
10056 }
10060 }
10063 // [stack] ACCESSOR
10064 };
10067 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER
10068 // or:
10069 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER
10071 };
10074 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER SETTER
10075 // or:
10076 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER SETTER
10078 };
10079 }
10083 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX GETTER SETTER INITS
10084 // or:
10085 // [stack] CTOR HOMEOBJ ARRAY INDEX GETTER SETTER INITS
10087 }
10090 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER SETTER
10091 // or:
10092 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER SETTER
10094 }
10099 // [stack] HERITAGE? ARRAY INDEX INITS GETTER SETTER HOMEOBJ
10101 }
10104 // [stack] HOMEOBJ ARRAY INDEX INITS GETTER SETTER CTOR
10106 }
10108 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ
10110 }
10111 }
10121 // [stack] HERITAGE? ARRAY INDEX INITS GETTER SETTER HOMEOBJ
10122 // or:
10123 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ CTOR
10125 }
10127 // [stack] HERITAGE? ARRAY INDEX INITS GETTER HOMEOBJ SETTER
10128 // or:
10129 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR SETTER
10131 }
10133 // [stack] HERITAGE? ARRAY INDEX INITS GETTER HOMEOBJ
10134 // or:
10135 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ
10137 }
10140 // [stack] HERITAGE? ARRAY INDEX INITS GETTER HOMEOBJ
10141 // or:
10142 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR
10144 }
10146 // [stack] HERITAGE? ARRAY INDEX INITS HOMEOBJ GETTER
10147 // or:
10148 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ CTOR GETTER
10150 }
10152 // [stack] HERITAGE? ARRAY INDEX INITS HOMEOBJ
10153 // or:
10154 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ
10156 }
10159 // The getter and setter share the same name.
10161 accessorSetterKeyAtom)) {
10163 }
10165 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ CTOR
10167 }
10170 // [stack] ARRAY INDEX INITS GETTER SETTER CTOR HOMEOBJ CTOR
10171 // KEY
10173 }
10175 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR KEY
10176 // SETTER
10178 }
10180 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ
10182 }
10185 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR
10187 }
10190 // [stack] ARRAY INDEX INITS GETTER CTOR HOMEOBJ CTOR KEY
10192 }
10194 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ CTOR KEY GETTER
10196 }
10198 // [stack] ARRAY INDEX INITS CTOR HOMEOBJ
10200 }
10201 }
10205 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS
10207 }
10210 // [stack] HOMEOBJ ARRAY INDEX INITS CTOR
10212 }
10214 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS
10216 }
10217 }
10222 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER SETTER
10223 // or:
10224 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER SETTER
10226 }
10229 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER
10230 // or:
10231 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER
10233 }
10236 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS GETTER
10237 // or:
10238 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS GETTER
10240 }
10243 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX INITS
10244 // or:
10245 // [stack] CTOR HOMEOBJ ARRAY INDEX INITS
10247 }
10248 }
10249 }
10251 // [stack] HOMEOBJ HERITAGE? ARRAY INDEX
10252 // or:
10253 // [stack] CTOR HOMEOBJ ARRAY INDEX
10255 }
10256 }
10257 }
10259 // Pop INDEX
10261 // [stack] HOMEOBJ HERITAGE? ARRAY
10262 // or:
10263 // [stack] CTOR HOMEOBJ ARRAY
10265 }
10266 #endif
10269 // [stack] HOMEOBJ HERITAGE?
10270 // or:
10271 // [stack] CTOR HOMEOBJ
10273 }
10276 }
10283 }
10286 // Skip over anything which isn't a private instance accessor.
10289 }
10292 // [stack] HOMEOBJ HERITAGE? ARRAY
10293 // or:
10294 // [stack] CTOR HOMEOBJ ARRAY
10296 }
10298 // Synthesize a name for the lexical variable that will store the
10299 // private method body.
10305 }
10309 }
10313 // Emit the private method body and store it as a lexical var.
10315 // [stack] HOMEOBJ HERITAGE? ARRAY METHOD
10316 // or:
10317 // [stack] CTOR HOMEOBJ ARRAY METHOD
10319 }
10320 // The private method body needs to access the home object,
10321 // and the CE knows where that is on the stack.
10324 // [stack] HOMEOBJ HERITAGE? ARRAY METHOD
10325 // or:
10326 // [stack] CTOR HOMEOBJ ARRAY METHOD
10328 }
10329 }
10331 // [stack] HOMEOBJ HERITAGE? ARRAY METHOD
10332 // or:
10333 // [stack] CTOR HOMEOBJ ARRAY METHOD
10335 }
10337 // [stack] HOMEOBJ HERITAGE? ARRAY
10338 // or:
10339 // [stack] CTOR HOMEOBJ ARRAY
10341 }
10344 // [stack] HOMEOBJ HERITAGE? ARRAY
10345 // or:
10346 // [stack] CTOR HOMEOBJ ARRAY
10348 }
10350 // Store the emitted initializer function into the .initializers array.
10352 // [stack] HOMEOBJ HERITAGE? ARRAY
10353 // or:
10354 // [stack] CTOR HOMEOBJ ARRAY
10356 }
10357 }
10360 }
10368 // Emit the synthesized initializer function.
10375 // [stack]
10377 }
10382 }
10386 // [stack]
10388 }
10390 // [stack]
10392 }
10394 // [stack]
10396 }
10399 // [stack] THIS
10401 }
10403 // [stack] THIS NAME
10405 }
10407 // [stack] THIS NAME METHOD
10409 }
10414 // [stack] THIS
10416 }
10418 // [stack] THIS NAME
10420 }
10424 // [stack] THIS NAME FUN
10426 }
10428 // [stack] THIS
10430 }
10436 // [stack] THIS
10438 }
10441 // [stack] THIS
10443 }
10444 }
10448 }
10450 // Pop remaining THIS.
10452 // [stack]
10454 }
10457 // [stack]
10459 }
10462 }
10465 // [stack] HOMEOBJ HERITAGE? ARRAY FUN
10466 // or:
10467 // [stack] CTOR HOMEOBJ ARRAY FUN
10469 }
10472 }
10481 }
10483 // If we found a non-arrow / non-constructor we were never allowed to
10484 // expect fields in the first place.
10489 }
10490 }
10494 }
10503 // This is guaranteed to run after super(), so we don't need TDZ checks.
10505 // [stack] THIS
10507 }
10509 // [stack] THIS BRAND
10511 }
10515 // [stack] THIS BRAND BOOL
10517 }
10519 // [stack] THIS BRAND
10521 }
10522 }
10524 // [stack] THIS BRAND NULL
10526 }
10528 // [stack] THIS
10530 }
10532 // [stack]
10534 }
10535 }
10540 // [stack] ARRAY
10542 }
10546 // We Dup to keep the array around (it is consumed in the bytecode
10547 // below) for next iterations of this loop, except for the last
10548 // iteration, which avoids an extra Pop at the end of the loop.
10550 // [stack] ARRAY ARRAY
10552 }
10553 }
10556 // [stack] ARRAY? ARRAY INDEX
10558 }
10561 // [stack] ARRAY? FUNC
10563 }
10565 // This is guaranteed to run after super(), so we don't need TDZ checks.
10567 // [stack] ARRAY? FUNC THIS
10569 }
10571 // Callee is always internal function.
10573 // [stack] ARRAY? RVAL
10575 }
10578 // [stack] ARRAY?
10580 }
10581 }
10582 #ifdef ENABLE_DECORATORS
10583 // Decorators Proposal
10584 // https://arai-a.github.io/ecma262-compare/?pr=2417&id=sec-initializeinstanceelements
10585 // 4. For each element e of elements, do
10586 // 4.a. If elementRecord.[[Kind]] is field or accessor, then
10587 // 4.a.i. Perform ? InitializeFieldOrAccessor(O, elementRecord).
10588 //
10590 // TODO: (See Bug 1817993) At the moment, we're applying the initialization
10591 // logic in two steps. The pre-decorator initialization code runs, stores
10592 // the initial value, and then we retrieve it here and apply the
10593 // initializers added by decorators. We should unify these two steps.
10595 // [stack] ARRAY
10597 }
10600 // [stack] ARRAY ARRAY
10602 }
10606 // [stack] ARRAY LENGTH
10608 }
10611 // [stack] ARRAY LENGTH INDEX
10613 }
10616 // At this point, we have no context to determine offsets in the
10617 // code for this while statement. Ideally, it would correspond to
10618 // the field we're initializing.
10620 // [stack] ARRAY LENGTH INDEX
10622 }
10625 // [stack] ARRAY LENGTH INDEX INDEX
10627 }
10630 // [stack] ARRAY LENGTH INDEX INDEX LENGTH
10632 }
10635 // [stack] ARRAY LENGTH INDEX BOOL
10637 }
10640 // [stack] ARRAY LENGTH INDEX
10642 }
10645 // [stack] ARRAY LENGTH INDEX ARRAY
10647 }
10650 // [stack] ARRAY LENGTH INDEX ARRAY INDEX
10652 }
10654 // Retrieve initializers for this field
10656 // [stack] ARRAY LENGTH INDEX INITIALIZERS
10658 }
10660 // This is guaranteed to run after super(), so we don't need TDZ checks.
10662 // [stack] ARRAY LENGTH INDEX INITIALIZERS THIS
10664 }
10667 // [stack] ARRAY LENGTH INDEX THIS INITIALIZERS
10669 }
10673 // [stack] ARRAY LENGTH INDEX
10675 }
10678 // [stack] ARRAY LENGTH INDEX
10680 }
10683 // [stack] ARRAY LENGTH INDEX
10685 }
10688 // [stack]
10690 }
10691 // 5. Return unused.
10692 #endif
10693 }
10695 }
10700 };
10707 }
10711 // [stack] CTOR ARRAY
10713 }
10718 // We Dup to keep the array around (it is consumed in the bytecode below)
10719 // for next iterations of this loop, except for the last iteration, which
10720 // avoids an extra Pop at the end of the loop.
10722 // [stack] CTOR ARRAY ARRAY
10724 }
10725 }
10728 // [stack] CTOR ARRAY? ARRAY INDEX
10730 }
10733 // [stack] CTOR ARRAY? FUNC
10735 }
10738 // [stack] CTOR ARRAY? FUNC CTOR
10740 }
10742 // Callee is always internal function.
10744 // [stack] CTOR ARRAY? RVAL
10746 }
10749 // [stack] CTOR ARRAY?
10751 }
10752 }
10754 #ifdef ENABLE_DECORATORS
10755 // Decorators Proposal
10756 // https://arai-a.github.io/ecma262-compare/?pr=2417&id=sec-initializeinstanceelements
10757 // 4. For each element e of elements, do
10758 // 4.a. If elementRecord.[[Kind]] is field or accessor, then
10759 // 4.a.i. Perform ? InitializeFieldOrAccessor(O, elementRecord).
10760 //
10762 // TODO: (See Bug 1817993) At the moment, we're applying the initialization
10763 // logic in two steps. The pre-decorator initialization code runs, stores
10764 // the initial value, and then we retrieve it here and apply the
10765 // initializers added by decorators. We should unify these two steps.
10768 // [stack] CTOR ARRAY
10770 }
10773 // [stack] CTOR ARRAY ARRAY
10775 }
10778 // [stack] CTOR ARRAY LENGTH
10780 }
10783 // [stack] CTOR ARRAY LENGTH INDEX
10785 }
10788 // At this point, we have no context to determine offsets in the
10789 // code for this while statement. Ideally, it would correspond to
10790 // the field we're initializing.
10792 // [stack] CTOR ARRAY LENGTH INDEX
10794 }
10797 // [stack] CTOR ARRAY LENGTH INDEX INDEX
10799 }
10802 // [stack] CTOR ARRAY LENGTH INDEX INDEX LENGTH
10804 }
10807 // [stack] CTOR ARRAY LENGTH INDEX BOOL
10809 }
10812 // [stack] CTOR ARRAY LENGTH INDEX
10814 }
10817 // [stack] CTOR ARRAY LENGTH INDEX ARRAY
10819 }
10822 // [stack] CTOR ARRAY LENGTH INDEX ARRAY INDEX
10824 }
10826 // Retrieve initializers for this field
10828 // [stack] CTOR ARRAY LENGTH INDEX INITIALIZERS
10830 }
10833 // [stack] CTOR ARRAY LENGTH INDEX INITIALIZERS CTOR
10835 }
10838 // [stack] CTOR ARRAY LENGTH INDEX CTOR INITIALIZERS
10840 }
10844 // [stack] CTOR ARRAY LENGTH INDEX
10846 }
10849 // [stack] CTOR ARRAY LENGTH INDEX
10851 }
10854 // [stack] CTOR ARRAY LENGTH INDEX
10856 }
10859 // [stack] CTOR
10861 }
10862 // 5. Return unused.
10863 #endif
10865 // Overwrite |.staticInitializers| and |.staticFieldKeys| with undefined to
10866 // avoid keeping the arrays alive indefinitely.
10870 // [stack] ENV? VAL?
10872 }
10875 // [stack] ENV? VAL? UNDEFINED
10877 }
10880 // [stack] VAL
10882 }
10885 // [stack]
10887 }
10890 };
10895 }
10901 };
10905 isStaticFieldWithComputedName)) {
10909 }
10910 }
10913 }
10915 // Using MOZ_NEVER_INLINE in here is a workaround for llvm.org/pr14047. See
10916 // the comment on emitSwitch.
10918 // Note: this method uses the ObjLiteralWriter and emits ObjLiteralStencil
10919 // objects into the GCThingList, which will evaluate them into real GC objects
10920 // or shapes during JSScript::fullyInitFromEmitter. Eventually we want
10921 // JSOp::Object to be a real opcode, but for now, performance constraints
10922 // limit us to evaluating object literals at the end of parse, when we're
10923 // allowed to allocate GC things.
10924 //
10925 // There are four cases here, in descending order of preference:
10926 //
10927 // 1. The list of property names is "normal" and constant (no computed
10928 // values, no integer indices), the values are all simple constants
10929 // (numbers, booleans, strings), *and* this occurs in a run-once
10930 // (singleton) context. In this case, we can emit ObjLiteral
10931 // instructions to build an object with values, and the object will be
10932 // attached to a JSOp::Object opcode, whose semantics are for the backend
10933 // to simply steal the object from the script.
10934 //
10935 // 2. The list of property names is "normal" and constant as above, *and* this
10936 // occurs in a run-once (singleton) context, but some values are complex
10937 // (computed expressions, sub-objects, functions, etc.). In this case, we
10938 // can still use JSOp::Object (because singleton context), but the object
10939 // has |undefined| property values and InitProp ops are emitted to set the
10940 // values.
10941 //
10942 // 3. The list of property names is "normal" and constant as above, but this
10943 // occurs in a non-run-once (non-singleton) context. In this case, we can
10944 // use the ObjLiteral functionality to describe an *empty* object (all
10945 // values left undefined) with the right fields, which will become a
10946 // JSOp::NewObject opcode using the object's shape to speed up the creation
10947 // of the object each time it executes. The emitted bytecode still needs
10948 // InitProp ops to set the values in this case.
10949 //
10950 // 4. Any other case. As a fallback, we use NewInit to create a new, empty
10951 // object (i.e., `{}`) and then emit bytecode to initialize its properties
10952 // one-by-one.
10959 // [stack]
10960 //
10965 JSOp op;
10967 // Case 1 or 2.
10970 // Case 3.
10973 }
10975 // Use an ObjLiteral op. This will record ObjLiteral insns in the
10976 // objLiteralWriter's buffer and add a fixup to the list of ObjLiteral
10977 // fixups so that at GC-publish time at the end of parse, the full object
10978 // (case 1 or 2) or shape (case 3) can be allocated and the bytecode can be
10979 // patched to refer to it.
10981 // [stack] OBJ
10983 }
10984 // Put the ObjectEmitter in the right state. This tells it that there will
10985 // already be an object on the stack as a result of the (eventual)
10986 // NewObject or Object op, and prepares it to emit values if needed.
10988 // [stack] OBJ
10990 }
10992 // Case 2 or 3 above: we still need to emit bytecode to fill in the
10993 // object's property values.
10995 // [stack] OBJ
10997 }
10998 }
11000 // Case 4 above: no ObjLiteral use, just bytecode to build the object from
11001 // scratch.
11003 // [stack] OBJ
11005 }
11007 // [stack] OBJ
11009 }
11010 }
11013 // [stack] OBJ
11015 }
11018 }
11021 // Emit JSOp::Object if the array consists entirely of primitive values and we
11022 // are in a singleton context.
11026 }
11029 }
11032 /*
11033 * Emit code for [a, b, c] that is equivalent to constructing a new
11034 * array and in source order evaluating each element value and adding
11035 * it to the array, without invoking latent setters. We use the
11036 * JSOp::NewInit and JSOp::InitElemArray bytecodes to ignore setters and
11037 * to avoid dup'ing and popping the array as each element is added, as
11038 * JSOp::SetElem/JSOp::SetProp would do.
11039 */
11044 nspread++;
11045 }
11046 }
11048 // Array literal's length is limited to NELEMENTS_LIMIT in parser.
11050 "array literals' maximum length must not exceed limits "
11051 "required by BaselineCompiler::emit_NewArray, "
11052 "BaselineCompiler::emit_InitElemArray, "
11058 "the parser must throw an error if the array exceeds maximum "
11061 // For arrays with spread, this is a very pessimistic allocation, the
11062 // minimum possible final size.
11064 // [stack] ARRAY
11066 }
11075 // [stack] ARRAY INDEX
11077 }
11078 }
11085 }
11087 // [stack] ARRAY INDEX ITERABLE
11089 }
11091 // [stack] ARRAY INDEX NEXT ITER
11093 }
11095 // [stack] INDEX NEXT ITER ARRAY
11097 }
11099 // [stack] NEXT ITER ARRAY INDEX
11101 }
11103 // [stack] ARRAY INDEX
11105 }
11109 }
11113 }
11116 // [stack] ARRAY INDEX? VALUE
11118 }
11119 }
11123 // [stack] ARRAY (INDEX+1)
11125 }
11128 // [stack] ARRAY
11130 }
11131 }
11132 }
11134 index++;
11135 }
11139 // [stack] ARRAY
11141 }
11142 }
11144 }
11150 // [stack] VALUE
11152 }
11159 // [stack] NEXT ITER
11161 }
11164 // [stack] NEXT ITER ARRAY
11166 }
11169 // [stack] NEXT ITER ARRAY INDEX
11171 }
11174 // [stack] ARRAY INDEX
11176 }
11179 // [stack] ARRAY
11181 }
11183 }
11185 #ifdef ENABLE_RECORD_TUPLE
11188 // [stack] RECORD
11190 }
11195 // [stack] RECORD SPREADEE
11197 }
11199 // [stack] RECORD
11201 }
11212 }
11217 }
11225 }
11227 }
11228 // [stack] RECORD KEY
11231 // [stack] RECORD KEY VALUE
11233 }
11236 // [stack] RECORD
11238 }
11239 }
11240 }
11243 // [stack] RECORD
11245 }
11248 }
11252 // [stack] TUPLE
11254 }
11262 // [stack] TUPLE ITERABLE
11264 }
11266 // [stack] TUPLE NEXT ITER
11268 }
11270 // [stack] NEXT ITER TUPLE
11272 }
11275 // [stack] TUPLE
11277 }
11279 // Update location to throw errors about non-primitive elements
11280 // in the correct position.
11283 }
11286 // [stack] TUPLE VALUE
11288 }
11291 // [stack] TUPLE
11293 }
11294 }
11295 }
11298 // [stack] TUPLE
11300 }
11303 }
11304 #endif
11322 }
11323 }
11328 }
11331 ValueUsage valueUsage =
11335 }
11337 }
11344 }
11348 }
11351 }
11365 }
11371 // Left-hand sides are either simple names or destructuring patterns.
11377 // [stack]
11380 // [stack] DEFAULT
11382 }
11384 };
11387 // [stack] ARG
11391 // [stack] ARG
11393 }
11396 };
11401 // [stack]
11403 }
11405 // [stack]
11407 }
11409 // [stack]
11411 }
11415 // [stack]
11417 }
11418 }
11421 }
11426 // [stack]
11428 }
11430 // [stack]
11432 }
11434 // [stack]
11436 }
11438 // [stack]
11440 }
11442 // [stack]
11444 }
11447 // [stack]
11449 }
11451 // [stack]
11453 }
11455 // [stack]
11457 }
11458 }
11461 }
11465 // [stack]
11467 }
11469 // [stack]
11471 }
11474 // [stack]
11476 }
11479 }
11483 // [stack]
11485 }
11486 }
11489 }
11494 // [stack]
11498 // A special name must be slotful, either on the frame or on the
11499 // call environment.
11504 // [stack]
11506 }
11508 // [stack] THIS/ARGUMENTS/NEW.TARGET
11510 }
11512 // [stack] THIS/ARGUMENTS/NEW.TARGET
11514 }
11516 // [stack]
11518 }
11521 };
11523 // Do nothing if the function doesn't have an arguments binding.
11525 // Self-hosted code should use the more efficient ArgumentsLength and
11526 // GetArgument intrinsics instead of `arguments`.
11531 // [stack]
11533 }
11534 }
11536 // Do nothing if the function doesn't have a this-binding (this
11537 // happens for instance if it doesn't use this/eval or if it's an
11538 // arrow function).
11544 }
11545 }
11547 // Do nothing if the function doesn't have a new.target-binding (this happens
11548 // for instance if it doesn't use new.target/eval or if it's an arrow
11549 // function).
11555 }
11556 }
11558 // Do nothing if the function doesn't implicitly return a promise result.
11563 // [stack]
11565 }
11566 }
11568 }
11572 }
11578 }
11580 // The caller has pushed the RHS to the top of the stack. Assert that the
11581 // binding can be initialized without a binding object on the stack, and that
11582 // no JSOp::BindName or JSOp::BindGName ops were emitted.
11589 }
11592 }
11599 }
11609 }
11610 }
11611 }
11613 }
11616 TaggedParserAtomIndex symbolName) {
11618 // [stack] HERITAGE PRIVATENAME
11620 }
11622 // Add a binding for #name => privatename
11624 // [stack] HERITAGE PRIVATENAME
11626 }
11628 // Pop Private name off the stack.
11630 // [stack] HERITAGE
11632 }
11635 }
11649 }
11653 }
11655 // Non-static private methods' private names are optimized away.
11663 }
11664 }
11670 }
11671 }
11672 }
11675 // We don't make a private name for every optimized method, but we need one
11676 // private name per class, the `.privateBrand`.
11679 privateBrandName)) {
11681 }
11682 }
11684 }
11686 // This follows ES6 14.5.14 (ClassDefinitionEvaluation) and ES6 14.5.15
11687 // (BindingClassDeclarationEvaluation).
11691 TaggedParserAtomIndex
11700 // If |nameKind != ClassNameKind::ComputedName|
11701 // [stack]
11702 // Else
11703 // [stack] NAME
11706 TaggedParserAtomIndex innerName;
11717 }
11718 }
11722 // [stack]
11724 }
11725 }
11731 }
11734 }
11736 // [stack] HERITAGE
11738 }
11739 }
11741 // The class body scope holds any private names. Those mustn't be visible in
11742 // the heritage expression and hence the scope must be emitted after the
11743 // heritage expression.
11746 // [stack] HERITAGE
11748 }
11750 // The spec does not say anything about private brands being symbols. It's
11751 // an implementation detail. So we can give the special private brand
11752 // symbol any description we want and users won't normally see it. For
11753 // debugging, use the class name.
11756 privateBrandName = nameForAnonymousClass
11757 ? nameForAnonymousClass
11759 }
11762 }
11763 }
11768 hasNameOnStack)) {
11769 // [stack] HERITAGE HOMEOBJ
11771 }
11774 // [stack] HOMEOBJ
11776 }
11777 }
11779 // Stack currently has HOMEOBJ followed by optional HERITAGE. When HERITAGE
11780 // is not used, an implicit value of %FunctionPrototype% is implied.
11782 // See |Parser::classMember(...)| for the reason why |.initializers| is
11783 // created within its own scope.
11789 // The constructor scope should only contain the |.initializers| binding.
11799 };
11801 // As an optimization omit the |.initializers| binding when no instance
11802 // fields or private methods are present.
11811 }
11813 // Any class with field initializers will have a constructor
11816 #ifdef ENABLE_DECORATORS
11817 ,
11818 isDerived
11819 #endif
11820 )) {
11822 }
11823 }
11827 // The |.initializers| binding is never emitted when in self-hosting mode.
11830 }
11833 // HERITAGE is consumed inside emitFunction.
11837 }
11838 }
11840 // [stack] HOMEOBJ CTOR
11842 }
11846 }
11848 }
11850 // [stack] CTOR HOMEOBJ
11852 }
11856 }
11859 #ifdef ENABLE_DECORATORS
11860 ,
11861 false
11862 #endif
11863 )) {
11865 }
11869 }
11872 // [stack] CTOR HOMEOBJ
11874 }
11877 // [stack] CTOR
11879 }
11882 // [stack] CTOR
11884 }
11886 #if ENABLE_DECORATORS
11888 // [stack] CTOR
11890 }
11897 // [stack] CTOR
11899 }
11900 }
11901 #endif
11904 // [stack] # class declaration
11905 // [stack]
11906 // [stack] # class expression
11907 // [stack] CTOR
11909 }
11912 }
11924 }
11928 }
11929 }
11934 }
11938 }
11939 }
11942 }
11950 }
11952 /* Emit notes to tell the current bytecode's source line number.
11953 However, a couple trees require special treatment; see the
11954 relevant emitter functions for details. */
11959 }
11960 }
11966 }
11977 }
11983 }
11989 }
11995 }
12001 }
12005 // Ensure that the column of the 'break' is set properly.
12008 }
12011 }
12015 }
12019 // Ensure that the column of the 'continue' is set properly.
12022 }
12025 }
12029 }
12035 }
12041 }
12047 }
12053 }
12059 }
12065 }
12071 }
12077 }
12083 }
12089 }
12095 }
12104 }
12110 }
12116 }
12137 }
12139 }
12146 }
12151 valueUsage)) {
12153 }
12161 }
12187 }
12193 }
12199 }
12205 }
12211 }
12217 }
12220 }
12229 }
12238 }
12244 }
12250 }
12256 }
12262 }
12268 }
12274 }
12285 }
12289 // [stack] THIS
12291 }
12294 // [stack] OBJ
12296 }
12297 }
12299 // [stack] PROP
12301 }
12303 }
12313 // [stack] # if Super
12314 // [stack] THIS KEY
12315 // [stack] # otherwise
12316 // [stack] OBJ KEY
12318 }
12320 // [stack] ELEM
12322 }
12325 }
12332 // [stack] OBJ
12334 }
12336 // [stack] OBJ NAME
12338 }
12340 // [stack] VALUE
12342 }
12345 }
12353 }
12359 }
12366 }
12380 }
12381 }
12383 }
12389 }
12399 }
12405 }
12411 }
12417 }
12423 }
12429 }
12436 }
12442 }
12448 }
12452 GCThingIndex index;
12456 }
12459 }
12461 }
12466 }
12471 }
12476 }
12481 }
12487 }
12493 }
12496 }
12499 }
12505 }
12511 }
12517 }
12524 // [stack] specifier
12526 }
12529 // [stack] specifier options
12532 }
12534 // [stack] specifier undefined
12537 }
12538 }
12542 }
12545 }
12550 }
12553 #ifdef ENABLE_RECORD_TUPLE
12557 }
12563 }
12565 #endif
12574 }
12577 }
12586 }
12590 }
12594 }
12600 }
12606 /*
12607 * Compute delta from the last annotated bytecode's offset. If it's too
12608 * big to fit in sn, allocate one or more xdelta notes and reset sn.
12609 */
12617 }
12619 };
12623 }
12627 }
12633 }
12636 }
12643 }
12646 }
12649 }
12651 }
12663 }
12667 }
12672 // The Line operand is either 1 byte or 4 bytes.
12681 }
12685 }
12691 }
12699 }
12701 };
12704 }
12711 }
12719 }
12721 // Hand over the ImmutableScriptData instance generated by BCE.
12726 }
12728 // De-duplicate the bytecode within the runtime.
12731 }
12736 // Update flags specific to functions.
12745 }
12748 }
12756 }
12760 }
12764 }
12765 }
12768 }
12770 #if defined(DEBUG) || defined(JS_JITSPEW)
12773 }
12774 #endif