URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [tools/] [external/] [asm/] [org/] [objectweb/] [asm/] [commons/] [AdviceAdapter.java] - Blame information for rev 779

Details | Compare with Previous | View Log


/***
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2005 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.objectweb.asm.commons;
 
import java.util.ArrayList;
import java.util.HashMap;
 
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
 
/**
 * A <code>MethodAdapter</code> to dispatch method body instruction
 * <p>
 * The behavior is like this:
 * <ol>
 *
 * <li>as long as the INVOKESPECIAL for the object initialization has not been
 *     reached, every bytecode instruction is dispatched in the ctor code visitor</li>
 *
 * <li>when this one is reached, it is only added in the ctor code visitor and
 *     a JP invoke is added</li>
 * <li>after that, only the other code visitor receives the instructions</li>
 *
 * </ol>
 *
 * @author Eugene Kuleshov
 * @author Eric Bruneton
 */
public abstract class AdviceAdapter extends GeneratorAdapter implements Opcodes {
    private static final Object THIS = new Object();
    private static final Object OTHER = new Object();
 
    protected int methodAccess;
    protected String methodDesc;
 
    private boolean constructor;
    private boolean superInitialized;
    private ArrayList stackFrame;
    private HashMap branches;
 
 
    /**
     * Creates a new {@link AdviceAdapter}.
     *
     * @param mv the method visitor to which this adapter delegates calls.
     * @param access the method's access flags (see {@link Opcodes}).
     * @param name the method's name.
     * @param desc the method's descriptor (see {@link Type Type}).
     */
    public AdviceAdapter(MethodVisitor mv, int access, String name, String desc) {
        super(mv, access, name, desc);
        methodAccess = access;
        methodDesc = desc;
 
        constructor = "<init>".equals(name);
        if (!constructor) {
            superInitialized = true;
            onMethodEnter();
        } else {
            stackFrame = new ArrayList();
            branches = new HashMap();
        }
    }
 
    public void visitLabel(Label label) {
        mv.visitLabel(label);
 
        if (constructor && branches != null) {
            ArrayList frame = (ArrayList) branches.get(label);
            if (frame != null) {
                stackFrame = frame;
                branches.remove(label);
            }
        }
    }
 
