diff options
Diffstat (limited to 'src/jvm/clojure/asm/MethodWriter.java')
| -rw-r--r-- | src/jvm/clojure/asm/MethodWriter.java | 3029 |
1 files changed, 3029 insertions, 0 deletions
diff --git a/src/jvm/clojure/asm/MethodWriter.java b/src/jvm/clojure/asm/MethodWriter.java new file mode 100644 index 00000000..19239738 --- /dev/null +++ b/src/jvm/clojure/asm/MethodWriter.java @@ -0,0 +1,3029 @@ +/***
+ * 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 clojure.asm;
+
+/**
+ * A {@link MethodVisitor} that generates methods in bytecode form. Each visit
+ * method of this class appends the bytecode corresponding to the visited
+ * instruction to a byte vector, in the order these methods are called.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+class MethodWriter implements MethodVisitor{
+
+/**
+ * Pseudo access flag used to denote constructors.
+ */
+final static int ACC_CONSTRUCTOR = 262144;
+
+/**
+ * Frame has exactly the same locals as the previous stack map frame and
+ * number of stack items is zero.
+ */
+final static int SAME_FRAME = 0; // to 63 (0-3f)
+
+/**
+ * Frame has exactly the same locals as the previous stack map frame and
+ * number of stack items is 1
+ */
+final static int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; // to 127 (40-7f)
+
+/**
+ * Reserved for future use
+ */
+final static int RESERVED = 128;
+
+/**
+ * Frame has exactly the same locals as the previous stack map frame and
+ * number of stack items is 1. Offset is bigger then 63;
+ */
+final static int SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247; // f7
+
+/**
+ * Frame where current locals are the same as the locals in the previous
+ * frame, except that the k last locals are absent. The value of k is given
+ * by the formula 251-frame_type.
+ */
+final static int CHOP_FRAME = 248; // to 250 (f8-fA)
+
+/**
+ * Frame has exactly the same locals as the previous stack map frame and
+ * number of stack items is zero. Offset is bigger then 63;
+ */
+final static int SAME_FRAME_EXTENDED = 251; // fb
+
+/**
+ * Frame where current locals are the same as the locals in the previous
+ * frame, except that k additional locals are defined. The value of k is
+ * given by the formula frame_type-251.
+ */
+final static int APPEND_FRAME = 252; // to 254 // fc-fe
+
+/**
+ * Full frame
+ */
+final static int FULL_FRAME = 255; // ff
+
+/**
+ * Indicates that the stack map frames must be recomputed from scratch. In
+ * this case the maximum stack size and number of local variables is also
+ * recomputed from scratch.
+ *
+ * @see #compute
+ */
+private final static int FRAMES = 0;
+
+/**
+ * Indicates that the maximum stack size and number of local variables must
+ * be automatically computed.
+ *
+ * @see #compute
+ */
+private final static int MAXS = 1;
+
+/**
+ * Indicates that nothing must be automatically computed.
+ *
+ * @see #compute
+ */
+private final static int NOTHING = 2;
+
+/**
+ * Next method writer (see {@link ClassWriter#firstMethod firstMethod}).
+ */
+MethodWriter next;
+
+/**
+ * The class writer to which this method must be added.
+ */
+ClassWriter cw;
+
+/**
+ * Access flags of this method.
+ */
+private int access;
+
+/**
+ * The index of the constant pool item that contains the name of this
+ * method.
+ */
+private int name;
+
+/**
+ * The index of the constant pool item that contains the descriptor of this
+ * method.
+ */
+private int desc;
+
+/**
+ * The descriptor of this method.
+ */
+private String descriptor;
+
+/**
+ * The signature of this method.
+ */
+String signature;
+
+/**
+ * If not zero, indicates that the code of this method must be copied from
+ * the ClassReader associated to this writer in <code>cw.cr</code>. More
+ * precisely, this field gives the index of the first byte to copied from
+ * <code>cw.cr.b</code>.
+ */
+int classReaderOffset;
+
+/**
+ * If not zero, indicates that the code of this method must be copied from
+ * the ClassReader associated to this writer in <code>cw.cr</code>. More
+ * precisely, this field gives the number of bytes to copied from
+ * <code>cw.cr.b</code>.
+ */
+int classReaderLength;
+
+/**
+ * Number of exceptions that can be thrown by this method.
+ */
+int exceptionCount;
+
+/**
+ * The exceptions that can be thrown by this method. More precisely, this
+ * array contains the indexes of the constant pool items that contain the
+ * internal names of these exception classes.
+ */
+int[] exceptions;
+
+/**
+ * The annotation default attribute of this method. May be <tt>null</tt>.
+ */
+private ByteVector annd;
+
+/**
+ * The runtime visible annotations of this method. May be <tt>null</tt>.
+ */
+private AnnotationWriter anns;
+
+/**
+ * The runtime invisible annotations of this method. May be <tt>null</tt>.
+ */
+private AnnotationWriter ianns;
+
+/**
+ * The runtime visible parameter annotations of this method. May be
+ * <tt>null</tt>.
+ */
+private AnnotationWriter[] panns;
+
+/**
+ * The runtime invisible parameter annotations of this method. May be
+ * <tt>null</tt>.
+ */
+private AnnotationWriter[] ipanns;
+
+/**
+ * The non standard attributes of the method.
+ */
+private Attribute attrs;
+
+/**
+ * The bytecode of this method.
+ */
+private ByteVector code = new ByteVector();
+
+/**
+ * Maximum stack size of this method.
+ */
+private int maxStack;
+
+/**
+ * Maximum number of local variables for this method.
+ */
+private int maxLocals;
+
+/**
+ * Number of stack map frames in the StackMapTable attribute.
+ */
+private int frameCount;
+
+/**
+ * The StackMapTable attribute.
+ */
+private ByteVector stackMap;
+
+/**
+ * The offset of the last frame that was written in the StackMapTable
+ * attribute.
+ */
+private int previousFrameOffset;
+
+/**
+ * The last frame that was written in the StackMapTable attribute.
+ *
+ * @see #frame
+ */
+private int[] previousFrame;
+
+/**
+ * Index of the next element to be added in {@link #frame}.
+ */
+private int frameIndex;
+
+/**
+ * The current stack map frame. The first element contains the offset of the
+ * instruction to which the frame corresponds, the second element is the
+ * number of locals and the third one is the number of stack elements. The
+ * local variables start at index 3 and are followed by the operand stack
+ * values. In summary frame[0] = offset, frame[1] = nLocal, frame[2] =
+ * nStack, frame[3] = nLocal. All types are encoded as integers, with the
+ * same format as the one used in {@link Label}, but limited to BASE types.
+ */
+private int[] frame;
+
+/**
+ * Number of elements in the exception handler list.
+ */
+private int handlerCount;
+
+/**
+ * The first element in the exception handler list.
+ */
+private Handler firstHandler;
+
+/**
+ * The last element in the exception handler list.
+ */
+private Handler lastHandler;
+
+/**
+ * Number of entries in the LocalVariableTable attribute.
+ */
+private int localVarCount;
+
+/**
+ * The LocalVariableTable attribute.
+ */
+private ByteVector localVar;
+
+/**
+ * Number of entries in the LocalVariableTypeTable attribute.
+ */
+private int localVarTypeCount;
+
+/**
+ * The LocalVariableTypeTable attribute.
+ */
+private ByteVector localVarType;
+
+/**
+ * Number of entries in the LineNumberTable attribute.
+ */
+private int lineNumberCount;
+
+/**
+ * The LineNumberTable attribute.
+ */
+private ByteVector lineNumber;
+
+/**
+ * The non standard attributes of the method's code.
+ */
+private Attribute cattrs;
+
+/**
+ * Indicates if some jump instructions are too small and need to be resized.
+ */
+private boolean resize;
+
+/**
+ * Indicates if the instructions contain at least one JSR instruction.
+ */
+private boolean jsr;
+
+// ------------------------------------------------------------------------
+
+/*
+ * Fields for the control flow graph analysis algorithm (used to compute the
+ * maximum stack size). A control flow graph contains one node per "basic
+ * block", and one edge per "jump" from one basic block to another. Each
+ * node (i.e., each basic block) is represented by the Label object that
+ * corresponds to the first instruction of this basic block. Each node also
+ * stores the list of its successors in the graph, as a linked list of Edge
+ * objects.
+ */
+
+/**
+ * Indicates what must be automatically computed.
+ *
+ * @see FRAMES
+ * @see MAXS
+ * @see NOTHING
+ */
+private int compute;
+
+/**
+ * A list of labels. This list is the list of basic blocks in the method,
+ * i.e. a list of Label objects linked to each other by their
+ * {@link Label#successor} field, in the order they are visited by
+ * {@link visitLabel}, and starting with the first basic block.
+ */
+private Label labels;
+
+/**
+ * The previous basic block.
+ */
+private Label previousBlock;
+
+/**
+ * The current basic block.
+ */
+private Label currentBlock;
+
+/**
+ * The (relative) stack size after the last visited instruction. This size
+ * is relative to the beginning of the current basic block, i.e., the true
+ * stack size after the last visited instruction is equal to the
+ * {@link Label#inputStackTop beginStackSize} of the current basic block
+ * plus <tt>stackSize</tt>.
+ */
+private int stackSize;
+
+/**
+ * The (relative) maximum stack size after the last visited instruction.
+ * This size is relative to the beginning of the current basic block, i.e.,
+ * the true maximum stack size after the last visited instruction is equal
+ * to the {@link Label#inputStackTop beginStackSize} of the current basic
+ * block plus <tt>stackSize</tt>.
+ */
+private int maxStackSize;
+
+// ------------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------------
+
+/**
+ * Constructs a new {@link MethodWriter}.
+ *
+ * @param cw the class writer in which the method must be added.
+ * @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}).
+ * @param signature the method's signature. May be <tt>null</tt>.
+ * @param exceptions the internal names of the method's exceptions. May be
+ * <tt>null</tt>.
+ * @param computeMaxs <tt>true</tt> if the maximum stack size and number
+ * of local variables must be automatically computed.
+ * @param computeFrames <tt>true</tt> if the stack map tables must be
+ * recomputed from scratch.
+ */
+MethodWriter(
+ final ClassWriter cw,
+ final int access,
+ final String name,
+ final String desc,
+ final String signature,
+ final String[] exceptions,
+ final boolean computeMaxs,
+ final boolean computeFrames){
+ if(cw.firstMethod == null)
+ {
+ cw.firstMethod = this;
+ }
+ else
+ {
+ cw.lastMethod.next = this;
+ }
+ cw.lastMethod = this;
+ this.cw = cw;
+ this.access = access;
+ this.name = cw.newUTF8(name);
+ this.desc = cw.newUTF8(desc);
+ this.descriptor = desc;
+ this.signature = signature;
+ if(exceptions != null && exceptions.length > 0)
+ {
+ exceptionCount = exceptions.length;
+ this.exceptions = new int[exceptionCount];
+ for(int i = 0; i < exceptionCount; ++i)
+ {
+ this.exceptions[i] = cw.newClass(exceptions[i]);
+ }
+ }
+ this.compute = computeFrames ? FRAMES : (computeMaxs ? MAXS : NOTHING);
+ if(computeMaxs || computeFrames)
+ {
+ if(computeFrames && name.equals("<init>"))
+ {
+ this.access |= ACC_CONSTRUCTOR;
+ }
+ // updates maxLocals
+ int size = getArgumentsAndReturnSizes(descriptor) >> 2;
+ if((access & Opcodes.ACC_STATIC) != 0)
+ {
+ --size;
+ }
+ maxLocals = size;
+ // creates and visits the label for the first basic block
+ labels = new Label();
+ labels.status |= Label.PUSHED;
+ visitLabel(labels);
+ }
+}
+
+// ------------------------------------------------------------------------
+// Implementation of the MethodVisitor interface
+// ------------------------------------------------------------------------
+
+public AnnotationVisitor visitAnnotationDefault(){
+ annd = new ByteVector();
+ return new AnnotationWriter(cw, false, annd, null, 0);
+}
+
+public AnnotationVisitor visitAnnotation(
+ final String desc,
+ final boolean visible){
+ ByteVector bv = new ByteVector();
+ // write type, and reserve space for values count
+ bv.putShort(cw.newUTF8(desc)).putShort(0);
+ AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
+ if(visible)
+ {
+ aw.next = anns;
+ anns = aw;
+ }
+ else
+ {
+ aw.next = ianns;
+ ianns = aw;
+ }
+ return aw;
+}
+
+public AnnotationVisitor visitParameterAnnotation(
+ final int parameter,
+ final String desc,
+ final boolean visible){
+ ByteVector bv = new ByteVector();
+ // write type, and reserve space for values count
+ bv.putShort(cw.newUTF8(desc)).putShort(0);
+ AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
+ if(visible)
+ {
+ if(panns == null)
+ {
+ panns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];
+ }
+ aw.next = panns[parameter];
+ panns[parameter] = aw;
+ }
+ else
+ {
+ if(ipanns == null)
+ {
+ ipanns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];
+ }
+ aw.next = ipanns[parameter];
+ ipanns[parameter] = aw;
+ }
+ return aw;
+}
+
+public void visitAttribute(final Attribute attr){
+ if(attr.isCodeAttribute())
+ {
+ attr.next = cattrs;
+ cattrs = attr;
+ }
+ else
+ {
+ attr.next = attrs;
+ attrs = attr;
+ }
+}
+
+public void visitCode(){
+}
+
+public void visitFrame(
+ final int type,
+ final int nLocal,
+ final Object[] local,
+ final int nStack,
+ final Object[] stack){
+ if(compute == FRAMES)
+ {
+ return;
+ }
+
+ if(type == Opcodes.F_NEW)
+ {
+ startFrame(code.length, nLocal, nStack);
+ for(int i = 0; i < nLocal; ++i)
+ {
+ if(local[i] instanceof String)
+ {
+ frame[frameIndex++] = Frame.OBJECT
+ | cw.addType((String) local[i]);
+ }
+ else if(local[i] instanceof Integer)
+ {
+ frame[frameIndex++] = ((Integer) local[i]).intValue();
+ }
+ else
+ {
+ frame[frameIndex++] = Frame.UNINITIALIZED
+ | cw.addUninitializedType("",
+ ((Label) local[i]).position);
+ }
+ }
+ for(int i = 0; i < nStack; ++i)
+ {
+ if(stack[i] instanceof String)
+ {
+ frame[frameIndex++] = Frame.OBJECT
+ | cw.addType((String) stack[i]);
+ }
+ else if(stack[i] instanceof Integer)
+ {
+ frame[frameIndex++] = ((Integer) stack[i]).intValue();
+ }
+ else
+ {
+ frame[frameIndex++] = Frame.UNINITIALIZED
+ | cw.addUninitializedType("",
+ ((Label) stack[i]).position);
+ }
+ }
+ endFrame();
+ }
+ else
+ {
+ int delta;
+ if(stackMap == null)
+ {
+ stackMap = new ByteVector();
+ delta = code.length;
+ }
+ else
+ {
+ delta = code.length - previousFrameOffset - 1;
+ }
+
+ switch(type)
+ {
+ case Opcodes.F_FULL:
+ stackMap.putByte(FULL_FRAME)
+ .putShort(delta)
+ .putShort(nLocal);
+ for(int i = 0; i < nLocal; ++i)
+ {
+ writeFrameType(local[i]);
+ }
+ stackMap.putShort(nStack);
+ for(int i = 0; i < nStack; ++i)
+ {
+ writeFrameType(stack[i]);
+ }
+ break;
+ case Opcodes.F_APPEND:
+ stackMap.putByte(SAME_FRAME_EXTENDED + nLocal)
+ .putShort(delta);
+ for(int i = 0; i < nLocal; ++i)
+ {
+ writeFrameType(local[i]);
+ }
+ break;
+ case Opcodes.F_CHOP:
+ stackMap.putByte(SAME_FRAME_EXTENDED - nLocal)
+ .putShort(delta);
+ break;
+ case Opcodes.F_SAME:
+ if(delta < 64)
+ {
+ stackMap.putByte(delta);
+ }
+ else
+ {
+ stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
+ }
+ break;
+ case Opcodes.F_SAME1:
+ if(delta < 64)
+ {
+ stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
+ }
+ else
+ {
+ stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
+ .putShort(delta);
+ }
+ writeFrameType(stack[0]);
+ break;
+ }
+
+ previousFrameOffset = code.length;
+ ++frameCount;
+ }
+}
+
+public void visitInsn(final int opcode){
+ // adds the instruction to the bytecode of the method
+ code.putByte(opcode);
+ // update currentBlock
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, 0, null, null);
+ }
+ else
+ {
+ // updates current and max stack sizes
+ int size = stackSize + Frame.SIZE[opcode];
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ // if opcode == ATHROW or xRETURN, ends current block (no successor)
+ if((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
+ || opcode == Opcodes.ATHROW)
+ {
+ noSuccessor();
+ }
+ }
+}
+
+public void visitIntInsn(final int opcode, final int operand){
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, operand, null, null);
+ }
+ else if(opcode != Opcodes.NEWARRAY)
+ {
+ // updates current and max stack sizes only for NEWARRAY
+ // (stack size variation = 0 for BIPUSH or SIPUSH)
+ int size = stackSize + 1;
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ if(opcode == Opcodes.SIPUSH)
+ {
+ code.put12(opcode, operand);
+ }
+ else
+ { // BIPUSH or NEWARRAY
+ code.put11(opcode, operand);
+ }
+}
+
+public void visitVarInsn(final int opcode, final int var){
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, var, null, null);
+ }
+ else
+ {
+ // updates current and max stack sizes
+ if(opcode == Opcodes.RET)
+ {
+ // no stack change, but end of current block (no successor)
+ currentBlock.status |= Label.RET;
+ // save 'stackSize' here for future use
+ // (see {@link #findSubroutineSuccessors})
+ currentBlock.inputStackTop = stackSize;
+ noSuccessor();
+ }
+ else
+ { // xLOAD or xSTORE
+ int size = stackSize + Frame.SIZE[opcode];
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ }
+ }
+ if(compute != NOTHING)
+ {
+ // updates max locals
+ int n;
+ if(opcode == Opcodes.LLOAD || opcode == Opcodes.DLOAD
+ || opcode == Opcodes.LSTORE || opcode == Opcodes.DSTORE)
+ {
+ n = var + 2;
+ }
+ else
+ {
+ n = var + 1;
+ }
+ if(n > maxLocals)
+ {
+ maxLocals = n;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ if(var < 4 && opcode != Opcodes.RET)
+ {
+ int opt;
+ if(opcode < Opcodes.ISTORE)
+ {
+ /* ILOAD_0 */
+ opt = 26 + ((opcode - Opcodes.ILOAD) << 2) + var;
+ }
+ else
+ {
+ /* ISTORE_0 */
+ opt = 59 + ((opcode - Opcodes.ISTORE) << 2) + var;
+ }
+ code.putByte(opt);
+ }
+ else if(var >= 256)
+ {
+ code.putByte(196 /* WIDE */).put12(opcode, var);
+ }
+ else
+ {
+ code.put11(opcode, var);
+ }
+ if(opcode >= Opcodes.ISTORE && compute == FRAMES && handlerCount > 0)
+ {
+ visitLabel(new Label());
+ }
+}
+
+public void visitTypeInsn(final int opcode, final String desc){
+ Item i = cw.newClassItem(desc);
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, code.length, cw, i);
+ }
+ else if(opcode == Opcodes.NEW)
+ {
+ // updates current and max stack sizes only if opcode == NEW
+ // (no stack change for ANEWARRAY, CHECKCAST, INSTANCEOF)
+ int size = stackSize + 1;
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ code.put12(opcode, i.index);
+}
+
+public void visitFieldInsn(
+ final int opcode,
+ final String owner,
+ final String name,
+ final String desc){
+ Item i = cw.newFieldItem(owner, name, desc);
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, 0, cw, i);
+ }
+ else
+ {
+ int size;
+ // computes the stack size variation
+ char c = desc.charAt(0);
+ switch(opcode)
+ {
+ case Opcodes.GETSTATIC:
+ size = stackSize + (c == 'D' || c == 'J' ? 2 : 1);
+ break;
+ case Opcodes.PUTSTATIC:
+ size = stackSize + (c == 'D' || c == 'J' ? -2 : -1);
+ break;
+ case Opcodes.GETFIELD:
+ size = stackSize + (c == 'D' || c == 'J' ? 1 : 0);
+ break;
+ // case Constants.PUTFIELD:
+ default:
+ size = stackSize + (c == 'D' || c == 'J' ? -3 : -2);
+ break;
+ }
+ // updates current and max stack sizes
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ code.put12(opcode, i.index);
+}
+
+public void visitMethodInsn(
+ final int opcode,
+ final String owner,
+ final String name,
+ final String desc){
+ boolean itf = opcode == Opcodes.INVOKEINTERFACE;
+ Item i = cw.newMethodItem(owner, name, desc, itf);
+ int argSize = i.intVal;
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, 0, cw, i);
+ }
+ else
+ {
+ /*
+ * computes the stack size variation. In order not to recompute
+ * several times this variation for the same Item, we use the
+ * intVal field of this item to store this variation, once it
+ * has been computed. More precisely this intVal field stores
+ * the sizes of the arguments and of the return value
+ * corresponding to desc.
+ */
+ if(argSize == 0)
+ {
+ // the above sizes have not been computed yet,
+ // so we compute them...
+ argSize = getArgumentsAndReturnSizes(desc);
+ // ... and we save them in order
+ // not to recompute them in the future
+ i.intVal = argSize;
+ }
+ int size;
+ if(opcode == Opcodes.INVOKESTATIC)
+ {
+ size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;
+ }
+ else
+ {
+ size = stackSize - (argSize >> 2) + (argSize & 0x03);
+ }
+ // updates current and max stack sizes
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ if(itf)
+ {
+ if(argSize == 0)
+ {
+ argSize = getArgumentsAndReturnSizes(desc);
+ i.intVal = argSize;
+ }
+ code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);
+ }
+ else
+ {
+ code.put12(opcode, i.index);
+ }
+}
+
+public void visitJumpInsn(final int opcode, final Label label){
+ Label nextInsn = null;
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(opcode, 0, null, null);
+ // 'label' is the target of a jump instruction
+ label.getFirst().status |= Label.TARGET;
+ // adds 'label' as a successor of this basic block
+ addSuccessor(Edge.NORMAL, label);
+ if(opcode != Opcodes.GOTO)
+ {
+ // creates a Label for the next basic block
+ nextInsn = new Label();
+ }
+ }
+ else
+ {
+ if(opcode == Opcodes.JSR)
+ {
+ jsr = true;
+ currentBlock.status |= Label.JSR;
+ addSuccessor(stackSize + 1, label);
+ // creates a Label for the next basic block
+ nextInsn = new Label();
+ /*
+ * note that, by construction in this method, a JSR block
+ * has at least two successors in the control flow graph:
+ * the first one leads the next instruction after the JSR,
+ * while the second one leads to the JSR target.
+ */
+ }
+ else
+ {
+ // updates current stack size (max stack size unchanged
+ // because stack size variation always negative in this
+ // case)
+ stackSize += Frame.SIZE[opcode];
+ addSuccessor(stackSize, label);
+ }
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ if((label.status & Label.RESOLVED) != 0
+ && label.position - code.length < Short.MIN_VALUE)
+ {
+ /*
+ * case of a backward jump with an offset < -32768. In this case we
+ * automatically replace GOTO with GOTO_W, JSR with JSR_W and IFxxx
+ * <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is the
+ * "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and where <l'>
+ * designates the instruction just after the GOTO_W.
+ */
+ if(opcode == Opcodes.GOTO)
+ {
+ code.putByte(200); // GOTO_W
+ }
+ else if(opcode == Opcodes.JSR)
+ {
+ code.putByte(201); // JSR_W
+ }
+ else
+ {
+ // if the IF instruction is transformed into IFNOT GOTO_W the
+ // next instruction becomes the target of the IFNOT instruction
+ if(nextInsn != null)
+ {
+ nextInsn.status |= Label.TARGET;
+ }
+ code.putByte(opcode <= 166
+ ? ((opcode + 1) ^ 1) - 1
+ : opcode ^ 1);
+ code.putShort(8); // jump offset
+ code.putByte(200); // GOTO_W
+ }
+ label.put(this, code, code.length - 1, true);
+ }
+ else
+ {
+ /*
+ * case of a backward jump with an offset >= -32768, or of a forward
+ * jump with, of course, an unknown offset. In these cases we store
+ * the offset in 2 bytes (which will be increased in
+ * resizeInstructions, if needed).
+ */
+ code.putByte(opcode);
+ label.put(this, code, code.length - 1, false);
+ }
+ if(currentBlock != null)
+ {
+ if(nextInsn != null)
+ {
+ // if the jump instruction is not a GOTO, the next instruction
+ // is also a successor of this instruction. Calling visitLabel
+ // adds the label of this next instruction as a successor of the
+ // current block, and starts a new basic block
+ visitLabel(nextInsn);
+ }
+ if(opcode == Opcodes.GOTO)
+ {
+ noSuccessor();
+ }
+ }
+}
+
+public void visitLabel(final Label label){
+ // resolves previous forward references to label, if any
+ resize |= label.resolve(this, code.length, code.data);
+ // updates currentBlock
+ if((label.status & Label.DEBUG) != 0)
+ {
+ return;
+ }
+ if(compute == FRAMES)
+ {
+ if(currentBlock != null)
+ {
+ if(label.position == currentBlock.position)
+ {
+ // successive labels, do not start a new basic block
+ currentBlock.status |= (label.status & Label.TARGET);
+ label.frame = currentBlock.frame;
+ return;
+ }
+ // ends current block (with one new successor)
+ addSuccessor(Edge.NORMAL, label);
+ }
+ // begins a new current block
+ currentBlock = label;
+ if(label.frame == null)
+ {
+ label.frame = new Frame();
+ label.frame.owner = label;
+ }
+ // updates the basic block list
+ if(previousBlock != null)
+ {
+ if(label.position == previousBlock.position)
+ {
+ previousBlock.status |= (label.status & Label.TARGET);
+ label.frame = previousBlock.frame;
+ currentBlock = previousBlock;
+ return;
+ }
+ previousBlock.successor = label;
+ }
+ previousBlock = label;
+ }
+ else if(compute == MAXS)
+ {
+ if(currentBlock != null)
+ {
+ // ends current block (with one new successor)
+ currentBlock.outputStackMax = maxStackSize;
+ addSuccessor(stackSize, label);
+ }
+ // begins a new current block
+ currentBlock = label;
+ // resets the relative current and max stack sizes
+ stackSize = 0;
+ maxStackSize = 0;
+ // updates the basic block list
+ if(previousBlock != null)
+ {
+ previousBlock.successor = label;
+ }
+ previousBlock = label;
+ }
+}
+
+public void visitLdcInsn(final Object cst){
+ Item i = cw.newConstItem(cst);
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(Opcodes.LDC, 0, cw, i);
+ }
+ else
+ {
+ int size;
+ // computes the stack size variation
+ if(i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE)
+ {
+ size = stackSize + 2;
+ }
+ else
+ {
+ size = stackSize + 1;
+ }
+ // updates current and max stack sizes
+ if(size > maxStackSize)
+ {
+ maxStackSize = size;
+ }
+ stackSize = size;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ int index = i.index;
+ if(i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE)
+ {
+ code.put12(20 /* LDC2_W */, index);
+ }
+ else if(index >= 256)
+ {
+ code.put12(19 /* LDC_W */, index);
+ }
+ else
+ {
+ code.put11(Opcodes.LDC, index);
+ }
+}
+
+public void visitIincInsn(final int var, final int increment){
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(Opcodes.IINC, var, null, null);
+ }
+ }
+ if(compute != NOTHING)
+ {
+ // updates max locals
+ int n = var + 1;
+ if(n > maxLocals)
+ {
+ maxLocals = n;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ if((var > 255) || (increment > 127) || (increment < -128))
+ {
+ code.putByte(196 /* WIDE */)
+ .put12(Opcodes.IINC, var)
+ .putShort(increment);
+ }
+ else
+ {
+ code.putByte(Opcodes.IINC).put11(var, increment);
+ }
+}
+
+public void visitTableSwitchInsn(
+ final int min,
+ final int max,
+ final Label dflt,
+ final Label labels[]){
+ // adds the instruction to the bytecode of the method
+ int source = code.length;
+ code.putByte(Opcodes.TABLESWITCH);
+ code.length += (4 - code.length % 4) % 4;
+ dflt.put(this, code, source, true);
+ code.putInt(min).putInt(max);
+ for(int i = 0; i < labels.length; ++i)
+ {
+ labels[i].put(this, code, source, true);
+ }
+ // updates currentBlock
+ visitSwitchInsn(dflt, labels);
+}
+
+public void visitLookupSwitchInsn(
+ final Label dflt,
+ final int keys[],
+ final Label labels[]){
+ // adds the instruction to the bytecode of the method
+ int source = code.length;
+ code.putByte(Opcodes.LOOKUPSWITCH);
+ code.length += (4 - code.length % 4) % 4;
+ dflt.put(this, code, source, true);
+ code.putInt(labels.length);
+ for(int i = 0; i < labels.length; ++i)
+ {
+ code.putInt(keys[i]);
+ labels[i].put(this, code, source, true);
+ }
+ // updates currentBlock
+ visitSwitchInsn(dflt, labels);
+}
+
+private void visitSwitchInsn(final Label dflt, final Label[] labels){
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(Opcodes.LOOKUPSWITCH, 0, null, null);
+ // adds current block successors
+ addSuccessor(Edge.NORMAL, dflt);
+ dflt.getFirst().status |= Label.TARGET;
+ for(int i = 0; i < labels.length; ++i)
+ {
+ addSuccessor(Edge.NORMAL, labels[i]);
+ labels[i].getFirst().status |= Label.TARGET;
+ }
+ }
+ else
+ {
+ // updates current stack size (max stack size unchanged)
+ --stackSize;
+ // adds current block successors
+ addSuccessor(stackSize, dflt);
+ for(int i = 0; i < labels.length; ++i)
+ {
+ addSuccessor(stackSize, labels[i]);
+ }
+ }
+ // ends current block
+ noSuccessor();
+ }
+}
+
+public void visitMultiANewArrayInsn(final String desc, final int dims){
+ Item i = cw.newClassItem(desc);
+ // Label currentBlock = this.currentBlock;
+ if(currentBlock != null)
+ {
+ if(compute == FRAMES)
+ {
+ currentBlock.frame.execute(Opcodes.MULTIANEWARRAY, dims, cw, i);
+ }
+ else
+ {
+ // updates current stack size (max stack size unchanged because
+ // stack size variation always negative or null)
+ stackSize += 1 - dims;
+ }
+ }
+ // adds the instruction to the bytecode of the method
+ code.put12(Opcodes.MULTIANEWARRAY, i.index).putByte(dims);
+}
+
+public void visitTryCatchBlock(
+ final Label start,
+ final Label end,
+ final Label handler,
+ final String type){
+ ++handlerCount;
+ Handler h = new Handler();
+ h.start = start;
+ h.end = end;
+ h.handler = handler;
+ h.desc = type;
+ h.type = type != null ? cw.newClass(type) : 0;
+ if(lastHandler == null)
+ {
+ firstHandler = h;
+ }
+ else
+ {
+ lastHandler.next = h;
+ }
+ lastHandler = h;
+}
+
+public void visitLocalVariable(
+ final String name,
+ final String desc,
+ final String signature,
+ final Label start,
+ final Label end,
+ final int index){
+ if(signature != null)
+ {
+ if(localVarType == null)
+ {
+ localVarType = new ByteVector();
+ }
+ ++localVarTypeCount;
+ localVarType.putShort(start.position)
+ .putShort(end.position - start.position)
+ .putShort(cw.newUTF8(name))
+ .putShort(cw.newUTF8(signature))
+ .putShort(index);
+ }
+ if(localVar == null)
+ {
+ localVar = new ByteVector();
+ }
+ ++localVarCount;
+ localVar.putShort(start.position)
+ .putShort(end.position - start.position)
+ .putShort(cw.newUTF8(name))
+ .putShort(cw.newUTF8(desc))
+ .putShort(index);
+ if(compute != NOTHING)
+ {
+ // updates max locals
+ char c = desc.charAt(0);
+ int n = index + (c == 'J' || c == 'D' ? 2 : 1);
+ if(n > maxLocals)
+ {
+ maxLocals = n;
+ }
+ }
+}
+
+public void visitLineNumber(final int line, final Label start){
+ if(lineNumber == null)
+ {
+ lineNumber = new ByteVector();
+ }
+ ++lineNumberCount;
+ lineNumber.putShort(start.position);
+ lineNumber.putShort(line);
+}
+
+public void visitMaxs(final int maxStack, final int maxLocals){
+ if(compute == FRAMES)
+ {
+ // completes the control flow graph with exception handler blocks
+ Handler handler = firstHandler;
+ while(handler != null)
+ {
+ Label l = handler.start.getFirst();
+ Label h = handler.handler.getFirst();
+ Label e = handler.end.getFirst();
+ // computes the kind of the edges to 'h'
+ String t = handler.desc == null
+ ? "java/lang/Throwable"
+ : handler.desc;
+ int kind = Frame.OBJECT | cw.addType(t);
+ // h is an exception handler
+ h.status |= Label.TARGET;
+ // adds 'h' as a successor of labels between 'start' and 'end'
+ while(l != e)
+ {
+ // creates an edge to 'h'
+ Edge b = new Edge();
+ b.info = kind;
+ b.successor = h;
+ // adds it to the successors of 'l'
+ b.next = l.successors;
+ l.successors = b;
+ // goes to the next label
+ l = l.successor;
+ }
+ handler = handler.next;
+ }
+
+ // creates and visits the first (implicit) frame
+ Frame f = labels.frame;
+ Type[] args = Type.getArgumentTypes(descriptor);
+ f.initInputFrame(cw, access, args, this.maxLocals);
+ visitFrame(f);
+
+ /*
+ * fix point algorithm: mark the first basic block as 'changed'
+ * (i.e. put it in the 'changed' list) and, while there are changed
+ * basic blocks, choose one, mark it as unchanged, and update its
+ * successors (which can be changed in the process).
+ */
+ int max = 0;
+ Label changed = labels;
+ while(changed != null)
+ {
+ // removes a basic block from the list of changed basic blocks
+ Label l = changed;
+ changed = changed.next;
+ l.next = null;
+ f = l.frame;
+ // a reacheable jump target must be stored in the stack map
+ if((l.status & Label.TARGET) != 0)
+ {
+ l.status |= Label.STORE;
+ }
+ // all visited labels are reacheable, by definition
+ l.status |= Label.REACHABLE;
+ // updates the (absolute) maximum stack size
+ int blockMax = f.inputStack.length + l.outputStackMax;
+ if(blockMax > max)
+ {
+ max = blockMax;
+ }
+ // updates the successors of the current basic block
+ Edge e = l.successors;
+ while(e != null)
+ {
+ Label n = e.successor.getFirst();
+ boolean change = f.merge(cw, n.frame, e.info);
+ if(change && n.next == null)
+ {
+ // if n has changed and is not already in the 'changed'
+ // list, adds it to this list
+ n.next = changed;
+ changed = n;
+ }
+ e = e.next;
+ }
+ }
+ this.maxStack = max;
+
+ // visits all the frames that must be stored in the stack map
+ Label l = labels;
+ while(l != null)
+ {
+ f = l.frame;
+ if((l.status & Label.STORE) != 0)
+ {
+ visitFrame(f);
+ }
+ if((l.status & Label.REACHABLE) == 0)
+ {
+ // finds start and end of dead basic block
+ Label k = l.successor;
+ int start = l.position;
+ int end = (k == null ? code.length : k.position) - 1;
+ // if non empty basic block
+ if(end >= start)
+ {
+ // replaces instructions with NOP ... NOP ATHROW
+ for(int i = start; i < end; ++i)
+ {
+ code.data[i] = Opcodes.NOP;
+ }
+ code.data[end] = (byte) Opcodes.ATHROW;
+ // emits a frame for this unreachable block
+ startFrame(start, 0, 1);
+ frame[frameIndex++] = Frame.OBJECT
+ | cw.addType("java/lang/Throwable");
+ endFrame();
+ }
+ }
+ l = l.successor;
+ }
+ }
+ else if(compute == MAXS)
+ {
+ // completes the control flow graph with exception handler blocks
+ Handler handler = firstHandler;
+ while(handler != null)
+ {
+ Label l = handler.start;
+ Label h = handler.handler;
+ Label e = handler.end;
+ // adds 'h' as a successor of labels between 'start' and 'end'
+ while(l != e)
+ {
+ // creates an edge to 'h'
+ Edge b = new Edge();
+ b.info = Edge.EXCEPTION;
+ b.successor = h;
+ // adds it to the successors of 'l'
+ if((l.status & Label.JSR) != 0)
+ {
+ // if l is a JSR block, adds b after the first two edges
+ // to preserve the hypothesis about JSR block successors
+ // order (see {@link #visitJumpInsn})
+ b.next = l.successors.next.next;
+ l.successors.next.next = b;
+ }
+ else
+ {
+ b.next = l.successors;
+ l.successors = b;
+ }
+ // goes to the next label
+ l = l.successor;
+ }
+ handler = handler.next;
+ }
+
+ if(jsr)
+ {
+ // completes the control flow graph with the RET successors
+ /*
+ * first step: finds the subroutines. This step determines, for
+ * each basic block, to which subroutine(s) it belongs, and
+ * stores this set as a bit set in the {@link Label#status}
+ * field. Subroutines are numbered with powers of two, from
+ * 0x1000 to 0x80000000 (so there must be at most 20 subroutines
+ * in a method).
+ */
+ // finds the basic blocks that belong to the "main" subroutine
+ int id = 0x1000;
+ findSubroutine(labels, id);
+ // finds the basic blocks that belong to the real subroutines
+ Label l = labels;
+ while(l != null)
+ {
+ if((l.status & Label.JSR) != 0)
+ {
+ // the subroutine is defined by l's TARGET, not by l
+ Label subroutine = l.successors.next.successor;
+ // if this subroutine does not have an id yet...
+ if((subroutine.status & ~0xFFF) == 0)
+ {
+ // ...assigns it a new id and finds its basic blocks
+ id = id << 1;
+ findSubroutine(subroutine, id);
+ }
+ }
+ l = l.successor;
+ }
+ // second step: finds the successors of RET blocks
+ findSubroutineSuccessors(0x1000, new Label[10], 0);
+ }
+
+ /*
+ * control flow analysis algorithm: while the block stack is not
+ * empty, pop a block from this stack, update the max stack size,
+ * compute the true (non relative) begin stack size of the
+ * successors of this block, and push these successors onto the
+ * stack (unless they have already been pushed onto the stack).
+ * Note: by hypothesis, the {@link Label#inputStackTop} of the
+ * blocks in the block stack are the true (non relative) beginning
+ * stack sizes of these blocks.
+ */
+ int max = 0;
+ Label stack = labels;
+ while(stack != null)
+ {
+ // pops a block from the stack
+ Label l = stack;
+ stack = stack.next;
+ // computes the true (non relative) max stack size of this block
+ int start = l.inputStackTop;
+ int blockMax = start + l.outputStackMax;
+ // updates the global max stack size
+ if(blockMax > max)
+ {
+ max = blockMax;
+ }
+ // analyses the successors of the block
+ Edge b = l.successors;
+ if((l.status & Label.JSR) != 0)
+ {
+ // ignores the first edge of JSR blocks (virtual successor)
+ b = b.next;
+ }
+ while(b != null)
+ {
+ l = b.successor;
+ // if this successor has not already been pushed...
+ if((l.status & Label.PUSHED) == 0)
+ {
+ // computes its true beginning stack size...
+ l.inputStackTop = b.info == Edge.EXCEPTION ? 1 : start
+ + b.info;
+ // ...and pushes it onto the stack
+ l.status |= Label.PUSHED;
+ l.next = stack;
+ stack = l;
+ }
+ b = b.next;
+ }
+ }
+ this.maxStack = max;
+ }
+ else
+ {
+ this.maxStack = maxStack;
+ this.maxLocals = maxLocals;
+ }
+}
+
+public void visitEnd(){
+}
+
+// ------------------------------------------------------------------------
+// Utility methods: control flow analysis algorithm
+// ------------------------------------------------------------------------
+
+/**
+ * Computes the size of the arguments and of the return value of a method.
+ *
+ * @param desc the descriptor of a method.
+ * @return the size of the arguments of the method (plus one for the
+ * implicit this argument), argSize, and the size of its return
+ * value, retSize, packed into a single int i =
+ * <tt>(argSize << 2) | retSize</tt> (argSize is therefore equal
+ * to <tt>i >> 2</tt>, and retSize to <tt>i & 0x03</tt>).
+ */
+static int getArgumentsAndReturnSizes(final String desc){
+ int n = 1;
+ int c = 1;
+ while(true)
+ {
+ char car = desc.charAt(c++);
+ if(car == ')')
+ {
+ car = desc.charAt(c);
+ return n << 2
+ | (car == 'V' ? 0 : (car == 'D' || car == 'J' ? 2 : 1));
+ }
+ else if(car == 'L')
+ {
+ while(desc.charAt(c++) != ';')
+ {
+ }
+ n += 1;
+ }
+ else if(car == '[')
+ {
+ while((car = desc.charAt(c)) == '[')
+ {
+ ++c;
+ }
+ if(car == 'D' || car == 'J')
+ {
+ n -= 1;
+ }
+ }
+ else if(car == 'D' || car == 'J')
+ {
+ n += 2;
+ }
+ else
+ {
+ n += 1;
+ }
+ }
+}
+
+/**
+ * Adds a successor to the {@link #currentBlock currentBlock} block.
+ *
+ * @param info information about the control flow edge to be added.
+ * @param successor the successor block to be added to the current block.
+ */
+private void addSuccessor(final int info, final Label successor){
+ // creates and initializes an Edge object...
+ Edge b = new Edge();
+ b.info = info;
+ b.successor = successor;
+ // ...and adds it to the successor list of the currentBlock block
+ b.next = currentBlock.successors;
+ currentBlock.successors = b;
+}
+
+/**
+ * Ends the current basic block. This method must be used in the case where
+ * the current basic block does not have any successor.
+ */
+private void noSuccessor(){
+ if(compute == FRAMES)
+ {
+ Label l = new Label();
+ l.frame = new Frame();
+ l.frame.owner = l;
+ l.resolve(this, code.length, code.data);
+ previousBlock.successor = l;
+ previousBlock = l;
+ }
+ else
+ {
+ currentBlock.outputStackMax = maxStackSize;
+ }
+ currentBlock = null;
+}
+
+/**
+ * Finds the basic blocks that belong to a given subroutine, and marks these
+ * blocks as belonging to this subroutine (by using {@link Label#status} as
+ * a bit set (see {@link #visitMaxs}). This recursive method follows the
+ * control flow graph to find all the blocks that are reachable from the
+ * given block WITHOUT following any JSR target.
+ *
+ * @param block a block that belongs to the subroutine
+ * @param id the id of this subroutine
+ */
+private void findSubroutine(final Label block, final int id){
+ // if 'block' is already marked as belonging to subroutine 'id', returns
+ if((block.status & id) != 0)
+ {
+ return;
+ }
+ // marks 'block' as belonging to subroutine 'id'
+ block.status |= id;
+ // calls this method recursively on each successor, except JSR targets
+ Edge e = block.successors;
+ while(e != null)
+ {
+ // if 'block' is a JSR block, then 'block.successors.next' leads
+ // to the JSR target (see {@link #visitJumpInsn}) and must therefore
+ // not be followed
+ if((block.status & Label.JSR) == 0 || e != block.successors.next)
+ {
+ findSubroutine(e.successor, id);
+ }
+ e = e.next;
+ }
+}
+
+/**
+ * Finds the successors of the RET blocks of the specified subroutine, and
+ * of any nested subroutine it calls.
+ *
+ * @param id id of the subroutine whose RET block successors must be found.
+ * @param JSRs the JSR blocks that were followed to reach this subroutine.
+ * @param nJSRs number of JSR blocks in the JSRs array.
+ */
+private void findSubroutineSuccessors(
+ final int id,
+ final Label[] JSRs,
+ final int nJSRs){
+ // iterates over all the basic blocks...
+ Label l = labels;
+ while(l != null)
+ {
+ // for those that belong to subroutine 'id'...
+ if((l.status & id) != 0)
+ {
+ if((l.status & Label.JSR) != 0)
+ {
+ // finds the subroutine to which 'l' leads by following the
+ // second edge of l.successors (see {@link #visitJumpInsn})
+ int nId = l.successors.next.successor.status & ~0xFFF;
+ if(nId != id)
+ {
+ // calls this method recursively with l pushed onto the
+ // JSRs stack to find the successors of the RET blocks
+ // of this nested subroutine 'nId'
+ JSRs[nJSRs] = l;
+ findSubroutineSuccessors(nId, JSRs, nJSRs + 1);
+ }
+ }
+ else if((l.status & Label.RET) != 0)
+ {
+ /*
+ * finds the JSR block in the JSRs stack that corresponds to
+ * this RET block, and updates the successors of this RET
+ * block accordingly. This corresponding JSR is the one that
+ * leads to the subroutine to which the RET block belongs.
+ * But the RET block can belong to several subroutines (if a
+ * nested subroutine returns to its parent subroutine
+ * implicitely, without a RET). So, in fact, the JSR that
+ * corresponds to this RET is the first block in the JSRs
+ * stack, starting from the bottom of the stack, that leads
+ * to a subroutine to which the RET block belongs.
+ */
+ for(int i = 0; i < nJSRs; ++i)
+ {
+ int JSRstatus = JSRs[i].successors.next.successor.status;
+ if(((JSRstatus & ~0xFFF) & (l.status & ~0xFFF)) != 0)
+ {
+ Edge e = new Edge();
+ e.info = l.inputStackTop;
+ e.successor = JSRs[i].successors.successor;
+ e.next = l.successors;
+ l.successors = e;
+ break;
+ }
+ }
+ }
+ }
+ l = l.successor;
+ }
+}
+
+// ------------------------------------------------------------------------
+// Utility methods: stack map frames
+// ------------------------------------------------------------------------
+
+/**
+ * Visits a frame that has been computed from scratch.
+ *
+ * @param f the frame that must be visited.
+ */
+private void visitFrame(final Frame f){
+ int i, t;
+ int nTop = 0;
+ int nLocal = 0;
+ int nStack = 0;
+ int[] locals = f.inputLocals;
+ int[] stacks = f.inputStack;
+ // computes the number of locals (ignores TOP types that are just after
+ // a LONG or a DOUBLE, and all trailing TOP types)
+ for(i = 0; i < locals.length; ++i)
+ {
+ t = locals[i];
+ if(t == Frame.TOP)
+ {
+ ++nTop;
+ }
+ else
+ {
+ nLocal += nTop + 1;
+ nTop = 0;
+ }
+ if(t == Frame.LONG || t == Frame.DOUBLE)
+ {
+ ++i;
+ }
+ }
+ // computes the stack size (ignores TOP types that are just after
+ // a LONG or a DOUBLE)
+ for(i = 0; i < stacks.length; ++i)
+ {
+ t = stacks[i];
+ ++nStack;
+ if(t == Frame.LONG || t == Frame.DOUBLE)
+ {
+ ++i;
+ }
+ }
+ // visits the frame and its content
+ startFrame(f.owner.position, nLocal, nStack);
+ for(i = 0; nLocal > 0; ++i, --nLocal)
+ {
+ t = locals[i];
+ frame[frameIndex++] = t;
+ if(t == Frame.LONG || t == Frame.DOUBLE)
+ {
+ ++i;
+ }
+ }
+ for(i = 0; i < stacks.length; ++i)
+ {
+ t = stacks[i];
+ frame[frameIndex++] = t;
+ if(t == Frame.LONG || t == Frame.DOUBLE)
+ {
+ ++i;
+ }
+ }
+ endFrame();
+}
+
+/**
+ * Starts the visit of a stack map frame.
+ *
+ * @param offset the offset of the instruction to which the frame
+ * corresponds.
+ * @param nLocal the number of local variables in the frame.
+ * @param nStack the number of stack elements in the frame.
+ */
+private void startFrame(final int offset, final int nLocal, final int nStack){
+ int n = 3 + nLocal + nStack;
+ if(frame == null || frame.length < n)
+ {
+ frame = new int[n];
+ }
+ frame[0] = offset;
+ frame[1] = nLocal;
+ frame[2] = nStack;
+ frameIndex = 3;
+}
+
+/**
+ * Checks if the visit of the current frame {@link #frame} is finished, and
+ * if yes, write it in the StackMapTable attribute.
+ */
+private void endFrame(){
+ if(previousFrame != null)
+ { // do not write the first frame
+ if(stackMap == null)
+ {
+ stackMap = new ByteVector();
+ }
+ writeFrame();
+ ++frameCount;
+ }
+ previousFrame = frame;
+ frame = null;
+}
+
+/**
+ * Compress and writes the current frame {@link #frame} in the StackMapTable
+ * attribute.
+ */
+private void writeFrame(){
+ int clocalsSize = frame[1];
+ int cstackSize = frame[2];
+ if((cw.version & 0xFFFF) < Opcodes.V1_6)
+ {
+ stackMap.putShort(frame[0]).putShort(clocalsSize);
+ writeFrameTypes(3, 3 + clocalsSize);
+ stackMap.putShort(cstackSize);
+ writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
+ return;
+ }
+ int localsSize = previousFrame[1];
+ int type = FULL_FRAME;
+ int k = 0;
+ int delta;
+ if(frameCount == 0)
+ {
+ delta = frame[0];
+ }
+ else
+ {
+ delta = frame[0] - previousFrame[0] - 1;
+ }
+ if(cstackSize == 0)
+ {
+ k = clocalsSize - localsSize;
+ switch(k)
+ {
+ case-3:
+ case-2:
+ case-1:
+ type = CHOP_FRAME;
+ localsSize = clocalsSize;
+ break;
+ case 0:
+ type = delta < 64 ? SAME_FRAME : SAME_FRAME_EXTENDED;
+ break;
+ case 1:
+ case 2:
+ case 3:
+ type = APPEND_FRAME;
+ break;
+ }
+ }
+ else if(clocalsSize == localsSize && cstackSize == 1)
+ {
+ type = delta < 63
+ ? SAME_LOCALS_1_STACK_ITEM_FRAME
+ : SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED;
+ }
+ if(type != FULL_FRAME)
+ {
+ // verify if locals are the same
+ int l = 3;
+ for(int j = 0; j < localsSize; j++)
+ {
+ if(frame[l] != previousFrame[l])
+ {
+ type = FULL_FRAME;
+ break;
+ }
+ l++;
+ }
+ }
+ switch(type)
+ {
+ case SAME_FRAME:
+ stackMap.putByte(delta);
+ break;
+ case SAME_LOCALS_1_STACK_ITEM_FRAME:
+ stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);
+ writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
+ break;
+ case SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED:
+ stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
+ .putShort(delta);
+ writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);
+ break;
+ case SAME_FRAME_EXTENDED:
+ stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);
+ break;
+ case CHOP_FRAME:
+ stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
+ break;
+ case APPEND_FRAME:
+ stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);
+ writeFrameTypes(3 + localsSize, 3 + clocalsSize);
+ break;
+ // case FULL_FRAME:
+ default:
+ stackMap.putByte(FULL_FRAME)
+ .putShort(delta)
+ .putShort(clocalsSize);
+ writeFrameTypes(3, 3 + clocalsSize);
+ stackMap.putShort(cstackSize);
+ writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);
+ }
+}
+
+/**
+ * Writes some types of the current frame {@link #frame} into the
+ * StackMapTableAttribute. This method converts types from the format used
+ * in {@link Label} to the format used in StackMapTable attributes. In
+ * particular, it converts type table indexes to constant pool indexes.
+ *
+ * @param start index of the first type in {@link #frame} to write.
+ * @param end index of last type in {@link #frame} to write (exclusive).
+ */
+private void writeFrameTypes(final int start, final int end){
+ for(int i = start; i < end; ++i)
+ {
+ int t = frame[i];
+ int d = t & Frame.DIM;
+ if(d == 0)
+ {
+ int v = t & Frame.BASE_VALUE;
+ switch(t & Frame.BASE_KIND)
+ {
+ case Frame.OBJECT:
+ stackMap.putByte(7)
+ .putShort(cw.newClass(cw.typeTable[v].strVal1));
+ break;
+ case Frame.UNINITIALIZED:
+ stackMap.putByte(8).putShort(cw.typeTable[v].intVal);
+ break;
+ default:
+ stackMap.putByte(v);
+ }
+ }
+ else
+ {
+ StringBuffer buf = new StringBuffer();
+ d >>= 28;
+ while(d-- > 0)
+ {
+ buf.append('[');
+ }
+ if((t & Frame.BASE_KIND) == Frame.OBJECT)
+ {
+ buf.append('L');
+ buf.append(cw.typeTable[t & Frame.BASE_VALUE].strVal1);
+ buf.append(';');
+ }
+ else
+ {
+ switch(t & 0xF)
+ {
+ case 1:
+ buf.append('I');
+ break;
+ case 2:
+ buf.append('F');
+ break;
+ case 3:
+ buf.append('D');
+ break;
+ case 9:
+ buf.append('Z');
+ break;
+ case 10:
+ buf.append('B');
+ break;
+ case 11:
+ buf.append('C');
+ break;
+ case 12:
+ buf.append('S');
+ break;
+ default:
+ buf.append('J');
+ }
+ }
+ stackMap.putByte(7).putShort(cw.newClass(buf.toString()));
+ }
+ }
+}
+
+private void writeFrameType(final Object type){
+ if(type instanceof String)
+ {
+ stackMap.putByte(7).putShort(cw.newClass((String) type));
+ }
+ else if(type instanceof Integer)
+ {
+ stackMap.putByte(((Integer) type).intValue());
+ }
+ else
+ {
+ stackMap.putByte(8).putShort(((Label) type).position);
+ }
+}
+
+// ------------------------------------------------------------------------
+// Utility methods: dump bytecode array
+// ------------------------------------------------------------------------
+
+/**
+ * Returns the size of the bytecode of this method.
+ *
+ * @return the size of the bytecode of this method.
+ */
+final int getSize(){
+ if(classReaderOffset != 0)
+ {
+ return 6 + classReaderLength;
+ }
+ if(resize)
+ {
+ // replaces the temporary jump opcodes introduced by Label.resolve.
+ resizeInstructions();
+ }
+ int size = 8;
+ if(code.length > 0)
+ {
+ cw.newUTF8("Code");
+ size += 18 + code.length + 8 * handlerCount;
+ if(localVar != null)
+ {
+ cw.newUTF8("LocalVariableTable");
+ size += 8 + localVar.length;
+ }
+ if(localVarType != null)
+ {
+ cw.newUTF8("LocalVariableTypeTable");
+ size += 8 + localVarType.length;
+ }
+ if(lineNumber != null)
+ {
+ cw.newUTF8("LineNumberTable");
+ size += 8 + lineNumber.length;
+ }
+ if(stackMap != null)
+ {
+ boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
+ cw.newUTF8(zip ? "StackMapTable" : "StackMap");
+ size += 8 + stackMap.length;
+ }
+ if(cattrs != null)
+ {
+ size += cattrs.getSize(cw,
+ code.data,
+ code.length,
+ maxStack,
+ maxLocals);
+ }
+ }
+ if(exceptionCount > 0)
+ {
+ cw.newUTF8("Exceptions");
+ size += 8 + 2 * exceptionCount;
+ }
+ if((access & Opcodes.ACC_SYNTHETIC) != 0
+ && (cw.version & 0xffff) < Opcodes.V1_5)
+ {
+ cw.newUTF8("Synthetic");
+ size += 6;
+ }
+ if((access & Opcodes.ACC_DEPRECATED) != 0)
+ {
+ cw.newUTF8("Deprecated");
+ size += 6;
+ }
+ if(signature != null)
+ {
+ cw.newUTF8("Signature");
+ cw.newUTF8(signature);
+ size += 8;
+ }
+ if(annd != null)
+ {
+ cw.newUTF8("AnnotationDefault");
+ size += 6 + annd.length;
+ }
+ if(anns != null)
+ {
+ cw.newUTF8("RuntimeVisibleAnnotations");
+ size += 8 + anns.getSize();
+ }
+ if(ianns != null)
+ {
+ cw.newUTF8("RuntimeInvisibleAnnotations");
+ size += 8 + ianns.getSize();
+ }
+ if(panns != null)
+ {
+ cw.newUTF8("RuntimeVisibleParameterAnnotations");
+ size += 7 + 2 * panns.length;
+ for(int i = panns.length - 1; i >= 0; --i)
+ {
+ size += panns[i] == null ? 0 : panns[i].getSize();
+ }
+ }
+ if(ipanns != null)
+ {
+ cw.newUTF8("RuntimeInvisibleParameterAnnotations");
+ size += 7 + 2 * ipanns.length;
+ for(int i = ipanns.length - 1; i >= 0; --i)
+ {
+ size += ipanns[i] == null ? 0 : ipanns[i].getSize();
+ }
+ }
+ if(attrs != null)
+ {
+ size += attrs.getSize(cw, null, 0, -1, -1);
+ }
+ return size;
+}
+
+/**
+ * Puts the bytecode of this method in the given byte vector.
+ *
+ * @param out the byte vector into which the bytecode of this method must be
+ * copied.
+ */
+final void put(final ByteVector out){
+ out.putShort(access).putShort(name).putShort(desc);
+ if(classReaderOffset != 0)
+ {
+ out.putByteArray(cw.cr.b, classReaderOffset, classReaderLength);
+ return;
+ }
+ int attributeCount = 0;
+ if(code.length > 0)
+ {
+ ++attributeCount;
+ }
+ if(exceptionCount > 0)
+ {
+ ++attributeCount;
+ }
+ if((access & Opcodes.ACC_SYNTHETIC) != 0
+ && (cw.version & 0xffff) < Opcodes.V1_5)
+ {
+ ++attributeCount;
+ }
+ if((access & Opcodes.ACC_DEPRECATED) != 0)
+ {
+ ++attributeCount;
+ }
+ if(signature != null)
+ {
+ ++attributeCount;
+ }
+ if(annd != null)
+ {
+ ++attributeCount;
+ }
+ if(anns != null)
+ {
+ ++attributeCount;
+ }
+ if(ianns != null)
+ {
+ ++attributeCount;
+ }
+ if(panns != null)
+ {
+ ++attributeCount;
+ }
+ if(ipanns != null)
+ {
+ ++attributeCount;
+ }
+ if(attrs != null)
+ {
+ attributeCount += attrs.getCount();
+ }
+ out.putShort(attributeCount);
+ if(code.length > 0)
+ {
+ int size = 12 + code.length + 8 * handlerCount;
+ if(localVar != null)
+ {
+ size += 8 + localVar.length;
+ }
+ if(localVarType != null)
+ {
+ size += 8 + localVarType.length;
+ }
+ if(lineNumber != null)
+ {
+ size += 8 + lineNumber.length;
+ }
+ if(stackMap != null)
+ {
+ size += 8 + stackMap.length;
+ }
+ if(cattrs != null)
+ {
+ size += cattrs.getSize(cw,
+ code.data,
+ code.length,
+ maxStack,
+ maxLocals);
+ }
+ out.putShort(cw.newUTF8("Code")).putInt(size);
+ out.putShort(maxStack).putShort(maxLocals);
+ out.putInt(code.length).putByteArray(code.data, 0, code.length);
+ out.putShort(handlerCount);
+ if(handlerCount > 0)
+ {
+ Handler h = firstHandler;
+ while(h != null)
+ {
+ out.putShort(h.start.position)
+ .putShort(h.end.position)
+ .putShort(h.handler.position)
+ .putShort(h.type);
+ h = h.next;
+ }
+ }
+ attributeCount = 0;
+ if(localVar != null)
+ {
+ ++attributeCount;
+ }
+ if(localVarType != null)
+ {
+ ++attributeCount;
+ }
+ if(lineNumber != null)
+ {
+ ++attributeCount;
+ }
+ if(stackMap != null)
+ {
+ ++attributeCount;
+ }
+ if(cattrs != null)
+ {
+ attributeCount += cattrs.getCount();
+ }
+ out.putShort(attributeCount);
+ if(localVar != null)
+ {
+ out.putShort(cw.newUTF8("LocalVariableTable"));
+ out.putInt(localVar.length + 2).putShort(localVarCount);
+ out.putByteArray(localVar.data, 0, localVar.length);
+ }
+ if(localVarType != null)
+ {
+ out.putShort(cw.newUTF8("LocalVariableTypeTable"));
+ out.putInt(localVarType.length + 2).putShort(localVarTypeCount);
+ out.putByteArray(localVarType.data, 0, localVarType.length);
+ }
+ if(lineNumber != null)
+ {
+ out.putShort(cw.newUTF8("LineNumberTable"));
+ out.putInt(lineNumber.length + 2).putShort(lineNumberCount);
+ out.putByteArray(lineNumber.data, 0, lineNumber.length);
+ }
+ if(stackMap != null)
+ {
+ boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;
+ out.putShort(cw.newUTF8(zip ? "StackMapTable" : "StackMap"));
+ out.putInt(stackMap.length + 2).putShort(frameCount);
+ out.putByteArray(stackMap.data, 0, stackMap.length);
+ }
+ if(cattrs != null)
+ {
+ cattrs.put(cw, code.data, code.length, maxLocals, maxStack, out);
+ }
+ }
+ if(exceptionCount > 0)
+ {
+ out.putShort(cw.newUTF8("Exceptions"))
+ .putInt(2 * exceptionCount + 2);
+ out.putShort(exceptionCount);
+ for(int i = 0; i < exceptionCount; ++i)
+ {
+ out.putShort(exceptions[i]);
+ }
+ }
+ if((access & Opcodes.ACC_SYNTHETIC) != 0
+ && (cw.version & 0xffff) < Opcodes.V1_5)
+ {
+ out.putShort(cw.newUTF8("Synthetic")).putInt(0);
+ }
+ if((access & Opcodes.ACC_DEPRECATED) != 0)
+ {
+ out.putShort(cw.newUTF8("Deprecated")).putInt(0);
+ }
+ if(signature != null)
+ {
+ out.putShort(cw.newUTF8("Signature"))
+ .putInt(2)
+ .putShort(cw.newUTF8(signature));
+ }
+ if(annd != null)
+ {
+ out.putShort(cw.newUTF8("AnnotationDefault"));
+ out.putInt(annd.length);
+ out.putByteArray(annd.data, 0, annd.length);
+ }
+ if(anns != null)
+ {
+ out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));
+ anns.put(out);
+ }
+ if(ianns != null)
+ {
+ out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));
+ ianns.put(out);
+ }
+ if(panns != null)
+ {
+ out.putShort(cw.newUTF8("RuntimeVisibleParameterAnnotations"));
+ AnnotationWriter.put(panns, out);
+ }
+ if(ipanns != null)
+ {
+ out.putShort(cw.newUTF8("RuntimeInvisibleParameterAnnotations"));
+ AnnotationWriter.put(ipanns, out);
+ }
+ if(attrs != null)
+ {
+ attrs.put(cw, null, 0, -1, -1, out);
+ }
+}
+
+// ------------------------------------------------------------------------
+// Utility methods: instruction resizing (used to handle GOTO_W and JSR_W)
+// ------------------------------------------------------------------------
+
+/**
+ * Resizes and replaces the temporary instructions inserted by
+ * {@link Label#resolve} for wide forward jumps, while keeping jump offsets
+ * and instruction addresses consistent. This may require to resize other
+ * existing instructions, or even to introduce new instructions: for
+ * example, increasing the size of an instruction by 2 at the middle of a
+ * method can increases the offset of an IFEQ instruction from 32766 to
+ * 32768, in which case IFEQ 32766 must be replaced with IFNEQ 8 GOTO_W
+ * 32765. This, in turn, may require to increase the size of another jump
+ * instruction, and so on... All these operations are handled automatically
+ * by this method. <p> <i>This method must be called after all the method
+ * that is being built has been visited</i>. In particular, the
+ * {@link Label Label} objects used to construct the method are no longer
+ * valid after this method has been called.
+ */
+private void resizeInstructions(){
+ byte[] b = code.data; // bytecode of the method
+ int u, v, label; // indexes in b
+ int i, j; // loop indexes
+ /*
+ * 1st step: As explained above, resizing an instruction may require to
+ * resize another one, which may require to resize yet another one, and
+ * so on. The first step of the algorithm consists in finding all the
+ * instructions that need to be resized, without modifying the code.
+ * This is done by the following "fix point" algorithm:
+ *
+ * Parse the code to find the jump instructions whose offset will need
+ * more than 2 bytes to be stored (the future offset is computed from
+ * the current offset and from the number of bytes that will be inserted
+ * or removed between the source and target instructions). For each such
+ * instruction, adds an entry in (a copy of) the indexes and sizes
+ * arrays (if this has not already been done in a previous iteration!).
+ *
+ * If at least one entry has been added during the previous step, go
+ * back to the beginning, otherwise stop.
+ *
+ * In fact the real algorithm is complicated by the fact that the size
+ * of TABLESWITCH and LOOKUPSWITCH instructions depends on their
+ * position in the bytecode (because of padding). In order to ensure the
+ * convergence of the algorithm, the number of bytes to be added or
+ * removed from these instructions is over estimated during the previous
+ * loop, and computed exactly only after the loop is finished (this
+ * requires another pass to parse the bytecode of the method).
+ */
+ int[] allIndexes = new int[0]; // copy of indexes
+ int[] allSizes = new int[0]; // copy of sizes
+ boolean[] resize; // instructions to be resized
+ int newOffset; // future offset of a jump instruction
+
+ resize = new boolean[code.length];
+
+ // 3 = loop again, 2 = loop ended, 1 = last pass, 0 = done
+ int state = 3;
+ do
+ {
+ if(state == 3)
+ {
+ state = 2;
+ }
+ u = 0;
+ while(u < b.length)
+ {
+ int opcode = b[u] & 0xFF; // opcode of current instruction
+ int insert = 0; // bytes to be added after this instruction
+
+ switch(ClassWriter.TYPE[opcode])
+ {
+ case ClassWriter.NOARG_INSN:
+ case ClassWriter.IMPLVAR_INSN:
+ u += 1;
+ break;
+ case ClassWriter.LABEL_INSN:
+ if(opcode > 201)
+ {
+ // converts temporary opcodes 202 to 217, 218 and
+ // 219 to IFEQ ... JSR (inclusive), IFNULL and
+ // IFNONNULL
+ opcode = opcode < 218 ? opcode - 49 : opcode - 20;
+ label = u + readUnsignedShort(b, u + 1);
+ }
+ else
+ {
+ label = u + readShort(b, u + 1);
+ }
+ newOffset = getNewOffset(allIndexes, allSizes, u, label);
+ if(newOffset < Short.MIN_VALUE
+ || newOffset > Short.MAX_VALUE)
+ {
+ if(!resize[u])
+ {
+ if(opcode == Opcodes.GOTO
+ || opcode == Opcodes.JSR)
+ {
+ // two additional bytes will be required to
+ // replace this GOTO or JSR instruction with
+ // a GOTO_W or a JSR_W
+ insert = 2;
+ }
+ else
+ {
+ // five additional bytes will be required to
+ // replace this IFxxx <l> instruction with
+ // IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx
+ // is the "opposite" opcode of IFxxx (i.e.,
+ // IFNE for IFEQ) and where <l'> designates
+ // the instruction just after the GOTO_W.
+ insert = 5;
+ }
+ resize[u] = true;
+ }
+ }
+ u += 3;
+ break;
+ case ClassWriter.LABELW_INSN:
+ u += 5;
+ break;
+ case ClassWriter.TABL_INSN:
+ if(state == 1)
+ {
+ // true number of bytes to be added (or removed)
+ // from this instruction = (future number of padding
+ // bytes - current number of padding byte) -
+ // previously over estimated variation =
+ // = ((3 - newOffset%4) - (3 - u%4)) - u%4
+ // = (-newOffset%4 + u%4) - u%4
+ // = -(newOffset & 3)
+ newOffset = getNewOffset(allIndexes, allSizes, 0, u);
+ insert = -(newOffset & 3);
+ }
+ else if(!resize[u])
+ {
+ // over estimation of the number of bytes to be
+ // added to this instruction = 3 - current number
+ // of padding bytes = 3 - (3 - u%4) = u%4 = u & 3
+ insert = u & 3;
+ resize[u] = true;
+ }
+ // skips instruction
+ u = u + 4 - (u & 3);
+ u += 4 * (readInt(b, u + 8) - readInt(b, u + 4) + 1) + 12;
+ break;
+ case ClassWriter.LOOK_INSN:
+ if(state == 1)
+ {
+ // like TABL_INSN
+ newOffset = getNewOffset(allIndexes, allSizes, 0, u);
+ insert = -(newOffset & 3);
+ }
+ else if(!resize[u])
+ {
+ // like TABL_INSN
+ insert = u & 3;
+ resize[u] = true;
+ }
+ // skips instruction
+ u = u + 4 - (u & 3);
+ u += 8 * readInt(b, u + 4) + 8;
+ break;
+ case ClassWriter.WIDE_INSN:
+ opcode = b[u + 1] & 0xFF;
+ if(opcode == Opcodes.IINC)
+ {
+ u += 6;
+ }
+ else
+ {
+ u += 4;
+ }
+ break;
+ case ClassWriter.VAR_INSN:
+ case ClassWriter.SBYTE_INSN:
+ case ClassWriter.LDC_INSN:
+ u += 2;
+ break;
+ case ClassWriter.SHORT_INSN:
+ case ClassWriter.LDCW_INSN:
+ case ClassWriter.FIELDORMETH_INSN:
+ case ClassWriter.TYPE_INSN:
+ case ClassWriter.IINC_INSN:
+ u += 3;
+ break;
+ case ClassWriter.ITFMETH_INSN:
+ u += 5;
+ break;
+ // case ClassWriter.MANA_INSN:
+ default:
+ u += 4;
+ break;
+ }
+ if(insert != 0)
+ {
+ // adds a new (u, insert) entry in the allIndexes and
+ // allSizes arrays
+ int[] newIndexes = new int[allIndexes.length + 1];
+ int[] newSizes = new int[allSizes.length + 1];
+ System.arraycopy(allIndexes,
+ 0,
+ newIndexes,
+ 0,
+ allIndexes.length);
+ System.arraycopy(allSizes, 0, newSizes, 0, allSizes.length);
+ newIndexes[allIndexes.length] = u;
+ newSizes[allSizes.length] = insert;
+ allIndexes = newIndexes;
+ allSizes = newSizes;
+ if(insert > 0)
+ {
+ state = 3;
+ }
+ }
+ }
+ if(state < 3)
+ {
+ --state;
+ }
+ } while(state != 0);
+
+ // 2nd step:
+ // copies the bytecode of the method into a new bytevector, updates the
+ // offsets, and inserts (or removes) bytes as requested.
+
+ ByteVector newCode = new ByteVector(code.length);
+
+ u = 0;
+ while(u < code.length)
+ {
+ int opcode = b[u] & 0xFF;
+ switch(ClassWriter.TYPE[opcode])
+ {
+ case ClassWriter.NOARG_INSN:
+ case ClassWriter.IMPLVAR_INSN:
+ newCode.putByte(opcode);
+ u += 1;
+ break;
+ case ClassWriter.LABEL_INSN:
+ if(opcode > 201)
+ {
+ // changes temporary opcodes 202 to 217 (inclusive), 218
+ // and 219 to IFEQ ... JSR (inclusive), IFNULL and
+ // IFNONNULL
+ opcode = opcode < 218 ? opcode - 49 : opcode - 20;
+ label = u + readUnsignedShort(b, u + 1);
+ }
+ else
+ {
+ label = u + readShort(b, u + 1);
+ }
+ newOffset = getNewOffset(allIndexes, allSizes, u, label);
+ if(resize[u])
+ {
+ // replaces GOTO with GOTO_W, JSR with JSR_W and IFxxx
+ // <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is
+ // the "opposite" opcode of IFxxx (i.e., IFNE for IFEQ)
+ // and where <l'> designates the instruction just after
+ // the GOTO_W.
+ if(opcode == Opcodes.GOTO)
+ {
+ newCode.putByte(200); // GOTO_W
+ }
+ else if(opcode == Opcodes.JSR)
+ {
+ newCode.putByte(201); // JSR_W
+ }
+ else
+ {
+ newCode.putByte(opcode <= 166
+ ? ((opcode + 1) ^ 1) - 1
+ : opcode ^ 1);
+ newCode.putShort(8); // jump offset
+ newCode.putByte(200); // GOTO_W
+ // newOffset now computed from start of GOTO_W
+ newOffset -= 3;
+ }
+ newCode.putInt(newOffset);
+ }
+ else
+ {
+ newCode.putByte(opcode);
+ newCode.putShort(newOffset);
+ }
+ u += 3;
+ break;
+ case ClassWriter.LABELW_INSN:
+ label = u + readInt(b, u + 1);
+ newOffset = getNewOffset(allIndexes, allSizes, u, label);
+ newCode.putByte(opcode);
+ newCode.putInt(newOffset);
+ u += 5;
+ break;
+ case ClassWriter.TABL_INSN:
+ // skips 0 to 3 padding bytes
+ v = u;
+ u = u + 4 - (v & 3);
+ // reads and copies instruction
+ newCode.putByte(Opcodes.TABLESWITCH);
+ newCode.length += (4 - newCode.length % 4) % 4;
+ label = v + readInt(b, u);
+ u += 4;
+ newOffset = getNewOffset(allIndexes, allSizes, v, label);
+ newCode.putInt(newOffset);
+ j = readInt(b, u);
+ u += 4;
+ newCode.putInt(j);
+ j = readInt(b, u) - j + 1;
+ u += 4;
+ newCode.putInt(readInt(b, u - 4));
+ for(; j > 0; --j)
+ {
+ label = v + readInt(b, u);
+ u += 4;
+ newOffset = getNewOffset(allIndexes, allSizes, v, label);
+ newCode.putInt(newOffset);
+ }
+ break;
+ case ClassWriter.LOOK_INSN:
+ // skips 0 to 3 padding bytes
+ v = u;
+ u = u + 4 - (v & 3);
+ // reads and copies instruction
+ newCode.putByte(Opcodes.LOOKUPSWITCH);
+ newCode.length += (4 - newCode.length % 4) % 4;
+ label = v + readInt(b, u);
+ u += 4;
+ newOffset = getNewOffset(allIndexes, allSizes, v, label);
+ newCode.putInt(newOffset);
+ j = readInt(b, u);
+ u += 4;
+ newCode.putInt(j);
+ for(; j > 0; --j)
+ {
+ newCode.putInt(readInt(b, u));
+ u += 4;
+ label = v + readInt(b, u);
+ u += 4;
+ newOffset = getNewOffset(allIndexes, allSizes, v, label);
+ newCode.putInt(newOffset);
+ }
+ break;
+ case ClassWriter.WIDE_INSN:
+ opcode = b[u + 1] & 0xFF;
+ if(opcode == Opcodes.IINC)
+ {
+ newCode.putByteArray(b, u, 6);
+ u += 6;
+ }
+ else
+ {
+ newCode.putByteArray(b, u, 4);
+ u += 4;
+ }
+ break;
+ case ClassWriter.VAR_INSN:
+ case ClassWriter.SBYTE_INSN:
+ case ClassWriter.LDC_INSN:
+ newCode.putByteArray(b, u, 2);
+ u += 2;
+ break;
+ case ClassWriter.SHORT_INSN:
+ case ClassWriter.LDCW_INSN:
+ case ClassWriter.FIELDORMETH_INSN:
+ case ClassWriter.TYPE_INSN:
+ case ClassWriter.IINC_INSN:
+ newCode.putByteArray(b, u, 3);
+ u += 3;
+ break;
+ case ClassWriter.ITFMETH_INSN:
+ newCode.putByteArray(b, u, 5);
+ u += 5;
+ break;
+ // case MANA_INSN:
+ default:
+ newCode.putByteArray(b, u, 4);
+ u += 4;
+ break;
+ }
+ }
+
+ // recomputes the stack map frames
+ if(frameCount > 0)
+ {
+ if(compute == FRAMES)
+ {
+ frameCount = 0;
+ stackMap = null;
+ previousFrame = null;
+ frame = null;
+ Frame f = new Frame();
+ f.owner = labels;
+ Type[] args = Type.getArgumentTypes(descriptor);
+ f.initInputFrame(cw, access, args, maxLocals);
+ visitFrame(f);
+ Label l = labels;
+ while(l != null)
+ {
+ /*
+ * here we need the original label position. getNewOffset
+ * must therefore never have been called for this label.
+ */
+ u = l.position - 3;
+ if((l.status & Label.STORE) != 0 || (u >= 0 && resize[u]))
+ {
+ getNewOffset(allIndexes, allSizes, l);
+ // TODO update offsets in UNINITIALIZED values
+ visitFrame(l.frame);
+ }
+ l = l.successor;
+ }
+ }
+ else
+ {
+ /*
+ * Resizing an existing stack map frame table is really hard.
+ * Not only the table must be parsed to update the offets, but
+ * new frames may be needed for jump instructions that were
+ * inserted by this method. And updating the offsets or
+ * inserting frames can change the format of the following
+ * frames, in case of packed frames. In practice the whole table
+ * must be recomputed. For this the frames are marked as
+ * potentially invalid. This will cause the whole class to be
+ * reread and rewritten with the COMPUTE_FRAMES option (see the
+ * ClassWriter.toByteArray method). This is not very efficient
+ * but is much easier and requires much less code than any other
+ * method I can think of.
+ */
+ cw.invalidFrames = true;
+ }
+ }
+ // updates the exception handler block labels
+ Handler h = firstHandler;
+ while(h != null)
+ {
+ getNewOffset(allIndexes, allSizes, h.start);
+ getNewOffset(allIndexes, allSizes, h.end);
+ getNewOffset(allIndexes, allSizes, h.handler);
+ h = h.next;
+ }
+ // updates the instructions addresses in the
+ // local var and line number tables
+ for(i = 0; i < 2; ++i)
+ {
+ ByteVector bv = i == 0 ? localVar : localVarType;
+ if(bv != null)
+ {
+ b = bv.data;
+ u = 0;
+ while(u < bv.length)
+ {
+ label = readUnsignedShort(b, u);
+ newOffset = getNewOffset(allIndexes, allSizes, 0, label);
+ writeShort(b, u, newOffset);
+ label += readUnsignedShort(b, u + 2);
+ newOffset = getNewOffset(allIndexes, allSizes, 0, label)
+ - newOffset;
+ writeShort(b, u + 2, newOffset);
+ u += 10;
+ }
+ }
+ }
+ if(lineNumber != null)
+ {
+ b = lineNumber.data;
+ u = 0;
+ while(u < lineNumber.length)
+ {
+ writeShort(b, u, getNewOffset(allIndexes,
+ allSizes,
+ 0,
+ readUnsignedShort(b, u)));
+ u += 4;
+ }
+ }
+ // updates the labels of the other attributes
+ Attribute attr = cattrs;
+ while(attr != null)
+ {
+ Label[] labels = attr.getLabels();
+ if(labels != null)
+ {
+ for(i = labels.length - 1; i >= 0; --i)
+ {
+ getNewOffset(allIndexes, allSizes, labels[i]);
+ }
+ }
+ attr = attr.next;
+ }
+
+ // replaces old bytecodes with new ones
+ code = newCode;
+}
+
+/**
+ * Reads an unsigned short value in the given byte array.
+ *
+ * @param b a byte array.
+ * @param index the start index of the value to be read.
+ * @return the read value.
+ */
+static int readUnsignedShort(final byte[] b, final int index){
+ return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
+}
+
+/**
+ * Reads a signed short value in the given byte array.
+ *
+ * @param b a byte array.
+ * @param index the start index of the value to be read.
+ * @return the read value.
+ */
+static short readShort(final byte[] b, final int index){
+ return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
+}
+
+/**
+ * Reads a signed int value in the given byte array.
+ *
+ * @param b a byte array.
+ * @param index the start index of the value to be read.
+ * @return the read value.
+ */
+static int readInt(final byte[] b, final int index){
+ return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
+ | ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
+}
+
+/**
+ * Writes a short value in the given byte array.
+ *
+ * @param b a byte array.
+ * @param index where the first byte of the short value must be written.
+ * @param s the value to be written in the given byte array.
+ */
+static void writeShort(final byte[] b, final int index, final int s){
+ b[index] = (byte) (s >>> 8);
+ b[index + 1] = (byte) s;
+}
+
+/**
+ * Computes the future value of a bytecode offset. <p> Note: it is possible
+ * to have several entries for the same instruction in the <tt>indexes</tt>
+ * and <tt>sizes</tt>: two entries (index=a,size=b) and (index=a,size=b')
+ * are equivalent to a single entry (index=a,size=b+b').
+ *
+ * @param indexes current positions of the instructions to be resized. Each
+ * instruction must be designated by the index of its <i>last</i>
+ * byte, plus one (or, in other words, by the index of the <i>first</i>
+ * byte of the <i>next</i> instruction).
+ * @param sizes the number of bytes to be <i>added</i> to the above
+ * instructions. More precisely, for each i < <tt>len</tt>,
+ * <tt>sizes</tt>[i] bytes will be added at the end of the
+ * instruction designated by <tt>indexes</tt>[i] or, if
+ * <tt>sizes</tt>[i] is negative, the <i>last</i> |<tt>sizes[i]</tt>|
+ * bytes of the instruction will be removed (the instruction size
+ * <i>must not</i> become negative or null).
+ * @param begin index of the first byte of the source instruction.
+ * @param end index of the first byte of the target instruction.
+ * @return the future value of the given bytecode offset.
+ */
+static int getNewOffset(
+ final int[] indexes,
+ final int[] sizes,
+ final int begin,
+ final int end){
+ int offset = end - begin;
+ for(int i = 0; i < indexes.length; ++i)
+ {
+ if(begin < indexes[i] && indexes[i] <= end)
+ {
+ // forward jump
+ offset += sizes[i];
+ }
+ else if(end < indexes[i] && indexes[i] <= begin)
+ {
+ // backward jump
+ offset -= sizes[i];
+ }
+ }
+ return offset;
+}
+
+/**
+ * Updates the offset of the given label.
+ *
+ * @param indexes current positions of the instructions to be resized. Each
+ * instruction must be designated by the index of its <i>last</i>
+ * byte, plus one (or, in other words, by the index of the <i>first</i>
+ * byte of the <i>next</i> instruction).
+ * @param sizes the number of bytes to be <i>added</i> to the above
+ * instructions. More precisely, for each i < <tt>len</tt>,
+ * <tt>sizes</tt>[i] bytes will be added at the end of the
+ * instruction designated by <tt>indexes</tt>[i] or, if
+ * <tt>sizes</tt>[i] is negative, the <i>last</i> |<tt>sizes[i]</tt>|
+ * bytes of the instruction will be removed (the instruction size
+ * <i>must not</i> become negative or null).
+ * @param label the label whose offset must be updated.
+ */
+static void getNewOffset(
+ final int[] indexes,
+ final int[] sizes,
+ final Label label){
+ if((label.status & Label.RESIZED) == 0)
+ {
+ label.position = getNewOffset(indexes, sizes, 0, label.position);
+ label.status |= Label.RESIZED;
+ }
+}
+}
|