mirrors
/
javassist
mirror of https://github.com/jboss-javassist/javassist.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 57 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
525 Commits
8 Branches
Tree: 121a67e8df
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '121a67e8df'
${ noResults }
javassist/src/main/javassist/bytecode/analysis/Executor.java

Executor.java 35KB
Raw Blame History

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032 
  1. /*

  2.  * Javassist, a Java-bytecode translator toolkit.

  3.  * Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.

  4.  *

  5.  * The contents of this file are subject to the Mozilla Public License Version

  6.  * 1.1 (the "License"); you may not use this file except in compliance with

  7.  * the License.  Alternatively, the contents of this file may be used under

  8.  * the terms of the GNU Lesser General Public License Version 2.1 or later,

  9.  * or the Apache License Version 2.0.

  10.  *

  11.  * Software distributed under the License is distributed on an "AS IS" basis,

  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

  13.  * for the specific language governing rights and limitations under the

  14.  * License.

  15.  */

  16. package javassist.bytecode.analysis;

  17. 

  18. import javassist.ClassPool;

  19. import javassist.CtClass;

  20. import javassist.NotFoundException;

  21. import javassist.bytecode.BadBytecode;

  22. import javassist.bytecode.CodeIterator;

  23. import javassist.bytecode.ConstPool;

  24. import javassist.bytecode.Descriptor;

  25. import javassist.bytecode.MethodInfo;

  26. import javassist.bytecode.Opcode;

  27. 

  28. /**

  29.  * Executor is responsible for modeling the effects of a JVM instruction on a frame.

  30.  *

  31.  * @author Jason T. Greene

  32.  */

  33. public class Executor implements Opcode {

  34.     private final ConstPool constPool;

  35.     private final ClassPool classPool;

  36.     private final Type STRING_TYPE;

  37.     private final Type CLASS_TYPE;

  38.     private final Type THROWABLE_TYPE;

  39.     private int lastPos;

  40. 

  41.     public Executor(ClassPool classPool, ConstPool constPool) {

  42.         this.constPool = constPool;

  43.         this.classPool = classPool;

  44. 

  45.         try {

  46.             STRING_TYPE = getType("java.lang.String");

  47.             CLASS_TYPE = getType("java.lang.Class");

  48.             THROWABLE_TYPE = getType("java.lang.Throwable");

  49.         } catch (Exception e) {

  50.             throw new RuntimeException(e);

  51.         }

  52.     }

  53. 

  54. 

  55.     /**

  56.      * Execute the instruction, modeling the effects on the specified frame and subroutine.

  57.      * If a subroutine is passed, the access flags will be modified if this instruction accesses

  58.      * the local variable table.

  59.      *

  60.      * @param method the method containing the instruction

  61.      * @param pos the position of the instruction in the method

  62.      * @param iter the code iterator used to find the instruction

  63.      * @param frame the frame to modify to represent the result of the instruction

  64.      * @param subroutine the optional subroutine this instruction belongs to.

  65.      * @throws BadBytecode if the bytecode violates the jvm spec

  66.      */

  67.     public void execute(MethodInfo method, int pos, CodeIterator iter, Frame frame, Subroutine subroutine) throws BadBytecode {

  68.         this.lastPos = pos;

  69.         int opcode = iter.byteAt(pos);

  70. 

  71. 

  72.         // Declared opcode in order

  73.         switch (opcode) {

  74.             case NOP:

  75.                 break;

  76.             case ACONST_NULL:

  77.                 frame.push(Type.UNINIT);

  78.                 break;

  79.             case ICONST_M1:

  80.             case ICONST_0:

  81.             case ICONST_1:

  82.             case ICONST_2:

  83.             case ICONST_3:

  84.             case ICONST_4:

  85.             case ICONST_5:

  86.                 frame.push(Type.INTEGER);

  87.                 break;

  88.             case LCONST_0:

  89.             case LCONST_1:

  90.                 frame.push(Type.LONG);

  91.                 frame.push(Type.TOP);

  92.                 break;

  93.             case FCONST_0:

  94.             case FCONST_1:

  95.             case FCONST_2:

  96.                 frame.push(Type.FLOAT);

  97.                 break;

  98.             case DCONST_0:

  99.             case DCONST_1:

  100.                 frame.push(Type.DOUBLE);

  101.                 frame.push(Type.TOP);

  102.                 break;

  103.             case BIPUSH:

  104.             case SIPUSH:

  105.                 frame.push(Type.INTEGER);

  106.                 break;

  107.             case LDC:

  108.                 evalLDC(iter.byteAt(pos + 1),  frame);

  109.                 break;

  110.             case LDC_W :

  111.             case LDC2_W :

  112.                 evalLDC(iter.u16bitAt(pos + 1), frame);

  113.                 break;

  114.             case ILOAD:

  115.                 evalLoad(Type.INTEGER, iter.byteAt(pos + 1), frame, subroutine);

  116.                 break;

  117.             case LLOAD:

  118.                 evalLoad(Type.LONG, iter.byteAt(pos + 1), frame, subroutine);

  119.                 break;

  120.             case FLOAD:

  121.                 evalLoad(Type.FLOAT, iter.byteAt(pos + 1), frame, subroutine);

  122.                 break;

  123.             case DLOAD:

  124.                 evalLoad(Type.DOUBLE, iter.byteAt(pos + 1), frame, subroutine);

  125.                 break;

  126.             case ALOAD:

  127.                 evalLoad(Type.OBJECT, iter.byteAt(pos + 1), frame, subroutine);

  128.                 break;

  129.             case ILOAD_0:

  130.             case ILOAD_1:

  131.             case ILOAD_2:

  132.             case ILOAD_3:

  133.                 evalLoad(Type.INTEGER, opcode - ILOAD_0, frame, subroutine);

  134.                 break;

  135.             case LLOAD_0:

  136.             case LLOAD_1:

  137.             case LLOAD_2:

  138.             case LLOAD_3:

  139.                 evalLoad(Type.LONG, opcode - LLOAD_0, frame, subroutine);

  140.                 break;

  141.             case FLOAD_0:

  142.             case FLOAD_1:

  143.             case FLOAD_2:

  144.             case FLOAD_3:

  145.                 evalLoad(Type.FLOAT, opcode - FLOAD_0, frame, subroutine);

  146.                 break;

  147.             case DLOAD_0:

  148.             case DLOAD_1:

  149.             case DLOAD_2:

  150.             case DLOAD_3:

  151.                 evalLoad(Type.DOUBLE, opcode - DLOAD_0, frame, subroutine);

  152.                 break;

  153.             case ALOAD_0:

  154.             case ALOAD_1:

  155.             case ALOAD_2:

  156.             case ALOAD_3:

  157.                 evalLoad(Type.OBJECT, opcode - ALOAD_0, frame, subroutine);

  158.                 break;

  159.             case IALOAD:

  160.                 evalArrayLoad(Type.INTEGER, frame);

  161.                 break;

  162.             case LALOAD:

  163.                 evalArrayLoad(Type.LONG, frame);

  164.                 break;

  165.             case FALOAD:

  166.                 evalArrayLoad(Type.FLOAT, frame);

  167.                 break;

  168.             case DALOAD:

  169.                 evalArrayLoad(Type.DOUBLE, frame);

  170.                 break;

  171.             case AALOAD:

  172.                 evalArrayLoad(Type.OBJECT, frame);

  173.                 break;

  174.             case BALOAD:

  175.             case CALOAD:

  176.             case SALOAD:

  177.                 evalArrayLoad(Type.INTEGER, frame);

  178.                 break;

  179.             case ISTORE:

  180.                 evalStore(Type.INTEGER, iter.byteAt(pos + 1), frame, subroutine);

  181.                 break;

  182.             case LSTORE:

  183.                 evalStore(Type.LONG, iter.byteAt(pos + 1), frame, subroutine);

  184.                 break;

  185.             case FSTORE:

  186.                 evalStore(Type.FLOAT, iter.byteAt(pos + 1), frame, subroutine);

  187.                 break;

  188.             case DSTORE:

  189.                 evalStore(Type.DOUBLE, iter.byteAt(pos + 1), frame, subroutine);

  190.                 break;

  191.             case ASTORE:

  192.                 evalStore(Type.OBJECT, iter.byteAt(pos + 1), frame, subroutine);

  193.                 break;

  194.             case ISTORE_0:

  195.             case ISTORE_1:

  196.             case ISTORE_2:

  197.             case ISTORE_3:

  198.                 evalStore(Type.INTEGER, opcode - ISTORE_0, frame, subroutine);

  199.                 break;

  200.             case LSTORE_0:

  201.             case LSTORE_1:

  202.             case LSTORE_2:

  203.             case LSTORE_3:

  204.                 evalStore(Type.LONG, opcode - LSTORE_0, frame, subroutine);

  205.                 break;

  206.             case FSTORE_0:

  207.             case FSTORE_1:

  208.             case FSTORE_2:

  209.             case FSTORE_3:

  210.                 evalStore(Type.FLOAT, opcode - FSTORE_0, frame, subroutine);

  211.                 break;

  212.             case DSTORE_0:

  213.             case DSTORE_1:

  214.             case DSTORE_2:

  215.             case DSTORE_3:

  216.                 evalStore(Type.DOUBLE, opcode - DSTORE_0, frame, subroutine);

  217.                 break;

  218.             case ASTORE_0:

  219.             case ASTORE_1:

  220.             case ASTORE_2:

  221.             case ASTORE_3:

  222.                 evalStore(Type.OBJECT, opcode - ASTORE_0, frame, subroutine);

  223.                 break;

  224.             case IASTORE:

  225.                 evalArrayStore(Type.INTEGER, frame);

  226.                 break;

  227.             case LASTORE:

  228.                 evalArrayStore(Type.LONG, frame);

  229.                 break;

  230.             case FASTORE:

  231.                 evalArrayStore(Type.FLOAT, frame);

  232.                 break;

  233.             case DASTORE:

  234.                 evalArrayStore(Type.DOUBLE, frame);

  235.                 break;

  236.             case AASTORE:

  237.                 evalArrayStore(Type.OBJECT, frame);

  238.                 break;

  239.             case BASTORE:

  240.             case CASTORE:

  241.             case SASTORE:

  242.                 evalArrayStore(Type.INTEGER, frame);

  243.                 break;

  244.             case POP:

  245.                 if (frame.pop() == Type.TOP)

  246.                     throw new BadBytecode("POP can not be used with a category 2 value, pos = " + pos);

  247.                 break;

  248.             case POP2:

  249.                 frame.pop();

  250.                 frame.pop();

  251.                 break;

  252.             case DUP: {

  253.                 Type type = frame.peek();

  254.                 if (type == Type.TOP)

  255.                     throw new BadBytecode("DUP can not be used with a category 2 value, pos = " + pos);

  256. 

  257.                 frame.push(frame.peek());

  258.                 break;

  259.             }

  260.             case DUP_X1:

  261.             case DUP_X2: {

  262.                 Type type = frame.peek();

  263.                 if (type == Type.TOP)

  264.                     throw new BadBytecode("DUP can not be used with a category 2 value, pos = " + pos);

  265.                 int end = frame.getTopIndex();

  266.                 int insert = end - (opcode - DUP_X1) - 1;

  267.                 frame.push(type);

  268. 

  269.                 while (end > insert) {

  270.                     frame.setStack(end, frame.getStack(end - 1));

  271.                     end--;

  272.                 }

  273.                 frame.setStack(insert, type);

  274.                 break;

  275.             }

  276.             case DUP2:

  277.                 frame.push(frame.getStack(frame.getTopIndex() - 1));

  278.                 frame.push(frame.getStack(frame.getTopIndex() - 1));

  279.                 break;

  280.             case DUP2_X1:

  281.             case DUP2_X2: {

  282.                 int end = frame.getTopIndex();

  283.                 int insert = end - (opcode - DUP2_X1) - 1;

  284.                 Type type1 = frame.getStack(frame.getTopIndex() - 1);

  285.                 Type type2 = frame.peek();

  286.                 frame.push(type1);

  287.                 frame.push(type2);

  288.                 while (end > insert) {

  289.                     frame.setStack(end, frame.getStack(end - 2));

  290.                     end--;

  291.                 }

  292.                 frame.setStack(insert, type2);

  293.                 frame.setStack(insert - 1, type1);

  294.                 break;

  295.             }

  296.             case SWAP: {

  297.                 Type type1 = frame.pop();

  298.                 Type type2 = frame.pop();

  299.                 if (type1.getSize() == 2 || type2.getSize() == 2)

  300.                     throw new BadBytecode("Swap can not be used with category 2 values, pos = " + pos);

  301.                 frame.push(type1);

  302.                 frame.push(type2);

  303.                 break;

  304.             }

  305. 

  306.             // Math

  307.             case IADD:

  308.                 evalBinaryMath(Type.INTEGER, frame);

  309.                 break;

  310.             case LADD:

  311.                 evalBinaryMath(Type.LONG, frame);

  312.                 break;

  313.             case FADD:

  314.                 evalBinaryMath(Type.FLOAT, frame);

  315.                 break;

  316.             case DADD:

  317.                 evalBinaryMath(Type.DOUBLE, frame);

  318.                 break;

  319.             case ISUB:

  320.                 evalBinaryMath(Type.INTEGER, frame);

  321.                 break;

  322.             case LSUB:

  323.                 evalBinaryMath(Type.LONG, frame);

  324.                 break;

  325.             case FSUB:

  326.                 evalBinaryMath(Type.FLOAT, frame);

  327.                 break;

  328.             case DSUB:

  329.                 evalBinaryMath(Type.DOUBLE, frame);

  330.                 break;

  331.             case IMUL:

  332.                 evalBinaryMath(Type.INTEGER, frame);

  333.                 break;

  334.             case LMUL:

  335.                 evalBinaryMath(Type.LONG, frame);

  336.                 break;

  337.             case FMUL:

  338.                 evalBinaryMath(Type.FLOAT, frame);

  339.                 break;

  340.             case DMUL:

  341.                 evalBinaryMath(Type.DOUBLE, frame);

  342.                 break;

  343.             case IDIV:

  344.                 evalBinaryMath(Type.INTEGER, frame);

  345.                 break;

  346.             case LDIV:

  347.                 evalBinaryMath(Type.LONG, frame);

  348.                 break;

  349.             case FDIV:

  350.                 evalBinaryMath(Type.FLOAT, frame);

  351.                 break;

  352.             case DDIV:

  353.                 evalBinaryMath(Type.DOUBLE, frame);

  354.                 break;

  355.             case IREM:

  356.                 evalBinaryMath(Type.INTEGER, frame);

  357.                 break;

  358.             case LREM:

  359.                 evalBinaryMath(Type.LONG, frame);

  360.                 break;

  361.             case FREM:

  362.                 evalBinaryMath(Type.FLOAT, frame);

  363.                 break;

  364.             case DREM:

  365.                 evalBinaryMath(Type.DOUBLE, frame);

  366.                 break;

  367. 

  368.             // Unary

  369.             case INEG:

  370.                 verifyAssignable(Type.INTEGER, simplePeek(frame));

  371.                 break;

  372.             case LNEG:

  373.                 verifyAssignable(Type.LONG, simplePeek(frame));

  374.                 break;

  375.             case FNEG:

  376.                 verifyAssignable(Type.FLOAT, simplePeek(frame));

  377.                 break;

  378.             case DNEG:

  379.                 verifyAssignable(Type.DOUBLE, simplePeek(frame));

  380.                 break;

  381. 

  382.             // Shifts

  383.             case ISHL:

  384.                 evalShift(Type.INTEGER, frame);

  385.                 break;

  386.             case LSHL:

  387.                 evalShift(Type.LONG, frame);

  388.                 break;

  389.             case ISHR:

  390.                 evalShift(Type.INTEGER, frame);

  391.                 break;

  392.             case LSHR:

  393.                 evalShift(Type.LONG, frame);

  394.                 break;

  395.             case IUSHR:

  396.                 evalShift(Type.INTEGER,frame);

  397.                 break;

  398.             case LUSHR:

  399.                 evalShift(Type.LONG, frame);

  400.                 break;

  401. 

  402.             // Bitwise Math

  403.             case IAND:

  404.                 evalBinaryMath(Type.INTEGER, frame);

  405.                 break;

  406.             case LAND:

  407.                 evalBinaryMath(Type.LONG, frame);

  408.                 break;

  409.             case IOR:

  410.                 evalBinaryMath(Type.INTEGER, frame);

  411.                 break;

  412.             case LOR:

  413.                 evalBinaryMath(Type.LONG, frame);

  414.                 break;

  415.             case IXOR:

  416.                 evalBinaryMath(Type.INTEGER, frame);

  417.                 break;

  418.             case LXOR:

  419.                 evalBinaryMath(Type.LONG, frame);

  420.                 break;

  421. 

  422.             case IINC: {

  423.                 int index = iter.byteAt(pos + 1);

  424.                 verifyAssignable(Type.INTEGER, frame.getLocal(index));

  425.                 access(index, Type.INTEGER, subroutine);

  426.                 break;

  427.             }

  428. 

  429.             // Conversion

  430.             case I2L:

  431.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  432.                 simplePush(Type.LONG, frame);

  433.                 break;

  434.             case I2F:

  435.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  436.                 simplePush(Type.FLOAT, frame);

  437.                 break;

  438.             case I2D:

  439.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  440.                 simplePush(Type.DOUBLE, frame);

  441.                 break;

  442.             case L2I:

  443.                 verifyAssignable(Type.LONG, simplePop(frame));

  444.                 simplePush(Type.INTEGER, frame);

  445.                 break;

  446.             case L2F:

  447.                 verifyAssignable(Type.LONG, simplePop(frame));

  448.                 simplePush(Type.FLOAT, frame);

  449.                 break;

  450.             case L2D:

  451.                 verifyAssignable(Type.LONG, simplePop(frame));

  452.                 simplePush(Type.DOUBLE, frame);

  453.                 break;

  454.             case F2I:

  455.                 verifyAssignable(Type.FLOAT, simplePop(frame));

  456.                 simplePush(Type.INTEGER, frame);

  457.                 break;

  458.             case F2L:

  459.                 verifyAssignable(Type.FLOAT, simplePop(frame));

  460.                 simplePush(Type.LONG, frame);

  461.                 break;

  462.             case F2D:

  463.                 verifyAssignable(Type.FLOAT, simplePop(frame));

  464.                 simplePush(Type.DOUBLE, frame);

  465.                 break;

  466.             case D2I:

  467.                 verifyAssignable(Type.DOUBLE, simplePop(frame));

  468.                 simplePush(Type.INTEGER, frame);

  469.                 break;

  470.             case D2L:

  471.                 verifyAssignable(Type.DOUBLE, simplePop(frame));

  472.                 simplePush(Type.LONG, frame);

  473.                 break;

  474.             case D2F:

  475.                 verifyAssignable(Type.DOUBLE, simplePop(frame));

  476.                 simplePush(Type.FLOAT, frame);

  477.                 break;

  478.             case I2B:

  479.             case I2C:

  480.             case I2S:

  481.                 verifyAssignable(Type.INTEGER, frame.peek());

  482.                 break;

  483.             case LCMP:

  484.                 verifyAssignable(Type.LONG, simplePop(frame));

  485.                 verifyAssignable(Type.LONG, simplePop(frame));

  486.                 frame.push(Type.INTEGER);

  487.                 break;

  488.             case FCMPL:

  489.             case FCMPG:

  490.                 verifyAssignable(Type.FLOAT, simplePop(frame));

  491.                 verifyAssignable(Type.FLOAT, simplePop(frame));

  492.                 frame.push(Type.INTEGER);

  493.                 break;

  494.             case DCMPL:

  495.             case DCMPG:

  496.                 verifyAssignable(Type.DOUBLE, simplePop(frame));

  497.                 verifyAssignable(Type.DOUBLE, simplePop(frame));

  498.                 frame.push(Type.INTEGER);

  499.                 break;

  500. 

  501.             // Control flow

  502.             case IFEQ:

  503.             case IFNE:

  504.             case IFLT:

  505.             case IFGE:

  506.             case IFGT:

  507.             case IFLE:

  508.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  509.                 break;

  510.             case IF_ICMPEQ:

  511.             case IF_ICMPNE:

  512.             case IF_ICMPLT:

  513.             case IF_ICMPGE:

  514.             case IF_ICMPGT:

  515.             case IF_ICMPLE:

  516.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  517.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  518.                 break;

  519.             case IF_ACMPEQ:

  520.             case IF_ACMPNE:

  521.                 verifyAssignable(Type.OBJECT, simplePop(frame));

  522.                 verifyAssignable(Type.OBJECT, simplePop(frame));

  523.                 break;

  524.             case GOTO:

  525.                 break;

  526.             case JSR:

  527.                 frame.push(Type.RETURN_ADDRESS);

  528.                 break;

  529.             case RET:

  530.                 verifyAssignable(Type.RETURN_ADDRESS, frame.getLocal(iter.byteAt(pos + 1)));

  531.                 break;

  532.             case TABLESWITCH:

  533.             case LOOKUPSWITCH:

  534.             case IRETURN:

  535.                 verifyAssignable(Type.INTEGER, simplePop(frame));

  536.                 break;

  537.             case LRETURN:

  538.                 verifyAssignable(Type.LONG, simplePop(frame));

  539.                 break;

  540.             case FRETURN:

  541.                 verifyAssignable(Type.FLOAT, simplePop(frame));

  542.                 break;

  543.             case DRETURN:

  544.                 verifyAssignable(Type.DOUBLE, simplePop(frame));

  545.                 break;

  546.             case ARETURN:

  547.                 try {

  548.                     CtClass returnType = Descriptor.getReturnType(method.getDescriptor(), classPool);

  549.                     verifyAssignable(Type.get(returnType), simplePop(frame));

  550.                 } catch (NotFoundException e) {

  551.                    throw new RuntimeException(e);

  552.                 }

  553.                 break;

  554.             case RETURN:

  555.                 break;

  556.             case GETSTATIC:

  557.                 evalGetField(opcode, iter.u16bitAt(pos + 1), frame);

  558.                 break;

  559.             case PUTSTATIC:

  560.                 evalPutField(opcode, iter.u16bitAt(pos + 1), frame);

  561.                 break;

  562.             case GETFIELD:

  563.                 evalGetField(opcode, iter.u16bitAt(pos + 1), frame);

  564.                 break;

  565.             case PUTFIELD:

  566.                 evalPutField(opcode, iter.u16bitAt(pos + 1), frame);

  567.                 break;

  568.             case INVOKEVIRTUAL:

  569.             case INVOKESPECIAL:

  570.             case INVOKESTATIC:

  571.                 evalInvokeMethod(opcode, iter.u16bitAt(pos + 1), frame);

  572.                 break;

  573.             case INVOKEINTERFACE:

  574.                 evalInvokeIntfMethod(opcode, iter.u16bitAt(pos + 1), frame);

  575.                 break;

  576.             case 186:

  577.                 throw new RuntimeException("Bad opcode 186");

  578.             case NEW:

  579.                 frame.push(resolveClassInfo(constPool.getClassInfo(iter.u16bitAt(pos + 1))));

  580.                 break;

  581.             case NEWARRAY:

  582.                 evalNewArray(pos, iter, frame);

  583.                 break;

  584.             case ANEWARRAY:

  585.                 evalNewObjectArray(pos, iter, frame);

  586.                 break;

  587.             case ARRAYLENGTH: {

  588.                 Type array = simplePop(frame);

  589.                 if (! array.isArray() && array != Type.UNINIT)

  590.                     throw new BadBytecode("Array length passed a non-array [pos = " + pos + "]: " + array);

  591.                 frame.push(Type.INTEGER);

  592.                 break;

  593.             }

  594.             case ATHROW:

  595.                 verifyAssignable(THROWABLE_TYPE, simplePop(frame));

  596.                 break;

  597.             case CHECKCAST:

  598.                 verifyAssignable(Type.OBJECT, simplePop(frame));

  599.                 frame.push(typeFromDesc(constPool.getClassInfo(iter.u16bitAt(pos + 1))));

  600.                 break;

  601.             case INSTANCEOF:

  602.                 verifyAssignable(Type.OBJECT, simplePop(frame));

  603.                 frame.push(Type.INTEGER);

  604.                 break;

  605.             case MONITORENTER:

  606.             case MONITOREXIT:

  607.                 verifyAssignable(Type.OBJECT, simplePop(frame));

  608.                 break;

  609.             case WIDE:

  610.                 evalWide(pos, iter, frame, subroutine);

  611.                 break;

  612.             case MULTIANEWARRAY:

  613.                 evalNewObjectArray(pos, iter, frame);

  614.                 break;

  615.             case IFNULL:

  616.             case IFNONNULL:

  617.                 verifyAssignable(Type.OBJECT, simplePop(frame));

  618.                 break;

  619.             case GOTO_W:

  620.                 break;

  621.             case JSR_W:

  622.                 frame.push(Type.RETURN_ADDRESS);

  623.                 break;

  624.         }

  625.     }

  626. 

  627.     private Type zeroExtend(Type type) {

  628.         if (type == Type.SHORT || type == Type.BYTE || type == Type.CHAR || type == Type.BOOLEAN)

  629.             return  Type.INTEGER;

  630. 

  631.         return type;

  632.     }

  633. 

  634.     private void evalArrayLoad(Type expectedComponent, Frame frame) throws BadBytecode {

  635.         Type index = frame.pop();

  636.         Type array = frame.pop();

  637. 

  638.         // Special case, an array defined by aconst_null

  639.         // TODO - we might need to be more inteligent about this

  640.         if (array == Type.UNINIT) {

  641.             verifyAssignable(Type.INTEGER, index);

  642.             if (expectedComponent == Type.OBJECT) {

  643.                 simplePush(Type.UNINIT, frame);

  644.             } else {

  645.                 simplePush(expectedComponent, frame);

  646.             }

  647.             return;

  648.         }

  649. 

  650.         Type component = array.getComponent();

  651. 

  652.         if (component == null)

  653.             throw new BadBytecode("Not an array! [pos = " + lastPos + "]: " + component);

  654. 

  655.         component = zeroExtend(component);

  656. 

  657.         verifyAssignable(expectedComponent, component);

  658.         verifyAssignable(Type.INTEGER, index);

  659.         simplePush(component, frame);

  660.     }

  661. 

  662.     private void evalArrayStore(Type expectedComponent, Frame frame) throws BadBytecode {

  663.         Type value = simplePop(frame);

  664.         Type index = frame.pop();

  665.         Type array = frame.pop();

  666. 

  667.         if (array == Type.UNINIT) {

  668.             verifyAssignable(Type.INTEGER, index);

  669.             return;

  670.         }

  671. 

  672.         Type component = array.getComponent();

  673. 

  674.         if (component == null)

  675.             throw new BadBytecode("Not an array! [pos = " + lastPos + "]: " + component);

  676. 

  677.         component = zeroExtend(component);

  678. 

  679.         verifyAssignable(expectedComponent, component);

  680.         verifyAssignable(Type.INTEGER, index);

  681. 

  682.         // This intentionally only checks for Object on aastore

  683.         // downconverting of an array (no casts)

  684.         // e.g. Object[] blah = new String[];

  685.         //      blah[2] = (Object) "test";

  686.         //      blah[3] = new Integer(); // compiler doesnt catch it (has legal bytecode),

  687.         //                               // but will throw arraystoreexception

  688.         if (expectedComponent == Type.OBJECT) {

  689.             verifyAssignable(expectedComponent, value);

  690.         } else {

  691.             verifyAssignable(component, value);

  692.         }

  693.     }

  694. 

  695.     private void evalBinaryMath(Type expected, Frame frame) throws BadBytecode {

  696.         Type value2 = simplePop(frame);

  697.         Type value1 = simplePop(frame);

  698. 

  699.         verifyAssignable(expected, value2);

  700.         verifyAssignable(expected, value1);

  701.         simplePush(value1, frame);

  702.     }

  703. 

  704.     private void evalGetField(int opcode, int index, Frame frame) throws BadBytecode {

  705.         String desc = constPool.getFieldrefType(index);

  706.         Type type = zeroExtend(typeFromDesc(desc));

  707. 

  708.         if (opcode == GETFIELD) {

  709.             Type objectType = resolveClassInfo(constPool.getFieldrefClassName(index));

  710.             verifyAssignable(objectType, simplePop(frame));

  711.         }

  712. 

  713.         simplePush(type, frame);

  714.     }

  715. 

  716.     private void evalInvokeIntfMethod(int opcode, int index, Frame frame) throws BadBytecode {

  717.         String desc = constPool.getInterfaceMethodrefType(index);

  718.         Type[] types = paramTypesFromDesc(desc);

  719.         int i = types.length;

  720. 

  721.         while (i > 0)

  722.             verifyAssignable(zeroExtend(types[--i]), simplePop(frame));

  723. 

  724.         String classInfo = constPool.getInterfaceMethodrefClassName(index);

  725.         Type objectType = resolveClassInfo(classInfo);

  726.         verifyAssignable(objectType, simplePop(frame));

  727. 

  728.         Type returnType = returnTypeFromDesc(desc);

  729.         if (returnType != Type.VOID)

  730.             simplePush(zeroExtend(returnType), frame);

  731.     }

  732. 

  733.     private void evalInvokeMethod(int opcode, int index, Frame frame) throws BadBytecode {

  734.         String desc = constPool.getMethodrefType(index);

  735.         Type[] types = paramTypesFromDesc(desc);

  736.         int i = types.length;

  737. 

  738.         while (i > 0)

  739.             verifyAssignable(zeroExtend(types[--i]), simplePop(frame));

  740. 

  741.         if (opcode != INVOKESTATIC) {

  742.             Type objectType = resolveClassInfo(constPool.getMethodrefClassName(index));

  743.             verifyAssignable(objectType, simplePop(frame));

  744.         }

  745. 

  746.         Type returnType = returnTypeFromDesc(desc);

  747.         if (returnType != Type.VOID)

  748.             simplePush(zeroExtend(returnType), frame);

  749.     }

  750. 

  751. 

  752.     private void evalLDC(int index, Frame frame) throws BadBytecode {

  753.         int tag = constPool.getTag(index);

  754.         Type type;

  755.         switch (tag) {

  756.         case ConstPool.CONST_String:

  757.             type = STRING_TYPE;

  758.             break;

  759.         case ConstPool.CONST_Integer:

  760.             type = Type.INTEGER;

  761.             break;

  762.         case ConstPool.CONST_Float:

  763.             type = Type.FLOAT;

  764.             break;

  765.         case ConstPool.CONST_Long:

  766.             type = Type.LONG;

  767.             break;

  768.         case ConstPool.CONST_Double:

  769.             type = Type.DOUBLE;

  770.             break;

  771.         case ConstPool.CONST_Class:

  772.             type = CLASS_TYPE;

  773.             break;

  774.         default:

  775.             throw new BadBytecode("bad LDC [pos = " + lastPos + "]: " + tag);

  776.         }

  777. 

  778.         simplePush(type, frame);

  779.     }

  780. 

  781.     private void evalLoad(Type expected, int index, Frame frame, Subroutine subroutine) throws BadBytecode {

  782.         Type type = frame.getLocal(index);

  783. 

  784.         verifyAssignable(expected, type);

  785. 

  786.         simplePush(type, frame);

  787.         access(index, type, subroutine);

  788.     }

  789. 

  790.     private void evalNewArray(int pos, CodeIterator iter, Frame frame) throws BadBytecode {

  791.         verifyAssignable(Type.INTEGER, simplePop(frame));

  792.         Type type = null;

  793.         int typeInfo = iter.byteAt(pos + 1);

  794.         switch (typeInfo) {

  795.             case T_BOOLEAN:

  796.                 type = getType("boolean[]");

  797.                 break;

  798.             case T_CHAR:

  799.                 type = getType("char[]");

  800.                 break;

  801.             case T_BYTE:

  802.                 type = getType("byte[]");

  803.                 break;

  804.             case T_SHORT:

  805.                 type = getType("short[]");

  806.                 break;

  807.             case T_INT:

  808.                 type = getType("int[]");

  809.                 break;

  810.             case T_LONG:

  811.                 type = getType("long[]");

  812.                 break;

  813.             case T_FLOAT:

  814.                 type = getType("float[]");

  815.                 break;

  816.             case T_DOUBLE:

  817.                 type = getType("double[]");

  818.                 break;

  819.             default:

  820.                 throw new BadBytecode("Invalid array type [pos = " + pos + "]: " + typeInfo);

  821. 

  822.         }

  823. 

  824.         frame.push(type);

  825.     }

  826. 

  827.     private void evalNewObjectArray(int pos, CodeIterator iter, Frame frame) throws BadBytecode {

  828.         // Convert to x[] format

  829.         Type type = resolveClassInfo(constPool.getClassInfo(iter.u16bitAt(pos + 1)));

  830.         String name = type.getCtClass().getName();

  831.         int opcode = iter.byteAt(pos);

  832.         int dimensions;

  833. 

  834.         if (opcode == MULTIANEWARRAY) {

  835.             dimensions = iter.byteAt(pos + 3);

  836.         } else {

  837.             name = name + "[]";

  838.             dimensions = 1;

  839.         }

  840. 

  841.         while (dimensions-- > 0) {

  842.             verifyAssignable(Type.INTEGER, simplePop(frame));

  843.         }

  844. 

  845.         simplePush(getType(name), frame);

  846.     }

  847. 

  848.     private void evalPutField(int opcode, int index, Frame frame) throws BadBytecode {

  849.         String desc = constPool.getFieldrefType(index);

  850.         Type type = zeroExtend(typeFromDesc(desc));

  851. 

  852.         verifyAssignable(type, simplePop(frame));

  853. 

  854.         if (opcode == PUTFIELD) {

  855.             Type objectType = resolveClassInfo(constPool.getFieldrefClassName(index));

  856.             verifyAssignable(objectType, simplePop(frame));

  857.         }

  858.     }

  859. 

  860.     private void evalShift(Type expected, Frame frame) throws BadBytecode {

  861.         Type value2 = simplePop(frame);

  862.         Type value1 = simplePop(frame);

  863. 

  864.         verifyAssignable(Type.INTEGER, value2);

  865.         verifyAssignable(expected, value1);

  866.         simplePush(value1, frame);

  867.     }

  868. 

  869.     private void evalStore(Type expected, int index, Frame frame, Subroutine subroutine) throws BadBytecode {

  870.         Type type = simplePop(frame);

  871. 

  872.         // RETURN_ADDRESS is allowed by ASTORE

  873.         if (! (expected == Type.OBJECT && type == Type.RETURN_ADDRESS))

  874.             verifyAssignable(expected, type);

  875.         simpleSetLocal(index, type, frame);

  876.         access(index, type, subroutine);

  877.     }

  878. 

  879.     private void evalWide(int pos, CodeIterator iter, Frame frame, Subroutine subroutine) throws BadBytecode {

  880.         int opcode = iter.byteAt(pos + 1);

  881.         int index = iter.u16bitAt(pos + 2);

  882.         switch (opcode) {

  883.             case ILOAD:

  884.                 evalLoad(Type.INTEGER, index, frame, subroutine);

  885.                 break;

  886.             case LLOAD:

  887.                 evalLoad(Type.LONG, index, frame, subroutine);

  888.                 break;

  889.             case FLOAD:

  890.                 evalLoad(Type.FLOAT, index, frame, subroutine);

  891.                 break;

  892.             case DLOAD:

  893.                 evalLoad(Type.DOUBLE, index, frame, subroutine);

  894.                 break;

  895.             case ALOAD:

  896.                 evalLoad(Type.OBJECT, index, frame, subroutine);

  897.                 break;

  898.             case ISTORE:

  899.                 evalStore(Type.INTEGER, index, frame, subroutine);

  900.                 break;

  901.             case LSTORE:

  902.                 evalStore(Type.LONG, index, frame, subroutine);

  903.                 break;

  904.             case FSTORE:

  905.                 evalStore(Type.FLOAT, index, frame, subroutine);

  906.                 break;

  907.             case DSTORE:

  908.                 evalStore(Type.DOUBLE, index, frame, subroutine);

  909.                 break;

  910.             case ASTORE:

  911.                 evalStore(Type.OBJECT, index, frame, subroutine);

  912.                 break;

  913.             case IINC:

  914.                 verifyAssignable(Type.INTEGER, frame.getLocal(index));

  915.                 break;

  916.             case RET:

  917.                 verifyAssignable(Type.RETURN_ADDRESS, frame.getLocal(index));

  918.                 break;

  919.             default:

  920.                 throw new BadBytecode("Invalid WIDE operand [pos = " + pos + "]: " + opcode);

  921.         }

  922. 

  923.     }

  924. 

  925.     private Type getType(String name) throws BadBytecode {

  926.         try {

  927.             return Type.get(classPool.get(name));

  928.         } catch (NotFoundException e) {

  929.             throw new BadBytecode("Could not find class [pos = " + lastPos + "]: " + name);

  930.         }

  931.     }

  932. 

  933.     private Type[] paramTypesFromDesc(String desc) throws BadBytecode {

  934.         CtClass classes[] = null;

  935.         try {

  936.             classes = Descriptor.getParameterTypes(desc, classPool);

  937.         } catch (NotFoundException e) {

  938.             throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());

  939.         }

  940. 

  941.         if (classes == null)

  942.             throw new BadBytecode("Could not obtain parameters for descriptor [pos = " + lastPos + "]: " + desc);

  943. 

  944.         Type[] types = new Type[classes.length];

  945.         for (int i = 0; i < types.length; i++)

  946.             types[i] = Type.get(classes[i]);

  947. 

  948.         return types;

  949.     }

  950. 

  951.     private Type returnTypeFromDesc(String desc) throws BadBytecode {

  952.         CtClass clazz = null;

  953.         try {

  954.             clazz = Descriptor.getReturnType(desc, classPool);

  955.         } catch (NotFoundException e) {

  956.             throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());

  957.         }

  958. 

  959.         if (clazz == null)

  960.             throw new BadBytecode("Could not obtain return type for descriptor [pos = " + lastPos + "]: " + desc);

  961. 

  962.         return Type.get(clazz);

  963.     }

  964. 

  965.     private Type simplePeek(Frame frame) {

  966.         Type type = frame.peek();

  967.         return (type == Type.TOP) ? frame.getStack(frame.getTopIndex() - 1) : type;

  968.     }

  969. 

  970.     private Type simplePop(Frame frame) {

  971.         Type type = frame.pop();

  972.         return (type == Type.TOP) ? frame.pop() : type;

  973.     }

  974. 

  975.     private void simplePush(Type type, Frame frame) {

  976.         frame.push(type);

  977.         if (type.getSize() == 2)

  978.             frame.push(Type.TOP);

  979.     }

  980. 

  981.     private void access(int index, Type type, Subroutine subroutine) {

  982.         if (subroutine == null)

  983.             return;

  984.         subroutine.access(index);

  985.         if (type.getSize() == 2)

  986.             subroutine.access(index + 1);

  987.     }

  988. 

  989.     private void simpleSetLocal(int index, Type type, Frame frame) {

  990.         frame.setLocal(index, type);

  991.         if (type.getSize() == 2)

  992.             frame.setLocal(index + 1, Type.TOP);

  993.     }

  994. 

  995.     private Type resolveClassInfo(String info) throws BadBytecode {

  996.         CtClass clazz = null;

  997.         try {

  998.             if (info.charAt(0) == '[') {

  999.                 clazz = Descriptor.toCtClass(info, classPool);

  1000.             } else {

  1001.                 clazz = classPool.get(info);

  1002.             }

  1003. 

  1004.         } catch (NotFoundException e) {

  1005.             throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());

  1006.         }

  1007. 

  1008.         if (clazz == null)

  1009.             throw new BadBytecode("Could not obtain type for descriptor [pos = " + lastPos + "]: " + info);

  1010. 

  1011.         return Type.get(clazz);

  1012.     }

  1013. 

  1014.     private Type typeFromDesc(String desc) throws BadBytecode {

  1015.         CtClass clazz = null;

  1016.         try {

  1017.             clazz = Descriptor.toCtClass(desc, classPool);

  1018.         } catch (NotFoundException e) {

  1019.             throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());

  1020.         }

  1021. 

  1022.         if (clazz == null)

  1023.             throw new BadBytecode("Could not obtain type for descriptor [pos = " + lastPos + "]: " + desc);

  1024. 

  1025.         return Type.get(clazz);

  1026.     }

  1027. 

  1028.     private void verifyAssignable(Type expected, Type type) throws BadBytecode {

  1029.         if (! expected.isAssignableFrom(type))

  1030.             throw new BadBytecode("Expected type: " + expected + " Got: " + type + " [pos = " + lastPos + "]");

  1031.     }

  1032. }