    public void visitInsn(int opcode) {
        if (constructor) {
            switch (opcode) {
                case RETURN: // empty stack
                    onMethodExit(opcode);
                    break;
 
                case IRETURN: // 1 before n/a after
                case FRETURN: // 1 before n/a after
                case ARETURN: // 1 before n/a after
                case ATHROW: // 1 before n/a after
                    popValue();
                    popValue();
                    onMethodExit(opcode);
                    break;
 
                case LRETURN: // 2 before n/a after
                case DRETURN: // 2 before n/a after
                    popValue();
                    popValue();
                    onMethodExit(opcode);
                    break;
 
                case NOP:
                case LALOAD: // remove 2 add 2
                case DALOAD: // remove 2 add 2
                case LNEG:
                case DNEG:
                case FNEG:
                case INEG:
                case L2D:
                case D2L:
                case F2I:
                case I2B:
                case I2C:
                case I2S:
                case I2F:
                case Opcodes.ARRAYLENGTH:
                    break;
 
                case ACONST_NULL:
                case ICONST_M1:
                case ICONST_0:
                case ICONST_1:
                case ICONST_2:
                case ICONST_3:
                case ICONST_4:
                case ICONST_5:
                case FCONST_0:
                case FCONST_1:
                case FCONST_2:
                case F2L: // 1 before 2 after
                case F2D:
                case I2L:
                case I2D:
                    pushValue(OTHER);
                    break;
 
                case LCONST_0:
                case LCONST_1:
                case DCONST_0:
                case DCONST_1:
                    pushValue(OTHER);
                    pushValue(OTHER);
                    break;
 
                case IALOAD: // remove 2 add 1
                case FALOAD: // remove 2 add 1
                case AALOAD: // remove 2 add 1
                case BALOAD: // remove 2 add 1
                case CALOAD: // remove 2 add 1
                case SALOAD: // remove 2 add 1
                case POP:
                case IADD:
                case FADD:
                case ISUB:
                case LSHL: // 3 before 2 after
                case LSHR: // 3 before 2 after
                case LUSHR: // 3 before 2 after
                case L2I: // 2 before 1 after
                case L2F: // 2 before 1 after
                case D2I: // 2 before 1 after
                case D2F: // 2 before 1 after
                case FSUB:
                case FMUL:
                case FDIV:
                case FREM:
                case FCMPL: // 2 before 1 after
                case FCMPG: // 2 before 1 after
                case IMUL:
                case IDIV:
                case IREM:
                case ISHL:
                case ISHR:
                case IUSHR:
                case IAND:
                case IOR:
                case IXOR:
                case MONITORENTER:
                case MONITOREXIT:
                    popValue();
                    break;
 
                case POP2:
                case LSUB:
                case LMUL:
                case LDIV:
                case LREM:
                case LADD:
                case LAND:
                case LOR:
                case LXOR:
                case DADD:
                case DMUL:
                case DSUB:
                case DDIV:
                case DREM:
                    popValue();
                    popValue();
                    break;
 
                case IASTORE:
                case FASTORE:
                case AASTORE:
                case BASTORE:
                case CASTORE:
                case SASTORE:
                case LCMP: // 4 before 1 after
                case DCMPL:
                case DCMPG:
                    popValue();
                    popValue();
                    popValue();
                    break;
 
                case LASTORE:
                case DASTORE:
                    popValue();
                    popValue();
                    popValue();
                    popValue();
                    break;
 
                case DUP:
                    pushValue(peekValue());
                    break;
 
                case DUP_X1:
                // TODO optimize this
                {
                    Object o1 = popValue();
                    Object o2 = popValue();
                    pushValue(o1);
                    pushValue(o2);
                    pushValue(o1);
                }
                    break;
 
                case DUP_X2:
                // TODO optimize this
                {
                    Object o1 = popValue();
                    Object o2 = popValue();
                    Object o3 = popValue();
                    pushValue(o1);
                    pushValue(o3);
                    pushValue(o2);
                    pushValue(o1);
                }
                    break;
 
                case DUP2:
                // TODO optimize this
                {
                    Object o1 = popValue();
                    Object o2 = popValue();
                    pushValue(o2);
                    pushValue(o1);
                    pushValue(o2);
                    pushValue(o1);
                }
                    break;
 
                case DUP2_X1:
                // TODO optimize this
                {
                    Object o1 = popValue();
                    Object o2 = popValue();
                    Object o3 = popValue();
                    pushValue(o2);
                    pushValue(o1);
                    pushValue(o3);
                    pushValue(o2);
                    pushValue(o1);
                }
                    break;
 
                case DUP2_X2:
                // TODO optimize this
                {
                    Object o1 = popValue();
                    Object o2 = popValue();
                    Object o3 = popValue();
                    Object o4 = popValue();
                    pushValue(o2);
                    pushValue(o1);
                    pushValue(o4);
                    pushValue(o3);
                    pushValue(o2);
                    pushValue(o1);
                }
                    break;
 
                case SWAP: {
                    Object o1 = popValue();
                    Object o2 = popValue();
                    pushValue(o1);
                    pushValue(o2);
                }
                    break;
            }
        } else {
            switch (opcode) {
                case RETURN:
                case IRETURN:
                case FRETURN:
                case ARETURN:
                case LRETURN:
                case DRETURN:
                case ATHROW:
                    onMethodExit(opcode);
                    break;
            }
        }
        mv.visitInsn(opcode);
    }
 
    public void visitVarInsn(int opcode, int var) {
        super.visitVarInsn(opcode, var);
 
        if (constructor) {
            switch (opcode) {
                case ILOAD:
                case FLOAD:
                    pushValue(OTHER);
                    break;
                case LLOAD:
                case DLOAD:
                    pushValue(OTHER);
                    pushValue(OTHER);
                    break;
                case ALOAD:
                    pushValue(var == 0 ? THIS : OTHER);
                    break;
                case ASTORE:
                case ISTORE:
                case FSTORE:
                    popValue();
                    break;
                case LSTORE:
                case DSTORE:
                    popValue();
                    popValue();
                    break;
            }
        }
    }
 
