Line data Source code
1 : // Copyright 2016 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/v8.h"
6 :
7 : #include "src/api.h"
8 : #include "src/heap/factory.h"
9 : #include "src/interpreter/bytecode-array-writer.h"
10 : #include "src/interpreter/bytecode-label.h"
11 : #include "src/interpreter/bytecode-node.h"
12 : #include "src/interpreter/bytecode-register.h"
13 : #include "src/interpreter/bytecode-source-info.h"
14 : #include "src/interpreter/constant-array-builder.h"
15 : #include "src/isolate.h"
16 : #include "src/objects-inl.h"
17 : #include "src/source-position-table.h"
18 : #include "src/utils.h"
19 : #include "test/unittests/interpreter/bytecode-utils.h"
20 : #include "test/unittests/test-utils.h"
21 :
22 : namespace v8 {
23 : namespace internal {
24 : namespace interpreter {
25 : namespace bytecode_array_writer_unittest {
26 :
27 : #define B(Name) static_cast<uint8_t>(Bytecode::k##Name)
28 : #define R(i) static_cast<uint32_t>(Register(i).ToOperand())
29 :
30 : class BytecodeArrayWriterUnittest : public TestWithIsolateAndZone {
31 : public:
32 4 : BytecodeArrayWriterUnittest()
33 : : constant_array_builder_(zone()),
34 : bytecode_array_writer_(
35 : zone(), &constant_array_builder_,
36 8 : SourcePositionTableBuilder::RECORD_SOURCE_POSITIONS) {}
37 12 : ~BytecodeArrayWriterUnittest() override = default;
38 :
39 : void Write(Bytecode bytecode, BytecodeSourceInfo info = BytecodeSourceInfo());
40 : void Write(Bytecode bytecode, uint32_t operand0,
41 : BytecodeSourceInfo info = BytecodeSourceInfo());
42 : void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
43 : BytecodeSourceInfo info = BytecodeSourceInfo());
44 : void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
45 : uint32_t operand2, BytecodeSourceInfo info = BytecodeSourceInfo());
46 : void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
47 : uint32_t operand2, uint32_t operand3,
48 : BytecodeSourceInfo info = BytecodeSourceInfo());
49 :
50 : void WriteJump(Bytecode bytecode, BytecodeLabel* label,
51 : BytecodeSourceInfo info = BytecodeSourceInfo());
52 : void WriteJumpLoop(Bytecode bytecode, BytecodeLoopHeader* loop_header,
53 : int depth, BytecodeSourceInfo info = BytecodeSourceInfo());
54 :
55 41 : BytecodeArrayWriter* writer() { return &bytecode_array_writer_; }
56 : ZoneVector<unsigned char>* bytecodes() { return writer()->bytecodes(); }
57 : SourcePositionTableBuilder* source_position_table_builder() {
58 : return writer()->source_position_table_builder();
59 : }
60 :
61 : private:
62 : ConstantArrayBuilder constant_array_builder_;
63 : BytecodeArrayWriter bytecode_array_writer_;
64 : };
65 :
66 0 : void BytecodeArrayWriterUnittest::Write(Bytecode bytecode,
67 : BytecodeSourceInfo info) {
68 : BytecodeNode node(bytecode, info);
69 16 : writer()->Write(&node);
70 0 : }
71 :
72 23 : void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
73 : BytecodeSourceInfo info) {
74 : BytecodeNode node(bytecode, operand0, info);
75 23 : writer()->Write(&node);
76 23 : }
77 :
78 3 : void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
79 : uint32_t operand1,
80 : BytecodeSourceInfo info) {
81 : BytecodeNode node(bytecode, operand0, operand1, info);
82 3 : writer()->Write(&node);
83 3 : }
84 :
85 0 : void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
86 : uint32_t operand1, uint32_t operand2,
87 : BytecodeSourceInfo info) {
88 : BytecodeNode node(bytecode, operand0, operand1, operand2, info);
89 0 : writer()->Write(&node);
90 0 : }
91 :
92 1 : void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
93 : uint32_t operand1, uint32_t operand2,
94 : uint32_t operand3,
95 : BytecodeSourceInfo info) {
96 : BytecodeNode node(bytecode, operand0, operand1, operand2, operand3, info);
97 1 : writer()->Write(&node);
98 1 : }
99 :
100 9 : void BytecodeArrayWriterUnittest::WriteJump(Bytecode bytecode,
101 : BytecodeLabel* label,
102 : BytecodeSourceInfo info) {
103 : BytecodeNode node(bytecode, 0, info);
104 9 : writer()->WriteJump(&node, label);
105 9 : }
106 :
107 1 : void BytecodeArrayWriterUnittest::WriteJumpLoop(Bytecode bytecode,
108 : BytecodeLoopHeader* loop_header,
109 : int depth,
110 : BytecodeSourceInfo info) {
111 1 : BytecodeNode node(bytecode, 0, depth, info);
112 1 : writer()->WriteJumpLoop(&node, loop_header);
113 1 : }
114 :
115 15418 : TEST_F(BytecodeArrayWriterUnittest, SimpleExample) {
116 1 : CHECK_EQ(bytecodes()->size(), 0u);
117 :
118 : Write(Bytecode::kStackCheck, {10, false});
119 1 : CHECK_EQ(bytecodes()->size(), 1u);
120 :
121 1 : Write(Bytecode::kLdaSmi, 127, {55, true});
122 1 : CHECK_EQ(bytecodes()->size(), 3u);
123 :
124 1 : Write(Bytecode::kStar, Register(20).ToOperand());
125 1 : CHECK_EQ(bytecodes()->size(), 5u);
126 :
127 1 : Write(Bytecode::kLdar, Register(200).ToOperand());
128 1 : CHECK_EQ(bytecodes()->size(), 9u);
129 :
130 : Write(Bytecode::kReturn, {70, true});
131 1 : CHECK_EQ(bytecodes()->size(), 10u);
132 :
133 : static const uint8_t expected_bytes[] = {
134 : // clang-format off
135 : /* 0 10 E> */ B(StackCheck),
136 : /* 1 55 S> */ B(LdaSmi), U8(127),
137 : /* 3 */ B(Star), R8(20),
138 : /* 5 */ B(Wide), B(Ldar), R16(200),
139 : /* 9 70 S> */ B(Return),
140 : // clang-format on
141 : };
142 1 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
143 21 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
144 20 : CHECK_EQ(bytecodes()->at(i), expected_bytes[i]);
145 : }
146 :
147 : Handle<BytecodeArray> bytecode_array =
148 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
149 1 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
150 :
151 : PositionTableEntry expected_positions[] = {
152 : {0, 10, false}, {1, 55, true}, {9, 70, true}};
153 : SourcePositionTableIterator source_iterator(
154 1 : bytecode_array->SourcePositionTable());
155 7 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
156 : const PositionTableEntry& expected = expected_positions[i];
157 3 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
158 6 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
159 : expected.source_position);
160 3 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
161 3 : source_iterator.Advance();
162 : }
163 1 : CHECK(source_iterator.done());
164 1 : }
165 :
166 15418 : TEST_F(BytecodeArrayWriterUnittest, ComplexExample) {
167 : static const uint8_t expected_bytes[] = {
168 : // clang-format off
169 : /* 0 30 E> */ B(StackCheck),
170 : /* 1 42 S> */ B(LdaConstant), U8(0),
171 : /* 3 42 E> */ B(Add), R8(1), U8(1),
172 : /* 5 68 S> */ B(JumpIfUndefined), U8(39),
173 : /* 7 */ B(JumpIfNull), U8(37),
174 : /* 9 */ B(ToObject), R8(3),
175 : /* 11 */ B(ForInPrepare), R8(3), U8(4),
176 : /* 14 */ B(LdaZero),
177 : /* 15 */ B(Star), R8(7),
178 : /* 17 63 S> */ B(ForInContinue), R8(7), R8(6),
179 : /* 20 */ B(JumpIfFalse), U8(24),
180 : /* 22 */ B(ForInNext), R8(3), R8(7), R8(4), U8(1),
181 : /* 27 */ B(JumpIfUndefined), U8(10),
182 : /* 29 */ B(Star), R8(0),
183 : /* 31 54 E> */ B(StackCheck),
184 : /* 32 */ B(Ldar), R8(0),
185 : /* 34 */ B(Star), R8(2),
186 : /* 36 85 S> */ B(Return),
187 : /* 37 */ B(ForInStep), R8(7),
188 : /* 39 */ B(Star), R8(7),
189 : /* 41 */ B(JumpLoop), U8(24), U8(0),
190 : /* 44 */ B(LdaUndefined),
191 : /* 45 85 S> */ B(Return),
192 : // clang-format on
193 : };
194 :
195 : static const PositionTableEntry expected_positions[] = {
196 : {0, 30, false}, {1, 42, true}, {3, 42, false}, {6, 68, true},
197 2 : {18, 63, true}, {32, 54, false}, {37, 85, true}, {46, 85, true}};
198 :
199 : BytecodeLoopHeader loop_header;
200 : BytecodeLabel jump_for_in, jump_end_1, jump_end_2, jump_end_3;
201 :
202 : Write(Bytecode::kStackCheck, {30, false});
203 1 : Write(Bytecode::kLdaConstant, U8(0), {42, true});
204 1 : Write(Bytecode::kAdd, R(1), U8(1), {42, false});
205 1 : WriteJump(Bytecode::kJumpIfUndefined, &jump_end_1, {68, true});
206 1 : WriteJump(Bytecode::kJumpIfNull, &jump_end_2);
207 1 : Write(Bytecode::kToObject, R(3));
208 1 : Write(Bytecode::kForInPrepare, R(3), U8(4));
209 : Write(Bytecode::kLdaZero);
210 1 : Write(Bytecode::kStar, R(7));
211 1 : writer()->BindLoopHeader(&loop_header);
212 1 : Write(Bytecode::kForInContinue, R(7), R(6), {63, true});
213 1 : WriteJump(Bytecode::kJumpIfFalse, &jump_end_3);
214 1 : Write(Bytecode::kForInNext, R(3), R(7), R(4), U8(1));
215 1 : WriteJump(Bytecode::kJumpIfUndefined, &jump_for_in);
216 1 : Write(Bytecode::kStar, R(0));
217 : Write(Bytecode::kStackCheck, {54, false});
218 1 : Write(Bytecode::kLdar, R(0));
219 1 : Write(Bytecode::kStar, R(2));
220 : Write(Bytecode::kReturn, {85, true});
221 1 : writer()->BindLabel(&jump_for_in);
222 1 : Write(Bytecode::kForInStep, R(7));
223 1 : Write(Bytecode::kStar, R(7));
224 1 : WriteJumpLoop(Bytecode::kJumpLoop, &loop_header, 0);
225 1 : writer()->BindLabel(&jump_end_1);
226 1 : writer()->BindLabel(&jump_end_2);
227 1 : writer()->BindLabel(&jump_end_3);
228 : Write(Bytecode::kLdaUndefined);
229 : Write(Bytecode::kReturn, {85, true});
230 :
231 1 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
232 95 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
233 94 : CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
234 : static_cast<int>(expected_bytes[i]));
235 : }
236 :
237 : Handle<BytecodeArray> bytecode_array =
238 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
239 : SourcePositionTableIterator source_iterator(
240 1 : bytecode_array->SourcePositionTable());
241 17 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
242 : const PositionTableEntry& expected = expected_positions[i];
243 8 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
244 16 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
245 : expected.source_position);
246 8 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
247 8 : source_iterator.Advance();
248 : }
249 1 : CHECK(source_iterator.done());
250 1 : }
251 :
252 15418 : TEST_F(BytecodeArrayWriterUnittest, ElideNoneffectfulBytecodes) {
253 1 : if (!i::FLAG_ignition_elide_noneffectful_bytecodes) return;
254 :
255 : static const uint8_t expected_bytes[] = {
256 : // clang-format off
257 : /* 0 10 E> */ B(StackCheck),
258 : /* 1 55 S> */ B(Ldar), R8(20),
259 : /* 3 */ B(Star), R8(20),
260 : /* 5 */ B(CreateMappedArguments),
261 : /* 6 60 S> */ B(LdaSmi), U8(127),
262 : /* 8 70 S> */ B(Ldar), R8(20),
263 : /* 10 75 S> */ B(Return),
264 : // clang-format on
265 : };
266 :
267 : static const PositionTableEntry expected_positions[] = {{0, 10, false},
268 : {1, 55, true},
269 : {6, 60, false},
270 : {8, 70, true},
271 2 : {10, 75, true}};
272 :
273 : Write(Bytecode::kStackCheck, {10, false});
274 1 : Write(Bytecode::kLdaSmi, 127, {55, true}); // Should be elided.
275 1 : Write(Bytecode::kLdar, Register(20).ToOperand());
276 1 : Write(Bytecode::kStar, Register(20).ToOperand());
277 1 : Write(Bytecode::kLdar, Register(20).ToOperand()); // Should be elided.
278 : Write(Bytecode::kCreateMappedArguments);
279 1 : Write(Bytecode::kLdaSmi, 127, {60, false}); // Not elided due to source info.
280 1 : Write(Bytecode::kLdar, Register(20).ToOperand(), {70, true});
281 : Write(Bytecode::kReturn, {75, true});
282 :
283 1 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
284 23 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
285 22 : CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
286 : static_cast<int>(expected_bytes[i]));
287 : }
288 :
289 : Handle<BytecodeArray> bytecode_array =
290 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
291 : SourcePositionTableIterator source_iterator(
292 1 : bytecode_array->SourcePositionTable());
293 11 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
294 : const PositionTableEntry& expected = expected_positions[i];
295 5 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
296 10 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
297 : expected.source_position);
298 5 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
299 5 : source_iterator.Advance();
300 : }
301 1 : CHECK(source_iterator.done());
302 : }
303 :
304 15418 : TEST_F(BytecodeArrayWriterUnittest, DeadcodeElimination) {
305 : static const uint8_t expected_bytes[] = {
306 : // clang-format off
307 : /* 0 10 E> */ B(StackCheck),
308 : /* 1 55 S> */ B(LdaSmi), U8(127),
309 : /* 3 */ B(Jump), U8(2),
310 : /* 5 65 S> */ B(LdaSmi), U8(127),
311 : /* 7 */ B(JumpIfFalse), U8(3),
312 : /* 9 75 S> */ B(Return),
313 : /* 10 */ B(JumpIfFalse), U8(3),
314 : /* 12 */ B(Throw),
315 : /* 13 */ B(JumpIfFalse), U8(3),
316 : /* 15 */ B(ReThrow),
317 : /* 16 */ B(Return),
318 : // clang-format on
319 : };
320 :
321 : static const PositionTableEntry expected_positions[] = {
322 2 : {0, 10, false}, {1, 55, true}, {5, 65, true}, {9, 75, true}};
323 :
324 : BytecodeLabel after_jump, after_conditional_jump, after_return, after_throw,
325 : after_rethrow;
326 :
327 : Write(Bytecode::kStackCheck, {10, false});
328 1 : Write(Bytecode::kLdaSmi, 127, {55, true});
329 1 : WriteJump(Bytecode::kJump, &after_jump);
330 1 : Write(Bytecode::kLdaSmi, 127); // Dead code.
331 1 : WriteJump(Bytecode::kJumpIfFalse, &after_conditional_jump); // Dead code.
332 1 : writer()->BindLabel(&after_jump);
333 : // We would bind the after_conditional_jump label here, but the jump to it is
334 : // dead.
335 1 : CHECK(!after_conditional_jump.has_referrer_jump());
336 1 : Write(Bytecode::kLdaSmi, 127, {65, true});
337 1 : WriteJump(Bytecode::kJumpIfFalse, &after_return);
338 : Write(Bytecode::kReturn, {75, true});
339 1 : Write(Bytecode::kLdaSmi, 127, {100, true}); // Dead code.
340 1 : writer()->BindLabel(&after_return);
341 1 : WriteJump(Bytecode::kJumpIfFalse, &after_throw);
342 : Write(Bytecode::kThrow);
343 1 : Write(Bytecode::kLdaSmi, 127); // Dead code.
344 1 : writer()->BindLabel(&after_throw);
345 1 : WriteJump(Bytecode::kJumpIfFalse, &after_rethrow);
346 : Write(Bytecode::kReThrow);
347 1 : Write(Bytecode::kLdaSmi, 127); // Dead code.
348 1 : writer()->BindLabel(&after_rethrow);
349 : Write(Bytecode::kReturn);
350 :
351 1 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
352 35 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
353 34 : CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
354 : static_cast<int>(expected_bytes[i]));
355 : }
356 :
357 : Handle<BytecodeArray> bytecode_array =
358 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
359 : SourcePositionTableIterator source_iterator(
360 1 : bytecode_array->SourcePositionTable());
361 9 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
362 : const PositionTableEntry& expected = expected_positions[i];
363 4 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
364 8 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
365 : expected.source_position);
366 4 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
367 4 : source_iterator.Advance();
368 : }
369 1 : CHECK(source_iterator.done());
370 1 : }
371 :
372 : #undef B
373 : #undef R
374 :
375 : } // namespace bytecode_array_writer_unittest
376 : } // namespace interpreter
377 : } // namespace internal
378 9249 : } // namespace v8
|
