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/interpreter/bytecode-decoder.h" 8 #include "src/interpreter/interpreter-intrinsics.h" 9 #include "src/objects-inl.h" 10 11 namespace v8 { 12 namespace internal { 13 namespace interpreter { 14 15 BytecodeArrayAccessor::BytecodeArrayAccessor( 16 Handle<BytecodeArray> bytecode_array, int initial_offset) 17 : bytecode_array_(bytecode_array), 18 bytecode_offset_(initial_offset), 19 operand_scale_(OperandScale::kSingle), 20 prefix_offset_(0) { 21 UpdateOperandScale(); 22 } 23 24 void BytecodeArrayAccessor::SetOffset(int offset) { 25 bytecode_offset_ = offset; 26 UpdateOperandScale(); 27 } 28 29 void BytecodeArrayAccessor::UpdateOperandScale() { 30 if (OffsetInBounds()) { 31 uint8_t current_byte = bytecode_array()->get(bytecode_offset_); 32 Bytecode current_bytecode = Bytecodes::FromByte(current_byte); 33 if (Bytecodes::IsPrefixScalingBytecode(current_bytecode)) { 34 operand_scale_ = 35 Bytecodes::PrefixBytecodeToOperandScale(current_bytecode); 36 prefix_offset_ = 1; 37 } else { 38 operand_scale_ = OperandScale::kSingle; 39 prefix_offset_ = 0; 40 } 41 } 42 } 43 44 bool BytecodeArrayAccessor::OffsetInBounds() const { 45 return bytecode_offset_ >= 0 && bytecode_offset_ < bytecode_array()->length(); 46 } 47 48 Bytecode BytecodeArrayAccessor::current_bytecode() const { 49 DCHECK(OffsetInBounds()); 50 uint8_t current_byte = 51 bytecode_array()->get(bytecode_offset_ + current_prefix_offset()); 52 Bytecode current_bytecode = Bytecodes::FromByte(current_byte); 53 DCHECK(!Bytecodes::IsPrefixScalingBytecode(current_bytecode)); 54 return current_bytecode; 55 } 56 57 int BytecodeArrayAccessor::current_bytecode_size() const { 58 return current_prefix_offset() + 59 Bytecodes::Size(current_bytecode(), current_operand_scale()); 60 } 61 62 uint32_t BytecodeArrayAccessor::GetUnsignedOperand( 63 int operand_index, OperandType operand_type) const { 64 DCHECK_GE(operand_index, 0); 65 DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode())); 66 DCHECK_EQ(operand_type, 67 Bytecodes::GetOperandType(current_bytecode(), operand_index)); 68 DCHECK(Bytecodes::IsUnsignedOperandType(operand_type)); 69 const uint8_t* operand_start = 70 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ + 71 current_prefix_offset() + 72 Bytecodes::GetOperandOffset(current_bytecode(), operand_index, 73 current_operand_scale()); 74 return BytecodeDecoder::DecodeUnsignedOperand(operand_start, operand_type, 75 current_operand_scale()); 76 } 77 78 int32_t BytecodeArrayAccessor::GetSignedOperand( 79 int operand_index, OperandType operand_type) const { 80 DCHECK_GE(operand_index, 0); 81 DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode())); 82 DCHECK_EQ(operand_type, 83 Bytecodes::GetOperandType(current_bytecode(), operand_index)); 84 DCHECK(!Bytecodes::IsUnsignedOperandType(operand_type)); 85 const uint8_t* operand_start = 86 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ + 87 current_prefix_offset() + 88 Bytecodes::GetOperandOffset(current_bytecode(), operand_index, 89 current_operand_scale()); 90 return BytecodeDecoder::DecodeSignedOperand(operand_start, operand_type, 91 current_operand_scale()); 92 } 93 94 uint32_t BytecodeArrayAccessor::GetFlagOperand(int operand_index) const { 95 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index), 96 OperandType::kFlag8); 97 return GetUnsignedOperand(operand_index, OperandType::kFlag8); 98 } 99 100 uint32_t BytecodeArrayAccessor::GetUnsignedImmediateOperand( 101 int operand_index) const { 102 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index), 103 OperandType::kUImm); 104 return GetUnsignedOperand(operand_index, OperandType::kUImm); 105 } 106 107 int32_t BytecodeArrayAccessor::GetImmediateOperand(int operand_index) const { 108 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index), 109 OperandType::kImm); 110 return GetSignedOperand(operand_index, OperandType::kImm); 111 } 112 113 uint32_t BytecodeArrayAccessor::GetRegisterCountOperand( 114 int operand_index) const { 115 DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index), 116 OperandType::kRegCount); 117 return GetUnsignedOperand(operand_index, OperandType::kRegCount); 118 } 119 120 uint32_t BytecodeArrayAccessor::GetIndexOperand(int operand_index) const { 121 OperandType operand_type = 122 Bytecodes::GetOperandType(current_bytecode(), operand_index); 123 DCHECK_EQ(operand_type, OperandType::kIdx); 124 return GetUnsignedOperand(operand_index, operand_type); 125 } 126 127 Register BytecodeArrayAccessor::GetRegisterOperand(int operand_index) const { 128 OperandType operand_type = 129 Bytecodes::GetOperandType(current_bytecode(), operand_index); 130 const uint8_t* operand_start = 131 bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ + 132 current_prefix_offset() + 133 Bytecodes::GetOperandOffset(current_bytecode(), operand_index, 134 current_operand_scale()); 135 return BytecodeDecoder::DecodeRegisterOperand(operand_start, operand_type, 136 current_operand_scale()); 137 } 138 139 int BytecodeArrayAccessor::GetRegisterOperandRange(int operand_index) const { 140 DCHECK_LE(operand_index, Bytecodes::NumberOfOperands(current_bytecode())); 141 const OperandType* operand_types = 142 Bytecodes::GetOperandTypes(current_bytecode()); 143 OperandType operand_type = operand_types[operand_index]; 144 DCHECK(Bytecodes::IsRegisterOperandType(operand_type)); 145 if (operand_type == OperandType::kRegList) { 146 return GetRegisterCountOperand(operand_index + 1); 147 } else { 148 return Bytecodes::GetNumberOfRegistersRepresentedBy(operand_type); 149 } 150 } 151 152 Runtime::FunctionId BytecodeArrayAccessor::GetRuntimeIdOperand( 153 int operand_index) const { 154 OperandType operand_type = 155 Bytecodes::GetOperandType(current_bytecode(), operand_index); 156 DCHECK(operand_type == OperandType::kRuntimeId); 157 uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type); 158 return static_cast<Runtime::FunctionId>(raw_id); 159 } 160 161 Runtime::FunctionId BytecodeArrayAccessor::GetIntrinsicIdOperand( 162 int operand_index) const { 163 OperandType operand_type = 164 Bytecodes::GetOperandType(current_bytecode(), operand_index); 165 DCHECK(operand_type == OperandType::kIntrinsicId); 166 uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type); 167 return IntrinsicsHelper::ToRuntimeId( 168 static_cast<IntrinsicsHelper::IntrinsicId>(raw_id)); 169 } 170 171 Handle<Object> BytecodeArrayAccessor::GetConstantForIndexOperand( 172 int operand_index) const { 173 return FixedArray::get(bytecode_array()->constant_pool(), 174 GetIndexOperand(operand_index), 175 bytecode_array()->GetIsolate()); 176 } 177 178 int BytecodeArrayAccessor::GetJumpTargetOffset() const { 179 Bytecode bytecode = current_bytecode(); 180 if (interpreter::Bytecodes::IsJumpImmediate(bytecode)) { 181 int relative_offset = GetUnsignedImmediateOperand(0); 182 if (bytecode == Bytecode::kJumpLoop) { 183 relative_offset = -relative_offset; 184 } 185 return current_offset() + relative_offset + current_prefix_offset(); 186 } else if (interpreter::Bytecodes::IsJumpConstant(bytecode)) { 187 Smi* smi = Smi::cast(*GetConstantForIndexOperand(0)); 188 return current_offset() + smi->value() + current_prefix_offset(); 189 } else { 190 UNREACHABLE(); 191 return kMinInt; 192 } 193 } 194 195 bool BytecodeArrayAccessor::OffsetWithinBytecode(int offset) const { 196 return current_offset() <= offset && 197 offset < current_offset() + current_bytecode_size(); 198 } 199 200 std::ostream& BytecodeArrayAccessor::PrintTo(std::ostream& os) const { 201 return BytecodeDecoder::Decode( 202 os, bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_, 203 bytecode_array()->parameter_count()); 204 } 205 206 } // namespace interpreter 207 } // namespace internal 208 } // namespace v8 209