From: chiba Date: Thu, 8 Oct 2009 22:14:55 +0000 (+0000) Subject: snapshot X-Git-Tag: rel_3_17_1_ga~155 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=c6ec7f23fac10ba8c9afa751b34bb00efd276a1c;p=javassist.git snapshot git-svn-id: http://anonsvn.jboss.org/repos/javassist/trunk@494 30ef5769-5b8d-40dd-aea6-55b5d6557bb3 --- diff --git a/src/main/javassist/bytecode/AttributeInfo.java b/src/main/javassist/bytecode/AttributeInfo.java index 915f291f..77f1686d 100644 --- a/src/main/javassist/bytecode/AttributeInfo.java +++ b/src/main/javassist/bytecode/AttributeInfo.java @@ -112,6 +112,8 @@ public class AttributeInfo { return new SourceFileAttribute(cp, name, in); else if (nameStr.equals(SyntheticAttribute.tag)) return new SyntheticAttribute(cp, name, in); + else if (nameStr.equals(StackMap.tag)) + return new StackMap(cp, name, in); else if (nameStr.equals(StackMapTable.tag)) return new StackMapTable(cp, name, in); } diff --git a/src/main/javassist/bytecode/StackMap.java b/src/main/javassist/bytecode/StackMap.java new file mode 100644 index 00000000..b5748d90 --- /dev/null +++ b/src/main/javassist/bytecode/StackMap.java @@ -0,0 +1,233 @@ +/* + * Javassist, a Java-bytecode translator toolkit. + * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved. + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. Alternatively, the contents of this file may be used under + * the terms of the GNU Lesser General Public License Version 2.1 or later. + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + */ + +package javassist.bytecode; + +import java.io.DataInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.Map; +import javassist.bytecode.stackmap.*; + +/** + * Another stack_map attribute defined in CLDC 1.1 for J2ME. + * + *

This is an entry in the attributes table of a Code attribute. + * It was introduced by J2ME CLDC 1.1 (JSR 139) for pre-verification. + * + *

According to the CLDC specification, the sizes of some fields are not 16bit + * but 32bit if the code size is more than 64K or the number of the local variables + * is more than 64K. However, for the J2ME CLDC technology, they are always 16bit. + * The implementation of the StackMap class assumes they are 16bit. + * + * @see StackMapTable + * @since 3.12 + */ +public class StackMap extends AttributeInfo { + /** + * The name of this attribute "StackMap". + */ + public static final String tag = "StackMap"; + + + /** + * Constructs a stack_map attribute. + */ + StackMap(ConstPool cp, byte[] newInfo) { + super(cp, tag, newInfo); + } + + StackMap(ConstPool cp, int name_id, DataInputStream in) + throws IOException + { + super(cp, name_id, in); + } + + /** + * Returns number_of_entries. + */ + public int numOfEntries() { + return ByteArray.readU16bit(info, 0); + } + + /** + * Top_variable_info.tag. + */ + public static final int TOP = 0; + + /** + * Integer_variable_info.tag. + */ + public static final int INTEGER = 1; + + /** + * Float_variable_info.tag. + */ + public static final int FLOAT = 2; + + /** + * Double_variable_info.tag. + */ + public static final int DOUBLE = 3; + + /** + * Long_variable_info.tag. + */ + public static final int LONG = 4; + + /** + * Null_variable_info.tag. + */ + public static final int NULL = 5; + + /** + * UninitializedThis_variable_info.tag. + */ + public static final int THIS = 6; + + /** + * Object_variable_info.tag. + */ + public static final int OBJECT = 7; + + /** + * Uninitialized_variable_info.tag. + */ + public static final int UNINIT = 8; + + /** + * Makes a copy. + */ + public AttributeInfo copy(ConstPool newCp, Map classnames) { + ConstPool cp = getConstPool(); + byte[] srcInfo = info; + byte[] newInfo = new byte[srcInfo.length]; + int num = numOfEntries(); + ByteArray.write16bit(num, newInfo, 0); + int pos = 2; + for (int i = 0; i < num; i++) { + int offset = ByteArray.readU16bit(srcInfo, pos); + ByteArray.write16bit(offset, newInfo, pos); + pos += 2; + int numLoc = ByteArray.readU16bit(srcInfo, pos); + ByteArray.write16bit(numLoc, newInfo, pos); + pos = copyFrames(srcInfo, newInfo, pos + 2, numLoc, cp, newCp, + classnames); + int numStack = ByteArray.readU16bit(srcInfo, pos); + ByteArray.write16bit(numStack, newInfo, pos); + pos = copyFrames(srcInfo, newInfo, pos + 2, numStack, cp, newCp, + classnames); + } + + return new StackMap(newCp, newInfo); + } + + private static int copyFrames(byte[] srcInfo, byte[] newInfo, int pos, + int numFrames, ConstPool cp, ConstPool newCp, Map classnames) { + for (int k = 0; k < numFrames; k++) { + byte tag = srcInfo[pos]; + newInfo[pos] = tag; + if (tag == OBJECT) { + int clazz = ByteArray.readU16bit(srcInfo, pos + 1); + clazz = cp.copy(clazz, newCp, classnames); + ByteArray.write16bit(clazz, newInfo, pos + 1); + pos += 3; + } + else if (tag == UNINIT) { + ByteArray.write16bit(ByteArray.readU16bit(srcInfo, pos + 1), + newInfo, pos + 1); + pos += 3; + } + else + pos++; + } + + return pos; + } + + int i; + + static class NullType extends TypeData.BasicType { + NullType() { + super("null", StackMapTable.NULL); + } + } + + static final NullType nullType = new NullType(); + + static class Conv extends StackMapTable.Walker { + private ByteArrayOutputStream output; + private ConstPool pool; + private int offset; + private TypedBlock frame; + + // more than one entries must be included! + + public Conv(byte[] data, MethodInfo minfo, CodeAttribute ca) + throws BadBytecode { + super(data); + output = new ByteArrayOutputStream(); + pool = minfo.getConstPool(); + offset = -1; + frame = TypedBlock.make(minfo, ca); + } + + private void write16bit(int value) { + output.write((byte) (value >>> 8)); + output.write((byte) value); + } + + private void writeFrame() { + int numLocals = frame.numLocals; + int numStack = frame.stackTop; + } + + private void writeTypes(TypeData[] types, int num) { + for (int i = 0; i < num; i++) { + TypeData t = types[i]; + int tag = t.getTypeTag(); + if (t.is2WordType()) + i++; + + output.write(tag); + if (tag == UNINIT) { + write16bit(t.getTypeData(pool)); + } + } + } + + public void sameFrame(int pos, int offsetDelta) { + offset += offsetDelta + 1; + } + + public void sameLocals(int pos, int offsetDelta, int stackTag, + int stackData) { + offset += offsetDelta + 1; + } + + public void chopFrame(int pos, int offsetDelta, int k) { + offset += offsetDelta + 1; + } + + public void appendFrame(int pos, int offsetDelta, int[] tags, int[] data) { + offset += offsetDelta + 1; + } + + public void fullFrame(int pos, int offsetDelta, int[] localTags, + int[] localData, int[] stackTags, int[] stackData) { + offset += offsetDelta + 1; + } + } +}