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 4 : SourcePositionTableBuilder::RECORD_SOURCE_POSITIONS) {}
37 8 : ~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, BytecodeLabel* label, int depth,
53 : BytecodeSourceInfo info = BytecodeSourceInfo());
54 :
55 : 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 : BytecodeLabel* label, int depth,
109 : BytecodeSourceInfo info) {
110 1 : BytecodeNode node(bytecode, 0, depth, info);
111 1 : writer()->WriteJump(&node, label);
112 1 : }
113 :
114 15188 : TEST_F(BytecodeArrayWriterUnittest, SimpleExample) {
115 2 : CHECK_EQ(bytecodes()->size(), 0u);
116 :
117 : Write(Bytecode::kStackCheck, {10, false});
118 2 : CHECK_EQ(bytecodes()->size(), 1u);
119 :
120 1 : Write(Bytecode::kLdaSmi, 127, {55, true});
121 2 : CHECK_EQ(bytecodes()->size(), 3u);
122 :
123 1 : Write(Bytecode::kStar, Register(20).ToOperand());
124 2 : CHECK_EQ(bytecodes()->size(), 5u);
125 :
126 1 : Write(Bytecode::kLdar, Register(200).ToOperand());
127 2 : CHECK_EQ(bytecodes()->size(), 9u);
128 :
129 : Write(Bytecode::kReturn, {70, true});
130 2 : CHECK_EQ(bytecodes()->size(), 10u);
131 :
132 : static const uint8_t expected_bytes[] = {
133 : // clang-format off
134 : /* 0 10 E> */ B(StackCheck),
135 : /* 1 55 S> */ B(LdaSmi), U8(127),
136 : /* 3 */ B(Star), R8(20),
137 : /* 5 */ B(Wide), B(Ldar), R16(200),
138 : /* 9 70 S> */ B(Return),
139 : // clang-format on
140 : };
141 1 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
142 10 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
143 20 : CHECK_EQ(bytecodes()->at(i), expected_bytes[i]);
144 : }
145 :
146 : Handle<BytecodeArray> bytecode_array =
147 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
148 2 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
149 :
150 : PositionTableEntry expected_positions[] = {
151 : {0, 10, false}, {1, 55, true}, {9, 70, true}};
152 : SourcePositionTableIterator source_iterator(
153 1 : bytecode_array->SourcePositionTable());
154 4 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
155 3 : const PositionTableEntry& expected = expected_positions[i];
156 3 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
157 6 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
158 : expected.source_position);
159 3 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
160 3 : source_iterator.Advance();
161 : }
162 1 : CHECK(source_iterator.done());
163 1 : }
164 :
165 15188 : TEST_F(BytecodeArrayWriterUnittest, ComplexExample) {
166 : static const uint8_t expected_bytes[] = {
167 : // clang-format off
168 : /* 0 30 E> */ B(StackCheck),
169 : /* 1 42 S> */ B(LdaConstant), U8(0),
170 : /* 3 42 E> */ B(Add), R8(1), U8(1),
171 : /* 5 68 S> */ B(JumpIfUndefined), U8(39),
172 : /* 7 */ B(JumpIfNull), U8(37),
173 : /* 9 */ B(ToObject), R8(3),
174 : /* 11 */ B(ForInPrepare), R8(3), U8(4),
175 : /* 14 */ B(LdaZero),
176 : /* 15 */ B(Star), R8(7),
177 : /* 17 63 S> */ B(ForInContinue), R8(7), R8(6),
178 : /* 20 */ B(JumpIfFalse), U8(24),
179 : /* 22 */ B(ForInNext), R8(3), R8(7), R8(4), U8(1),
180 : /* 27 */ B(JumpIfUndefined), U8(10),
181 : /* 29 */ B(Star), R8(0),
182 : /* 31 54 E> */ B(StackCheck),
183 : /* 32 */ B(Ldar), R8(0),
184 : /* 34 */ B(Star), R8(2),
185 : /* 36 85 S> */ B(Return),
186 : /* 37 */ B(ForInStep), R8(7),
187 : /* 39 */ B(Star), R8(7),
188 : /* 41 */ B(JumpLoop), U8(24), U8(0),
189 : /* 44 */ B(LdaUndefined),
190 : /* 45 85 S> */ B(Return),
191 : // clang-format on
192 : };
193 :
194 : static const PositionTableEntry expected_positions[] = {
195 : {0, 30, false}, {1, 42, true}, {3, 42, false}, {6, 68, true},
196 2 : {18, 63, true}, {32, 54, false}, {37, 85, true}, {46, 85, true}};
197 :
198 : BytecodeLabel back_jump, jump_for_in, jump_end_1, jump_end_2, jump_end_3;
199 :
200 : Write(Bytecode::kStackCheck, {30, false});
201 1 : Write(Bytecode::kLdaConstant, U8(0), {42, true});
202 1 : Write(Bytecode::kAdd, R(1), U8(1), {42, false});
203 1 : WriteJump(Bytecode::kJumpIfUndefined, &jump_end_1, {68, true});
204 1 : WriteJump(Bytecode::kJumpIfNull, &jump_end_2);
205 1 : Write(Bytecode::kToObject, R(3));
206 1 : Write(Bytecode::kForInPrepare, R(3), U8(4));
207 : Write(Bytecode::kLdaZero);
208 1 : Write(Bytecode::kStar, R(7));
209 1 : writer()->BindLabel(&back_jump);
210 1 : Write(Bytecode::kForInContinue, R(7), R(6), {63, true});
211 1 : WriteJump(Bytecode::kJumpIfFalse, &jump_end_3);
212 1 : Write(Bytecode::kForInNext, R(3), R(7), R(4), U8(1));
213 1 : WriteJump(Bytecode::kJumpIfUndefined, &jump_for_in);
214 1 : Write(Bytecode::kStar, R(0));
215 : Write(Bytecode::kStackCheck, {54, false});
216 1 : Write(Bytecode::kLdar, R(0));
217 1 : Write(Bytecode::kStar, R(2));
218 : Write(Bytecode::kReturn, {85, true});
219 1 : writer()->BindLabel(&jump_for_in);
220 1 : Write(Bytecode::kForInStep, R(7));
221 1 : Write(Bytecode::kStar, R(7));
222 1 : WriteJumpLoop(Bytecode::kJumpLoop, &back_jump, 0);
223 1 : writer()->BindLabel(&jump_end_1);
224 1 : writer()->BindLabel(&jump_end_2);
225 1 : writer()->BindLabel(&jump_end_3);
226 : Write(Bytecode::kLdaUndefined);
227 : Write(Bytecode::kReturn, {85, true});
228 :
229 2 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
230 47 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
231 94 : CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
232 : static_cast<int>(expected_bytes[i]));
233 : }
234 :
235 : Handle<BytecodeArray> bytecode_array =
236 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
237 : SourcePositionTableIterator source_iterator(
238 1 : bytecode_array->SourcePositionTable());
239 9 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
240 8 : const PositionTableEntry& expected = expected_positions[i];
241 8 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
242 16 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
243 : expected.source_position);
244 8 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
245 8 : source_iterator.Advance();
246 : }
247 1 : CHECK(source_iterator.done());
248 1 : }
249 :
250 15188 : TEST_F(BytecodeArrayWriterUnittest, ElideNoneffectfulBytecodes) {
251 1 : if (!i::FLAG_ignition_elide_noneffectful_bytecodes) return;
252 :
253 : static const uint8_t expected_bytes[] = {
254 : // clang-format off
255 : /* 0 10 E> */ B(StackCheck),
256 : /* 1 55 S> */ B(Ldar), R8(20),
257 : /* 3 */ B(Star), R8(20),
258 : /* 5 */ B(CreateMappedArguments),
259 : /* 6 60 S> */ B(LdaSmi), U8(127),
260 : /* 8 70 S> */ B(Ldar), R8(20),
261 : /* 10 75 S> */ B(Return),
262 : // clang-format on
263 : };
264 :
265 : static const PositionTableEntry expected_positions[] = {{0, 10, false},
266 : {1, 55, true},
267 : {6, 60, false},
268 : {8, 70, true},
269 2 : {10, 75, true}};
270 :
271 : Write(Bytecode::kStackCheck, {10, false});
272 1 : Write(Bytecode::kLdaSmi, 127, {55, true}); // Should be elided.
273 1 : Write(Bytecode::kLdar, Register(20).ToOperand());
274 1 : Write(Bytecode::kStar, Register(20).ToOperand());
275 1 : Write(Bytecode::kLdar, Register(20).ToOperand()); // Should be elided.
276 : Write(Bytecode::kCreateMappedArguments);
277 1 : Write(Bytecode::kLdaSmi, 127, {60, false}); // Not elided due to source info.
278 1 : Write(Bytecode::kLdar, Register(20).ToOperand(), {70, true});
279 : Write(Bytecode::kReturn, {75, true});
280 :
281 2 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
282 11 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
283 22 : CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
284 : static_cast<int>(expected_bytes[i]));
285 : }
286 :
287 : Handle<BytecodeArray> bytecode_array =
288 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
289 : SourcePositionTableIterator source_iterator(
290 1 : bytecode_array->SourcePositionTable());
291 6 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
292 5 : const PositionTableEntry& expected = expected_positions[i];
293 5 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
294 10 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
295 : expected.source_position);
296 5 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
297 5 : source_iterator.Advance();
298 : }
299 1 : CHECK(source_iterator.done());
300 : }
301 :
302 15188 : TEST_F(BytecodeArrayWriterUnittest, DeadcodeElimination) {
303 : static const uint8_t expected_bytes[] = {
304 : // clang-format off
305 : /* 0 10 E> */ B(StackCheck),
306 : /* 1 55 S> */ B(LdaSmi), U8(127),
307 : /* 3 */ B(Jump), U8(2),
308 : /* 5 65 S> */ B(LdaSmi), U8(127),
309 : /* 7 */ B(JumpIfFalse), U8(3),
310 : /* 9 75 S> */ B(Return),
311 : /* 10 */ B(JumpIfFalse), U8(3),
312 : /* 12 */ B(Throw),
313 : /* 13 */ B(JumpIfFalse), U8(3),
314 : /* 15 */ B(ReThrow),
315 : /* 16 */ B(Return),
316 : // clang-format on
317 : };
318 :
319 : static const PositionTableEntry expected_positions[] = {
320 2 : {0, 10, false}, {1, 55, true}, {5, 65, true}, {9, 75, true}};
321 :
322 : BytecodeLabel after_jump, after_conditional_jump, after_return, after_throw,
323 : after_rethrow;
324 :
325 : Write(Bytecode::kStackCheck, {10, false});
326 1 : Write(Bytecode::kLdaSmi, 127, {55, true});
327 1 : WriteJump(Bytecode::kJump, &after_jump);
328 1 : Write(Bytecode::kLdaSmi, 127); // Dead code.
329 1 : WriteJump(Bytecode::kJumpIfFalse, &after_conditional_jump); // Dead code.
330 1 : writer()->BindLabel(&after_jump);
331 1 : writer()->BindLabel(&after_conditional_jump);
332 1 : Write(Bytecode::kLdaSmi, 127, {65, true});
333 1 : WriteJump(Bytecode::kJumpIfFalse, &after_return);
334 : Write(Bytecode::kReturn, {75, true});
335 1 : Write(Bytecode::kLdaSmi, 127, {100, true}); // Dead code.
336 1 : writer()->BindLabel(&after_return);
337 1 : WriteJump(Bytecode::kJumpIfFalse, &after_throw);
338 : Write(Bytecode::kThrow);
339 1 : Write(Bytecode::kLdaSmi, 127); // Dead code.
340 1 : writer()->BindLabel(&after_throw);
341 1 : WriteJump(Bytecode::kJumpIfFalse, &after_rethrow);
342 : Write(Bytecode::kReThrow);
343 1 : Write(Bytecode::kLdaSmi, 127); // Dead code.
344 1 : writer()->BindLabel(&after_rethrow);
345 : Write(Bytecode::kReturn);
346 :
347 2 : CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
348 17 : for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
349 34 : CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
350 : static_cast<int>(expected_bytes[i]));
351 : }
352 :
353 : Handle<BytecodeArray> bytecode_array =
354 1 : writer()->ToBytecodeArray(isolate(), 0, 0, factory()->empty_byte_array());
355 : SourcePositionTableIterator source_iterator(
356 1 : bytecode_array->SourcePositionTable());
357 5 : for (size_t i = 0; i < arraysize(expected_positions); ++i) {
358 4 : const PositionTableEntry& expected = expected_positions[i];
359 4 : CHECK_EQ(source_iterator.code_offset(), expected.code_offset);
360 8 : CHECK_EQ(source_iterator.source_position().ScriptOffset(),
361 : expected.source_position);
362 4 : CHECK_EQ(source_iterator.is_statement(), expected.is_statement);
363 4 : source_iterator.Advance();
364 : }
365 1 : CHECK(source_iterator.done());
366 1 : }
367 :
368 : #undef B
369 : #undef R
370 :
371 : } // namespace bytecode_array_writer_unittest
372 : } // namespace interpreter
373 : } // namespace internal
374 9111 : } // namespace v8
|
