1 /* 2 * Copyright (C) 2008 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 /* 18 * Dalvik instruction utility functions. 19 */ 20 #include "InstrUtils.h" 21 22 #include <stdlib.h> 23 24 25 /* 26 * Generate a table that holds the width of all instructions. 27 * 28 * Standard instructions have positive values, optimizer instructions 29 * have negative values, unimplemented instructions have a width of zero. 30 * 31 * I'm doing it with a giant switch statement because it's easier to 32 * maintain and update than a static table with 256 unadorned integers, 33 * and if we're missing a case gcc emits a "warning: enumeration value not 34 * handled" message. 35 * 36 * (To save space in the binary we could generate a static table with a 37 * command-line utility.) 38 * 39 * TODO: it doesn't look like we're using the negative values anymore. 40 * Consider switching to only positive values. 41 */ 42 InstructionWidth* dexCreateInstrWidthTable(void) 43 { 44 #ifdef __ARM_ARCH_7A__ 45 /* hack to work around mysterious problem on emulator */ 46 LOGD("creating instr width table\n"); 47 #endif 48 InstructionWidth* instrWidth; 49 int i; 50 51 instrWidth = malloc(sizeof(InstructionWidth) * kNumDalvikInstructions); 52 if (instrWidth == NULL) 53 return NULL; 54 55 for (i = 0; i < kNumDalvikInstructions; i++) { 56 OpCode opc = (OpCode) i; 57 int width = 0; 58 59 switch (opc) { 60 case OP_NOP: /* note data for e.g. switch-* encoded "inside" a NOP */ 61 case OP_MOVE: 62 case OP_MOVE_WIDE: 63 case OP_MOVE_OBJECT: 64 case OP_MOVE_RESULT: 65 case OP_MOVE_RESULT_WIDE: 66 case OP_MOVE_RESULT_OBJECT: 67 case OP_MOVE_EXCEPTION: 68 case OP_RETURN_VOID: 69 case OP_RETURN: 70 case OP_RETURN_WIDE: 71 case OP_RETURN_OBJECT: 72 case OP_CONST_4: 73 case OP_MONITOR_ENTER: 74 case OP_MONITOR_EXIT: 75 case OP_ARRAY_LENGTH: 76 case OP_THROW: 77 case OP_GOTO: 78 case OP_NEG_INT: 79 case OP_NOT_INT: 80 case OP_NEG_LONG: 81 case OP_NOT_LONG: 82 case OP_NEG_FLOAT: 83 case OP_NEG_DOUBLE: 84 case OP_INT_TO_LONG: 85 case OP_INT_TO_FLOAT: 86 case OP_INT_TO_DOUBLE: 87 case OP_LONG_TO_INT: 88 case OP_LONG_TO_FLOAT: 89 case OP_LONG_TO_DOUBLE: 90 case OP_FLOAT_TO_INT: 91 case OP_FLOAT_TO_LONG: 92 case OP_FLOAT_TO_DOUBLE: 93 case OP_DOUBLE_TO_INT: 94 case OP_DOUBLE_TO_LONG: 95 case OP_DOUBLE_TO_FLOAT: 96 case OP_INT_TO_BYTE: 97 case OP_INT_TO_CHAR: 98 case OP_INT_TO_SHORT: 99 case OP_ADD_INT_2ADDR: 100 case OP_SUB_INT_2ADDR: 101 case OP_MUL_INT_2ADDR: 102 case OP_DIV_INT_2ADDR: 103 case OP_REM_INT_2ADDR: 104 case OP_AND_INT_2ADDR: 105 case OP_OR_INT_2ADDR: 106 case OP_XOR_INT_2ADDR: 107 case OP_SHL_INT_2ADDR: 108 case OP_SHR_INT_2ADDR: 109 case OP_USHR_INT_2ADDR: 110 case OP_ADD_LONG_2ADDR: 111 case OP_SUB_LONG_2ADDR: 112 case OP_MUL_LONG_2ADDR: 113 case OP_DIV_LONG_2ADDR: 114 case OP_REM_LONG_2ADDR: 115 case OP_AND_LONG_2ADDR: 116 case OP_OR_LONG_2ADDR: 117 case OP_XOR_LONG_2ADDR: 118 case OP_SHL_LONG_2ADDR: 119 case OP_SHR_LONG_2ADDR: 120 case OP_USHR_LONG_2ADDR: 121 case OP_ADD_FLOAT_2ADDR: 122 case OP_SUB_FLOAT_2ADDR: 123 case OP_MUL_FLOAT_2ADDR: 124 case OP_DIV_FLOAT_2ADDR: 125 case OP_REM_FLOAT_2ADDR: 126 case OP_ADD_DOUBLE_2ADDR: 127 case OP_SUB_DOUBLE_2ADDR: 128 case OP_MUL_DOUBLE_2ADDR: 129 case OP_DIV_DOUBLE_2ADDR: 130 case OP_REM_DOUBLE_2ADDR: 131 width = 1; 132 break; 133 134 case OP_MOVE_FROM16: 135 case OP_MOVE_WIDE_FROM16: 136 case OP_MOVE_OBJECT_FROM16: 137 case OP_CONST_16: 138 case OP_CONST_HIGH16: 139 case OP_CONST_WIDE_16: 140 case OP_CONST_WIDE_HIGH16: 141 case OP_CONST_STRING: 142 case OP_CONST_CLASS: 143 case OP_CHECK_CAST: 144 case OP_INSTANCE_OF: 145 case OP_NEW_INSTANCE: 146 case OP_NEW_ARRAY: 147 case OP_CMPL_FLOAT: 148 case OP_CMPG_FLOAT: 149 case OP_CMPL_DOUBLE: 150 case OP_CMPG_DOUBLE: 151 case OP_CMP_LONG: 152 case OP_GOTO_16: 153 case OP_IF_EQ: 154 case OP_IF_NE: 155 case OP_IF_LT: 156 case OP_IF_GE: 157 case OP_IF_GT: 158 case OP_IF_LE: 159 case OP_IF_EQZ: 160 case OP_IF_NEZ: 161 case OP_IF_LTZ: 162 case OP_IF_GEZ: 163 case OP_IF_GTZ: 164 case OP_IF_LEZ: 165 case OP_AGET: 166 case OP_AGET_WIDE: 167 case OP_AGET_OBJECT: 168 case OP_AGET_BOOLEAN: 169 case OP_AGET_BYTE: 170 case OP_AGET_CHAR: 171 case OP_AGET_SHORT: 172 case OP_APUT: 173 case OP_APUT_WIDE: 174 case OP_APUT_OBJECT: 175 case OP_APUT_BOOLEAN: 176 case OP_APUT_BYTE: 177 case OP_APUT_CHAR: 178 case OP_APUT_SHORT: 179 case OP_IGET: 180 case OP_IGET_WIDE: 181 case OP_IGET_OBJECT: 182 case OP_IGET_BOOLEAN: 183 case OP_IGET_BYTE: 184 case OP_IGET_CHAR: 185 case OP_IGET_SHORT: 186 case OP_IPUT: 187 case OP_IPUT_WIDE: 188 case OP_IPUT_OBJECT: 189 case OP_IPUT_BOOLEAN: 190 case OP_IPUT_BYTE: 191 case OP_IPUT_CHAR: 192 case OP_IPUT_SHORT: 193 case OP_SGET: 194 case OP_SGET_WIDE: 195 case OP_SGET_OBJECT: 196 case OP_SGET_BOOLEAN: 197 case OP_SGET_BYTE: 198 case OP_SGET_CHAR: 199 case OP_SGET_SHORT: 200 case OP_SPUT: 201 case OP_SPUT_WIDE: 202 case OP_SPUT_OBJECT: 203 case OP_SPUT_BOOLEAN: 204 case OP_SPUT_BYTE: 205 case OP_SPUT_CHAR: 206 case OP_SPUT_SHORT: 207 case OP_ADD_INT: 208 case OP_SUB_INT: 209 case OP_MUL_INT: 210 case OP_DIV_INT: 211 case OP_REM_INT: 212 case OP_AND_INT: 213 case OP_OR_INT: 214 case OP_XOR_INT: 215 case OP_SHL_INT: 216 case OP_SHR_INT: 217 case OP_USHR_INT: 218 case OP_ADD_LONG: 219 case OP_SUB_LONG: 220 case OP_MUL_LONG: 221 case OP_DIV_LONG: 222 case OP_REM_LONG: 223 case OP_AND_LONG: 224 case OP_OR_LONG: 225 case OP_XOR_LONG: 226 case OP_SHL_LONG: 227 case OP_SHR_LONG: 228 case OP_USHR_LONG: 229 case OP_ADD_FLOAT: 230 case OP_SUB_FLOAT: 231 case OP_MUL_FLOAT: 232 case OP_DIV_FLOAT: 233 case OP_REM_FLOAT: 234 case OP_ADD_DOUBLE: 235 case OP_SUB_DOUBLE: 236 case OP_MUL_DOUBLE: 237 case OP_DIV_DOUBLE: 238 case OP_REM_DOUBLE: 239 case OP_ADD_INT_LIT16: 240 case OP_RSUB_INT: 241 case OP_MUL_INT_LIT16: 242 case OP_DIV_INT_LIT16: 243 case OP_REM_INT_LIT16: 244 case OP_AND_INT_LIT16: 245 case OP_OR_INT_LIT16: 246 case OP_XOR_INT_LIT16: 247 case OP_ADD_INT_LIT8: 248 case OP_RSUB_INT_LIT8: 249 case OP_MUL_INT_LIT8: 250 case OP_DIV_INT_LIT8: 251 case OP_REM_INT_LIT8: 252 case OP_AND_INT_LIT8: 253 case OP_OR_INT_LIT8: 254 case OP_XOR_INT_LIT8: 255 case OP_SHL_INT_LIT8: 256 case OP_SHR_INT_LIT8: 257 case OP_USHR_INT_LIT8: 258 width = 2; 259 break; 260 261 case OP_MOVE_16: 262 case OP_MOVE_WIDE_16: 263 case OP_MOVE_OBJECT_16: 264 case OP_CONST: 265 case OP_CONST_WIDE_32: 266 case OP_CONST_STRING_JUMBO: 267 case OP_GOTO_32: 268 case OP_FILLED_NEW_ARRAY: 269 case OP_FILLED_NEW_ARRAY_RANGE: 270 case OP_FILL_ARRAY_DATA: 271 case OP_PACKED_SWITCH: 272 case OP_SPARSE_SWITCH: 273 case OP_INVOKE_VIRTUAL: 274 case OP_INVOKE_SUPER: 275 case OP_INVOKE_DIRECT: 276 case OP_INVOKE_STATIC: 277 case OP_INVOKE_INTERFACE: 278 case OP_INVOKE_VIRTUAL_RANGE: 279 case OP_INVOKE_SUPER_RANGE: 280 case OP_INVOKE_DIRECT_RANGE: 281 case OP_INVOKE_STATIC_RANGE: 282 case OP_INVOKE_INTERFACE_RANGE: 283 width = 3; 284 break; 285 286 case OP_CONST_WIDE: 287 width = 5; 288 break; 289 290 /* 291 * Optimized instructions. We return negative size values for these 292 * to distinguish them. 293 */ 294 case OP_IGET_QUICK: 295 case OP_IGET_WIDE_QUICK: 296 case OP_IGET_OBJECT_QUICK: 297 case OP_IPUT_QUICK: 298 case OP_IPUT_WIDE_QUICK: 299 case OP_IPUT_OBJECT_QUICK: 300 case OP_IGET_VOLATILE: 301 case OP_IPUT_VOLATILE: 302 case OP_SGET_VOLATILE: 303 case OP_SPUT_VOLATILE: 304 case OP_IGET_OBJECT_VOLATILE: 305 case OP_IPUT_OBJECT_VOLATILE: 306 case OP_SGET_OBJECT_VOLATILE: 307 case OP_SPUT_OBJECT_VOLATILE: 308 case OP_IGET_WIDE_VOLATILE: 309 case OP_IPUT_WIDE_VOLATILE: 310 case OP_SGET_WIDE_VOLATILE: 311 case OP_SPUT_WIDE_VOLATILE: 312 case OP_THROW_VERIFICATION_ERROR: 313 width = -2; 314 break; 315 case OP_INVOKE_VIRTUAL_QUICK: 316 case OP_INVOKE_VIRTUAL_QUICK_RANGE: 317 case OP_INVOKE_SUPER_QUICK: 318 case OP_INVOKE_SUPER_QUICK_RANGE: 319 case OP_EXECUTE_INLINE: 320 case OP_EXECUTE_INLINE_RANGE: 321 case OP_INVOKE_DIRECT_EMPTY: 322 width = -3; 323 break; 324 325 /* these should never appear when scanning bytecode */ 326 case OP_UNUSED_3E: 327 case OP_UNUSED_3F: 328 case OP_UNUSED_40: 329 case OP_UNUSED_41: 330 case OP_UNUSED_42: 331 case OP_UNUSED_43: 332 case OP_UNUSED_73: 333 case OP_UNUSED_79: 334 case OP_UNUSED_7A: 335 case OP_BREAKPOINT: 336 case OP_UNUSED_F1: 337 case OP_UNUSED_FF: 338 assert(width == 0); 339 break; 340 341 /* 342 * DO NOT add a "default" clause here. Without it the compiler will 343 * complain if an instruction is missing (which is desirable). 344 */ 345 } 346 347 instrWidth[opc] = width; 348 } 349 350 return instrWidth; 351 } 352 353 /* 354 * Generate a table that holds instruction flags. 355 */ 356 InstructionFlags* dexCreateInstrFlagsTable(void) 357 { 358 InstructionFlags* instrFlags; 359 int i; 360 361 instrFlags = malloc(sizeof(InstructionFlags) * kNumDalvikInstructions); 362 if (instrFlags == NULL) 363 return NULL; 364 365 for (i = 0; i < kNumDalvikInstructions; i++) { 366 OpCode opc = (OpCode) i; 367 InstructionFlags flags = 0; 368 369 switch (opc) { 370 /* these don't affect the PC and can't cause an exception */ 371 case OP_NOP: 372 case OP_MOVE: 373 case OP_MOVE_FROM16: 374 case OP_MOVE_16: 375 case OP_MOVE_WIDE: 376 case OP_MOVE_WIDE_FROM16: 377 case OP_MOVE_WIDE_16: 378 case OP_MOVE_OBJECT: 379 case OP_MOVE_OBJECT_FROM16: 380 case OP_MOVE_OBJECT_16: 381 case OP_MOVE_RESULT: 382 case OP_MOVE_RESULT_WIDE: 383 case OP_MOVE_RESULT_OBJECT: 384 case OP_MOVE_EXCEPTION: 385 case OP_CONST_4: 386 case OP_CONST_16: 387 case OP_CONST: 388 case OP_CONST_HIGH16: 389 case OP_CONST_WIDE_16: 390 case OP_CONST_WIDE_32: 391 case OP_CONST_WIDE: 392 case OP_CONST_WIDE_HIGH16: 393 case OP_FILL_ARRAY_DATA: 394 case OP_CMPL_FLOAT: 395 case OP_CMPG_FLOAT: 396 case OP_CMPL_DOUBLE: 397 case OP_CMPG_DOUBLE: 398 case OP_CMP_LONG: 399 case OP_NEG_INT: 400 case OP_NOT_INT: 401 case OP_NEG_LONG: 402 case OP_NOT_LONG: 403 case OP_NEG_FLOAT: 404 case OP_NEG_DOUBLE: 405 case OP_INT_TO_LONG: 406 case OP_INT_TO_FLOAT: 407 case OP_INT_TO_DOUBLE: 408 case OP_LONG_TO_INT: 409 case OP_LONG_TO_FLOAT: 410 case OP_LONG_TO_DOUBLE: 411 case OP_FLOAT_TO_INT: 412 case OP_FLOAT_TO_LONG: 413 case OP_FLOAT_TO_DOUBLE: 414 case OP_DOUBLE_TO_INT: 415 case OP_DOUBLE_TO_LONG: 416 case OP_DOUBLE_TO_FLOAT: 417 case OP_INT_TO_BYTE: 418 case OP_INT_TO_CHAR: 419 case OP_INT_TO_SHORT: 420 case OP_ADD_INT: 421 case OP_SUB_INT: 422 case OP_MUL_INT: 423 case OP_AND_INT: 424 case OP_OR_INT: 425 case OP_XOR_INT: 426 case OP_SHL_INT: 427 case OP_SHR_INT: 428 case OP_USHR_INT: 429 case OP_ADD_LONG: 430 case OP_SUB_LONG: 431 case OP_MUL_LONG: 432 case OP_AND_LONG: 433 case OP_OR_LONG: 434 case OP_XOR_LONG: 435 case OP_SHL_LONG: 436 case OP_SHR_LONG: 437 case OP_USHR_LONG: 438 case OP_ADD_FLOAT: 439 case OP_SUB_FLOAT: 440 case OP_MUL_FLOAT: 441 case OP_DIV_FLOAT: 442 case OP_REM_FLOAT: 443 case OP_ADD_DOUBLE: 444 case OP_SUB_DOUBLE: 445 case OP_MUL_DOUBLE: 446 case OP_DIV_DOUBLE: // div by zero just returns NaN 447 case OP_REM_DOUBLE: 448 case OP_ADD_INT_2ADDR: 449 case OP_SUB_INT_2ADDR: 450 case OP_MUL_INT_2ADDR: 451 case OP_AND_INT_2ADDR: 452 case OP_OR_INT_2ADDR: 453 case OP_XOR_INT_2ADDR: 454 case OP_SHL_INT_2ADDR: 455 case OP_SHR_INT_2ADDR: 456 case OP_USHR_INT_2ADDR: 457 case OP_ADD_LONG_2ADDR: 458 case OP_SUB_LONG_2ADDR: 459 case OP_MUL_LONG_2ADDR: 460 case OP_AND_LONG_2ADDR: 461 case OP_OR_LONG_2ADDR: 462 case OP_XOR_LONG_2ADDR: 463 case OP_SHL_LONG_2ADDR: 464 case OP_SHR_LONG_2ADDR: 465 case OP_USHR_LONG_2ADDR: 466 case OP_ADD_FLOAT_2ADDR: 467 case OP_SUB_FLOAT_2ADDR: 468 case OP_MUL_FLOAT_2ADDR: 469 case OP_DIV_FLOAT_2ADDR: 470 case OP_REM_FLOAT_2ADDR: 471 case OP_ADD_DOUBLE_2ADDR: 472 case OP_SUB_DOUBLE_2ADDR: 473 case OP_MUL_DOUBLE_2ADDR: 474 case OP_DIV_DOUBLE_2ADDR: 475 case OP_REM_DOUBLE_2ADDR: 476 case OP_ADD_INT_LIT16: 477 case OP_RSUB_INT: 478 case OP_MUL_INT_LIT16: 479 case OP_AND_INT_LIT16: 480 case OP_OR_INT_LIT16: 481 case OP_XOR_INT_LIT16: 482 case OP_ADD_INT_LIT8: 483 case OP_RSUB_INT_LIT8: 484 case OP_MUL_INT_LIT8: 485 case OP_AND_INT_LIT8: 486 case OP_OR_INT_LIT8: 487 case OP_XOR_INT_LIT8: 488 case OP_SHL_INT_LIT8: 489 case OP_SHR_INT_LIT8: 490 case OP_USHR_INT_LIT8: 491 flags = kInstrCanContinue; 492 break; 493 494 /* these don't affect the PC, but can cause exceptions */ 495 case OP_CONST_STRING: 496 case OP_CONST_STRING_JUMBO: 497 case OP_CONST_CLASS: 498 case OP_MONITOR_ENTER: 499 case OP_MONITOR_EXIT: 500 case OP_CHECK_CAST: 501 case OP_INSTANCE_OF: 502 case OP_ARRAY_LENGTH: 503 case OP_NEW_INSTANCE: 504 case OP_NEW_ARRAY: 505 case OP_FILLED_NEW_ARRAY: 506 case OP_FILLED_NEW_ARRAY_RANGE: 507 case OP_AGET: 508 case OP_AGET_BOOLEAN: 509 case OP_AGET_BYTE: 510 case OP_AGET_CHAR: 511 case OP_AGET_SHORT: 512 case OP_AGET_WIDE: 513 case OP_AGET_OBJECT: 514 case OP_APUT: 515 case OP_APUT_BOOLEAN: 516 case OP_APUT_BYTE: 517 case OP_APUT_CHAR: 518 case OP_APUT_SHORT: 519 case OP_APUT_WIDE: 520 case OP_APUT_OBJECT: 521 case OP_IGET: 522 case OP_IGET_BOOLEAN: 523 case OP_IGET_BYTE: 524 case OP_IGET_CHAR: 525 case OP_IGET_SHORT: 526 case OP_IGET_WIDE: 527 case OP_IGET_OBJECT: 528 case OP_IPUT: 529 case OP_IPUT_BOOLEAN: 530 case OP_IPUT_BYTE: 531 case OP_IPUT_CHAR: 532 case OP_IPUT_SHORT: 533 case OP_IPUT_WIDE: 534 case OP_IPUT_OBJECT: 535 case OP_SGET: 536 case OP_SGET_BOOLEAN: 537 case OP_SGET_BYTE: 538 case OP_SGET_CHAR: 539 case OP_SGET_SHORT: 540 case OP_SGET_WIDE: 541 case OP_SGET_OBJECT: 542 case OP_SPUT: 543 case OP_SPUT_BOOLEAN: 544 case OP_SPUT_BYTE: 545 case OP_SPUT_CHAR: 546 case OP_SPUT_SHORT: 547 case OP_SPUT_WIDE: 548 case OP_SPUT_OBJECT: 549 case OP_DIV_INT: 550 case OP_REM_INT: 551 case OP_DIV_LONG: 552 case OP_REM_LONG: 553 case OP_DIV_INT_2ADDR: 554 case OP_REM_INT_2ADDR: 555 case OP_DIV_LONG_2ADDR: 556 case OP_REM_LONG_2ADDR: 557 case OP_DIV_INT_LIT16: 558 case OP_REM_INT_LIT16: 559 case OP_DIV_INT_LIT8: 560 case OP_REM_INT_LIT8: 561 flags = kInstrCanContinue | kInstrCanThrow; 562 break; 563 564 case OP_INVOKE_VIRTUAL: 565 case OP_INVOKE_VIRTUAL_RANGE: 566 case OP_INVOKE_SUPER: 567 case OP_INVOKE_SUPER_RANGE: 568 case OP_INVOKE_DIRECT: 569 case OP_INVOKE_DIRECT_RANGE: 570 case OP_INVOKE_STATIC: 571 case OP_INVOKE_STATIC_RANGE: 572 case OP_INVOKE_INTERFACE: 573 case OP_INVOKE_INTERFACE_RANGE: 574 flags = kInstrCanContinue | kInstrCanThrow | kInstrInvoke; 575 break; 576 577 case OP_RETURN_VOID: 578 case OP_RETURN: 579 case OP_RETURN_WIDE: 580 case OP_RETURN_OBJECT: 581 flags = kInstrCanReturn; 582 break; 583 584 case OP_THROW: 585 flags = kInstrCanThrow; 586 break; 587 588 /* unconditional branches */ 589 case OP_GOTO: 590 case OP_GOTO_16: 591 case OP_GOTO_32: 592 flags = kInstrCanBranch | kInstrUnconditional; 593 break; 594 595 /* conditional branches */ 596 case OP_IF_EQ: 597 case OP_IF_NE: 598 case OP_IF_LT: 599 case OP_IF_GE: 600 case OP_IF_GT: 601 case OP_IF_LE: 602 case OP_IF_EQZ: 603 case OP_IF_NEZ: 604 case OP_IF_LTZ: 605 case OP_IF_GEZ: 606 case OP_IF_GTZ: 607 case OP_IF_LEZ: 608 flags = kInstrCanBranch | kInstrCanContinue; 609 break; 610 611 /* switch statements; if value not in switch, it continues */ 612 case OP_PACKED_SWITCH: 613 case OP_SPARSE_SWITCH: 614 flags = kInstrCanSwitch | kInstrCanContinue; 615 break; 616 617 /* verifier/optimizer-generated instructions */ 618 case OP_THROW_VERIFICATION_ERROR: 619 flags = kInstrCanThrow; 620 break; 621 case OP_EXECUTE_INLINE: 622 case OP_EXECUTE_INLINE_RANGE: 623 flags = kInstrCanContinue | kInstrCanThrow; 624 break; 625 case OP_IGET_QUICK: 626 case OP_IGET_WIDE_QUICK: 627 case OP_IGET_OBJECT_QUICK: 628 case OP_IPUT_QUICK: 629 case OP_IPUT_WIDE_QUICK: 630 case OP_IPUT_OBJECT_QUICK: 631 case OP_IGET_VOLATILE: 632 case OP_IPUT_VOLATILE: 633 case OP_SGET_VOLATILE: 634 case OP_SPUT_VOLATILE: 635 case OP_IGET_OBJECT_VOLATILE: 636 case OP_IPUT_OBJECT_VOLATILE: 637 case OP_SGET_OBJECT_VOLATILE: 638 case OP_SPUT_OBJECT_VOLATILE: 639 case OP_IGET_WIDE_VOLATILE: 640 case OP_IPUT_WIDE_VOLATILE: 641 case OP_SGET_WIDE_VOLATILE: 642 case OP_SPUT_WIDE_VOLATILE: 643 flags = kInstrCanContinue | kInstrCanThrow; 644 break; 645 646 case OP_INVOKE_VIRTUAL_QUICK: 647 case OP_INVOKE_VIRTUAL_QUICK_RANGE: 648 case OP_INVOKE_SUPER_QUICK: 649 case OP_INVOKE_SUPER_QUICK_RANGE: 650 case OP_INVOKE_DIRECT_EMPTY: 651 flags = kInstrCanContinue | kInstrCanThrow | kInstrInvoke; 652 break; 653 654 /* these should never appear when scanning code */ 655 case OP_UNUSED_3E: 656 case OP_UNUSED_3F: 657 case OP_UNUSED_40: 658 case OP_UNUSED_41: 659 case OP_UNUSED_42: 660 case OP_UNUSED_43: 661 case OP_UNUSED_73: 662 case OP_UNUSED_79: 663 case OP_UNUSED_7A: 664 case OP_BREAKPOINT: 665 case OP_UNUSED_F1: 666 case OP_UNUSED_FF: 667 break; 668 669 /* 670 * DO NOT add a "default" clause here. Without it the compiler will 671 * complain if an instruction is missing (which is desirable). 672 */ 673 } 674 675 instrFlags[opc] = flags; 676 } 677 678 return instrFlags; 679 } 680 681 /* 682 * Allocate and populate a 256-element array with instruction formats. 683 * Used in conjunction with dexDecodeInstruction. 684 */ 685 InstructionFormat* dexCreateInstrFormatTable(void) 686 { 687 InstructionFormat* instFmt; 688 int i; 689 690 instFmt = malloc(sizeof(InstructionFormat) * kNumDalvikInstructions); 691 if (instFmt == NULL) 692 return NULL; 693 694 for (i = 0; i < kNumDalvikInstructions; i++) { 695 OpCode opc = (OpCode) i; 696 InstructionFormat fmt = kFmtUnknown; 697 698 switch (opc) { 699 case OP_GOTO: 700 fmt = kFmt10t; 701 break; 702 case OP_NOP: 703 case OP_RETURN_VOID: 704 fmt = kFmt10x; 705 break; 706 case OP_CONST_4: 707 fmt = kFmt11n; 708 break; 709 case OP_CONST_HIGH16: 710 case OP_CONST_WIDE_HIGH16: 711 fmt = kFmt21h; 712 break; 713 case OP_MOVE_RESULT: 714 case OP_MOVE_RESULT_WIDE: 715 case OP_MOVE_RESULT_OBJECT: 716 case OP_MOVE_EXCEPTION: 717 case OP_RETURN: 718 case OP_RETURN_WIDE: 719 case OP_RETURN_OBJECT: 720 case OP_MONITOR_ENTER: 721 case OP_MONITOR_EXIT: 722 case OP_THROW: 723 fmt = kFmt11x; 724 break; 725 case OP_MOVE: 726 case OP_MOVE_WIDE: 727 case OP_MOVE_OBJECT: 728 case OP_ARRAY_LENGTH: 729 case OP_NEG_INT: 730 case OP_NOT_INT: 731 case OP_NEG_LONG: 732 case OP_NOT_LONG: 733 case OP_NEG_FLOAT: 734 case OP_NEG_DOUBLE: 735 case OP_INT_TO_LONG: 736 case OP_INT_TO_FLOAT: 737 case OP_INT_TO_DOUBLE: 738 case OP_LONG_TO_INT: 739 case OP_LONG_TO_FLOAT: 740 case OP_LONG_TO_DOUBLE: 741 case OP_FLOAT_TO_INT: 742 case OP_FLOAT_TO_LONG: 743 case OP_FLOAT_TO_DOUBLE: 744 case OP_DOUBLE_TO_INT: 745 case OP_DOUBLE_TO_LONG: 746 case OP_DOUBLE_TO_FLOAT: 747 case OP_INT_TO_BYTE: 748 case OP_INT_TO_CHAR: 749 case OP_INT_TO_SHORT: 750 case OP_ADD_INT_2ADDR: 751 case OP_SUB_INT_2ADDR: 752 case OP_MUL_INT_2ADDR: 753 case OP_DIV_INT_2ADDR: 754 case OP_REM_INT_2ADDR: 755 case OP_AND_INT_2ADDR: 756 case OP_OR_INT_2ADDR: 757 case OP_XOR_INT_2ADDR: 758 case OP_SHL_INT_2ADDR: 759 case OP_SHR_INT_2ADDR: 760 case OP_USHR_INT_2ADDR: 761 case OP_ADD_LONG_2ADDR: 762 case OP_SUB_LONG_2ADDR: 763 case OP_MUL_LONG_2ADDR: 764 case OP_DIV_LONG_2ADDR: 765 case OP_REM_LONG_2ADDR: 766 case OP_AND_LONG_2ADDR: 767 case OP_OR_LONG_2ADDR: 768 case OP_XOR_LONG_2ADDR: 769 case OP_SHL_LONG_2ADDR: 770 case OP_SHR_LONG_2ADDR: 771 case OP_USHR_LONG_2ADDR: 772 case OP_ADD_FLOAT_2ADDR: 773 case OP_SUB_FLOAT_2ADDR: 774 case OP_MUL_FLOAT_2ADDR: 775 case OP_DIV_FLOAT_2ADDR: 776 case OP_REM_FLOAT_2ADDR: 777 case OP_ADD_DOUBLE_2ADDR: 778 case OP_SUB_DOUBLE_2ADDR: 779 case OP_MUL_DOUBLE_2ADDR: 780 case OP_DIV_DOUBLE_2ADDR: 781 case OP_REM_DOUBLE_2ADDR: 782 fmt = kFmt12x; 783 break; 784 case OP_GOTO_16: 785 fmt = kFmt20t; 786 break; 787 case OP_GOTO_32: 788 fmt = kFmt30t; 789 break; 790 case OP_CONST_STRING: 791 case OP_CONST_CLASS: 792 case OP_CHECK_CAST: 793 case OP_NEW_INSTANCE: 794 case OP_SGET: 795 case OP_SGET_WIDE: 796 case OP_SGET_OBJECT: 797 case OP_SGET_BOOLEAN: 798 case OP_SGET_BYTE: 799 case OP_SGET_CHAR: 800 case OP_SGET_SHORT: 801 case OP_SPUT: 802 case OP_SPUT_WIDE: 803 case OP_SPUT_OBJECT: 804 case OP_SPUT_BOOLEAN: 805 case OP_SPUT_BYTE: 806 case OP_SPUT_CHAR: 807 case OP_SPUT_SHORT: 808 fmt = kFmt21c; 809 break; 810 case OP_CONST_16: 811 case OP_CONST_WIDE_16: 812 fmt = kFmt21s; 813 break; 814 case OP_IF_EQZ: 815 case OP_IF_NEZ: 816 case OP_IF_LTZ: 817 case OP_IF_GEZ: 818 case OP_IF_GTZ: 819 case OP_IF_LEZ: 820 fmt = kFmt21t; 821 break; 822 case OP_FILL_ARRAY_DATA: 823 case OP_PACKED_SWITCH: 824 case OP_SPARSE_SWITCH: 825 fmt = kFmt31t; 826 break; 827 case OP_ADD_INT_LIT8: 828 case OP_RSUB_INT_LIT8: 829 case OP_MUL_INT_LIT8: 830 case OP_DIV_INT_LIT8: 831 case OP_REM_INT_LIT8: 832 case OP_AND_INT_LIT8: 833 case OP_OR_INT_LIT8: 834 case OP_XOR_INT_LIT8: 835 case OP_SHL_INT_LIT8: 836 case OP_SHR_INT_LIT8: 837 case OP_USHR_INT_LIT8: 838 fmt = kFmt22b; 839 break; 840 case OP_INSTANCE_OF: 841 case OP_NEW_ARRAY: 842 case OP_IGET: 843 case OP_IGET_WIDE: 844 case OP_IGET_OBJECT: 845 case OP_IGET_BOOLEAN: 846 case OP_IGET_BYTE: 847 case OP_IGET_CHAR: 848 case OP_IGET_SHORT: 849 case OP_IPUT: 850 case OP_IPUT_WIDE: 851 case OP_IPUT_OBJECT: 852 case OP_IPUT_BOOLEAN: 853 case OP_IPUT_BYTE: 854 case OP_IPUT_CHAR: 855 case OP_IPUT_SHORT: 856 fmt = kFmt22c; 857 break; 858 case OP_ADD_INT_LIT16: 859 case OP_RSUB_INT: 860 case OP_MUL_INT_LIT16: 861 case OP_DIV_INT_LIT16: 862 case OP_REM_INT_LIT16: 863 case OP_AND_INT_LIT16: 864 case OP_OR_INT_LIT16: 865 case OP_XOR_INT_LIT16: 866 fmt = kFmt22s; 867 break; 868 case OP_IF_EQ: 869 case OP_IF_NE: 870 case OP_IF_LT: 871 case OP_IF_GE: 872 case OP_IF_GT: 873 case OP_IF_LE: 874 fmt = kFmt22t; 875 break; 876 case OP_MOVE_FROM16: 877 case OP_MOVE_WIDE_FROM16: 878 case OP_MOVE_OBJECT_FROM16: 879 fmt = kFmt22x; 880 break; 881 case OP_CMPL_FLOAT: 882 case OP_CMPG_FLOAT: 883 case OP_CMPL_DOUBLE: 884 case OP_CMPG_DOUBLE: 885 case OP_CMP_LONG: 886 case OP_AGET: 887 case OP_AGET_WIDE: 888 case OP_AGET_OBJECT: 889 case OP_AGET_BOOLEAN: 890 case OP_AGET_BYTE: 891 case OP_AGET_CHAR: 892 case OP_AGET_SHORT: 893 case OP_APUT: 894 case OP_APUT_WIDE: 895 case OP_APUT_OBJECT: 896 case OP_APUT_BOOLEAN: 897 case OP_APUT_BYTE: 898 case OP_APUT_CHAR: 899 case OP_APUT_SHORT: 900 case OP_ADD_INT: 901 case OP_SUB_INT: 902 case OP_MUL_INT: 903 case OP_DIV_INT: 904 case OP_REM_INT: 905 case OP_AND_INT: 906 case OP_OR_INT: 907 case OP_XOR_INT: 908 case OP_SHL_INT: 909 case OP_SHR_INT: 910 case OP_USHR_INT: 911 case OP_ADD_LONG: 912 case OP_SUB_LONG: 913 case OP_MUL_LONG: 914 case OP_DIV_LONG: 915 case OP_REM_LONG: 916 case OP_AND_LONG: 917 case OP_OR_LONG: 918 case OP_XOR_LONG: 919 case OP_SHL_LONG: 920 case OP_SHR_LONG: 921 case OP_USHR_LONG: 922 case OP_ADD_FLOAT: 923 case OP_SUB_FLOAT: 924 case OP_MUL_FLOAT: 925 case OP_DIV_FLOAT: 926 case OP_REM_FLOAT: 927 case OP_ADD_DOUBLE: 928 case OP_SUB_DOUBLE: 929 case OP_MUL_DOUBLE: 930 case OP_DIV_DOUBLE: 931 case OP_REM_DOUBLE: 932 fmt = kFmt23x; 933 break; 934 case OP_CONST: 935 case OP_CONST_WIDE_32: 936 fmt = kFmt31i; 937 break; 938 case OP_CONST_STRING_JUMBO: 939 fmt = kFmt31c; 940 break; 941 case OP_MOVE_16: 942 case OP_MOVE_WIDE_16: 943 case OP_MOVE_OBJECT_16: 944 fmt = kFmt32x; 945 break; 946 case OP_FILLED_NEW_ARRAY: 947 case OP_INVOKE_VIRTUAL: 948 case OP_INVOKE_SUPER: 949 case OP_INVOKE_DIRECT: 950 case OP_INVOKE_STATIC: 951 case OP_INVOKE_INTERFACE: 952 fmt = kFmt35c; 953 break; 954 case OP_FILLED_NEW_ARRAY_RANGE: 955 case OP_INVOKE_VIRTUAL_RANGE: 956 case OP_INVOKE_SUPER_RANGE: 957 case OP_INVOKE_DIRECT_RANGE: 958 case OP_INVOKE_STATIC_RANGE: 959 case OP_INVOKE_INTERFACE_RANGE: 960 fmt = kFmt3rc; 961 break; 962 case OP_CONST_WIDE: 963 fmt = kFmt51l; 964 break; 965 966 /* 967 * Optimized instructions. 968 */ 969 case OP_THROW_VERIFICATION_ERROR: 970 fmt = kFmt20bc; 971 break; 972 case OP_IGET_WIDE_VOLATILE: 973 case OP_IPUT_WIDE_VOLATILE: 974 case OP_IGET_VOLATILE: 975 case OP_IPUT_VOLATILE: 976 case OP_IGET_OBJECT_VOLATILE: 977 case OP_IPUT_OBJECT_VOLATILE: 978 fmt = kFmt22c; 979 break; 980 case OP_SGET_OBJECT_VOLATILE: 981 case OP_SPUT_OBJECT_VOLATILE: 982 case OP_SGET_VOLATILE: 983 case OP_SPUT_VOLATILE: 984 case OP_SGET_WIDE_VOLATILE: 985 case OP_SPUT_WIDE_VOLATILE: 986 fmt = kFmt21c; 987 break; 988 case OP_IGET_QUICK: 989 case OP_IGET_WIDE_QUICK: 990 case OP_IGET_OBJECT_QUICK: 991 case OP_IPUT_QUICK: 992 case OP_IPUT_WIDE_QUICK: 993 case OP_IPUT_OBJECT_QUICK: 994 fmt = kFmt22cs; 995 break; 996 case OP_INVOKE_VIRTUAL_QUICK: 997 case OP_INVOKE_SUPER_QUICK: 998 fmt = kFmt35ms; 999 break; 1000 case OP_INVOKE_VIRTUAL_QUICK_RANGE: 1001 case OP_INVOKE_SUPER_QUICK_RANGE: 1002 fmt = kFmt3rms; 1003 break; 1004 case OP_EXECUTE_INLINE: 1005 fmt = kFmt3inline; 1006 break; 1007 case OP_EXECUTE_INLINE_RANGE: 1008 fmt = kFmt3rinline; 1009 break; 1010 case OP_INVOKE_DIRECT_EMPTY: 1011 fmt = kFmt35c; 1012 break; 1013 1014 /* these should never appear when scanning code */ 1015 case OP_UNUSED_3E: 1016 case OP_UNUSED_3F: 1017 case OP_UNUSED_40: 1018 case OP_UNUSED_41: 1019 case OP_UNUSED_42: 1020 case OP_UNUSED_43: 1021 case OP_UNUSED_73: 1022 case OP_UNUSED_79: 1023 case OP_UNUSED_7A: 1024 case OP_BREAKPOINT: 1025 case OP_UNUSED_F1: 1026 case OP_UNUSED_FF: 1027 fmt = kFmtUnknown; 1028 break; 1029 1030 /* 1031 * DO NOT add a "default" clause here. Without it the compiler will 1032 * complain if an instruction is missing (which is desirable). 1033 */ 1034 } 1035 1036 instFmt[opc] = fmt; 1037 } 1038 1039 return instFmt; 1040 } 1041 1042 /* 1043 * Copied from InterpCore.h. Used for instruction decoding. 1044 */ 1045 #define FETCH(_offset) (insns[(_offset)]) 1046 #define INST_INST(_inst) ((_inst) & 0xff) 1047 #define INST_A(_inst) (((u2)(_inst) >> 8) & 0x0f) 1048 #define INST_B(_inst) ((u2)(_inst) >> 12) 1049 #define INST_AA(_inst) ((_inst) >> 8) 1050 1051 /* 1052 * Decode the instruction pointed to by "insns". 1053 * 1054 * Fills out the pieces of "pDec" that are affected by the current 1055 * instruction. Does not touch anything else. 1056 */ 1057 void dexDecodeInstruction(const InstructionFormat* fmts, const u2* insns, 1058 DecodedInstruction* pDec) 1059 { 1060 u2 inst = *insns; 1061 1062 pDec->opCode = (OpCode) INST_INST(inst); 1063 1064 switch (dexGetInstrFormat(fmts, pDec->opCode)) { 1065 case kFmt10x: // op 1066 /* nothing to do; copy the AA bits out for the verifier */ 1067 pDec->vA = INST_AA(inst); 1068 break; 1069 case kFmt12x: // op vA, vB 1070 pDec->vA = INST_A(inst); 1071 pDec->vB = INST_B(inst); 1072 break; 1073 case kFmt11n: // op vA, #+B 1074 pDec->vA = INST_A(inst); 1075 pDec->vB = (s4) (INST_B(inst) << 28) >> 28; // sign extend 4-bit value 1076 break; 1077 case kFmt11x: // op vAA 1078 pDec->vA = INST_AA(inst); 1079 break; 1080 case kFmt10t: // op +AA 1081 pDec->vA = (s1) INST_AA(inst); // sign-extend 8-bit value 1082 break; 1083 case kFmt20t: // op +AAAA 1084 pDec->vA = (s2) FETCH(1); // sign-extend 16-bit value 1085 break; 1086 case kFmt20bc: // op AA, thing@BBBB 1087 case kFmt21c: // op vAA, thing@BBBB 1088 case kFmt22x: // op vAA, vBBBB 1089 pDec->vA = INST_AA(inst); 1090 pDec->vB = FETCH(1); 1091 break; 1092 case kFmt21s: // op vAA, #+BBBB 1093 case kFmt21t: // op vAA, +BBBB 1094 pDec->vA = INST_AA(inst); 1095 pDec->vB = (s2) FETCH(1); // sign-extend 16-bit value 1096 break; 1097 case kFmt21h: // op vAA, #+BBBB0000[00000000] 1098 pDec->vA = INST_AA(inst); 1099 /* 1100 * The value should be treated as right-zero-extended, but we don't 1101 * actually do that here. Among other things, we don't know if it's 1102 * the top bits of a 32- or 64-bit value. 1103 */ 1104 pDec->vB = FETCH(1); 1105 break; 1106 case kFmt23x: // op vAA, vBB, vCC 1107 pDec->vA = INST_AA(inst); 1108 pDec->vB = FETCH(1) & 0xff; 1109 pDec->vC = FETCH(1) >> 8; 1110 break; 1111 case kFmt22b: // op vAA, vBB, #+CC 1112 pDec->vA = INST_AA(inst); 1113 pDec->vB = FETCH(1) & 0xff; 1114 pDec->vC = (s1) (FETCH(1) >> 8); // sign-extend 8-bit value 1115 break; 1116 case kFmt22s: // op vA, vB, #+CCCC 1117 case kFmt22t: // op vA, vB, +CCCC 1118 pDec->vA = INST_A(inst); 1119 pDec->vB = INST_B(inst); 1120 pDec->vC = (s2) FETCH(1); // sign-extend 16-bit value 1121 break; 1122 case kFmt22c: // op vA, vB, thing@CCCC 1123 case kFmt22cs: // [opt] op vA, vB, field offset CCCC 1124 pDec->vA = INST_A(inst); 1125 pDec->vB = INST_B(inst); 1126 pDec->vC = FETCH(1); 1127 break; 1128 case kFmt30t: // op +AAAAAAAA 1129 pDec->vA = FETCH(1) | ((u4) FETCH(2) << 16); // signed 32-bit value 1130 break; 1131 case kFmt31t: // op vAA, +BBBBBBBB 1132 case kFmt31c: // op vAA, thing@BBBBBBBB 1133 pDec->vA = INST_AA(inst); 1134 pDec->vB = FETCH(1) | ((u4) FETCH(2) << 16); // 32-bit value 1135 break; 1136 case kFmt32x: // op vAAAA, vBBBB 1137 pDec->vA = FETCH(1); 1138 pDec->vB = FETCH(2); 1139 break; 1140 case kFmt31i: // op vAA, #+BBBBBBBB 1141 pDec->vA = INST_AA(inst); 1142 pDec->vB = FETCH(1) | ((u4) FETCH(2) << 16); 1143 break; 1144 case kFmt35c: // op vB, {vD..vG,vA}, thing@CCCC 1145 case kFmt35ms: // [opt] invoke-virtual+super 1146 { 1147 /* 1148 * The lettering changes that came about when we went from 4 args 1149 * to 5 made the "range" versions of the calls different from 1150 * the non-range versions. We have the choice between decoding 1151 * them the way the spec shows and having lots of conditionals 1152 * in the verifier, or mapping the values onto their original 1153 * registers and leaving the verifier intact. 1154 * 1155 * Current plan is to leave the verifier alone. We can fix it 1156 * later if it's architecturally unbearable. 1157 * 1158 * Bottom line: method constant is always in vB. 1159 */ 1160 u2 regList; 1161 int i, count; 1162 1163 pDec->vA = INST_B(inst); 1164 pDec->vB = FETCH(1); 1165 regList = FETCH(2); 1166 1167 if (pDec->vA > 5) { 1168 LOGW("Invalid arg count in 35c/35ms (%d)\n", pDec->vA); 1169 goto bail; 1170 } 1171 count = pDec->vA; 1172 if (count == 5) { 1173 /* 5th arg comes from A field in instruction */ 1174 pDec->arg[4] = INST_A(inst); 1175 count--; 1176 } 1177 for (i = 0; i < count; i++) { 1178 pDec->arg[i] = regList & 0x0f; 1179 regList >>= 4; 1180 } 1181 /* copy arg[0] to vC; we don't have vD/vE/vF, so ignore those */ 1182 if (pDec->vA > 0) 1183 pDec->vC = pDec->arg[0]; 1184 } 1185 break; 1186 case kFmt3inline: // [opt] inline invoke 1187 { 1188 u2 regList; 1189 int i; 1190 1191 pDec->vA = INST_B(inst); 1192 pDec->vB = FETCH(1); 1193 regList = FETCH(2); 1194 1195 if (pDec->vA > 4) { 1196 LOGW("Invalid arg count in 3inline (%d)\n", pDec->vA); 1197 goto bail; 1198 } 1199 for (i = 0; i < (int) pDec->vA; i++) { 1200 pDec->arg[i] = regList & 0x0f; 1201 regList >>= 4; 1202 } 1203 /* copy arg[0] to vC; we don't have vD/vE/vF, so ignore those */ 1204 if (pDec->vA > 0) 1205 pDec->vC = pDec->arg[0]; 1206 } 1207 break; 1208 case kFmt35fs: // [opt] invoke-interface 1209 assert(false); // TODO 1210 break; 1211 case kFmt3rc: // op {vCCCC .. v(CCCC+AA-1)}, meth@BBBB 1212 case kFmt3rms: // [opt] invoke-virtual+super/range 1213 case kFmt3rinline: // [opt] execute-inline/range 1214 pDec->vA = INST_AA(inst); 1215 pDec->vB = FETCH(1); 1216 pDec->vC = FETCH(2); 1217 break; 1218 case kFmt3rfs: // [opt] invoke-interface/range 1219 assert(false); // TODO 1220 break; 1221 case kFmt51l: // op vAA, #+BBBBBBBBBBBBBBBB 1222 pDec->vA = INST_AA(inst); 1223 pDec->vB_wide = FETCH(1); 1224 pDec->vB_wide |= (u8)FETCH(2) << 16; 1225 pDec->vB_wide |= (u8)FETCH(3) << 32; 1226 pDec->vB_wide |= (u8)FETCH(4) << 48; 1227 break; 1228 default: 1229 LOGW("Can't decode unexpected format %d (op=%d)\n", 1230 dexGetInstrFormat(fmts, pDec->opCode), pDec->opCode); 1231 assert(false); 1232 break; 1233 } 1234 1235 bail: 1236 ; 1237 } 1238 1239 /* 1240 * Return the width of the specified instruction, or 0 if not defined. Also 1241 * works for special OP_NOP entries, including switch statement data tables 1242 * and array data. 1243 */ 1244 size_t dexGetInstrOrTableWidthAbs(const InstructionWidth* widths, 1245 const u2* insns) 1246 { 1247 size_t width; 1248 1249 if (*insns == kPackedSwitchSignature) { 1250 width = 4 + insns[1] * 2; 1251 } else if (*insns == kSparseSwitchSignature) { 1252 width = 2 + insns[1] * 4; 1253 } else if (*insns == kArrayDataSignature) { 1254 u2 elemWidth = insns[1]; 1255 u4 len = insns[2] | (((u4)insns[3]) << 16); 1256 width = 4 + (elemWidth * len + 1) / 2; 1257 } else { 1258 width = dexGetInstrWidthAbs(widths, INST_INST(insns[0])); 1259 } 1260 return width; 1261 } 1262