CodeDisassembler


1   /* ====================================================================
2    * Trove - Copyright (c) 1997-2000 Walt Disney Internet Group
3    * ====================================================================
4    * The Tea Software License, Version 1.1
5    *
6    * Copyright (c) 2000 Walt Disney Internet Group. All rights reserved.
7    *
8    * Redistribution and use in source and binary forms, with or without
9    * modification, are permitted provided that the following conditions
10   * are met:
11   *
12   * 1. Redistributions of source code must retain the above copyright
13   *    notice, this list of conditions and the following disclaimer.
14   *
15   * 2. Redistributions in binary form must reproduce the above copyright
16   *    notice, this list of conditions and the following disclaimer in
17   *    the documentation and/or other materials provided with the
18   *    distribution.
19   *
20   * 3. The end-user documentation included with the redistribution,
21   *    if any, must include the following acknowledgment:
22   *       "This product includes software developed by the
23   *        Walt Disney Internet Group (http://opensource.go.com/)."
24   *    Alternately, this acknowledgment may appear in the software itself,
25   *    if and wherever such third-party acknowledgments normally appear.
26   *
27   * 4. The names "Tea", "TeaServlet", "Kettle", "Trove" and "BeanDoc" must
28   *    not be used to endorse or promote products derived from this
29   *    software without prior written permission. For written
30   *    permission, please contact opensource@dig.com.
31   *
32   * 5. Products derived from this software may not be called "Tea",
33   *    "TeaServlet", "Kettle" or "Trove", nor may "Tea", "TeaServlet",
34   *    "Kettle", "Trove" or "BeanDoc" appear in their name, without prior
35   *    written permission of the Walt Disney Internet Group.
36   *
37   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40   * DISCLAIMED.  IN NO EVENT SHALL THE WALT DISNEY INTERNET GROUP OR ITS
41   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
42   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
43   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
44   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
45   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
46   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
47   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48   * ====================================================================
49   *
50   * For more information about Tea, please see http://opensource.go.com/.
51   */
52  
53  package com.go.trove.classfile;
54  
55  import java.util.*;
56  
57  /******************************************************************************
58   * 
59   * @author Brian S O'Neill
60   * @version
61   * <!--$$Revision:--> 16 <!-- $-->, <!--$$JustDate:--> 00/12/27 <!-- $-->
62   */
63  public class CodeDisassembler {
64      private final MethodInfo mMethod;
65      private final String   mEnclosingClassName;
66      private final String   mSuperClassName;
67      private final CodeAttr mCode;
68      private final ConstantPool mCp;
69      private final byte[] mByteCodes;
70      private final ExceptionHandler[] mExceptionHandlers;
71  
72      // Current CodeAssembler in use for disassembly.
73      private CodeAssembler mAssembler;
74  
75      // List of all the LocalVariable objects in use.
76      private Vector mLocals;
77  
78      // True if the method being decompiled still has a "this" reference.
79      private boolean mHasThis;
80  
81      // Maps Integer address keys to itself, but to Label objects after first
82      // needed.
83      private Map mLabels;
84  
85      // Maps Integer catch locations to Lists of ExceptionHandler objects.
86      private Map mCatchLocations;
87  
88      // Current address being decompiled.
89      private int mAddress;
90  
91      public CodeDisassembler(MethodInfo method) {
92          mMethod = method;
93          mEnclosingClassName = method.getClassFile().getClassName();
94          mSuperClassName = method.getClassFile().getSuperClassName();
95          mCode = method.getCodeAttr();
96          mCp = mCode.getConstantPool();
97          CodeBuffer buffer = mCode.getCodeBuffer();
98          mByteCodes = buffer.getByteCodes();
99          mExceptionHandlers = buffer.getExceptionHandlers();
100     }
101 
102     /**
103      * Disassemble the MethodInfo into the given assembler.
104      *
105      * @see CodeAssemblerPrinter
106      */
107     public synchronized void disassemble(CodeAssembler assembler) {
108         mAssembler = assembler;
109         mLocals = new Vector();
110         mHasThis = !mMethod.getAccessFlags().isStatic();
111 
112         gatherLabels();
113 
114         // Gather the local variables of the parameters.
115         LocalVariable[] paramVars = assembler.getParameters();
116         for (int i=0; i<paramVars.length; i++) {
117             LocalVariable paramVar = paramVars[i];
118             int number = paramVar.getNumber();
119             if (number >= mLocals.size()) {
120                 mLocals.setSize(number + 1);
121             }
122             mLocals.setElementAt(paramVar, number);
123         }
124 
125         Location currentLoc = new Location() {
126             public int getLocation() {
127                 return mAddress;
128             }
129 
130             public int compareTo(Object   obj) {
131                 if (this == obj) {
132                     return 0;
133                 }
134                 Location other = (Location)obj;
135                 
136                 int loca = getLocation();
137                 int locb = other.getLocation();
138                 
139                 if (loca < locb) {
140                     return -1;
141                 }
142                 else if (loca > locb) {
143                     return 1;
144                 }
145                 else {
146                     return 0;
147                 }
148             }
149         };
150 
151         int currentLine = -1;
152 
153         for (mAddress = 0; mAddress < mByteCodes.length; mAddress++) {
154             int nextLine = mCode.getLineNumber(currentLoc);
155             if (nextLine != currentLine) {
156                 if ((currentLine = nextLine) >= 0) {
157                     mAssembler.mapLineNumber(currentLine);
158                 }
159             }
160 
161             // Check if a label needs to be created and/or located.
162             locateLabel();
163 
164             byte opcode = mByteCodes[mAddress];
165 
166             int index;
167             Location loc;
168             Class   clazz;
169             ConstantInfo ci;
170 
171             switch (opcode) {
172 
173             default:
174                 // TODO: raise an error.
175                 break;
176 
177                 // Opcodes with no operands...
178 
179             case Opcode.NOP:
180                 assembler.nop();
181                 break;
182             case Opcode.BREAKPOINT:
183                 assembler.breakpoint();
184                 break;
185 
186             case Opcode.ACONST_NULL:
187                 assembler.loadConstant(null);
188                 break;
189             case Opcode.ICONST_M1:
190                 assembler.loadConstant(-1);
191                 break;
192             case Opcode.ICONST_0:
193                 assembler.loadConstant(0);
194                 break;
195             case Opcode.ICONST_1:
196                 assembler.loadConstant(1);
197                 break;
198             case Opcode.ICONST_2:
199                 assembler.loadConstant(2);
200                 break;
201             case Opcode.ICONST_3:
202                 assembler.loadConstant(3);
203                 break;
204             case Opcode.ICONST_4:
205                 assembler.loadConstant(4);
206                 break;
207             case Opcode.ICONST_5:
208                 assembler.loadConstant(5);
209                 break;
210             case Opcode.LCONST_0:
211                 assembler.loadConstant(0L);
212                 break;
213             case Opcode.LCONST_1:
214                 assembler.loadConstant(1L);
215                 break;
216             case Opcode.FCONST_0:
217                 assembler.loadConstant(0f);
218                 break;
219             case Opcode.FCONST_1:
220                 assembler.loadConstant(1f);
221                 break;
222             case Opcode.FCONST_2:
223                 assembler.loadConstant(2f);
224                 break;
225             case Opcode.DCONST_0:
226                 assembler.loadConstant(0d);
227                 break;
228             case Opcode.DCONST_1:
229                 assembler.loadConstant(1d);
230                 break;
231 
232             case Opcode.POP:
233                 assembler.pop();
234                 break;
235             case Opcode.POP2:
236                 assembler.pop2();
237                 break;
238             case Opcode.DUP:
239                 assembler.dup();
240                 break;
241             case Opcode.DUP_X1:
242                 assembler.dupX1();
243                 break;
244             case Opcode.DUP_X2:
245                 assembler.dupX2();
246                 break;
247             case Opcode.DUP2:
248                 assembler.dup2();
249                 break;
250             case Opcode.DUP2_X1:
251                 assembler.dup2X2();
252                 break;
253             case Opcode.DUP2_X2:
254                 assembler.dup2X2();
255                 break;
256             case Opcode.SWAP:
257                 assembler.swap();
258                 break;
259 
260             case Opcode.IADD:  case Opcode.LADD: 
261             case Opcode.FADD:  case Opcode.DADD:
262             case Opcode.ISUB:  case Opcode.LSUB:
263             case Opcode.FSUB:  case Opcode.DSUB:
264             case Opcode.IMUL:  case Opcode.LMUL:
265             case Opcode.FMUL:  case Opcode.DMUL:
266             case Opcode.IDIV:  case Opcode.LDIV:
267             case Opcode.FDIV:  case Opcode.DDIV:
268             case Opcode.IREM:  case Opcode.LREM:
269             case Opcode.FREM:  case Opcode.DREM:
270             case Opcode.INEG:  case Opcode.LNEG:
271             case Opcode.FNEG:  case Opcode.DNEG:
272             case Opcode.ISHL:  case Opcode.LSHL:
273             case Opcode.ISHR:  case Opcode.LSHR:
274             case Opcode.IUSHR: case Opcode.LUSHR:
275             case Opcode.IAND:  case Opcode.LAND:
276             case Opcode.IOR:   case Opcode.LOR:
277             case Opcode.IXOR:  case Opcode.LXOR:
278             case Opcode.FCMPL: case Opcode.DCMPL:
279             case Opcode.FCMPG: case Opcode.DCMPG:
280             case Opcode.LCMP: 
281                 assembler.math(opcode);
282                 break;
283 
284             case Opcode.I2L:
285                 assembler.convert(int.class, long.class);
286                 break;
287             case Opcode.I2F:
288                 assembler.convert(int.class, float.class);
289                 break;
290             case Opcode.I2D:
291                 assembler.convert(int.class, double.class);
292                 break;
293             case Opcode.L2I:
294                 assembler.convert(long.class, int.class);
295                 break;
296             case Opcode.L2F:
297                 assembler.convert(long.class, float.class);
298                 break;
299             case Opcode.L2D:
300                 assembler.convert(long.class, double.class);
301                 break;
302             case Opcode.F2I:
303                 assembler.convert(float.class, int.class);
304                 break;
305             case Opcode.F2L:
306                 assembler.convert(float.class, long.class);
307                 break;
308             case Opcode.F2D:
309                 assembler.convert(float.class, double.class);
310                 break;
311             case Opcode.D2I:
312                 assembler.convert(double.class, int.class);
313                 break;
314             case Opcode.D2L:
315                 assembler.convert(double.class, long.class);
316                 break;
317             case Opcode.D2F:
318                 assembler.convert(double.class, float.class);
319                 break;
320             case Opcode.I2B:
321                 assembler.convert(int.class, byte.class);
322                 break;
323             case Opcode.I2C:
324                 assembler.convert(int.class, char.class);
325                 break;
326             case Opcode.I2S:
327                 assembler.convert(int.class, short.class);
328                 break;
329 
330             case Opcode.IRETURN:
331                 assembler.returnValue(int.class);
332                 break;
333             case Opcode.LRETURN:
334                 assembler.returnValue(long.class);
335                 break;
336             case Opcode.FRETURN:
337                 assembler.returnValue(float.class);
338                 break;
339             case Opcode.DRETURN:
340                 assembler.returnValue(double.class);
341                 break;
342             case Opcode.ARETURN:
343                 assembler.returnValue(Object  .class);
344                 break;
345             case Opcode.RETURN:
346                 assembler.returnVoid();
347                 break;
348 
349             case Opcode.IALOAD:
350                 assembler.loadFromArray(int.class);
351                 break;
352             case Opcode.LALOAD:
353                 assembler.loadFromArray(long.class);
354                 break;
355             case Opcode.FALOAD:
356                 assembler.loadFromArray(float.class);
357                 break;
358             case Opcode.DALOAD:
359                 assembler.loadFromArray(double.class);
360                 break;
361             case Opcode.AALOAD:
362                 assembler.loadFromArray(Object  .class);
363                 break;
364             case Opcode.BALOAD:
365                 assembler.loadFromArray(byte.class);
366                 break;
367             case Opcode.CALOAD:
368                 assembler.loadFromArray(char.class);
369                 break;
370             case Opcode.SALOAD:
371                 assembler.loadFromArray(short.class);
372                 break;
373 
374             case Opcode.IASTORE:
375                 assembler.storeToArray(int.class);
376                 break;
377             case Opcode.LASTORE:
378                 assembler.storeToArray(long.class);
379                 break;
380             case Opcode.FASTORE:
381                 assembler.storeToArray(float.class);
382                 break;
383             case Opcode.DASTORE:
384                 assembler.storeToArray(double.class);
385                 break;
386             case Opcode.AASTORE:
387                 assembler.storeToArray(Object  .class);
388                 break;
389             case Opcode.BASTORE:
390                 assembler.storeToArray(byte.class);
391                 break;
392             case Opcode.CASTORE:
393                 assembler.storeToArray(char.class);
394                 break;
395             case Opcode.SASTORE:
396                 assembler.storeToArray(short.class);
397                 break;
398 
399             case Opcode.ARRAYLENGTH:
400                 assembler.arrayLength();
401                 break;
402             case Opcode.ATHROW:
403                 assembler.throwObject();
404                 break;
405             case Opcode.MONITORENTER:
406                 assembler.monitorEnter();
407                 break;
408             case Opcode.MONITOREXIT:
409                 assembler.monitorExit();
410                 break;
411 
412                 // End opcodes with no operands.
413 
414                 // Opcodes that load a constant from the constant pool...
415                 
416             case Opcode.LDC:
417             case Opcode.LDC_W:
418             case Opcode.LDC2_W:
419                 switch (opcode) {
420                 case Opcode.LDC:
421                     index = readUnsignedByte();
422                     break;
423                 case Opcode.LDC_W:
424                 case Opcode.LDC2_W:
425                     index = readUnsignedShort();
426                     break;
427                 default:
428                     index = 0;
429                     break;
430                 }
431 
432                 ci = mCp.getConstant(index);
433 
434                 if (ci instanceof ConstantStringInfo) {
435                     assembler.loadConstant
436                         (((ConstantStringInfo)ci).getValue());
437                 }
438                 else if (ci instanceof ConstantIntegerInfo) {
439                     assembler.loadConstant
440                         (((ConstantIntegerInfo)ci).getValue().intValue());
441                 }
442                 else if (ci instanceof ConstantLongInfo) {
443                     assembler.loadConstant
444                         (((ConstantLongInfo)ci).getValue().longValue());
445                 }
446                 else if (ci instanceof ConstantFloatInfo) {
447                     assembler.loadConstant
448                         (((ConstantFloatInfo)ci).getValue().floatValue());
449                 }
450                 else if (ci instanceof ConstantDoubleInfo) {
451                     assembler.loadConstant
452                         (((ConstantDoubleInfo)ci).getValue().doubleValue());
453                 }
454                 else {
455                     // TODO: raise an error.
456                 }
457                 break;
458 
459             case Opcode.NEW:
460                 ci = mCp.getConstant(readUnsignedShort());
461 
462                 if (ci instanceof ConstantClassInfo) {
463                     assembler.newObject
464                         (((ConstantClassInfo)ci).getTypeDescriptor());
465                 }
466                 else {
467                     // TODO: raise an error.
468                 }
469                 break;
470             case Opcode.ANEWARRAY:
471                 ci = mCp.getConstant(readUnsignedShort());
472 
473                 if (ci instanceof ConstantClassInfo) {
474                     TypeDescriptor type = 
475                         ((ConstantClassInfo)ci).getTypeDescriptor();
476                     type = new TypeDescriptor(type, 1);
477                     assembler.newObject(type);
478                 }
479                 else {
480                     // TODO: raise an error.
481                 }
482                 break;
483             case Opcode.MULTIANEWARRAY:
484                 ci = mCp.getConstant(readUnsignedShort());
485                 int dims = readUnsignedByte();
486 
487                 if (ci instanceof ConstantClassInfo) {
488                     assembler.newObject
489                         (((ConstantClassInfo)ci).getTypeDescriptor());
490                 }
491                 else {
492                     // TODO: raise an error.
493                 }
494                 break;
495 
496             case Opcode.CHECKCAST:
497                 ci = mCp.getConstant(readUnsignedShort());
498 
499                 if (ci instanceof ConstantClassInfo) {
500                     assembler.checkCast
501                         (((ConstantClassInfo)ci).getTypeDescriptor());
502                 }
503                 else {
504                     // TODO: raise an error.
505                 }
506                 break;
507             case Opcode.INSTANCEOF:
508                 ci = mCp.getConstant(readUnsignedShort());
509 
510                 if (ci instanceof ConstantClassInfo) {
511                     assembler.instanceOf
512                         (((ConstantClassInfo)ci).getTypeDescriptor());
513                 }
514                 else {
515                     // TODO: raise an error.
516                 }
517                 break;
518 
519             case Opcode.GETSTATIC:
520             case Opcode.PUTSTATIC:
521             case Opcode.GETFIELD:
522             case Opcode.PUTFIELD:
523                 ci = mCp.getConstant(readUnsignedShort());
524                 if (!(ci instanceof ConstantFieldInfo)) {
525                     // TODO: raise an error.
526                     break;
527                 }
528                 ConstantFieldInfo field = (ConstantFieldInfo)ci;
529                 String   className = field.getParentClass().getClassName();
530                 if (mEnclosingClassName.equals(className)) {
531                     className = null;
532                 }
533                 String   fieldName = field.getNameAndType().getName();
534                 Descriptor type = field.getNameAndType().getType();
535                 if (!(type instanceof TypeDescriptor)) {
536                     // TODO: raise an error.
537                     break;
538                 }
539 
540                 // Implementation note: Although it may seem convenient if the
541                 // CodeAssembler had methods that accepted ConstantFieldInfo
542                 // objects as parameters, it would cause problems because
543                 // ConstantPools are not portable between ClassFiles.
544                 
545                 switch (opcode) {
546                 case Opcode.GETSTATIC:
547                     if (className == null) {
548                         assembler.loadStaticField
549                             (fieldName, (TypeDescriptor)type);
550                     }
551                     else {
552                         assembler.loadStaticField
553                             (className, fieldName, (TypeDescriptor)type);
554                     }
555                     break;
556                 case Opcode.PUTSTATIC:
557                     if (className == null) {
558                         assembler.storeStaticField
559                             (fieldName, (TypeDescriptor)type);
560                     }
561                     else {
562                         assembler.storeStaticField
563                             (className, fieldName, (TypeDescriptor)type);
564                     }
565                     break;
566                 case Opcode.GETFIELD:
567                     if (className == null) {
568                         assembler.loadField
569                             (fieldName, (TypeDescriptor)type);
570                     }
571                     else {
572                         assembler.loadField
573                             (className, fieldName, (TypeDescriptor)type);
574                     }
575                     break;
576                 case Opcode.PUTFIELD:
577                     if (className == null) {
578                         assembler.storeField
579                             (fieldName, (TypeDescriptor)type);
580                     }
581                     else {
582                         assembler.storeField
583                             (className, fieldName, (TypeDescriptor)type);
584                     }
585                     break;
586                 }
587                 break;
588 
589             case Opcode.INVOKEVIRTUAL:
590             case Opcode.INVOKESPECIAL:
591             case Opcode.INVOKESTATIC:
592             case Opcode.INVOKEINTERFACE:
593                 ci = mCp.getConstant(readUnsignedShort());
594 
595                 ConstantNameAndTypeInfo nameAndType;
596 
597                 if (opcode == Opcode.INVOKEINTERFACE) {
598                     // Read and ignore nargs and padding byte.
599                     readShort();
600                     if (!(ci instanceof ConstantInterfaceMethodInfo)) {
601                         // TODO: raise an error.
602                         break;
603                     }
604                     ConstantInterfaceMethodInfo method = 
605                         (ConstantInterfaceMethodInfo)ci;
606                     className = method.getParentClass().getClassName();
607                     nameAndType = method.getNameAndType();
608                 }
609                 else {
610                     if (!(ci instanceof ConstantMethodInfo)) {
611                         // TODO: raise an error.
612                         break;
613                     }
614                     ConstantMethodInfo method = 
615                         (ConstantMethodInfo)ci;
616                     className = method.getParentClass().getClassName();
617                     if (mEnclosingClassName.equals(className)) {
618                         className = null;
619                     }
620                     nameAndType = method.getNameAndType();
621                 }
622 
623                 String   methodName = nameAndType.getName();
624                 type = nameAndType.getType();
625                 if (!(type instanceof MethodDescriptor)) {
626                     // TODO: raise an error.
627                     break;
628                 }
629                 TypeDescriptor ret = ((MethodDescriptor)type).getReturnType();
630                 if (ret.getClassArg() == void.class) {
631                     ret = null;
632                 }
633                 TypeDescriptor[] params = 
634                     ((MethodDescriptor)type).getParameterTypes();
635                 if (params.length == 0) {
636                     params = null;
637                 }
638 
639                 switch (opcode) {
640                 case Opcode.INVOKEVIRTUAL:
641                     if (className == null) {
642                         assembler.invokeVirtual(methodName, ret, params);
643                     }
644                     else {
645                         assembler.invokeVirtual
646                             (className, methodName, ret, params);
647                     }
648                     break;
649                 case Opcode.INVOKESPECIAL:
650                     if ("<init>".equals(methodName)) {
651                         if (className == null) {
652                             assembler.invokeConstructor(params);
653                         }
654                         else {
655                             if (className.equals(mSuperClassName)) {
656                                 assembler.invokeSuperConstructor(params);
657                             }
658                             else {
659                                 assembler.invokeConstructor(className, params);
660                             }
661                         }
662                     }
663                     else {
664                         if (className == null) {
665                             assembler.invokePrivate(methodName, ret, params);
666                         }
667                         else {
668                             assembler.invokeSuper
669                                 (className, methodName, ret, params);
670                         }
671                     }
672                     break;
673                 case Opcode.INVOKESTATIC:
674                     if (className == null) {
675                         assembler.invokeStatic(methodName, ret, params);
676                     }
677                     else {
678                         assembler.invokeStatic
679                             (className, methodName, ret, params);
680                     }
681                     break;
682                 case Opcode.INVOKEINTERFACE:
683                     assembler.invokeInterface
684                         (className, methodName, ret, params);
685                     break;
686                 }
687                 break;
688 
689                 // End opcodes that load a constant from the constant pool.
690 
691                 // Opcodes that load or store local variables...
692 
693             case Opcode.ILOAD: case Opcode.ISTORE:
694             case Opcode.LLOAD: case Opcode.LSTORE:
695             case Opcode.FLOAD: case Opcode.FSTORE:
696             case Opcode.DLOAD: case Opcode.DSTORE:
697             case Opcode.ALOAD: case Opcode.ASTORE:
698             case Opcode.ILOAD_0: case Opcode.ISTORE_0:
699             case Opcode.ILOAD_1: case Opcode.ISTORE_1:
700             case Opcode.ILOAD_2: case Opcode.ISTORE_2:
701             case Opcode.ILOAD_3: case Opcode.ISTORE_3:
702             case Opcode.LLOAD_0: case Opcode.LSTORE_0:
703             case Opcode.LLOAD_1: case Opcode.LSTORE_1:
704             case Opcode.LLOAD_2: case Opcode.LSTORE_2:
705             case Opcode.LLOAD_3: case Opcode.LSTORE_3:
706             case Opcode.FLOAD_0: case Opcode.FSTORE_0:
707             case Opcode.FLOAD_1: case Opcode.FSTORE_1:
708             case Opcode.FLOAD_2: case Opcode.FSTORE_2:
709             case Opcode.FLOAD_3: case Opcode.FSTORE_3:
710             case Opcode.DLOAD_0: case Opcode.DSTORE_0:
711             case Opcode.DLOAD_1: case Opcode.DSTORE_1:
712             case Opcode.DLOAD_2: case Opcode.DSTORE_2:
713             case Opcode.DLOAD_3: case Opcode.DSTORE_3:
714             case Opcode.ALOAD_0: case Opcode.ASTORE_0:
715             case Opcode.ALOAD_1: case Opcode.ASTORE_1:
716             case Opcode.ALOAD_2: case Opcode.ASTORE_2:
717             case Opcode.ALOAD_3: case Opcode.ASTORE_3:
718                 switch (opcode) {
719                 case Opcode.ILOAD: case Opcode.ISTORE:
720                     index = readUnsignedByte();
721                     clazz = int.class;
722                     break;
723                 case Opcode.LLOAD: case Opcode.LSTORE:
724                     index = readUnsignedByte();
725                     clazz = long.class;
726                     break;
727                 case Opcode.FLOAD: case Opcode.FSTORE:
728                     index = readUnsignedByte();
729                     clazz = float.class;
730                     break;
731                 case Opcode.DLOAD: case Opcode.DSTORE:
732                     index = readUnsignedByte();
733                     clazz = double.class;
734                     break;
735                 case Opcode.ALOAD: case Opcode.ASTORE:
736                     index = readUnsignedByte();
737                     clazz = Object  .class;
738                     break;
739                 case Opcode.ILOAD_0: case Opcode.ISTORE_0:
740                     index = 0;
741                     clazz = int.class;
742                     break;
743                 case Opcode.ILOAD_1: case Opcode.ISTORE_1:
744                     index = 1;
745                     clazz = int.class;
746                     break;
747                 case Opcode.ILOAD_2: case Opcode.ISTORE_2:
748                     index = 2;
749                     clazz = int.class;
750                     break;
751                 case Opcode.ILOAD_3: case Opcode.ISTORE_3:
752                     index = 3;
753                     clazz = int.class;
754                     break;
755                 case Opcode.LLOAD_0: case Opcode.LSTORE_0:
756                     index = 0;
757                     clazz = long.class;
758                     break;
759                 case Opcode.LLOAD_1: case Opcode.LSTORE_1:
760                     index = 1;
761                     clazz = long.class;
762                     break;
763                 case Opcode.LLOAD_2: case Opcode.LSTORE_2:
764                     index = 2;
765                     clazz = long.class;
766                     break;
767                 case Opcode.LLOAD_3: case Opcode.LSTORE_3:
768                     index = 3;
769                     clazz = long.class;
770                     break;
771                 case Opcode.FLOAD_0: case Opcode.FSTORE_0:
772                     index = 0;
773                     clazz = float.class;
774                     break;
775                 case Opcode.FLOAD_1: case Opcode.FSTORE_1:
776                     index = 1;
777                     clazz = float.class;
778                     break;
779                 case Opcode.FLOAD_2: case Opcode.FSTORE_2:
780                     index = 2;
781                     clazz = float.class;
782                     break;
783                 case Opcode.FLOAD_3: case Opcode.FSTORE_3:
784                     index = 3;
785                     clazz = float.class;
786                     break;
787                 case Opcode.DLOAD_0: case Opcode.DSTORE_0:
788                     index = 0;
789                     clazz = double.class;
790                     break;
791                 case Opcode.DLOAD_1: case Opcode.DSTORE_1:
792                     index = 1;
793                     clazz = double.class;
794                     break;
795                 case Opcode.DLOAD_2: case Opcode.DSTORE_2:
796                     index = 2;
797                     clazz = double.class;
798                     break;
799                 case Opcode.DLOAD_3: case Opcode.DSTORE_3:
800                     index = 3;
801                     clazz = double.class;
802                     break;
803                 case Opcode.ALOAD_0: case Opcode.ASTORE_0:
804                     index = 0;
805                     clazz = Object  .class;
806                     break;
807                 case Opcode.ALOAD_1: case Opcode.ASTORE_1:
808                     index = 1;
809                     clazz = Object  .class;
810                     break;
811                 case Opcode.ALOAD_2: case Opcode.ASTORE_2:
812                     index = 2;
813                     clazz = Object  .class;
814                     break;
815                 case Opcode.ALOAD_3: case Opcode.ASTORE_3:
816                     index = 3;
817                     clazz = Object  .class;
818                     break;
819                 default:
820                     index = 0;
821                     clazz = null;
822                     break;
823                 }
824 
825                 switch (opcode) {
826                 case Opcode.ILOAD:
827                 case Opcode.LLOAD:
828                 case Opcode.FLOAD:
829                 case Opcode.DLOAD:
830                 case Opcode.ALOAD:
831                 case Opcode.ILOAD_0:
832                 case Opcode.ILOAD_1:
833                 case Opcode.ILOAD_2:
834                 case Opcode.ILOAD_3:
835                 case Opcode.LLOAD_0:
836                 case Opcode.LLOAD_1:
837                 case Opcode.LLOAD_2:
838                 case Opcode.LLOAD_3:
839                 case Opcode.FLOAD_0:
840                 case Opcode.FLOAD_1:
841                 case Opcode.FLOAD_2:
842                 case Opcode.FLOAD_3:
843                 case Opcode.DLOAD_0:
844                 case Opcode.DLOAD_1:
845                 case Opcode.DLOAD_2:
846                 case Opcode.DLOAD_3:
847                 case Opcode.ALOAD_0:
848                 case Opcode.ALOAD_1:
849                 case Opcode.ALOAD_2:
850                 case Opcode.ALOAD_3:
851                     if (index == 0 && mHasThis) {
852                         assembler.loadThis();
853                     }
854                     else {
855                         assembler.loadLocal(getLocalVariable(index, clazz));
856                     }
857                     break;
858                 case Opcode.ISTORE:
859                 case Opcode.LSTORE:
860                 case Opcode.FSTORE:
861                 case Opcode.DSTORE:
862                 case Opcode.ASTORE:
863                 case Opcode.ISTORE_0:
864                 case Opcode.ISTORE_1:
865                 case Opcode.ISTORE_2:
866                 case Opcode.ISTORE_3:
867                 case Opcode.LSTORE_0:
868                 case Opcode.LSTORE_1:
869                 case Opcode.LSTORE_2:
870                 case Opcode.LSTORE_3:
871                 case Opcode.FSTORE_0:
872                 case Opcode.FSTORE_1:
873                 case Opcode.FSTORE_2:
874                 case Opcode.FSTORE_3:
875                 case Opcode.DSTORE_0:
876                 case Opcode.DSTORE_1:
877                 case Opcode.DSTORE_2:
878                 case Opcode.DSTORE_3:
879                 case Opcode.ASTORE_0:
880                 case Opcode.ASTORE_1:
881                 case Opcode.ASTORE_2:
882                 case Opcode.ASTORE_3:
883                     if (index == 0 && mHasThis) {
884                         // The "this" reference just got blown away.
885                         mHasThis = false;
886                     }
887                     assembler.storeLocal(getLocalVariable(index, clazz));
888                     break;
889                 }
890                 break;
891 
892             case Opcode.RET:
893                 LocalVariable local = getLocalVariable
894                     (readUnsignedByte(), Object  .class);
895                 assembler.ret(local);
896                 break;
897 
898             case Opcode.IINC:
899                 local = getLocalVariable(readUnsignedByte(), int.class);
900                 assembler.integerIncrement(local, readByte());
901                 break;
902 
903                 // End opcodes that load or store local variables.
904 
905                 // Opcodes that branch to another address.
906 
907             case Opcode.GOTO:
908                 loc = getLabel(mAddress + readShort());
909                 assembler.branch(loc);
910                 break;
911             case Opcode.JSR:
912                 loc = getLabel(mAddress + readShort());
913                 assembler.jsr(loc);
914                 break;
915             case Opcode.GOTO_W:
916                 loc = getLabel(mAddress + readInt());
917                 assembler.branch(loc);
918                 break;
919             case Opcode.JSR_W:
920                 loc = getLabel(mAddress + readInt());
921                 assembler.jsr(loc);
922                 break;
923 
924             case Opcode.IFNULL:
925                 loc = getLabel(mAddress + readShort());
926                 assembler.ifNullBranch(loc, true);
927                 break;
928             case Opcode.IFNONNULL:
929                 loc = getLabel(mAddress + readShort());
930                 assembler.ifNullBranch(loc, false);
931                 break;
932 
933             case Opcode.IF_ACMPEQ:
934                 loc = getLabel(mAddress + readShort());
935                 assembler.ifEqualBranch(loc, true);
936                 break;
937             case Opcode.IF_ACMPNE:
938                 loc = getLabel(mAddress + readShort());
939                 assembler.ifEqualBranch(loc, false);
940                 break;
941 
942             case Opcode.IFEQ:
943             case Opcode.IFNE:
944             case Opcode.IFLT:
945             case Opcode.IFGE:
946             case Opcode.IFGT:
947             case Opcode.IFLE:
948                 loc = getLabel(mAddress + readShort());
949                 String   choice;
950                 switch (opcode) {
951                 case Opcode.IFEQ:
952                     choice = "==";
953                     break;
954                 case Opcode.IFNE:
955                     choice = "!=";
956                     break;
957                 case Opcode.IFLT:
958                     choice = "<";
959                     break;
960                 case Opcode.IFGE:
961                     choice = ">=";
962                     break;
963                 case Opcode.IFGT:
964                     choice = ">";
965                     break;
966                 case Opcode.IFLE:
967                     choice = "<=";
968                     break;
969                 default:
970                     choice = null;
971                     break;
972                 }
973                 assembler.ifZeroComparisonBranch(loc, choice);
974                 break;
975 
976             case Opcode.IF_ICMPEQ:
977             case Opcode.IF_ICMPNE:
978             case Opcode.IF_ICMPLT:
979             case Opcode.IF_ICMPGE:
980             case Opcode.IF_ICMPGT:
981             case Opcode.IF_ICMPLE:
982                 loc = getLabel(mAddress + readShort());
983                 switch (opcode) {
984                 case Opcode.IF_ICMPEQ:
985                     choice = "==";
986                     break;
987                 case Opcode.IF_ICMPNE:
988                     choice = "!=";
989                     break;
990                 case Opcode.IF_ICMPLT:
991                     choice = "<";
992                     break;
993                 case Opcode.IF_ICMPGE:
994                     choice = ">=";
995                     break;
996                 case Opcode.IF_ICMPGT:
997                     choice = ">";
998                     break;
999                 case Opcode.IF_ICMPLE:
1000                    choice = "<=";
1001                    break;
1002                default:
1003                    choice = null;
1004                    break;
1005                }
1006                assembler.ifComparisonBranch(loc, choice);
1007                break;
1008
1009                // End opcodes that branch to another address.
1010
1011                // Miscellaneous opcodes...
1012
1013            case Opcode.BIPUSH:
1014                assembler.loadConstant(readByte());
1015                break;
1016            case Opcode.SIPUSH:
1017                assembler.loadConstant(readShort());
1018                break;
1019
1020            case Opcode.NEWARRAY:
1021                int atype = readByte();
1022                clazz = null;
1023                switch (atype) {
1024                case 4: // T_BOOLEAN
1025                    clazz = boolean.class;
1026                    break;
1027                case 5: // T_CHAR
1028                    clazz = char.class;
1029                    break;
1030                case 6: // T_FLOAT
1031                    clazz = float.class;
1032                    break;
1033                case 7: // T_DOUBLE
1034                    clazz = double.class;
1035                    break;
1036                case 8: // T_BYTE
1037                    clazz = byte.class;
1038                    break;
1039                case 9: // T_SHORT
1040                    clazz = short.class;
1041                    break;
1042                case 10: // T_INT
1043                    clazz = int.class;
1044                    break;
1045                case 11: // T_LONG
1046                    clazz = long.class;
1047                    break;
1048                }
1049
1050                if (clazz == null) {
1051                    // TODO: raise an error.
1052                    break;
1053                }
1054
1055                assembler.newObject
1056                    (new TypeDescriptor(new TypeDescriptor(clazz), 1));
1057                break;
1058
1059            case Opcode.TABLESWITCH:
1060            case Opcode.LOOKUPSWITCH:
1061                int opcodeAddress = mAddress;
1062                // Read padding until address is 32 bit word aligned.
1063                while (((mAddress + 1) & 3) != 0) {
1064                    ++mAddress;
1065                }
1066                Location defaultLocation = getLabel(opcodeAddress + readInt());
1067                int[] cases;
1068                Location[] locations;
1069                
1070                if (opcode == Opcode.TABLESWITCH) {
1071                    int lowValue = readInt();
1072                    int highValue = readInt();
1073                    int caseCount = highValue - lowValue + 1;
1074                    try {
1075                        cases = new int[caseCount];
1076                    }
1077                    catch (NegativeArraySizeException   e) {
1078                        // TODO: raise an error.
1079                        break;
1080                    }
1081                    locations = new Location[caseCount];
1082                    for (int i=0; i<caseCount; i++) {
1083                        cases[i] = lowValue + i;
1084                        locations[i] = getLabel(opcodeAddress + readInt());
1085                    }
1086                }
1087                else {
1088                    int caseCount = readInt();
1089                    try {
1090                        cases = new int[caseCount];
1091                    }
1092                    catch (NegativeArraySizeException   e) {
1093                        // TODO: raise an error.
1094                        break;
1095                    }
1096                    locations = new Location[caseCount];
1097                    for (int i=0; i<caseCount; i++) {
1098                        cases[i] = readInt();
1099                        locations[i] = getLabel(opcodeAddress + readInt());
1100                    }
1101                }
1102
1103                assembler.switchBranch(cases, locations, defaultLocation);
1104                break;
1105
1106            case Opcode.WIDE:
1107                opcode = mByteCodes[++mAddress];
1108                switch (opcode) {
1109
1110                default:
1111                    // TODO: raise an error.
1112                    break;
1113
1114                case Opcode.ILOAD: case Opcode.ISTORE:
1115                case Opcode.LLOAD: case Opcode.LSTORE:
1116                case Opcode.FLOAD: case Opcode.FSTORE:
1117                case Opcode.DLOAD: case Opcode.DSTORE:
1118                case Opcode.ALOAD: case Opcode.ASTORE:
1119
1120                    switch (opcode) {
1121                    case Opcode.ILOAD: case Opcode.ISTORE:
1122                        clazz = int.class;
1123                        break;
1124                    case Opcode.LLOAD: case Opcode.LSTORE:
1125                        clazz = long.class;
1126                        break;
1127                    case Opcode.FLOAD: case Opcode.FSTORE:
1128                        clazz = float.class;
1129                        break;
1130                    case Opcode.DLOAD: case Opcode.DSTORE:
1131                        clazz = double.class;
1132                        break;
1133                    case Opcode.ALOAD: case Opcode.ASTORE:
1134                        clazz = Object  .class;
1135                        break;
1136                    default:
1137                        clazz = null;
1138                        break;
1139                    }
1140                    
1141                    index = readUnsignedShort();
1142
1143                    switch (opcode) {
1144                    case Opcode.ILOAD:
1145                    case Opcode.LLOAD:
1146                    case Opcode.FLOAD:
1147                    case Opcode.DLOAD:
1148                    case Opcode.ALOAD:
1149                        if (index == 0 && mHasThis) {
1150                            assembler.loadThis();
1151                        }
1152                        else {
1153                            assembler.loadLocal
1154                                (getLocalVariable(index, clazz));
1155                        }
1156                        break;
1157                    case Opcode.ISTORE:
1158                    case Opcode.LSTORE:
1159                    case Opcode.FSTORE:
1160                    case Opcode.DSTORE:
1161                    case Opcode.ASTORE:
1162                        if (index == 0 && mHasThis) {
1163                            // The "this" reference just got blown away.
1164                            mHasThis = false;
1165                        }
1166                        assembler.storeLocal(getLocalVariable(index, clazz));
1167                        break;
1168                    }
1169                    break;
1170
1171                case Opcode.RET:
1172                    local = getLocalVariable
1173                        (readUnsignedShort(), Object  .class);
1174                    assembler.ret(local);
1175                    break;
1176                    
1177                case Opcode.IINC:
1178                    local = getLocalVariable(readUnsignedShort(), int.class);
1179                    assembler.integerIncrement(local, readShort());
1180                    break;
1181                }
1182
1183                break;
1184            } // end huge switch
1185        } // end for loop
1186    }
1187
1188    private void gatherLabels() {
1189        mLabels = new HashMap();
1190        mCatchLocations = new HashMap(mExceptionHandlers.length * 2 + 1);
1191        Integer   labelKey;
1192
1193        // Gather labels for any exception handlers.
1194        for (int i = mExceptionHandlers.length - 1; i >= 0; i--) {
1195            ExceptionHandler handler = mExceptionHandlers[i];
1196            labelKey = new Integer  (handler.getStartLocation().getLocation());
1197            mLabels.put(labelKey, labelKey);
1198            labelKey = new Integer  (handler.getEndLocation().getLocation());
1199            mLabels.put(labelKey, labelKey);
1200            labelKey = new Integer  (handler.getCatchLocation().getLocation());
1201            List list = (List)mCatchLocations.get(labelKey);
1202            if (list == null) {
1203                list = new ArrayList(2);
1204                mCatchLocations.put(labelKey, list);
1205            }
1206            list.add(handler);
1207        }
1208
1209        // Now gather labels that occur within byte code.
1210        for (mAddress = 0; mAddress < mByteCodes.length; mAddress++) {
1211            byte opcode = mByteCodes[mAddress];
1212
1213            switch (opcode) {
1214
1215            default:
1216                // TODO: raise an error.
1217                break;
1218
1219                // Opcodes that use labels.
1220
1221            case Opcode.GOTO:
1222            case Opcode.JSR:
1223            case Opcode.IFNULL:
1224            case Opcode.IFNONNULL:
1225            case Opcode.IF_ACMPEQ:
1226            case Opcode.IF_ACMPNE:
1227            case Opcode.IFEQ:
1228            case Opcode.IFNE:
1229            case Opcode.IFLT:
1230            case Opcode.IFGE:
1231            case Opcode.IFGT:
1232            case Opcode.IFLE:
1233            case Opcode.IF_ICMPEQ:
1234            case Opcode.IF_ICMPNE:
1235            case Opcode.IF_ICMPLT:
1236            case Opcode.IF_ICMPGE:
1237            case Opcode.IF_ICMPGT:
1238            case Opcode.IF_ICMPLE:
1239                labelKey = new Integer  (mAddress + readShort());
1240                mLabels.put(labelKey, labelKey);
1241                break;
1242
1243            case Opcode.GOTO_W:
1244            case Opcode.JSR_W:
1245                labelKey = new Integer  (mAddress + readInt());
1246                mLabels.put(labelKey, labelKey);
1247                break;
1248
1249            case Opcode.TABLESWITCH:
1250            case Opcode.LOOKUPSWITCH:
1251                int opcodeAddress = mAddress;
1252                // Read padding until address is 32 bit word aligned.
1253                while (((mAddress + 1) & 3) != 0) {
1254                    ++mAddress;
1255                }
1256                
1257                // Read the default location.
1258                labelKey = new Integer  (opcodeAddress + readInt());
1259                mLabels.put(labelKey, labelKey);
1260                
1261                if (opcode == Opcode.TABLESWITCH) {
1262                    int lowValue = readInt();
1263                    int highValue = readInt();
1264                    int caseCount = highValue - lowValue + 1;
1265
1266                    for (int i=0; i<caseCount; i++) {
1267                        // Read the branch location.
1268                        labelKey = new Integer  (opcodeAddress + readInt());
1269                        mLabels.put(labelKey, labelKey);
1270                    }
1271                }
1272                else {
1273                    int caseCount = readInt();
1274
1275                    for (int i=0; i<caseCount; i++) {
1276                        // Skip the case value.
1277                        mAddress += 4;
1278                        // Read the branch location.
1279                        labelKey = new Integer  (opcodeAddress + readInt());
1280                        mLabels.put(labelKey, labelKey);
1281                    }
1282                }
1283                break;
1284
1285                // All other operations are skipped. The amount to skip
1286                // depends on the operand size.
1287
1288                // Opcodes with no operands...
1289
1290            case Opcode.NOP:
1291            case Opcode.BREAKPOINT:
1292            case Opcode.ACONST_NULL:
1293            case Opcode.ICONST_M1:
1294            case Opcode.ICONST_0:
1295            case Opcode.ICONST_1:
1296            case Opcode.ICONST_2:
1297            case Opcode.ICONST_3:
1298            case Opcode.ICONST_4:
1299            case Opcode.ICONST_5:
1300            case Opcode.LCONST_0:
1301            case Opcode.LCONST_1:
1302            case Opcode.FCONST_0:
1303            case Opcode.FCONST_1:
1304            case Opcode.FCONST_2:
1305            case Opcode.DCONST_0:
1306            case Opcode.DCONST_1:
1307            case Opcode.POP:
1308            case Opcode.POP2:
1309            case Opcode.DUP:
1310            case Opcode.DUP_X1:
1311            case Opcode.DUP_X2:
1312            case Opcode.DUP2:
1313            case Opcode.DUP2_X1:
1314            case Opcode.DUP2_X2:
1315            case Opcode.SWAP:
1316            case Opcode.IADD:  case Opcode.LADD: 
1317            case Opcode.FADD:  case Opcode.DADD:
1318            case Opcode.ISUB:  case Opcode.LSUB:
1319            case Opcode.FSUB:  case Opcode.DSUB:
1320            case Opcode.IMUL:  case Opcode.LMUL:
1321            case Opcode.FMUL:  case Opcode.DMUL:
1322            case Opcode.IDIV:  case Opcode.LDIV:
1323            case Opcode.FDIV:  case Opcode.DDIV:
1324            case Opcode.IREM:  case Opcode.LREM:
1325            case Opcode.FREM:  case Opcode.DREM:
1326            case Opcode.INEG:  case Opcode.LNEG:
1327            case Opcode.FNEG:  case Opcode.DNEG:
1328            case Opcode.ISHL:  case Opcode.LSHL:
1329            case Opcode.ISHR:  case Opcode.LSHR:
1330            case Opcode.IUSHR: case Opcode.LUSHR:
1331            case Opcode.IAND:  case Opcode.LAND:
1332            case Opcode.IOR:   case Opcode.LOR:
1333            case Opcode.IXOR:  case Opcode.LXOR:
1334            case Opcode.FCMPL: case Opcode.DCMPL:
1335            case Opcode.FCMPG: case Opcode.DCMPG:
1336            case Opcode.LCMP: 
1337            case Opcode.I2L:
1338            case Opcode.I2F:
1339            case Opcode.I2D:
1340            case Opcode.L2I:
1341            case Opcode.L2F:
1342            case Opcode.L2D:
1343            case Opcode.F2I:
1344            case Opcode.F2L:
1345            case Opcode.F2D:
1346            case Opcode.D2I:
1347            case Opcode.D2L:
1348            case Opcode.D2F:
1349            case Opcode.I2B:
1350            case Opcode.I2C:
1351            case Opcode.I2S:
1352            case Opcode.IRETURN:
1353            case Opcode.LRETURN:
1354            case Opcode.FRETURN:
1355            case Opcode.DRETURN:
1356            case Opcode.ARETURN:
1357            case Opcode.RETURN:
1358            case Opcode.IALOAD:
1359            case Opcode.LALOAD:
1360            case Opcode.FALOAD:
1361            case Opcode.DALOAD:
1362            case Opcode.AALOAD:
1363            case Opcode.BALOAD:
1364            case Opcode.CALOAD:
1365            case Opcode.SALOAD:
1366            case Opcode.IASTORE:
1367            case Opcode.LASTORE:
1368            case Opcode.FASTORE:
1369            case Opcode.DASTORE:
1370            case Opcode.AASTORE:
1371            case Opcode.BASTORE:
1372            case Opcode.CASTORE:
1373            case Opcode.SASTORE:
1374            case Opcode.ARRAYLENGTH:
1375            case Opcode.ATHROW:
1376            case Opcode.MONITORENTER:
1377            case Opcode.MONITOREXIT:
1378            case Opcode.ILOAD_0: case Opcode.ISTORE_0:
1379            case Opcode.ILOAD_1: case Opcode.ISTORE_1:
1380            case Opcode.ILOAD_2: case Opcode.ISTORE_2:
1381            case Opcode.ILOAD_3: case Opcode.ISTORE_3:
1382            case Opcode.LLOAD_0: case Opcode.LSTORE_0:
1383            case Opcode.LLOAD_1: case Opcode.LSTORE_1:
1384            case Opcode.LLOAD_2: case Opcode.LSTORE_2:
1385            case Opcode.LLOAD_3: case Opcode.LSTORE_3:
1386            case Opcode.FLOAD_0: case Opcode.FSTORE_0:
1387            case Opcode.FLOAD_1: case Opcode.FSTORE_1:
1388            case Opcode.FLOAD_2: case Opcode.FSTORE_2:
1389            case Opcode.FLOAD_3: case Opcode.FSTORE_3:
1390            case Opcode.DLOAD_0: case Opcode.DSTORE_0:
1391            case Opcode.DLOAD_1: case Opcode.DSTORE_1:
1392            case Opcode.DLOAD_2: case Opcode.DSTORE_2:
1393            case Opcode.DLOAD_3: case Opcode.DSTORE_3:
1394            case Opcode.ALOAD_0: case Opcode.ASTORE_0:
1395            case Opcode.ALOAD_1: case Opcode.ASTORE_1:
1396            case Opcode.ALOAD_2: case Opcode.ASTORE_2:
1397            case Opcode.ALOAD_3: case Opcode.ASTORE_3:
1398                break;
1399
1400                // Opcodes with one operand byte...
1401
1402            case Opcode.LDC:
1403            case Opcode.ILOAD: case Opcode.ISTORE:
1404            case Opcode.LLOAD: case Opcode.LSTORE:
1405            case Opcode.FLOAD: case Opcode.FSTORE:
1406            case Opcode.DLOAD: case Opcode.DSTORE:
1407            case Opcode.ALOAD: case Opcode.ASTORE:
1408            case Opcode.RET:
1409            case Opcode.IINC:
1410            case Opcode.BIPUSH:
1411            case Opcode.NEWARRAY:
1412                mAddress += 1;
1413                break;
1414
1415                // Opcodes with two operand bytes...
1416
1417            case Opcode.LDC_W:
1418            case Opcode.LDC2_W:
1419            case Opcode.NEW:
1420            case Opcode.ANEWARRAY:
1421            case Opcode.CHECKCAST:
1422            case Opcode.INSTANCEOF:
1423            case Opcode.GETSTATIC:
1424            case Opcode.PUTSTATIC:
1425            case Opcode.GETFIELD:
1426            case Opcode.PUTFIELD:
1427            case Opcode.INVOKEVIRTUAL:
1428            case Opcode.INVOKESPECIAL:
1429            case Opcode.INVOKESTATIC:
1430            case Opcode.SIPUSH:
1431                mAddress += 2;
1432                break;
1433
1434                // Opcodes with three operand bytes...
1435
1436            case Opcode.MULTIANEWARRAY:
1437                mAddress += 3;
1438                break;
1439
1440                // Opcodes with four operand bytes...
1441
1442            case Opcode.INVOKEINTERFACE:
1443                mAddress += 4;
1444                break;
1445
1446                // Wide opcode has a variable sized operand.
1447
1448            case Opcode.WIDE:
1449                opcode = mByteCodes[++mAddress];
1450                mAddress += 2;
1451                if (opcode == Opcode.IINC) {
1452                    mAddress += 2;
1453                }
1454                break;
1455            } // end huge switch
1456        } // end for loop
1457    }
1458
1459    private int readByte() {
1460        return mByteCodes[++mAddress];
1461    }
1462
1463    private int readUnsignedByte() {
1464        return mByteCodes[++mAddress] & 0xff;
1465    }
1466
1467    private int readShort() {
1468        return (mByteCodes[++mAddress] << 8) | (mByteCodes[++mAddress] & 0xff);
1469    }
1470
1471    private int readUnsignedShort() {
1472        return 
1473            ((mByteCodes[++mAddress] & 0xff) << 8) | 
1474            ((mByteCodes[++mAddress] & 0xff) << 0);
1475    }
1476
1477    private int readInt() {
1478        return
1479            (mByteCodes[++mAddress] << 24) | 
1480            ((mByteCodes[++mAddress] & 0xff) << 16) |
1481            ((mByteCodes[++mAddress] & 0xff) << 8) |
1482            ((mByteCodes[++mAddress] & 0xff) << 0);
1483    }
1484
1485    private LocalVariable getLocalVariable(int index, Class   typeHint) {
1486        TypeDescriptor type = new TypeDescriptor(typeHint);
1487        LocalVariable local;
1488
1489        if (index >= mLocals.size()) {
1490            mLocals.setSize(index + 1);
1491            local = null;
1492        }
1493        else {
1494            local = (LocalVariable)mLocals.elementAt(index);
1495            if (local != null) {
1496                TypeDescriptor localType = local.getType();
1497                Class   typeClass = type.getClassArg();
1498                Class   localTypeClass = localType.getClassArg();
1499
1500                if (typeClass != null && !typeClass.isPrimitive()) {
1501                    typeClass = null;
1502                }
1503
1504                if (localTypeClass != null && !localTypeClass.isPrimitive()) {
1505                    localTypeClass = null;
1506                }
1507
1508                if (typeClass == null) {
1509                    if (localTypeClass == null) {
1510                        // Both types must represent objects. This is ok.
1511                    }
1512                    else {
1513                        // Requesting object type, but existing is primitive.
1514                        local = null;
1515                    }
1516                }
1517                else {
1518                    if (localTypeClass == null) {
1519                        // Requesting primitive type, but existing is object.
1520                        local = null;
1521                    }
1522                    else {
1523                        // Primitive types must exactly match.
1524                        if (typeClass != localTypeClass) {
1525                            local = null;
1526                        }
1527                    }
1528                }
1529            }
1530        }
1531
1532        if (local == null) {
1533            local = mAssembler.createLocalVariable(null, type);
1534            mLocals.setElementAt(local, index);
1535        }
1536
1537        return local;
1538    }
1539
1540    private void locateLabel() {
1541        Integer   labelKey = new Integer  (mAddress);
1542        Object   labelValue = mLabels.get(labelKey);
1543        if (labelValue != null) {
1544            if (labelValue instanceof Label) {
1545                ((Label)labelValue).setLocation();
1546            }
1547            else {
1548                labelValue = mAssembler.createLabel().setLocation();
1549                mLabels.put(labelKey, labelValue);
1550            }
1551        }
1552
1553        List handlers = (List)mCatchLocations.get(labelKey);
1554
1555        if (handlers != null) {
1556            for (int i=0; i<handlers.size(); i++) {
1557                ExceptionHandler handler = (ExceptionHandler)handlers.get(i);
1558                Label start =
1559                    getLabel(handler.getStartLocation().getLocation());
1560                Label end =
1561                    getLabel(handler.getEndLocation().getLocation());
1562                String   catchClassName;
1563                if (handler.getCatchType() == null) {
1564                    catchClassName = null;
1565                }
1566                else {
1567                    catchClassName = handler.getCatchType().getClassName();
1568                }
1569                mAssembler.exceptionHandler(start, end, catchClassName);
1570            }
1571        }
1572    }
1573
1574    private Label getLabel(int address) {
1575        Integer   labelKey = new Integer  (address);
1576        Object   labelValue = mLabels.get(labelKey);
1577        // labelValue will never be null unless gatherLabels is broken.
1578        if (!(labelValue instanceof Label)) {
1579            labelValue = mAssembler.createLabel();
1580            mLabels.put(labelKey, labelValue);
1581        }
1582        return (Label)labelValue;
1583    }
1584}
1585
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags