| /** |
| * ASM: a very small and fast Java bytecode manipulation framework |
| * Copyright (c) 2000-2005 INRIA, France Telecom |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| package org.objectweb.asm.attrs; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import org.objectweb.asm.Attribute; |
| import org.objectweb.asm.ByteVector; |
| import org.objectweb.asm.ClassReader; |
| import org.objectweb.asm.ClassWriter; |
| import org.objectweb.asm.Label; |
| import org.objectweb.asm.Opcodes; |
| import org.objectweb.asm.Type; |
| |
| /** |
| * The stack map attribute is used during the process of verification by |
| * typechecking (§4.11.1). <br> <br> A stack map attribute consists of zero or |
| * more stack map frames. Each stack map frame specifies (either explicitly or |
| * implicitly) a bytecode offset, the verification types (§4.11.1) for the local |
| * variables, and the verification types for the operand stack. <br> <br> The |
| * type checker deals with and manipulates the expected types of a method's |
| * local variables and operand stack. Throughout this section, a location refers |
| * to either a single local variable or to a single operand stack entry. <br> |
| * <br> We will use the terms stack frame map and type state interchangeably to |
| * describe a mapping from locations in the operand stack and local variables of |
| * a method to verification types. We will usually use the term stack frame map |
| * when such a mapping is provided in the class file, and the term type state |
| * when the mapping is inferred by the type checker. <br> <br> If a method's |
| * Code attribute does not have a StackMapTable attribute, it has an implicit |
| * stack map attribute. This implicit stack map attribute is equivalent to a |
| * StackMapTable attribute with number_of_entries equal to zero. A method's Code |
| * attribute may have at most one StackMapTable attribute, otherwise a |
| * java.lang.ClassFormatError is thrown. <br> <br> The format of the stack map |
| * in the class file is given below. In the following, if the length of the |
| * method's byte code is 65535 or less, then uoffset represents the type u2; |
| * otherwise uoffset represents the type u4. If the maximum number of local |
| * variables for the method is 65535 or less, then <code>ulocalvar</code> |
| * represents the type u2; otherwise ulocalvar represents the type u4. If the |
| * maximum size of the operand stack is 65535 or less, then <code>ustack</code> |
| * represents the type u2; otherwise ustack represents the type u4. |
| * |
| * <pre> |
| * stack_map { // attribute StackMapTable |
| * u2 attribute_name_index; |
| * u4 attribute_length |
| * uoffset number_of_entries; |
| * stack_map_frame entries[number_of_entries]; |
| * } |
| * </pre> |
| * |
| * Each stack_map_frame structure specifies the type state at a particular byte |
| * code offset. Each frame type specifies (explicitly or implicitly) a value, |
| * offset_delta, that is used to calulate the actual byte code offset at which |
| * it applies. The byte code offset at which the frame applies is given by |
| * adding <code>1 + offset_delta</code> to the <code>offset</code> of the |
| * previous frame, unless the previous frame is the initial frame of the method, |
| * in which case the byte code offset is <code>offset_delta</code>. <br> <br> |
| * <i>Note that the length of the byte codes is not the same as the length of |
| * the Code attribute. The byte codes are embedded in the Code attribute, along |
| * with other information.</i> <br> <br> By using an offset delta rather than |
| * the actual byte code offset we ensure, by definition, that stack map frames |
| * are in the correctly sorted order. Furthermore, by consistently using the |
| * formula <code>offset_delta + 1</code> for all explicit frames, we guarantee |
| * the absence of duplicates. <br> <br> All frame types, even full_frame, rely |
| * on the previous frame for some of their semantics. This raises the question |
| * of what is the very first frame? The initial frame is implicit, and computed |
| * from the method descriptor. See the Prolog code for methodInitialStacFrame. |
| * <br> <br> The stack_map_frame structure consists of a one-byte tag followed |
| * by zero or more bytes, giving more information, depending upon the tag. <br> |
| * <br> A stack map frame may belong to one of several frame types |
| * |
| * <pre> |
| * union stack_map_frame { |
| * same_frame; |
| * same_locals_1_stack_item_frame; |
| * chop_frame; |
| * same_frame_extended; |
| * append_frame; |
| * full_frame; |
| * } |
| * </pre> |
| * |
| * The frame type same_frame is represented by tags in the range [0-63]. If the |
| * frame type is same_frame, it means the frame has exactly the same locals as |
| * the previous stack map frame and that the number of stack items is zero. The |
| * offset_delta value for the frame is the value of the tag field, frame_type. |
| * The form of such a frame is then: |
| * |
| * <pre> |
| * same_frame { |
| * u1 frame_type = SAME; // 0-63 |
| * } |
| * </pre> |
| * |
| * The frame type same_locals_1_stack_item_frame is represented by tags in the |
| * range [64, 127]. If the frame_type is same_locals_1_stack_item_frame, it |
| * means the frame has exactly the same locals as the previous stack map frame |
| * and that the number of stack items is 1. The offset_delta value for the frame |
| * is the value (frame_type - 64). There is a verification_type_info following |
| * the frame_type for the one stack item. The form of such a frame is then: |
| * |
| * <pre> |
| * same_locals_1_stack_item_frame { |
| * u1 frame_type = SAME_LOCALS_1_STACK_ITEM; // 64-127 |
| * verification_type_info stack[1]; |
| * } |
| * </pre> |
| * |
| * Tags in the range [128-247] are reserved for future use. <br> <br> The frame |
| * type chop_frame is represented by tags in the range [248-250]. If the |
| * frame_type is chop_frame, it means that the 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. <br> <br> The form of |
| * such a frame is then: |
| * |
| * <pre> |
| * chop_frame { |
| * u1 frame_type=CHOP; // 248-250 |
| * uoffset offset_delta; |
| * } |
| * </pre> |
| * |
| * The frame type same_frame_extended is represented by the tag value 251. If |
| * the frame type is same_frame_extended, it means the frame has exactly the |
| * same locals as the previous stack map frame and that the number of stack |
| * items is zero. The form of such a frame is then: |
| * |
| * <pre> |
| * same_frame_extended { |
| * u1 frame_type = SAME_FRAME_EXTENDED; // 251 |
| * uoffset offset_delta; |
| * } |
| * </pre> |
| * |
| * The frame type append_frame is represented by tags in the range [252-254]. If |
| * the frame_type is append_frame, it means that the 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. <br> <br> The |
| * form of such a frame is then: |
| * |
| * <pre> |
| * append_frame { |
| * u1 frame_type =APPEND; // 252-254 |
| * uoffset offset_delta; |
| * verification_type_info locals[frame_type -251]; |
| * } |
| * </pre> |
| * |
| * The 0th entry in locals represents the type of the first additional local |
| * variable. If locals[M] represents local variable N, then locals[M+1] |
| * represents local variable N+1 if locals[M] is one of Top_variable_info, |
| * Integer_variable_info, Float_variable_info, Null_variable_info, |
| * UninitializedThis_variable_info, Object_variable_info, or |
| * Uninitialized_variable_info, otherwise locals[M+1] represents local variable |
| * N+2. It is an error if, for any index i, locals[i] represents a local |
| * variable whose index is greater than the maximum number of local variables |
| * for the method. <br> <br> The frame type full_frame is represented by the tag |
| * value 255. The form of such a frame is then: |
| * |
| * <pre> |
| * full_frame { |
| * u1 frame_type = FULL_FRAME; // 255 |
| * uoffset offset_delta; |
| * ulocalvar number_of_locals; |
| * verification_type_info locals[number_of_locals]; |
| * ustack number_of_stack_items; |
| * verification_type_info stack[number_of_stack_items]; |
| * } |
| * </pre> |
| * |
| * The 0th entry in locals represents the type of local variable 0. If locals[M] |
| * represents local variable N, then locals[M+1] represents local variable N+1 |
| * if locals[M] is one of Top_variable_info, Integer_variable_info, |
| * Float_variable_info, Null_variable_info, UninitializedThis_variable_info, |
| * Object_variable_info, or Uninitialized_variable_info, otherwise locals[M+1] |
| * represents local variable N+2. It is an error if, for any index i, locals[i] |
| * represents a local variable whose index is greater than the maximum number of |
| * local variables for the method. <br> <br> The 0th entry in stack represents |
| * the type of the bottom of the stack, and subsequent entries represent types |
| * of stack elements closer to the top of the operand stack. We shall refer to |
| * the bottom element of the stack as stack element 0, and to subsequent |
| * elements as stack element 1, 2 etc. If stack[M] represents stack element N, |
| * then stack[M+1] represents stack element N+1 if stack[M] is one of |
| * Top_variable_info, Integer_variable_info, Float_variable_info, |
| * Null_variable_info, UninitializedThis_variable_info, Object_variable_info, or |
| * Uninitialized_variable_info, otherwise stack[M+1] represents stack element |
| * N+2. It is an error if, for any index i, stack[i] represents a stack entry |
| * whose index is greater than the maximum operand stack size for the method. |
| * <br> <br> We say that an instruction in the byte code has a corresponding |
| * stack map frame if the offset in the offset field of the stack map frame is |
| * the same as the offset of the instruction in the byte codes. <br> <br> The |
| * verification_type_info structure consists of a one-byte tag followed by zero |
| * or more bytes, giving more information about the tag. Each |
| * verification_type_info structure specifies the verification type of one or |
| * two locations. |
| * |
| * <pre> |
| * union verification_type_info { |
| * Top_variable_info; |
| * Integer_variable_info; |
| * Float_variable_info; |
| * Long_variable_info; |
| * Double_variable_info; |
| * Null_variable_info; |
| * UninitializedThis_variable_info; |
| * Object_variable_info; |
| * Uninitialized_variable_info; |
| * } |
| * </pre> |
| * |
| * The Top_variable_info type indicates that the local variable has the |
| * verification type top (T.) |
| * |
| * <pre> |
| * Top_variable_info { |
| * u1 tag = ITEM_Top; // 0 |
| * } |
| * </pre> |
| * |
| * The Integer_variable_info type indicates that the location contains the |
| * verification type int. |
| * |
| * <pre> |
| * Integer_variable_info { |
| * u1 tag = ITEM_Integer; // 1 |
| * } |
| * </pre> |
| * |
| * The Float_variable_info type indicates that the location contains the |
| * verification type float. |
| * |
| * <pre> |
| * Float_variable_info { |
| * u1 tag = ITEM_Float; // 2 |
| * } |
| * </pre> |
| * |
| * The Long_variable_info type indicates that the location contains the |
| * verification type long. If the location is a local variable, then: |
| * |
| * <ul> <li>It must not be the local variable with the highest index.</li> |
| * <li>The next higher numbered local variable contains the verification type |
| * T.</li> </ul> |
| * |
| * If the location is an operand stack entry, then: |
| * |
| * <ul> <li>The current location must not be the topmost location of the |
| * operand stack.</li> <li>the next location closer to the top of the operand |
| * stack contains the verification type T.</li> </ul> |
| * |
| * This structure gives the contents of two locations in the operand stack or in |
| * the local variables. |
| * |
| * <pre> |
| * Long_variable_info { |
| * u1 tag = ITEM_Long; // 4 |
| * } |
| * </pre> |
| * |
| * The Double_variable_info type indicates that the location contains the |
| * verification type double. If the location is a local variable, then: |
| * |
| * <ul> <li>It must not be the local variable with the highest index.</li> |
| * <li>The next higher numbered local variable contains the verification type |
| * T. <li> </ul> |
| * |
| * If the location is an operand stack entry, then: |
| * |
| * <ul> <li>The current location must not be the topmost location of the |
| * operand stack.</li> <li>the next location closer to the top of the operand |
| * stack contains the verification type T.</li> </ul> |
| * |
| * This structure gives the contents of two locations in in the operand stack or |
| * in the local variables. |
| * |
| * <pre> |
| * Double_variable_info { |
| * u1 tag = ITEM_Double; // 3 |
| * } |
| * </pre> |
| * |
| * The Null_variable_info type indicates that location contains the verification |
| * type null. |
| * |
| * <pre> |
| * Null_variable_info { |
| * u1 tag = ITEM_Null; // 5 |
| * } |
| * </pre> |
| * |
| * The UninitializedThis_variable_info type indicates that the location contains |
| * the verification type uninitializedThis. |
| * |
| * <pre> |
| * UninitializedThis_variable_info { |
| * u1 tag = ITEM_UninitializedThis; // 6 |
| * } |
| * </pre> |
| * |
| * The Object_variable_info type indicates that the location contains an |
| * instance of the class referenced by the constant pool entry. |
| * |
| * <pre> |
| * Object_variable_info { |
| * u1 tag = ITEM_Object; // 7 |
| * u2 cpool_index; |
| * } |
| * </pre> |
| * |
| * The Uninitialized_variable_info indicates that the location contains the |
| * verification type uninitialized(offset). The offset item indicates the offset |
| * of the new instruction that created the object being stored in the location. |
| * |
| * <pre> |
| * Uninitialized_variable_info { |
| * u1 tag = ITEM_Uninitialized // 8 |
| * uoffset offset; |
| * } |
| * </pre> |
| * |
| * @see "ClassFileFormat-Java6.fm Page 138 Friday, April 15, 2005 3:22 PM" |
| * |
| * @author Eugene Kuleshov |
| */ |
| public class StackMapTableAttribute extends Attribute { |
| /** |
| * Frame has exactly the same locals as the previous stack map frame and |
| * number of stack items is zero. |
| */ |
| public 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 |
| */ |
| public static final int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; // to 127 |
| |
| // (40-7f) |
| |
| /** |
| * Reserved for future use |
| */ |
| public 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; |
| */ |
| public 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. |
| */ |
| public 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; |
| */ |
| public 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. |
| */ |
| public static final int APPEND_FRAME = 252; // to 254 // fc-fe |
| |
| /** |
| * Full frame |
| */ |
| public static final int FULL_FRAME = 255; // ff |
| |
| private static final int MAX_SHORT = 65535; |
| |
| /** |
| * A <code>List</code> of <code>StackMapFrame</code> instances. |
| */ |
| private List frames; |
| |
| public StackMapTableAttribute() { |
| super("StackMapTable"); |
| } |
| |
| public StackMapTableAttribute(List frames) { |
| this(); |
| this.frames = frames; |
| } |
| |
| public List getFrames() { |
| return frames; |
| } |
| |
| public StackMapFrame getFrame(Label label) { |
| for (int i = 0; i < frames.size(); i++) { |
| StackMapFrame frame = (StackMapFrame) frames.get(i); |
| if (frame.label == label) { |
| return frame; |
| } |
| } |
| return null; |
| } |
| |
| public boolean isUnknown() { |
| return false; |
| } |
| |
| public boolean isCodeAttribute() { |
| return true; |
| } |
| |
| protected Attribute read( |
| ClassReader cr, |
| int off, |
| int len, |
| char[] buf, |
| int codeOff, |
| Label[] labels) |
| { |
| |
| ArrayList frames = new ArrayList(); |
| |
| // note that this is not the size of Code attribute |
| boolean isExtCodeSize = cr.readInt(codeOff + 4) > MAX_SHORT; |
| boolean isExtLocals = cr.readUnsignedShort(codeOff + 2) > MAX_SHORT; |
| boolean isExtStack = cr.readUnsignedShort(codeOff) > MAX_SHORT; |
| |
| int offset = 0; |
| |
| int methodOff = getMethodOff(cr, codeOff, buf); |
| StackMapFrame frame = new StackMapFrame(getLabel(offset, labels), |
| calculateLocals(cr.readClass(cr.header + 2, buf), // owner |
| cr.readUnsignedShort(methodOff), // method access |
| cr.readUTF8(methodOff + 2, buf), // method name |
| cr.readUTF8(methodOff + 4, buf)), // method desc |
| Collections.EMPTY_LIST); |
| frames.add(frame); |
| |
| // System.err.println( cr.readUTF8( methodOff + 2, buf)); |
| // System.err.println( offset +" delta:" + 0 +" : "+ frame); |
| |
| int size; |
| if (isExtCodeSize) { |
| size = cr.readInt(off); |
| off += 4; |
| } else { |
| size = cr.readUnsignedShort(off); |
| off += 2; |
| } |
| |
| for (; size > 0; size--) { |
| int tag = cr.readByte(off); // & 0xff; |
| off++; |
| |
| List stack; |
| List locals; |
| |
| int offsetDelta; |
| if (tag < SAME_LOCALS_1_STACK_ITEM_FRAME) { // SAME_FRAME |
| offsetDelta = tag; |
| |
| locals = new ArrayList(frame.locals); |
| stack = Collections.EMPTY_LIST; |
| |
| } else if (tag < RESERVED) { // SAME_LOCALS_1_STACK_ITEM_FRAME |
| offsetDelta = tag - SAME_LOCALS_1_STACK_ITEM_FRAME; |
| |
| locals = new ArrayList(frame.locals); |
| stack = new ArrayList(); |
| // read verification_type_info stack[1]; |
| off = readType(stack, isExtCodeSize, cr, off, labels, buf); |
| |
| } else { |
| if (isExtCodeSize) { |
| offsetDelta = cr.readInt(off); |
| off += 4; |
| } else { |
| offsetDelta = cr.readUnsignedShort(off); |
| off += 2; |
| } |
| |
| if (tag == SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) { // SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED |
| locals = new ArrayList(frame.locals); |
| stack = new ArrayList(); |
| // read verification_type_info stack[1]; |
| off = readType(stack, isExtCodeSize, cr, off, labels, buf); |
| |
| } else if (tag >= CHOP_FRAME && tag < SAME_FRAME_EXTENDED) { // CHOP_FRAME |
| stack = Collections.EMPTY_LIST; |
| |
| int k = SAME_FRAME_EXTENDED - tag; |
| // copy locals from prev frame and chop last k |
| locals = new ArrayList(frame.locals.subList(0, |
| frame.locals.size() - k)); |
| |
| } else if (tag == SAME_FRAME_EXTENDED) { // SAME_FRAME_EXTENDED |
| stack = Collections.EMPTY_LIST; |
| locals = new ArrayList(frame.locals); |
| |
| } else if ( /* tag>=APPEND && */tag < FULL_FRAME) { // APPEND_FRAME |
| stack = Collections.EMPTY_LIST; |
| |
| // copy locals from prev frame and append new k |
| locals = new ArrayList(frame.locals); |
| for (int k = tag - SAME_FRAME_EXTENDED; k > 0; k--) { |
| off = readType(locals, |
| isExtCodeSize, |
| cr, |
| off, |
| labels, |
| buf); |
| } |
| |
| } else if (tag == FULL_FRAME) { // FULL_FRAME |
| // read verification_type_info locals[number_of_locals]; |
| locals = new ArrayList(); |
| off = readTypes(locals, |
| isExtLocals, |
| isExtCodeSize, |
| cr, |
| off, |
| labels, |
| buf); |
| |
| // read verification_type_info stack[number_of_stack_items]; |
| stack = new ArrayList(); |
| off = readTypes(stack, |
| isExtStack, |
| isExtCodeSize, |
| cr, |
| off, |
| labels, |
| buf); |
| |
| } else { |
| throw new RuntimeException("Unknown frame type " + tag |
| + " after offset " + offset); |
| |
| } |
| } |
| |
| offset += offsetDelta; |
| |
| Label offsetLabel = getLabel(offset, labels); |
| |
| frame = new StackMapFrame(offsetLabel, locals, stack); |
| frames.add(frame); |
| // System.err.println( tag +" " + offset +" delta:" + offsetDelta + |
| // " frameType:"+ frameType+" : "+ frame); |
| |
| offset++; |
| } |
| |
| return new StackMapTableAttribute(frames); |
| } |
| |
| protected ByteVector write( |
| ClassWriter cw, |
| byte[] code, |
| int len, |
| int maxStack, |
| int maxLocals) |
| { |
| ByteVector bv = new ByteVector(); |
| // TODO verify this value (MAX_SHORT) |
| boolean isExtCodeSize = code != null && code.length > MAX_SHORT; |
| writeSize(frames.size() - 1, bv, isExtCodeSize); |
| |
| if (frames.size() < 2) { |
| return bv; |
| } |
| |
| boolean isExtLocals = maxLocals > MAX_SHORT; |
| boolean isExtStack = maxStack > MAX_SHORT; |
| |
| // skip the first frame |
| StackMapFrame frame = (StackMapFrame) frames.get(0); |
| List locals = frame.locals; |
| int offset = frame.label.getOffset(); |
| |
| for (int i = 1; i < frames.size(); i++) { |
| frame = (StackMapFrame) frames.get(i); |
| |
| List clocals = frame.locals; |
| List cstack = frame.stack; |
| int coffset = frame.label.getOffset(); |
| |
| int clocalsSize = clocals.size(); |
| int cstackSize = cstack.size(); |
| |
| int localsSize = locals.size(); |
| |
| int delta = coffset - offset; |
| |
| int type = FULL_FRAME; |
| int k = 0; |
| if (cstackSize == 0) { |
| k = clocalsSize - localsSize; |
| switch (k) { |
| case -3: |
| case -2: |
| case -1: |
| type = CHOP_FRAME; // CHOP or FULL |
| localsSize = clocalsSize; // for full_frame check |
| break; |
| |
| case 0: |
| // SAME, SAME_EXTENDED or FULL |
| type = delta < 64 ? SAME_FRAME : SAME_FRAME_EXTENDED; |
| break; |
| |
| case 1: |
| case 2: |
| case 3: |
| type = APPEND_FRAME; // APPEND or FULL |
| break; |
| } |
| } else if (localsSize == clocalsSize && cstackSize == 1) { |
| // SAME_LOCAL_1_STACK or FULL |
| type = delta < 63 |
| ? SAME_LOCALS_1_STACK_ITEM_FRAME |
| : SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED; |
| } |
| |
| if (type != FULL_FRAME) { |
| // verify if stack and locals are the same |
| for (int j = 0; j < localsSize && type != FULL_FRAME; j++) { |
| if (!locals.get(j).equals(clocals.get(j))) |
| type = FULL_FRAME; |
| } |
| } |
| |
| switch (type) { |
| case SAME_FRAME: |
| bv.putByte(delta); |
| break; |
| |
| case SAME_LOCALS_1_STACK_ITEM_FRAME: |
| bv.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta); |
| writeTypeInfos(bv, cw, cstack, 0, 1); |
| break; |
| |
| case SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED: |
| bv.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED); |
| writeSize(delta, bv, isExtCodeSize); |
| writeTypeInfos(bv, cw, cstack, 0, 1); |
| break; |
| |
| case SAME_FRAME_EXTENDED: |
| bv.putByte(SAME_FRAME_EXTENDED); |
| writeSize(delta, bv, isExtCodeSize); |
| break; |
| |
| case CHOP_FRAME: |
| bv.putByte(SAME_FRAME_EXTENDED + k); // negative k |
| writeSize(delta, bv, isExtCodeSize); |
| break; |
| |
| case APPEND_FRAME: |
| bv.putByte(SAME_FRAME_EXTENDED + k); // positive k |
| writeSize(delta, bv, isExtCodeSize); |
| writeTypeInfos(bv, |
| cw, |
| clocals, |
| clocalsSize - 1, |
| clocalsSize); |
| break; |
| |
| case FULL_FRAME: |
| bv.putByte(FULL_FRAME); |
| writeSize(delta, bv, isExtCodeSize); |
| writeSize(clocalsSize, bv, isExtLocals); |
| writeTypeInfos(bv, cw, clocals, 0, clocalsSize); |
| writeSize(cstackSize, bv, isExtStack); |
| writeTypeInfos(bv, cw, cstack, 0, cstackSize); |
| break; |
| |
| default: |
| throw new RuntimeException(); |
| } |
| offset = coffset + 1; // compensating non first offset |
| locals = clocals; |
| } |
| return bv; |
| } |
| |
| private void writeSize(int delta, ByteVector bv, boolean isExt) { |
| if (isExt) { |
| bv.putInt(delta); |
| } else { |
| bv.putShort(delta); |
| } |
| } |
| |
| private void writeTypeInfos( |
| ByteVector bv, |
| ClassWriter cw, |
| List info, |
| int start, |
| int end) |
| { |
| for (int j = start; j < end; j++) { |
| StackMapType typeInfo = (StackMapType) info.get(j); |
| bv.putByte(typeInfo.getType()); |
| |
| switch (typeInfo.getType()) { |
| case StackMapType.ITEM_Object: // |
| bv.putShort(cw.newClass(typeInfo.getObject())); |
| break; |
| |
| case StackMapType.ITEM_Uninitialized: // |
| bv.putShort(typeInfo.getLabel().getOffset()); |
| break; |
| |
| } |
| } |
| } |
| |
| public static int getMethodOff(ClassReader cr, int codeOff, char[] buf) { |
| int off = cr.header + 6; |
| |
| int interfacesCount = cr.readUnsignedShort(off); |
| off += 2 + interfacesCount * 2; |
| |
| int fieldsCount = cr.readUnsignedShort(off); |
| off += 2; |
| for (; fieldsCount > 0; --fieldsCount) { |
| int attrCount = cr.readUnsignedShort(off + 6); // field attributes |
| off += 8; |
| for (; attrCount > 0; --attrCount) { |
| off += 6 + cr.readInt(off + 2); |
| } |
| } |
| |
| int methodsCount = cr.readUnsignedShort(off); |
| off += 2; |
| for (; methodsCount > 0; --methodsCount) { |
| int methodOff = off; |
| int attrCount = cr.readUnsignedShort(off + 6); // method attributes |
| off += 8; |
| for (; attrCount > 0; --attrCount) { |
| String attrName = cr.readUTF8(off, buf); |
| off += 6; |
| if (attrName.equals("Code")) { |
| if (codeOff == off) { |
| return methodOff; |
| } |
| } |
| off += cr.readInt(off - 4); |
| } |
| } |
| |
| return -1; |
| } |
| |
| /** |
| * Use method signature and access flags to resolve initial locals state. |
| * |
| * @param className name of the method's owner class. |
| * @param access access flags of the method. |
| * @param methodName name of the method. |
| * @param methodDesc descriptor of the method. |
| * @return list of <code>StackMapType</code> instances representing locals |
| * for an initial frame. |
| */ |
| public static List calculateLocals( |
| String className, |
| int access, |
| String methodName, |
| String methodDesc) |
| { |
| List locals = new ArrayList(); |
| |
| // TODO |
| if ("<init>".equals(methodName) |
| && !className.equals("java/lang/Object")) |
| { |
| StackMapType typeInfo = StackMapType.getTypeInfo(StackMapType.ITEM_UninitializedThis); |
| typeInfo.setObject(className); // this |
| locals.add(typeInfo); |
| } else if ((access & Opcodes.ACC_STATIC) == 0) { |
| StackMapType typeInfo = StackMapType.getTypeInfo(StackMapType.ITEM_Object); |
| typeInfo.setObject(className); // this |
| locals.add(typeInfo); |
| } |
| |
| Type[] types = Type.getArgumentTypes(methodDesc); |
| for (int i = 0; i < types.length; i++) { |
| Type t = types[i]; |
| StackMapType smt; |
| switch (t.getSort()) { |
| case Type.LONG: |
| smt = StackMapType.getTypeInfo(StackMapType.ITEM_Long); |
| break; |
| case Type.DOUBLE: |
| smt = StackMapType.getTypeInfo(StackMapType.ITEM_Double); |
| break; |
| |
| case Type.FLOAT: |
| smt = StackMapType.getTypeInfo(StackMapType.ITEM_Float); |
| break; |
| |
| case Type.ARRAY: |
| case Type.OBJECT: |
| smt = StackMapType.getTypeInfo(StackMapType.ITEM_Object); |
| smt.setObject(t.getDescriptor()); // TODO verify name |
| break; |
| |
| default: |
| smt = StackMapType.getTypeInfo(StackMapType.ITEM_Integer); |
| break; |
| } |
| } |
| |
| return locals; |
| } |
| |
| private int readTypes( |
| List info, |
| boolean isExt, |
| boolean isExtCodeSize, |
| ClassReader cr, |
| int off, |
| Label[] labels, |
| char[] buf) |
| { |
| int n = 0; |
| if (isExt) { |
| n = cr.readInt(off); |
| off += 4; |
| } else { |
| n = cr.readUnsignedShort(off); |
| off += 2; |
| } |
| |
| for (; n > 0; n--) { |
| off = readType(info, isExtCodeSize, cr, off, labels, buf); |
| } |
| return off; |
| } |
| |
| private int readType( |
| List info, |
| boolean isExtCodeSize, |
| ClassReader cr, |
| int off, |
| Label[] labels, |
| char[] buf) |
| { |
| int itemType = cr.readByte(off++); |
| StackMapType typeInfo = StackMapType.getTypeInfo(itemType); |
| info.add(typeInfo); |
| switch (itemType) { |
| // case StackMapType.ITEM_Long: // |
| // case StackMapType.ITEM_Double: // |
| // info.add(StackMapType.getTypeInfo(StackMapType.ITEM_Top)); |
| // break; |
| |
| case StackMapType.ITEM_Object: // |
| typeInfo.setObject(cr.readClass(off, buf)); |
| off += 2; |
| break; |
| |
| case StackMapType.ITEM_Uninitialized: // |
| int offset; |
| if (isExtCodeSize) { |
| offset = cr.readInt(off); |
| off += 4; |
| } else { |
| offset = cr.readUnsignedShort(off); |
| off += 2; |
| } |
| |
| typeInfo.setLabel(getLabel(offset, labels)); |
| break; |
| } |
| return off; |
| } |
| |
| private Label getLabel(int offset, Label[] labels) { |
| Label l = labels[offset]; |
| if (l != null) { |
| return l; |
| } |
| return labels[offset] = new Label(); |
| } |
| |
| public String toString() { |
| StringBuffer sb = new StringBuffer("StackMapTable["); |
| for (int i = 0; i < frames.size(); i++) { |
| sb.append('\n').append('[').append(frames.get(i)).append(']'); |
| } |
| sb.append("\n]"); |
| return sb.toString(); |
| } |
| } |
