/** Returns the constant string at the specified offset */
public static String get_constant_str(ConstantPool pool, int index) {
Constant c = pool.getConstant(index);
if (c instanceof ConstantUtf8) return ((ConstantUtf8) c).getBytes();
else if (c instanceof ConstantClass) {
ConstantClass cc = (ConstantClass) c;
return cc.getBytes(pool) + " [" + cc.getNameIndex() + "]";
} else assert false : "unexpected constant " + c + " class " + c.getClass();
return (null);
}
/** @param cp */
public void resolveCPool(ConstantPool cp) {
Constant[] ca = cp.getConstantPool();
cpoolArry = new int[cpoolUsed.size()];
cpoolComments = new String[ca.length];
// System.out.println(clazz.getClassName()+" cpool "+cpoolUsed);
for (int i = 0; i < ca.length; ++i) {
Constant co = ca[i];
Integer idx = new Integer(i);
// pos is the new position in the reduced constant pool
// idx is the position in the 'original' unresolved cpool
int pos = cpoolUsed.indexOf(idx);
if (pos != -1) {
boolean isInterface = false;
// System.out.println("cpool@"+pos+" = orig_cp@"+i+" "+co);
switch (co.getTag()) {
case Constants.CONSTANT_Integer:
cpoolArry[pos] = ((ConstantInteger) co).getBytes();
cpoolComments[pos] = "Integer";
break;
case Constants.CONSTANT_Long:
long lval = ((ConstantLong) co).getBytes();
// store LOW, HIGH words in this order
int loW = (new Long(0xFFFFFFFF & lval)).intValue();
int hiW = (new Long(lval >>> 32)).intValue();
cpoolArry[pos] = hiW;
cpoolArry[pos + 1] = loW;
cpoolComments[pos] = "Long: " + lval;
cpoolComments[pos + 1] = "";
break;
case Constants.CONSTANT_Float:
float fval = ((ConstantFloat) co).getBytes();
cpoolArry[pos] = Float.floatToRawIntBits(fval);
cpoolComments[pos] = "Float: " + fval;
break;
case Constants.CONSTANT_Double:
double dval = ((ConstantDouble) co).getBytes();
long d_lval = Double.doubleToRawLongBits(dval);
// store LOW, HIGH words in this order
int d_loW = (new Long(0xFFFFFFFF & d_lval)).intValue();
int d_hiW = (new Long(d_lval >>> 32)).intValue();
cpoolArry[pos] = d_hiW;
cpoolArry[pos + 1] = d_loW;
cpoolComments[pos] = "Double: " + dval;
cpoolComments[pos + 1] = "";
break;
case Constants.CONSTANT_String:
String str = ((ConstantString) co).getBytes(cp);
StringInfo si = StringInfo.getStringInfo(str);
cpoolArry[pos] = StringInfo.stringTableAddress + si.getAddress();
cpoolComments[pos] = "String: " + si.getSaveString();
break;
case Constants.CONSTANT_Class:
String clname = ((ConstantClass) co).getBytes(cp).replace('/', '.');
JopClassInfo clinfo = (JopClassInfo) appInfo.cliMap.get(clname);
if (clinfo == null) {
cpoolComments[pos] = "Problem with class: " + clname;
String type = clname.substring(clname.length() - 2);
if (type.charAt(0) == '[') {
switch (type.charAt(1)) {
case 'Z':
cpoolArry[pos] = 4;
break;
case 'C':
cpoolArry[pos] = 5;
break;
case 'F':
cpoolArry[pos] = 6;
break;
case 'D':
cpoolArry[pos] = 7;
break;
case 'B':
cpoolArry[pos] = 8;
break;
case 'S':
cpoolArry[pos] = 9;
break;
case 'I':
cpoolArry[pos] = 10;
break;
case 'J':
cpoolArry[pos] = 11;
break;
default:; // all other types are missing...
}
}
// System.out.println(cpoolComments[pos]+" "+type+" "+cpoolArry[pos]);
continue;
}
cpoolArry[pos] = clinfo.classRefAddress;
cpoolComments[pos] = "Class: " + clname;
break;
case Constants.CONSTANT_InterfaceMethodref:
isInterface = true;
case Constants.CONSTANT_Methodref:
// find the class for this method
int mclidx;
if (isInterface) {
mclidx = ((ConstantInterfaceMethodref) co).getClassIndex();
} else {
mclidx = ((ConstantMethodref) co).getClassIndex();
}
ConstantClass mcl = (ConstantClass) cp.getConstant(mclidx);
// the method has "/" instead of ".", fix that
// now get the signature too...
String mclname = mcl.getBytes(cp).replace('/', '.');
int sigidx;
if (isInterface) {
sigidx = ((ConstantInterfaceMethodref) co).getNameAndTypeIndex();
} else {
sigidx = ((ConstantMethodref) co).getNameAndTypeIndex();
}
ConstantNameAndType signt = (ConstantNameAndType) cp.getConstant(sigidx);
String sigstr = signt.getName(cp) + signt.getSignature(cp);
// now find the address of the method struct!
JopClassInfo clinf = (JopClassInfo) appInfo.cliMap.get(mclname);
if (clinf == null) {
// probably a reference to Native - a class that
// is NOT present in the application.
// we could avoid this by not adding method refs to
// Native in our reduced cpool.
cpoolArry[pos] = 0;
cpoolComments[pos] = "static " + mclname + "." + sigstr;
break;
}
JopMethodInfo minf;
if (isInterface) {
minf = clinf.getITMethodInfo(sigstr);
} else {
minf = clinf.getVTMethodInfo(sigstr);
}
if (minf == null) {
System.out.println(
"Error: Method " + clinf.clazz.getClassName() + '.' + sigstr + " not found.");
System.out.println("Invoked by " + clazz.getClassName());
for (int xxx = 0; xxx < clinf.clvt.len; ++xxx) {
System.out.println(clinf.clvt.key[xxx]);
}
System.exit(1);
}
if (minf.getMethod().isStatic()
||
// <init> and privat methods are called with invokespecial
// which mapps in jvm.asm to invokestatic
minf.getMethod().isPrivate()
|| sigstr.charAt(0) == '<') {
// for static methods a direct pointer to the
// method struct
cpoolArry[pos] = minf.structAddress;
cpoolComments[pos] =
"static, special or private " + clinf.clazz.getClassName() + "." + minf.methodId;
} else {
// as Flavius correctly comments:
// TODO: CHANGE THIS TO A MORE CONSISTENT FORMAT...
// extract the objref! for some reason the microcode
// needs -1 here...weird
// that's for simple virtual methods
int vpos = minf.vtindex;
String comment = "virtual";
// TODO: is kind of redundant search as we've already
// searched the IT table with getVTMethodInfo()
// TODO: do we handle different interfaces with same
// method id correct? (see buildIT)
if (isInterface) {
comment = "interface";
for (int j = 0; j < listIT.size(); ++j) {
IT it = (IT) listIT.get(j);
if (it.key.equals(minf.methodId)) {
vpos = j;
break;
}
}
// offest in interface table
// index plus number of arguments (without this!)
cpoolArry[pos] = (vpos << 8) + (minf.margs - 1);
} else {
// offest in method table
// (index*2) plus number of arguments (without
// this!)
cpoolArry[pos] = (vpos * ClassStructConstants.METH_STR << 8) + (minf.margs - 1);
}
cpoolComments[pos] =
comment
+ " index: "
+ vpos
+ " args: "
+ minf.margs
+ " "
+ clinf.clazz.getClassName()
+ "."
+ minf.methodId;
}
break;
case Constants.CONSTANT_Fieldref:
throw new Error("Fieldref should not be used anymore");
// int fidx = ((ConstantFieldref) co).getClassIndex();
// ConstantClass fcl = (ConstantClass) cp.getConstant(fidx);
// String fclname = fcl.getBytes(cp).replace('/', '.');
// // got the class name
// sigidx = ((ConstantFieldref) co).getNameAndTypeIndex();
// signt = (ConstantNameAndType) cp.getConstant(sigidx);
// sigstr = signt.getName(cp) + signt.getSignature(cp);
// clinf = (JopClassInfo) appInfo.cliMap.get(fclname);
// int j;
// String comment = "";
// boolean found = false;
// while (!found) {
// for (j = 0; j < clinf.clft.len; ++j) {
// if (clinf.clft.key[j].equals(sigstr)) {
// found = true;
// if (clinf.clft.isStatic[j]) {
// comment = "static ";
// }
// // for static fields a direct pointer to the
// // static field
// cpoolArry[pos] = clinf.clft.idx[j];
// cpoolComments[pos] = comment
// + clinf.clazz.getClassName() + "."
// + sigstr;
// break;
// }
// }
// if (!found) {
// clinf = (JopClassInfo) clinf.superClass;
// if (clinf == null) {
// System.out.println("Error: field " + fclname
// + "." + sigstr + " not found!");
// break;
// }
// }
// }
// break;
default:
System.out.println("TODO: cpool@" + pos + " = orig_cp@" + i + " " + co);
cpoolComments[pos] = "Problem with: " + co;
}
}
}
}
/**
* Adds all the constants found in the given class into the given ConstantSet, and returns it.
*
* @see #getConstants(String)
*/
public static ConstantSet getConstants(String classname, ConstantSet result) {
ClassParser cp;
JavaClass jc;
try {
String classfileBase = classname.replace('.', '/');
InputStream is = ClassPath.SYSTEM_CLASS_PATH.getInputStream(classfileBase, ".class");
cp = new ClassParser(is, classname);
jc = cp.parse();
} catch (java.io.IOException e) {
throw new Error("IOException while reading '" + classname + "': " + e.getMessage());
}
result.classname = jc.getClassName();
// Get all of the constants from the pool
ConstantPool constant_pool = jc.getConstantPool();
for (Constant c : constant_pool.getConstantPool()) {
// System.out.printf ("*Constant = %s%n", c);
if (c == null
|| c instanceof ConstantClass
|| c instanceof ConstantFieldref
|| c instanceof ConstantInterfaceMethodref
|| c instanceof ConstantMethodref
|| c instanceof ConstantNameAndType
|| c instanceof ConstantUtf8) {
continue;
}
if (c instanceof ConstantString) {
result.strings.add((String) ((ConstantString) c).getConstantValue(constant_pool));
} else if (c instanceof ConstantDouble) {
result.doubles.add((Double) ((ConstantDouble) c).getConstantValue(constant_pool));
} else if (c instanceof ConstantFloat) {
result.floats.add((Float) ((ConstantFloat) c).getConstantValue(constant_pool));
} else if (c instanceof ConstantInteger) {
result.ints.add((Integer) ((ConstantInteger) c).getConstantValue(constant_pool));
} else if (c instanceof ConstantLong) {
result.longs.add((Long) ((ConstantLong) c).getConstantValue(constant_pool));
} else {
throw new RuntimeException("Unrecognized constant of type " + c.getClass() + ": " + c);
}
}
ClassGen gen = new ClassGen(jc);
ConstantPoolGen pool = gen.getConstantPool();
// Process the code in each method looking for literals
for (Method m : jc.getMethods()) {
MethodGen mg = new MethodGen(m, jc.getClassName(), pool);
InstructionList il = mg.getInstructionList();
if (il == null) {
// System.out.println("No instructions for " + mg);
} else {
for (Instruction inst : il.getInstructions()) {
switch (inst.getOpcode()) {
// Compare two objects, no literals
case Constants.IF_ACMPEQ:
case Constants.IF_ACMPNE:
break;
// These instructions compare the integer on the top of the stack
// to zero. There are no literals here (except 0)
case Constants.IFEQ:
case Constants.IFNE:
case Constants.IFLT:
case Constants.IFGE:
case Constants.IFGT:
case Constants.IFLE:
{
break;
}
// Instanceof pushes either 0 or 1 on the stack depending on whether
// the object on top of stack is of the specified type.
// If were interested in class literals, this would be interesting
case Constants.INSTANCEOF:
break;
// Duplicates the item on the top of stack. No literal.
case Constants.DUP:
{
break;
}
// Duplicates the item on the top of the stack and inserts it 2
// values down in the stack. No literals
case Constants.DUP_X1:
{
break;
}
// Duplicates either the top 2 category 1 values or a single
// category 2 value and inserts it 2 or 3 values down on the
// stack.
case Constants.DUP2_X1:
{
break;
}
// Duplicate either one category 2 value or two category 1 values.
case Constants.DUP2:
{
break;
}
// Dup the category 1 value on the top of the stack and insert it either
// two or three values down on the stack.
case Constants.DUP_X2:
{
break;
}
case Constants.DUP2_X2:
{
break;
}
// Pop instructions discard the top of the stack.
case Constants.POP:
{
break;
}
// Pops either the top 2 category 1 values or a single category 2 value
// from the top of the stack.
case Constants.POP2:
{
break;
}
// Swaps the two category 1 types on the top of the stack.
case Constants.SWAP:
{
break;
}
// Compares two integers on the stack
case Constants.IF_ICMPEQ:
case Constants.IF_ICMPGE:
case Constants.IF_ICMPGT:
case Constants.IF_ICMPLE:
case Constants.IF_ICMPLT:
case Constants.IF_ICMPNE:
{
break;
}
// Get the value of a field
case Constants.GETFIELD:
{
break;
}
// stores the top of stack into a field
case Constants.PUTFIELD:
{
break;
}
// Pushes the value of a static field on the stack
case Constants.GETSTATIC:
{
break;
}
// Pops a value off of the stack into a static field
case Constants.PUTSTATIC:
{
break;
}
// pushes a local onto the stack
case Constants.DLOAD:
case Constants.DLOAD_0:
case Constants.DLOAD_1:
case Constants.DLOAD_2:
case Constants.DLOAD_3:
case Constants.FLOAD:
case Constants.FLOAD_0:
case Constants.FLOAD_1:
case Constants.FLOAD_2:
case Constants.FLOAD_3:
case Constants.ILOAD:
case Constants.ILOAD_0:
case Constants.ILOAD_1:
case Constants.ILOAD_2:
case Constants.ILOAD_3:
case Constants.LLOAD:
case Constants.LLOAD_0:
case Constants.LLOAD_1:
case Constants.LLOAD_2:
case Constants.LLOAD_3:
{
break;
}
// Pops a value off of the stack into a local
case Constants.DSTORE:
case Constants.DSTORE_0:
case Constants.DSTORE_1:
case Constants.DSTORE_2:
case Constants.DSTORE_3:
case Constants.FSTORE:
case Constants.FSTORE_0:
case Constants.FSTORE_1:
case Constants.FSTORE_2:
case Constants.FSTORE_3:
case Constants.ISTORE:
case Constants.ISTORE_0:
case Constants.ISTORE_1:
case Constants.ISTORE_2:
case Constants.ISTORE_3:
case Constants.LSTORE:
case Constants.LSTORE_0:
case Constants.LSTORE_1:
case Constants.LSTORE_2:
case Constants.LSTORE_3:
{
break;
}
// Push a value from the runtime constant pool. We'll get these
// values when processing the constant pool itself
case Constants.LDC:
case Constants.LDC_W:
case Constants.LDC2_W:
{
break;
}
// Push the length of an array on the stack
case Constants.ARRAYLENGTH:
{
break;
}
// Push small constants (-1..5) on the stack. These literals are
// too common to bother mentioning
case Constants.DCONST_0:
case Constants.DCONST_1:
case Constants.FCONST_0:
case Constants.FCONST_1:
case Constants.FCONST_2:
case Constants.ICONST_0:
case Constants.ICONST_1:
case Constants.ICONST_2:
case Constants.ICONST_3:
case Constants.ICONST_4:
case Constants.ICONST_5:
case Constants.ICONST_M1:
case Constants.LCONST_0:
case Constants.LCONST_1:
{
break;
}
case Constants.BIPUSH:
case Constants.SIPUSH:
{
ConstantPushInstruction cpi = (ConstantPushInstruction) inst;
result.ints.add((Integer) cpi.getValue());
break;
}
// Primitive Binary operators.
case Constants.DADD:
case Constants.DCMPG:
case Constants.DCMPL:
case Constants.DDIV:
case Constants.DMUL:
case Constants.DREM:
case Constants.DSUB:
case Constants.FADD:
case Constants.FCMPG:
case Constants.FCMPL:
case Constants.FDIV:
case Constants.FMUL:
case Constants.FREM:
case Constants.FSUB:
case Constants.IADD:
case Constants.IAND:
case Constants.IDIV:
case Constants.IMUL:
case Constants.IOR:
case Constants.IREM:
case Constants.ISHL:
case Constants.ISHR:
case Constants.ISUB:
case Constants.IUSHR:
case Constants.IXOR:
case Constants.LADD:
case Constants.LAND:
case Constants.LCMP:
case Constants.LDIV:
case Constants.LMUL:
case Constants.LOR:
case Constants.LREM:
case Constants.LSHL:
case Constants.LSHR:
case Constants.LSUB:
case Constants.LUSHR:
case Constants.LXOR:
break;
case Constants.LOOKUPSWITCH:
case Constants.TABLESWITCH:
break;
case Constants.ANEWARRAY:
case Constants.NEWARRAY:
{
break;
}
case Constants.MULTIANEWARRAY:
{
break;
}
// push the value at an index in an array
case Constants.AALOAD:
case Constants.BALOAD:
case Constants.CALOAD:
case Constants.DALOAD:
case Constants.FALOAD:
case Constants.IALOAD:
case Constants.LALOAD:
case Constants.SALOAD:
{
break;
}
// Pop the top of stack into an array location
case Constants.AASTORE:
case Constants.BASTORE:
case Constants.CASTORE:
case Constants.DASTORE:
case Constants.FASTORE:
case Constants.IASTORE:
case Constants.LASTORE:
case Constants.SASTORE:
break;
case Constants.ARETURN:
case Constants.DRETURN:
case Constants.FRETURN:
case Constants.IRETURN:
case Constants.LRETURN:
case Constants.RETURN:
{
break;
}
// subroutine calls.
case Constants.INVOKESTATIC:
case Constants.INVOKEVIRTUAL:
case Constants.INVOKESPECIAL:
case Constants.INVOKEINTERFACE:
break;
// Throws an exception.
case Constants.ATHROW:
break;
// Opcodes that don't need any modifications. Here for reference
case Constants.ACONST_NULL:
case Constants.ALOAD:
case Constants.ALOAD_0:
case Constants.ALOAD_1:
case Constants.ALOAD_2:
case Constants.ALOAD_3:
case Constants.ASTORE:
case Constants.ASTORE_0:
case Constants.ASTORE_1:
case Constants.ASTORE_2:
case Constants.ASTORE_3:
case Constants.CHECKCAST:
case Constants.D2F: // double to float
case Constants.D2I: // double to integer
case Constants.D2L: // double to long
case Constants.DNEG: // Negate double on top of stack
case Constants.F2D: // float to double
case Constants.F2I: // float to integer
case Constants.F2L: // float to long
case Constants.FNEG: // Negate float on top of stack
case Constants.GOTO:
case Constants.GOTO_W:
case Constants.I2B: // integer to byte
case Constants.I2C: // integer to char
case Constants.I2D: // integer to double
case Constants.I2F: // integer to float
case Constants.I2L: // integer to long
case Constants.I2S: // integer to short
case Constants.IFNONNULL:
case Constants.IFNULL:
case Constants.IINC: // increment local variable by a constant
case Constants.INEG: // negate integer on top of stack
case Constants.JSR: // pushes return address on the stack,
case Constants.JSR_W:
case Constants.L2D: // long to double
case Constants.L2F: // long to float
case Constants.L2I: // long to int
case Constants.LNEG: // negate long on top of stack
case Constants.MONITORENTER:
case Constants.MONITOREXIT:
case Constants.NEW:
case Constants.NOP:
case Constants.RET: // this is the internal JSR return
break;
// Make sure we didn't miss anything
default:
throw new Error("instruction " + inst + " unsupported");
}
}
}
}
return result;
}
