mirrors
/
javassist
kopia lustrzana https://github.com/jboss-javassist/javassist.git
Obserwuj 1
Gwiazdka 0
Forkuj 0
Kod Problemy 0 Wydania 57 Wiki Aktywność
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.
402 Commity
8 Gałęzie
Drzewo: 6b4fd8d02d
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '6b4fd8d02d'
${ noResults }
javassist/src/main/javassist/bytecode/analysis/Executor.java

Executor.java 35KB
Czysty Blame Historia

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031 
  1. /*

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

  3.  * Copyright (C) 1999-2007 Shigeru Chiba, and others. 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.  *

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

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

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

  13.  * License.

  14.  */

  15. package javassist.bytecode.analysis;

  16. 

  17. import javassist.ClassPool;

  18. import javassist.CtClass;

  19. import javassist.NotFoundException;

  20. import javassist.bytecode.BadBytecode;

  21. import javassist.bytecode.CodeIterator;

  22. import javassist.bytecode.ConstPool;

  23. import javassist.bytecode.Descriptor;

  24. import javassist.bytecode.MethodInfo;

  25. import javassist.bytecode.Opcode;

  26. 

  27. /**

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

  29.  *

  30.  * @author Jason T. Greene

  31.  */

  32. public class Executor implements Opcode {

  33.     private final ConstPool constPool;

  34.     private final ClassPool classPool;

  35.     private final Type STRING_TYPE;

  36.     private final Type CLASS_TYPE;

  37.     private final Type THROWABLE_TYPE;

  38.     private int lastPos;

  39. 

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

  41.         this.constPool = constPool;

  42.         this.classPool = classPool;

  43. 

  44.         try {

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

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

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

  48.         } catch (Exception e) {

  49.             throw new RuntimeException(e);

  50.         }

  51.     }

  52. 

  53. 

  54.     /**

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

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

  57.      * the local variable table.

  58.      *

  59.      * @param method the method containing the instruction

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

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

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

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

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

  65.      */

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

  67.         this.lastPos = pos;

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

  69. 

  70. 

  71.         // Declared opcode in order

  72.         switch (opcode) {

  73.             case NOP:

  74.                 break;

  75.             case ACONST_NULL:

  76.                 frame.push(Type.UNINIT);

  77.                 break;

  78.             case ICONST_M1:

  79.             case ICONST_0:

  80.             case ICONST_1:

  81.             case ICONST_2:

  82.             case ICONST_3:

  83.             case ICONST_4:

  84.             case ICONST_5:

  85.                 frame.push(Type.INTEGER);

  86.                 break;

  87.             case LCONST_0:

  88.             case LCONST_1:

  89.                 frame.push(Type.LONG);

  90.                 frame.push(Type.TOP);

  91.                 break;

  92.             case FCONST_0:

  93.             case FCONST_1:

  94.             case FCONST_2:

  95.                 frame.push(Type.FLOAT);

  96.                 break;

  97.             case DCONST_0:

  98.             case DCONST_1:

  99.                 frame.push(Type.DOUBLE);

  100.                 frame.push(Type.TOP);

  101.                 break;

  102.             case BIPUSH:

  103.             case SIPUSH:

  104.                 frame.push(Type.INTEGER);

  105.                 break;

  106.             case LDC:

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

  108.                 break;

  109.             case LDC_W :

  110.             case LDC2_W :

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

  112.                 break;

  113.             case ILOAD:

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

  115.                 break;

  116.             case LLOAD:

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

  118.                 break;

  119.             case FLOAD:

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

  121.                 break;

  122.             case DLOAD:

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

  124.                 break;

  125.             case ALOAD:

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

  127.                 break;

  128.             case ILOAD_0:

  129.             case ILOAD_1:

  130.             case ILOAD_2:

  131.             case ILOAD_3:

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

  133.                 break;

  134.             case LLOAD_0:

  135.             case LLOAD_1:

  136.             case LLOAD_2:

  137.             case LLOAD_3:

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

  139.                 break;

  140.             case FLOAD_0:

  141.             case FLOAD_1:

  142.             case FLOAD_2:

  143.             case FLOAD_3:

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

  145.                 break;

  146.             case DLOAD_0:

  147.             case DLOAD_1:

  148.             case DLOAD_2:

  149.             case DLOAD_3:

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

  151.                 break;

  152.             case ALOAD_0:

  153.             case ALOAD_1:

  154.             case ALOAD_2:

  155.             case ALOAD_3:

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

  157.                 break;

  158.             case IALOAD:

  159.                 evalArrayLoad(Type.INTEGER, frame);

  160.                 break;

  161.             case LALOAD:

  162.                 evalArrayLoad(Type.LONG, frame);

  163.                 break;

  164.             case FALOAD:

  165.                 evalArrayLoad(Type.FLOAT, frame);

  166.                 break;

  167.             case DALOAD:

  168.                 evalArrayLoad(Type.DOUBLE, frame);

  169.                 break;

  170.             case AALOAD:

  171.                 evalArrayLoad(Type.OBJECT, frame);

  172.                 break;

  173.             case BALOAD:

  174.             case CALOAD:

  175.             case SALOAD:

  176.                 evalArrayLoad(Type.INTEGER, frame);

  177.                 break;

  178.             case ISTORE:

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

  180.                 break;

  181.             case LSTORE:

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

  183.                 break;

  184.             case FSTORE:

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

  186.                 break;

  187.             case DSTORE:

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

  189.                 break;

  190.             case ASTORE:

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

  192.                 break;

  193.             case ISTORE_0:

  194.             case ISTORE_1:

  195.             case ISTORE_2:

  196.             case ISTORE_3:

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

  198.                 break;

  199.             case LSTORE_0:

  200.             case LSTORE_1:

  201.             case LSTORE_2:

  202.             case LSTORE_3:

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

  204.                 break;

  205.             case FSTORE_0:

  206.             case FSTORE_1:

  207.             case FSTORE_2:

  208.             case FSTORE_3:

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

  210.                 break;

  211.             case DSTORE_0:

  212.             case DSTORE_1:

  213.             case DSTORE_2:

  214.             case DSTORE_3:

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

  216.                 break;

  217.             case ASTORE_0:

  218.             case ASTORE_1:

  219.             case ASTORE_2:

  220.             case ASTORE_3:

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

  222.                 break;

  223.             case IASTORE:

  224.                 evalArrayStore(Type.INTEGER, frame);

  225.                 break;

  226.             case LASTORE:

  227.                 evalArrayStore(Type.LONG, frame);

  228.                 break;

  229.             case FASTORE:

  230.                 evalArrayStore(Type.FLOAT, frame);

  231.                 break;

  232.             case DASTORE:

  233.                 evalArrayStore(Type.DOUBLE, frame);

  234.                 break;

  235.             case AASTORE:

  236.                 evalArrayStore(Type.OBJECT, frame);

  237.                 break;

  238.             case BASTORE:

  239.             case CASTORE:

  240.             case SASTORE:

  241.                 evalArrayStore(Type.INTEGER, frame);

  242.                 break;

  243.             case POP:

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

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

  246.                 break;

  247.             case POP2:

  248.                 frame.pop();

  249.                 frame.pop();

  250.                 break;

  251.             case DUP: {

  252.                 Type type = frame.peek();

  253.                 if (type == Type.TOP)

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

  255. 

  256.                 frame.push(frame.peek());

  257.                 break;

  258.             }

  259.             case DUP_X1:

  260.             case DUP_X2: {

  261.                 Type type = frame.peek();

  262.                 if (type == Type.TOP)

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

  264.                 int end = frame.getTopIndex();

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

  266.                 frame.push(type);

  267. 

  268.                 while (end > insert) {

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

  270.                     end--;

  271.                 }

  272.                 frame.setStack(insert, type);

  273.                 break;

  274.             }

  275.             case DUP2:

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

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

  278.                 break;

  279.             case DUP2_X1:

  280.             case DUP2_X2: {

  281.                 int end = frame.getTopIndex();

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

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

  284.                 Type type2 = frame.peek();

  285.                 frame.push(type1);

  286.                 frame.push(type2);

  287.                 while (end > insert) {

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

  289.                     end--;

  290.                 }

  291.                 frame.setStack(insert, type2);

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

  293.                 break;

  294.             }

  295.             case SWAP: {

  296.                 Type type1 = frame.pop();

  297.                 Type type2 = frame.pop();

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

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

  300.                 frame.push(type1);

  301.                 frame.push(type2);

  302.                 break;

  303.             }

  304. 

  305.             // Math

  306.             case IADD:

  307.                 evalBinaryMath(Type.INTEGER, frame);

  308.                 break;

  309.             case LADD:

  310.                 evalBinaryMath(Type.LONG, frame);

  311.                 break;

  312.             case FADD:

  313.                 evalBinaryMath(Type.FLOAT, frame);

  314.                 break;

  315.             case DADD:

  316.                 evalBinaryMath(Type.DOUBLE, frame);

  317.                 break;

  318.             case ISUB:

  319.                 evalBinaryMath(Type.INTEGER, frame);

  320.                 break;

  321.             case LSUB:

  322.                 evalBinaryMath(Type.LONG, frame);

  323.                 break;

  324.             case FSUB:

  325.                 evalBinaryMath(Type.FLOAT, frame);

  326.                 break;

  327.             case DSUB:

  328.                 evalBinaryMath(Type.DOUBLE, frame);

  329.                 break;

  330.             case IMUL:

  331.                 evalBinaryMath(Type.INTEGER, frame);

  332.                 break;

  333.             case LMUL:

  334.                 evalBinaryMath(Type.LONG, frame);

  335.                 break;

  336.             case FMUL:

  337.                 evalBinaryMath(Type.FLOAT, frame);

  338.                 break;

  339.             case DMUL:

  340.                 evalBinaryMath(Type.DOUBLE, frame);

  341.                 break;

  342.             case IDIV:

  343.                 evalBinaryMath(Type.INTEGER, frame);

  344.                 break;

  345.             case LDIV:

  346.                 evalBinaryMath(Type.LONG, frame);

  347.                 break;

  348.             case FDIV:

  349.                 evalBinaryMath(Type.FLOAT, frame);

  350.                 break;

  351.             case DDIV:

  352.                 evalBinaryMath(Type.DOUBLE, frame);

  353.                 break;

  354.             case IREM:

  355.                 evalBinaryMath(Type.INTEGER, frame);

  356.                 break;

  357.             case LREM:

  358.                 evalBinaryMath(Type.LONG, frame);

  359.                 break;

  360.             case FREM:

  361.                 evalBinaryMath(Type.FLOAT, frame);

  362.                 break;

  363.             case DREM:

  364.                 evalBinaryMath(Type.DOUBLE, frame);

  365.                 break;

  366. 

  367.             // Unary

  368.             case INEG:

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

  370.                 break;

  371.             case LNEG:

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

  373.                 break;

  374.             case FNEG:

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

  376.                 break;

  377.             case DNEG:

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

  379.                 break;

  380. 

  381.             // Shifts

  382.             case ISHL:

  383.                 evalShift(Type.INTEGER, frame);

  384.                 break;

  385.             case LSHL:

  386.                 evalShift(Type.LONG, frame);

  387.                 break;

  388.             case ISHR:

  389.                 evalShift(Type.INTEGER, frame);

  390.                 break;

  391.             case LSHR:

  392.                 evalShift(Type.LONG, frame);

  393.                 break;

  394.             case IUSHR:

  395.                 evalShift(Type.INTEGER,frame);

  396.                 break;

  397.             case LUSHR:

  398.                 evalShift(Type.LONG, frame);

  399.                 break;

  400. 

  401.             // Bitwise Math

  402.             case IAND:

  403.                 evalBinaryMath(Type.INTEGER, frame);

  404.                 break;

  405.             case LAND:

  406.                 evalBinaryMath(Type.LONG, frame);

  407.                 break;

  408.             case IOR:

  409.                 evalBinaryMath(Type.INTEGER, frame);

  410.                 break;

  411.             case LOR:

  412.                 evalBinaryMath(Type.LONG, frame);

  413.                 break;

  414.             case IXOR:

  415.                 evalBinaryMath(Type.INTEGER, frame);

  416.                 break;

  417.             case LXOR:

  418.                 evalBinaryMath(Type.LONG, frame);

  419.                 break;

  420. 

  421.             case IINC: {

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

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

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

  425.                 break;

  426.             }

  427. 

  428.             // Conversion

  429.             case I2L:

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

  431.                 simplePush(Type.LONG, frame);

  432.                 break;

  433.             case I2F:

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

  435.                 simplePush(Type.FLOAT, frame);

  436.                 break;

  437.             case I2D:

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

  439.                 simplePush(Type.DOUBLE, frame);

  440.                 break;

  441.             case L2I:

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

  443.                 simplePush(Type.INTEGER, frame);

  444.                 break;

  445.             case L2F:

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

  447.                 simplePush(Type.FLOAT, frame);

  448.                 break;

  449.             case L2D:

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

  451.                 simplePush(Type.DOUBLE, frame);

  452.                 break;

  453.             case F2I:

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

  455.                 simplePush(Type.INTEGER, frame);

  456.                 break;

  457.             case F2L:

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

  459.                 simplePush(Type.LONG, frame);

  460.                 break;

  461.             case F2D:

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

  463.                 simplePush(Type.DOUBLE, frame);

  464.                 break;

  465.             case D2I:

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

  467.                 simplePush(Type.INTEGER, frame);

  468.                 break;

  469.             case D2L:

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

  471.                 simplePush(Type.LONG, frame);

  472.                 break;

  473.             case D2F:

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

  475.                 simplePush(Type.FLOAT, frame);

  476.                 break;

  477.             case I2B:

  478.             case I2C:

  479.             case I2S:

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

  481.                 break;

  482.             case LCMP:

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

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

  485.                 frame.push(Type.INTEGER);

  486.                 break;

  487.             case FCMPL:

  488.             case FCMPG:

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

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

  491.                 frame.push(Type.INTEGER);

  492.                 break;

  493.             case DCMPL:

  494.             case DCMPG:

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

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

  497.                 frame.push(Type.INTEGER);

  498.                 break;

  499. 

  500.             // Control flow

  501.             case IFEQ:

  502.             case IFNE:

  503.             case IFLT:

  504.             case IFGE:

  505.             case IFGT:

  506.             case IFLE:

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

  508.                 break;

  509.             case IF_ICMPEQ:

  510.             case IF_ICMPNE:

  511.             case IF_ICMPLT:

  512.             case IF_ICMPGE:

  513.             case IF_ICMPGT:

  514.             case IF_ICMPLE:

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

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

  517.                 break;

  518.             case IF_ACMPEQ:

  519.             case IF_ACMPNE:

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

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

  522.                 break;

  523.             case GOTO:

  524.                 break;

  525.             case JSR:

  526.                 frame.push(Type.RETURN_ADDRESS);

  527.                 break;

  528.             case RET:

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

  530.                 break;

  531.             case TABLESWITCH:

  532.             case LOOKUPSWITCH:

  533.             case IRETURN:

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

  535.                 break;

  536.             case LRETURN:

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

  538.                 break;

  539.             case FRETURN:

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

  541.                 break;

  542.             case DRETURN:

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

  544.                 break;

  545.             case ARETURN:

  546.                 try {

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

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

  549.                 } catch (NotFoundException e) {

  550.                    throw new RuntimeException(e);

  551.                 }

  552.                 break;

  553.             case RETURN:

  554.                 break;

  555.             case GETSTATIC:

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

  557.                 break;

  558.             case PUTSTATIC:

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

  560.                 break;

  561.             case GETFIELD:

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

  563.                 break;

  564.             case PUTFIELD:

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

  566.                 break;

  567.             case INVOKEVIRTUAL:

  568.             case INVOKESPECIAL:

  569.             case INVOKESTATIC:

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

  571.                 break;

  572.             case INVOKEINTERFACE:

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

  574.                 break;

  575.             case 186:

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

  577.             case NEW:

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

  579.                 break;

  580.             case NEWARRAY:

  581.                 evalNewArray(pos, iter, frame);

  582.                 break;

  583.             case ANEWARRAY:

  584.                 evalNewObjectArray(pos, iter, frame);

  585.                 break;

  586.             case ARRAYLENGTH: {

  587.                 Type array = simplePop(frame);

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

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

  590.                 frame.push(Type.INTEGER);

  591.                 break;

  592.             }

  593.             case ATHROW:

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

  595.                 break;

  596.             case CHECKCAST:

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

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

  599.                 break;

  600.             case INSTANCEOF:

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

  602.                 frame.push(Type.INTEGER);

  603.                 break;

  604.             case MONITORENTER:

  605.             case MONITOREXIT:

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

  607.                 break;

  608.             case WIDE:

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

  610.                 break;

  611.             case MULTIANEWARRAY:

  612.                 evalNewObjectArray(pos, iter, frame);

  613.                 break;

  614.             case IFNULL:

  615.             case IFNONNULL:

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

  617.                 break;

  618.             case GOTO_W:

  619.                 break;

  620.             case JSR_W:

  621.                 frame.push(Type.RETURN_ADDRESS);

  622.                 break;

  623.         }

  624.     }

  625. 

  626.     private Type zeroExtend(Type type) {

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

  628.             return  Type.INTEGER;

  629. 

  630.         return type;

  631.     }

  632. 

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

  634.         Type index = frame.pop();

  635.         Type array = frame.pop();

  636. 

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

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

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

  640.             verifyAssignable(Type.INTEGER, index);

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

  642.                 simplePush(Type.UNINIT, frame);

  643.             } else {

  644.                 simplePush(expectedComponent, frame);

  645.             }

  646.             return;

  647.         }

  648. 

  649.         Type component = array.getComponent();

  650. 

  651.         if (component == null)

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

  653. 

  654.         component = zeroExtend(component);

  655. 

  656.         verifyAssignable(expectedComponent, component);

  657.         verifyAssignable(Type.INTEGER, index);

  658.         simplePush(component, frame);

  659.     }

  660. 

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

  662.         Type value = simplePop(frame);

  663.         Type index = frame.pop();

  664.         Type array = frame.pop();

  665. 

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

  667.             verifyAssignable(Type.INTEGER, index);

  668.             return;

  669.         }

  670. 

  671.         Type component = array.getComponent();

  672. 

  673.         if (component == null)

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

  675. 

  676.         component = zeroExtend(component);

  677. 

  678.         verifyAssignable(expectedComponent, component);

  679.         verifyAssignable(Type.INTEGER, index);

  680. 

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

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

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

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

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

  686.         //                               // but will throw arraystoreexception

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

  688.             verifyAssignable(expectedComponent, value);

  689.         } else {

  690.             verifyAssignable(component, value);

  691.         }

  692.     }

  693. 

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

  695.         Type value2 = simplePop(frame);

  696.         Type value1 = simplePop(frame);

  697. 

  698.         verifyAssignable(expected, value2);

  699.         verifyAssignable(expected, value1);

  700.         simplePush(value1, frame);

  701.     }

  702. 

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

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

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

  706. 

  707.         if (opcode == GETFIELD) {

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

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

  710.         }

  711. 

  712.         simplePush(type, frame);

  713.     }

  714. 

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

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

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

  718.         int i = types.length;

  719. 

  720.         while (i > 0)

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

  722. 

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

  724.         Type objectType = resolveClassInfo(classInfo);

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

  726. 

  727.         Type returnType = returnTypeFromDesc(desc);

  728.         if (returnType != Type.VOID)

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

  730.     }

  731. 

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

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

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

  735.         int i = types.length;

  736. 

  737.         while (i > 0)

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

  739. 

  740.         if (opcode != INVOKESTATIC) {

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

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

  743.         }

  744. 

  745.         Type returnType = returnTypeFromDesc(desc);

  746.         if (returnType != Type.VOID)

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

  748.     }

  749. 

  750. 

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

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

  753.         Type type;

  754.         switch (tag) {

  755.         case ConstPool.CONST_String:

  756.             type = STRING_TYPE;

  757.             break;

  758.         case ConstPool.CONST_Integer:

  759.             type = Type.INTEGER;

  760.             break;

  761.         case ConstPool.CONST_Float:

  762.             type = Type.FLOAT;

  763.             break;

  764.         case ConstPool.CONST_Long:

  765.             type = Type.LONG;

  766.             break;

  767.         case ConstPool.CONST_Double:

  768.             type = Type.DOUBLE;

  769.             break;

  770.         case ConstPool.CONST_Class:

  771.             type = CLASS_TYPE;

  772.             break;

  773.         default:

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

  775.         }

  776. 

  777.         simplePush(type, frame);

  778.     }

  779. 

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

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

  782. 

  783.         verifyAssignable(expected, type);

  784. 

  785.         simplePush(type, frame);

  786.         access(index, type, subroutine);

  787.     }

  788. 

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

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

  791.         Type type = null;

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

  793.         switch (typeInfo) {

  794.             case T_BOOLEAN:

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

  796.                 break;

  797.             case T_CHAR:

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

  799.                 break;

  800.             case T_BYTE:

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

  802.                 break;

  803.             case T_SHORT:

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

  805.                 break;

  806.             case T_INT:

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

  808.                 break;

  809.             case T_LONG:

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

  811.                 break;

  812.             case T_FLOAT:

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

  814.                 break;

  815.             case T_DOUBLE:

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

  817.                 break;

  818.             default:

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

  820. 

  821.         }

  822. 

  823.         frame.push(type);

  824.     }

  825. 

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

  827.         // Convert to x[] format

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

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

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

  831.         int dimensions;

  832. 

  833.         if (opcode == MULTIANEWARRAY) {

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

  835.         } else {

  836.             name = name + "[]";

  837.             dimensions = 1;

  838.         }

  839. 

  840.         while (dimensions-- > 0) {

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

  842.         }

  843. 

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

  845.     }

  846. 

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

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

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

  850. 

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

  852. 

  853.         if (opcode == PUTFIELD) {

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

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

  856.         }

  857.     }

  858. 

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

  860.         Type value2 = simplePop(frame);

  861.         Type value1 = simplePop(frame);

  862. 

  863.         verifyAssignable(Type.INTEGER, value2);

  864.         verifyAssignable(expected, value1);

  865.         simplePush(value1, frame);

  866.     }

  867. 

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

  869.         Type type = simplePop(frame);

  870. 

  871.         // RETURN_ADDRESS is allowed by ASTORE

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

  873.             verifyAssignable(expected, type);

  874.         simpleSetLocal(index, type, frame);

  875.         access(index, type, subroutine);

  876.     }

  877. 

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

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

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

  881.         switch (opcode) {

  882.             case ILOAD:

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

  884.                 break;

  885.             case LLOAD:

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

  887.                 break;

  888.             case FLOAD:

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

  890.                 break;

  891.             case DLOAD:

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

  893.                 break;

  894.             case ALOAD:

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

  896.                 break;

  897.             case ISTORE:

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

  899.                 break;

  900.             case LSTORE:

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

  902.                 break;

  903.             case FSTORE:

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

  905.                 break;

  906.             case DSTORE:

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

  908.                 break;

  909.             case ASTORE:

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

  911.                 break;

  912.             case IINC:

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

  914.                 break;

  915.             case RET:

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

  917.                 break;

  918.             default:

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

  920.         }

  921. 

  922.     }

  923. 

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

  925.         try {

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

  927.         } catch (NotFoundException e) {

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

  929.         }

  930.     }

  931. 

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

  933.         CtClass classes[] = null;

  934.         try {

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

  936.         } catch (NotFoundException e) {

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

  938.         }

  939. 

  940.         if (classes == null)

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

  942. 

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

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

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

  946. 

  947.         return types;

  948.     }

  949. 

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

  951.         CtClass clazz = null;

  952.         try {

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

  954.         } catch (NotFoundException e) {

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

  956.         }

  957. 

  958.         if (clazz == null)

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

  960. 

  961.         return Type.get(clazz);

  962.     }

  963. 

  964.     private Type simplePeek(Frame frame) {

  965.         Type type = frame.peek();

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

  967.     }

  968. 

  969.     private Type simplePop(Frame frame) {

  970.         Type type = frame.pop();

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

  972.     }

  973. 

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

  975.         frame.push(type);

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

  977.             frame.push(Type.TOP);

  978.     }

  979. 

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

  981.         if (subroutine == null)

  982.             return;

  983.         subroutine.access(index);

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

  985.             subroutine.access(index + 1);

  986.     }

  987. 

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

  989.         frame.setLocal(index, type);

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

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

  992.     }

  993. 

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

  995.         CtClass clazz = null;

  996.         try {

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

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

  999.             } else {

  1000.                 clazz = classPool.get(info);

  1001.             }

  1002. 

  1003.         } catch (NotFoundException e) {

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

  1005.         }

  1006. 

  1007.         if (clazz == null)

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

  1009. 

  1010.         return Type.get(clazz);

  1011.     }

  1012. 

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

  1014.         CtClass clazz = null;

  1015.         try {

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

  1017.         } catch (NotFoundException e) {

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

  1019.         }

  1020. 

  1021.         if (clazz == null)

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

  1023. 

  1024.         return Type.get(clazz);

  1025.     }

  1026. 

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

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

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

  1030.     }

  1031. }