    public void visitFieldInsn(
        int opcode,
        String owner,
        String name,
        String desc)
    {
        mv.visitFieldInsn(opcode, owner, name, desc);
 
        if (constructor) {
            char c = desc.charAt(0);
            boolean longOrDouble = c == 'J' || c == 'D';
            switch (opcode) {
                case GETSTATIC:
                    pushValue(OTHER);
                    if (longOrDouble) {
                        pushValue(OTHER);
                    }
                    break;
                case PUTSTATIC:
                    popValue();
                    if(longOrDouble) {
                        popValue();
                    }
                    break;
                case PUTFIELD:
                    popValue();
                    if(longOrDouble) {
                        popValue();
                        popValue();
                    }
                    break;
                // case GETFIELD:
                default:
                    if (longOrDouble) {
                        pushValue(OTHER);
                    }
            }
        }
    }
 
    public void visitIntInsn(int opcode, int operand) {
        mv.visitIntInsn(opcode, operand);
 
        if (constructor) {
            switch (opcode) {
                case BIPUSH:
                case SIPUSH:
                    pushValue(OTHER);
            }
        }
    }
 
    public void visitLdcInsn(Object cst) {
        mv.visitLdcInsn(cst);
 
        if (constructor) {
            pushValue(OTHER);
            if (cst instanceof Double || cst instanceof Long) {
                pushValue(OTHER);
            }
        }
    }
 
    public void visitMultiANewArrayInsn(String desc, int dims) {
        mv.visitMultiANewArrayInsn(desc, dims);
 
        if (constructor) {
            for (int i = 0; i < dims; i++) {
                popValue();
            }
            pushValue(OTHER);
        }
    }
 
    public void visitTypeInsn(int opcode, String name) {
        mv.visitTypeInsn(opcode, name);
 
        // ANEWARRAY, CHECKCAST or INSTANCEOF don't change stack
        if (constructor && opcode == NEW) {
            pushValue(OTHER);
        }
    }
 
    public void visitMethodInsn(
        int opcode,
        String owner,
        String name,
        String desc)
    {
        mv.visitMethodInsn(opcode, owner, name, desc);
 
        if (constructor) {
            Type[] types = Type.getArgumentTypes(desc);
            for (int i = 0; i < types.length; i++) {
                popValue();
                if (types[i].getSize() == 2) {
                    popValue();
                }
            }
            switch (opcode) {
                // case INVOKESTATIC:
                // break;
 
                case INVOKEINTERFACE:
                case INVOKEVIRTUAL:
                    popValue(); // objectref
                    break;
 
                case INVOKESPECIAL:
                    Object type = popValue(); // objectref
                    if (type == THIS && !superInitialized) {
                        onMethodEnter();
                        superInitialized = true;
                        // once super has been initialized it is no longer
                        // necessary to keep track of stack state
                        constructor = false;
                    }
                    break;
            }
 
            Type returnType = Type.getReturnType(desc);
            if (returnType != Type.VOID_TYPE) {
                pushValue(OTHER);
                if (returnType.getSize() == 2) {
                    pushValue(OTHER);
                }
            }
        }
    }
 
    public void visitJumpInsn(int opcode, Label label) {
        mv.visitJumpInsn(opcode, label);
 
        if (constructor) {
            switch (opcode) {
                case IFEQ:
                case IFNE:
                case IFLT:
                case IFGE:
                case IFGT:
                case IFLE:
                case IFNULL:
                case IFNONNULL:
                    popValue();
                    break;
 
                case IF_ICMPEQ:
                case IF_ICMPNE:
                case IF_ICMPLT:
                case IF_ICMPGE:
                case IF_ICMPGT:
                case IF_ICMPLE:
                case IF_ACMPEQ:
                case IF_ACMPNE:
                    popValue();
                    popValue();
                    break;
 
                case JSR:
                    pushValue(OTHER);
                    break;
            }
            addBranch(label);
        }
    }
 
