RubyGems - sometsome - Versions diffs - 1.0.2 → 3.10.42 - Mend

sometsome 1.0.2 → 3.10.42

Files changed (732) hide show

data/lib/proguard4.7/src/proguard/optimize/peephole/package.html ADDED

@@ -0,0 +1,3 @@
+<body>
+This package contains visitors that perform various peephole optimizations.
+</body>

data/lib/proguard4.7/src/proguard/package.html ADDED

@@ -0,0 +1,5 @@
+<body>
+This package contains the main ProGuard application.
+ProGuard can read jar files, shrink and obfuscate them, and write out the
+resulting jar file.
+</body>

data/lib/proguard4.7/src/proguard/preverify/CodePreverifier.java ADDED

@@ -0,0 +1,611 @@
+/*
+ * 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.preverify;
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.preverification.*;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.editor.*;
+import proguard.classfile.instruction.*;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.*;
+import proguard.evaluation.*;
+import proguard.evaluation.value.*;
+import proguard.optimize.evaluation.*;
+import java.util.*;
+/**
+ * This class can preverify methods in program class pools, according to a given
+ * specification.
+ *
+ * @author Eric Lafortune
+ */
+public class CodePreverifier
+extends      SimplifiedVisitor
+implements   MemberVisitor,
+             AttributeVisitor
+{
+    //*
+    private static final boolean DEBUG = false;
+    /*/
+    private static       boolean DEBUG = true;
+    //*/
+    private final boolean microEdition;
+    private final PartialEvaluator partialEvaluator = new PartialEvaluator();
+    private final LivenessAnalyzer livenessAnalyzer = new LivenessAnalyzer(partialEvaluator);
+    /**
+     * Creates a new CodePreverifier.
+     */
+    public CodePreverifier(boolean microEdition)
+    {
+        this.microEdition = microEdition;
+    }
+    // Implementations for AttributeVisitor.
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        // TODO: Remove this when the preverifier has stabilized.
+        // Catch any unexpected exceptions from the actual visiting method.
+        try
+        {
+            // Process the code.
+            visitCodeAttribute0(clazz, method, codeAttribute);
+        }
+        catch (RuntimeException ex)
+        {
+            System.err.println("Unexpected error while preverifying:");
+            System.err.println("  Class       = ["+clazz.getName()+"]");
+            System.err.println("  Method      = ["+method.getName(clazz)+method.getDescriptor(clazz)+"]");
+            System.err.println("  Exception   = ["+ex.getClass().getName()+"] ("+ex.getMessage()+")");
+            throw ex;
+        }
+    }
+    public void visitCodeAttribute0(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+//        DEBUG =
+//            clazz.getName().equals("abc/Def") &&
+//            method.getName(clazz).equals("abc");
+        ProgramClass  programClass  = (ProgramClass)clazz;
+        ProgramMethod programMethod = (ProgramMethod)method;
+        // Evaluate the method.
+        //partialEvaluator.visitCodeAttribute(clazz, method, codeAttribute);
+        livenessAnalyzer.visitCodeAttribute(clazz, method, codeAttribute);
+        // Collect the stack map frames.
+        List stackMapFrameList = new ArrayList();
+        for (int offset = 0; offset < codeAttribute.u4codeLength; offset++)
+        {
+            // Only store frames at the beginning of code blocks.
+            if (partialEvaluator.isTraced(offset) &&
+                partialEvaluator.isBranchOrExceptionTarget(offset))
+            {
+                // Convert the variable values to types.
+                VerificationType[] variableTypes =
+                    correspondingVerificationTypes(programClass,
+                                                   programMethod,
+                                                   codeAttribute,
+                                                   offset,
+                                                   partialEvaluator.getVariablesBefore(offset));
+                // Convert the stack values to types.
+                VerificationType[] stackTypes =
+                    correspondingVerificationTypes(programClass,
+                                                   programMethod,
+                                                   codeAttribute,
+                                                   offset,
+                                                   partialEvaluator.getStackBefore(offset));
+                // Create and store a new frame.
+                stackMapFrameList.add(new FullFrame(offset,
+                                                    variableTypes,
+                                                    stackTypes));
+            }
+        }
+        // Compress the stack map frames if the target is not Java Micro Edition.
+        if (!microEdition && !stackMapFrameList.isEmpty())
+        {
+            // Convert the initial variable values to types.
+            VerificationType[] initialVariables =
+                correspondingVerificationTypes(programClass,
+                                               programMethod,
+                                               codeAttribute,
+                                               PartialEvaluator.AT_METHOD_ENTRY,
+                                               partialEvaluator.getVariablesBefore(0));
+            // Special case: the <init> method.
+            if (method.getName(programClass).equals(ClassConstants.INTERNAL_METHOD_NAME_INIT))
+            {
+                initialVariables[0] = VerificationTypeFactory.createUninitializedThisType();
+            }
+            compressStackMapFrames(initialVariables,
+                                   stackMapFrameList);
+        }
+        // Get the proper name for the attribute to be added/replaced/deleted.
+        String stackMapAttributeName = microEdition ?
+             ClassConstants.ATTR_StackMap :
+             ClassConstants.ATTR_StackMapTable;
+        int frameCount = stackMapFrameList.size();
+        if (DEBUG)
+        {
+            Attribute originalStackMapAttribute = codeAttribute.getAttribute(clazz,
+                                                                             stackMapAttributeName);
+            if (originalStackMapAttribute != null)
+            {
+                int originalFrameCount = microEdition ?
+                    ((StackMapAttribute)originalStackMapAttribute).u2stackMapFramesCount :
+                    ((StackMapTableAttribute)originalStackMapAttribute).u2stackMapFramesCount;
+                StackMapFrame[] originalFrames = microEdition ?
+                    ((StackMapAttribute)originalStackMapAttribute).stackMapFrames :
+                    ((StackMapTableAttribute)originalStackMapAttribute).stackMapFrames;
+                if (frameCount != originalFrameCount ||
+                    !Arrays.equals(stackMapFrameList.toArray(), originalFrames))
+                {
+                    System.out.println("Original preverification ["+clazz.getName()+"]:");
+                    new ClassPrinter().visitProgramMethod(programClass, programMethod);
+                }
+            }
+            else if (frameCount != 0)
+            {
+                System.out.println("Original preverification empty ["+clazz.getName()+"."+method.getName(clazz)+"]");
+            }
+        }
+        if (frameCount == 0)
+        {
+            // Remove any stack map (table) attribute from the code attribute.
+            new AttributesEditor(programClass, programMethod, codeAttribute, true).deleteAttribute(stackMapAttributeName);
+        }
+        else
+        {
+            Attribute stackMapAttribute;
+            // Create the appropriate attribute.
+            if (microEdition)
+            {
+                // Copy the frames into an array.
+                FullFrame[] stackMapFrames = new FullFrame[frameCount];
+                stackMapFrameList.toArray(stackMapFrames);
+                // Put the frames into a stack map attribute.
+                stackMapAttribute = new StackMapAttribute(stackMapFrames);
+            }
+            else
+            {
+                // Copy the frames into an array.
+                StackMapFrame[] stackMapFrames = new StackMapFrame[frameCount];
+                stackMapFrameList.toArray(stackMapFrames);
+                // Put the frames into a stack map table attribute.
+                stackMapAttribute = new StackMapTableAttribute(stackMapFrames);
+            }
+            // Fill out the name of the stack map attribute.
+            stackMapAttribute.u2attributeNameIndex =
+                new ConstantPoolEditor(programClass).addUtf8Constant(stackMapAttributeName);
+            // Add the new stack map (table) attribute to the code attribute.
+            new AttributesEditor(programClass, programMethod, codeAttribute, true).addAttribute(stackMapAttribute);
+            if (DEBUG)
+            {
+                System.out.println("Preverifier ["+programClass.getName()+"."+programMethod.getName(programClass)+"]:");
+                stackMapAttribute.accept(programClass, programMethod, codeAttribute, new ClassPrinter());
+            }
+        }
+    }
+    // Small utility methods.
+    /**
+     * Creates and returns the verification types corresponding to the given
+     * variables. If necessary, class constants are added to the constant pool
+     * of the given class.
+     */
+    private VerificationType[] correspondingVerificationTypes(ProgramClass    programClass,
+                                                              ProgramMethod   programMethod,
+                                                              CodeAttribute   codeAttribute,
+                                                              int             offset,
+                                                              TracedVariables variables)
+    {
+        int maximumVariablesSize = variables.size();
+        int typeCount = 0;
+        int typeIndex = 0;
+        // Count the the number of verification types, ignoring any nulls at
+        // the end.
+        for (int index = 0; index < maximumVariablesSize; index++)
+        {
+            Value value = variables.getValue(index);
+            typeIndex++;
+            // Remember the maximum live type index.
+            if (value != null &&
+                (offset == PartialEvaluator.AT_METHOD_ENTRY ||
+                 livenessAnalyzer.isAliveBefore(offset, index)))
+            {
+                typeCount = typeIndex;
+                // Category 2 types that are alive are stored as single entries.
+                if (value.isCategory2())
+                {
+                    index++;
+                }
+            }
+        }
+        // Create and fill out the verification types.
+        VerificationType[] types = new VerificationType[typeCount];
+        typeIndex = 0;
+        // Note the slightly different terminating condition, because the
+        // types may have been truncated.
+        for (int index = 0; typeIndex < typeCount; index++)
+        {
+            Value value         = variables.getValue(index);
+            Value producerValue = variables.getProducerValue(index);
+            // Fill out the type.
+            VerificationType type;
+            if (value != null &&
+                (offset == PartialEvaluator.AT_METHOD_ENTRY ||
+                 livenessAnalyzer.isAliveBefore(offset, index)))
+            {
+                type = correspondingVerificationType(programClass,
+                                                     programMethod,
+                                                     codeAttribute,
+                                                     offset,
+                                                     index == 0,
+                                                     value,
+                                                     producerValue);
+                // Category 2 types that are alive are stored as single entries.
+                if (value.isCategory2())
+                {
+                    index++;
+                }
+            }
+            else
+            {
+                type = VerificationTypeFactory.createTopType();
+            }
+            types[typeIndex++] = type;
+        }
+        return types;
+    }
+    /**
+     * Creates and returns the verification types corresponding to the given
+     * stack. If necessary, class constants are added to the constant pool
+     * of the given class.
+     */
+    private VerificationType[] correspondingVerificationTypes(ProgramClass  programClass,
+                                                              ProgramMethod programMethod,
+                                                              CodeAttribute codeAttribute,
+                                                              int           offset,
+                                                              TracedStack   stack)
+    {
+        int maximumStackSize = stack.size();
+        int typeCount = 0;
+        // Count the the number of verification types.
+        for (int index = 0; index < maximumStackSize; index++)
+        {
+            // We have to work down from the top of the stack.
+            Value value = stack.getTop(index);
+            typeCount++;
+            // Category 2 types are stored as single entries.
+            if (value.isCategory2())
+            {
+                index++;
+            }
+        }
+        // Create and fill out the verification types.
+        VerificationType[] types = new VerificationType[typeCount];
+        int typeIndex = typeCount;
+        for (int index = 0; index < maximumStackSize; index++)
+        {
+            // We have to work down from the top of the stack.
+            Value value         = stack.getTop(index);
+            Value producerValue = stack.getTopProducerValue(index);
+            // Fill out the type.
+            types[--typeIndex] =
+                correspondingVerificationType(programClass,
+                                              programMethod,
+                                              codeAttribute,
+                                              offset,
+                                              false,
+                                              value,
+                                              producerValue);
+            // Category 2 types are stored as single entries.
+            if (value.isCategory2())
+            {
+                index++;
+            }
+        }
+        return types;
+    }
+    /**
+     * Creates and returns the verification type corresponding to the given
+     * value. If necessary, a class constant is added to the constant pool of
+     * the given class.
+     */
+    private VerificationType correspondingVerificationType(ProgramClass  programClass,
+                                                           ProgramMethod programMethod,
+                                                           CodeAttribute codeAttribute,
+                                                           int           offset,
+                                                           boolean       isVariable0,
+                                                           Value         value,
+                                                           Value         producerValue)
+    {
+        if (value == null)
+        {
+            return VerificationTypeFactory.createTopType();
+        }
+        int type = value.computationalType();
+        switch (type)
+        {
+            case Value.TYPE_INSTRUCTION_OFFSET:
+            case Value.TYPE_INTEGER:   return VerificationTypeFactory.createIntegerType();
+            case Value.TYPE_LONG:      return VerificationTypeFactory.createLongType();
+            case Value.TYPE_FLOAT:     return VerificationTypeFactory.createFloatType();
+            case Value.TYPE_DOUBLE:    return VerificationTypeFactory.createDoubleType();
+            case Value.TYPE_TOP:       return VerificationTypeFactory.createTopType();
+            case Value.TYPE_REFERENCE:
+                // Is it a Null type?
+                ReferenceValue referenceValue = value.referenceValue();
+                if (referenceValue.isNull() == Value.ALWAYS)
+                {
+                    return VerificationTypeFactory.createNullType();
+                }
+                // Does the reference type have a single producer?
+                if (offset != PartialEvaluator.AT_METHOD_ENTRY)
+                {
+                    InstructionOffsetValue producers = producerValue.instructionOffsetValue();
+                    if (producers.instructionOffsetCount() == 1)
+                    {
+                        int producerOffset = producers.instructionOffset(0);
+                        // Follow any dup or swap instructions.
+                        while (producerOffset != PartialEvaluator.AT_METHOD_ENTRY &&
+                               isDupOrSwap(codeAttribute.code[producerOffset]))
+                        {
+                            producers      = partialEvaluator.getStackBefore(producerOffset).getTopProducerValue(0).instructionOffsetValue();
+                            producerOffset = producers.instructionOffset(0);
+                        }
+                        // Are we in an instance initialization method,
+                        // before the super initialization, loading "this"?
+                        if (partialEvaluator.isInitializer()                       &&
+                            offset <= partialEvaluator.superInitializationOffset() &&
+                            (isVariable0 ||
+                             producerOffset > PartialEvaluator.AT_METHOD_ENTRY &&
+                             codeAttribute.code[producerOffset] == InstructionConstants.OP_ALOAD_0))
+                        {
+                            // It's an UninitializedThis type.
+                            return VerificationTypeFactory.createUninitializedThisType();
+                        }
+                        // Is the reference type newly created and still
+                        // uninitialized?
+                        if (producerOffset > PartialEvaluator.AT_METHOD_ENTRY &&
+                            offset <= partialEvaluator.initializationOffset(producerOffset))
+                        {
+                            // It's an Uninitialized type.
+                            return VerificationTypeFactory.createUninitializedType(producerOffset);
+                        }
+                    }
+                }
+                // It's an ordinary Object type.
+                return VerificationTypeFactory.createObjectType(createClassConstant(programClass, referenceValue));
+        }
+        throw new IllegalArgumentException("Unknown computational type ["+type+"]");
+    }
+    /**
+     * Finds or creates a class constant for the given reference value, and
+     * returns its index in the constant pool.
+     */
+    private int createClassConstant(ProgramClass   programClass,
+                                    ReferenceValue referenceValue)
+    {
+        return new ConstantPoolEditor(programClass).addClassConstant(referenceValue.getType(),
+                                                                     referenceValue.getReferencedClass());
+    }
+    /**
+     * Compresses the given list of full frames, for use in a stack map table.
+     */
+    private void compressStackMapFrames(VerificationType[] initialVariableTypes,
+                                        List               stackMapFrameList)
+    {
+        int                previousVariablesCount = initialVariableTypes.length;
+        VerificationType[] previousVariableTypes  = initialVariableTypes;
+        int previousOffset = -1;
+        for (int index = 0; index < stackMapFrameList.size(); index++)
+        {
+            FullFrame fullFrame = (FullFrame)stackMapFrameList.get(index);
+            int                variablesCount = fullFrame.variablesCount;
+            VerificationType[] variables      = fullFrame.variables;
+            int                stackCount     = fullFrame.stackCount;
+            VerificationType[] stack          = fullFrame.stack;
+            // Start computing the compressed frame.
+            // The default is the full frame.
+            StackMapFrame compressedFrame = fullFrame;
+            // Are all variables equal?
+            if (variablesCount == previousVariablesCount &&
+                equalVerificationTypes(variables, previousVariableTypes, variablesCount))
+            {
+                // Are the stacks equal?
+                //if (stackCount == previousStackCount &&
+                //    equalVerificationTypes(stack, previousStack, stackCount))
+                //{
+                //    // Remove the identical frame.
+                //    stackMapFrameList.remove(index--);
+                //
+                //    // Move on to the next frame (at the same index).
+                //    continue;
+                //}
+                // Is the new stack empty?
+                //else
+                if (stackCount == 0)
+                {
+                    compressedFrame = new SameZeroFrame();
+                }
+                // Does the new stack contain a single element?
+                else if (stackCount == 1)
+                {
+                    compressedFrame = new SameOneFrame(stack[0]);
+                }
+            }
+            // Is the stack empty?
+            else if (stackCount == 0)
+            {
+                int additionalVariablesCount = variablesCount - previousVariablesCount;
+                // Are the variables chopped?
+                if (additionalVariablesCount < 0  &&
+                    additionalVariablesCount > -4 &&
+                    equalVerificationTypes(variables, previousVariableTypes, variablesCount))
+                {
+                    compressedFrame = new LessZeroFrame((byte)-additionalVariablesCount);
+                }
+                // Are the variables extended?
+                else if (//previousVariablesCount   > 0 &&
+                         additionalVariablesCount > 0 &&
+                         additionalVariablesCount < 4 &&
+                         equalVerificationTypes(variables, previousVariableTypes, previousVariablesCount))
+                {
+                    // Copy the additional variables into an array.
+                    VerificationType[] additionalVariables = new VerificationType[additionalVariablesCount];
+                    System.arraycopy(variables, variablesCount - additionalVariablesCount,
+                                     additionalVariables, 0,
+                                     additionalVariablesCount);
+                    compressedFrame = new MoreZeroFrame(additionalVariables);
+                }
+            }
+            // Compress the instruction offset.
+            int offset = fullFrame.u2offsetDelta;
+            compressedFrame.u2offsetDelta = offset - previousOffset - 1;
+            previousOffset = offset;
+            // Remember this frame.
+            previousVariablesCount = fullFrame.variablesCount;
+            previousVariableTypes     = fullFrame.variables;
+            // Replace the full frame.
+            stackMapFrameList.set(index, compressedFrame);
+        }
+    }
+    /**
+     * Returns whether the given arrays of verification types are equal, up to
+     * the given length.
+     */
+    private boolean equalVerificationTypes(VerificationType[] types1,
+                                           VerificationType[] types2,
+                                           int                length)
+    {
+        if (length > 0 &&
+            (types1.length < length ||
+             types2.length < length))
+        {
+            return false;
+        }
+        for (int index = 0; index < length; index++)
+        {
+            if (!types1[index].equals(types2[index]))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Returns whether the given instruction opcode represents a dup or swap
+     * instruction (dup, dup_x1, dup_x2, dup2, dup2_x1, dup2_x2, swap).
+     */
+    private boolean isDupOrSwap(int opcode)
+    {
+        return opcode >= InstructionConstants.OP_DUP &&
+               opcode <= InstructionConstants.OP_SWAP;
+    }
+}