1 // Copyright 2015 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/interpreter/bytecode-array-accessor.h"
6
7 #include "src/feedback-vector.h"
8 #include "src/interpreter/bytecode-decoder.h"
9 #include "src/interpreter/interpreter-intrinsics.h"
10 #include "src/objects-inl.h"
11 #include "src/objects/code-inl.h"
12
13 namespace v8 {
14 namespace internal {
15 namespace interpreter {
16
BytecodeArrayAccessor(Handle<BytecodeArray> bytecode_array,int initial_offset)17 BytecodeArrayAccessor::BytecodeArrayAccessor(
18 Handle<BytecodeArray> bytecode_array, int initial_offset)
19 : bytecode_array_(bytecode_array),
20 bytecode_offset_(initial_offset),
21 operand_scale_(OperandScale::kSingle),
22 prefix_offset_(0) {
23 UpdateOperandScale();
24 }
25
SetOffset(int offset)26 void BytecodeArrayAccessor::SetOffset(int offset) {
27 bytecode_offset_ = offset;
28 UpdateOperandScale();
29 }
30
ApplyDebugBreak()31 void BytecodeArrayAccessor::ApplyDebugBreak() {
32 // Get the raw bytecode from the bytecode array. This may give us a
33 // scaling prefix, which we can patch with the matching debug-break
34 // variant.
35 interpreter::Bytecode bytecode =
36 interpreter::Bytecodes::FromByte(bytecode_array_->get(bytecode_offset_));
37 if (interpreter::Bytecodes::IsDebugBreak(bytecode)) return;
38 interpreter::Bytecode debugbreak =
39 interpreter::Bytecodes::GetDebugBreak(bytecode);
40 bytecode_array_->set(bytecode_offset_,
41 interpreter::Bytecodes::ToByte(debugbreak));
42 }
43
UpdateOperandScale()44 void BytecodeArrayAccessor::UpdateOperandScale() {
45 if (OffsetInBounds()) {
46 uint8_t current_byte = bytecode_array()->get(bytecode_offset_);
47 Bytecode current_bytecode = Bytecodes::FromByte(current_byte);
48 if (Bytecodes::IsPrefixScalingBytecode(current_bytecode)) {
49 operand_scale_ =
50 Bytecodes::PrefixBytecodeToOperandScale(current_bytecode);
51 prefix_offset_ = 1;
52 } else {
53 operand_scale_ = OperandScale::kSingle;
54 prefix_offset_ = 0;
55 }
56 }
57 }
58
OffsetInBounds() const59 bool BytecodeArrayAccessor::OffsetInBounds() const {
60 return bytecode_offset_ >= 0 && bytecode_offset_ < bytecode_array()->length();
61 }
62
current_bytecode() const63 Bytecode BytecodeArrayAccessor::current_bytecode() const {
64 DCHECK(OffsetInBounds());
65 uint8_t current_byte =
66 bytecode_array()->get(bytecode_offset_ + current_prefix_offset());
67 Bytecode current_bytecode = Bytecodes::FromByte(current_byte);
68 DCHECK(!Bytecodes::IsPrefixScalingBytecode(current_bytecode));
69 return current_bytecode;
70 }
71
current_bytecode_size() const72 int BytecodeArrayAccessor::current_bytecode_size() const {
73 return current_prefix_offset() +
74 Bytecodes::Size(current_bytecode(), current_operand_scale());
75 }
76
GetUnsignedOperand(int operand_index,OperandType operand_type) const77 uint32_t BytecodeArrayAccessor::GetUnsignedOperand(
78 int operand_index, OperandType operand_type) const {
79 DCHECK_GE(operand_index, 0);
80 DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
81 DCHECK_EQ(operand_type,
82 Bytecodes::GetOperandType(current_bytecode(), operand_index));
83 DCHECK(Bytecodes::IsUnsignedOperandType(operand_type));
84 Address operand_start =
85 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ +
86 current_prefix_offset() +
87 Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
88 current_operand_scale());
89 return BytecodeDecoder::DecodeUnsignedOperand(operand_start, operand_type,
90 current_operand_scale());
91 }
92
GetSignedOperand(int operand_index,OperandType operand_type) const93 int32_t BytecodeArrayAccessor::GetSignedOperand(
94 int operand_index, OperandType operand_type) const {
95 DCHECK_GE(operand_index, 0);
96 DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
97 DCHECK_EQ(operand_type,
98 Bytecodes::GetOperandType(current_bytecode(), operand_index));
99 DCHECK(!Bytecodes::IsUnsignedOperandType(operand_type));
100 Address operand_start =
101 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ +
102 current_prefix_offset() +
103 Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
104 current_operand_scale());
105 return BytecodeDecoder::DecodeSignedOperand(operand_start, operand_type,
106 current_operand_scale());
107 }
108
GetFlagOperand(int operand_index) const109 uint32_t BytecodeArrayAccessor::GetFlagOperand(int operand_index) const {
110 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
111 OperandType::kFlag8);
112 return GetUnsignedOperand(operand_index, OperandType::kFlag8);
113 }
114
GetUnsignedImmediateOperand(int operand_index) const115 uint32_t BytecodeArrayAccessor::GetUnsignedImmediateOperand(
116 int operand_index) const {
117 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
118 OperandType::kUImm);
119 return GetUnsignedOperand(operand_index, OperandType::kUImm);
120 }
121
GetImmediateOperand(int operand_index) const122 int32_t BytecodeArrayAccessor::GetImmediateOperand(int operand_index) const {
123 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
124 OperandType::kImm);
125 return GetSignedOperand(operand_index, OperandType::kImm);
126 }
127
GetRegisterCountOperand(int operand_index) const128 uint32_t BytecodeArrayAccessor::GetRegisterCountOperand(
129 int operand_index) const {
130 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
131 OperandType::kRegCount);
132 return GetUnsignedOperand(operand_index, OperandType::kRegCount);
133 }
134
GetIndexOperand(int operand_index) const135 uint32_t BytecodeArrayAccessor::GetIndexOperand(int operand_index) const {
136 OperandType operand_type =
137 Bytecodes::GetOperandType(current_bytecode(), operand_index);
138 DCHECK_EQ(operand_type, OperandType::kIdx);
139 return GetUnsignedOperand(operand_index, operand_type);
140 }
141
GetSlotOperand(int operand_index) const142 FeedbackSlot BytecodeArrayAccessor::GetSlotOperand(int operand_index) const {
143 int index = GetIndexOperand(operand_index);
144 return FeedbackVector::ToSlot(index);
145 }
146
GetRegisterOperand(int operand_index) const147 Register BytecodeArrayAccessor::GetRegisterOperand(int operand_index) const {
148 OperandType operand_type =
149 Bytecodes::GetOperandType(current_bytecode(), operand_index);
150 Address operand_start =
151 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ +
152 current_prefix_offset() +
153 Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
154 current_operand_scale());
155 return BytecodeDecoder::DecodeRegisterOperand(operand_start, operand_type,
156 current_operand_scale());
157 }
158
GetRegisterOperandRange(int operand_index) const159 int BytecodeArrayAccessor::GetRegisterOperandRange(int operand_index) const {
160 DCHECK_LE(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
161 const OperandType* operand_types =
162 Bytecodes::GetOperandTypes(current_bytecode());
163 OperandType operand_type = operand_types[operand_index];
164 DCHECK(Bytecodes::IsRegisterOperandType(operand_type));
165 if (operand_type == OperandType::kRegList ||
166 operand_type == OperandType::kRegOutList) {
167 return GetRegisterCountOperand(operand_index + 1);
168 } else {
169 return Bytecodes::GetNumberOfRegistersRepresentedBy(operand_type);
170 }
171 }
172
GetRuntimeIdOperand(int operand_index) const173 Runtime::FunctionId BytecodeArrayAccessor::GetRuntimeIdOperand(
174 int operand_index) const {
175 OperandType operand_type =
176 Bytecodes::GetOperandType(current_bytecode(), operand_index);
177 DCHECK_EQ(operand_type, OperandType::kRuntimeId);
178 uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type);
179 return static_cast<Runtime::FunctionId>(raw_id);
180 }
181
GetNativeContextIndexOperand(int operand_index) const182 uint32_t BytecodeArrayAccessor::GetNativeContextIndexOperand(
183 int operand_index) const {
184 OperandType operand_type =
185 Bytecodes::GetOperandType(current_bytecode(), operand_index);
186 DCHECK_EQ(operand_type, OperandType::kNativeContextIndex);
187 return GetUnsignedOperand(operand_index, operand_type);
188 }
189
GetIntrinsicIdOperand(int operand_index) const190 Runtime::FunctionId BytecodeArrayAccessor::GetIntrinsicIdOperand(
191 int operand_index) const {
192 OperandType operand_type =
193 Bytecodes::GetOperandType(current_bytecode(), operand_index);
194 DCHECK_EQ(operand_type, OperandType::kIntrinsicId);
195 uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type);
196 return IntrinsicsHelper::ToRuntimeId(
197 static_cast<IntrinsicsHelper::IntrinsicId>(raw_id));
198 }
199
GetConstantAtIndex(int index) const200 Object* BytecodeArrayAccessor::GetConstantAtIndex(int index) const {
201 return bytecode_array()->constant_pool()->get(index);
202 }
203
GetConstantForIndexOperand(int operand_index) const204 Object* BytecodeArrayAccessor::GetConstantForIndexOperand(
205 int operand_index) const {
206 return GetConstantAtIndex(GetIndexOperand(operand_index));
207 }
208
GetJumpTargetOffset() const209 int BytecodeArrayAccessor::GetJumpTargetOffset() const {
210 Bytecode bytecode = current_bytecode();
211 if (interpreter::Bytecodes::IsJumpImmediate(bytecode)) {
212 int relative_offset = GetUnsignedImmediateOperand(0);
213 if (bytecode == Bytecode::kJumpLoop) {
214 relative_offset = -relative_offset;
215 }
216 return GetAbsoluteOffset(relative_offset);
217 } else if (interpreter::Bytecodes::IsJumpConstant(bytecode)) {
218 Smi* smi = Smi::cast(GetConstantForIndexOperand(0));
219 return GetAbsoluteOffset(smi->value());
220 } else {
221 UNREACHABLE();
222 }
223 }
224
GetJumpTableTargetOffsets() const225 JumpTableTargetOffsets BytecodeArrayAccessor::GetJumpTableTargetOffsets()
226 const {
227 uint32_t table_start, table_size;
228 int32_t case_value_base;
229 if (current_bytecode() == Bytecode::kSwitchOnGeneratorState) {
230 table_start = GetIndexOperand(1);
231 table_size = GetUnsignedImmediateOperand(2);
232 case_value_base = 0;
233 } else {
234 DCHECK_EQ(current_bytecode(), Bytecode::kSwitchOnSmiNoFeedback);
235 table_start = GetIndexOperand(0);
236 table_size = GetUnsignedImmediateOperand(1);
237 case_value_base = GetImmediateOperand(2);
238 }
239 return JumpTableTargetOffsets(this, table_start, table_size, case_value_base);
240 }
241
GetAbsoluteOffset(int relative_offset) const242 int BytecodeArrayAccessor::GetAbsoluteOffset(int relative_offset) const {
243 return current_offset() + relative_offset + current_prefix_offset();
244 }
245
OffsetWithinBytecode(int offset) const246 bool BytecodeArrayAccessor::OffsetWithinBytecode(int offset) const {
247 return current_offset() <= offset &&
248 offset < current_offset() + current_bytecode_size();
249 }
250
PrintTo(std::ostream & os) const251 std::ostream& BytecodeArrayAccessor::PrintTo(std::ostream& os) const {
252 const uint8_t* bytecode_addr = reinterpret_cast<const uint8_t*>(
253 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_);
254 return BytecodeDecoder::Decode(os, bytecode_addr,
255 bytecode_array()->parameter_count());
256 }
257
JumpTableTargetOffsets(const BytecodeArrayAccessor * accessor,int table_start,int table_size,int case_value_base)258 JumpTableTargetOffsets::JumpTableTargetOffsets(
259 const BytecodeArrayAccessor* accessor, int table_start, int table_size,
260 int case_value_base)
261 : accessor_(accessor),
262 table_start_(table_start),
263 table_size_(table_size),
264 case_value_base_(case_value_base) {}
265
begin() const266 JumpTableTargetOffsets::iterator JumpTableTargetOffsets::begin() const {
267 return iterator(case_value_base_, table_start_, table_start_ + table_size_,
268 accessor_);
269 }
end() const270 JumpTableTargetOffsets::iterator JumpTableTargetOffsets::end() const {
271 return iterator(case_value_base_ + table_size_, table_start_ + table_size_,
272 table_start_ + table_size_, accessor_);
273 }
size() const274 int JumpTableTargetOffsets::size() const {
275 int ret = 0;
276 // TODO(leszeks): Is there a more efficient way of doing this than iterating?
277 for (const auto& entry : *this) {
278 USE(entry);
279 ret++;
280 }
281 return ret;
282 }
283
iterator(int case_value,int table_offset,int table_end,const BytecodeArrayAccessor * accessor)284 JumpTableTargetOffsets::iterator::iterator(
285 int case_value, int table_offset, int table_end,
286 const BytecodeArrayAccessor* accessor)
287 : accessor_(accessor),
288 current_(Smi::kZero),
289 index_(case_value),
290 table_offset_(table_offset),
291 table_end_(table_end) {
292 UpdateAndAdvanceToValid();
293 }
294
operator *()295 JumpTableTargetOffset JumpTableTargetOffsets::iterator::operator*() {
296 DCHECK_LT(table_offset_, table_end_);
297 return {index_, accessor_->GetAbsoluteOffset(Smi::ToInt(current_))};
298 }
299
300 JumpTableTargetOffsets::iterator& JumpTableTargetOffsets::iterator::
operator ++()301 operator++() {
302 DCHECK_LT(table_offset_, table_end_);
303 ++table_offset_;
304 ++index_;
305 UpdateAndAdvanceToValid();
306 return *this;
307 }
308
operator !=(const JumpTableTargetOffsets::iterator & other)309 bool JumpTableTargetOffsets::iterator::operator!=(
310 const JumpTableTargetOffsets::iterator& other) {
311 DCHECK_EQ(accessor_, other.accessor_);
312 DCHECK_EQ(table_end_, other.table_end_);
313 DCHECK_EQ(index_ - other.index_, table_offset_ - other.table_offset_);
314 return index_ != other.index_;
315 }
316
UpdateAndAdvanceToValid()317 void JumpTableTargetOffsets::iterator::UpdateAndAdvanceToValid() {
318 if (table_offset_ >= table_end_) return;
319
320 Object* current = accessor_->GetConstantAtIndex(table_offset_);
321 while (!current->IsSmi()) {
322 DCHECK(current->IsTheHole());
323 ++table_offset_;
324 ++index_;
325 if (table_offset_ >= table_end_) break;
326 current = accessor_->GetConstantAtIndex(table_offset_);
327 }
328 // Make sure we haven't reached the end of the table with a hole in current.
329 if (current->IsSmi()) {
330 current_ = Smi::cast(current);
331 }
332 }
333
334 } // namespace interpreter
335 } // namespace internal
336 } // namespace v8
337