Java tutorial
// 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; /** * The input and output stack map frames of a basic block. * * <p>Stack map frames are computed in two steps: * * <ul> * <li>During the visit of each instruction in MethodWriter, the state of the frame at the end of * the current basic block is updated by simulating the action of the instruction on the * previous state of this so called "output frame". * <li>After all instructions have been visited, a fix point algorithm is used in MethodWriter to * compute the "input frame" of each basic block (i.e. the stack map frame at the beginning of * the basic block). See {@link MethodWriter#computeAllFrames}. * </ul> * * <p>Output stack map frames are computed relatively to the input frame of the basic block, which * is not yet known when output frames are computed. It is therefore necessary to be able to * represent abstract types such as "the type at position x in the input frame locals" or "the type * at position x from the top of the input frame stack" or even "the type at position x in the input * frame, with y more (or less) array dimensions". This explains the rather complicated type format * used in this class, explained below. * * <p>The local variables and the operand stack of input and output frames contain values called * "abstract types" hereafter. An abstract type is represented with 4 fields named DIM, KIND, FLAGS * and VALUE, packed in a single int value for better performance and memory efficiency: * * <pre> * ===================================== * |...DIM|KIND|.F|...............VALUE| * ===================================== * </pre> * * <ul> * <li>the DIM field, stored in the 6 most significant bits, is a signed number of array * dimensions (from -32 to 31, included). It can be retrieved with {@link #DIM_MASK} and a * right shift of {@link #DIM_SHIFT}. * <li>the KIND field, stored in 4 bits, indicates the kind of VALUE used. These 4 bits can be * retrieved with {@link #KIND_MASK} and, without any shift, must be equal to {@link * #CONSTANT_KIND}, {@link #REFERENCE_KIND}, {@link #UNINITIALIZED_KIND}, {@link #LOCAL_KIND} * or {@link #STACK_KIND}. * <li>the FLAGS field, stored in 2 bits, contains up to 2 boolean flags. Currently only one flag * is defined, namely {@link #TOP_IF_LONG_OR_DOUBLE_FLAG}. * <li>the VALUE field, stored in the remaining 20 bits, contains either * <ul> * <li>one of the constants {@link #ITEM_TOP}, {@link #ITEM_ASM_BOOLEAN}, {@link * #ITEM_ASM_BYTE}, {@link #ITEM_ASM_CHAR} or {@link #ITEM_ASM_SHORT}, {@link * #ITEM_INTEGER}, {@link #ITEM_FLOAT}, {@link #ITEM_LONG}, {@link #ITEM_DOUBLE}, {@link * #ITEM_NULL} or {@link #ITEM_UNINITIALIZED_THIS}, if KIND is equal to {@link * #CONSTANT_KIND}. * <li>the index of a {@link Symbol#TYPE_TAG} {@link Symbol} in the type table of a {@link * SymbolTable}, if KIND is equal to {@link #REFERENCE_KIND}. * <li>the index of an {@link Symbol#UNINITIALIZED_TYPE_TAG} {@link Symbol} in the type * table of a SymbolTable, if KIND is equal to {@link #UNINITIALIZED_KIND}. * <li>the index of a local variable in the input stack frame, if KIND is equal to {@link * #LOCAL_KIND}. * <li>a position relatively to the top of the stack of the input stack frame, if KIND is * equal to {@link #STACK_KIND}, * </ul> * </ul> * * <p>Output frames can contain abstract types of any kind and with a positive or negative array * dimension (and even unassigned types, represented by 0 - which does not correspond to any valid * abstract type value). Input frames can only contain CONSTANT_KIND, REFERENCE_KIND or * UNINITIALIZED_KIND abstract types of positive or {@literal null} array dimension. In all cases * the type table contains only internal type names (array type descriptors are forbidden - array * dimensions must be represented through the DIM field). * * <p>The LONG and DOUBLE types are always represented by using two slots (LONG + TOP or DOUBLE + * TOP), for local variables as well as in the operand stack. This is necessary to be able to * simulate DUPx_y instructions, whose effect would be dependent on the concrete types represented * by the abstract types in the stack (which are not always known). * * @author Eric Bruneton */ class Frame { // Constants used in the StackMapTable attribute. // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.4. static final int SAME_FRAME = 0; static final int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; static final int RESERVED = 128; static final int SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247; static final int CHOP_FRAME = 248; static final int SAME_FRAME_EXTENDED = 251; static final int APPEND_FRAME = 252; static final int FULL_FRAME = 255; static final int ITEM_TOP = 0; static final int ITEM_INTEGER = 1; static final int ITEM_FLOAT = 2; static final int ITEM_DOUBLE = 3; static final int ITEM_LONG = 4; static final int ITEM_NULL = 5; static final int ITEM_UNINITIALIZED_THIS = 6; static final int ITEM_OBJECT = 7; static final int ITEM_UNINITIALIZED = 8; // Additional, ASM specific constants used in abstract types below. private static final int ITEM_ASM_BOOLEAN = 9; private static final int ITEM_ASM_BYTE = 10; private static final int ITEM_ASM_CHAR = 11; private static final int ITEM_ASM_SHORT = 12; // The size and offset in bits of each field of an abstract type. private static final int DIM_SIZE = 6; private static final int KIND_SIZE = 4; private static final int FLAGS_SIZE = 2; private static final int VALUE_SIZE = 32 - DIM_SIZE - KIND_SIZE - FLAGS_SIZE; private static final int DIM_SHIFT = KIND_SIZE + FLAGS_SIZE + VALUE_SIZE; private static final int KIND_SHIFT = FLAGS_SIZE + VALUE_SIZE; private static final int FLAGS_SHIFT = VALUE_SIZE; // Bitmasks to get each field of an abstract type. private static final int DIM_MASK = ((1 << DIM_SIZE) - 1) << DIM_SHIFT; private static final int KIND_MASK = ((1 << KIND_SIZE) - 1) << KIND_SHIFT; private static final int VALUE_MASK = (1 << VALUE_SIZE) - 1; // Constants to manipulate the DIM field of an abstract type. /** The constant to be added to an abstract type to get one with one more array dimension. */ private static final int ARRAY_OF = +1 << DIM_SHIFT; /** The constant to be added to an abstract type to get one with one less array dimension. */ private static final int ELEMENT_OF = -1 << DIM_SHIFT; // Possible values for the KIND field of an abstract type. private static final int CONSTANT_KIND = 1 << KIND_SHIFT; private static final int REFERENCE_KIND = 2 << KIND_SHIFT; private static final int UNINITIALIZED_KIND = 3 << KIND_SHIFT; private static final int LOCAL_KIND = 4 << KIND_SHIFT; private static final int STACK_KIND = 5 << KIND_SHIFT; // Possible flags for the FLAGS field of an abstract type. /** * A flag used for LOCAL_KIND and STACK_KIND abstract types, indicating that if the resolved, * concrete type is LONG or DOUBLE, TOP should be used instead (because the value has been * partially overridden with an xSTORE instruction). */ private static final int TOP_IF_LONG_OR_DOUBLE_FLAG = 1 << FLAGS_SHIFT; // Useful predefined abstract types (all the possible CONSTANT_KIND types). private static final int TOP = CONSTANT_KIND | ITEM_TOP; private static final int BOOLEAN = CONSTANT_KIND | ITEM_ASM_BOOLEAN; private static final int BYTE = CONSTANT_KIND | ITEM_ASM_BYTE; private static final int CHAR = CONSTANT_KIND | ITEM_ASM_CHAR; private static final int SHORT = CONSTANT_KIND | ITEM_ASM_SHORT; private static final int INTEGER = CONSTANT_KIND | ITEM_INTEGER; private static final int FLOAT = CONSTANT_KIND | ITEM_FLOAT; private static final int LONG = CONSTANT_KIND | ITEM_LONG; private static final int DOUBLE = CONSTANT_KIND | ITEM_DOUBLE; private static final int NULL = CONSTANT_KIND | ITEM_NULL; private static final int UNINITIALIZED_THIS = CONSTANT_KIND | ITEM_UNINITIALIZED_THIS; // ----------------------------------------------------------------------------------------------- // Instance fields // ----------------------------------------------------------------------------------------------- /** The basic block to which these input and output stack map frames correspond. */ Label owner; /** The input stack map frame locals. This is an array of abstract types. */ private int[] inputLocals; /** The input stack map frame stack. This is an array of abstract types. */ private int[] inputStack; /** The output stack map frame locals. This is an array of abstract types. */ private int[] outputLocals; /** The output stack map frame stack. This is an array of abstract types. */ private int[] outputStack; /** * The start of the output stack, relatively to the input stack. This offset is always negative or * null. A null offset means that the output stack must be appended to the input stack. A -n * offset means that the first n output stack elements must replace the top n input stack * elements, and that the other elements must be appended to the input stack. */ private short outputStackStart; /** The index of the top stack element in {@link #outputStack}. */ private short outputStackTop; /** The number of types that are initialized in the basic block. See {@link #initializations}. */ private int initializationCount; /** * The abstract types that are initialized in the basic block. A constructor invocation on an * UNINITIALIZED or UNINITIALIZED_THIS abstract type must replace <i>every occurrence</i> of this * type in the local variables and in the operand stack. This cannot be done during the first step * of the algorithm since, during this step, the local variables and the operand stack types are * still abstract. It is therefore necessary to store the abstract types of the constructors which * are invoked in the basic block, in order to do this replacement during the second step of the * algorithm, where the frames are fully computed. Note that this array can contain abstract types * that are relative to the input locals or to the input stack. */ private int[] initializations; // ----------------------------------------------------------------------------------------------- // Constructor // ----------------------------------------------------------------------------------------------- /** * Constructs a new Frame. * * @param owner the basic block to which these input and output stack map frames correspond. */ Frame(final Label owner) { this.owner = owner; } /** * Sets this frame to the value of the given frame. * * <p>WARNING: after this method is called the two frames share the same data structures. It is * recommended to discard the given frame to avoid unexpected side effects. * * @param frame The new frame value. */ final void copyFrom(final Frame frame) { inputLocals = frame.inputLocals; inputStack = frame.inputStack; outputStackStart = 0; outputLocals = frame.outputLocals; outputStack = frame.outputStack; outputStackTop = frame.outputStackTop; initializationCount = frame.initializationCount; initializations = frame.initializations; } // ----------------------------------------------------------------------------------------------- // Static methods to get abstract types from other type formats // ----------------------------------------------------------------------------------------------- /** * Returns the abstract type corresponding to the given public API frame element type. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param type a frame element type described using the same format as in {@link * MethodVisitor#visitFrame}, i.e. either {@link Opcodes#TOP}, {@link Opcodes#INTEGER}, {@link * Opcodes#FLOAT}, {@link Opcodes#LONG}, {@link Opcodes#DOUBLE}, {@link Opcodes#NULL}, or * {@link Opcodes#UNINITIALIZED_THIS}, or the internal name of a class, or a Label designating * a NEW instruction (for uninitialized types). * @return the abstract type corresponding to the given frame element type. */ static int getAbstractTypeFromApiFormat(final SymbolTable symbolTable, final Object type) { if (type instanceof Integer) { return CONSTANT_KIND | ((Integer) type).intValue(); } else if (type instanceof String) { String descriptor = Type.getObjectType((String) type).getDescriptor(); return getAbstractTypeFromDescriptor(symbolTable, descriptor, 0); } else { return UNINITIALIZED_KIND | symbolTable.addUninitializedType("", ((Label) type).bytecodeOffset); } } /** * Returns the abstract type corresponding to the internal name of a class. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param internalName the internal name of a class. This must <i>not</i> be an array type * descriptor. * @return the abstract type value corresponding to the given internal name. */ static int getAbstractTypeFromInternalName(final SymbolTable symbolTable, final String internalName) { return REFERENCE_KIND | symbolTable.addType(internalName); } /** * Returns the abstract type corresponding to the given type descriptor. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param buffer a string ending with a type descriptor. * @param offset the start offset of the type descriptor in buffer. * @return the abstract type corresponding to the given type descriptor. */ private static int getAbstractTypeFromDescriptor(final SymbolTable symbolTable, final String buffer, final int offset) { String internalName; switch (buffer.charAt(offset)) { case 'V': return 0; case 'Z': case 'C': case 'B': case 'S': case 'I': return INTEGER; case 'F': return FLOAT; case 'J': return LONG; case 'D': return DOUBLE; case 'L': internalName = buffer.substring(offset + 1, buffer.length() - 1); return REFERENCE_KIND | symbolTable.addType(internalName); case '[': int elementDescriptorOffset = offset + 1; while (buffer.charAt(elementDescriptorOffset) == '[') { ++elementDescriptorOffset; } int typeValue; switch (buffer.charAt(elementDescriptorOffset)) { case 'Z': typeValue = BOOLEAN; break; case 'C': typeValue = CHAR; break; case 'B': typeValue = BYTE; break; case 'S': typeValue = SHORT; break; case 'I': typeValue = INTEGER; break; case 'F': typeValue = FLOAT; break; case 'J': typeValue = LONG; break; case 'D': typeValue = DOUBLE; break; case 'L': internalName = buffer.substring(elementDescriptorOffset + 1, buffer.length() - 1); typeValue = REFERENCE_KIND | symbolTable.addType(internalName); break; default: throw new IllegalArgumentException(); } return ((elementDescriptorOffset - offset) << DIM_SHIFT) | typeValue; default: throw new IllegalArgumentException(); } } // ----------------------------------------------------------------------------------------------- // Methods related to the input frame // ----------------------------------------------------------------------------------------------- /** * Sets the input frame from the given method description. This method is used to initialize the * first frame of a method, which is implicit (i.e. not stored explicitly in the StackMapTable * attribute). * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param access the method's access flags. * @param descriptor the method descriptor. * @param maxLocals the maximum number of local variables of the method. */ final void setInputFrameFromDescriptor(final SymbolTable symbolTable, final int access, final String descriptor, final int maxLocals) { inputLocals = new int[maxLocals]; inputStack = new int[0]; int inputLocalIndex = 0; if ((access & Opcodes.ACC_STATIC) == 0) { if ((access & Constants.ACC_CONSTRUCTOR) == 0) { inputLocals[inputLocalIndex++] = REFERENCE_KIND | symbolTable.addType(symbolTable.getClassName()); } else { inputLocals[inputLocalIndex++] = UNINITIALIZED_THIS; } } for (Type argumentType : Type.getArgumentTypes(descriptor)) { int abstractType = getAbstractTypeFromDescriptor(symbolTable, argumentType.getDescriptor(), 0); inputLocals[inputLocalIndex++] = abstractType; if (abstractType == LONG || abstractType == DOUBLE) { inputLocals[inputLocalIndex++] = TOP; } } while (inputLocalIndex < maxLocals) { inputLocals[inputLocalIndex++] = TOP; } } /** * Sets the input frame from the given public API frame description. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param numLocal the number of local variables. * @param local the local variable types, described using the same format as in {@link * MethodVisitor#visitFrame}. * @param numStack the number of operand stack elements. * @param stack the operand stack types, described using the same format as in {@link * MethodVisitor#visitFrame}. */ final void setInputFrameFromApiFormat(final SymbolTable symbolTable, final int numLocal, final Object[] local, final int numStack, final Object[] stack) { int inputLocalIndex = 0; for (int i = 0; i < numLocal; ++i) { inputLocals[inputLocalIndex++] = getAbstractTypeFromApiFormat(symbolTable, local[i]); if (local[i] == Opcodes.LONG || local[i] == Opcodes.DOUBLE) { inputLocals[inputLocalIndex++] = TOP; } } while (inputLocalIndex < inputLocals.length) { inputLocals[inputLocalIndex++] = TOP; } int numStackTop = 0; for (int i = 0; i < numStack; ++i) { if (stack[i] == Opcodes.LONG || stack[i] == Opcodes.DOUBLE) { ++numStackTop; } } inputStack = new int[numStack + numStackTop]; int inputStackIndex = 0; for (int i = 0; i < numStack; ++i) { inputStack[inputStackIndex++] = getAbstractTypeFromApiFormat(symbolTable, stack[i]); if (stack[i] == Opcodes.LONG || stack[i] == Opcodes.DOUBLE) { inputStack[inputStackIndex++] = TOP; } } outputStackTop = 0; initializationCount = 0; } final int getInputStackSize() { return inputStack.length; } // ----------------------------------------------------------------------------------------------- // Methods related to the output frame // ----------------------------------------------------------------------------------------------- /** * Returns the abstract type stored at the given local variable index in the output frame. * * @param localIndex the index of the local variable whose value must be returned. * @return the abstract type stored at the given local variable index in the output frame. */ private int getLocal(final int localIndex) { if (outputLocals == null || localIndex >= outputLocals.length) { // If this local has never been assigned in this basic block, it is still equal to its value // in the input frame. return LOCAL_KIND | localIndex; } else { int abstractType = outputLocals[localIndex]; if (abstractType == 0) { // If this local has never been assigned in this basic block, so it is still equal to its // value in the input frame. abstractType = outputLocals[localIndex] = LOCAL_KIND | localIndex; } return abstractType; } } /** * Replaces the abstract type stored at the given local variable index in the output frame. * * @param localIndex the index of the output frame local variable that must be set. * @param abstractType the value that must be set. */ private void setLocal(final int localIndex, final int abstractType) { // Create and/or resize the output local variables array if necessary. if (outputLocals == null) { outputLocals = new int[10]; } int outputLocalsLength = outputLocals.length; if (localIndex >= outputLocalsLength) { int[] newOutputLocals = new int[Math.max(localIndex + 1, 2 * outputLocalsLength)]; System.arraycopy(outputLocals, 0, newOutputLocals, 0, outputLocalsLength); outputLocals = newOutputLocals; } // Set the local variable. outputLocals[localIndex] = abstractType; } /** * Pushes the given abstract type on the output frame stack. * * @param abstractType an abstract type. */ private void push(final int abstractType) { // Create and/or resize the output stack array if necessary. if (outputStack == null) { outputStack = new int[10]; } int outputStackLength = outputStack.length; if (outputStackTop >= outputStackLength) { int[] newOutputStack = new int[Math.max(outputStackTop + 1, 2 * outputStackLength)]; System.arraycopy(outputStack, 0, newOutputStack, 0, outputStackLength); outputStack = newOutputStack; } // Pushes the abstract type on the output stack. outputStack[outputStackTop++] = abstractType; // Updates the maximum size reached by the output stack, if needed (note that this size is // relative to the input stack size, which is not known yet). short outputStackSize = (short) (outputStackStart + outputStackTop); if (outputStackSize > owner.outputStackMax) { owner.outputStackMax = outputStackSize; } } /** * Pushes the abstract type corresponding to the given descriptor on the output frame stack. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param descriptor a type or method descriptor (in which case its return type is pushed). */ private void push(final SymbolTable symbolTable, final String descriptor) { int typeDescriptorOffset = descriptor.charAt(0) == '(' ? Type.getReturnTypeOffset(descriptor) : 0; int abstractType = getAbstractTypeFromDescriptor(symbolTable, descriptor, typeDescriptorOffset); if (abstractType != 0) { push(abstractType); if (abstractType == LONG || abstractType == DOUBLE) { push(TOP); } } } /** * Pops an abstract type from the output frame stack and returns its value. * * @return the abstract type that has been popped from the output frame stack. */ private int pop() { if (outputStackTop > 0) { return outputStack[--outputStackTop]; } else { // If the output frame stack is empty, pop from the input stack. return STACK_KIND | -(--outputStackStart); } } /** * Pops the given number of abstract types from the output frame stack. * * @param elements the number of abstract types that must be popped. */ private void pop(final int elements) { if (outputStackTop >= elements) { outputStackTop -= elements; } else { // If the number of elements to be popped is greater than the number of elements in the output // stack, clear it, and pop the remaining elements from the input stack. outputStackStart -= elements - outputStackTop; outputStackTop = 0; } } /** * Pops as many abstract types from the output frame stack as described by the given descriptor. * * @param descriptor a type or method descriptor (in which case its argument types are popped). */ private void pop(final String descriptor) { char firstDescriptorChar = descriptor.charAt(0); if (firstDescriptorChar == '(') { pop((Type.getArgumentsAndReturnSizes(descriptor) >> 2) - 1); } else if (firstDescriptorChar == 'J' || firstDescriptorChar == 'D') { pop(2); } else { pop(1); } } // ----------------------------------------------------------------------------------------------- // Methods to handle uninitialized types // ----------------------------------------------------------------------------------------------- /** * Adds an abstract type to the list of types on which a constructor is invoked in the basic * block. * * @param abstractType an abstract type on a which a constructor is invoked. */ private void addInitializedType(final int abstractType) { // Create and/or resize the initializations array if necessary. if (initializations == null) { initializations = new int[2]; } int initializationsLength = initializations.length; if (initializationCount >= initializationsLength) { int[] newInitializations = new int[Math.max(initializationCount + 1, 2 * initializationsLength)]; System.arraycopy(initializations, 0, newInitializations, 0, initializationsLength); initializations = newInitializations; } // Store the abstract type. initializations[initializationCount++] = abstractType; } /** * Returns the "initialized" abstract type corresponding to the given abstract type. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param abstractType an abstract type. * @return the REFERENCE_KIND abstract type corresponding to abstractType if it is * UNINITIALIZED_THIS or an UNINITIALIZED_KIND abstract type for one of the types on which a * constructor is invoked in the basic block. Otherwise returns abstractType. */ private int getInitializedType(final SymbolTable symbolTable, final int abstractType) { if (abstractType == UNINITIALIZED_THIS || (abstractType & (DIM_MASK | KIND_MASK)) == UNINITIALIZED_KIND) { for (int i = 0; i < initializationCount; ++i) { int initializedType = initializations[i]; int dim = initializedType & DIM_MASK; int kind = initializedType & KIND_MASK; int value = initializedType & VALUE_MASK; if (kind == LOCAL_KIND) { initializedType = dim + inputLocals[value]; } else if (kind == STACK_KIND) { initializedType = dim + inputStack[inputStack.length - value]; } if (abstractType == initializedType) { if (abstractType == UNINITIALIZED_THIS) { return REFERENCE_KIND | symbolTable.addType(symbolTable.getClassName()); } else { return REFERENCE_KIND | symbolTable.addType(symbolTable.getType(abstractType & VALUE_MASK).value); } } } } return abstractType; } // ----------------------------------------------------------------------------------------------- // Main method, to simulate the execution of each instruction on the output frame // ----------------------------------------------------------------------------------------------- /** * Simulates the action of the given instruction on the output stack frame. * * @param opcode the opcode of the instruction. * @param arg the numeric operand of the instruction, if any. * @param argSymbol the Symbol operand of the instruction, if any. * @param symbolTable the type table to use to lookup and store type {@link Symbol}. */ void execute(final int opcode, final int arg, final Symbol argSymbol, final SymbolTable symbolTable) { // Abstract types popped from the stack or read from local variables. int abstractType1; int abstractType2; int abstractType3; int abstractType4; switch (opcode) { case Opcodes.NOP: case Opcodes.INEG: case Opcodes.LNEG: case Opcodes.FNEG: case Opcodes.DNEG: case Opcodes.I2B: case Opcodes.I2C: case Opcodes.I2S: case Opcodes.GOTO: case Opcodes.RETURN: break; case Opcodes.ACONST_NULL: push(NULL); break; case Opcodes.ICONST_M1: case Opcodes.ICONST_0: case Opcodes.ICONST_1: case Opcodes.ICONST_2: case Opcodes.ICONST_3: case Opcodes.ICONST_4: case Opcodes.ICONST_5: case Opcodes.BIPUSH: case Opcodes.SIPUSH: case Opcodes.ILOAD: push(INTEGER); break; case Opcodes.LCONST_0: case Opcodes.LCONST_1: case Opcodes.LLOAD: push(LONG); push(TOP); break; case Opcodes.FCONST_0: case Opcodes.FCONST_1: case Opcodes.FCONST_2: case Opcodes.FLOAD: push(FLOAT); break; case Opcodes.DCONST_0: case Opcodes.DCONST_1: case Opcodes.DLOAD: push(DOUBLE); push(TOP); break; case Opcodes.LDC: switch (argSymbol.tag) { case Symbol.CONSTANT_INTEGER_TAG: push(INTEGER); break; case Symbol.CONSTANT_LONG_TAG: push(LONG); push(TOP); break; case Symbol.CONSTANT_FLOAT_TAG: push(FLOAT); break; case Symbol.CONSTANT_DOUBLE_TAG: push(DOUBLE); push(TOP); break; case Symbol.CONSTANT_CLASS_TAG: push(REFERENCE_KIND | symbolTable.addType("java/lang/Class")); break; case Symbol.CONSTANT_STRING_TAG: push(REFERENCE_KIND | symbolTable.addType("java/lang/String")); break; case Symbol.CONSTANT_METHOD_TYPE_TAG: push(REFERENCE_KIND | symbolTable.addType("java/lang/invoke/MethodType")); break; case Symbol.CONSTANT_METHOD_HANDLE_TAG: push(REFERENCE_KIND | symbolTable.addType("java/lang/invoke/MethodHandle")); break; case Symbol.CONSTANT_DYNAMIC_TAG: push(symbolTable, argSymbol.value); break; default: throw new AssertionError(); } break; case Opcodes.ALOAD: push(getLocal(arg)); break; case Opcodes.LALOAD: case Opcodes.D2L: pop(2); push(LONG); push(TOP); break; case Opcodes.DALOAD: case Opcodes.L2D: pop(2); push(DOUBLE); push(TOP); break; case Opcodes.AALOAD: pop(1); abstractType1 = pop(); push(abstractType1 == NULL ? abstractType1 : ELEMENT_OF + abstractType1); break; case Opcodes.ISTORE: case Opcodes.FSTORE: case Opcodes.ASTORE: abstractType1 = pop(); setLocal(arg, abstractType1); if (arg > 0) { int previousLocalType = getLocal(arg - 1); if (previousLocalType == LONG || previousLocalType == DOUBLE) { setLocal(arg - 1, TOP); } else if ((previousLocalType & KIND_MASK) == LOCAL_KIND || (previousLocalType & KIND_MASK) == STACK_KIND) { // The type of the previous local variable is not known yet, but if it later appears // to be LONG or DOUBLE, we should then use TOP instead. setLocal(arg - 1, previousLocalType | TOP_IF_LONG_OR_DOUBLE_FLAG); } } break; case Opcodes.LSTORE: case Opcodes.DSTORE: pop(1); abstractType1 = pop(); setLocal(arg, abstractType1); setLocal(arg + 1, TOP); if (arg > 0) { int previousLocalType = getLocal(arg - 1); if (previousLocalType == LONG || previousLocalType == DOUBLE) { setLocal(arg - 1, TOP); } else if ((previousLocalType & KIND_MASK) == LOCAL_KIND || (previousLocalType & KIND_MASK) == STACK_KIND) { // The type of the previous local variable is not known yet, but if it later appears // to be LONG or DOUBLE, we should then use TOP instead. setLocal(arg - 1, previousLocalType | TOP_IF_LONG_OR_DOUBLE_FLAG); } } break; case Opcodes.IASTORE: case Opcodes.BASTORE: case Opcodes.CASTORE: case Opcodes.SASTORE: case Opcodes.FASTORE: case Opcodes.AASTORE: pop(3); break; case Opcodes.LASTORE: case Opcodes.DASTORE: pop(4); break; case Opcodes.POP: case Opcodes.IFEQ: case Opcodes.IFNE: case Opcodes.IFLT: case Opcodes.IFGE: case Opcodes.IFGT: case Opcodes.IFLE: case Opcodes.IRETURN: case Opcodes.FRETURN: case Opcodes.ARETURN: case Opcodes.TABLESWITCH: case Opcodes.LOOKUPSWITCH: case Opcodes.ATHROW: case Opcodes.MONITORENTER: case Opcodes.MONITOREXIT: case Opcodes.IFNULL: case Opcodes.IFNONNULL: pop(1); break; case Opcodes.POP2: case Opcodes.IF_ICMPEQ: case Opcodes.IF_ICMPNE: case Opcodes.IF_ICMPLT: case Opcodes.IF_ICMPGE: case Opcodes.IF_ICMPGT: case Opcodes.IF_ICMPLE: case Opcodes.IF_ACMPEQ: case Opcodes.IF_ACMPNE: case Opcodes.LRETURN: case Opcodes.DRETURN: pop(2); break; case Opcodes.DUP: abstractType1 = pop(); push(abstractType1); push(abstractType1); break; case Opcodes.DUP_X1: abstractType1 = pop(); abstractType2 = pop(); push(abstractType1); push(abstractType2); push(abstractType1); break; case Opcodes.DUP_X2: abstractType1 = pop(); abstractType2 = pop(); abstractType3 = pop(); push(abstractType1); push(abstractType3); push(abstractType2); push(abstractType1); break; case Opcodes.DUP2: abstractType1 = pop(); abstractType2 = pop(); push(abstractType2); push(abstractType1); push(abstractType2); push(abstractType1); break; case Opcodes.DUP2_X1: abstractType1 = pop(); abstractType2 = pop(); abstractType3 = pop(); push(abstractType2); push(abstractType1); push(abstractType3); push(abstractType2); push(abstractType1); break; case Opcodes.DUP2_X2: abstractType1 = pop(); abstractType2 = pop(); abstractType3 = pop(); abstractType4 = pop(); push(abstractType2); push(abstractType1); push(abstractType4); push(abstractType3); push(abstractType2); push(abstractType1); break; case Opcodes.SWAP: abstractType1 = pop(); abstractType2 = pop(); push(abstractType1); push(abstractType2); break; case Opcodes.IALOAD: case Opcodes.BALOAD: case Opcodes.CALOAD: case Opcodes.SALOAD: case Opcodes.IADD: case Opcodes.ISUB: case Opcodes.IMUL: case Opcodes.IDIV: case Opcodes.IREM: case Opcodes.IAND: case Opcodes.IOR: case Opcodes.IXOR: case Opcodes.ISHL: case Opcodes.ISHR: case Opcodes.IUSHR: case Opcodes.L2I: case Opcodes.D2I: case Opcodes.FCMPL: case Opcodes.FCMPG: pop(2); push(INTEGER); break; case Opcodes.LADD: case Opcodes.LSUB: case Opcodes.LMUL: case Opcodes.LDIV: case Opcodes.LREM: case Opcodes.LAND: case Opcodes.LOR: case Opcodes.LXOR: pop(4); push(LONG); push(TOP); break; case Opcodes.FALOAD: case Opcodes.FADD: case Opcodes.FSUB: case Opcodes.FMUL: case Opcodes.FDIV: case Opcodes.FREM: case Opcodes.L2F: case Opcodes.D2F: pop(2); push(FLOAT); break; case Opcodes.DADD: case Opcodes.DSUB: case Opcodes.DMUL: case Opcodes.DDIV: case Opcodes.DREM: pop(4); push(DOUBLE); push(TOP); break; case Opcodes.LSHL: case Opcodes.LSHR: case Opcodes.LUSHR: pop(3); push(LONG); push(TOP); break; case Opcodes.IINC: setLocal(arg, INTEGER); break; case Opcodes.I2L: case Opcodes.F2L: pop(1); push(LONG); push(TOP); break; case Opcodes.I2F: pop(1); push(FLOAT); break; case Opcodes.I2D: case Opcodes.F2D: pop(1); push(DOUBLE); push(TOP); break; case Opcodes.F2I: case Opcodes.ARRAYLENGTH: case Opcodes.INSTANCEOF: pop(1); push(INTEGER); break; case Opcodes.LCMP: case Opcodes.DCMPL: case Opcodes.DCMPG: pop(4); push(INTEGER); break; case Opcodes.JSR: case Opcodes.RET: throw new IllegalArgumentException("JSR/RET are not supported with computeFrames option"); case Opcodes.GETSTATIC: push(symbolTable, argSymbol.value); break; case Opcodes.PUTSTATIC: pop(argSymbol.value); break; case Opcodes.GETFIELD: pop(1); push(symbolTable, argSymbol.value); break; case Opcodes.PUTFIELD: pop(argSymbol.value); pop(); break; case Opcodes.INVOKEVIRTUAL: case Opcodes.INVOKESPECIAL: case Opcodes.INVOKESTATIC: case Opcodes.INVOKEINTERFACE: pop(argSymbol.value); if (opcode != Opcodes.INVOKESTATIC) { abstractType1 = pop(); if (opcode == Opcodes.INVOKESPECIAL && argSymbol.name.charAt(0) == '<') { addInitializedType(abstractType1); } } push(symbolTable, argSymbol.value); break; case Opcodes.INVOKEDYNAMIC: pop(argSymbol.value); push(symbolTable, argSymbol.value); break; case Opcodes.NEW: push(UNINITIALIZED_KIND | symbolTable.addUninitializedType(argSymbol.value, arg)); break; case Opcodes.NEWARRAY: pop(); switch (arg) { case Opcodes.T_BOOLEAN: push(ARRAY_OF | BOOLEAN); break; case Opcodes.T_CHAR: push(ARRAY_OF | CHAR); break; case Opcodes.T_BYTE: push(ARRAY_OF | BYTE); break; case Opcodes.T_SHORT: push(ARRAY_OF | SHORT); break; case Opcodes.T_INT: push(ARRAY_OF | INTEGER); break; case Opcodes.T_FLOAT: push(ARRAY_OF | FLOAT); break; case Opcodes.T_DOUBLE: push(ARRAY_OF | DOUBLE); break; case Opcodes.T_LONG: push(ARRAY_OF | LONG); break; default: throw new IllegalArgumentException(); } break; case Opcodes.ANEWARRAY: String arrayElementType = argSymbol.value; pop(); if (arrayElementType.charAt(0) == '[') { push(symbolTable, '[' + arrayElementType); } else { push(ARRAY_OF | REFERENCE_KIND | symbolTable.addType(arrayElementType)); } break; case Opcodes.CHECKCAST: String castType = argSymbol.value; pop(); if (castType.charAt(0) == '[') { push(symbolTable, castType); } else { push(REFERENCE_KIND | symbolTable.addType(castType)); } break; case Opcodes.MULTIANEWARRAY: pop(arg); push(symbolTable, argSymbol.value); break; default: throw new IllegalArgumentException(); } } // ----------------------------------------------------------------------------------------------- // Frame merging methods, used in the second step of the stack map frame computation algorithm // ----------------------------------------------------------------------------------------------- /** * Computes the concrete output type corresponding to a given abstract output type. * * @param abstractOutputType an abstract output type. * @param numStack the size of the input stack, used to resolve abstract output types of * STACK_KIND kind. * @return the concrete output type corresponding to 'abstractOutputType'. */ private int getConcreteOutputType(final int abstractOutputType, final int numStack) { int dim = abstractOutputType & DIM_MASK; int kind = abstractOutputType & KIND_MASK; if (kind == LOCAL_KIND) { // By definition, a LOCAL_KIND type designates the concrete type of a local variable at // the beginning of the basic block corresponding to this frame (which is known when // this method is called, but was not when the abstract type was computed). int concreteOutputType = dim + inputLocals[abstractOutputType & VALUE_MASK]; if ((abstractOutputType & TOP_IF_LONG_OR_DOUBLE_FLAG) != 0 && (concreteOutputType == LONG || concreteOutputType == DOUBLE)) { concreteOutputType = TOP; } return concreteOutputType; } else if (kind == STACK_KIND) { // By definition, a STACK_KIND type designates the concrete type of a local variable at // the beginning of the basic block corresponding to this frame (which is known when // this method is called, but was not when the abstract type was computed). int concreteOutputType = dim + inputStack[numStack - (abstractOutputType & VALUE_MASK)]; if ((abstractOutputType & TOP_IF_LONG_OR_DOUBLE_FLAG) != 0 && (concreteOutputType == LONG || concreteOutputType == DOUBLE)) { concreteOutputType = TOP; } return concreteOutputType; } else { return abstractOutputType; } } /** * Merges the input frame of the given {@link Frame} with the input and output frames of this * {@link Frame}. Returns {@literal true} if the given frame has been changed by this operation * (the input and output frames of this {@link Frame} are never changed). * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param dstFrame the {@link Frame} whose input frame must be updated. This should be the frame * of a successor, in the control flow graph, of the basic block corresponding to this frame. * @param catchTypeIndex if 'frame' corresponds to an exception handler basic block, the type * table index of the caught exception type, otherwise 0. * @return {@literal true} if the input frame of 'frame' has been changed by this operation. */ final boolean merge(final SymbolTable symbolTable, final Frame dstFrame, final int catchTypeIndex) { boolean frameChanged = false; // Compute the concrete types of the local variables at the end of the basic block corresponding // to this frame, by resolving its abstract output types, and merge these concrete types with // those of the local variables in the input frame of dstFrame. int numLocal = inputLocals.length; int numStack = inputStack.length; if (dstFrame.inputLocals == null) { dstFrame.inputLocals = new int[numLocal]; frameChanged = true; } for (int i = 0; i < numLocal; ++i) { int concreteOutputType; if (outputLocals != null && i < outputLocals.length) { int abstractOutputType = outputLocals[i]; if (abstractOutputType == 0) { // If the local variable has never been assigned in this basic block, it is equal to its // value at the beginning of the block. concreteOutputType = inputLocals[i]; } else { concreteOutputType = getConcreteOutputType(abstractOutputType, numStack); } } else { // If the local variable has never been assigned in this basic block, it is equal to its // value at the beginning of the block. concreteOutputType = inputLocals[i]; } // concreteOutputType might be an uninitialized type from the input locals or from the input // stack. However, if a constructor has been called for this class type in the basic block, // then this type is no longer uninitialized at the end of basic block. if (initializations != null) { concreteOutputType = getInitializedType(symbolTable, concreteOutputType); } frameChanged |= merge(symbolTable, concreteOutputType, dstFrame.inputLocals, i); } // If dstFrame is an exception handler block, it can be reached from any instruction of the // basic block corresponding to this frame, in particular from the first one. Therefore, the // input locals of dstFrame should be compatible (i.e. merged) with the input locals of this // frame (and the input stack of dstFrame should be compatible, i.e. merged, with a one // element stack containing the caught exception type). if (catchTypeIndex > 0) { for (int i = 0; i < numLocal; ++i) { frameChanged |= merge(symbolTable, inputLocals[i], dstFrame.inputLocals, i); } if (dstFrame.inputStack == null) { dstFrame.inputStack = new int[1]; frameChanged = true; } frameChanged |= merge(symbolTable, catchTypeIndex, dstFrame.inputStack, 0); return frameChanged; } // Compute the concrete types of the stack operands at the end of the basic block corresponding // to this frame, by resolving its abstract output types, and merge these concrete types with // those of the stack operands in the input frame of dstFrame. int numInputStack = inputStack.length + outputStackStart; if (dstFrame.inputStack == null) { dstFrame.inputStack = new int[numInputStack + outputStackTop]; frameChanged = true; } // First, do this for the stack operands that have not been popped in the basic block // corresponding to this frame, and which are therefore equal to their value in the input // frame (except for uninitialized types, which may have been initialized). for (int i = 0; i < numInputStack; ++i) { int concreteOutputType = inputStack[i]; if (initializations != null) { concreteOutputType = getInitializedType(symbolTable, concreteOutputType); } frameChanged |= merge(symbolTable, concreteOutputType, dstFrame.inputStack, i); } // Then, do this for the stack operands that have pushed in the basic block (this code is the // same as the one above for local variables). for (int i = 0; i < outputStackTop; ++i) { int abstractOutputType = outputStack[i]; int concreteOutputType = getConcreteOutputType(abstractOutputType, numStack); if (initializations != null) { concreteOutputType = getInitializedType(symbolTable, concreteOutputType); } frameChanged |= merge(symbolTable, concreteOutputType, dstFrame.inputStack, numInputStack + i); } return frameChanged; } /** * Merges the type at the given index in the given abstract type array with the given type. * Returns {@literal true} if the type array has been modified by this operation. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param sourceType the abstract type with which the abstract type array element must be merged. * This type should be of {@link #CONSTANT_KIND}, {@link #REFERENCE_KIND} or {@link * #UNINITIALIZED_KIND} kind, with positive or {@literal null} array dimensions. * @param dstTypes an array of abstract types. These types should be of {@link #CONSTANT_KIND}, * {@link #REFERENCE_KIND} or {@link #UNINITIALIZED_KIND} kind, with positive or {@literal * null} array dimensions. * @param dstIndex the index of the type that must be merged in dstTypes. * @return {@literal true} if the type array has been modified by this operation. */ private static boolean merge(final SymbolTable symbolTable, final int sourceType, final int[] dstTypes, final int dstIndex) { int dstType = dstTypes[dstIndex]; if (dstType == sourceType) { // If the types are equal, merge(sourceType, dstType) = dstType, so there is no change. return false; } int srcType = sourceType; if ((sourceType & ~DIM_MASK) == NULL) { if (dstType == NULL) { return false; } srcType = NULL; } if (dstType == 0) { // If dstTypes[dstIndex] has never been assigned, merge(srcType, dstType) = srcType. dstTypes[dstIndex] = srcType; return true; } int mergedType; if ((dstType & DIM_MASK) != 0 || (dstType & KIND_MASK) == REFERENCE_KIND) { // If dstType is a reference type of any array dimension. if (srcType == NULL) { // If srcType is the NULL type, merge(srcType, dstType) = dstType, so there is no change. return false; } else if ((srcType & (DIM_MASK | KIND_MASK)) == (dstType & (DIM_MASK | KIND_MASK))) { // If srcType has the same array dimension and the same kind as dstType. if ((dstType & KIND_MASK) == REFERENCE_KIND) { // If srcType and dstType are reference types with the same array dimension, // merge(srcType, dstType) = dim(srcType) | common super class of srcType and dstType. mergedType = (srcType & DIM_MASK) | REFERENCE_KIND | symbolTable.addMergedType(srcType & VALUE_MASK, dstType & VALUE_MASK); } else { // If srcType and dstType are array types of equal dimension but different element types, // merge(srcType, dstType) = dim(srcType) - 1 | java/lang/Object. int mergedDim = ELEMENT_OF + (srcType & DIM_MASK); mergedType = mergedDim | REFERENCE_KIND | symbolTable.addType("java/lang/Object"); } } else if ((srcType & DIM_MASK) != 0 || (srcType & KIND_MASK) == REFERENCE_KIND) { // If srcType is any other reference or array type, // merge(srcType, dstType) = min(srcDdim, dstDim) | java/lang/Object // where srcDim is the array dimension of srcType, minus 1 if srcType is an array type // with a non reference element type (and similarly for dstDim). int srcDim = srcType & DIM_MASK; if (srcDim != 0 && (srcType & KIND_MASK) != REFERENCE_KIND) { srcDim = ELEMENT_OF + srcDim; } int dstDim = dstType & DIM_MASK; if (dstDim != 0 && (dstType & KIND_MASK) != REFERENCE_KIND) { dstDim = ELEMENT_OF + dstDim; } mergedType = Math.min(srcDim, dstDim) | REFERENCE_KIND | symbolTable.addType("java/lang/Object"); } else { // If srcType is any other type, merge(srcType, dstType) = TOP. mergedType = TOP; } } else if (dstType == NULL) { // If dstType is the NULL type, merge(srcType, dstType) = srcType, or TOP if srcType is not a // an array type or a reference type. mergedType = (srcType & DIM_MASK) != 0 || (srcType & KIND_MASK) == REFERENCE_KIND ? srcType : TOP; } else { // If dstType is any other type, merge(srcType, dstType) = TOP whatever srcType. mergedType = TOP; } if (mergedType != dstType) { dstTypes[dstIndex] = mergedType; return true; } return false; } // ----------------------------------------------------------------------------------------------- // Frame output methods, to generate StackMapFrame attributes // ----------------------------------------------------------------------------------------------- /** * Makes the given {@link MethodWriter} visit the input frame of this {@link Frame}. The visit is * done with the {@link MethodWriter#visitFrameStart}, {@link MethodWriter#visitAbstractType} and * {@link MethodWriter#visitFrameEnd} methods. * * @param methodWriter the {@link MethodWriter} that should visit the input frame of this {@link * Frame}. */ final void accept(final MethodWriter methodWriter) { // Compute the number of locals, ignoring TOP types that are just after a LONG or a DOUBLE, and // all trailing TOP types. int[] localTypes = inputLocals; int numLocal = 0; int numTrailingTop = 0; int i = 0; while (i < localTypes.length) { int localType = localTypes[i]; i += (localType == LONG || localType == DOUBLE) ? 2 : 1; if (localType == TOP) { numTrailingTop++; } else { numLocal += numTrailingTop + 1; numTrailingTop = 0; } } // Compute the stack size, ignoring TOP types that are just after a LONG or a DOUBLE. int[] stackTypes = inputStack; int numStack = 0; i = 0; while (i < stackTypes.length) { int stackType = stackTypes[i]; i += (stackType == LONG || stackType == DOUBLE) ? 2 : 1; numStack++; } // Visit the frame and its content. int frameIndex = methodWriter.visitFrameStart(owner.bytecodeOffset, numLocal, numStack); i = 0; while (numLocal-- > 0) { int localType = localTypes[i]; i += (localType == LONG || localType == DOUBLE) ? 2 : 1; methodWriter.visitAbstractType(frameIndex++, localType); } i = 0; while (numStack-- > 0) { int stackType = stackTypes[i]; i += (stackType == LONG || stackType == DOUBLE) ? 2 : 1; methodWriter.visitAbstractType(frameIndex++, stackType); } methodWriter.visitFrameEnd(); } /** * Put the given abstract type in the given ByteVector, using the JVMS verification_type_info * format used in StackMapTable attributes. * * @param symbolTable the type table to use to lookup and store type {@link Symbol}. * @param abstractType an abstract type, restricted to {@link Frame#CONSTANT_KIND}, {@link * Frame#REFERENCE_KIND} or {@link Frame#UNINITIALIZED_KIND} types. * @param output where the abstract type must be put. * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.4">JVMS * 4.7.4</a> */ static void putAbstractType(final SymbolTable symbolTable, final int abstractType, final ByteVector output) { int arrayDimensions = (abstractType & Frame.DIM_MASK) >> DIM_SHIFT; if (arrayDimensions == 0) { int typeValue = abstractType & VALUE_MASK; switch (abstractType & KIND_MASK) { case CONSTANT_KIND: output.putByte(typeValue); break; case REFERENCE_KIND: output.putByte(ITEM_OBJECT) .putShort(symbolTable.addConstantClass(symbolTable.getType(typeValue).value).index); break; case UNINITIALIZED_KIND: output.putByte(ITEM_UNINITIALIZED).putShort((int) symbolTable.getType(typeValue).data); break; default: throw new AssertionError(); } } else { // Case of an array type, we need to build its descriptor first. StringBuilder typeDescriptor = new StringBuilder(); while (arrayDimensions-- > 0) { typeDescriptor.append('['); } if ((abstractType & KIND_MASK) == REFERENCE_KIND) { typeDescriptor.append('L').append(symbolTable.getType(abstractType & VALUE_MASK).value).append(';'); } else { switch (abstractType & VALUE_MASK) { case Frame.ITEM_ASM_BOOLEAN: typeDescriptor.append('Z'); break; case Frame.ITEM_ASM_BYTE: typeDescriptor.append('B'); break; case Frame.ITEM_ASM_CHAR: typeDescriptor.append('C'); break; case Frame.ITEM_ASM_SHORT: typeDescriptor.append('S'); break; case Frame.ITEM_INTEGER: typeDescriptor.append('I'); break; case Frame.ITEM_FLOAT: typeDescriptor.append('F'); break; case Frame.ITEM_LONG: typeDescriptor.append('J'); break; case Frame.ITEM_DOUBLE: typeDescriptor.append('D'); break; default: throw new AssertionError(); } } output.putByte(ITEM_OBJECT).putShort(symbolTable.addConstantClass(typeDescriptor.toString()).index); } } }