sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/optimize/KeepMarker.java

@@ -0,0 +1,95 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize;
+
+import proguard.classfile.*;
+import proguard.classfile.util.MethodLinker;
+import proguard.classfile.visitor.*;
+
+
+/**
+ * This <code>ClassVisitor</code> and <code>MemberVisitor</code>
+ * marks classes and class members it visits. The marked elements
+ * will remain unchanged as necessary in the optimization step.
+ *
+ * @author Eric Lafortune
+ */
+public class KeepMarker
+implements   ClassVisitor,
+             MemberVisitor
+{
+    // A visitor info flag to indicate the visitor accepter is being kept.
+    private static final Object KEPT = new Object();
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        markAsKept(programClass);
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        markAsKept(libraryClass);
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        markAsKept(programField);
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        markAsKept(MethodLinker.lastMember(programMethod));
+    }
+
+
+    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
+    {
+        markAsKept(libraryField);
+    }
+
+
+    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+    {
+        markAsKept(MethodLinker.lastMember(libraryMethod));
+    }
+
+
+    // Small utility methods.
+
+    private static void markAsKept(VisitorAccepter visitorAccepter)
+    {
+        visitorAccepter.setVisitorInfo(KEPT);
+    }
+
+
+    public static boolean isKept(VisitorAccepter visitorAccepter)
+    {
+        return MethodLinker.lastVisitorAccepter(visitorAccepter).getVisitorInfo() == KEPT;
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/KeptClassFilter.java

@@ -0,0 +1,69 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize;
+
+import proguard.classfile.*;
+import proguard.classfile.visitor.ClassVisitor;
+
+/**
+ * This ClassVisitor delegates all its method calls to another ClassVisitor,
+ * but only for Clazz objects that are marked as kept.
+ *
+ * @see KeepMarker
+ *
+ * @author Eric Lafortune
+ */
+public class KeptClassFilter
+implements   ClassVisitor
+{
+    private final ClassVisitor classVisitor;
+
+
+    /**
+     * Creates a new KeptClassFilter.
+     * @param classVisitor the class visitor to which the visiting will be
+     *                     delegated.
+     */
+    public KeptClassFilter(ClassVisitor classVisitor)
+    {
+        this.classVisitor = classVisitor;
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        if (KeepMarker.isKept(programClass))
+        {
+            classVisitor.visitProgramClass(programClass);
+        }
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        if (KeepMarker.isKept(libraryClass))
+        {
+            classVisitor.visitLibraryClass(libraryClass);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/KeptMemberFilter.java

@@ -0,0 +1,88 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize;
+
+import proguard.classfile.*;
+import proguard.classfile.visitor.MemberVisitor;
+
+/**
+ * This MemberVisitor delegates all its method calls to another MemberVisitor,
+ * but only for Member objects that are marked as kept.
+ *
+ * @see KeepMarker
+ *
+ * @author Eric Lafortune
+ */
+public class KeptMemberFilter
+implements   MemberVisitor
+{
+    private final MemberVisitor memberVisitor;
+
+
+    /**
+     * Creates a new KeptMemberFilter.
+     * @param memberVisitor the member visitor to which the visiting will be
+     *                      delegated.
+     */
+    public KeptMemberFilter(MemberVisitor memberVisitor)
+    {
+        this.memberVisitor = memberVisitor;
+    }
+
+
+    // Implementations for MemberVisitor.
+
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        if (KeepMarker.isKept(programField))
+        {
+            memberVisitor.visitProgramField(programClass, programField);
+        }
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        if (KeepMarker.isKept(programMethod))
+        {
+            memberVisitor.visitProgramMethod(programClass, programMethod);
+        }
+    }
+
+
+    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
+    {
+        if (KeepMarker.isKept(libraryField))
+        {
+            memberVisitor.visitLibraryField(libraryClass, libraryField);
+        }
+    }
+
+
+    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+    {
+        if (KeepMarker.isKept(libraryMethod))
+        {
+            memberVisitor.visitLibraryMethod(libraryClass, libraryMethod);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/MemberDescriptorSpecializer.java

@@ -0,0 +1,138 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize;
+
+import proguard.classfile.*;
+import proguard.classfile.editor.ClassReferenceFixer;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.MemberVisitor;
+import proguard.evaluation.value.Value;
+import proguard.optimize.evaluation.StoringInvocationUnit;
+
+/**
+ * This MemberVisitor specializes parameters in the descriptors of the
+ * methods that it visits.
+ *
+ * @see StoringInvocationUnit
+ * @see ClassReferenceFixer
+ * @author Eric Lafortune
+ */
+public class MemberDescriptorSpecializer
+extends      SimplifiedVisitor
+implements   MemberVisitor
+{
+    private static final boolean DEBUG = false;
+
+
+    private final MemberVisitor extraParameterMemberVisitor;
+
+
+    /**
+     * Creates a new MethodDescriptorShrinker.
+     */
+    public MemberDescriptorSpecializer()
+    {
+        this(null);
+    }
+
+
+    /**
+     * Creates a new MethodDescriptorShrinker with an extra visitor.
+     * @param extraParameterMemberVisitor an optional extra visitor for all
+     *                                    class members whose parameters have
+     *                                    been specialized.
+     */
+    public MemberDescriptorSpecializer(MemberVisitor extraParameterMemberVisitor)
+    {
+        this.extraParameterMemberVisitor = extraParameterMemberVisitor;
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        Value parameterValue = StoringInvocationUnit.getFieldValue(programField);
+        if (parameterValue.computationalType() == Value.TYPE_REFERENCE)
+        {
+            Clazz referencedClass = parameterValue.referenceValue().getReferencedClass();
+            if (programField.referencedClass != referencedClass)
+            {
+                if (DEBUG)
+                {
+                    System.out.println("MemberDescriptorSpecializer: "+programClass.getName()+"."+programField.getName(programClass)+" "+programField.getDescriptor(programClass));
+                    System.out.println("  "+programField.referencedClass.getName()+" -> "+referencedClass.getName());
+                }
+
+                programField.referencedClass = referencedClass;
+
+                // Visit the field, if required.
+                if (extraParameterMemberVisitor != null)
+                {
+                    extraParameterMemberVisitor.visitProgramField(programClass, programField);
+                }
+            }
+        }
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        // All parameters of non-static methods are shifted by one in the local
+        // variable frame.
+        int firstParameterIndex =
+            (programMethod.getAccessFlags() & ClassConstants.INTERNAL_ACC_STATIC) != 0 ?
+                0 : 1;
+
+        int parameterCount =
+            ClassUtil.internalMethodParameterCount(programMethod.getDescriptor(programClass));
+
+        int classIndex = 0;
+
+        // Go over the parameters.
+        for (int parameterIndex = firstParameterIndex; parameterIndex < parameterCount; parameterIndex++)
+        {
+            Value parameterValue = StoringInvocationUnit.getMethodParameterValue(programMethod, parameterIndex);
+             if (parameterValue.computationalType() == Value.TYPE_REFERENCE)
+             {
+                 Clazz referencedClass = parameterValue.referenceValue().getReferencedClass();
+                 if (programMethod.referencedClasses[classIndex] != referencedClass)
+                 {
+                     if (DEBUG)
+                     {
+                         System.out.println("MemberDescriptorSpecializer: "+programClass.getName()+"."+programMethod.getName(programClass)+programMethod.getDescriptor(programClass));
+                         System.out.println("  "+programMethod.referencedClasses[classIndex].getName()+" -> "+referencedClass.getName());
+                     }
+
+                     programMethod.referencedClasses[classIndex] = referencedClass;
+
+                     // Visit the method, if required.
+                     if (extraParameterMemberVisitor != null)
+                     {
+                         extraParameterMemberVisitor.visitProgramMethod(programClass, programMethod);
+                     }
+                 }
+
+                 classIndex++;
+             }
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/MethodDescriptorShrinker.java

@@ -0,0 +1,317 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.annotation.*;
+import proguard.classfile.attribute.visitor.*;
+import proguard.classfile.editor.ConstantPoolEditor;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.MemberVisitor;
+import proguard.optimize.info.*;
+import proguard.optimize.peephole.VariableShrinker;
+
+/**
+ * This MemberVisitor removes unused parameters in the descriptors of the
+ * methods that it visits.
+ *
+ * @see ParameterUsageMarker
+ * @see VariableUsageMarker
+ * @see VariableShrinker
+ * @author Eric Lafortune
+ */
+public class MethodDescriptorShrinker
+extends      SimplifiedVisitor
+implements   MemberVisitor,
+             AttributeVisitor
+{
+    private static final boolean DEBUG = false;
+
+
+    private final MemberVisitor extraMemberVisitor;
+
+
+    /**
+     * Creates a new MethodDescriptorShrinker.
+     */
+    public MethodDescriptorShrinker()
+    {
+        this(null);
+    }
+
+
+    /**
+     * Creates a new MethodDescriptorShrinker with an extra visitor.
+     * @param extraMemberVisitor an optional extra visitor for all methods whose
+     *                           parameters have been simplified.
+     */
+    public MethodDescriptorShrinker(MemberVisitor extraMemberVisitor)
+    {
+        this.extraMemberVisitor = extraMemberVisitor;
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        // Update the descriptor if it has any unused parameters.
+        String descriptor    = programMethod.getDescriptor(programClass);
+        String newDescriptor = shrinkDescriptor(programMethod, descriptor);
+
+        if (!descriptor.equals(newDescriptor))
+        {
+            // Shrink the signature and parameter annotations.
+            programMethod.attributesAccept(programClass, this);
+
+            String name    = programMethod.getName(programClass);
+            String newName = name;
+
+            // Append a code, if the method isn't a class instance initializer.
+            if (!name.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT))
+            {
+                newName += ClassConstants.SPECIAL_MEMBER_SEPARATOR + Long.toHexString(Math.abs((descriptor).hashCode()));
+            }
+
+            if (DEBUG)
+            {
+                System.out.println("MethodDescriptorShrinker:");
+                System.out.println("  ["+programClass.getName()+"."+
+                                   name+descriptor+"] -> ["+
+                                   newName+newDescriptor+"]");
+            }
+
+            ConstantPoolEditor constantPoolEditor =
+                new ConstantPoolEditor(programClass);
+
+            // Update the name, if necessary.
+            if (!newName.equals(name))
+            {
+                programMethod.u2nameIndex =
+                    constantPoolEditor.addUtf8Constant(newName);
+            }
+
+            // Update the referenced classes.
+            programMethod.referencedClasses =
+                shrinkReferencedClasses(programMethod,
+                                        descriptor,
+                                        programMethod.referencedClasses);
+
+            // Finally, update the descriptor itself.
+            programMethod.u2descriptorIndex =
+                constantPoolEditor.addUtf8Constant(newDescriptor);
+
+            // Visit the method, if required.
+            if (extraMemberVisitor != null)
+            {
+                extraMemberVisitor.visitProgramMethod(programClass, programMethod);
+            }
+        }
+    }
+
+
+    // Implementations for AttributeVisitor.
+
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+    public void visitSignatureAttribute(Clazz clazz, Method method, SignatureAttribute signatureAttribute)
+    {
+        // Compute the new signature.
+        String signature    = clazz.getString(signatureAttribute.u2signatureIndex);
+        String newSignature = shrinkDescriptor(method, signature);
+
+        // Update the signature.
+        signatureAttribute.u2signatureIndex =
+            new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newSignature);
+
+        // Update the referenced classes.
+        signatureAttribute.referencedClasses =
+            shrinkReferencedClasses(method,
+                                    signature,
+                                    signatureAttribute.referencedClasses);
+    }
+
+
+    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
+    {
+        int[]          annotationsCounts = parameterAnnotationsAttribute.u2parameterAnnotationsCount;
+        Annotation[][] annotations       = parameterAnnotationsAttribute.parameterAnnotations;
+
+        // All parameters of non-static methods are shifted by one in the local
+        // variable frame.
+        int parameterIndex =
+            (method.getAccessFlags() & ClassConstants.INTERNAL_ACC_STATIC) != 0 ?
+                0 : 1;
+
+        int annotationIndex    = 0;
+        int newAnnotationIndex = 0;
+
+        // Go over the parameters.
+        String descriptor = method.getDescriptor(clazz);
+        InternalTypeEnumeration internalTypeEnumeration =
+            new InternalTypeEnumeration(descriptor);
+
+        while (internalTypeEnumeration.hasMoreTypes())
+        {
+            String type = internalTypeEnumeration.nextType();
+            if (ParameterUsageMarker.isParameterUsed(method, parameterIndex))
+            {
+                annotationsCounts[newAnnotationIndex] = annotationsCounts[annotationIndex];
+                annotations[newAnnotationIndex++]     = annotations[annotationIndex];
+            }
+
+            annotationIndex++;
+
+            parameterIndex += ClassUtil.isInternalCategory2Type(type) ? 2 : 1;
+        }
+
+        // Update the number of parameters.
+        parameterAnnotationsAttribute.u2parametersCount = newAnnotationIndex;
+
+        // Clear the unused entries.
+        while (newAnnotationIndex < annotationIndex)
+        {
+            annotationsCounts[newAnnotationIndex] = 0;
+            annotations[newAnnotationIndex++]     = null;
+        }
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Returns a shrunk descriptor or signature of the given method.
+     */
+    private String shrinkDescriptor(Method method, String descriptor)
+    {
+        // All parameters of non-static methods are shifted by one in the local
+        // variable frame.
+        int parameterIndex =
+            (method.getAccessFlags() & ClassConstants.INTERNAL_ACC_STATIC) != 0 ?
+                0 : 1;
+
+        // Go over the parameters.
+        InternalTypeEnumeration internalTypeEnumeration =
+            new InternalTypeEnumeration(descriptor);
+
+        StringBuffer newDescriptorBuffer = new StringBuffer();
+
+        newDescriptorBuffer.append(internalTypeEnumeration.formalTypeParameters());
+        newDescriptorBuffer.append(ClassConstants.INTERNAL_METHOD_ARGUMENTS_OPEN);
+
+        while (internalTypeEnumeration.hasMoreTypes())
+        {
+            String type = internalTypeEnumeration.nextType();
+            if (ParameterUsageMarker.isParameterUsed(method, parameterIndex))
+            {
+                newDescriptorBuffer.append(type);
+            }
+            else if (DEBUG)
+            {
+                System.out.println("  Deleting parameter #"+parameterIndex+" ["+type+"]");
+            }
+
+            parameterIndex += ClassUtil.isInternalCategory2Type(type) ? 2 : 1;
+        }
+
+        newDescriptorBuffer.append(ClassConstants.INTERNAL_METHOD_ARGUMENTS_CLOSE);
+        newDescriptorBuffer.append(internalTypeEnumeration.returnType());
+
+        return newDescriptorBuffer.toString();
+    }
+
+
+    /**
+     * Shrinks the array of referenced classes of the given method.
+     */
+    private Clazz[] shrinkReferencedClasses(Method  method,
+                                            String  descriptor,
+                                            Clazz[] referencedClasses)
+    {
+        if (referencedClasses != null)
+        {
+            // All parameters of non-static methods are shifted by one in the local
+            // variable frame.
+            int parameterIndex =
+                (method.getAccessFlags() & ClassConstants.INTERNAL_ACC_STATIC) != 0 ?
+                    0 : 1;
+
+            int referencedClassIndex    = 0;
+            int newReferencedClassIndex = 0;
+
+            // Go over the parameters.
+            InternalTypeEnumeration internalTypeEnumeration =
+                new InternalTypeEnumeration(descriptor);
+
+            // Also look at the formal type parameters.
+            String type  = internalTypeEnumeration.formalTypeParameters();
+            int    count = new DescriptorClassEnumeration(type).classCount();
+            for (int counter = 0; counter < count; counter++)
+            {
+                referencedClasses[newReferencedClassIndex++] =
+                    referencedClasses[referencedClassIndex++];
+            }
+
+            while (internalTypeEnumeration.hasMoreTypes())
+            {
+                // Consider the classes referenced by this parameter type.
+                type  = internalTypeEnumeration.nextType();
+                count = new DescriptorClassEnumeration(type).classCount();
+
+                if (ParameterUsageMarker.isParameterUsed(method, parameterIndex))
+                {
+                    // Copy the referenced classes.
+                    for (int counter = 0; counter < count; counter++)
+                    {
+                        referencedClasses[newReferencedClassIndex++] =
+                            referencedClasses[referencedClassIndex++];
+                    }
+                }
+                else
+                {
+                    // Skip the referenced classes.
+                    referencedClassIndex += count;
+                }
+
+                parameterIndex += ClassUtil.isInternalCategory2Type(type) ? 2 : 1;
+            }
+
+            // Also look at the return value.
+            type  = internalTypeEnumeration.returnType();
+            count = new DescriptorClassEnumeration(type).classCount();
+            for (int counter = 0; counter < count; counter++)
+            {
+                referencedClasses[newReferencedClassIndex++] =
+                    referencedClasses[referencedClassIndex++];
+            }
+
+            // Clear the unused entries.
+            while (newReferencedClassIndex < referencedClassIndex)
+            {
+                referencedClasses[newReferencedClassIndex++] = null;
+            }
+        }
+
+        return referencedClasses;
+    }
+}