    public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) {
        mv.visitLookupSwitchInsn(dflt, keys, labels);
 
        if (constructor) {
            popValue();
            addBranches(dflt, labels);
        }
    }
 
    public void visitTableSwitchInsn(
        int min,
        int max,
        Label dflt,
        Label[] labels)
    {
        mv.visitTableSwitchInsn(min, max, dflt, labels);
 
        if (constructor) {
            popValue();
            addBranches(dflt, labels);
        }
    }
 
    private void addBranches(Label dflt, Label[] labels) {
        addBranch(dflt);
        for (int i = 0; i < labels.length; i++) {
            addBranch(labels[i]);
        }
    }
 
    private void addBranch(Label label) {
        if (branches.containsKey(label)) {
            return;
        }
        ArrayList frame = new ArrayList();
        frame.addAll(stackFrame);
        branches.put(label, frame);
    }
 
    private Object popValue() {
        return stackFrame.remove(stackFrame.size()-1);
    }
 
    private Object peekValue() {
        return stackFrame.get(stackFrame.size()-1);
    }
 
    private void pushValue(Object o) {
        stackFrame.add(o);
    }
 
    /**
     * Called at the beginning of the method or after super
     * class class call in the constructor.
     * <br><br>
     *
     * <i>Custom code can use or change all the local variables,
     * but should not change state of the stack.</i>
     */
    protected abstract void onMethodEnter();
 
    /**
     * Called before explicit exit from the method using either
     * return or throw. Top element on the stack contains the
     * return value or exception instance. For example:
     *
     * <pre>
     *   public void onMethodExit(int opcode) {
     *     if(opcode==RETURN) {
     *         visitInsn(ACONST_NULL);
     *     } else if(opcode==ARETURN || opcode==ATHROW) {
     *         dup();
     *     } else {
     *         if(opcode==LRETURN || opcode==DRETURN) {
     *             dup2();
     *         } else {
     *             dup();
     *         }
     *         box(Type.getReturnType(this.methodDesc));
     *     }
     *     visitIntInsn(SIPUSH, opcode);
     *     visitMethodInsn(INVOKESTATIC, owner, "onExit", "(Ljava/lang/Object;I)V");
     *   }
     *
     *   // an actual call back method
     *   public static void onExit(int opcode, Object param) {
     *     ...
     * </pre>
     *
     * <br><br>
     *
     * <i>Custom code can use or change all the local variables,
     * but should not change state of the stack.</i>
     *
     * @param opcode one of the RETURN, IRETURN, FRETURN,
     *   ARETURN, LRETURN, DRETURN or ATHROW
     *
     */
    protected abstract void onMethodExit(int opcode);
 
    // TODO onException, onMethodCall
 
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [tools/] [external/] [asm/] [org/] [objectweb/] [asm/] [commons/] [AdviceAdapter.java] - Blame information for rev 779

