1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "dex_instruction-inl.h" 18 19#include <inttypes.h> 20 21#include <iomanip> 22 23#include "base/stringprintf.h" 24#include "dex_file-inl.h" 25#include "utils.h" 26 27namespace art { 28 29const char* const Instruction::kInstructionNames[] = { 30#define INSTRUCTION_NAME(o, c, pname, f, r, i, a, v) pname, 31#include "dex_instruction_list.h" 32 DEX_INSTRUCTION_LIST(INSTRUCTION_NAME) 33#undef DEX_INSTRUCTION_LIST 34#undef INSTRUCTION_NAME 35}; 36 37Instruction::Format const Instruction::kInstructionFormats[] = { 38#define INSTRUCTION_FORMAT(o, c, p, format, r, i, a, v) format, 39#include "dex_instruction_list.h" 40 DEX_INSTRUCTION_LIST(INSTRUCTION_FORMAT) 41#undef DEX_INSTRUCTION_LIST 42#undef INSTRUCTION_FORMAT 43}; 44 45int const Instruction::kInstructionFlags[] = { 46#define INSTRUCTION_FLAGS(o, c, p, f, r, i, flags, v) flags, 47#include "dex_instruction_list.h" 48 DEX_INSTRUCTION_LIST(INSTRUCTION_FLAGS) 49#undef DEX_INSTRUCTION_LIST 50#undef INSTRUCTION_FLAGS 51}; 52 53int const Instruction::kInstructionVerifyFlags[] = { 54#define INSTRUCTION_VERIFY_FLAGS(o, c, p, f, r, i, a, vflags) vflags, 55#include "dex_instruction_list.h" 56 DEX_INSTRUCTION_LIST(INSTRUCTION_VERIFY_FLAGS) 57#undef DEX_INSTRUCTION_LIST 58#undef INSTRUCTION_VERIFY_FLAGS 59}; 60 61int const Instruction::kInstructionSizeInCodeUnits[] = { 62#define INSTRUCTION_SIZE(opcode, c, p, format, r, i, a, v) \ 63 ((opcode == NOP) ? -1 : \ 64 ((format >= k10x) && (format <= k10t)) ? 1 : \ 65 ((format >= k20t) && (format <= k22c)) ? 2 : \ 66 ((format >= k32x) && (format <= k3rc)) ? 3 : \ 67 (format == k51l) ? 5 : -1), 68#include "dex_instruction_list.h" 69 DEX_INSTRUCTION_LIST(INSTRUCTION_SIZE) 70#undef DEX_INSTRUCTION_LIST 71#undef INSTRUCTION_SIZE 72}; 73 74int32_t Instruction::GetTargetOffset() const { 75 switch (FormatOf(Opcode())) { 76 // Cases for conditional branches follow. 77 case k22t: return VRegC_22t(); 78 case k21t: return VRegB_21t(); 79 // Cases for unconditional branches follow. 80 case k10t: return VRegA_10t(); 81 case k20t: return VRegA_20t(); 82 case k30t: return VRegA_30t(); 83 default: LOG(FATAL) << "Tried to access the branch offset of an instruction " << Name() << 84 " which does not have a target operand."; 85 } 86 return 0; 87} 88 89bool Instruction::CanFlowThrough() const { 90 const uint16_t* insns = reinterpret_cast<const uint16_t*>(this); 91 uint16_t insn = *insns; 92 Code opcode = static_cast<Code>(insn & 0xFF); 93 return FlagsOf(opcode) & Instruction::kContinue; 94} 95 96size_t Instruction::SizeInCodeUnitsComplexOpcode() const { 97 const uint16_t* insns = reinterpret_cast<const uint16_t*>(this); 98 // Handle special NOP encoded variable length sequences. 99 switch (*insns) { 100 case kPackedSwitchSignature: 101 return (4 + insns[1] * 2); 102 case kSparseSwitchSignature: 103 return (2 + insns[1] * 4); 104 case kArrayDataSignature: { 105 uint16_t element_size = insns[1]; 106 uint32_t length = insns[2] | (((uint32_t)insns[3]) << 16); 107 // The plus 1 is to round up for odd size and width. 108 return (4 + (element_size * length + 1) / 2); 109 } 110 default: 111 if ((*insns & 0xFF) == 0) { 112 return 1; // NOP. 113 } else { 114 LOG(FATAL) << "Unreachable: " << DumpString(NULL); 115 return 0; 116 } 117 } 118} 119 120std::string Instruction::DumpHex(size_t code_units) const { 121 size_t inst_length = SizeInCodeUnits(); 122 if (inst_length > code_units) { 123 inst_length = code_units; 124 } 125 std::ostringstream os; 126 const uint16_t* insn = reinterpret_cast<const uint16_t*>(this); 127 for (size_t i = 0; i < inst_length; i++) { 128 os << StringPrintf("0x%04x", insn[i]) << " "; 129 } 130 for (size_t i = inst_length; i < code_units; i++) { 131 os << " "; 132 } 133 return os.str(); 134} 135 136std::string Instruction::DumpString(const DexFile* file) const { 137 std::ostringstream os; 138 const char* opcode = kInstructionNames[Opcode()]; 139 switch (FormatOf(Opcode())) { 140 case k10x: os << opcode; break; 141 case k12x: os << StringPrintf("%s v%d, v%d", opcode, VRegA_12x(), VRegB_12x()); break; 142 case k11n: os << StringPrintf("%s v%d, #%+d", opcode, VRegA_11n(), VRegB_11n()); break; 143 case k11x: os << StringPrintf("%s v%d", opcode, VRegA_11x()); break; 144 case k10t: os << StringPrintf("%s %+d", opcode, VRegA_10t()); break; 145 case k20t: os << StringPrintf("%s %+d", opcode, VRegA_20t()); break; 146 case k22x: os << StringPrintf("%s v%d, v%d", opcode, VRegA_22x(), VRegB_22x()); break; 147 case k21t: os << StringPrintf("%s v%d, %+d", opcode, VRegA_21t(), VRegB_21t()); break; 148 case k21s: os << StringPrintf("%s v%d, #%+d", opcode, VRegA_21s(), VRegB_21s()); break; 149 case k21h: { 150 // op vAA, #+BBBB0000[00000000] 151 if (Opcode() == CONST_HIGH16) { 152 uint32_t value = VRegB_21h() << 16; 153 os << StringPrintf("%s v%d, #int %+d // 0x%x", opcode, VRegA_21h(), value, value); 154 } else { 155 uint64_t value = static_cast<uint64_t>(VRegB_21h()) << 48; 156 os << StringPrintf("%s v%d, #long %+" PRId64 " // 0x%" PRIx64, opcode, VRegA_21h(), 157 value, value); 158 } 159 } 160 break; 161 case k21c: { 162 switch (Opcode()) { 163 case CONST_STRING: 164 if (file != NULL) { 165 uint32_t string_idx = VRegB_21c(); 166 os << StringPrintf("const-string v%d, %s // string@%d", VRegA_21c(), 167 PrintableString(file->StringDataByIdx(string_idx)).c_str(), string_idx); 168 break; 169 } // else fall-through 170 case CHECK_CAST: 171 case CONST_CLASS: 172 case NEW_INSTANCE: 173 if (file != NULL) { 174 uint32_t type_idx = VRegB_21c(); 175 os << opcode << " v" << static_cast<int>(VRegA_21c()) << ", " << PrettyType(type_idx, *file) 176 << " // type@" << type_idx; 177 break; 178 } // else fall-through 179 case SGET: 180 case SGET_WIDE: 181 case SGET_OBJECT: 182 case SGET_BOOLEAN: 183 case SGET_BYTE: 184 case SGET_CHAR: 185 case SGET_SHORT: 186 if (file != NULL) { 187 uint32_t field_idx = VRegB_21c(); 188 os << opcode << " v" << static_cast<int>(VRegA_21c()) << ", " << PrettyField(field_idx, *file, true) 189 << " // field@" << field_idx; 190 break; 191 } // else fall-through 192 case SPUT: 193 case SPUT_WIDE: 194 case SPUT_OBJECT: 195 case SPUT_BOOLEAN: 196 case SPUT_BYTE: 197 case SPUT_CHAR: 198 case SPUT_SHORT: 199 if (file != NULL) { 200 uint32_t field_idx = VRegB_21c(); 201 os << opcode << " v" << static_cast<int>(VRegA_21c()) << ", " << PrettyField(field_idx, *file, true) 202 << " // field@" << field_idx; 203 break; 204 } // else fall-through 205 default: 206 os << StringPrintf("%s v%d, thing@%d", opcode, VRegA_21c(), VRegB_21c()); 207 break; 208 } 209 break; 210 } 211 case k23x: os << StringPrintf("%s v%d, v%d, v%d", opcode, VRegA_23x(), VRegB_23x(), VRegC_23x()); break; 212 case k22b: os << StringPrintf("%s v%d, v%d, #%+d", opcode, VRegA_22b(), VRegB_22b(), VRegC_22b()); break; 213 case k22t: os << StringPrintf("%s v%d, v%d, %+d", opcode, VRegA_22t(), VRegB_22t(), VRegC_22t()); break; 214 case k22s: os << StringPrintf("%s v%d, v%d, #%+d", opcode, VRegA_22s(), VRegB_22s(), VRegC_22s()); break; 215 case k22c: { 216 switch (Opcode()) { 217 case IGET: 218 case IGET_WIDE: 219 case IGET_OBJECT: 220 case IGET_BOOLEAN: 221 case IGET_BYTE: 222 case IGET_CHAR: 223 case IGET_SHORT: 224 if (file != NULL) { 225 uint32_t field_idx = VRegC_22c(); 226 os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", " 227 << PrettyField(field_idx, *file, true) << " // field@" << field_idx; 228 break; 229 } // else fall-through 230 case IGET_QUICK: 231 case IGET_OBJECT_QUICK: 232 if (file != NULL) { 233 uint32_t field_idx = VRegC_22c(); 234 os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", " 235 << "// offset@" << field_idx; 236 break; 237 } // else fall-through 238 case IPUT: 239 case IPUT_WIDE: 240 case IPUT_OBJECT: 241 case IPUT_BOOLEAN: 242 case IPUT_BYTE: 243 case IPUT_CHAR: 244 case IPUT_SHORT: 245 if (file != NULL) { 246 uint32_t field_idx = VRegC_22c(); 247 os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", " 248 << PrettyField(field_idx, *file, true) << " // field@" << field_idx; 249 break; 250 } // else fall-through 251 case IPUT_QUICK: 252 case IPUT_OBJECT_QUICK: 253 if (file != NULL) { 254 uint32_t field_idx = VRegC_22c(); 255 os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", " 256 << "// offset@" << field_idx; 257 break; 258 } // else fall-through 259 case INSTANCE_OF: 260 if (file != NULL) { 261 uint32_t type_idx = VRegC_22c(); 262 os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", " 263 << PrettyType(type_idx, *file) << " // type@" << type_idx; 264 break; 265 } 266 case NEW_ARRAY: 267 if (file != NULL) { 268 uint32_t type_idx = VRegC_22c(); 269 os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", " 270 << PrettyType(type_idx, *file) << " // type@" << type_idx; 271 break; 272 } // else fall-through 273 default: 274 os << StringPrintf("%s v%d, v%d, thing@%d", opcode, VRegA_22c(), VRegB_22c(), VRegC_22c()); 275 break; 276 } 277 break; 278 } 279 case k32x: os << StringPrintf("%s v%d, v%d", opcode, VRegA_32x(), VRegB_32x()); break; 280 case k30t: os << StringPrintf("%s %+d", opcode, VRegA_30t()); break; 281 case k31t: os << StringPrintf("%s v%d, %+d", opcode, VRegA_31t(), VRegB_31t()); break; 282 case k31i: os << StringPrintf("%s v%d, #%+d", opcode, VRegA_31i(), VRegB_31i()); break; 283 case k31c: 284 if (Opcode() == CONST_STRING_JUMBO) { 285 uint32_t string_idx = VRegB_31c(); 286 if (file != NULL) { 287 os << StringPrintf("%s v%d, %s // string@%d", opcode, VRegA_31c(), 288 PrintableString(file->StringDataByIdx(string_idx)).c_str(), 289 string_idx); 290 } else { 291 os << StringPrintf("%s v%d, string@%d", opcode, VRegA_31c(), string_idx); 292 } 293 } else { 294 os << StringPrintf("%s v%d, thing@%d", opcode, VRegA_31c(), VRegB_31c()); break; 295 } 296 break; 297 case k35c: { 298 uint32_t arg[5]; 299 GetVarArgs(arg); 300 switch (Opcode()) { 301 case FILLED_NEW_ARRAY: 302 { 303 const int32_t a = VRegA_35c(); 304 os << opcode << " {"; 305 for (int i = 0; i < a; ++i) { 306 if (i > 0) { 307 os << ", "; 308 } 309 os << "v" << arg[i]; 310 } 311 os << "}, type@" << VRegB_35c(); 312 } 313 break; 314 315 case INVOKE_VIRTUAL: 316 case INVOKE_SUPER: 317 case INVOKE_DIRECT: 318 case INVOKE_STATIC: 319 case INVOKE_INTERFACE: 320 if (file != NULL) { 321 os << opcode << " {"; 322 uint32_t method_idx = VRegB_35c(); 323 for (size_t i = 0; i < VRegA_35c(); ++i) { 324 if (i != 0) { 325 os << ", "; 326 } 327 os << "v" << arg[i]; 328 } 329 os << "}, " << PrettyMethod(method_idx, *file) << " // method@" << method_idx; 330 break; 331 } // else fall-through 332 case INVOKE_VIRTUAL_QUICK: 333 if (file != NULL) { 334 os << opcode << " {"; 335 uint32_t method_idx = VRegB_35c(); 336 for (size_t i = 0; i < VRegA_35c(); ++i) { 337 if (i != 0) { 338 os << ", "; 339 } 340 os << "v" << arg[i]; 341 } 342 os << "}, // vtable@" << method_idx; 343 break; 344 } // else fall-through 345 default: 346 os << opcode << " {v" << arg[0] << ", v" << arg[1] << ", v" << arg[2] 347 << ", v" << arg[3] << ", v" << arg[4] << "}, thing@" << VRegB_35c(); 348 break; 349 } 350 break; 351 } 352 case k3rc: { 353 switch (Opcode()) { 354 case INVOKE_VIRTUAL_RANGE: 355 case INVOKE_SUPER_RANGE: 356 case INVOKE_DIRECT_RANGE: 357 case INVOKE_STATIC_RANGE: 358 case INVOKE_INTERFACE_RANGE: 359 if (file != NULL) { 360 uint32_t method_idx = VRegB_3rc(); 361 os << StringPrintf("%s, {v%d .. v%d}, ", opcode, VRegC_3rc(), (VRegC_3rc() + VRegA_3rc() - 1)) 362 << PrettyMethod(method_idx, *file) << " // method@" << method_idx; 363 break; 364 } // else fall-through 365 case INVOKE_VIRTUAL_RANGE_QUICK: 366 if (file != NULL) { 367 uint32_t method_idx = VRegB_3rc(); 368 os << StringPrintf("%s, {v%d .. v%d}, ", opcode, VRegC_3rc(), (VRegC_3rc() + VRegA_3rc() - 1)) 369 << "// vtable@" << method_idx; 370 break; 371 } // else fall-through 372 default: 373 os << StringPrintf("%s, {v%d .. v%d}, thing@%d", opcode, VRegC_3rc(), 374 (VRegC_3rc() + VRegA_3rc() - 1), VRegB_3rc()); 375 break; 376 } 377 break; 378 } 379 case k51l: os << StringPrintf("%s v%d, #%+" PRId64, opcode, VRegA_51l(), VRegB_51l()); break; 380 default: os << " unknown format (" << DumpHex(5) << ")"; break; 381 } 382 return os.str(); 383} 384 385std::ostream& operator<<(std::ostream& os, const Instruction::Code& code) { 386 return os << Instruction::Name(code); 387} 388 389} // namespace art 390