/** * Override this method to create you own classes on the fly. The name contains the special token * $$BCEL$$. Everything before that token is consddered to be a package name. You can encode you * own arguments into the subsequent string. You must regard however not to use any "illegal" * characters, i.e., characters that may not appear in a Java class name too<br> * The default implementation interprets the string as a encoded compressed Java class, unpacks * and decodes it with the Utility.decode() method, and parses the resulting byte array and * returns the resulting JavaClass object. * * @param class_name compressed byte code with "$$BCEL$$" in it */ protected JavaClass createClass(String class_name) { int index = class_name.indexOf("$$BCEL$$"); String real_name = class_name.substring(index + 8); JavaClass clazz = null; try { byte[] bytes = Utility.decode(real_name, true); ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes), "foo"); clazz = parser.parse(); } catch (Throwable e) { e.printStackTrace(); return null; } // Adapt the class name to the passed value ConstantPool cp = clazz.getConstantPool(); ConstantClass cl = (ConstantClass) cp.getConstant(clazz.getClassNameIndex(), Constants.CONSTANT_Class); ConstantUtf8 name = (ConstantUtf8) cp.getConstant(cl.getNameIndex(), Constants.CONSTANT_Utf8); name.setBytes(class_name.replace('.', '/')); return clazz; }
/** * Initialize with given array of constants. * * @param c array of given constants, new ones will be appended */ public ConstantPoolGen(Constant[] cs) { if (cs.length > size) { size = cs.length; constants = new Constant[size]; } System.arraycopy(cs, 0, constants, 0, cs.length); if (cs.length > 0) index = cs.length; for (int i = 1; i < index; i++) { Constant c = constants[i]; if (c instanceof ConstantString) { ConstantString s = (ConstantString) c; ConstantUtf8 u8 = (ConstantUtf8) constants[s.getStringIndex()]; string_table.put(u8.getBytes(), new Index(i)); } else if (c instanceof ConstantClass) { ConstantClass s = (ConstantClass) c; ConstantUtf8 u8 = (ConstantUtf8) constants[s.getNameIndex()]; class_table.put(u8.getBytes(), new Index(i)); } else if (c instanceof ConstantNameAndType) { ConstantNameAndType n = (ConstantNameAndType) c; ConstantUtf8 u8 = (ConstantUtf8) constants[n.getNameIndex()]; ConstantUtf8 u8_2 = (ConstantUtf8) constants[n.getSignatureIndex()]; n_a_t_table.put(u8.getBytes() + NAT_DELIM + u8_2.getBytes(), new Index(i)); } else if (c instanceof ConstantUtf8) { ConstantUtf8 u = (ConstantUtf8) c; utf8_table.put(u.getBytes(), new Index(i)); } else if (c instanceof ConstantCP) { ConstantCP m = (ConstantCP) c; ConstantClass clazz = (ConstantClass) constants[m.getClassIndex()]; ConstantNameAndType n = (ConstantNameAndType) constants[m.getNameAndTypeIndex()]; ConstantUtf8 u8 = (ConstantUtf8) constants[clazz.getNameIndex()]; String class_name = u8.getBytes().replace('/', '.'); u8 = (ConstantUtf8) constants[n.getNameIndex()]; String method_name = u8.getBytes(); u8 = (ConstantUtf8) constants[n.getSignatureIndex()]; String signature = u8.getBytes(); String delim = METHODREF_DELIM; if (c instanceof ConstantInterfaceMethodref) delim = IMETHODREF_DELIM; else if (c instanceof ConstantFieldref) delim = FIELDREF_DELIM; cp_table.put(class_name + delim + method_name + delim + signature, new Index(i)); } } }
/** * Returns all related classes * * @param start * @return */ private static Collection<Class<?>> getAllRelatedClasses(Class<?> start) { List<Class<?>> rval = new ArrayList<Class<?>>(); JavaClass lookupClass; // In case the class fails, return empty. try { lookupClass = Repository.lookupClass(start); } catch (ClassNotFoundException e) { e.printStackTrace(); return rval; } ConstantPool constantPool = lookupClass.getConstantPool(); int length = constantPool.getLength(); for (int i = 0; i < length; i++) { Constant constant = constantPool.getConstant(i); if (constant instanceof ConstantClass) { ConstantClass cc = (ConstantClass) constant; ConstantUtf8 constant2 = (ConstantUtf8) constantPool.getConstant(cc.getNameIndex()); // In case a subclass fails, skip, but print warning. try { String toLoad = constant2.getBytes().replace('/', '.'); if (toLoad.contains("[")) continue; Class<?> forName = Class.forName(toLoad); rval.add(forName); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } return rval; }
public void visitConstantClass(ConstantClass constant) { constant.accept(visitor); }
private void writeConstant(int index) { byte tag = constants[index].getTag(); int class_index, name_index; String ref; // The header is always the same file.println("<H4> <A NAME=cp" + index + ">" + index + "</A> " + CONSTANT_NAMES[tag] + "</H4>"); /* For every constant type get the needed parameters and print them appropiately */ switch (tag) { case CONSTANT_InterfaceMethodref: case CONSTANT_Methodref: // Get class_index and name_and_type_index, depending on type if (tag == CONSTANT_Methodref) { ConstantMethodref c = (ConstantMethodref) constant_pool.getConstant(index, CONSTANT_Methodref); class_index = c.getClassIndex(); name_index = c.getNameAndTypeIndex(); } else { ConstantInterfaceMethodref c1 = (ConstantInterfaceMethodref) constant_pool.getConstant(index, CONSTANT_InterfaceMethodref); class_index = c1.getClassIndex(); name_index = c1.getNameAndTypeIndex(); } // Get method name and its class String method_name = constant_pool.constantToString(name_index, CONSTANT_NameAndType); String html_method_name = Class2HTML.toHTML(method_name); // Partially compacted class name, i.e., / -> . String method_class = constant_pool.constantToString(class_index, CONSTANT_Class); String short_method_class = Utility.compactClassName(method_class); // I.e., remove java.lang. short_method_class = Utility.compactClassName(method_class); // I.e., remove java.lang. short_method_class = Utility.compactClassName( short_method_class, class_package + ".", true); // Remove class package prefix // Get method signature ConstantNameAndType c2 = (ConstantNameAndType) constant_pool.getConstant(name_index, CONSTANT_NameAndType); String signature = constant_pool.constantToString(c2.getSignatureIndex(), CONSTANT_Utf8); // Get array of strings containing the argument types String[] args = Utility.methodSignatureArgumentTypes(signature, false); // Get return type string String type = Utility.methodSignatureReturnType(signature, false); String ret_type = Class2HTML.referenceType(type); StringBuffer buf = new StringBuffer("("); for (int i = 0; i < args.length; i++) { buf.append(Class2HTML.referenceType(args[i])); if (i < args.length - 1) buf.append(", "); } buf.append(")"); String arg_types = buf.toString(); if (method_class.equals(class_name)) // Method is local to class ref = "<A HREF=\"" + class_name + "_code.html#method" + getMethodNumber(method_name + signature) + "\" TARGET=Code>" + html_method_name + "</A>"; else ref = "<A HREF=\"" + method_class + ".html" + "\" TARGET=_top>" + short_method_class + "</A>." + html_method_name; constant_ref[index] = ret_type + " <A HREF=\"" + class_name + "_cp.html#cp" + class_index + "\" TARGET=Constants>" + short_method_class + "</A>.<A HREF=\"" + class_name + "_cp.html#cp" + index + "\" TARGET=ConstantPool>" + html_method_name + "</A> " + arg_types; file.println( "<P><TT>" + ret_type + " " + ref + arg_types + " </TT>\n<UL>" + "<LI><A HREF=\"#cp" + class_index + "\">Class index(" + class_index + ")</A>\n" + "<LI><A HREF=\"#cp" + name_index + "\">NameAndType index(" + name_index + ")</A></UL>"); break; case CONSTANT_Fieldref: // Get class_index and name_and_type_index ConstantFieldref c3 = (ConstantFieldref) constant_pool.getConstant(index, CONSTANT_Fieldref); class_index = c3.getClassIndex(); name_index = c3.getNameAndTypeIndex(); // Get method name and its class (compacted) String field_class = constant_pool.constantToString(class_index, CONSTANT_Class); String short_field_class = Utility.compactClassName(field_class); // I.e., remove java.lang. short_field_class = Utility.compactClassName( short_field_class, class_package + ".", true); // Remove class package prefix String field_name = constant_pool.constantToString(name_index, CONSTANT_NameAndType); if (field_class.equals(class_name)) // Field is local to class ref = "<A HREF=\"" + field_class + "_methods.html#field" + field_name + "\" TARGET=Methods>" + field_name + "</A>"; else ref = "<A HREF=\"" + field_class + ".html\" TARGET=_top>" + short_field_class + "</A>." + field_name + "\n"; constant_ref[index] = "<A HREF=\"" + class_name + "_cp.html#cp" + class_index + "\" TARGET=Constants>" + short_field_class + "</A>.<A HREF=\"" + class_name + "_cp.html#cp" + index + "\" TARGET=ConstantPool>" + field_name + "</A>"; file.println( "<P><TT>" + ref + "</TT><BR>\n" + "<UL>" + "<LI><A HREF=\"#cp" + class_index + "\">Class(" + class_index + ")</A><BR>\n" + "<LI><A HREF=\"#cp" + name_index + "\">NameAndType(" + name_index + ")</A></UL>"); break; case CONSTANT_Class: ConstantClass c4 = (ConstantClass) constant_pool.getConstant(index, CONSTANT_Class); name_index = c4.getNameIndex(); String class_name2 = constant_pool.constantToString(index, tag); // / -> . String short_class_name = Utility.compactClassName(class_name2); // I.e., remove java.lang. short_class_name = Utility.compactClassName( short_class_name, class_package + ".", true); // Remove class package prefix ref = "<A HREF=\"" + class_name2 + ".html\" TARGET=_top>" + short_class_name + "</A>"; constant_ref[index] = "<A HREF=\"" + class_name + "_cp.html#cp" + index + "\" TARGET=ConstantPool>" + short_class_name + "</A>"; file.println( "<P><TT>" + ref + "</TT><UL>" + "<LI><A HREF=\"#cp" + name_index + "\">Name index(" + name_index + ")</A></UL>\n"); break; case CONSTANT_String: ConstantString c5 = (ConstantString) constant_pool.getConstant(index, CONSTANT_String); name_index = c5.getStringIndex(); String str = Class2HTML.toHTML(constant_pool.constantToString(index, tag)); file.println( "<P><TT>" + str + "</TT><UL>" + "<LI><A HREF=\"#cp" + name_index + "\">Name index(" + name_index + ")</A></UL>\n"); break; case CONSTANT_NameAndType: ConstantNameAndType c6 = (ConstantNameAndType) constant_pool.getConstant(index, CONSTANT_NameAndType); name_index = c6.getNameIndex(); int signature_index = c6.getSignatureIndex(); file.println( "<P><TT>" + Class2HTML.toHTML(constant_pool.constantToString(index, tag)) + "</TT><UL>" + "<LI><A HREF=\"#cp" + name_index + "\">Name index(" + name_index + ")</A>\n" + "<LI><A HREF=\"#cp" + signature_index + "\">Signature index(" + signature_index + ")</A></UL>\n"); break; default: file.println( "<P><TT>" + Class2HTML.toHTML(constant_pool.constantToString(index, tag)) + "</TT>\n"); } // switch }
/** @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; } } } }
/** Import constant from another ConstantPool and return new index. */ public int addConstant(Constant c, ConstantPoolGen cp) { Constant[] constants = cp.getConstantPool().getConstantPool(); switch (c.getTag()) { case Constants.CONSTANT_String: { ConstantString s = (ConstantString) c; ConstantUtf8 u8 = (ConstantUtf8) constants[s.getStringIndex()]; return addString(u8.getBytes()); } case Constants.CONSTANT_Class: { ConstantClass s = (ConstantClass) c; ConstantUtf8 u8 = (ConstantUtf8) constants[s.getNameIndex()]; return addClass(u8.getBytes()); } case Constants.CONSTANT_NameAndType: { ConstantNameAndType n = (ConstantNameAndType) c; ConstantUtf8 u8 = (ConstantUtf8) constants[n.getNameIndex()]; ConstantUtf8 u8_2 = (ConstantUtf8) constants[n.getSignatureIndex()]; return addNameAndType(u8.getBytes(), u8_2.getBytes()); } case Constants.CONSTANT_Utf8: return addUtf8(((ConstantUtf8) c).getBytes()); case Constants.CONSTANT_Double: return addDouble(((ConstantDouble) c).getBytes()); case Constants.CONSTANT_Float: return addFloat(((ConstantFloat) c).getBytes()); case Constants.CONSTANT_Long: return addLong(((ConstantLong) c).getBytes()); case Constants.CONSTANT_Integer: return addInteger(((ConstantInteger) c).getBytes()); case Constants.CONSTANT_InterfaceMethodref: case Constants.CONSTANT_Methodref: case Constants.CONSTANT_Fieldref: { ConstantCP m = (ConstantCP) c; ConstantClass clazz = (ConstantClass) constants[m.getClassIndex()]; ConstantNameAndType n = (ConstantNameAndType) constants[m.getNameAndTypeIndex()]; ConstantUtf8 u8 = (ConstantUtf8) constants[clazz.getNameIndex()]; String class_name = u8.getBytes().replace('/', '.'); u8 = (ConstantUtf8) constants[n.getNameIndex()]; String name = u8.getBytes(); u8 = (ConstantUtf8) constants[n.getSignatureIndex()]; String signature = u8.getBytes(); switch (c.getTag()) { case Constants.CONSTANT_InterfaceMethodref: return addInterfaceMethodref(class_name, name, signature); case Constants.CONSTANT_Methodref: return addMethodref(class_name, name, signature); case Constants.CONSTANT_Fieldref: return addFieldref(class_name, name, signature); default: // Never reached throw new RuntimeException("Unknown constant type " + c); } } default: // Never reached throw new RuntimeException("Unknown constant type " + c); } }