Line No.	Rev	Author	Line
1	779	jeremybenn	`/***`
2			`* ASM: a very small and fast Java bytecode manipulation framework`
3			`* Copyright (c) 2000-2005 INRIA, France Telecom`
4			`* All rights reserved.`
5			`*`
6			`* Redistribution and use in source and binary forms, with or without`
7			`* modification, are permitted provided that the following conditions`
8			`* are met:`
9			`* 1. Redistributions of source code must retain the above copyright`
10			`* notice, this list of conditions and the following disclaimer.`
11			`* 2. Redistributions in binary form must reproduce the above copyright`
12			`* notice, this list of conditions and the following disclaimer in the`
13			`* documentation and/or other materials provided with the distribution.`
14			`* 3. Neither the name of the copyright holders nor the names of its`
15			`* contributors may be used to endorse or promote products derived from`
16			`* this software without specific prior written permission.`
17			`*`
18			`* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"`
19			`* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE`
20			`* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE`
21			`* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE`
22			`* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR`
23			`* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF`
24			`* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS`
25			`* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN`
26			`* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)`
27			`* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF`
28			`* THE POSSIBILITY OF SUCH DAMAGE.`
29			`*/`
30			`package org.objectweb.asm.commons;`
31
32			`import java.util.ArrayList;`
33			`import java.util.HashMap;`
34
35			`import org.objectweb.asm.Label;`
36			`import org.objectweb.asm.MethodVisitor;`
37			`import org.objectweb.asm.Opcodes;`
38			`import org.objectweb.asm.Type;`
39
40			`/**`
41			`* A <code>MethodAdapter</code> to dispatch method body instruction`
42			`* <p>`
43			`* The behavior is like this:`
44			`* <ol>`
45			`*`
46			`* <li>as long as the INVOKESPECIAL for the object initialization has not been`
47			`* reached, every bytecode instruction is dispatched in the ctor code visitor</li>`
48			`*`
49			`* <li>when this one is reached, it is only added in the ctor code visitor and`
50			`* a JP invoke is added</li>`
51			`* <li>after that, only the other code visitor receives the instructions</li>`
52			`*`
53			`* </ol>`
54			`*`
55			`* @author Eugene Kuleshov`
56			`* @author Eric Bruneton`
57			`*/`
58			`public abstract class AdviceAdapter extends GeneratorAdapter implements Opcodes {`
59			`private static final Object THIS = new Object();`
60			`private static final Object OTHER = new Object();`
61
62			`protected int methodAccess;`
63			`protected String methodDesc;`
64
65			`private boolean constructor;`
66			`private boolean superInitialized;`
67			`private ArrayList stackFrame;`
68			`private HashMap branches;`
69
70
71			`/**`
72			`* Creates a new {@link AdviceAdapter}.`
73			`*`
74			`* @param mv the method visitor to which this adapter delegates calls.`
75			`* @param access the method's access flags (see {@link Opcodes}).`
76			`* @param name the method's name.`
77			`* @param desc the method's descriptor (see {@link Type Type}).`
78			`*/`
79			`public AdviceAdapter(MethodVisitor mv, int access, String name, String desc) {`
80			`super(mv, access, name, desc);`
81			`methodAccess = access;`
82			`methodDesc = desc;`
83
84			`constructor = "<init>".equals(name);`
85			`if (!constructor) {`
86			`superInitialized = true;`
87			`onMethodEnter();`
88			`} else {`
89			`stackFrame = new ArrayList();`
90			`branches = new HashMap();`
91			`}`
92			`}`
93
94			`public void visitLabel(Label label) {`
95			`mv.visitLabel(label);`
96
97			`if (constructor && branches != null) {`
98			`ArrayList frame = (ArrayList) branches.get(label);`
99			`if (frame != null) {`
100			`stackFrame = frame;`
101			`branches.remove(label);`
102			`}`
103			`}`
104			`}`
105
106			`public void visitInsn(int opcode) {`
107			`if (constructor) {`
108			`switch (opcode) {`
109			`case RETURN: // empty stack`
110			`onMethodExit(opcode);`
111			`break;`
112
113			`case IRETURN: // 1 before n/a after`
114			`case FRETURN: // 1 before n/a after`
115			`case ARETURN: // 1 before n/a after`
116			`case ATHROW: // 1 before n/a after`
117			`popValue();`
118			`popValue();`
119			`onMethodExit(opcode);`
120			`break;`
121
122			`case LRETURN: // 2 before n/a after`
123			`case DRETURN: // 2 before n/a after`
124			`popValue();`
125			`popValue();`
126			`onMethodExit(opcode);`
127			`break;`
128
129			`case NOP:`
130			`case LALOAD: // remove 2 add 2`
131			`case DALOAD: // remove 2 add 2`
132			`case LNEG:`
133			`case DNEG:`
134			`case FNEG:`
135			`case INEG:`
136			`case L2D:`
137			`case D2L:`
138			`case F2I:`
139			`case I2B:`
140			`case I2C:`
141			`case I2S:`
142			`case I2F:`
143			`case Opcodes.ARRAYLENGTH:`
144			`break;`
145
146			`case ACONST_NULL:`
147			`case ICONST_M1:`
148			`case ICONST_0:`
149			`case ICONST_1:`
150			`case ICONST_2:`
151			`case ICONST_3:`
152			`case ICONST_4:`
153			`case ICONST_5:`
154			`case FCONST_0:`
155			`case FCONST_1:`
156			`case FCONST_2:`
157			`case F2L: // 1 before 2 after`
158			`case F2D:`
159			`case I2L:`
160			`case I2D:`
161			`pushValue(OTHER);`
162			`break;`
163
164			`case LCONST_0:`
165			`case LCONST_1:`
166			`case DCONST_0:`
167			`case DCONST_1:`
168			`pushValue(OTHER);`
169			`pushValue(OTHER);`
170			`break;`
171
172			`case IALOAD: // remove 2 add 1`
173			`case FALOAD: // remove 2 add 1`
174			`case AALOAD: // remove 2 add 1`
175			`case BALOAD: // remove 2 add 1`
176			`case CALOAD: // remove 2 add 1`
177			`case SALOAD: // remove 2 add 1`
178			`case POP:`
179			`case IADD:`
180			`case FADD:`
181			`case ISUB:`
182			`case LSHL: // 3 before 2 after`
183			`case LSHR: // 3 before 2 after`
184			`case LUSHR: // 3 before 2 after`
185			`case L2I: // 2 before 1 after`
186			`case L2F: // 2 before 1 after`
187			`case D2I: // 2 before 1 after`
188			`case D2F: // 2 before 1 after`
189			`case FSUB:`
190			`case FMUL:`
191			`case FDIV:`
192			`case FREM:`
193			`case FCMPL: // 2 before 1 after`
194			`case FCMPG: // 2 before 1 after`
195			`case IMUL:`
196			`case IDIV:`
197			`case IREM:`
198			`case ISHL:`
199			`case ISHR:`
200			`case IUSHR:`
201			`case IAND:`
202			`case IOR:`
203			`case IXOR:`
204			`case MONITORENTER:`
205			`case MONITOREXIT:`
206			`popValue();`
207			`break;`
208
209			`case POP2:`
210			`case LSUB:`
211			`case LMUL:`
212			`case LDIV:`
213			`case LREM:`
214			`case LADD:`
215			`case LAND:`
216			`case LOR:`
217			`case LXOR:`
218			`case DADD:`
219			`case DMUL:`
220			`case DSUB:`
221			`case DDIV:`
222			`case DREM:`
223			`popValue();`
224			`popValue();`
225			`break;`
226
227			`case IASTORE:`
228			`case FASTORE:`
229			`case AASTORE:`
230			`case BASTORE:`
231			`case CASTORE:`
232			`case SASTORE:`
233			`case LCMP: // 4 before 1 after`
234			`case DCMPL:`
235			`case DCMPG:`
236			`popValue();`
237			`popValue();`
238			`popValue();`
239			`break;`
240
241			`case LASTORE:`
242			`case DASTORE:`
243			`popValue();`
244			`popValue();`
245			`popValue();`
246			`popValue();`
247			`break;`
248
249			`case DUP:`
250			`pushValue(peekValue());`
251			`break;`
252
253			`case DUP_X1:`
254			`// TODO optimize this`
255			`{`
256			`Object o1 = popValue();`
257			`Object o2 = popValue();`
258			`pushValue(o1);`
259			`pushValue(o2);`
260			`pushValue(o1);`
261			`}`
262			`break;`
263
264			`case DUP_X2:`
265			`// TODO optimize this`
266			`{`
267			`Object o1 = popValue();`
268			`Object o2 = popValue();`
269			`Object o3 = popValue();`
270			`pushValue(o1);`
271			`pushValue(o3);`
272			`pushValue(o2);`
273			`pushValue(o1);`
274			`}`
275			`break;`
276
277			`case DUP2:`
278			`// TODO optimize this`
279			`{`
280			`Object o1 = popValue();`
281			`Object o2 = popValue();`
282			`pushValue(o2);`
283			`pushValue(o1);`
284			`pushValue(o2);`
285			`pushValue(o1);`
286			`}`
287			`break;`
288
289			`case DUP2_X1:`
290			`// TODO optimize this`
291			`{`
292			`Object o1 = popValue();`
293			`Object o2 = popValue();`
294			`Object o3 = popValue();`
295			`pushValue(o2);`
296			`pushValue(o1);`
297			`pushValue(o3);`
298			`pushValue(o2);`
299			`pushValue(o1);`
300			`}`
301			`break;`
302
303			`case DUP2_X2:`
304			`// TODO optimize this`
305			`{`
306			`Object o1 = popValue();`
307			`Object o2 = popValue();`
308			`Object o3 = popValue();`
309			`Object o4 = popValue();`
310			`pushValue(o2);`
311			`pushValue(o1);`
312			`pushValue(o4);`
313			`pushValue(o3);`
314			`pushValue(o2);`
315			`pushValue(o1);`
316			`}`
317			`break;`
318
319			`case SWAP: {`
320			`Object o1 = popValue();`
321			`Object o2 = popValue();`
322			`pushValue(o1);`
323			`pushValue(o2);`
324			`}`
325			`break;`
326			`}`
327			`} else {`
328			`switch (opcode) {`
329			`case RETURN:`
330			`case IRETURN:`
331			`case FRETURN:`
332			`case ARETURN:`
333			`case LRETURN:`
334			`case DRETURN:`
335			`case ATHROW:`
336			`onMethodExit(opcode);`
337			`break;`
338			`}`
339			`}`
340			`mv.visitInsn(opcode);`
341			`}`
342
343			`public void visitVarInsn(int opcode, int var) {`
344			`super.visitVarInsn(opcode, var);`
345
346			`if (constructor) {`
347			`switch (opcode) {`
348			`case ILOAD:`
349			`case FLOAD:`
350			`pushValue(OTHER);`
351			`break;`
352			`case LLOAD:`
353			`case DLOAD:`
354			`pushValue(OTHER);`
355			`pushValue(OTHER);`
356			`break;`
357			`case ALOAD:`
358			`pushValue(var == 0 ? THIS : OTHER);`
359			`break;`
360			`case ASTORE:`
361			`case ISTORE:`
362			`case FSTORE:`
363			`popValue();`
364			`break;`
365			`case LSTORE:`
366			`case DSTORE:`
367			`popValue();`
368			`popValue();`
369			`break;`
370			`}`
371			`}`
372			`}`
373
374			`public void visitFieldInsn(`
375			`int opcode,`
376			`String owner,`
377			`String name,`
378			`String desc)`
379			`{`
380			`mv.visitFieldInsn(opcode, owner, name, desc);`
381
382			`if (constructor) {`
383			`char c = desc.charAt(0);`
384			`boolean longOrDouble = c == 'J' \|\| c == 'D';`
385			`switch (opcode) {`
386			`case GETSTATIC:`
387			`pushValue(OTHER);`
388			`if (longOrDouble) {`
389			`pushValue(OTHER);`
390			`}`
391			`break;`
392			`case PUTSTATIC:`
393			`popValue();`
394			`if(longOrDouble) {`
395			`popValue();`
396			`}`
397			`break;`
398			`case PUTFIELD:`
399			`popValue();`
400			`if(longOrDouble) {`
401			`popValue();`
402			`popValue();`
403			`}`
404			`break;`
405			`// case GETFIELD:`
406			`default:`
407			`if (longOrDouble) {`
408			`pushValue(OTHER);`
409			`}`
410			`}`
411			`}`
412			`}`
413
414			`public void visitIntInsn(int opcode, int operand) {`
415			`mv.visitIntInsn(opcode, operand);`
416
417			`if (constructor) {`
418			`switch (opcode) {`
419			`case BIPUSH:`
420			`case SIPUSH:`
421			`pushValue(OTHER);`
422			`}`
423			`}`
424			`}`
425
426			`public void visitLdcInsn(Object cst) {`
427			`mv.visitLdcInsn(cst);`
428
429			`if (constructor) {`
430			`pushValue(OTHER);`
431			`if (cst instanceof Double \|\| cst instanceof Long) {`
432			`pushValue(OTHER);`
433			`}`
434			`}`
435			`}`
436
437			`public void visitMultiANewArrayInsn(String desc, int dims) {`
438			`mv.visitMultiANewArrayInsn(desc, dims);`
439
440			`if (constructor) {`
441			`for (int i = 0; i < dims; i++) {`
442			`popValue();`
443			`}`
444			`pushValue(OTHER);`
445			`}`
446			`}`
447
448			`public void visitTypeInsn(int opcode, String name) {`
449			`mv.visitTypeInsn(opcode, name);`
450
451			`// ANEWARRAY, CHECKCAST or INSTANCEOF don't change stack`
452			`if (constructor && opcode == NEW) {`
453			`pushValue(OTHER);`
454			`}`
455			`}`
456
457			`public void visitMethodInsn(`
458			`int opcode,`
459			`String owner,`
460			`String name,`
461			`String desc)`
462			`{`
463			`mv.visitMethodInsn(opcode, owner, name, desc);`
464
465			`if (constructor) {`
466			`Type[] types = Type.getArgumentTypes(desc);`
467			`for (int i = 0; i < types.length; i++) {`
468			`popValue();`
469			`if (types[i].getSize() == 2) {`
470			`popValue();`
471			`}`
472			`}`
473			`switch (opcode) {`
474			`// case INVOKESTATIC:`
475			`// break;`
476
477			`case INVOKEINTERFACE:`
478			`case INVOKEVIRTUAL:`
479			`popValue(); // objectref`
480			`break;`
481
482			`case INVOKESPECIAL:`
483			`Object type = popValue(); // objectref`
484			`if (type == THIS && !superInitialized) {`
485			`onMethodEnter();`
486			`superInitialized = true;`
487			`// once super has been initialized it is no longer`
488			`// necessary to keep track of stack state`
489			`constructor = false;`
490			`}`
491			`break;`
492			`}`
493
494			`Type returnType = Type.getReturnType(desc);`
495			`if (returnType != Type.VOID_TYPE) {`
496			`pushValue(OTHER);`
497			`if (returnType.getSize() == 2) {`
498			`pushValue(OTHER);`
499			`}`
500			`}`
501			`}`
502			`}`
503
504			`public void visitJumpInsn(int opcode, Label label) {`
505			`mv.visitJumpInsn(opcode, label);`
506
507			`if (constructor) {`
508			`switch (opcode) {`
509			`case IFEQ:`
510			`case IFNE:`
511			`case IFLT:`
512			`case IFGE:`
513			`case IFGT:`
514			`case IFLE:`
515			`case IFNULL:`
516			`case IFNONNULL:`
517			`popValue();`
518			`break;`
519
520			`case IF_ICMPEQ:`
521			`case IF_ICMPNE:`
522			`case IF_ICMPLT:`
523			`case IF_ICMPGE:`
524			`case IF_ICMPGT:`
525			`case IF_ICMPLE:`
526			`case IF_ACMPEQ:`
527			`case IF_ACMPNE:`
528			`popValue();`
529			`popValue();`
530			`break;`
531
532			`case JSR:`
533			`pushValue(OTHER);`
534			`break;`
535			`}`
536			`addBranch(label);`
537			`}`
538			`}`
539
540			`public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) {`
541			`mv.visitLookupSwitchInsn(dflt, keys, labels);`
542
543			`if (constructor) {`
544			`popValue();`
545			`addBranches(dflt, labels);`
546			`}`
547			`}`
548
549			`public void visitTableSwitchInsn(`
550			`int min,`
551			`int max,`
552			`Label dflt,`
553			`Label[] labels)`
554			`{`
555			`mv.visitTableSwitchInsn(min, max, dflt, labels);`
556
557			`if (constructor) {`
558			`popValue();`
559			`addBranches(dflt, labels);`
560			`}`
561			`}`
562
563			`private void addBranches(Label dflt, Label[] labels) {`
564			`addBranch(dflt);`
565			`for (int i = 0; i < labels.length; i++) {`
566			`addBranch(labels[i]);`
567			`}`
568			`}`
569
570			`private void addBranch(Label label) {`
571			`if (branches.containsKey(label)) {`
572			`return;`
573			`}`
574			`ArrayList frame = new ArrayList();`
575			`frame.addAll(stackFrame);`
576			`branches.put(label, frame);`
577			`}`
578
579			`private Object popValue() {`
580			`return stackFrame.remove(stackFrame.size()-1);`
581			`}`
582
583			`private Object peekValue() {`
584			`return stackFrame.get(stackFrame.size()-1);`
585			`}`
586
587			`private void pushValue(Object o) {`
588			`stackFrame.add(o);`
589			`}`
590
591			`/**`
592			`* Called at the beginning of the method or after super`
593			`* class class call in the constructor.`
594			`* <br><br>`
595			`*`
596			`* <i>Custom code can use or change all the local variables,`
597			`* but should not change state of the stack.</i>`
598			`*/`
599			`protected abstract void onMethodEnter();`
600
601			`/**`
602			`* Called before explicit exit from the method using either`
603			`* return or throw. Top element on the stack contains the`
604			`* return value or exception instance. For example:`
605			`*`
606			`* <pre>`
607			`* public void onMethodExit(int opcode) {`
608			`* if(opcode==RETURN) {`
609			`* visitInsn(ACONST_NULL);`
610			`* } else if(opcode==ARETURN \|\| opcode==ATHROW) {`
611			`* dup();`
612			`* } else {`
613			`* if(opcode==LRETURN \|\| opcode==DRETURN) {`
614			`* dup2();`
615			`* } else {`
616			`* dup();`
617			`* }`
618			`* box(Type.getReturnType(this.methodDesc));`
619			`* }`
620			`* visitIntInsn(SIPUSH, opcode);`
621			`* visitMethodInsn(INVOKESTATIC, owner, "onExit", "(Ljava/lang/Object;I)V");`
622			`* }`
623			`*`
624			`* // an actual call back method`
625			`* public static void onExit(int opcode, Object param) {`
626			`* ...`
627			`* </pre>`
628			`*`
629			`* <br><br>`
630			`*`
631			`* <i>Custom code can use or change all the local variables,`
632			`* but should not change state of the stack.</i>`
633			`*`
634			`* @param opcode one of the RETURN, IRETURN, FRETURN,`
635			`* ARETURN, LRETURN, DRETURN or ATHROW`
636			`*`
637			`*/`
638			`protected abstract void onMethodExit(int opcode);`
639
640			`// TODO onException, onMethodCall`
641
642			`}`