dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Tests/LibJS/Bytecode/expected/eval-same-function.txt

41 lines
1 KiB
Text
Raw Permalink Normal View History

LibJS: Store bytecode cache indexes instead of pointers Store compact cache indexes in bytecode instructions instead of raw pointers to the executable cache vectors. This keeps the instruction stream independent from heap addresses and removes pointer fixups when materializing cached bytecode. Resolve the mutable cache pointers at execution time from the current Executable. Bytecode test expectations are updated for the smaller cache operands and resulting instruction offsets.
2026-05-18 08:26:41 -03:00
$49b95e06 eval-same-function.js:10:1
LibJS: Improve bytecode executable dump format Add a metadata header showing register count, block count, local variable names, and the constants table. Resolve jump targets to block labels (e.g. "block1") instead of raw hex addresses, and add visual separation between basic blocks. Make identifier and property key formatting more concise by using backtick quoting and showing base_identifier as a trailing parenthetical hint that joins the base and property names. Generate a stable name for each executable by hashing the source text it covers (stable across codegen changes). Named functions show as "foo$9beb91ec", anonymous ones as "$43362f3f". Also show the source filename, line, and column.
2026-03-18 19:56:54 -03:00
Registers: 7
Blocks: 1
Constants:
[0] = Undefined
LibJS: Stop propagating is_inside_scope_with_eval across functions Previously, when a nested function contained eval(), the parser would mark all identifiers in parent functions as "inside scope with eval". This prevented those identifiers from being marked as global, forcing them to use GetBinding instead of GetGlobal. However, eval() can only inject variables into its containing function's scope, not into parent function scopes. So a parent function's reference to a global like `Number` should still be able to use GetGlobal even if a nested function contains eval(). This change adds a new flag `m_eval_in_current_function` that propagates through block scopes within the same function but stops at function boundaries. This flag is used for marking identifiers, while the existing `m_screwed_by_eval_in_scope_chain` continues to propagate across functions for local variable deoptimization (since eval can access closure variables). Before: `new Number(42)` in outer() with eval in inner() -> GetBinding After: `new Number(42)` in outer() with eval in inner() -> GetGlobal
2026-01-26 17:17:28 -03:00
LibJS: Improve bytecode executable dump format Add a metadata header showing register count, block count, local variable names, and the constants table. Resolve jump targets to block labels (e.g. "block1") instead of raw hex addresses, and add visual separation between basic blocks. Make identifier and property key formatting more concise by using backtick quoting and showing base_identifier as a trailing parenthetical hint that joins the base and property names. Generate a stable name for each executable by hashing the source text it covers (stable across codegen changes). Named functions show as "foo$9beb91ec", anonymous ones as "$43362f3f". Also show the source filename, line, and column.
2026-03-18 19:56:54 -03:00
block0:
LibJS: Drop dead entry GetLexicalEnvironment loads Teach the Rust bytecode generator to treat the synthetic entry GetLexicalEnvironment as a removable prologue load. We still model reg4 as the saved entry lexical environment during codegen, but assemble() now deletes that load when no emitted instruction refers to the saved environment register. This keeps the semantics of unwinding and environment restoration intact while letting empty functions and other simple bodies start at their first real instruction.
2026-04-13 08:16:17 -03:00
[ 0] GetGlobal dst:reg6, `foo`
LibJS: Store bytecode cache indexes instead of pointers Store compact cache indexes in bytecode instructions instead of raw pointers to the executable cache vectors. This keeps the instruction stream independent from heap addresses and removes pointer fixups when materializing cached bytecode. Resolve the mutable cache pointers at execution time from the current Executable. Bytecode test expectations are updated for the smaller cache operands and resulting instruction offsets.
2026-05-18 08:26:41 -03:00
[ 10] Call dst:reg5, callee:reg6, this_value:Undefined, foo
[ 30] End value:reg5
LibJS: Stop propagating is_inside_scope_with_eval across functions Previously, when a nested function contained eval(), the parser would mark all identifiers in parent functions as "inside scope with eval". This prevented those identifiers from being marked as global, forcing them to use GetBinding instead of GetGlobal. However, eval() can only inject variables into its containing function's scope, not into parent function scopes. So a parent function's reference to a global like `Number` should still be able to use GetGlobal even if a nested function contains eval(). This change adds a new flag `m_eval_in_current_function` that propagates through block scopes within the same function but stops at function boundaries. This flag is used for marking identifiers, while the existing `m_screwed_by_eval_in_scope_chain` continues to propagate across functions for local variable deoptimization (since eval can access closure variables). Before: `new Number(42)` in outer() with eval in inner() -> GetBinding After: `new Number(42)` in outer() with eval in inner() -> GetGlobal
2026-01-26 17:17:28 -03:00
LibJS: Improve bytecode executable dump format Add a metadata header showing register count, block count, local variable names, and the constants table. Resolve jump targets to block labels (e.g. "block1") instead of raw hex addresses, and add visual separation between basic blocks. Make identifier and property key formatting more concise by using backtick quoting and showing base_identifier as a trailing parenthetical hint that joins the base and property names. Generate a stable name for each executable by hashing the source text it covers (stable across codegen changes). Named functions show as "foo$9beb91ec", anonymous ones as "$43362f3f". Also show the source filename, line, and column.
2026-03-18 19:56:54 -03:00
LibJS: Cache dynamic environment coordinates Dynamic environment binding opcodes lost the old coordinate warmup. They were split away from the static coordinate opcodes. Hot closures and eval-sensitive functions then resolved the same binding by name on every execution, which regressed JS benchmark throughput badly. Give each dynamic environment opcode a per-executable coordinate cache slot. The cache keeps the bytecode stream immutable while letting both interpreters take a direct declarative environment fast path after the first lookup. Keep the existing eval invalidation behavior and only warm caches for declarative-only chains so with environments continue to observe object shadowing. Reject cached bytecode that uses the no-cache sentinel for dynamic environment coordinate cache operands, since execution indexes those cache arrays unconditionally. Rebaseline bytecode expectations for the instruction size changes. Add coverage for with-object shadowing across repeated dynamic lookups and for rejecting corrupt dynamic environment cache indices.
2026-05-19 06:22:33 -03:00
foo$3e35f384 eval-same-function.js:6:9
LibJS: Improve bytecode executable dump format Add a metadata header showing register count, block count, local variable names, and the constants table. Resolve jump targets to block labels (e.g. "block1") instead of raw hex addresses, and add visual separation between basic blocks. Make identifier and property key formatting more concise by using backtick quoting and showing base_identifier as a trailing parenthetical hint that joins the base and property names. Generate a stable name for each executable by hashing the source text it covers (stable across codegen changes). Named functions show as "foo$9beb91ec", anonymous ones as "$43362f3f". Also show the source filename, line, and column.
2026-03-18 19:56:54 -03:00
Registers: 8
Blocks: 1
Constants:
[0] = String("var x = 1")
[1] = Undefined
[2] = Int32(42)
block0:
LibJS: Drop dead entry GetLexicalEnvironment loads Teach the Rust bytecode generator to treat the synthetic entry GetLexicalEnvironment as a removable prologue load. We still model reg4 as the saved entry lexical environment during codegen, but assemble() now deletes that load when no emitted instruction refers to the saved environment register. This keeps the semantics of unwinding and environment restoration intact while letting empty functions and other simple bodies start at their first real instruction.
2026-04-13 08:16:17 -03:00
[ 0] CreateArguments is_immutable:false
LibJS: Split dynamic environment lookups from coordinates Add separate bytecode instructions for environment lookups that must stay dynamic, such as eval- and with-sensitive scopes. Keep the coordinate variants for eagerly resolved declarative environments so their operands can be treated as immutable at runtime. This removes cached-coordinate mutation from the interpreter paths and updates the bytecode expectations for the new dynamic lookup opcodes.
2026-05-18 08:27:20 -03:00
[ 10] DynamicGetCalleeAndThisFromEnvironment callee:reg6, this_value:reg7, `eval`
LibJS: Cache dynamic environment coordinates Dynamic environment binding opcodes lost the old coordinate warmup. They were split away from the static coordinate opcodes. Hot closures and eval-sensitive functions then resolved the same binding by name on every execution, which regressed JS benchmark throughput badly. Give each dynamic environment opcode a per-executable coordinate cache slot. The cache keeps the bytecode stream immutable while letting both interpreters take a direct declarative environment fast path after the first lookup. Keep the existing eval invalidation behavior and only warm caches for declarative-only chains so with environments continue to observe object shadowing. Reject cached bytecode that uses the no-cache sentinel for dynamic environment coordinate cache operands, since execution indexes those cache arrays unconditionally. Rebaseline bytecode expectations for the instruction size changes. Add coverage for with-object shadowing across repeated dynamic lookups and for rejecting corrupt dynamic environment cache indices.
2026-05-19 06:22:33 -03:00
[ 28] CallDirectEval dst:reg5, callee:reg6, this_value:reg7, eval, arguments:[String("var x = 1")]
[ 50] DynamicGetBinding dst:reg6, `Number`
[ 60] CallConstruct dst:reg5, callee:reg6, Number, arguments:[Int32(42)]
[ 80] Return value:reg5
LibJS: Improve bytecode executable dump format Add a metadata header showing register count, block count, local variable names, and the constants table. Resolve jump targets to block labels (e.g. "block1") instead of raw hex addresses, and add visual separation between basic blocks. Make identifier and property key formatting more concise by using backtick quoting and showing base_identifier as a trailing parenthetical hint that joins the base and property names. Generate a stable name for each executable by hashing the source text it covers (stable across codegen changes). Named functions show as "foo$9beb91ec", anonymous ones as "$43362f3f". Also show the source filename, line, and column.
2026-03-18 19:56:54 -03:00
LibJS: Preserve resolved assignment bindings Resolve dynamic identifier assignment targets before evaluating the right hand side, then store through that saved environment record. This matches the ECMA-262 ordering for simple assignment and var initializers when a with binding is deleted or direct eval creates a nearer var. Add runtime coverage for with and direct-eval cases and refresh bytecode expectations for dynamic assignments that now snapshot the binding before storing.
2026-05-21 12:41:47 -03:00
eval$e1340763 line 1, column 1
Registers: 6
LibJS: Improve bytecode executable dump format Add a metadata header showing register count, block count, local variable names, and the constants table. Resolve jump targets to block labels (e.g. "block1") instead of raw hex addresses, and add visual separation between basic blocks. Make identifier and property key formatting more concise by using backtick quoting and showing base_identifier as a trailing parenthetical hint that joins the base and property names. Generate a stable name for each executable by hashing the source text it covers (stable across codegen changes). Named functions show as "foo$9beb91ec", anonymous ones as "$43362f3f". Also show the source filename, line, and column.
2026-03-18 19:56:54 -03:00
Blocks: 1
Constants:
[0] = Int32(1)
[1] = Undefined
block0:
LibJS: Preserve resolved assignment bindings Resolve dynamic identifier assignment targets before evaluating the right hand side, then store through that saved environment record. This matches the ECMA-262 ordering for simple assignment and var initializers when a with binding is deleted or direct eval creates a nearer var. Add runtime coverage for with and direct-eval cases and refresh bytecode expectations for dynamic assignments that now snapshot the binding before storing.
2026-05-21 12:41:47 -03:00
[ 0] ResolveBinding dst:reg5, `x`
[ 10] SetResolvedBinding environment:reg5, `x`, src:Int32(1)
[ 20] End value:Undefined
Reference in a new issue Copy permalink