2 * Copyright (C) 2008 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * Dalvik instruction utility functions.
20 #include "InstrUtils.h"
26 * Generate a table that holds the width of all instructions.
28 * Standard instructions have positive values, optimizer instructions
29 * have negative values, unimplemented instructions have a width of zero.
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
36 * (To save space in the binary we could generate a static table with a
37 * command-line utility.)
39 * TODO: it doesn't look like we're using the negative values anymore.
40 * Consider switching to only positive values.
42 InstructionWidth* dexCreateInstrWidthTable(void)
44 #ifdef __ARM_ARCH_7A__
45 /* hack to work around mysterious problem on emulator */
46 LOGD("creating instr width table\n");
48 InstructionWidth* instrWidth;
51 instrWidth = malloc(sizeof(InstructionWidth) * kNumDalvikInstructions);
52 if (instrWidth == NULL)
55 for (i = 0; i < kNumDalvikInstructions; i++) {
56 OpCode opc = (OpCode) i;
60 case OP_NOP: /* note data for e.g. switch-* encoded "inside" a NOP */
65 case OP_MOVE_RESULT_WIDE:
66 case OP_MOVE_RESULT_OBJECT:
67 case OP_MOVE_EXCEPTION:
71 case OP_RETURN_OBJECT:
73 case OP_MONITOR_ENTER:
86 case OP_INT_TO_DOUBLE:
88 case OP_LONG_TO_FLOAT:
89 case OP_LONG_TO_DOUBLE:
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:
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:
135 case OP_MOVE_WIDE_FROM16:
136 case OP_MOVE_OBJECT_FROM16:
138 case OP_CONST_HIGH16:
139 case OP_CONST_WIDE_16:
140 case OP_CONST_WIDE_HIGH16:
141 case OP_CONST_STRING:
145 case OP_NEW_INSTANCE:
168 case OP_AGET_BOOLEAN:
175 case OP_APUT_BOOLEAN:
182 case OP_IGET_BOOLEAN:
189 case OP_IPUT_BOOLEAN:
196 case OP_SGET_BOOLEAN:
203 case OP_SPUT_BOOLEAN:
239 case OP_ADD_INT_LIT16:
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:
254 case OP_XOR_INT_LIT8:
255 case OP_SHL_INT_LIT8:
256 case OP_SHR_INT_LIT8:
257 case OP_USHR_INT_LIT8:
262 case OP_MOVE_WIDE_16:
263 case OP_MOVE_OBJECT_16:
265 case OP_CONST_WIDE_32:
266 case OP_CONST_STRING_JUMBO:
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:
291 * Optimized instructions. We return negative size values for these
292 * to distinguish them.
295 case OP_IGET_WIDE_QUICK:
296 case OP_IGET_OBJECT_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:
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:
325 /* these should never appear when scanning bytecode */
342 * DO NOT add a "default" clause here. Without it the compiler will
343 * complain if an instruction is missing (which is desirable).
347 instrWidth[opc] = width;
354 * Generate a table that holds instruction flags.
356 InstructionFlags* dexCreateInstrFlagsTable(void)
358 InstructionFlags* instrFlags;
361 instrFlags = malloc(sizeof(InstructionFlags) * kNumDalvikInstructions);
362 if (instrFlags == NULL)
365 for (i = 0; i < kNumDalvikInstructions; i++) {
366 OpCode opc = (OpCode) i;
367 InstructionFlags flags = 0;
370 /* these don't affect the PC and can't cause an exception */
376 case OP_MOVE_WIDE_FROM16:
377 case OP_MOVE_WIDE_16:
379 case OP_MOVE_OBJECT_FROM16:
380 case OP_MOVE_OBJECT_16:
382 case OP_MOVE_RESULT_WIDE:
383 case OP_MOVE_RESULT_OBJECT:
384 case OP_MOVE_EXCEPTION:
388 case OP_CONST_HIGH16:
389 case OP_CONST_WIDE_16:
390 case OP_CONST_WIDE_32:
392 case OP_CONST_WIDE_HIGH16:
393 case OP_FILL_ARRAY_DATA:
406 case OP_INT_TO_FLOAT:
407 case OP_INT_TO_DOUBLE:
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:
419 case OP_INT_TO_SHORT:
446 case OP_DIV_DOUBLE: // div by zero just returns NaN
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:
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:
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;
494 /* these don't affect the PC, but can cause exceptions */
495 case OP_CONST_STRING:
496 case OP_CONST_STRING_JUMBO:
498 case OP_MONITOR_ENTER:
499 case OP_MONITOR_EXIT:
502 case OP_ARRAY_LENGTH:
503 case OP_NEW_INSTANCE:
505 case OP_FILLED_NEW_ARRAY:
506 case OP_FILLED_NEW_ARRAY_RANGE:
508 case OP_AGET_BOOLEAN:
515 case OP_APUT_BOOLEAN:
522 case OP_IGET_BOOLEAN:
529 case OP_IPUT_BOOLEAN:
536 case OP_SGET_BOOLEAN:
543 case OP_SPUT_BOOLEAN:
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;
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;
580 case OP_RETURN_OBJECT:
581 flags = kInstrCanReturn;
585 flags = kInstrCanThrow;
588 /* unconditional branches */
592 flags = kInstrCanBranch | kInstrUnconditional;
595 /* conditional branches */
608 flags = kInstrCanBranch | kInstrCanContinue;
611 /* switch statements; if value not in switch, it continues */
612 case OP_PACKED_SWITCH:
613 case OP_SPARSE_SWITCH:
614 flags = kInstrCanSwitch | kInstrCanContinue;
617 /* verifier/optimizer-generated instructions */
618 case OP_THROW_VERIFICATION_ERROR:
619 flags = kInstrCanThrow;
621 case OP_EXECUTE_INLINE:
622 case OP_EXECUTE_INLINE_RANGE:
623 flags = kInstrCanContinue | kInstrCanThrow;
626 case OP_IGET_WIDE_QUICK:
627 case OP_IGET_OBJECT_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;
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;
654 /* these should never appear when scanning code */
670 * DO NOT add a "default" clause here. Without it the compiler will
671 * complain if an instruction is missing (which is desirable).
675 instrFlags[opc] = flags;
682 * Allocate and populate a 256-element array with instruction formats.
683 * Used in conjunction with dexDecodeInstruction.
685 InstructionFormat* dexCreateInstrFormatTable(void)
687 InstructionFormat* instFmt;
690 instFmt = malloc(sizeof(InstructionFormat) * kNumDalvikInstructions);
694 for (i = 0; i < kNumDalvikInstructions; i++) {
695 OpCode opc = (OpCode) i;
696 InstructionFormat fmt = kFmtUnknown;
709 case OP_CONST_HIGH16:
710 case OP_CONST_WIDE_HIGH16:
714 case OP_MOVE_RESULT_WIDE:
715 case OP_MOVE_RESULT_OBJECT:
716 case OP_MOVE_EXCEPTION:
719 case OP_RETURN_OBJECT:
720 case OP_MONITOR_ENTER:
721 case OP_MONITOR_EXIT:
728 case OP_ARRAY_LENGTH:
736 case OP_INT_TO_FLOAT:
737 case OP_INT_TO_DOUBLE:
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:
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:
790 case OP_CONST_STRING:
793 case OP_NEW_INSTANCE:
797 case OP_SGET_BOOLEAN:
804 case OP_SPUT_BOOLEAN:
811 case OP_CONST_WIDE_16:
822 case OP_FILL_ARRAY_DATA:
823 case OP_PACKED_SWITCH:
824 case OP_SPARSE_SWITCH:
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:
834 case OP_XOR_INT_LIT8:
835 case OP_SHL_INT_LIT8:
836 case OP_SHR_INT_LIT8:
837 case OP_USHR_INT_LIT8:
845 case OP_IGET_BOOLEAN:
852 case OP_IPUT_BOOLEAN:
858 case OP_ADD_INT_LIT16:
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:
877 case OP_MOVE_WIDE_FROM16:
878 case OP_MOVE_OBJECT_FROM16:
889 case OP_AGET_BOOLEAN:
896 case OP_APUT_BOOLEAN:
935 case OP_CONST_WIDE_32:
938 case OP_CONST_STRING_JUMBO:
942 case OP_MOVE_WIDE_16:
943 case OP_MOVE_OBJECT_16:
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:
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:
967 * Optimized instructions.
969 case OP_THROW_VERIFICATION_ERROR:
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:
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:
989 case OP_IGET_WIDE_QUICK:
990 case OP_IGET_OBJECT_QUICK:
992 case OP_IPUT_WIDE_QUICK:
993 case OP_IPUT_OBJECT_QUICK:
996 case OP_INVOKE_VIRTUAL_QUICK:
997 case OP_INVOKE_SUPER_QUICK:
1000 case OP_INVOKE_VIRTUAL_QUICK_RANGE:
1001 case OP_INVOKE_SUPER_QUICK_RANGE:
1004 case OP_EXECUTE_INLINE:
1007 case OP_EXECUTE_INLINE_RANGE:
1010 case OP_INVOKE_DIRECT_EMPTY:
1014 /* these should never appear when scanning code */
1031 * DO NOT add a "default" clause here. Without it the compiler will
1032 * complain if an instruction is missing (which is desirable).
1043 * Copied from InterpCore.h. Used for instruction decoding.
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)
1052 * Decode the instruction pointed to by "insns".
1054 * Fills out the pieces of "pDec" that are affected by the current
1055 * instruction. Does not touch anything else.
1057 void dexDecodeInstruction(const InstructionFormat* fmts, const u2* insns,
1058 DecodedInstruction* pDec)
1062 pDec->opCode = (OpCode) INST_INST(inst);
1064 switch (dexGetInstrFormat(fmts, pDec->opCode)) {
1066 /* nothing to do; copy the AA bits out for the verifier */
1067 pDec->vA = INST_AA(inst);
1069 case kFmt12x: // op vA, vB
1070 pDec->vA = INST_A(inst);
1071 pDec->vB = INST_B(inst);
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
1077 case kFmt11x: // op vAA
1078 pDec->vA = INST_AA(inst);
1080 case kFmt10t: // op +AA
1081 pDec->vA = (s1) INST_AA(inst); // sign-extend 8-bit value
1083 case kFmt20t: // op +AAAA
1084 pDec->vA = (s2) FETCH(1); // sign-extend 16-bit value
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);
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
1097 case kFmt21h: // op vAA, #+BBBB0000[00000000]
1098 pDec->vA = INST_AA(inst);
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.
1104 pDec->vB = FETCH(1);
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;
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
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
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);
1128 case kFmt30t: // op +AAAAAAAA
1129 pDec->vA = FETCH(1) | ((u4) FETCH(2) << 16); // signed 32-bit value
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
1136 case kFmt32x: // op vAAAA, vBBBB
1137 pDec->vA = FETCH(1);
1138 pDec->vB = FETCH(2);
1140 case kFmt31i: // op vAA, #+BBBBBBBB
1141 pDec->vA = INST_AA(inst);
1142 pDec->vB = FETCH(1) | ((u4) FETCH(2) << 16);
1144 case kFmt35c: // op vB, {vD..vG,vA}, thing@CCCC
1145 case kFmt35ms: // [opt] invoke-virtual+super
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.
1155 * Current plan is to leave the verifier alone. We can fix it
1156 * later if it's architecturally unbearable.
1158 * Bottom line: method constant is always in vB.
1163 pDec->vA = INST_B(inst);
1164 pDec->vB = FETCH(1);
1168 LOGW("Invalid arg count in 35c/35ms (%d)\n", pDec->vA);
1173 /* 5th arg comes from A field in instruction */
1174 pDec->arg[4] = INST_A(inst);
1177 for (i = 0; i < count; i++) {
1178 pDec->arg[i] = regList & 0x0f;
1181 /* copy arg[0] to vC; we don't have vD/vE/vF, so ignore those */
1183 pDec->vC = pDec->arg[0];
1186 case kFmt3inline: // [opt] inline invoke
1191 pDec->vA = INST_B(inst);
1192 pDec->vB = FETCH(1);
1196 LOGW("Invalid arg count in 3inline (%d)\n", pDec->vA);
1199 for (i = 0; i < (int) pDec->vA; i++) {
1200 pDec->arg[i] = regList & 0x0f;
1203 /* copy arg[0] to vC; we don't have vD/vE/vF, so ignore those */
1205 pDec->vC = pDec->arg[0];
1208 case kFmt35fs: // [opt] invoke-interface
1209 assert(false); // TODO
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);
1218 case kFmt3rfs: // [opt] invoke-interface/range
1219 assert(false); // TODO
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;
1229 LOGW("Can't decode unexpected format %d (op=%d)\n",
1230 dexGetInstrFormat(fmts, pDec->opCode), pDec->opCode);
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
1244 size_t dexGetInstrOrTableWidthAbs(const InstructionWidth* widths,
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;
1258 width = dexGetInstrWidthAbs(widths, INST_INST(insns[0]));