v8/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden

915 lines
27 KiB
Plaintext
Raw Normal View History

#
# Autogenerated by generate-bytecode-expectations.
#
---
wrap: yes
---
snippet: "
var a; return function() { a = 1; };
"
frame size: 1
parameter count: 1
bytecode array length: 10
bytecodes: [
B(CreateFunctionContext), U8(1),
B(PushContext), R(0),
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(CreateClosure), U8(0), U8(4), U8(2),
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
/* 70 S> */ B(Return),
]
constant pool: [
SHARED_FUNCTION_INFO_TYPE,
]
handlers: [
]
---
snippet: "
var a = 1; return function() { a = 2; };
"
frame size: 1
parameter count: 1
bytecode array length: 14
bytecodes: [
B(CreateFunctionContext), U8(1),
B(PushContext), R(0),
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), I8(1),
/* 42 E> */ B(StaCurrentContextSlot), U8(4),
/* 45 S> */ B(CreateClosure), U8(0), U8(4), U8(2),
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
/* 74 S> */ B(Return),
]
constant pool: [
SHARED_FUNCTION_INFO_TYPE,
]
handlers: [
]
---
snippet: "
var a = 1; var b = 2; return function() { a = 2; b = 3 };
"
frame size: 1
parameter count: 1
bytecode array length: 18
bytecodes: [
B(CreateFunctionContext), U8(2),
B(PushContext), R(0),
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), I8(1),
/* 42 E> */ B(StaCurrentContextSlot), U8(4),
/* 53 S> */ B(LdaSmi), I8(2),
/* 53 E> */ B(StaCurrentContextSlot), U8(5),
/* 56 S> */ B(CreateClosure), U8(0), U8(4), U8(2),
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
/* 91 S> */ B(Return),
]
constant pool: [
SHARED_FUNCTION_INFO_TYPE,
]
handlers: [
]
---
snippet: "
var a; (function() { a = 2; })(); return a;
"
frame size: 2
parameter count: 1
bytecode array length: 17
bytecodes: [
B(CreateFunctionContext), U8(1),
B(PushContext), R(0),
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(CreateClosure), U8(0), U8(6), U8(2),
B(Star), R(1),
/* 64 E> */ B(CallUndefinedReceiver0), R(1), U8(4),
/* 68 S> */ B(LdaCurrentContextSlot), U8(4),
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
/* 77 S> */ B(Return),
]
constant pool: [
SHARED_FUNCTION_INFO_TYPE,
]
handlers: [
]
---
snippet: "
'use strict';
let a = 1;
{ let b = 2; return function() { a + b; }; }
"
frame size: 2
parameter count: 1
bytecode array length: 30
bytecodes: [
B(CreateFunctionContext), U8(1),
B(PushContext), R(0),
B(LdaTheHole),
B(StaCurrentContextSlot), U8(4),
/* 30 E> */ B(StackCheck),
/* 56 S> */ B(LdaSmi), I8(1),
/* 56 E> */ B(StaCurrentContextSlot), U8(4),
B(Ldar), R(closure),
B(CreateBlockContext), U8(0),
B(PushContext), R(1),
B(LdaTheHole),
B(StaCurrentContextSlot), U8(4),
/* 69 S> */ B(LdaSmi), I8(2),
/* 69 E> */ B(StaCurrentContextSlot), U8(4),
/* 72 S> */ B(CreateClosure), U8(1), U8(4), U8(2),
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
/* 101 S> */ B(Return),
]
constant pool: [
FIXED_ARRAY_TYPE,
SHARED_FUNCTION_INFO_TYPE,
]
handlers: [
]
---
snippet: "
'use strict';
var a0 = 0;
var a1 = 0;
var a2 = 0;
var a3 = 0;
var a4 = 0;
var a5 = 0;
var a6 = 0;
var a7 = 0;
var a8 = 0;
var a9 = 0;
var a10 = 0;
var a11 = 0;
var a12 = 0;
var a13 = 0;
var a14 = 0;
var a15 = 0;
var a16 = 0;
var a17 = 0;
var a18 = 0;
var a19 = 0;
var a20 = 0;
var a21 = 0;
var a22 = 0;
var a23 = 0;
var a24 = 0;
var a25 = 0;
var a26 = 0;
var a27 = 0;
var a28 = 0;
var a29 = 0;
var a30 = 0;
var a31 = 0;
var a32 = 0;
var a33 = 0;
var a34 = 0;
var a35 = 0;
var a36 = 0;
var a37 = 0;
var a38 = 0;
var a39 = 0;
var a40 = 0;
var a41 = 0;
var a42 = 0;
var a43 = 0;
var a44 = 0;
var a45 = 0;
var a46 = 0;
var a47 = 0;
var a48 = 0;
var a49 = 0;
var a50 = 0;
var a51 = 0;
var a52 = 0;
var a53 = 0;
var a54 = 0;
var a55 = 0;
var a56 = 0;
var a57 = 0;
var a58 = 0;
var a59 = 0;
var a60 = 0;
var a61 = 0;
var a62 = 0;
var a63 = 0;
var a64 = 0;
var a65 = 0;
var a66 = 0;
var a67 = 0;
var a68 = 0;
var a69 = 0;
var a70 = 0;
var a71 = 0;
var a72 = 0;
var a73 = 0;
var a74 = 0;
var a75 = 0;
var a76 = 0;
var a77 = 0;
var a78 = 0;
var a79 = 0;
var a80 = 0;
var a81 = 0;
var a82 = 0;
var a83 = 0;
var a84 = 0;
var a85 = 0;
var a86 = 0;
var a87 = 0;
var a88 = 0;
var a89 = 0;
var a90 = 0;
var a91 = 0;
var a92 = 0;
var a93 = 0;
var a94 = 0;
var a95 = 0;
var a96 = 0;
var a97 = 0;
var a98 = 0;
var a99 = 0;
var a100 = 0;
var a101 = 0;
var a102 = 0;
var a103 = 0;
var a104 = 0;
var a105 = 0;
var a106 = 0;
var a107 = 0;
var a108 = 0;
var a109 = 0;
var a110 = 0;
var a111 = 0;
var a112 = 0;
var a113 = 0;
var a114 = 0;
var a115 = 0;
var a116 = 0;
var a117 = 0;
var a118 = 0;
var a119 = 0;
var a120 = 0;
var a121 = 0;
var a122 = 0;
var a123 = 0;
var a124 = 0;
var a125 = 0;
var a126 = 0;
var a127 = 0;
var a128 = 0;
var a129 = 0;
var a130 = 0;
var a131 = 0;
var a132 = 0;
var a133 = 0;
var a134 = 0;
var a135 = 0;
var a136 = 0;
var a137 = 0;
var a138 = 0;
var a139 = 0;
var a140 = 0;
var a141 = 0;
var a142 = 0;
var a143 = 0;
var a144 = 0;
var a145 = 0;
var a146 = 0;
var a147 = 0;
var a148 = 0;
var a149 = 0;
var a150 = 0;
var a151 = 0;
var a152 = 0;
var a153 = 0;
var a154 = 0;
var a155 = 0;
var a156 = 0;
var a157 = 0;
var a158 = 0;
var a159 = 0;
var a160 = 0;
var a161 = 0;
var a162 = 0;
var a163 = 0;
var a164 = 0;
var a165 = 0;
var a166 = 0;
var a167 = 0;
var a168 = 0;
var a169 = 0;
var a170 = 0;
var a171 = 0;
var a172 = 0;
var a173 = 0;
var a174 = 0;
var a175 = 0;
var a176 = 0;
var a177 = 0;
var a178 = 0;
var a179 = 0;
var a180 = 0;
var a181 = 0;
var a182 = 0;
var a183 = 0;
var a184 = 0;
var a185 = 0;
var a186 = 0;
var a187 = 0;
var a188 = 0;
var a189 = 0;
var a190 = 0;
var a191 = 0;
var a192 = 0;
var a193 = 0;
var a194 = 0;
var a195 = 0;
var a196 = 0;
var a197 = 0;
var a198 = 0;
var a199 = 0;
var a200 = 0;
var a201 = 0;
var a202 = 0;
var a203 = 0;
var a204 = 0;
var a205 = 0;
var a206 = 0;
var a207 = 0;
var a208 = 0;
var a209 = 0;
var a210 = 0;
var a211 = 0;
var a212 = 0;
var a213 = 0;
var a214 = 0;
var a215 = 0;
var a216 = 0;
var a217 = 0;
var a218 = 0;
var a219 = 0;
var a220 = 0;
var a221 = 0;
var a222 = 0;
var a223 = 0;
var a224 = 0;
var a225 = 0;
var a226 = 0;
var a227 = 0;
var a228 = 0;
var a229 = 0;
var a230 = 0;
var a231 = 0;
var a232 = 0;
var a233 = 0;
var a234 = 0;
var a235 = 0;
var a236 = 0;
var a237 = 0;
var a238 = 0;
var a239 = 0;
var a240 = 0;
var a241 = 0;
var a242 = 0;
var a243 = 0;
var a244 = 0;
var a245 = 0;
var a246 = 0;
var a247 = 0;
var a248 = 0;
var a249 = 0;
eval();
var b = 100;
return b
"
frame size: 2
parameter count: 1
bytecode array length: 787
bytecodes: [
B(CreateFunctionContext), U8(254),
B(PushContext), R(0),
B(Ldar), R(this),
B(StaCurrentContextSlot), U8(4),
B(CreateUnmappedArguments),
B(Wide), B(StaCurrentContextSlot), U16(257),
B(Ldar), R(new_target),
B(StaCurrentContextSlot), U8(5),
/* 30 E> */ B(StackCheck),
/* 57 S> */ B(LdaZero),
/* 57 E> */ B(StaCurrentContextSlot), U8(6),
/* 69 S> */ B(LdaZero),
/* 69 E> */ B(StaCurrentContextSlot), U8(7),
/* 81 S> */ B(LdaZero),
/* 81 E> */ B(StaCurrentContextSlot), U8(8),
/* 93 S> */ B(LdaZero),
/* 93 E> */ B(StaCurrentContextSlot), U8(9),
/* 105 S> */ B(LdaZero),
/* 105 E> */ B(StaCurrentContextSlot), U8(10),
/* 117 S> */ B(LdaZero),
/* 117 E> */ B(StaCurrentContextSlot), U8(11),
/* 129 S> */ B(LdaZero),
/* 129 E> */ B(StaCurrentContextSlot), U8(12),
/* 141 S> */ B(LdaZero),
/* 141 E> */ B(StaCurrentContextSlot), U8(13),
/* 153 S> */ B(LdaZero),
/* 153 E> */ B(StaCurrentContextSlot), U8(14),
/* 165 S> */ B(LdaZero),
/* 165 E> */ B(StaCurrentContextSlot), U8(15),
/* 178 S> */ B(LdaZero),
/* 178 E> */ B(StaCurrentContextSlot), U8(16),
/* 191 S> */ B(LdaZero),
/* 191 E> */ B(StaCurrentContextSlot), U8(17),
/* 204 S> */ B(LdaZero),
/* 204 E> */ B(StaCurrentContextSlot), U8(18),
/* 217 S> */ B(LdaZero),
/* 217 E> */ B(StaCurrentContextSlot), U8(19),
/* 230 S> */ B(LdaZero),
/* 230 E> */ B(StaCurrentContextSlot), U8(20),
/* 243 S> */ B(LdaZero),
/* 243 E> */ B(StaCurrentContextSlot), U8(21),
/* 256 S> */ B(LdaZero),
/* 256 E> */ B(StaCurrentContextSlot), U8(22),
/* 269 S> */ B(LdaZero),
/* 269 E> */ B(StaCurrentContextSlot), U8(23),
/* 282 S> */ B(LdaZero),
/* 282 E> */ B(StaCurrentContextSlot), U8(24),
/* 295 S> */ B(LdaZero),
/* 295 E> */ B(StaCurrentContextSlot), U8(25),
/* 308 S> */ B(LdaZero),
/* 308 E> */ B(StaCurrentContextSlot), U8(26),
/* 321 S> */ B(LdaZero),
/* 321 E> */ B(StaCurrentContextSlot), U8(27),
/* 334 S> */ B(LdaZero),
/* 334 E> */ B(StaCurrentContextSlot), U8(28),
/* 347 S> */ B(LdaZero),
/* 347 E> */ B(StaCurrentContextSlot), U8(29),
/* 360 S> */ B(LdaZero),
/* 360 E> */ B(StaCurrentContextSlot), U8(30),
/* 373 S> */ B(LdaZero),
/* 373 E> */ B(StaCurrentContextSlot), U8(31),
/* 386 S> */ B(LdaZero),
/* 386 E> */ B(StaCurrentContextSlot), U8(32),
/* 399 S> */ B(LdaZero),
/* 399 E> */ B(StaCurrentContextSlot), U8(33),
/* 412 S> */ B(LdaZero),
/* 412 E> */ B(StaCurrentContextSlot), U8(34),
/* 425 S> */ B(LdaZero),
/* 425 E> */ B(StaCurrentContextSlot), U8(35),
/* 438 S> */ B(LdaZero),
/* 438 E> */ B(StaCurrentContextSlot), U8(36),
/* 451 S> */ B(LdaZero),
/* 451 E> */ B(StaCurrentContextSlot), U8(37),
/* 464 S> */ B(LdaZero),
/* 464 E> */ B(StaCurrentContextSlot), U8(38),
/* 477 S> */ B(LdaZero),
/* 477 E> */ B(StaCurrentContextSlot), U8(39),
/* 490 S> */ B(LdaZero),
/* 490 E> */ B(StaCurrentContextSlot), U8(40),
/* 503 S> */ B(LdaZero),
/* 503 E> */ B(StaCurrentContextSlot), U8(41),
/* 516 S> */ B(LdaZero),
/* 516 E> */ B(StaCurrentContextSlot), U8(42),
/* 529 S> */ B(LdaZero),
/* 529 E> */ B(StaCurrentContextSlot), U8(43),
/* 542 S> */ B(LdaZero),
/* 542 E> */ B(StaCurrentContextSlot), U8(44),
/* 555 S> */ B(LdaZero),
/* 555 E> */ B(StaCurrentContextSlot), U8(45),
/* 568 S> */ B(LdaZero),
/* 568 E> */ B(StaCurrentContextSlot), U8(46),
/* 581 S> */ B(LdaZero),
/* 581 E> */ B(StaCurrentContextSlot), U8(47),
/* 594 S> */ B(LdaZero),
/* 594 E> */ B(StaCurrentContextSlot), U8(48),
/* 607 S> */ B(LdaZero),
/* 607 E> */ B(StaCurrentContextSlot), U8(49),
/* 620 S> */ B(LdaZero),
/* 620 E> */ B(StaCurrentContextSlot), U8(50),
/* 633 S> */ B(LdaZero),
/* 633 E> */ B(StaCurrentContextSlot), U8(51),
/* 646 S> */ B(LdaZero),
/* 646 E> */ B(StaCurrentContextSlot), U8(52),
/* 659 S> */ B(LdaZero),
/* 659 E> */ B(StaCurrentContextSlot), U8(53),
/* 672 S> */ B(LdaZero),
/* 672 E> */ B(StaCurrentContextSlot), U8(54),
/* 685 S> */ B(LdaZero),
/* 685 E> */ B(StaCurrentContextSlot), U8(55),
/* 698 S> */ B(LdaZero),
/* 698 E> */ B(StaCurrentContextSlot), U8(56),
/* 711 S> */ B(LdaZero),
/* 711 E> */ B(StaCurrentContextSlot), U8(57),
/* 724 S> */ B(LdaZero),
/* 724 E> */ B(StaCurrentContextSlot), U8(58),
/* 737 S> */ B(LdaZero),
/* 737 E> */ B(StaCurrentContextSlot), U8(59),
/* 750 S> */ B(LdaZero),
/* 750 E> */ B(StaCurrentContextSlot), U8(60),
/* 763 S> */ B(LdaZero),
/* 763 E> */ B(StaCurrentContextSlot), U8(61),
/* 776 S> */ B(LdaZero),
/* 776 E> */ B(StaCurrentContextSlot), U8(62),
/* 789 S> */ B(LdaZero),
/* 789 E> */ B(StaCurrentContextSlot), U8(63),
/* 802 S> */ B(LdaZero),
/* 802 E> */ B(StaCurrentContextSlot), U8(64),
/* 815 S> */ B(LdaZero),
/* 815 E> */ B(StaCurrentContextSlot), U8(65),
/* 828 S> */ B(LdaZero),
/* 828 E> */ B(StaCurrentContextSlot), U8(66),
/* 841 S> */ B(LdaZero),
/* 841 E> */ B(StaCurrentContextSlot), U8(67),
/* 854 S> */ B(LdaZero),
/* 854 E> */ B(StaCurrentContextSlot), U8(68),
/* 867 S> */ B(LdaZero),
/* 867 E> */ B(StaCurrentContextSlot), U8(69),
/* 880 S> */ B(LdaZero),
/* 880 E> */ B(StaCurrentContextSlot), U8(70),
/* 893 S> */ B(LdaZero),
/* 893 E> */ B(StaCurrentContextSlot), U8(71),
/* 906 S> */ B(LdaZero),
/* 906 E> */ B(StaCurrentContextSlot), U8(72),
/* 919 S> */ B(LdaZero),
/* 919 E> */ B(StaCurrentContextSlot), U8(73),
/* 932 S> */ B(LdaZero),
/* 932 E> */ B(StaCurrentContextSlot), U8(74),
/* 945 S> */ B(LdaZero),
/* 945 E> */ B(StaCurrentContextSlot), U8(75),
/* 958 S> */ B(LdaZero),
/* 958 E> */ B(StaCurrentContextSlot), U8(76),
/* 971 S> */ B(LdaZero),
/* 971 E> */ B(StaCurrentContextSlot), U8(77),
/* 984 S> */ B(LdaZero),
/* 984 E> */ B(StaCurrentContextSlot), U8(78),
/* 997 S> */ B(LdaZero),
/* 997 E> */ B(StaCurrentContextSlot), U8(79),
/* 1010 S> */ B(LdaZero),
/* 1010 E> */ B(StaCurrentContextSlot), U8(80),
/* 1023 S> */ B(LdaZero),
/* 1023 E> */ B(StaCurrentContextSlot), U8(81),
/* 1036 S> */ B(LdaZero),
/* 1036 E> */ B(StaCurrentContextSlot), U8(82),
/* 1049 S> */ B(LdaZero),
/* 1049 E> */ B(StaCurrentContextSlot), U8(83),
/* 1062 S> */ B(LdaZero),
/* 1062 E> */ B(StaCurrentContextSlot), U8(84),
/* 1075 S> */ B(LdaZero),
/* 1075 E> */ B(StaCurrentContextSlot), U8(85),
/* 1088 S> */ B(LdaZero),
/* 1088 E> */ B(StaCurrentContextSlot), U8(86),
/* 1101 S> */ B(LdaZero),
/* 1101 E> */ B(StaCurrentContextSlot), U8(87),
/* 1114 S> */ B(LdaZero),
/* 1114 E> */ B(StaCurrentContextSlot), U8(88),
/* 1127 S> */ B(LdaZero),
/* 1127 E> */ B(StaCurrentContextSlot), U8(89),
/* 1140 S> */ B(LdaZero),
/* 1140 E> */ B(StaCurrentContextSlot), U8(90),
/* 1153 S> */ B(LdaZero),
/* 1153 E> */ B(StaCurrentContextSlot), U8(91),
/* 1166 S> */ B(LdaZero),
/* 1166 E> */ B(StaCurrentContextSlot), U8(92),
/* 1179 S> */ B(LdaZero),
/* 1179 E> */ B(StaCurrentContextSlot), U8(93),
/* 1192 S> */ B(LdaZero),
/* 1192 E> */ B(StaCurrentContextSlot), U8(94),
/* 1205 S> */ B(LdaZero),
/* 1205 E> */ B(StaCurrentContextSlot), U8(95),
/* 1218 S> */ B(LdaZero),
/* 1218 E> */ B(StaCurrentContextSlot), U8(96),
/* 1231 S> */ B(LdaZero),
/* 1231 E> */ B(StaCurrentContextSlot), U8(97),
/* 1244 S> */ B(LdaZero),
/* 1244 E> */ B(StaCurrentContextSlot), U8(98),
/* 1257 S> */ B(LdaZero),
/* 1257 E> */ B(StaCurrentContextSlot), U8(99),
/* 1270 S> */ B(LdaZero),
/* 1270 E> */ B(StaCurrentContextSlot), U8(100),
/* 1283 S> */ B(LdaZero),
/* 1283 E> */ B(StaCurrentContextSlot), U8(101),
/* 1296 S> */ B(LdaZero),
/* 1296 E> */ B(StaCurrentContextSlot), U8(102),
/* 1309 S> */ B(LdaZero),
/* 1309 E> */ B(StaCurrentContextSlot), U8(103),
/* 1322 S> */ B(LdaZero),
/* 1322 E> */ B(StaCurrentContextSlot), U8(104),
/* 1335 S> */ B(LdaZero),
/* 1335 E> */ B(StaCurrentContextSlot), U8(105),
/* 1349 S> */ B(LdaZero),
/* 1349 E> */ B(StaCurrentContextSlot), U8(106),
/* 1363 S> */ B(LdaZero),
/* 1363 E> */ B(StaCurrentContextSlot), U8(107),
/* 1377 S> */ B(LdaZero),
/* 1377 E> */ B(StaCurrentContextSlot), U8(108),
/* 1391 S> */ B(LdaZero),
/* 1391 E> */ B(StaCurrentContextSlot), U8(109),
/* 1405 S> */ B(LdaZero),
/* 1405 E> */ B(StaCurrentContextSlot), U8(110),
/* 1419 S> */ B(LdaZero),
/* 1419 E> */ B(StaCurrentContextSlot), U8(111),
/* 1433 S> */ B(LdaZero),
/* 1433 E> */ B(StaCurrentContextSlot), U8(112),
/* 1447 S> */ B(LdaZero),
/* 1447 E> */ B(StaCurrentContextSlot), U8(113),
/* 1461 S> */ B(LdaZero),
/* 1461 E> */ B(StaCurrentContextSlot), U8(114),
/* 1475 S> */ B(LdaZero),
/* 1475 E> */ B(StaCurrentContextSlot), U8(115),
/* 1489 S> */ B(LdaZero),
/* 1489 E> */ B(StaCurrentContextSlot), U8(116),
/* 1503 S> */ B(LdaZero),
/* 1503 E> */ B(StaCurrentContextSlot), U8(117),
/* 1517 S> */ B(LdaZero),
/* 1517 E> */ B(StaCurrentContextSlot), U8(118),
/* 1531 S> */ B(LdaZero),
/* 1531 E> */ B(StaCurrentContextSlot), U8(119),
/* 1545 S> */ B(LdaZero),
/* 1545 E> */ B(StaCurrentContextSlot), U8(120),
/* 1559 S> */ B(LdaZero),
/* 1559 E> */ B(StaCurrentContextSlot), U8(121),
/* 1573 S> */ B(LdaZero),
/* 1573 E> */ B(StaCurrentContextSlot), U8(122),
/* 1587 S> */ B(LdaZero),
/* 1587 E> */ B(StaCurrentContextSlot), U8(123),
/* 1601 S> */ B(LdaZero),
/* 1601 E> */ B(StaCurrentContextSlot), U8(124),
/* 1615 S> */ B(LdaZero),
/* 1615 E> */ B(StaCurrentContextSlot), U8(125),
/* 1629 S> */ B(LdaZero),
/* 1629 E> */ B(StaCurrentContextSlot), U8(126),
/* 1643 S> */ B(LdaZero),
/* 1643 E> */ B(StaCurrentContextSlot), U8(127),
/* 1657 S> */ B(LdaZero),
/* 1657 E> */ B(StaCurrentContextSlot), U8(128),
/* 1671 S> */ B(LdaZero),
/* 1671 E> */ B(StaCurrentContextSlot), U8(129),
/* 1685 S> */ B(LdaZero),
/* 1685 E> */ B(StaCurrentContextSlot), U8(130),
/* 1699 S> */ B(LdaZero),
/* 1699 E> */ B(StaCurrentContextSlot), U8(131),
/* 1713 S> */ B(LdaZero),
/* 1713 E> */ B(StaCurrentContextSlot), U8(132),
/* 1727 S> */ B(LdaZero),
/* 1727 E> */ B(StaCurrentContextSlot), U8(133),
/* 1741 S> */ B(LdaZero),
/* 1741 E> */ B(StaCurrentContextSlot), U8(134),
/* 1755 S> */ B(LdaZero),
/* 1755 E> */ B(StaCurrentContextSlot), U8(135),
/* 1769 S> */ B(LdaZero),
/* 1769 E> */ B(StaCurrentContextSlot), U8(136),
/* 1783 S> */ B(LdaZero),
/* 1783 E> */ B(StaCurrentContextSlot), U8(137),
/* 1797 S> */ B(LdaZero),
/* 1797 E> */ B(StaCurrentContextSlot), U8(138),
/* 1811 S> */ B(LdaZero),
/* 1811 E> */ B(StaCurrentContextSlot), U8(139),
/* 1825 S> */ B(LdaZero),
/* 1825 E> */ B(StaCurrentContextSlot), U8(140),
/* 1839 S> */ B(LdaZero),
/* 1839 E> */ B(StaCurrentContextSlot), U8(141),
/* 1853 S> */ B(LdaZero),
/* 1853 E> */ B(StaCurrentContextSlot), U8(142),
/* 1867 S> */ B(LdaZero),
/* 1867 E> */ B(StaCurrentContextSlot), U8(143),
/* 1881 S> */ B(LdaZero),
/* 1881 E> */ B(StaCurrentContextSlot), U8(144),
/* 1895 S> */ B(LdaZero),
/* 1895 E> */ B(StaCurrentContextSlot), U8(145),
/* 1909 S> */ B(LdaZero),
/* 1909 E> */ B(StaCurrentContextSlot), U8(146),
/* 1923 S> */ B(LdaZero),
/* 1923 E> */ B(StaCurrentContextSlot), U8(147),
/* 1937 S> */ B(LdaZero),
/* 1937 E> */ B(StaCurrentContextSlot), U8(148),
/* 1951 S> */ B(LdaZero),
/* 1951 E> */ B(StaCurrentContextSlot), U8(149),
/* 1965 S> */ B(LdaZero),
/* 1965 E> */ B(StaCurrentContextSlot), U8(150),
/* 1979 S> */ B(LdaZero),
/* 1979 E> */ B(StaCurrentContextSlot), U8(151),
/* 1993 S> */ B(LdaZero),
/* 1993 E> */ B(StaCurrentContextSlot), U8(152),
/* 2007 S> */ B(LdaZero),
/* 2007 E> */ B(StaCurrentContextSlot), U8(153),
/* 2021 S> */ B(LdaZero),
/* 2021 E> */ B(StaCurrentContextSlot), U8(154),
/* 2035 S> */ B(LdaZero),
/* 2035 E> */ B(StaCurrentContextSlot), U8(155),
/* 2049 S> */ B(LdaZero),
/* 2049 E> */ B(StaCurrentContextSlot), U8(156),
/* 2063 S> */ B(LdaZero),
/* 2063 E> */ B(StaCurrentContextSlot), U8(157),
/* 2077 S> */ B(LdaZero),
/* 2077 E> */ B(StaCurrentContextSlot), U8(158),
/* 2091 S> */ B(LdaZero),
/* 2091 E> */ B(StaCurrentContextSlot), U8(159),
/* 2105 S> */ B(LdaZero),
/* 2105 E> */ B(StaCurrentContextSlot), U8(160),
/* 2119 S> */ B(LdaZero),
/* 2119 E> */ B(StaCurrentContextSlot), U8(161),
/* 2133 S> */ B(LdaZero),
/* 2133 E> */ B(StaCurrentContextSlot), U8(162),
/* 2147 S> */ B(LdaZero),
/* 2147 E> */ B(StaCurrentContextSlot), U8(163),
/* 2161 S> */ B(LdaZero),
/* 2161 E> */ B(StaCurrentContextSlot), U8(164),
/* 2175 S> */ B(LdaZero),
/* 2175 E> */ B(StaCurrentContextSlot), U8(165),
/* 2189 S> */ B(LdaZero),
/* 2189 E> */ B(StaCurrentContextSlot), U8(166),
/* 2203 S> */ B(LdaZero),
/* 2203 E> */ B(StaCurrentContextSlot), U8(167),
/* 2217 S> */ B(LdaZero),
/* 2217 E> */ B(StaCurrentContextSlot), U8(168),
/* 2231 S> */ B(LdaZero),
/* 2231 E> */ B(StaCurrentContextSlot), U8(169),
/* 2245 S> */ B(LdaZero),
/* 2245 E> */ B(StaCurrentContextSlot), U8(170),
/* 2259 S> */ B(LdaZero),
/* 2259 E> */ B(StaCurrentContextSlot), U8(171),
/* 2273 S> */ B(LdaZero),
/* 2273 E> */ B(StaCurrentContextSlot), U8(172),
/* 2287 S> */ B(LdaZero),
/* 2287 E> */ B(StaCurrentContextSlot), U8(173),
/* 2301 S> */ B(LdaZero),
/* 2301 E> */ B(StaCurrentContextSlot), U8(174),
/* 2315 S> */ B(LdaZero),
/* 2315 E> */ B(StaCurrentContextSlot), U8(175),
/* 2329 S> */ B(LdaZero),
/* 2329 E> */ B(StaCurrentContextSlot), U8(176),
/* 2343 S> */ B(LdaZero),
/* 2343 E> */ B(StaCurrentContextSlot), U8(177),
/* 2357 S> */ B(LdaZero),
/* 2357 E> */ B(StaCurrentContextSlot), U8(178),
/* 2371 S> */ B(LdaZero),
/* 2371 E> */ B(StaCurrentContextSlot), U8(179),
/* 2385 S> */ B(LdaZero),
/* 2385 E> */ B(StaCurrentContextSlot), U8(180),
/* 2399 S> */ B(LdaZero),
/* 2399 E> */ B(StaCurrentContextSlot), U8(181),
/* 2413 S> */ B(LdaZero),
/* 2413 E> */ B(StaCurrentContextSlot), U8(182),
/* 2427 S> */ B(LdaZero),
/* 2427 E> */ B(StaCurrentContextSlot), U8(183),
/* 2441 S> */ B(LdaZero),
/* 2441 E> */ B(StaCurrentContextSlot), U8(184),
/* 2455 S> */ B(LdaZero),
/* 2455 E> */ B(StaCurrentContextSlot), U8(185),
/* 2469 S> */ B(LdaZero),
/* 2469 E> */ B(StaCurrentContextSlot), U8(186),
/* 2483 S> */ B(LdaZero),
/* 2483 E> */ B(StaCurrentContextSlot), U8(187),
/* 2497 S> */ B(LdaZero),
/* 2497 E> */ B(StaCurrentContextSlot), U8(188),
/* 2511 S> */ B(LdaZero),
/* 2511 E> */ B(StaCurrentContextSlot), U8(189),
/* 2525 S> */ B(LdaZero),
/* 2525 E> */ B(StaCurrentContextSlot), U8(190),
/* 2539 S> */ B(LdaZero),
/* 2539 E> */ B(StaCurrentContextSlot), U8(191),
/* 2553 S> */ B(LdaZero),
/* 2553 E> */ B(StaCurrentContextSlot), U8(192),
/* 2567 S> */ B(LdaZero),
/* 2567 E> */ B(StaCurrentContextSlot), U8(193),
/* 2581 S> */ B(LdaZero),
/* 2581 E> */ B(StaCurrentContextSlot), U8(194),
/* 2595 S> */ B(LdaZero),
/* 2595 E> */ B(StaCurrentContextSlot), U8(195),
/* 2609 S> */ B(LdaZero),
/* 2609 E> */ B(StaCurrentContextSlot), U8(196),
/* 2623 S> */ B(LdaZero),
/* 2623 E> */ B(StaCurrentContextSlot), U8(197),
/* 2637 S> */ B(LdaZero),
/* 2637 E> */ B(StaCurrentContextSlot), U8(198),
/* 2651 S> */ B(LdaZero),
/* 2651 E> */ B(StaCurrentContextSlot), U8(199),
/* 2665 S> */ B(LdaZero),
/* 2665 E> */ B(StaCurrentContextSlot), U8(200),
/* 2679 S> */ B(LdaZero),
/* 2679 E> */ B(StaCurrentContextSlot), U8(201),
/* 2693 S> */ B(LdaZero),
/* 2693 E> */ B(StaCurrentContextSlot), U8(202),
/* 2707 S> */ B(LdaZero),
/* 2707 E> */ B(StaCurrentContextSlot), U8(203),
/* 2721 S> */ B(LdaZero),
/* 2721 E> */ B(StaCurrentContextSlot), U8(204),
/* 2735 S> */ B(LdaZero),
/* 2735 E> */ B(StaCurrentContextSlot), U8(205),
/* 2749 S> */ B(LdaZero),
/* 2749 E> */ B(StaCurrentContextSlot), U8(206),
/* 2763 S> */ B(LdaZero),
/* 2763 E> */ B(StaCurrentContextSlot), U8(207),
/* 2777 S> */ B(LdaZero),
/* 2777 E> */ B(StaCurrentContextSlot), U8(208),
/* 2791 S> */ B(LdaZero),
/* 2791 E> */ B(StaCurrentContextSlot), U8(209),
/* 2805 S> */ B(LdaZero),
/* 2805 E> */ B(StaCurrentContextSlot), U8(210),
/* 2819 S> */ B(LdaZero),
/* 2819 E> */ B(StaCurrentContextSlot), U8(211),
/* 2833 S> */ B(LdaZero),
/* 2833 E> */ B(StaCurrentContextSlot), U8(212),
/* 2847 S> */ B(LdaZero),
/* 2847 E> */ B(StaCurrentContextSlot), U8(213),
/* 2861 S> */ B(LdaZero),
/* 2861 E> */ B(StaCurrentContextSlot), U8(214),
/* 2875 S> */ B(LdaZero),
/* 2875 E> */ B(StaCurrentContextSlot), U8(215),
/* 2889 S> */ B(LdaZero),
/* 2889 E> */ B(StaCurrentContextSlot), U8(216),
/* 2903 S> */ B(LdaZero),
/* 2903 E> */ B(StaCurrentContextSlot), U8(217),
/* 2917 S> */ B(LdaZero),
/* 2917 E> */ B(StaCurrentContextSlot), U8(218),
/* 2931 S> */ B(LdaZero),
/* 2931 E> */ B(StaCurrentContextSlot), U8(219),
/* 2945 S> */ B(LdaZero),
/* 2945 E> */ B(StaCurrentContextSlot), U8(220),
/* 2959 S> */ B(LdaZero),
/* 2959 E> */ B(StaCurrentContextSlot), U8(221),
/* 2973 S> */ B(LdaZero),
/* 2973 E> */ B(StaCurrentContextSlot), U8(222),
/* 2987 S> */ B(LdaZero),
/* 2987 E> */ B(StaCurrentContextSlot), U8(223),
/* 3001 S> */ B(LdaZero),
/* 3001 E> */ B(StaCurrentContextSlot), U8(224),
/* 3015 S> */ B(LdaZero),
/* 3015 E> */ B(StaCurrentContextSlot), U8(225),
/* 3029 S> */ B(LdaZero),
/* 3029 E> */ B(StaCurrentContextSlot), U8(226),
/* 3043 S> */ B(LdaZero),
/* 3043 E> */ B(StaCurrentContextSlot), U8(227),
/* 3057 S> */ B(LdaZero),
/* 3057 E> */ B(StaCurrentContextSlot), U8(228),
/* 3071 S> */ B(LdaZero),
/* 3071 E> */ B(StaCurrentContextSlot), U8(229),
/* 3085 S> */ B(LdaZero),
/* 3085 E> */ B(StaCurrentContextSlot), U8(230),
/* 3099 S> */ B(LdaZero),
/* 3099 E> */ B(StaCurrentContextSlot), U8(231),
/* 3113 S> */ B(LdaZero),
/* 3113 E> */ B(StaCurrentContextSlot), U8(232),
/* 3127 S> */ B(LdaZero),
/* 3127 E> */ B(StaCurrentContextSlot), U8(233),
/* 3141 S> */ B(LdaZero),
/* 3141 E> */ B(StaCurrentContextSlot), U8(234),
/* 3155 S> */ B(LdaZero),
/* 3155 E> */ B(StaCurrentContextSlot), U8(235),
/* 3169 S> */ B(LdaZero),
/* 3169 E> */ B(StaCurrentContextSlot), U8(236),
/* 3183 S> */ B(LdaZero),
/* 3183 E> */ B(StaCurrentContextSlot), U8(237),
/* 3197 S> */ B(LdaZero),
/* 3197 E> */ B(StaCurrentContextSlot), U8(238),
/* 3211 S> */ B(LdaZero),
/* 3211 E> */ B(StaCurrentContextSlot), U8(239),
/* 3225 S> */ B(LdaZero),
/* 3225 E> */ B(StaCurrentContextSlot), U8(240),
/* 3239 S> */ B(LdaZero),
/* 3239 E> */ B(StaCurrentContextSlot), U8(241),
/* 3253 S> */ B(LdaZero),
/* 3253 E> */ B(StaCurrentContextSlot), U8(242),
/* 3267 S> */ B(LdaZero),
/* 3267 E> */ B(StaCurrentContextSlot), U8(243),
/* 3281 S> */ B(LdaZero),
/* 3281 E> */ B(StaCurrentContextSlot), U8(244),
/* 3295 S> */ B(LdaZero),
/* 3295 E> */ B(StaCurrentContextSlot), U8(245),
/* 3309 S> */ B(LdaZero),
/* 3309 E> */ B(StaCurrentContextSlot), U8(246),
/* 3323 S> */ B(LdaZero),
/* 3323 E> */ B(StaCurrentContextSlot), U8(247),
/* 3337 S> */ B(LdaZero),
/* 3337 E> */ B(StaCurrentContextSlot), U8(248),
/* 3351 S> */ B(LdaZero),
/* 3351 E> */ B(StaCurrentContextSlot), U8(249),
/* 3365 S> */ B(LdaZero),
/* 3365 E> */ B(StaCurrentContextSlot), U8(250),
/* 3379 S> */ B(LdaZero),
/* 3379 E> */ B(StaCurrentContextSlot), U8(251),
/* 3393 S> */ B(LdaZero),
/* 3393 E> */ B(StaCurrentContextSlot), U8(252),
/* 3407 S> */ B(LdaZero),
/* 3407 E> */ B(StaCurrentContextSlot), U8(253),
/* 3421 S> */ B(LdaZero),
/* 3421 E> */ B(StaCurrentContextSlot), U8(254),
/* 3435 S> */ B(LdaZero),
/* 3435 E> */ B(StaCurrentContextSlot), U8(255),
/* 3438 S> */ B(LdaGlobal), U8(0), U8(6),
B(Star), R(1),
/* 3438 E> */ B(CallUndefinedReceiver0), R(1), U8(4),
/* 3454 S> */ B(LdaSmi), I8(100),
/* 3454 E> */ B(Wide), B(StaCurrentContextSlot), U16(256),
/* 3459 S> */ B(Wide), B(LdaCurrentContextSlot), U16(256),
[inspector] improve return position of explicit return in non-async function Goal of this CL: explicit return from non-async function has position after return expression as return position (will unblock [1]). BytecodeArrayBuilder has SetStatementPosition and SetExpressionPosition methods. If one of these methods is called then next generated bytecode will get passed position. It's general treatment for most cases. Unfortunately it doesn't work for Returns: - debugger requires source positions exactly on kReturn bytecode in stepping implementation, - BytecodeGenerator::BuildReturn and BytecodeGenerator::BuildAsyncReturn generates more then one bytecode and general solution will put return position on first generated bytecode, - it's not easy to split BuildReturn function into two parts to allow something like following in BytecodeGenerator::VisitReturnStatement since generated bytecodes are actually controlled by execution_control(). ..->BuildReturnPrologue(); ..->SetReturnPosition(stmt); ..->Return(); In this CL we pass ReturnStatement through ExecutionControl and use it for position when we emit return bytecode right here. So this CL only will improve return position for returns inside of non-async functions, I'll address async functions later. [1] https://chromium-review.googlesource.com/c/543161/ Change-Id: Iede512c120b00c209990bf50c20e7d23dc0d65db Reviewed-on: https://chromium-review.googlesource.com/560738 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Reviewed-by: Jakob Gruber <jgruber@chromium.org> Cr-Commit-Position: refs/heads/master@{#46687}
2017-07-14 17:50:09 +00:00
/* 3467 S> */ B(Return),
]
constant pool: [
ONE_BYTE_INTERNALIZED_STRING_TYPE ["eval"],
]
handlers: [
]