public JopMethodInfo getITMethodInfo(String mid) { for (int j = 0; j < listIT.size(); ++j) { IT it = (IT) listIT.get(j); if (it.key.equals(mid)) { return it.meth; } } return null; }
public void dump(PrintWriter out, PrintWriter outLinkInfo) { int i; out.println("//"); out.println("//\t" + classRefAddress + ": " + clazz.getClassName() + " class info"); out.println("//"); out.println("\t\t" + instSize + ",\t//\tinstance size"); for (i = 0; i < clft.len; ++i) { if (!clft.isStatic[i]) { out.println("\t\t\t\t//\t" + clft.idx[i] + " " + clft.key[i]); } } // link info: class addresses outLinkInfo.println( "class " + clazz.getClassName() + " " + methodsAddress + " " + cpoolAddress); outLinkInfo.println(" -instSize " + instSize); out.println("\t\t" + staticValueVarAddress + ",\t//\tpointer to static primitive fields"); if (instSize > 31) { System.err.println("Error: Object of " + clazz.getClassName() + " to big! Size=" + instSize); System.exit(-1); } out.println("\t\t" + instGCinfo + ",\t//\tinstance GC info"); String supname = "null"; int superAddr = 0; if (superClass != null) { supname = superClass.clazz.getClassName(); superAddr = ((JopClassInfo) appInfo.cliMap.get(supname)).classRefAddress; } if (!clazz.isInterface()) { out.println("\t\t" + superAddr + ",\t//\tpointer to super class - " + supname); // link info: super address outLinkInfo.println(" -super " + superAddr); } else { out.println("\t\t" + (-interfaceID) + ",\t//\tinterface ID"); } boolean useSuperInterfaceTable = false; if ((iftableAddress == 0) && (superClass != null)) { iftableAddress = ((JopClassInfo) appInfo.cliMap.get(supname)).iftableAddress; useSuperInterfaceTable = true; } out.println("\t\t" + iftableAddress + ",\t//\tpointer to interface table"); if (!clazz.isInterface()) { out.println("//"); out.println("//\t" + methodsAddress + ": " + clazz.getClassName() + " method table"); out.println("//"); int addr = methodsAddress; for (i = 0; i < clvt.len; i++) { clvt.mi[i].dumpMethodStruct(out, addr); outLinkInfo.println(" -mtab " + clvt.mi[i].getFQMethodName() + " " + addr); addr += ClassStructConstants.METH_STR; } } else { out.println("//"); out.println("//\tno method table for interfaces"); out.println("//"); } out.println(); out.println("\t\t" + classRefAddress + ",\t//\tpointer back to class struct (cp-1)"); out.println(); out.println("//"); out.println("//\t" + cpoolAddress + ": " + clazz.getClassName() + " constants"); out.println("//"); // link info: constant pool mapping for (Entry<Integer, Integer> entry : cpoolMap.entrySet()) { outLinkInfo.println(" -constmap " + entry.getKey() + " " + entry.getValue()); } // constant pool length includes the length field // same is true for the index in the bytecodes: // The lowest constant has index 1. out.println("\t\t" + (cpoolArry.length + 1) + ",\t//\tconst pool length"); out.println(); for (i = 0; i < cpoolArry.length; ++i) { out.println("\t\t" + cpoolArry[i] + ",\t//\t" + cpoolComments[i]); } if (iftableAddress != 0 && !useSuperInterfaceTable) { out.println("//"); out.println( "//\t" + (iftableAddress - (interfaceCnt + 31) / 32) + ": " + clazz.getClassName() + " implements table"); out.println("//"); for (i = (interfaceCnt + 31) / 32 - 1; i >= 0; i--) { String comment = ""; int word = 0; int j; for (j = 31; j >= 0; j--) { word <<= 1; if ((i * 32 + j) < interfaceCnt) { if (implementsInterface(interfaceList.get(i * 32 + j))) { word |= 1; comment += interfaceList.get(i * 32 + j) + ", "; } ; } } out.println("\t\t" + word + ",\t//\t" + comment); } out.println("//"); out.println("//\t" + iftableAddress + ": " + clazz.getClassName() + " interface table"); out.println("//"); if (!clazz.isInterface()) { out.println("//\tTODO: is it enough to use methodId as key???"); out.println("//"); for (i = 0; i < listIT.size(); ++i) { IT it = (IT) listIT.get(i); int j; for (j = 0; j < clvt.len; j++) { if (clvt.key[j].equals(it.key)) { break; } } if (j != clvt.len) { out.print("\t\t" + (methodsAddress + j * ClassStructConstants.METH_STR) + ","); } else { out.print("\t\t" + 0 + ",\t"); } out.println("\t//\t" + it.meth.methodId); } } } }
/** @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; } } } }
/** * Calculate the size of the class info table, adjust the addresses and return the next available * address. Calculate GC info for the instance. * * @param addr * @return */ public int setAddress(OldAppInfo ai, int addr) { int i; instGCinfo = getGCInfo(); classRefAddress = addr; // class head contains the instance size and // a pointer to the interface table // class references point to the instance size addr += ClassStructConstants.CLS_HEAD; // start of the method table, objects contain a pointer // to the start of this table (at ref-1) if (!clazz.isInterface()) { methodsAddress = addr; for (i = 0; i < clvt.len; ++i) { JopMethodInfo m = clvt.mi[i]; m.vtindex = i; m.structAddress = addr; if (clazz.getClassName().equals(JOPizer.startupClass)) { if (m.methodId.equals(JOPizer.bootMethod)) { bootAddress = addr; } } if (clazz.getClassName().equals(ai.mainClass)) { if (m.methodId.equals(JOPizer.mainMethod)) { mainAddress = addr; } } addr += ClassStructConstants.METH_STR; } } // back reference from cp-1 to class struct addr += 1; // constant pool cpoolAddress = addr; // System.out.println(clazz.getClassName()+" // cplen="+clazz.getConstantPool().getLength()); // the final size of the cp plus the length field addr += cpoolUsed.size() + 1; // the optional interface table iftableAddress = 0; boolean needsInterfaceTable = false; for (i = 0; i < listIT.size(); i++) { IT it = (IT) listIT.get(i); boolean matchMethod = methods.containsKey(it.meth.methodId); boolean matchInterface = implementsInterface(it.meth.getCli().clazz.getClassName()); if (matchMethod && matchInterface) { needsInterfaceTable = true; } } if (superClass != null) { String[] interfaceNames = clazz.getInterfaceNames(); for (i = 0; i < interfaceNames.length; i++) { if (!((JopClassInfo) superClass).implementsInterface(interfaceNames[i])) { needsInterfaceTable = true; } } } else { needsInterfaceTable = clazz.getInterfaceNames().length > 0; } if (needsInterfaceTable) { addr += (interfaceCnt + 31) / 32; iftableAddress = addr; if (!clazz.isInterface()) { addr += listIT.size(); } } // add method count of class Object ! if (clazz.getClassName().equals(JOPizer.jvmClass)) { jvmAddress = methodsAddress + nrObjMethods * ClassStructConstants.METH_STR; } if (clazz.getClassName().equals(JOPizer.helpClass)) { jvmHelpAddress = methodsAddress + nrObjMethods * ClassStructConstants.METH_STR; } return addr; }