X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Fcom%2Fbrian_web%2Fgcclass%2FGCClass.java;h=86b427148c326658e189f8929049a98f722b8646;hb=6c5c8ed617e9e8f793cfbe9f0117440bfcb9a0a3;hp=77b6e122111fbc75c5f3e6ac5479e4de1d47c71e;hpb=94ca00b8891f6707c1b0a2133cc94517694d0c62;p=org.ibex.gcclass.git

diff --git a/src/com/brian_web/gcclass/GCClass.java b/src/com/brian_web/gcclass/GCClass.java
index 77b6e12..86b4271 100644
--- a/src/com/brian_web/gcclass/GCClass.java
+++ b/src/com/brian_web/gcclass/GCClass.java
@@ -19,9 +19,6 @@ import org.apache.bcel.util.*;
 import org.apache.bcel.generic.*;
 import org.apache.bcel.classfile.*;
 
-// FEATURE: Rebuild each method with a new constant pool to eliminate extra constant pool entries
-// FEATURE: Optimize away INSTANCEOF if the class can never be instansiated
-
 public class GCClass {
     private static final String[] PRE_REF = {
         "java.lang.Thread.run",
@@ -38,16 +35,25 @@ public class GCClass {
         "java.security.*"
     };
     
+    private static final String[] IGNORED_FIELDS = {
+        "java.io.ObjectInputStream.SUBCLASS_IMPLEMENTATION_PERMISSION"
+    };
+    
     private static final String[] NO_OUTPUT = { "java", "javax", "sun", "com.sun", "apple", "com.apple" };
     
     
     public static void main(String[] args) throws Exception {
         if(args.length < 3) {
-            System.err.println("Usage GCClass  classpath outdir entrypoint1 ... [ entrypoint n]");
+            System.err.println("Usage GCClass classpath outdir entrypoint1 ... [ entrypoint n]");
             System.exit(1);
         }
         GCClass gc = new GCClass(args[0]);
-        for(int i=2;i<args.length;i++) gc.referenceMethod(args[i]);
+        for(int i=2;i<args.length;i++) {
+            if(args[i].startsWith("hint:"))
+                gc.parseHint(args[i].substring(5));
+            else
+                gc.referenceMethod(args[i]);
+        }
         gc.go();
         gc.dump(new File(args[1]));
     }
@@ -56,10 +62,22 @@ public class GCClass {
     private final Vector work = new Vector();
     private final Hashtable completed = new Hashtable();
     private final Hashtable references = new Hashtable();
+    private final Hashtable instansiated = new Hashtable();
+    private final Hashtable hints = new Hashtable();
     
     public GCClass(String classpath) throws ClassNotFoundException {
-        repo = SyntheticRepository.getInstance(new ClassPath(ClassPath.SYSTEM_CLASS_PATH + File.pathSeparator + classpath));
-        for(int i=0;i<PRE_REF.length;i++) referenceMethod(PRE_REF[i]);
+        if(classpath.startsWith("="))
+            classpath = classpath.substring(1);
+        else
+            classpath = ClassPath.SYSTEM_CLASS_PATH + File.pathSeparator + classpath;
+        repo = SyntheticRepository.getInstance(new ClassPath(classpath));
+        for(int i=0;i<PRE_REF.length;i++) {
+            try {
+                referenceMethod(PRE_REF[i]);
+            } catch(ClassNotFoundException e) {
+                System.err.println("WARNING: Couldn't preref: " + PRE_REF[i]);
+            }
+        }
     }
     
     private Hashtable classRefHash(JavaClass c) { return classRefHash(new ObjectType(c.getClassName())); }
@@ -81,20 +99,52 @@ public class GCClass {
         return t;
     }
     
-    public final void referenceMethod(String s) throws ClassNotFoundException {
+    public void referenceMethod(String s) throws ClassNotFoundException {
         int p = s.lastIndexOf('.');
         if(p == -1) throw new IllegalArgumentException("invalid class/method string");
         String cs = s.substring(0,p);
         String ms = s.substring(p+1);
+        boolean skip = false;
+        
+        if(cs.startsWith("-")) { cs = cs.substring(1); skip = true; }
+        
+        if(!skip && (ms.equals("*") || ms.equals("<init>")))
+            instansiated.put(new ObjectType(cs),Boolean.TRUE);
+        
+        JavaClass c = repoGet(cs);
+        Method[] methods = c.getMethods();
+        for(int i=0;i<methods.length;i++) {
+            if(ms.equals("*") || methods[i].getName().equals(ms)) {
+                MethodRef mr = new MethodRef(c,methods[i]);
+                if(skip) completed.put(mr,Boolean.TRUE);
+                else referenceMethod(mr);
+            }
+        }
+    }
+    
+    public void parseHint(String s) throws ClassNotFoundException {
+        int p = s.indexOf(':');
+        if(p == -1) throw new IllegalArgumentException("invalid  hint");
+        String cms = s.substring(0,p);
+        String hint = s.substring(p+1);
+        p = cms.lastIndexOf('.');
+        if(p == -1)  throw new IllegalArgumentException("invalid hint");
+        String cs = cms.substring(0,p);
+        String ms = cms.substring(p+1);
         
         JavaClass c = repoGet(cs);
         Method[] methods = c.getMethods();
-        for(int i=0;i<methods.length;i++)
-            if(methods[i].getName().equals(ms))
-                referenceMethod(new MethodRef(c,methods[i]));
+        for(int i=0;i<methods.length;i++) {
+            if(ms.equals("*") || methods[i].getName().equals(ms)) {
+                MethodRef mr = new MethodRef(c,methods[i]);
+                Vector v = (Vector) hints.get(mr);
+                if(v == null) hints.put(mr,v=new Vector());
+                v.add(hint);
+            }
+        }
     }
         
-    public final void referenceMethod(MethodRef m) {
+    private final void referenceMethod(MethodRef m) {
         if(completed.get(m) != null) return;
         
         if(m.c.getClassName().startsWith("[")) {
@@ -110,42 +160,80 @@ public class GCClass {
         for(int i=0;i<m.args.length;i++) referenceClass(m.args[i]);
     }
     
-    public final void referenceField(FieldRef f) {
+    private final void referenceField(FieldRef f) throws ClassNotFoundException  {
+        if(completed.get(f) != null) return;
+        
         Hashtable h = classRefHash(f.c);
         h.put(f,Boolean.TRUE);
+        
+        // process(FieldRef) doesn't create much work so we don't bother queuing it 
+        process(f);
+        
         referenceClass(f.ftype);
     }
     
     private Hashtable repoCache = new Hashtable();
-    public JavaClass repoGet(ObjectType t) throws ClassNotFoundException { return repoGet(t.getClassName()); }
-    public JavaClass repoGet(String s) throws ClassNotFoundException {
+    private JavaClass repoGet(ObjectType t) throws ClassNotFoundException { return repoGet(t.getClassName()); }
+    private JavaClass repoGet(String s) throws ClassNotFoundException {
         Object o = repoCache.get(s);
         if(o == null) repoCache.put(s,o = repo.loadClass(s));
         return (JavaClass) o;
     }
     
-    public void go() throws Exn, ClassNotFoundException {
+    public void go() throws Exn {
         while(work.size() != 0) {
-            while(work.size() != 0) process((MethodRef) work.remove(work.size()-1));
-            fixup();
+            while(work.size() != 0) {
+                MethodRef mr = (MethodRef) work.remove(work.size()-1);
+                try {
+                    process(mr);
+                } catch(ClassNotFoundException e) {
+                    e.printStackTrace();
+                    String refBy = mr.refBy == null ? "unknown" : mr.refBy.toString();
+                    throw new Exn("ERROR: " + refBy + " references " + mr + " which cannot be found");
+                }
+            }
+            try {
+                fixup();
+            } catch(ClassNotFoundException e) {
+                e.printStackTrace();
+                throw new Exn("ClassNotFoundException in fixup");
+            }
         }
     }
-    
+        
     private void fixup() throws ClassNotFoundException {
         for(Enumeration e = references.keys(); e.hasMoreElements(); ) {
             ObjectType t = (ObjectType) e.nextElement();
             JavaClass c = repoGet(t);
-            if(c == null) continue;
             Hashtable refs = (Hashtable) references.get(t);
+             
+            if(c == null) continue;
+           
+            // add a ref to clinit if any fields/methods are referenced
             if(refs.size() != 0) {
                 MethodRef clinit = new MethodRef(t,"<clinit>",Type.VOID,Type.NO_ARGS);
                 if(findMethod(c,clinit) != null) referenceMethod(clinit);
             }
+            
             Method[] methods = c.getMethods();
             JavaClass[] supers = c.getSuperClasses();
             JavaClass[] interfaces = c.getInterfaces();
-            //System.err.println("Fixing up " + t);
+            
+            // If a subclass can be instansiated all its superclasses also can
+            if(instansiated.get(t) != null) {
+                for(int i=0;i<supers.length;i++) {
+                    ObjectType st = new ObjectType(supers[i].getClassName());
+                    if(instansiated.get(st) != null) break;
+                    instansiated.put(st, Boolean.TRUE);
+                }
+            }
+            
+            // If a subclass is referenced all is superclasses also are
             for(int i=0;i<supers.length;i++) referenceClass(supers[i]);
+            
+            // Go though each method and look for method references a
+            // superclass or interfaces version of the method, references them
+            // result in references to us
             for(int i=0;methods != null && i<methods.length;i++) {
                 MethodRef mr = new MethodRef(c,methods[i]);
                 if(refs.get(mr) != null) continue;
@@ -179,6 +267,7 @@ public class GCClass {
 
         JavaClass c = repoGet(mr.c.toString());
         
+        // interfaces can only have a clinit method - every other method has no definition
         if(!c.isClass() && !mr.name.equals("<clinit>")) return;
         
         Method m = findMethod(c,mr);
@@ -193,7 +282,7 @@ public class GCClass {
                 String pat = IGNORED_METHODS[i];
                 if(pat.endsWith("*") ? sig.startsWith(pat.substring(0,pat.length()-1)) : sig.equals(pat)) return;
             }
-            throw new Exn("Couldn't find " + sig);
+            throw new ClassNotFoundException("" + mr + " not found (but the class was)");
         }
         
         Code code = m.getCode();
@@ -207,15 +296,44 @@ public class GCClass {
         
         for(int n=0;n<insns.length;n++) {
             Instruction i = insns[n];
+            if(i instanceof NEW)
+                instansiated.put(((CPInstruction)i).getType(cpg),Boolean.TRUE);
             if(i instanceof ANEWARRAY || i instanceof CHECKCAST || i instanceof INSTANCEOF || i instanceof MULTIANEWARRAY || i instanceof NEW)
                 referenceClass(((CPInstruction)i).getType(cpg));
             else if(i instanceof FieldInstruction) // GETFIED, GETSTATIC, PUTFIELD, PUTSTATIC
                 referenceField(new FieldRef((FieldInstruction)i,cpg));
             else if(i instanceof InvokeInstruction) // INVOKESTATIC, INVOKEVIRTUAL, INVOKESPECIAL
-                referenceMethod(new MethodRef((InvokeInstruction)i,cpg));
+                referenceMethod(new MethodRef((InvokeInstruction)i,cpg,mr));
+        }
+        
+        if(hints.get(mr) != null) {
+            Vector v = (Vector) hints.get(mr);
+            for(int i=0;i<v.size();i++) referenceMethod((String) v.elementAt(i));
         }
     }
     
+    private void process(FieldRef fr) throws ClassNotFoundException {
+        if(completed.get(fr) != null) return;
+        completed.put(fr,Boolean.TRUE);
+
+        JavaClass c = repoGet(fr.c.toString());
+        Field f = findField(c,fr);
+        if(f == null) {
+            JavaClass supers[] = c.getSuperClasses();
+            for(int i=0;i<supers.length;i++) {
+                f = findField(supers[i],fr);
+                if(f != null) { referenceField(new FieldRef(supers[i],f)); return; }
+            }
+            String sig = fr.toString();
+            for(int i=0;i<IGNORED_FIELDS.length;i++) {
+                String pat = IGNORED_FIELDS[i];
+                if(pat.endsWith("*") ? sig.startsWith(pat.substring(0,pat.length()-1)) : sig.equals(pat)) return;
+            }
+            throw new ClassNotFoundException("" + fr + " not found (but the class was)");            
+        }
+        /* nothing to do */
+    }
+    
     private static Method findMethod(JavaClass c, MethodRef mr) {
         Method[] ms = c.getMethods();
         for(int i=0;i<ms.length;i++) {
@@ -226,6 +344,16 @@ public class GCClass {
         return null;
     }
     
+    private static Field findField(JavaClass c, FieldRef fr) {
+        Field[] fs = c.getFields();
+        for(int i=0;i<fs.length;i++) {
+            Field f = fs[i];
+            if(f.getName().equals(fr.name) && f.getType().equals(fr.ftype))
+                return f;
+        }
+        return null;
+    }
+    
     public void dump(File outdir) throws IOException, ClassNotFoundException {
         if(!outdir.isDirectory()) throw new IOException("" + outdir + " is not a directory");
         OUTER: for(Enumeration e = references.keys(); e.hasMoreElements(); ) {
@@ -235,37 +363,61 @@ public class GCClass {
             Hashtable refs = (Hashtable) references.get(t);
             JavaClass c = repoGet(t.getClassName());
             if(c == null) continue;
+            boolean staticOnly = c.isClass() && instansiated.get(t) == null;
             File cf = new File(outdir,t.getClassName().replace('.',File.separatorChar) + ".class");
             cf.getParentFile().mkdirs();
-            dumpClass(c,refs,cf);
+            dumpClass(c,refs,staticOnly,cf);
         }
     }
     
-    private void dumpClass(JavaClass c, Hashtable refs, File file) throws IOException {
-        ClassGen cg = new ClassGen(c);
-        Method[] methods= c.getMethods();
+    private void dumpClass(JavaClass c, Hashtable refs, boolean staticOnly, File file) throws IOException {
+        ClassGen oldCG = new ClassGen(c);
+        ConstantPoolGen oldCP = oldCG.getConstantPool();
+        
+        ConstantPoolGen cp = new ConstantPoolGen();
+        ClassGen cg = new ClassGen(c.getClassName(),c.getSuperclassName(),c.getSourceFileName(),c.getAccessFlags(),c.getInterfaceNames(),cp);
+        
+        Method[] methods= oldCG.getMethods();
         for(int i=0;i<methods.length;i++) {
             Method m = methods[i];
             MethodRef mr = new MethodRef(c,m);
-            if(refs.get(mr) == null) {
+            if((staticOnly && !m.isStatic()) || refs.get(mr) == null) {
                 System.err.println("Removing method " + mr);
-                if(false) {
-                    cg.removeMethod(m);
-                } else {
+                if(true) {
                     InstructionFactory fac = new InstructionFactory(cg,cg.getConstantPool());
                     InstructionList il = new InstructionList();
-                    MethodGen mg = new MethodGen(m.getAccessFlags(),m.getReturnType(),m.getArgumentTypes(),null,m.getName(),c.getClassName(),il,cg.getConstantPool());
+                    MethodGen mg = new MethodGen(m.getAccessFlags(),m.getReturnType(),m.getArgumentTypes(),null,m.getName(),c.getClassName(),il,cp);
                     il.append(fac.createNew("java.lang.UnsatisfiedLinkError"));
                     il.append(InstructionConstants.DUP);
-                    il.append(new PUSH(cg.getConstantPool(),"" + mr + " has been pruned"));
-                    il.append(fac.createInvoke("java.lang.UnsatisfiedLinkError","<init>",Type.VOID, new Type[]{Type.STRING},Constants.INVOKESPECIAL));
+                    if(false) {
+                        il.append(new PUSH(cg.getConstantPool(),"" + mr + " has been pruned"));
+                        il.append(fac.createInvoke("java.lang.UnsatisfiedLinkError","<init>",Type.VOID, new Type[]{Type.STRING},Constants.INVOKESPECIAL));
+                    } else {
+                        il.append(fac.createInvoke("java.lang.UnsatisfiedLinkError","<init>",Type.VOID,Type.NO_ARGS,Constants.INVOKESPECIAL));
+                    }
                     il.append(InstructionConstants.ATHROW);
                     mg.setMaxStack();
                     mg.setMaxLocals();
-                    cg.replaceMethod(m,mg.getMethod());
+                    cg.addMethod(mg.getMethod());
                 }
-            } else {
-                //System.err.println("Keeping method " + mr);
+            } else {                
+                MethodGen mg = new MethodGen(m,cg.getClassName(),oldCP);
+                mg.setConstantPool(cp);
+                if(mg.getInstructionList() != null) mg.getInstructionList().replaceConstantPool(oldCP, cp);
+                
+                Attribute[] attrs = m.getAttributes();
+                for(int j=0;j<attrs.length;j++) {
+                    Attribute a = attrs[j];
+                    if(a instanceof Code || a instanceof ExceptionTable) continue;
+                    mg.removeAttribute(a);
+                    Constant con = oldCP.getConstant(a.getNameIndex());
+                    a.setNameIndex(cp.addConstant(con,oldCP));
+                    mg.addAttribute(a);                    
+                }
+                
+                mg.removeLineNumbers();
+                mg.removeLocalVariables();
+                cg.addMethod(mg.getMethod());
             }
         }
         
@@ -275,9 +427,31 @@ public class GCClass {
             FieldRef fr = new FieldRef(c,f);
             if(refs.get(fr) == null) {
                 System.err.println("Removing field " + fr);
-                cg.removeField(f);
             } else {
                 //System.err.println("Keeping field " + fr);
+                FieldGen fg = new FieldGen(f.getAccessFlags(),f.getType(),f.getName(),cp);
+                Attribute[] attrs = f.getAttributes();
+                for(int j=0;j<attrs.length;j++) {
+                    if(attrs[j] instanceof ConstantValue) {
+                        ConstantObject co = (ConstantObject) oldCP.getConstant(((ConstantValue)attrs[i]).getConstantValueIndex());
+                        Object o = co.getConstantValue(oldCP.getConstantPool());
+                        if(co instanceof ConstantLong) fg.setInitValue(((Number)o).longValue());
+                        else if(co instanceof ConstantInteger) fg.setInitValue(((Number)o).intValue());
+                        else if(co instanceof ConstantFloat) fg.setInitValue(((Number)o).floatValue());
+                        else if(co instanceof ConstantDouble) fg.setInitValue(((Number)o).floatValue());
+                        else if(co instanceof ConstantString) fg.setInitValue((String)o);
+                        else throw new Error("should never happen");
+                    } else {
+                        Attribute a = attrs[j];
+                        Constant con = oldCP.getConstant(a.getNameIndex());
+                        a.setNameIndex(cp.addConstant(con,oldCP));
+                        //System.err.println("Adding attribute: " + attrs[j]);
+                        fg.addAttribute(a);
+                    }
+                }
+                /*if(f.getConstantValue() != null) throw new Error("this might be broken");
+                FieldGen fg = new FieldGen(f.getAccessFlags(),f.getType(),f.getName(),cp);*/
+                cg.addField(fg.getField());
             }
         }
         
@@ -286,20 +460,21 @@ public class GCClass {
     }
     
     public static class Exn extends Exception { public Exn(String s) { super(s); } }
-        
-        
+    
     private static class MethodRef {
         ObjectType c;
         String name;
         Type ret;
         Type[] args;
-        
+        MethodRef refBy;
+                
         public MethodRef(JavaClass c, Method m) {
             this(new ObjectType(c.getClassName()),m.getName(),m.getReturnType(),m.getArgumentTypes());
         }
         
-        public MethodRef(InvokeInstruction i, ConstantPoolGen cp) {
+        public MethodRef(InvokeInstruction i, ConstantPoolGen cp, MethodRef refBy) {
             this(i.getClassType(cp),i.getMethodName(cp),i.getReturnType(cp),i.getArgumentTypes(cp));
+            this.refBy = refBy;
         }
         
         public MethodRef(ObjectType c, String name, Type ret, Type[] args) { this.c = c; this.name = name; this.ret = ret; this.args = args; }
@@ -319,10 +494,11 @@ public class GCClass {
         public String toString() { return c.toString() + "." + name + Type.getMethodSignature(ret,args); }
     }
     
-    public static class FieldRef {
+    private static class FieldRef {
         ObjectType c;
         String name;
         Type ftype;
+        MethodRef refBy;
         
         public FieldRef(JavaClass c, Field f) {
             this(new ObjectType(c.getClassName()),f.getName(),f.getType());