/***

* ASM: a very small and fast Java bytecode manipulation framework

* Copyright (c) 2000-2011 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;

/**

* 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 extends MethodVisitor {

/**

* Pseudo access flag used to denote constructors.

*/

static final int ACC_CONSTRUCTOR = 0x80000;

/**

* Frame has exactly the same locals as the previous stack map frame and

* number of stack items is zero.

*/

static final 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

*/

static final int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; // to 127 (40-7f)

/**

* Reserved for future use

*/

static final 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;

*/

static final 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.

*/

static final 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;

*/

static final 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.

*/

static final int APPEND_FRAME = 252; // to 254 // fc-fe

/**

* Full frame

*/

static final 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 static final int FRAMES = 0;

/**

* Indicates that the maximum stack size and number of local variables must

* be automatically computed.

*

* @see #compute

*/

private static final int MAXS = 1;

/**

* Indicates that nothing must be automatically computed.

*

* @see #compute

*/

private static final int NOTHING = 2;

/**

* The class writer to which this method must be added.

*/

final 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 final int name;

/**

* The index of the constant pool item that contains the descriptor of this

* method.

*/

private final int desc;

/**

* The descriptor of this method.

*/

private final 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 type annotations of this method. May be <tt>null</tt>

* .

*/

private AnnotationWriter tanns;

/**

* The runtime invisible type annotations of this method. May be

* <tt>null</tt>.

*/

private AnnotationWriter itanns;

/**

* 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 number of synthetic parameters of this method.

*/

private int synthetics;

/**

* 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 local variables in the current stack map frame.

*/

private int currentLocals;

/**

* 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;

/**

* 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 MethodParameters attribute.

*/

private int methodParametersCount;

/**

* The MethodParameters attribute.

*/

private ByteVector methodParameters;

/**

* 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 start offset of the last visited instruction.

*/

private int lastCodeOffset;

/**

* The runtime visible type annotations of the code. May be <tt>null</tt>.

*/

private AnnotationWriter ctanns;

/**

* The runtime invisible type annotations of the code. May be <tt>null</tt>.

*/

private AnnotationWriter ictanns;

/**

* 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;

/**

* The number of subroutines in this method.

*/

private int subroutines;

// ------------------------------------------------------------------------

