OLD | NEW |
(Empty) | |
| 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/interpreter/bytecode-array-writer.h" |
| 8 #include "src/interpreter/source-position-table.h" |
| 9 #include "src/isolate.h" |
| 10 #include "src/utils.h" |
| 11 #include "test/unittests/interpreter/bytecode-utils.h" |
| 12 #include "test/unittests/test-utils.h" |
| 13 |
| 14 namespace v8 { |
| 15 namespace internal { |
| 16 namespace interpreter { |
| 17 |
| 18 class BytecodeArrayWriterUnittest : public TestWithIsolateAndZone { |
| 19 public: |
| 20 BytecodeArrayWriterUnittest() |
| 21 : source_position_builder_(isolate(), zone()), |
| 22 bytecode_array_writer_(zone(), &source_position_builder_) {} |
| 23 ~BytecodeArrayWriterUnittest() override {} |
| 24 |
| 25 void Write(BytecodeNode* node, const BytecodeSourceInfo& info); |
| 26 void Write(Bytecode bytecode, |
| 27 const BytecodeSourceInfo& info = BytecodeSourceInfo()); |
| 28 void Write(Bytecode bytecode, uint32_t operand0, OperandScale operand_scale, |
| 29 const BytecodeSourceInfo& info = BytecodeSourceInfo()); |
| 30 void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1, |
| 31 OperandScale operand_scale, |
| 32 const BytecodeSourceInfo& info = BytecodeSourceInfo()); |
| 33 void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1, |
| 34 uint32_t operand2, OperandScale operand_scale, |
| 35 const BytecodeSourceInfo& info = BytecodeSourceInfo()); |
| 36 void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1, |
| 37 uint32_t operand2, uint32_t operand3, OperandScale operand_scale, |
| 38 const BytecodeSourceInfo& info = BytecodeSourceInfo()); |
| 39 |
| 40 SourcePositionTableBuilder* source_position_builder() { |
| 41 return &source_position_builder_; |
| 42 } |
| 43 BytecodeArrayWriter* writer() { return &bytecode_array_writer_; } |
| 44 |
| 45 private: |
| 46 SourcePositionTableBuilder source_position_builder_; |
| 47 BytecodeArrayWriter bytecode_array_writer_; |
| 48 }; |
| 49 |
| 50 void BytecodeArrayWriterUnittest::Write(BytecodeNode* node, |
| 51 const BytecodeSourceInfo& info) { |
| 52 if (info.is_valid()) { |
| 53 node->source_info().Update(info); |
| 54 } |
| 55 writer()->Write(node); |
| 56 } |
| 57 |
| 58 void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, |
| 59 const BytecodeSourceInfo& info) { |
| 60 BytecodeNode node(bytecode); |
| 61 Write(&node, info); |
| 62 } |
| 63 |
| 64 void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0, |
| 65 OperandScale operand_scale, |
| 66 const BytecodeSourceInfo& info) { |
| 67 BytecodeNode node(bytecode, operand0, operand_scale); |
| 68 Write(&node, info); |
| 69 } |
| 70 |
| 71 void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0, |
| 72 uint32_t operand1, |
| 73 OperandScale operand_scale, |
| 74 const BytecodeSourceInfo& info) { |
| 75 BytecodeNode node(bytecode, operand0, operand1, operand_scale); |
| 76 Write(&node, info); |
| 77 } |
| 78 |
| 79 void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0, |
| 80 uint32_t operand1, uint32_t operand2, |
| 81 OperandScale operand_scale, |
| 82 const BytecodeSourceInfo& info) { |
| 83 BytecodeNode node(bytecode, operand0, operand1, operand2, operand_scale); |
| 84 Write(&node, info); |
| 85 } |
| 86 |
| 87 void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0, |
| 88 uint32_t operand1, uint32_t operand2, |
| 89 uint32_t operand3, |
| 90 OperandScale operand_scale, |
| 91 const BytecodeSourceInfo& info) { |
| 92 BytecodeNode node(bytecode, operand0, operand1, operand2, operand3, |
| 93 operand_scale); |
| 94 Write(&node, info); |
| 95 } |
| 96 |
| 97 TEST_F(BytecodeArrayWriterUnittest, SimpleExample) { |
| 98 CHECK_EQ(writer()->bytecodes()->size(), 0); |
| 99 |
| 100 Write(Bytecode::kStackCheck, {10, false}); |
| 101 CHECK_EQ(writer()->bytecodes()->size(), 1); |
| 102 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 0); |
| 103 |
| 104 Write(Bytecode::kLdaSmi, 0xff, OperandScale::kSingle, {55, true}); |
| 105 CHECK_EQ(writer()->bytecodes()->size(), 3); |
| 106 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 0); |
| 107 |
| 108 Write(Bytecode::kLdar, Register(1).ToOperand(), OperandScale::kDouble); |
| 109 CHECK_EQ(writer()->bytecodes()->size(), 7); |
| 110 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize); |
| 111 |
| 112 Write(Bytecode::kReturn, {70, true}); |
| 113 CHECK_EQ(writer()->bytecodes()->size(), 8); |
| 114 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize); |
| 115 |
| 116 static const uint8_t bytes[] = {B(StackCheck), B(LdaSmi), U8(0xff), B(Wide), |
| 117 B(Ldar), R16(1), B(Return)}; |
| 118 CHECK_EQ(writer()->bytecodes()->size(), arraysize(bytes)); |
| 119 for (size_t i = 0; i < arraysize(bytes); ++i) { |
| 120 CHECK_EQ(writer()->bytecodes()->at(i), bytes[i]); |
| 121 } |
| 122 |
| 123 CHECK_EQ(writer()->FlushForOffset(), arraysize(bytes)); |
| 124 writer()->FlushBasicBlock(); |
| 125 CHECK_EQ(writer()->bytecodes()->size(), arraysize(bytes)); |
| 126 |
| 127 PositionTableEntry expected_positions[] = { |
| 128 {0, 10, false}, {1, 55, true}, {7, 70, true}}; |
| 129 Handle<ByteArray> source_positions = |
| 130 source_position_builder()->ToSourcePositionTable(); |
| 131 SourcePositionTableIterator source_iterator(*source_positions); |
| 132 for (size_t i = 0; i < arraysize(expected_positions); ++i) { |
| 133 const PositionTableEntry& expected = expected_positions[i]; |
| 134 CHECK_EQ(source_iterator.bytecode_offset(), expected.bytecode_offset); |
| 135 CHECK_EQ(source_iterator.source_position(), expected.source_position); |
| 136 CHECK_EQ(source_iterator.is_statement(), expected.is_statement); |
| 137 source_iterator.Advance(); |
| 138 } |
| 139 CHECK(source_iterator.done()); |
| 140 } |
| 141 |
| 142 TEST_F(BytecodeArrayWriterUnittest, ComplexExample) { |
| 143 static const uint8_t expected_bytes[] = { |
| 144 // clang-format off |
| 145 /* 0 30 E> */ B(StackCheck), |
| 146 /* 1 42 S> */ B(LdaConstant), U8(0), |
| 147 /* 3 42 E> */ B(Star), R8(1), |
| 148 /* 5 68 S> */ B(JumpIfUndefined), U8(38), |
| 149 /* 7 */ B(JumpIfNull), U8(36), |
| 150 /* 9 */ B(ToObject), |
| 151 /* 10 */ B(Star), R8(3), |
| 152 /* 12 */ B(ForInPrepare), R8(4), |
| 153 /* 14 */ B(LdaZero), |
| 154 /* 15 */ B(Star), R8(7), |
| 155 /* 17 63 S> */ B(ForInDone), R8(7), R8(6), |
| 156 /* 20 */ B(JumpIfTrue), U8(23), |
| 157 /* 22 */ B(ForInNext), R8(3), R8(7), R8(4), U8(1), |
| 158 /* 27 */ B(JumpIfUndefined), U8(10), |
| 159 /* 29 */ B(Star), R8(0), |
| 160 /* 31 54 E> */ B(StackCheck), |
| 161 /* 32 */ B(Ldar), R8(0), |
| 162 /* 34 */ B(Star), R8(2), |
| 163 /* 36 85 S> */ B(Return), |
| 164 /* 37 */ B(ForInStep), R8(7), |
| 165 /* 39 */ B(Star), R8(7), |
| 166 /* 41 */ B(Jump), U8(-24), |
| 167 /* 43 */ B(LdaUndefined), |
| 168 /* 44 85 S> */ B(Return), |
| 169 // clang-format on |
| 170 }; |
| 171 |
| 172 static const PositionTableEntry expected_positions[] = { |
| 173 {0, 30, false}, {1, 42, true}, {3, 42, false}, {5, 68, true}, |
| 174 {17, 63, true}, {31, 54, false}, {36, 85, true}, {44, 85, true}}; |
| 175 |
| 176 #define R(i) static_cast<uint32_t>(Register(i).ToOperand()) |
| 177 Write(Bytecode::kStackCheck, {30, false}); |
| 178 Write(Bytecode::kLdaConstant, U8(0), OperandScale::kSingle, {42, true}); |
| 179 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 0 * kPointerSize); |
| 180 Write(Bytecode::kStar, R(1), OperandScale::kSingle, {42, false}); |
| 181 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize); |
| 182 Write(Bytecode::kJumpIfUndefined, U8(38), OperandScale::kSingle, {68, true}); |
| 183 Write(Bytecode::kJumpIfNull, U8(36), OperandScale::kSingle); |
| 184 Write(Bytecode::kToObject); |
| 185 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize); |
| 186 Write(Bytecode::kStar, R(3), OperandScale::kSingle); |
| 187 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 4 * kPointerSize); |
| 188 Write(Bytecode::kForInPrepare, R(4), OperandScale::kSingle); |
| 189 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 7 * kPointerSize); |
| 190 Write(Bytecode::kLdaZero); |
| 191 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 7 * kPointerSize); |
| 192 Write(Bytecode::kStar, R(7), OperandScale::kSingle); |
| 193 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 8 * kPointerSize); |
| 194 Write(Bytecode::kForInDone, R(7), R(6), OperandScale::kSingle, {63, true}); |
| 195 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 8 * kPointerSize); |
| 196 Write(Bytecode::kJumpIfTrue, U8(23), OperandScale::kSingle); |
| 197 Write(Bytecode::kForInNext, R(3), R(7), R(4), U8(1), OperandScale::kSingle); |
| 198 Write(Bytecode::kJumpIfUndefined, U8(10), OperandScale::kSingle); |
| 199 Write(Bytecode::kStar, R(0), OperandScale::kSingle); |
| 200 Write(Bytecode::kStackCheck, {54, false}); |
| 201 Write(Bytecode::kLdar, R(0), OperandScale::kSingle); |
| 202 Write(Bytecode::kStar, R(2), OperandScale::kSingle); |
| 203 Write(Bytecode::kReturn, {85, true}); |
| 204 Write(Bytecode::kForInStep, R(7), OperandScale::kSingle); |
| 205 Write(Bytecode::kStar, R(7), OperandScale::kSingle); |
| 206 Write(Bytecode::kJump, U8(-24), OperandScale::kSingle); |
| 207 Write(Bytecode::kLdaUndefined); |
| 208 Write(Bytecode::kReturn, {85, true}); |
| 209 CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 8 * kPointerSize); |
| 210 #undef R |
| 211 |
| 212 CHECK_EQ(writer()->bytecodes()->size(), arraysize(expected_bytes)); |
| 213 for (size_t i = 0; i < arraysize(expected_bytes); ++i) { |
| 214 CHECK_EQ(static_cast<int>(writer()->bytecodes()->at(i)), |
| 215 static_cast<int>(expected_bytes[i])); |
| 216 } |
| 217 |
| 218 Handle<ByteArray> source_positions = |
| 219 source_position_builder()->ToSourcePositionTable(); |
| 220 SourcePositionTableIterator source_iterator(*source_positions); |
| 221 for (size_t i = 0; i < arraysize(expected_positions); ++i) { |
| 222 const PositionTableEntry& expected = expected_positions[i]; |
| 223 CHECK_EQ(source_iterator.bytecode_offset(), expected.bytecode_offset); |
| 224 CHECK_EQ(source_iterator.source_position(), expected.source_position); |
| 225 CHECK_EQ(source_iterator.is_statement(), expected.is_statement); |
| 226 source_iterator.Advance(); |
| 227 } |
| 228 CHECK(source_iterator.done()); |
| 229 } |
| 230 |
| 231 } // namespace interpreter |
| 232 } // namespace internal |
| 233 } // namespace v8 |
OLD | NEW |