InstrUtils.cpp revision a70a3d8faa8f7332549fa0c9ae2008d428e28606 
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 * IMPORTANT NOTE: Much of the contents of this file are generated
21 * automatically by the opcode-gen tool. Any edits to the generated
22 * sections will get wiped out the next time the tool is run.
23 */
24
25#include "InstrUtils.h"
26#include <stdlib.h>
27
28/*
29 * Table that maps each opcode to the full width of instructions that
30 * use that opcode, in (16-bit) code units. Unimplemented opcodes as
31 * well as the "breakpoint" opcode have a width of zero.
32 */
33static InstructionWidth gInstructionWidthTable[kNumPackedOpcodes] = {
34    // BEGIN(libdex-widths); GENERATED AUTOMATICALLY BY opcode-gen
35    1, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 1, 1, 1, 1,
36    1, 1, 1, 2, 3, 2, 2, 3, 5, 2, 2, 3, 2, 1, 1, 2,
37    2, 1, 2, 2, 3, 3, 3, 1, 1, 2, 3, 3, 3, 2, 2, 2,
38    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0,
39    0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
40    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
41    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3,
42    3, 3, 3, 0, 3, 3, 3, 3, 3, 0, 0, 1, 1, 1, 1, 1,
43    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
44    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
45    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
46    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
49    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 3, 3,
50    3, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 0,
51    4, 4, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
52    5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
53    4, 4, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
56    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
58    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
59    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
60    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
62    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
63    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
64    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
66    0, 0, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4,
67    // END(libdex-widths)
68};
69
70/*
71 * Table that maps each opcode to the flags associated with that
72 * opcode.
73 */
74static u1 gOpcodeFlagsTable[kNumPackedOpcodes] = {
75    // BEGIN(libdex-flags); GENERATED AUTOMATICALLY BY opcode-gen
76    kInstrCanContinue,
77    kInstrCanContinue,
78    kInstrCanContinue,
79    kInstrCanContinue,
80    kInstrCanContinue,
81    kInstrCanContinue,
82    kInstrCanContinue,
83    kInstrCanContinue,
84    kInstrCanContinue,
85    kInstrCanContinue,
86    kInstrCanContinue,
87    kInstrCanContinue,
88    kInstrCanContinue,
89    kInstrCanContinue,
90    kInstrCanReturn,
91    kInstrCanReturn,
92    kInstrCanReturn,
93    kInstrCanReturn,
94    kInstrCanContinue,
95    kInstrCanContinue,
96    kInstrCanContinue,
97    kInstrCanContinue,
98    kInstrCanContinue,
99    kInstrCanContinue,
100    kInstrCanContinue,
101    kInstrCanContinue,
102    kInstrCanContinue|kInstrCanThrow,
103    kInstrCanContinue|kInstrCanThrow,
104    kInstrCanContinue|kInstrCanThrow,
105    kInstrCanContinue|kInstrCanThrow,
106    kInstrCanContinue|kInstrCanThrow,
107    kInstrCanContinue|kInstrCanThrow,
108    kInstrCanContinue|kInstrCanThrow,
109    kInstrCanContinue|kInstrCanThrow,
110    kInstrCanContinue|kInstrCanThrow,
111    kInstrCanContinue|kInstrCanThrow,
112    kInstrCanContinue|kInstrCanThrow,
113    kInstrCanContinue|kInstrCanThrow,
114    kInstrCanContinue,
115    kInstrCanThrow,
116    kInstrCanBranch,
117    kInstrCanBranch,
118    kInstrCanBranch,
119    kInstrCanContinue|kInstrCanSwitch,
120    kInstrCanContinue|kInstrCanSwitch,
121    kInstrCanContinue,
122    kInstrCanContinue,
123    kInstrCanContinue,
124    kInstrCanContinue,
125    kInstrCanContinue,
126    kInstrCanContinue|kInstrCanBranch,
127    kInstrCanContinue|kInstrCanBranch,
128    kInstrCanContinue|kInstrCanBranch,
129    kInstrCanContinue|kInstrCanBranch,
130    kInstrCanContinue|kInstrCanBranch,
131    kInstrCanContinue|kInstrCanBranch,
132    kInstrCanContinue|kInstrCanBranch,
133    kInstrCanContinue|kInstrCanBranch,
134    kInstrCanContinue|kInstrCanBranch,
135    kInstrCanContinue|kInstrCanBranch,
136    kInstrCanContinue|kInstrCanBranch,
137    kInstrCanContinue|kInstrCanBranch,
138    0,
139    0,
140    0,
141    0,
142    0,
143    0,
144    kInstrCanContinue|kInstrCanThrow,
145    kInstrCanContinue|kInstrCanThrow,
146    kInstrCanContinue|kInstrCanThrow,
147    kInstrCanContinue|kInstrCanThrow,
148    kInstrCanContinue|kInstrCanThrow,
149    kInstrCanContinue|kInstrCanThrow,
150    kInstrCanContinue|kInstrCanThrow,
151    kInstrCanContinue|kInstrCanThrow,
152    kInstrCanContinue|kInstrCanThrow,
153    kInstrCanContinue|kInstrCanThrow,
154    kInstrCanContinue|kInstrCanThrow,
155    kInstrCanContinue|kInstrCanThrow,
156    kInstrCanContinue|kInstrCanThrow,
157    kInstrCanContinue|kInstrCanThrow,
158    kInstrCanContinue|kInstrCanThrow,
159    kInstrCanContinue|kInstrCanThrow,
160    kInstrCanContinue|kInstrCanThrow,
161    kInstrCanContinue|kInstrCanThrow,
162    kInstrCanContinue|kInstrCanThrow,
163    kInstrCanContinue|kInstrCanThrow,
164    kInstrCanContinue|kInstrCanThrow,
165    kInstrCanContinue|kInstrCanThrow,
166    kInstrCanContinue|kInstrCanThrow,
167    kInstrCanContinue|kInstrCanThrow,
168    kInstrCanContinue|kInstrCanThrow,
169    kInstrCanContinue|kInstrCanThrow,
170    kInstrCanContinue|kInstrCanThrow,
171    kInstrCanContinue|kInstrCanThrow,
172    kInstrCanContinue|kInstrCanThrow,
173    kInstrCanContinue|kInstrCanThrow,
174    kInstrCanContinue|kInstrCanThrow,
175    kInstrCanContinue|kInstrCanThrow,
176    kInstrCanContinue|kInstrCanThrow,
177    kInstrCanContinue|kInstrCanThrow,
178    kInstrCanContinue|kInstrCanThrow,
179    kInstrCanContinue|kInstrCanThrow,
180    kInstrCanContinue|kInstrCanThrow,
181    kInstrCanContinue|kInstrCanThrow,
182    kInstrCanContinue|kInstrCanThrow,
183    kInstrCanContinue|kInstrCanThrow,
184    kInstrCanContinue|kInstrCanThrow,
185    kInstrCanContinue|kInstrCanThrow,
186    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
187    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
188    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
189    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
190    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
191    0,
192    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
193    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
194    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
195    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
196    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
197    0,
198    0,
199    kInstrCanContinue,
200    kInstrCanContinue,
201    kInstrCanContinue,
202    kInstrCanContinue,
203    kInstrCanContinue,
204    kInstrCanContinue,
205    kInstrCanContinue,
206    kInstrCanContinue,
207    kInstrCanContinue,
208    kInstrCanContinue,
209    kInstrCanContinue,
210    kInstrCanContinue,
211    kInstrCanContinue,
212    kInstrCanContinue,
213    kInstrCanContinue,
214    kInstrCanContinue,
215    kInstrCanContinue,
216    kInstrCanContinue,
217    kInstrCanContinue,
218    kInstrCanContinue,
219    kInstrCanContinue,
220    kInstrCanContinue,
221    kInstrCanContinue,
222    kInstrCanContinue,
223    kInstrCanContinue|kInstrCanThrow,
224    kInstrCanContinue|kInstrCanThrow,
225    kInstrCanContinue,
226    kInstrCanContinue,
227    kInstrCanContinue,
228    kInstrCanContinue,
229    kInstrCanContinue,
230    kInstrCanContinue,
231    kInstrCanContinue,
232    kInstrCanContinue,
233    kInstrCanContinue,
234    kInstrCanContinue|kInstrCanThrow,
235    kInstrCanContinue|kInstrCanThrow,
236    kInstrCanContinue,
237    kInstrCanContinue,
238    kInstrCanContinue,
239    kInstrCanContinue,
240    kInstrCanContinue,
241    kInstrCanContinue,
242    kInstrCanContinue,
243    kInstrCanContinue,
244    kInstrCanContinue,
245    kInstrCanContinue,
246    kInstrCanContinue,
247    kInstrCanContinue,
248    kInstrCanContinue,
249    kInstrCanContinue,
250    kInstrCanContinue,
251    kInstrCanContinue,
252    kInstrCanContinue,
253    kInstrCanContinue,
254    kInstrCanContinue,
255    kInstrCanContinue|kInstrCanThrow,
256    kInstrCanContinue|kInstrCanThrow,
257    kInstrCanContinue,
258    kInstrCanContinue,
259    kInstrCanContinue,
260    kInstrCanContinue,
261    kInstrCanContinue,
262    kInstrCanContinue,
263    kInstrCanContinue,
264    kInstrCanContinue,
265    kInstrCanContinue,
266    kInstrCanContinue|kInstrCanThrow,
267    kInstrCanContinue|kInstrCanThrow,
268    kInstrCanContinue,
269    kInstrCanContinue,
270    kInstrCanContinue,
271    kInstrCanContinue,
272    kInstrCanContinue,
273    kInstrCanContinue,
274    kInstrCanContinue,
275    kInstrCanContinue,
276    kInstrCanContinue,
277    kInstrCanContinue,
278    kInstrCanContinue,
279    kInstrCanContinue,
280    kInstrCanContinue,
281    kInstrCanContinue,
282    kInstrCanContinue,
283    kInstrCanContinue,
284    kInstrCanContinue,
285    kInstrCanContinue,
286    kInstrCanContinue,
287    kInstrCanContinue|kInstrCanThrow,
288    kInstrCanContinue|kInstrCanThrow,
289    kInstrCanContinue,
290    kInstrCanContinue,
291    kInstrCanContinue,
292    kInstrCanContinue,
293    kInstrCanContinue,
294    kInstrCanContinue,
295    kInstrCanContinue|kInstrCanThrow,
296    kInstrCanContinue|kInstrCanThrow,
297    kInstrCanContinue,
298    kInstrCanContinue,
299    kInstrCanContinue,
300    kInstrCanContinue,
301    kInstrCanContinue,
302    kInstrCanContinue,
303    kInstrCanContinue|kInstrCanThrow,
304    kInstrCanContinue|kInstrCanThrow,
305    kInstrCanContinue|kInstrCanThrow,
306    kInstrCanContinue|kInstrCanThrow,
307    kInstrCanContinue|kInstrCanThrow,
308    kInstrCanContinue|kInstrCanThrow,
309    kInstrCanContinue|kInstrCanThrow,
310    kInstrCanContinue|kInstrCanThrow,
311    kInstrCanContinue|kInstrCanThrow,
312    0,
313    kInstrCanThrow,
314    kInstrCanContinue|kInstrCanThrow,
315    kInstrCanContinue|kInstrCanThrow,
316    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
317    kInstrCanReturn,
318    kInstrCanContinue|kInstrCanThrow,
319    kInstrCanContinue|kInstrCanThrow,
320    kInstrCanContinue|kInstrCanThrow,
321    kInstrCanContinue|kInstrCanThrow,
322    kInstrCanContinue|kInstrCanThrow,
323    kInstrCanContinue|kInstrCanThrow,
324    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
325    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
326    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
327    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
328    kInstrCanContinue|kInstrCanThrow,
329    kInstrCanContinue|kInstrCanThrow,
330    kInstrCanContinue|kInstrCanThrow,
331    0,
332    kInstrCanContinue|kInstrCanThrow,
333    kInstrCanContinue|kInstrCanThrow,
334    kInstrCanContinue|kInstrCanThrow,
335    kInstrCanContinue|kInstrCanThrow,
336    kInstrCanContinue|kInstrCanThrow,
337    kInstrCanContinue|kInstrCanThrow,
338    kInstrCanContinue|kInstrCanThrow,
339    kInstrCanContinue|kInstrCanThrow,
340    kInstrCanContinue|kInstrCanThrow,
341    kInstrCanContinue|kInstrCanThrow,
342    kInstrCanContinue|kInstrCanThrow,
343    kInstrCanContinue|kInstrCanThrow,
344    kInstrCanContinue|kInstrCanThrow,
345    kInstrCanContinue|kInstrCanThrow,
346    kInstrCanContinue|kInstrCanThrow,
347    kInstrCanContinue|kInstrCanThrow,
348    kInstrCanContinue|kInstrCanThrow,
349    kInstrCanContinue|kInstrCanThrow,
350    kInstrCanContinue|kInstrCanThrow,
351    kInstrCanContinue|kInstrCanThrow,
352    kInstrCanContinue|kInstrCanThrow,
353    kInstrCanContinue|kInstrCanThrow,
354    kInstrCanContinue|kInstrCanThrow,
355    kInstrCanContinue|kInstrCanThrow,
356    kInstrCanContinue|kInstrCanThrow,
357    kInstrCanContinue|kInstrCanThrow,
358    kInstrCanContinue|kInstrCanThrow,
359    kInstrCanContinue|kInstrCanThrow,
360    kInstrCanContinue|kInstrCanThrow,
361    kInstrCanContinue|kInstrCanThrow,
362    kInstrCanContinue|kInstrCanThrow,
363    kInstrCanContinue|kInstrCanThrow,
364    kInstrCanContinue|kInstrCanThrow,
365    kInstrCanContinue|kInstrCanThrow,
366    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
367    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
368    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
369    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
370    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
371    0,
372    0,
373    0,
374    0,
375    0,
376    0,
377    0,
378    0,
379    0,
380    0,
381    0,
382    0,
383    0,
384    0,
385    0,
386    0,
387    0,
388    0,
389    0,
390    0,
391    0,
392    0,
393    0,
394    0,
395    0,
396    0,
397    0,
398    0,
399    0,
400    0,
401    0,
402    0,
403    0,
404    0,
405    0,
406    0,
407    0,
408    0,
409    0,
410    0,
411    0,
412    0,
413    0,
414    0,
415    0,
416    0,
417    0,
418    0,
419    0,
420    0,
421    0,
422    0,
423    0,
424    0,
425    0,
426    0,
427    0,
428    0,
429    0,
430    0,
431    0,
432    0,
433    0,
434    0,
435    0,
436    0,
437    0,
438    0,
439    0,
440    0,
441    0,
442    0,
443    0,
444    0,
445    0,
446    0,
447    0,
448    0,
449    0,
450    0,
451    0,
452    0,
453    0,
454    0,
455    0,
456    0,
457    0,
458    0,
459    0,
460    0,
461    0,
462    0,
463    0,
464    0,
465    0,
466    0,
467    0,
468    0,
469    0,
470    0,
471    0,
472    0,
473    0,
474    0,
475    0,
476    0,
477    0,
478    0,
479    0,
480    0,
481    0,
482    0,
483    0,
484    0,
485    0,
486    0,
487    0,
488    0,
489    0,
490    0,
491    0,
492    0,
493    0,
494    0,
495    0,
496    0,
497    0,
498    0,
499    0,
500    0,
501    0,
502    0,
503    0,
504    0,
505    0,
506    0,
507    0,
508    0,
509    0,
510    0,
511    0,
512    0,
513    0,
514    0,
515    0,
516    0,
517    0,
518    0,
519    0,
520    0,
521    0,
522    0,
523    0,
524    0,
525    0,
526    0,
527    0,
528    0,
529    0,
530    0,
531    0,
532    0,
533    0,
534    0,
535    0,
536    0,
537    0,
538    0,
539    0,
540    0,
541    0,
542    0,
543    0,
544    0,
545    0,
546    0,
547    0,
548    0,
549    0,
550    0,
551    0,
552    0,
553    0,
554    0,
555    0,
556    0,
557    0,
558    0,
559    0,
560    0,
561    0,
562    0,
563    0,
564    0,
565    0,
566    0,
567    0,
568    0,
569    0,
570    0,
571    0,
572    0,
573    0,
574    kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
575    kInstrCanContinue|kInstrCanThrow,
576    kInstrCanContinue|kInstrCanThrow,
577    kInstrCanContinue|kInstrCanThrow,
578    kInstrCanContinue|kInstrCanThrow,
579    kInstrCanContinue|kInstrCanThrow,
580    kInstrCanContinue|kInstrCanThrow,
581    kInstrCanContinue|kInstrCanThrow,
582    kInstrCanContinue|kInstrCanThrow,
583    kInstrCanContinue|kInstrCanThrow,
584    kInstrCanContinue|kInstrCanThrow,
585    kInstrCanContinue|kInstrCanThrow,
586    kInstrCanContinue|kInstrCanThrow,
587    kInstrCanThrow,
588    // END(libdex-flags)
589};
590
591/*
592 * Table that maps each opcode to the instruction format associated
593 * that opcode.
594 */
595static u1 gInstructionFormatTable[kNumPackedOpcodes] = {
596    // BEGIN(libdex-formats); GENERATED AUTOMATICALLY BY opcode-gen
597    kFmt10x,  kFmt12x,  kFmt22x,  kFmt32x,  kFmt12x,  kFmt22x,  kFmt32x,
598    kFmt12x,  kFmt22x,  kFmt32x,  kFmt11x,  kFmt11x,  kFmt11x,  kFmt11x,
599    kFmt10x,  kFmt11x,  kFmt11x,  kFmt11x,  kFmt11n,  kFmt21s,  kFmt31i,
600    kFmt21h,  kFmt21s,  kFmt31i,  kFmt51l,  kFmt21h,  kFmt21c,  kFmt31c,
601    kFmt21c,  kFmt11x,  kFmt11x,  kFmt21c,  kFmt22c,  kFmt12x,  kFmt21c,
602    kFmt22c,  kFmt35c,  kFmt3rc,  kFmt31t,  kFmt11x,  kFmt10t,  kFmt20t,
603    kFmt30t,  kFmt31t,  kFmt31t,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,
604    kFmt23x,  kFmt22t,  kFmt22t,  kFmt22t,  kFmt22t,  kFmt22t,  kFmt22t,
605    kFmt21t,  kFmt21t,  kFmt21t,  kFmt21t,  kFmt21t,  kFmt21t,  kFmt00x,
606    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt23x,  kFmt23x,
607    kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,
608    kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt22c,  kFmt22c,
609    kFmt22c,  kFmt22c,  kFmt22c,  kFmt22c,  kFmt22c,  kFmt22c,  kFmt22c,
610    kFmt22c,  kFmt22c,  kFmt22c,  kFmt22c,  kFmt22c,  kFmt21c,  kFmt21c,
611    kFmt21c,  kFmt21c,  kFmt21c,  kFmt21c,  kFmt21c,  kFmt21c,  kFmt21c,
612    kFmt21c,  kFmt21c,  kFmt21c,  kFmt21c,  kFmt21c,  kFmt35c,  kFmt35c,
613    kFmt35c,  kFmt35c,  kFmt35c,  kFmt00x,  kFmt3rc,  kFmt3rc,  kFmt3rc,
614    kFmt3rc,  kFmt3rc,  kFmt00x,  kFmt00x,  kFmt12x,  kFmt12x,  kFmt12x,
615    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,
616    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,
617    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt23x,  kFmt23x,  kFmt23x,
618    kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,
619    kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,
620    kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,
621    kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,  kFmt23x,
622    kFmt23x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,
623    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,
624    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,
625    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,
626    kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt12x,  kFmt22s,  kFmt22s,
627    kFmt22s,  kFmt22s,  kFmt22s,  kFmt22s,  kFmt22s,  kFmt22s,  kFmt22b,
628    kFmt22b,  kFmt22b,  kFmt22b,  kFmt22b,  kFmt22b,  kFmt22b,  kFmt22b,
629    kFmt22b,  kFmt22b,  kFmt22b,  kFmt22c,  kFmt22c,  kFmt21c,  kFmt21c,
630    kFmt22c,  kFmt22c,  kFmt22c,  kFmt21c,  kFmt21c,  kFmt00x,  kFmt20bc,
631    kFmt35mi, kFmt3rmi, kFmt35c,  kFmt10x,  kFmt22cs, kFmt22cs, kFmt22cs,
632    kFmt22cs, kFmt22cs, kFmt22cs, kFmt35ms, kFmt3rms, kFmt35ms, kFmt3rms,
633    kFmt22c,  kFmt21c,  kFmt21c,  kFmt00x,  kFmt41c,  kFmt41c,  kFmt52c,
634    kFmt41c,  kFmt52c,  kFmt5rc,  kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,
635    kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,
636    kFmt52c,  kFmt52c,  kFmt52c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,
637    kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,
638    kFmt41c,  kFmt41c,  kFmt41c,  kFmt5rc,  kFmt5rc,  kFmt5rc,  kFmt5rc,
639    kFmt5rc,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
640    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
641    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
642    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
643    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
644    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
645    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
646    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
647    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
648    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
649    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
650    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
651    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
652    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
653    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
654    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
655    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
656    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
657    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
658    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
659    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
660    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
661    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
662    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
663    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
664    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
665    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
666    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
667    kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,  kFmt00x,
668    kFmt00x,  kFmt5rc,  kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,  kFmt52c,
669    kFmt52c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,  kFmt41c,
670    kFmt40sc,
671    // END(libdex-formats)
672};
673
674/*
675 * Table that maps each opcode to the index type implied by that
676 * opcode.
677 */
678static u1 gInstructionIndexTypeTable[kNumPackedOpcodes] = {
679    // BEGIN(libdex-index-types); GENERATED AUTOMATICALLY BY opcode-gen
680    kIndexNone,         kIndexNone,         kIndexNone,
681    kIndexNone,         kIndexNone,         kIndexNone,
682    kIndexNone,         kIndexNone,         kIndexNone,
683    kIndexNone,         kIndexNone,         kIndexNone,
684    kIndexNone,         kIndexNone,         kIndexNone,
685    kIndexNone,         kIndexNone,         kIndexNone,
686    kIndexNone,         kIndexNone,         kIndexNone,
687    kIndexNone,         kIndexNone,         kIndexNone,
688    kIndexNone,         kIndexNone,         kIndexStringRef,
689    kIndexStringRef,    kIndexTypeRef,      kIndexNone,
690    kIndexNone,         kIndexTypeRef,      kIndexTypeRef,
691    kIndexNone,         kIndexTypeRef,      kIndexTypeRef,
692    kIndexTypeRef,      kIndexTypeRef,      kIndexNone,
693    kIndexNone,         kIndexNone,         kIndexNone,
694    kIndexNone,         kIndexNone,         kIndexNone,
695    kIndexNone,         kIndexNone,         kIndexNone,
696    kIndexNone,         kIndexNone,         kIndexNone,
697    kIndexNone,         kIndexNone,         kIndexNone,
698    kIndexNone,         kIndexNone,         kIndexNone,
699    kIndexNone,         kIndexNone,         kIndexNone,
700    kIndexNone,         kIndexNone,         kIndexUnknown,
701    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
702    kIndexUnknown,      kIndexUnknown,      kIndexNone,
703    kIndexNone,         kIndexNone,         kIndexNone,
704    kIndexNone,         kIndexNone,         kIndexNone,
705    kIndexNone,         kIndexNone,         kIndexNone,
706    kIndexNone,         kIndexNone,         kIndexNone,
707    kIndexNone,         kIndexFieldRef,     kIndexFieldRef,
708    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
709    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
710    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
711    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
712    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
713    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
714    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
715    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
716    kIndexFieldRef,     kIndexFieldRef,     kIndexMethodRef,
717    kIndexMethodRef,    kIndexMethodRef,    kIndexMethodRef,
718    kIndexMethodRef,    kIndexUnknown,      kIndexMethodRef,
719    kIndexMethodRef,    kIndexMethodRef,    kIndexMethodRef,
720    kIndexMethodRef,    kIndexUnknown,      kIndexUnknown,
721    kIndexNone,         kIndexNone,         kIndexNone,
722    kIndexNone,         kIndexNone,         kIndexNone,
723    kIndexNone,         kIndexNone,         kIndexNone,
724    kIndexNone,         kIndexNone,         kIndexNone,
725    kIndexNone,         kIndexNone,         kIndexNone,
726    kIndexNone,         kIndexNone,         kIndexNone,
727    kIndexNone,         kIndexNone,         kIndexNone,
728    kIndexNone,         kIndexNone,         kIndexNone,
729    kIndexNone,         kIndexNone,         kIndexNone,
730    kIndexNone,         kIndexNone,         kIndexNone,
731    kIndexNone,         kIndexNone,         kIndexNone,
732    kIndexNone,         kIndexNone,         kIndexNone,
733    kIndexNone,         kIndexNone,         kIndexNone,
734    kIndexNone,         kIndexNone,         kIndexNone,
735    kIndexNone,         kIndexNone,         kIndexNone,
736    kIndexNone,         kIndexNone,         kIndexNone,
737    kIndexNone,         kIndexNone,         kIndexNone,
738    kIndexNone,         kIndexNone,         kIndexNone,
739    kIndexNone,         kIndexNone,         kIndexNone,
740    kIndexNone,         kIndexNone,         kIndexNone,
741    kIndexNone,         kIndexNone,         kIndexNone,
742    kIndexNone,         kIndexNone,         kIndexNone,
743    kIndexNone,         kIndexNone,         kIndexNone,
744    kIndexNone,         kIndexNone,         kIndexNone,
745    kIndexNone,         kIndexNone,         kIndexNone,
746    kIndexNone,         kIndexNone,         kIndexNone,
747    kIndexNone,         kIndexNone,         kIndexNone,
748    kIndexNone,         kIndexNone,         kIndexNone,
749    kIndexNone,         kIndexNone,         kIndexNone,
750    kIndexNone,         kIndexNone,         kIndexNone,
751    kIndexNone,         kIndexNone,         kIndexNone,
752    kIndexNone,         kIndexNone,         kIndexNone,
753    kIndexNone,         kIndexNone,         kIndexNone,
754    kIndexNone,         kIndexNone,         kIndexNone,
755    kIndexNone,         kIndexNone,         kIndexFieldRef,
756    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
757    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
758    kIndexFieldRef,     kIndexFieldRef,     kIndexUnknown,
759    kIndexVaries,       kIndexInlineMethod, kIndexInlineMethod,
760    kIndexMethodRef,    kIndexNone,         kIndexFieldOffset,
761    kIndexFieldOffset,  kIndexFieldOffset,  kIndexFieldOffset,
762    kIndexFieldOffset,  kIndexFieldOffset,  kIndexVtableOffset,
763    kIndexVtableOffset, kIndexVtableOffset, kIndexVtableOffset,
764    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
765    kIndexUnknown,      kIndexTypeRef,      kIndexTypeRef,
766    kIndexTypeRef,      kIndexTypeRef,      kIndexTypeRef,
767    kIndexTypeRef,      kIndexFieldRef,     kIndexFieldRef,
768    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
769    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
770    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
771    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
772    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
773    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
774    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
775    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
776    kIndexFieldRef,     kIndexFieldRef,     kIndexMethodRef,
777    kIndexMethodRef,    kIndexMethodRef,    kIndexMethodRef,
778    kIndexMethodRef,    kIndexUnknown,      kIndexUnknown,
779    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
780    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
781    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
782    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
783    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
784    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
785    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
786    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
787    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
788    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
789    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
790    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
791    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
792    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
793    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
794    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
795    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
796    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
797    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
798    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
799    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
800    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
801    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
802    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
803    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
804    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
805    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
806    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
807    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
808    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
809    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
810    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
811    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
812    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
813    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
814    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
815    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
816    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
817    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
818    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
819    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
820    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
821    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
822    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
823    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
824    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
825    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
826    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
827    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
828    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
829    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
830    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
831    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
832    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
833    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
834    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
835    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
836    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
837    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
838    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
839    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
840    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
841    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
842    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
843    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
844    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
845    kIndexUnknown,      kIndexUnknown,      kIndexUnknown,
846    kIndexMethodRef,    kIndexFieldRef,     kIndexFieldRef,
847    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
848    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
849    kIndexFieldRef,     kIndexFieldRef,     kIndexFieldRef,
850    kIndexFieldRef,     kIndexVaries,
851    // END(libdex-index-types)
852};
853
854/*
855 * Global InstructionInfoTables struct.
856 */
857InstructionInfoTables gDexOpcodeInfo = {
858    gInstructionFormatTable,
859    gInstructionIndexTypeTable,
860    gOpcodeFlagsTable,
861    gInstructionWidthTable
862};
863
864/*
865 * Handy macros for helping decode instructions.
866 */
867#define FETCH(_offset)      (insns[(_offset)])
868#define FETCH_u4(_offset)   (fetch_u4_impl((_offset), insns))
869#define INST_A(_inst)       (((u2)(_inst) >> 8) & 0x0f)
870#define INST_B(_inst)       ((u2)(_inst) >> 12)
871#define INST_AA(_inst)      ((_inst) >> 8)
872
873/* Helper for FETCH_u4, above. */
874static inline u4 fetch_u4_impl(u4 offset, const u2* insns) {
875    return insns[offset] | ((u4) insns[offset+1] << 16);
876}
877
878/*
879 * Decode the instruction pointed to by "insns".
880 *
881 * Fills out the pieces of "pDec" that are affected by the current
882 * instruction.  Does not touch anything else.
883 */
884void dexDecodeInstruction(const u2* insns, DecodedInstruction* pDec)
885{
886    u2 inst = *insns;
887    Opcode opcode = dexOpcodeFromCodeUnit(inst);
888    InstructionFormat format = dexGetFormatFromOpcode(opcode);
889
890    pDec->opcode = opcode;
891    pDec->indexType = dexGetIndexTypeFromOpcode(opcode);
892
893    switch (format) {
894    case kFmt10x:       // op
895        /* nothing to do; copy the AA bits out for the verifier */
896        pDec->vA = INST_AA(inst);
897        break;
898    case kFmt12x:       // op vA, vB
899        pDec->vA = INST_A(inst);
900        pDec->vB = INST_B(inst);
901        break;
902    case kFmt11n:       // op vA, #+B
903        pDec->vA = INST_A(inst);
904        pDec->vB = (s4) (INST_B(inst) << 28) >> 28; // sign extend 4-bit value
905        break;
906    case kFmt11x:       // op vAA
907        pDec->vA = INST_AA(inst);
908        break;
909    case kFmt10t:       // op +AA
910        pDec->vA = (s1) INST_AA(inst);              // sign-extend 8-bit value
911        break;
912    case kFmt20t:       // op +AAAA
913        pDec->vA = (s2) FETCH(1);                   // sign-extend 16-bit value
914        break;
915    case kFmt20bc:      // [opt] op AA, thing@BBBB
916    case kFmt21c:       // op vAA, thing@BBBB
917    case kFmt22x:       // op vAA, vBBBB
918        pDec->vA = INST_AA(inst);
919        pDec->vB = FETCH(1);
920        break;
921    case kFmt21s:       // op vAA, #+BBBB
922    case kFmt21t:       // op vAA, +BBBB
923        pDec->vA = INST_AA(inst);
924        pDec->vB = (s2) FETCH(1);                   // sign-extend 16-bit value
925        break;
926    case kFmt21h:       // op vAA, #+BBBB0000[00000000]
927        pDec->vA = INST_AA(inst);
928        /*
929         * The value should be treated as right-zero-extended, but we don't
930         * actually do that here. Among other things, we don't know if it's
931         * the top bits of a 32- or 64-bit value.
932         */
933        pDec->vB = FETCH(1);
934        break;
935    case kFmt23x:       // op vAA, vBB, vCC
936        pDec->vA = INST_AA(inst);
937        pDec->vB = FETCH(1) & 0xff;
938        pDec->vC = FETCH(1) >> 8;
939        break;
940    case kFmt22b:       // op vAA, vBB, #+CC
941        pDec->vA = INST_AA(inst);
942        pDec->vB = FETCH(1) & 0xff;
943        pDec->vC = (s1) (FETCH(1) >> 8);            // sign-extend 8-bit value
944        break;
945    case kFmt22s:       // op vA, vB, #+CCCC
946    case kFmt22t:       // op vA, vB, +CCCC
947        pDec->vA = INST_A(inst);
948        pDec->vB = INST_B(inst);
949        pDec->vC = (s2) FETCH(1);                   // sign-extend 16-bit value
950        break;
951    case kFmt22c:       // op vA, vB, thing@CCCC
952    case kFmt22cs:      // [opt] op vA, vB, field offset CCCC
953        pDec->vA = INST_A(inst);
954        pDec->vB = INST_B(inst);
955        pDec->vC = FETCH(1);
956        break;
957    case kFmt30t:       // op +AAAAAAAA
958        pDec->vA = FETCH_u4(1);                     // signed 32-bit value
959        break;
960    case kFmt31t:       // op vAA, +BBBBBBBB
961    case kFmt31c:       // op vAA, string@BBBBBBBB
962        pDec->vA = INST_AA(inst);
963        pDec->vB = FETCH_u4(1);                     // 32-bit value
964        break;
965    case kFmt32x:       // op vAAAA, vBBBB
966        pDec->vA = FETCH(1);
967        pDec->vB = FETCH(2);
968        break;
969    case kFmt31i:       // op vAA, #+BBBBBBBB
970        pDec->vA = INST_AA(inst);
971        pDec->vB = FETCH_u4(1);                     // signed 32-bit value
972        break;
973    case kFmt35c:       // op {vC, vD, vE, vF, vG}, thing@BBBB
974    case kFmt35ms:      // [opt] invoke-virtual+super
975    case kFmt35mi:      // [opt] inline invoke
976        {
977            /*
978             * Note that the fields mentioned in the spec don't appear in
979             * their "usual" positions here compared to most formats. This
980             * was done so that the field names for the argument count and
981             * reference index match between this format and the corresponding
982             * range formats (3rc and friends).
983             *
984             * Bottom line: The argument count is always in vA, and the
985             * method constant (or equivalent) is always in vB.
986             */
987            u2 regList;
988            int i, count;
989
990            pDec->vA = INST_B(inst); // This is labeled A in the spec.
991            pDec->vB = FETCH(1);
992            regList = FETCH(2);
993
994            count = pDec->vA;
995
996            /*
997             * Copy the argument registers into the arg[] array, and
998             * also copy the first argument (if any) into vC. (The
999             * DecodedInstruction structure doesn't have separate
1000             * fields for {vD, vE, vF, vG}, so there's no need to make
1001             * copies of those.) Note that cases 5..2 fall through.
1002             */
1003            switch (count) {
1004            case 5: {
1005                if (format == kFmt35mi) {
1006                    /* A fifth arg is verboten for inline invokes. */
1007                    LOGW("Invalid arg count in 35mi (5)\n");
1008                    goto bail;
1009                }
1010                /*
1011                 * Per note at the top of this format decoder, the
1012                 * fifth argument comes from the A field in the
1013                 * instruction, but it's labeled G in the spec.
1014                 */
1015                pDec->arg[4] = INST_A(inst);
1016            }
1017            case 4: pDec->arg[3] = (regList >> 12) & 0x0f;
1018            case 3: pDec->arg[2] = (regList >> 8) & 0x0f;
1019            case 2: pDec->arg[1] = (regList >> 4) & 0x0f;
1020            case 1: pDec->vC = pDec->arg[0] = regList & 0x0f; break;
1021            case 0: break; // Valid, but no need to do anything.
1022            default:
1023                LOGW("Invalid arg count in 35c/35ms/35mi (%d)\n", count);
1024                goto bail;
1025            }
1026        }
1027        break;
1028    case kFmt3rc:       // op {vCCCC .. v(CCCC+AA-1)}, meth@BBBB
1029    case kFmt3rms:      // [opt] invoke-virtual+super/range
1030    case kFmt3rmi:      // [opt] execute-inline/range
1031        pDec->vA = INST_AA(inst);
1032        pDec->vB = FETCH(1);
1033        pDec->vC = FETCH(2);
1034        break;
1035    case kFmt51l:       // op vAA, #+BBBBBBBBBBBBBBBB
1036        pDec->vA = INST_AA(inst);
1037        pDec->vB_wide = FETCH_u4(1) | ((u8) FETCH_u4(3) << 32);
1038        break;
1039    case kFmt33x:       // exop vAA, vBB, vCCCC
1040        pDec->vA = FETCH(1) & 0xff;
1041        pDec->vB = FETCH(1) >> 8;
1042        pDec->vC = FETCH(2);
1043        break;
1044    case kFmt32s:       // exop vAA, vBB, #+CCCC
1045        pDec->vA = FETCH(1) & 0xff;
1046        pDec->vB = FETCH(1) >> 8;
1047        pDec->vC = (s2) FETCH(2);                   // sign-extend 16-bit value
1048        break;
1049    case kFmt40sc:      // [opt] exop AAAA, thing@BBBBBBBB
1050    case kFmt41c:       // exop vAAAA, thing@BBBBBBBB
1051        /*
1052         * The order of fields for this format in the spec is {B, A},
1053         * to match formats 21c and 31c.
1054         */
1055        pDec->vB = FETCH_u4(1);                     // 32-bit value
1056        pDec->vA = FETCH(3);
1057        break;
1058    case kFmt52c:       // exop vAAAA, vBBBB, thing@CCCCCCCC
1059        /*
1060         * The order of fields for this format in the spec is {C, A, B},
1061         * to match formats 22c and 22cs.
1062         */
1063        pDec->vC = FETCH_u4(1);                     // 32-bit value
1064        pDec->vA = FETCH(3);
1065        pDec->vB = FETCH(4);
1066        break;
1067    case kFmt5rc:       // exop {vCCCC .. v(CCCC+AAAA-1)}, meth@BBBBBBBB
1068        /*
1069         * The order of fields for this format in the spec is {B, A, C},
1070         * to match formats 3rc and friends.
1071         */
1072        pDec->vB = FETCH_u4(1);                     // 32-bit value
1073        pDec->vA = FETCH(3);
1074        pDec->vC = FETCH(4);
1075        break;
1076    default:
1077        LOGW("Can't decode unexpected format %d (op=%d)\n", format, opcode);
1078        assert(false);
1079        break;
1080    }
1081
1082bail:
1083    ;
1084}
1085
1086/*
1087 * Return the width of the specified instruction, or 0 if not defined.  Also
1088 * works for special OP_NOP entries, including switch statement data tables
1089 * and array data.
1090 */
1091size_t dexGetWidthFromInstruction(const u2* insns)
1092{
1093    size_t width;
1094
1095    if (*insns == kPackedSwitchSignature) {
1096        width = 4 + insns[1] * 2;
1097    } else if (*insns == kSparseSwitchSignature) {
1098        width = 2 + insns[1] * 4;
1099    } else if (*insns == kArrayDataSignature) {
1100        u2 elemWidth = insns[1];
1101        u4 len = insns[2] | (((u4)insns[3]) << 16);
1102        // The plus 1 is to round up for odd size and width.
1103        width = 4 + (elemWidth * len + 1) / 2;
1104    } else {
1105        width = dexGetWidthFromOpcode(dexOpcodeFromCodeUnit(insns[0]));
1106    }
1107
1108    return width;
1109}
1110