/*

* 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 final 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 MethodVisitor#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) {

super(Opcodes.ASM5);

if (cw.firstMethod == null) {

cw.firstMethod = this;

} else {

cw.lastMethod.mv = this;

}

cw.lastMethod = this;

this.cw = cw;

this.access = access;

if ("<init>".equals(name)) {

this.access |= ACC_CONSTRUCTOR;

}

this.name = cw.newUTF8(name);

this.desc = cw.newUTF8(desc);

this.descriptor = desc;

if (ClassReader.SIGNATURES) {

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) {

// updates maxLocals

int size = Type.getArgumentsAndReturnSizes(descriptor) >> 2;

if ((access & Opcodes.ACC_STATIC) != 0) {

--size;

}

maxLocals = size;

currentLocals = size;

// creates and visits the label for the first basic block

labels = new Label();

labels.status |= Label.PUSHED;

visitLabel(labels);

}

}

// ------------------------------------------------------------------------

// Implementation of the MethodVisitor abstract class

// ------------------------------------------------------------------------

@Override

public void visitParameter(String name, int access) {

if (methodParameters == null) {

methodParameters = new ByteVector();

}

++methodParametersCount;

methodParameters.putShort((name == null) ? 0 : cw.newUTF8(name))

.putShort(access);

}

@Override

public AnnotationVisitor visitAnnotationDefault() {

if (!ClassReader.ANNOTATIONS) {

return null;

}

annd = new ByteVector();

return new AnnotationWriter(cw, false, annd, null, 0);

}

@Override

public AnnotationVisitor visitAnnotation(final String desc,

final boolean visible) {

if (!ClassReader.ANNOTATIONS) {

return null;

}

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;

}

@Override

public AnnotationVisitor visitTypeAnnotation(final int typeRef,

final TypePath typePath, final String desc, final boolean visible) {

if (!ClassReader.ANNOTATIONS) {

return null;

}

ByteVector bv = new ByteVector();

// write target_type and target_info

AnnotationWriter.putTarget(typeRef, typePath, bv);

// write type, and reserve space for values count

bv.putShort(cw.newUTF8(desc)).putShort(0);

AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,

bv.length - 2);

if (visible) {

aw.next = tanns;

tanns = aw;

} else {

aw.next = itanns;

itanns = aw;

}

return aw;

}

@Override

public AnnotationVisitor visitParameterAnnotation(final int parameter,

final String desc, final boolean visible) {

if (!ClassReader.ANNOTATIONS) {

return null;

}

ByteVector bv = new ByteVector();

if ("Ljava/lang/Synthetic;".equals(desc)) {

// workaround for a bug in javac with synthetic parameters

// see ClassReader.readParameterAnnotations

synthetics = Math.max(synthetics, parameter + 1);

return new AnnotationWriter(cw, false, bv, null, 0);

}

// 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;

}

@Override

public void visitAttribute(final Attribute attr) {

if (attr.isCodeAttribute()) {

attr.next = cattrs;

cattrs = attr;

} else {

attr.next = attrs;

attrs = attr;

}

}

@Override

public void visitCode() {

}

@Override

public void visitFrame(final int type, final int nLocal,

final Object[] local, final int nStack, final Object[] stack) {

if (!ClassReader.FRAMES || compute == FRAMES) {

return;

}

if (type == Opcodes.F_NEW) {

if (previousFrame == null) {

visitImplicitFirstFrame();

}

currentLocals = nLocal;

int frameIndex = 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;

if (delta < 0) {

if (type == Opcodes.F_SAME) {

return;

} else {

throw new IllegalStateException();

}

}

}

switch (type) {

case Opcodes.F_FULL:

currentLocals = nLocal;

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:

currentLocals += nLocal;

stackMap.putByte(SAME_FRAME_EXTENDED + nLocal).putShort(delta);

for (int i = 0; i < nLocal; ++i) {

writeFrameType(local[i]);

}

break;

case Opcodes.F_CHOP:

currentLocals -= nLocal;

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;

}

maxStack = Math.max(maxStack, nStack);

maxLocals = Math.max(maxLocals, currentLocals);

}

@Override

public void visitInsn(final int opcode) {

lastCodeOffset = code.length;

// 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();

}

}

}

@Override

public void visitIntInsn(final int opcode, final int operand) {

lastCodeOffset = code.length;

// 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);

}

}

@Override

public void visitVarInsn(final int opcode, final int var) {

lastCodeOffset = code.length;

// 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());

}

}

@Override

public void visitTypeInsn(final int opcode, final String type) {

lastCodeOffset = code.length;

Item i = cw.newClassItem(type);

// 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);

}

@Override

public void visitFieldInsn(final int opcode, final String owner,

final String name, final String desc) {

lastCodeOffset = code.length;

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);

}

@Override

public void visitMethodInsn(final int opcode, final String owner,

final String name, final String desc, final boolean itf) {

lastCodeOffset = code.length;

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 = Type.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 (opcode == Opcodes.INVOKEINTERFACE) {

if (argSize == 0) {

argSize = Type.getArgumentsAndReturnSizes(desc);

i.intVal = argSize;

}

code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);

} else {

code.put12(opcode, i.index);

}

}

@Override

public void visitInvokeDynamicInsn(final String name, final String desc,

final Handle bsm, final Object... bsmArgs) {

lastCodeOffset = code.length;

Item i = cw.newInvokeDynamicItem(name, desc, bsm, bsmArgs);

int argSize = i.intVal;

// Label currentBlock = this.currentBlock;

if (currentBlock != null) {

if (compute == FRAMES) {

currentBlock.frame.execute(Opcodes.INVOKEDYNAMIC, 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 = Type.getArgumentsAndReturnSizes(desc);

// ... and we save them in order

// not to recompute them in the future

i.intVal = argSize;

}

int size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;

// updates current and max stack sizes

if (size > maxStackSize) {

maxStackSize = size;

}

stackSize = size;

}

}

// adds the instruction to the bytecode of the method

code.put12(Opcodes.INVOKEDYNAMIC, i.index);

code.putShort(0);

}

@Override

public void visitJumpInsn(final int opcode, final Label label) {

lastCodeOffset = code.length;

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) {

if ((label.status & Label.SUBROUTINE) == 0) {

label.status |= Label.SUBROUTINE;

++subroutines;

}

currentBlock.status |= Label.JSR;

addSuccessor(stackSize + 1, label);