InstructionCodec.java revision 7baa3b69f87348aa2f4f16375a66be59965e8dd4 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.dx.io.instructions;
18
19import com.android.dx.io.IndexType;
20import com.android.dx.io.OpcodeInfo;
21import com.android.dx.io.Opcodes;
22import com.android.dx.util.DexException;
23import com.android.dx.util.Hex;
24
25import java.io.EOFException;
26
27/**
28 * Representation of an instruction format, which knows how to decode into
29 * and encode from instances of {@link DecodedInstruction}.
30 */
31public enum InstructionCodec {
32    FORMAT_00X() {
33        @Override public DecodedInstruction decode(int opcodeUnit,
34                CodeInput in) throws EOFException {
35            return new ZeroRegisterDecodedInstruction(
36                    this, opcodeUnit, 0, null,
37                    0, 0L);
38        }
39
40        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
41            out.write(insn.getOpcodeUnit());
42        }
43    },
44
45    FORMAT_10X() {
46        @Override public DecodedInstruction decode(int opcodeUnit,
47                CodeInput in) throws EOFException {
48            int opcode = byte0(opcodeUnit);
49            int literal = byte1(opcodeUnit); // should be zero
50            return new ZeroRegisterDecodedInstruction(
51                    this, opcode, 0, null,
52                    0, literal);
53        }
54
55        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
56            out.write(insn.getOpcodeUnit());
57        }
58    },
59
60    FORMAT_12X() {
61        @Override public DecodedInstruction decode(int opcodeUnit,
62                CodeInput in) throws EOFException {
63            int opcode = byte0(opcodeUnit);
64            int a = nibble2(opcodeUnit);
65            int b = nibble3(opcodeUnit);
66            return new TwoRegisterDecodedInstruction(
67                    this, opcode, 0, null,
68                    0, 0L,
69                    a, b);
70        }
71
72        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
73            out.write(
74                    codeUnit(insn.getOpcodeUnit(),
75                             makeByte(insn.getA(), insn.getB())));
76        }
77    },
78
79    FORMAT_11N() {
80        @Override public DecodedInstruction decode(int opcodeUnit,
81                CodeInput in) throws EOFException {
82            int opcode = byte0(opcodeUnit);
83            int a = nibble2(opcodeUnit);
84            int literal = (nibble3(opcodeUnit) << 28) >> 28; // sign-extend
85            return new OneRegisterDecodedInstruction(
86                    this, opcode, 0, null,
87                    0, literal,
88                    a);
89        }
90
91        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
92            out.write(
93                    codeUnit(insn.getOpcodeUnit(),
94                             makeByte(insn.getA(), insn.getLiteralNibble())));
95        }
96    },
97
98    FORMAT_11X() {
99        @Override public DecodedInstruction decode(int opcodeUnit,
100                CodeInput in) throws EOFException {
101            int opcode = byte0(opcodeUnit);
102            int a = byte1(opcodeUnit);
103            return new OneRegisterDecodedInstruction(
104                    this, opcode, 0, null,
105                    0, 0L,
106                    a);
107        }
108
109        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
110            out.write(codeUnit(insn.getOpcode(), insn.getA()));
111        }
112    },
113
114    FORMAT_10T() {
115        @Override public DecodedInstruction decode(int opcodeUnit,
116                CodeInput in) throws EOFException {
117            int baseAddress = in.cursor() - 1;
118            int opcode = byte0(opcodeUnit);
119            int target = (byte) byte1(opcodeUnit); // sign-extend
120            return new ZeroRegisterDecodedInstruction(
121                    this, opcode, 0, null,
122                    baseAddress + target, 0L);
123        }
124
125        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
126            int relativeTarget = insn.getTargetByte(out.cursor());
127            out.write(codeUnit(insn.getOpcode(), relativeTarget));
128        }
129    },
130
131    FORMAT_20T() {
132        @Override public DecodedInstruction decode(int opcodeUnit,
133                CodeInput in) throws EOFException {
134            int baseAddress = in.cursor() - 1;
135            int opcode = byte0(opcodeUnit);
136            int literal = byte1(opcodeUnit); // should be zero
137            int target = (short) in.read(); // sign-extend
138            return new ZeroRegisterDecodedInstruction(
139                    this, opcode, 0, null,
140                    baseAddress + target, literal);
141        }
142
143        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
144            short relativeTarget = insn.getTargetUnit(out.cursor());
145            out.write(insn.getOpcodeUnit(), relativeTarget);
146        }
147    },
148
149    FORMAT_20BC() {
150        @Override public DecodedInstruction decode(int opcodeUnit,
151                CodeInput in) throws EOFException {
152            // Note: We use the literal field to hold the decoded AA value.
153            int opcode = byte0(opcodeUnit);
154            int literal = byte1(opcodeUnit);
155            int index = in.read();
156            return new ZeroRegisterDecodedInstruction(
157                    this, opcode, index, IndexType.VARIES,
158                    0, literal);
159        }
160
161        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
162            out.write(
163                    codeUnit(insn.getOpcode(), insn.getLiteralByte()),
164                    insn.getIndexUnit());
165        }
166    },
167
168    FORMAT_22X() {
169        @Override public DecodedInstruction decode(int opcodeUnit,
170                CodeInput in) throws EOFException {
171            int opcode = byte0(opcodeUnit);
172            int a = byte1(opcodeUnit);
173            int b = in.read();
174            return new TwoRegisterDecodedInstruction(
175                    this, opcode, 0, null,
176                    0, 0L,
177                    a, b);
178        }
179
180        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
181            out.write(
182                    codeUnit(insn.getOpcode(), insn.getA()),
183                    insn.getBUnit());
184        }
185    },
186
187    FORMAT_21T() {
188        @Override public DecodedInstruction decode(int opcodeUnit,
189                CodeInput in) throws EOFException {
190            int baseAddress = in.cursor() - 1;
191            int opcode = byte0(opcodeUnit);
192            int a = byte1(opcodeUnit);
193            int target = (short) in.read(); // sign-extend
194            return new OneRegisterDecodedInstruction(
195                    this, opcode, 0, null,
196                    baseAddress + target, 0L,
197                    a);
198        }
199
200        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
201            short relativeTarget = insn.getTargetUnit(out.cursor());
202            out.write(codeUnit(insn.getOpcode(), insn.getA()), relativeTarget);
203        }
204    },
205
206    FORMAT_21S() {
207        @Override public DecodedInstruction decode(int opcodeUnit,
208                CodeInput in) throws EOFException {
209            int opcode = byte0(opcodeUnit);
210            int a = byte1(opcodeUnit);
211            int literal = (short) in.read(); // sign-extend
212            return new OneRegisterDecodedInstruction(
213                    this, opcode, 0, null,
214                    0, literal,
215                    a);
216        }
217
218        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
219            out.write(
220                    codeUnit(insn.getOpcode(), insn.getA()),
221                    insn.getLiteralUnit());
222        }
223    },
224
225    FORMAT_21H() {
226        @Override public DecodedInstruction decode(int opcodeUnit,
227                CodeInput in) throws EOFException {
228            int opcode = byte0(opcodeUnit);
229            int a = byte1(opcodeUnit);
230            int literal = (short) in.read(); // sign-extend
231
232            /*
233             * Format 21h decodes differently depending on the opcode,
234             * because the "signed hat" might represent either a 32-
235             * or 64- bit value.
236             */
237            literal <<= (opcode == Opcodes.CONST_HIGH16) ? 16 : 48;
238
239            return new OneRegisterDecodedInstruction(
240                    this, opcode, 0, null,
241                    0, literal,
242                    a);
243        }
244
245        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
246            // See above.
247            int opcode = insn.getOpcode();
248            int shift = (opcode == Opcodes.CONST_HIGH16) ? 16 : 48;
249            short literal = (short) (insn.getLiteral() >> shift);
250
251            out.write(codeUnit(opcode, insn.getA()), literal);
252        }
253    },
254
255    FORMAT_21C() {
256        @Override public DecodedInstruction decode(int opcodeUnit,
257                CodeInput in) throws EOFException {
258            int opcode = byte0(opcodeUnit);
259            int a = byte1(opcodeUnit);
260            int index = in.read();
261            IndexType indexType = OpcodeInfo.getIndexType(opcode);
262            return new OneRegisterDecodedInstruction(
263                    this, opcode, index, indexType,
264                    0, 0L,
265                    a);
266        }
267
268        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
269            out.write(
270                    codeUnit(insn.getOpcode(), insn.getA()),
271                    insn.getLiteralUnit());
272        }
273    },
274
275    FORMAT_23X() {
276        @Override public DecodedInstruction decode(int opcodeUnit,
277                CodeInput in) throws EOFException {
278            int opcode = byte0(opcodeUnit);
279            int a = byte1(opcodeUnit);
280            int bc = in.read();
281            int b = byte0(bc);
282            int c = byte1(bc);
283            return new ThreeRegisterDecodedInstruction(
284                    this, opcode, 0, null,
285                    0, 0L,
286                    a, b, c);
287        }
288
289        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
290            out.write(
291                    codeUnit(insn.getOpcode(), insn.getA()),
292                    codeUnit(insn.getB(), insn.getC()));
293        }
294    },
295
296    FORMAT_22B() {
297        @Override public DecodedInstruction decode(int opcodeUnit,
298                CodeInput in) throws EOFException {
299            int opcode = byte0(opcodeUnit);
300            int a = byte1(opcodeUnit);
301            int bc = in.read();
302            int b = byte0(bc);
303            int literal = (byte) byte1(bc); // sign-extend
304            return new TwoRegisterDecodedInstruction(
305                    this, opcode, 0, null,
306                    0, literal,
307                    a, b);
308        }
309
310        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
311            out.write(
312                    codeUnit(insn.getOpcode(), insn.getA()),
313                    codeUnit(insn.getB(),
314                             insn.getLiteralByte()));
315        }
316    },
317
318    FORMAT_22T() {
319        @Override public DecodedInstruction decode(int opcodeUnit,
320                CodeInput in) throws EOFException {
321            int baseAddress = in.cursor() - 1;
322            int opcode = byte0(opcodeUnit);
323            int a = nibble2(opcodeUnit);
324            int b = nibble3(opcodeUnit);
325            int target = (short) in.read(); // sign-extend
326            return new TwoRegisterDecodedInstruction(
327                    this, opcode, 0, null,
328                    baseAddress + target, 0L,
329                    a, b);
330        }
331
332        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
333            short relativeTarget = insn.getTargetUnit(out.cursor());
334            out.write(
335                    codeUnit(insn.getOpcode(),
336                             makeByte(insn.getA(), insn.getB())),
337                    relativeTarget);
338        }
339    },
340
341    FORMAT_22S() {
342        @Override public DecodedInstruction decode(int opcodeUnit,
343                CodeInput in) throws EOFException {
344            int opcode = byte0(opcodeUnit);
345            int a = nibble2(opcodeUnit);
346            int b = nibble3(opcodeUnit);
347            int literal = (short) in.read(); // sign-extend
348            return new TwoRegisterDecodedInstruction(
349                    this, opcode, 0, null,
350                    0, literal,
351                    a, b);
352        }
353
354        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
355            out.write(
356                    codeUnit(insn.getOpcode(),
357                             makeByte(insn.getA(), insn.getB())),
358                    insn.getLiteralUnit());
359        }
360    },
361
362    FORMAT_22C() {
363        @Override public DecodedInstruction decode(int opcodeUnit,
364                CodeInput in) throws EOFException {
365            int opcode = byte0(opcodeUnit);
366            int a = nibble2(opcodeUnit);
367            int b = nibble3(opcodeUnit);
368            int index = in.read();
369            IndexType indexType = OpcodeInfo.getIndexType(opcode);
370            return new TwoRegisterDecodedInstruction(
371                    this, opcode, index, indexType,
372                    0, 0L,
373                    a, b);
374        }
375
376        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
377            out.write(
378                    codeUnit(insn.getOpcode(),
379                             makeByte(insn.getA(), insn.getB())),
380                    insn.getIndexUnit());
381        }
382    },
383
384    FORMAT_22CS() {
385        @Override public DecodedInstruction decode(int opcodeUnit,
386                CodeInput in) throws EOFException {
387            int opcode = byte0(opcodeUnit);
388            int a = nibble2(opcodeUnit);
389            int b = nibble3(opcodeUnit);
390            int index = in.read();
391            return new TwoRegisterDecodedInstruction(
392                    this, opcode, index, IndexType.FIELD_OFFSET,
393                    0, 0L,
394                    a, b);
395        }
396
397        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
398            out.write(
399                    codeUnit(insn.getOpcode(),
400                             makeByte(insn.getA(), insn.getB())),
401                    insn.getIndexUnit());
402        }
403    },
404
405    FORMAT_30T() {
406        @Override public DecodedInstruction decode(int opcodeUnit,
407                CodeInput in) throws EOFException {
408            int baseAddress = in.cursor() - 1;
409            int opcode = byte0(opcodeUnit);
410            int literal = byte1(opcodeUnit); // should be zero
411            int target = in.readInt();
412            return new ZeroRegisterDecodedInstruction(
413                    this, opcode, 0, null,
414                    baseAddress + target, literal);
415        }
416
417        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
418            int relativeTarget = insn.getTarget(out.cursor());
419            out.write(insn.getOpcodeUnit(),
420                    unit0(relativeTarget), unit1(relativeTarget));
421        }
422    },
423
424    FORMAT_32X() {
425        @Override public DecodedInstruction decode(int opcodeUnit,
426                CodeInput in) throws EOFException {
427            int opcode = byte0(opcodeUnit);
428            int literal = byte1(opcodeUnit); // should be zero
429            int a = in.read();
430            int b = in.read();
431            return new TwoRegisterDecodedInstruction(
432                    this, opcode, 0, null,
433                    0, literal,
434                    a, b);
435        }
436
437        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
438            out.write(insn.getOpcodeUnit(), insn.getAUnit(), insn.getBUnit());
439        }
440    },
441
442    FORMAT_31I() {
443        @Override public DecodedInstruction decode(int opcodeUnit,
444                CodeInput in) throws EOFException {
445            int opcode = byte0(opcodeUnit);
446            int a = byte1(opcodeUnit);
447            int literal = in.readInt();
448            return new OneRegisterDecodedInstruction(
449                    this, opcode, 0, null,
450                    0, literal,
451                    a);
452        }
453
454        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
455            int literal = insn.getLiteralInt();
456            out.write(
457                    codeUnit(insn.getOpcode(), insn.getA()),
458                    unit0(literal),
459                    unit1(literal));
460        }
461    },
462
463    FORMAT_31T() {
464        @Override public DecodedInstruction decode(int opcodeUnit,
465                CodeInput in) throws EOFException {
466            int baseAddress = in.cursor() - 1;
467            int opcode = byte0(opcodeUnit);
468            int a = byte1(opcodeUnit);
469            int target = baseAddress + in.readInt();
470
471            /*
472             * Switch instructions need to "forward" their addresses to their
473             * payload target instructions.
474             */
475            switch (opcode) {
476                case Opcodes.PACKED_SWITCH:
477                case Opcodes.SPARSE_SWITCH: {
478                    in.setBaseAddress(target, baseAddress);
479                    break;
480                }
481            }
482
483            return new OneRegisterDecodedInstruction(
484                    this, opcode, 0, null,
485                    target, 0L,
486                    a);
487        }
488
489        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
490            int relativeTarget = insn.getTarget(out.cursor());
491            out.write(
492                    codeUnit(insn.getOpcode(), insn.getA()),
493                    unit0(relativeTarget), unit1(relativeTarget));
494        }
495    },
496
497    FORMAT_31C() {
498        @Override public DecodedInstruction decode(int opcodeUnit,
499                CodeInput in) throws EOFException {
500            int opcode = byte0(opcodeUnit);
501            int a = byte1(opcodeUnit);
502            int index = in.readInt();
503            IndexType indexType = OpcodeInfo.getIndexType(opcode);
504            return new OneRegisterDecodedInstruction(
505                    this, opcode, index, indexType,
506                    0, 0L,
507                    a);
508        }
509
510        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
511            int index = insn.getIndex();
512            out.write(
513                    codeUnit(insn.getOpcode(), insn.getA()),
514                    unit0(index),
515                    unit1(index));
516        }
517    },
518
519    FORMAT_35C() {
520        @Override public DecodedInstruction decode(int opcodeUnit,
521                CodeInput in) throws EOFException {
522            return decodeRegisterList(this, opcodeUnit, in);
523        }
524
525        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
526            encodeRegisterList(insn, out);
527        }
528    },
529
530    FORMAT_35MS() {
531        @Override public DecodedInstruction decode(int opcodeUnit,
532                CodeInput in) throws EOFException {
533            return decodeRegisterList(this, opcodeUnit, in);
534        }
535
536        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
537            encodeRegisterList(insn, out);
538        }
539    },
540
541    FORMAT_35MI() {
542        @Override public DecodedInstruction decode(int opcodeUnit,
543                CodeInput in) throws EOFException {
544            return decodeRegisterList(this, opcodeUnit, in);
545        }
546
547        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
548            encodeRegisterList(insn, out);
549        }
550    },
551
552    FORMAT_3RC() {
553        @Override public DecodedInstruction decode(int opcodeUnit,
554                CodeInput in) throws EOFException {
555            return decodeRegisterRange(this, opcodeUnit, in);
556        }
557
558        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
559            encodeRegisterRange(insn, out);
560        }
561    },
562
563    FORMAT_3RMS() {
564        @Override public DecodedInstruction decode(int opcodeUnit,
565                CodeInput in) throws EOFException {
566            return decodeRegisterRange(this, opcodeUnit, in);
567        }
568
569        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
570            encodeRegisterRange(insn, out);
571        }
572    },
573
574    FORMAT_3RMI() {
575        @Override public DecodedInstruction decode(int opcodeUnit,
576                CodeInput in) throws EOFException {
577            return decodeRegisterRange(this, opcodeUnit, in);
578        }
579
580        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
581            encodeRegisterRange(insn, out);
582        }
583    },
584
585    FORMAT_51L() {
586        @Override public DecodedInstruction decode(int opcodeUnit,
587                CodeInput in) throws EOFException {
588            int opcode = byte0(opcodeUnit);
589            int a = byte1(opcodeUnit);
590            long literal = in.readLong();
591            return new OneRegisterDecodedInstruction(
592                    this, opcode, 0, null,
593                    0, literal,
594                    a);
595        }
596
597        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
598            int literal = insn.getLiteralInt();
599            out.write(
600                    codeUnit(insn.getOpcode(), insn.getA()),
601                    unit0(literal),
602                    unit1(literal),
603                    unit2(literal),
604                    unit3(literal));
605        }
606    },
607
608    FORMAT_33X() {
609        @Override public DecodedInstruction decode(int opcodeUnit,
610                CodeInput in) throws EOFException {
611            int ab = in.read();
612            int a = byte0(ab);
613            int b = byte1(ab);
614            int c = in.read();
615            return new ThreeRegisterDecodedInstruction(
616                    this, opcodeUnit, 0, null,
617                    0, 0L,
618                    a, b, c);
619        }
620
621        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
622            out.write(
623                    insn.getOpcodeUnit(),
624                    codeUnit(insn.getA(), insn.getB()),
625                    insn.getCUnit());
626        }
627    },
628
629    FORMAT_32S() {
630        @Override public DecodedInstruction decode(int opcodeUnit,
631                CodeInput in) throws EOFException {
632            int ab = in.read();
633            int a = byte0(ab);
634            int b = byte1(ab);
635            int literal = (short) in.read(); // sign-extend
636            return new TwoRegisterDecodedInstruction(
637                    this, opcodeUnit, 0, null,
638                    0, literal,
639                    a, b);
640        }
641
642        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
643            out.write(
644                    insn.getOpcodeUnit(),
645                    codeUnit(insn.getA(), insn.getB()),
646                    insn.getLiteralUnit());
647        }
648    },
649
650    FORMAT_40SC() {
651        @Override public DecodedInstruction decode(int opcodeUnit,
652                CodeInput in) throws EOFException {
653            // Note: We use the literal field to hold the decoded AA value.
654            int index = in.readInt();
655            int literal = in.read();
656            return new ZeroRegisterDecodedInstruction(
657                    this, opcodeUnit, index, IndexType.VARIES,
658                    0, literal);
659        }
660
661        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
662            int index = insn.getIndex();
663            out.write(
664                    insn.getOpcodeUnit(),
665                    unit0(index),
666                    unit1(index),
667                    insn.getLiteralUnit());
668        }
669    },
670
671    FORMAT_41C() {
672        @Override public DecodedInstruction decode(int opcodeUnit,
673                CodeInput in) throws EOFException {
674            int index = in.readInt();
675            int a = in.read();
676            IndexType indexType = OpcodeInfo.getIndexType(opcodeUnit);
677            return new OneRegisterDecodedInstruction(
678                    this, opcodeUnit, index, indexType,
679                    0, 0L,
680                    a);
681        }
682
683        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
684            int index = insn.getIndex();
685            out.write(
686                    insn.getOpcodeUnit(),
687                    unit0(index),
688                    unit1(index),
689                    insn.getAUnit());
690        }
691    },
692
693    FORMAT_52C() {
694        @Override public DecodedInstruction decode(int opcodeUnit,
695                CodeInput in) throws EOFException {
696            int index = in.readInt();
697            int a = in.read();
698            int b = in.read();
699            IndexType indexType = OpcodeInfo.getIndexType(opcodeUnit);
700            return new TwoRegisterDecodedInstruction(
701                    this, opcodeUnit, index, indexType,
702                    0, 0L,
703                    a, b);
704        }
705
706        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
707            int index = insn.getIndex();
708            out.write(
709                    insn.getOpcodeUnit(),
710                    unit0(index),
711                    unit1(index),
712                    insn.getAUnit(),
713                    insn.getBUnit());
714        }
715    },
716
717    FORMAT_5RC() {
718        @Override public DecodedInstruction decode(int opcodeUnit,
719                CodeInput in) throws EOFException {
720            int index = in.readInt();
721            int registerCount = in.read();
722            int a = in.read();
723            IndexType indexType = OpcodeInfo.getIndexType(opcodeUnit);
724            return new RegisterRangeDecodedInstruction(
725                    this, opcodeUnit, index, indexType,
726                    0, 0L,
727                    a, registerCount);
728        }
729
730        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
731            int index = insn.getIndex();
732            out.write(
733                    insn.getOpcodeUnit(),
734                    unit0(index),
735                    unit1(index),
736                    insn.getRegisterCountUnit(),
737                    insn.getAUnit());
738        }
739    },
740
741    FORMAT_PACKED_SWITCH_PAYLOAD() {
742        @Override public DecodedInstruction decode(int opcodeUnit,
743                CodeInput in) throws EOFException {
744            int baseAddress = in.baseAddressForCursor();
745            int size = in.read();
746            int firstKey = in.readInt();
747            int[] targets = new int[size];
748
749            for (int i = 0; i < size; i++) {
750                targets[i] = baseAddress + in.readInt();
751            }
752
753            return new PackedSwitchPayloadDecodedInstruction(
754                    this, opcodeUnit, firstKey, targets);
755        }
756
757        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
758            PackedSwitchPayloadDecodedInstruction payload =
759                (PackedSwitchPayloadDecodedInstruction) insn;
760            int[] targets = payload.getTargets();
761            int baseAddress = out.baseAddressForCursor();
762
763            out.write(payload.getOpcodeUnit());
764            out.write(asUnsignedUnit(targets.length));
765            out.writeInt(payload.getFirstKey());
766
767            for (int target : targets) {
768                out.writeInt(target - baseAddress);
769            }
770        }
771    },
772
773    FORMAT_SPARSE_SWITCH_PAYLOAD() {
774        @Override public DecodedInstruction decode(int opcodeUnit,
775                CodeInput in) throws EOFException {
776            int baseAddress = in.baseAddressForCursor();
777            int size = in.read();
778            int[] keys = new int[size];
779            int[] targets = new int[size];
780
781            for (int i = 0; i < size; i++) {
782                keys[i] = in.readInt();
783            }
784
785            for (int i = 0; i < size; i++) {
786                targets[i] = baseAddress + in.readInt();
787            }
788
789            return new SparseSwitchPayloadDecodedInstruction(
790                    this, opcodeUnit, keys, targets);
791        }
792
793        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
794            SparseSwitchPayloadDecodedInstruction payload =
795                (SparseSwitchPayloadDecodedInstruction) insn;
796            int[] keys = payload.getKeys();
797            int[] targets = payload.getTargets();
798            int baseAddress = out.baseAddressForCursor();
799
800            out.write(payload.getOpcodeUnit());
801            out.write(asUnsignedUnit(targets.length));
802
803            for (int key : keys) {
804                out.writeInt(key);
805            }
806
807            for (int target : targets) {
808                out.writeInt(target - baseAddress);
809            }
810        }
811    },
812
813    FORMAT_FILL_ARRAY_DATA_PAYLOAD() {
814        @Override public DecodedInstruction decode(int opcodeUnit,
815                CodeInput in) throws EOFException {
816            int elementWidth = in.read();
817            int size = in.readInt();
818
819            switch (elementWidth) {
820                case 1: {
821                    byte[] array = new byte[size];
822                    boolean even = true;
823                    for (int i = 0, value = 0; i < size; i++, even = !even) {
824                        if (even) {
825                            value = in.read();
826                        }
827                        array[i] = (byte) (value & 0xff);
828                        value >>= 8;
829                    }
830                    return new FillArrayDataPayloadDecodedInstruction(
831                            this, opcodeUnit, array);
832                }
833                case 2: {
834                    short[] array = new short[size];
835                    for (int i = 0; i < size; i++) {
836                        array[i] = (short) in.read();
837                    }
838                    return new FillArrayDataPayloadDecodedInstruction(
839                            this, opcodeUnit, array);
840                }
841                case 4: {
842                    int[] array = new int[size];
843                    for (int i = 0; i < size; i++) {
844                        array[i] = in.readInt();
845                    }
846                    return new FillArrayDataPayloadDecodedInstruction(
847                            this, opcodeUnit, array);
848                }
849                case 8: {
850                    long[] array = new long[size];
851                    for (int i = 0; i < size; i++) {
852                        array[i] = in.readLong();
853                    }
854                    return new FillArrayDataPayloadDecodedInstruction(
855                            this, opcodeUnit, array);
856                }
857            }
858
859            throw new DexException("bogus element_width: "
860                    + Hex.u2(elementWidth));
861        }
862
863        @Override public void encode(DecodedInstruction insn, CodeOutput out) {
864            FillArrayDataPayloadDecodedInstruction payload =
865                (FillArrayDataPayloadDecodedInstruction) insn;
866            short elementWidth = payload.getElementWidthUnit();
867            Object data = payload.getData();
868
869            out.write(payload.getOpcodeUnit());
870            out.write(elementWidth);
871            out.writeInt(payload.getSize());
872
873            switch (elementWidth) {
874                case 1: out.write((byte[]) data);  break;
875                case 2: out.write((short[]) data); break;
876                case 4: out.write((int[]) data);   break;
877                case 8: out.write((long[]) data);  break;
878                default: {
879                    throw new DexException("bogus element_width: "
880                            + Hex.u2(elementWidth));
881                }
882            }
883        }
884    };
885
886    /**
887     * Decodes an instruction specified by the given opcode unit, reading
888     * any required additional code units from the given input source.
889     */
890    public abstract DecodedInstruction decode(int opcodeUnit, CodeInput in)
891        throws EOFException;
892
893    /**
894     * Encodes the given instruction.
895     */
896    public abstract void encode(DecodedInstruction insn, CodeOutput out);
897
898    /**
899     * Helper method that decodes any of the register-list formats.
900     */
901    private static DecodedInstruction decodeRegisterList(
902            InstructionCodec format, int opcodeUnit, CodeInput in)
903            throws EOFException {
904        int opcode = byte0(opcodeUnit);
905        int e = nibble2(opcodeUnit);
906        int registerCount = nibble3(opcodeUnit);
907        int index = in.read();
908        int abcd = in.read();
909        int a = nibble0(abcd);
910        int b = nibble1(abcd);
911        int c = nibble2(abcd);
912        int d = nibble3(abcd);
913        IndexType indexType = OpcodeInfo.getIndexType(opcode);
914
915        // TODO: Having to switch like this is less than ideal.
916        switch (registerCount) {
917            case 0:
918                return new ZeroRegisterDecodedInstruction(
919                        format, opcode, index, indexType,
920                        0, 0L);
921            case 1:
922                return new OneRegisterDecodedInstruction(
923                        format, opcode, index, indexType,
924                        0, 0L,
925                        a);
926            case 2:
927                return new TwoRegisterDecodedInstruction(
928                        format, opcode, index, indexType,
929                        0, 0L,
930                        a, b);
931            case 3:
932                return new ThreeRegisterDecodedInstruction(
933                        format, opcode, index, indexType,
934                        0, 0L,
935                        a, b, c);
936            case 4:
937                return new FourRegisterDecodedInstruction(
938                        format, opcode, index, indexType,
939                        0, 0L,
940                        a, b, c, d);
941            case 5:
942                return new FiveRegisterDecodedInstruction(
943                        format, opcode, index, indexType,
944                        0, 0L,
945                        a, b, c, d, e);
946        }
947
948        throw new DexException("bogus registerCount: "
949                + Hex.uNibble(registerCount));
950    }
951
952    /**
953     * Helper method that encodes any of the register-list formats.
954     */
955    private static void encodeRegisterList(DecodedInstruction insn,
956            CodeOutput out) {
957        out.write(codeUnit(insn.getOpcode(),
958                        makeByte(insn.getE(), insn.getRegisterCount())),
959                insn.getIndexUnit(),
960                codeUnit(insn.getA(), insn.getB(), insn.getC(), insn.getD()));
961    }
962
963    /**
964     * Helper method that decodes any of the three-unit register-range formats.
965     */
966    private static DecodedInstruction decodeRegisterRange(
967            InstructionCodec format, int opcodeUnit, CodeInput in)
968            throws EOFException {
969        int opcode = byte0(opcodeUnit);
970        int registerCount = byte1(opcodeUnit);
971        int index = in.read();
972        int a = in.read();
973        IndexType indexType = OpcodeInfo.getIndexType(opcode);
974        return new RegisterRangeDecodedInstruction(
975                format, opcode, index, indexType,
976                0, 0L,
977                a, registerCount);
978    }
979
980    /**
981     * Helper method that encodes any of the three-unit register-range formats.
982     */
983    private static void encodeRegisterRange(DecodedInstruction insn,
984            CodeOutput out) {
985        out.write(codeUnit(insn.getOpcode(), insn.getRegisterCount()),
986                insn.getIndexUnit(),
987                insn.getAUnit());
988    }
989
990    private static short codeUnit(int lowByte, int highByte) {
991        if ((lowByte & ~0xff) != 0) {
992            throw new IllegalArgumentException("bogus lowByte");
993        }
994
995        if ((highByte & ~0xff) != 0) {
996            throw new IllegalArgumentException("bogus highByte");
997        }
998
999        return (short) (lowByte | (highByte << 8));
1000    }
1001
1002    private static short codeUnit(int nibble0, int nibble1, int nibble2,
1003            int nibble3) {
1004        if ((nibble0 & ~0xf) != 0) {
1005            throw new IllegalArgumentException("bogus nibble0");
1006        }
1007
1008        if ((nibble1 & ~0xf) != 0) {
1009            throw new IllegalArgumentException("bogus nibble1");
1010        }
1011
1012        if ((nibble2 & ~0xf) != 0) {
1013            throw new IllegalArgumentException("bogus nibble2");
1014        }
1015
1016        if ((nibble3 & ~0xf) != 0) {
1017            throw new IllegalArgumentException("bogus nibble3");
1018        }
1019
1020        return (short) (nibble0 | (nibble1 << 4)
1021                | (nibble2 << 8) | (nibble3 << 12));
1022    }
1023
1024    private static int makeByte(int lowNibble, int highNibble) {
1025        if ((lowNibble & ~0xf) != 0) {
1026            throw new IllegalArgumentException("bogus lowNibble");
1027        }
1028
1029        if ((highNibble & ~0xf) != 0) {
1030            throw new IllegalArgumentException("bogus highNibble");
1031        }
1032
1033        return lowNibble | (highNibble << 4);
1034    }
1035
1036    private static short asUnsignedUnit(int value) {
1037        if ((value & ~0xffff) != 0) {
1038            throw new IllegalArgumentException("bogus unsigned code unit");
1039        }
1040
1041        return (short) value;
1042    }
1043
1044    private static short unit0(int value) {
1045        return (short) value;
1046    }
1047
1048    private static short unit1(int value) {
1049        return (short) (value >> 16);
1050    }
1051
1052    private static short unit0(long value) {
1053        return (short) value;
1054    }
1055
1056    private static short unit1(long value) {
1057        return (short) (value >> 16);
1058    }
1059
1060    private static short unit2(long value) {
1061        return (short) (value >> 32);
1062    }
1063
1064    private static short unit3(long value) {
1065        return (short) (value >> 48);
1066    }
1067
1068    private static int byte0(int value) {
1069        return value & 0xff;
1070    }
1071
1072    private static int byte1(int value) {
1073        return (value >> 8) & 0xff;
1074    }
1075
1076    private static int byte2(int value) {
1077        return (value >> 16) & 0xff;
1078    }
1079
1080    private static int byte3(int value) {
1081        return value >>> 24;
1082    }
1083
1084    private static int nibble0(int value) {
1085        return value & 0xf;
1086    }
1087
1088    private static int nibble1(int value) {
1089        return (value >> 4) & 0xf;
1090    }
1091
1092    private static int nibble2(int value) {
1093        return (value >> 8) & 0xf;
1094    }
1095
1096    private static int nibble3(int value) {
1097        return (value >> 12) & 0xf;
1098    }
1099}
1100