sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/optimize/peephole/InstructionSequenceReplacer.java

@@ -0,0 +1,420 @@
+/*
+ * 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.peephole;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.editor.*;
+import proguard.classfile.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.*;
+
+/**
+ * This InstructionVisitor replaces a given pattern instruction sequence by
+ * another given replacement instruction sequence. The arguments of the
+ * instruction sequences can be wildcards that are matched and replaced.
+ *
+ * @see InstructionSequenceMatcher
+ * @author Eric Lafortune
+ */
+public class InstructionSequenceReplacer
+extends      SimplifiedVisitor
+implements   InstructionVisitor,
+             ConstantVisitor
+{
+    /*
+    public  static       boolean DEBUG = true;
+    /*/
+    private static final boolean DEBUG = false;
+    //*/
+
+    public static final int X = InstructionSequenceMatcher.X;
+    public static final int Y = InstructionSequenceMatcher.Y;
+    public static final int Z = InstructionSequenceMatcher.Z;
+
+    public static final int A = InstructionSequenceMatcher.A;
+    public static final int B = InstructionSequenceMatcher.B;
+    public static final int C = InstructionSequenceMatcher.C;
+    public static final int D = InstructionSequenceMatcher.D;
+
+    private static final int BOOLEAN_STRING = 0x1;
+    private static final int CHAR_STRING    = 0x2;
+    private static final int INT_STRING     = 0x3;
+    private static final int LONG_STRING    = 0x4;
+    private static final int FLOAT_STRING   = 0x5;
+    private static final int DOUBLE_STRING  = 0x6;
+    private static final int STRING_STRING  = 0x7;
+
+    public static final int STRING_A_LENGTH  = 0x20000000;
+    public static final int BOOLEAN_A_STRING = 0x20000001;
+    public static final int CHAR_A_STRING    = 0x20000002;
+    public static final int INT_A_STRING     = 0x20000003;
+    public static final int LONG_A_STRING    = 0x20000004;
+    public static final int FLOAT_A_STRING   = 0x20000005;
+    public static final int DOUBLE_A_STRING  = 0x20000006;
+    public static final int STRING_A_STRING  = 0x20000007;
+    public static final int BOOLEAN_B_STRING = 0x20000010;
+    public static final int CHAR_B_STRING    = 0x20000020;
+    public static final int INT_B_STRING     = 0x20000030;
+    public static final int LONG_B_STRING    = 0x20000040;
+    public static final int FLOAT_B_STRING   = 0x20000050;
+    public static final int DOUBLE_B_STRING  = 0x20000060;
+    public static final int STRING_B_STRING  = 0x20000070;
+
+
+    private final InstructionSequenceMatcher instructionSequenceMatcher;
+    private final Constant[]                 patternConstants;
+    private final Instruction[]              replacementInstructions;
+    private final BranchTargetFinder         branchTargetFinder;
+    private final CodeAttributeEditor        codeAttributeEditor;
+    private final InstructionVisitor         extraInstructionVisitor;
+
+    private final MyReplacementInstructionFactory replacementInstructionFactory = new MyReplacementInstructionFactory();
+
+
+    /**
+     * Creates a new InstructionSequenceReplacer.
+     * @param patternConstants        any constants referenced by the pattern
+     *                                instruction.
+     * @param patternInstructions     the pattern instruction sequence.
+     * @param replacementInstructions the replacement instruction sequence.
+     * @param branchTargetFinder      a branch target finder that has been
+     *                                initialized to indicate branch targets
+     *                                in the visited code.
+     * @param codeAttributeEditor     a code editor that can be used for
+     *                                accumulating changes to the code.
+     */
+    public InstructionSequenceReplacer(Constant[]          patternConstants,
+                                       Instruction[]       patternInstructions,
+                                       Instruction[]       replacementInstructions,
+                                       BranchTargetFinder  branchTargetFinder,
+                                       CodeAttributeEditor codeAttributeEditor)
+    {
+        this(patternConstants,
+             patternInstructions,
+             replacementInstructions,
+             branchTargetFinder,
+             codeAttributeEditor,
+             null);
+    }
+
+
+    /**
+     * Creates a new InstructionSequenceReplacer.
+     * @param patternConstants        any constants referenced by the pattern
+     *                                instruction.
+     * @param branchTargetFinder      a branch target finder that has been
+     *                                initialized to indicate branch targets
+     *                                in the visited code.
+     * @param codeAttributeEditor     a code editor that can be used for
+     *                                accumulating changes to the code.
+     * @param extraInstructionVisitor an optional extra visitor for all deleted
+     *                                load instructions.
+     */
+    public InstructionSequenceReplacer(Constant[]          patternConstants,
+                                       Instruction[]       patternInstructions,
+                                       Instruction[]       replacementInstructions,
+                                       BranchTargetFinder  branchTargetFinder,
+                                       CodeAttributeEditor codeAttributeEditor,
+                                       InstructionVisitor  extraInstructionVisitor)
+    {
+        this.instructionSequenceMatcher = new InstructionSequenceMatcher(patternConstants, patternInstructions);
+        this.patternConstants           = patternConstants;
+        this.replacementInstructions    = replacementInstructions;
+        this.branchTargetFinder         = branchTargetFinder;
+        this.codeAttributeEditor        = codeAttributeEditor;
+        this.extraInstructionVisitor    = extraInstructionVisitor;
+    }
+
+
+    // Implementations for InstructionVisitor.
+
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
+    {
+        // Reset the instruction sequence matcher if the instruction is a branch
+        // target or if it has already been modified.
+        if (branchTargetFinder.isTarget(offset) ||
+            codeAttributeEditor.isModified(offset))
+        {
+            instructionSequenceMatcher.reset();
+        }
+
+        // Try to match the instruction.
+        instruction.accept(clazz, method, codeAttribute, offset, instructionSequenceMatcher);
+
+        // Did the instruction sequence match and is it still unmodified?
+        if (instructionSequenceMatcher.isMatching() &&
+            matchedInstructionsUnmodified())
+        {
+            if (DEBUG)
+            {
+                System.out.println("InstructionSequenceReplacer: ["+clazz.getName()+"."+method.getName(clazz)+method.getDescriptor(clazz)+"]");
+                System.out.println("  Matched:");
+                for (int index = 0; index < instructionSequenceMatcher.instructionCount(); index++)
+                {
+                    int matchedOffset = instructionSequenceMatcher.matchedInstructionOffset(index);
+                    System.out.println("    "+InstructionFactory.create(codeAttribute.code, matchedOffset).toString(matchedOffset));
+                }
+                System.out.println("  Replacement:");
+                for (int index = 0; index < replacementInstructions.length; index++)
+                {
+                    int matchedOffset = instructionSequenceMatcher.matchedInstructionOffset(index);
+                    System.out.println("    "+replacementInstructionFactory.create(clazz, index).shrink().toString(matchedOffset));
+                }
+            }
+
+            // Replace the instruction sequence.
+            for (int index = 0; index < replacementInstructions.length; index++)
+            {
+                codeAttributeEditor.replaceInstruction(instructionSequenceMatcher.matchedInstructionOffset(index),
+                                                       replacementInstructionFactory.create(clazz, index).shrink());
+            }
+
+            // Delete any remaining instructions in the from sequence.
+            for (int index = replacementInstructions.length; index < instructionSequenceMatcher.instructionCount(); index++)
+            {
+                codeAttributeEditor.deleteInstruction(instructionSequenceMatcher.matchedInstructionOffset(index));
+            }
+
+            // Visit the instruction, if required.
+            if (extraInstructionVisitor != null)
+            {
+                instruction.accept(clazz,
+                                   method,
+                                   codeAttribute,
+                                   offset,
+                                   extraInstructionVisitor);
+            }
+        }
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Returns whether the matched pattern instructions haven't been modified
+     * before.
+     */
+    private boolean matchedInstructionsUnmodified()
+    {
+        for (int index = 0; index < instructionSequenceMatcher.instructionCount(); index++)
+        {
+            if (codeAttributeEditor.isModified(instructionSequenceMatcher.matchedInstructionOffset(index)))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * This class creates replacement instructions for matched sequences, with
+     * any matched arguments filled out.
+     */
+    private class MyReplacementInstructionFactory
+    implements    InstructionVisitor
+    {
+        private Instruction replacementInstruction;
+
+
+        /**
+         * Creates the replacement instruction for the given index in the
+         * instruction sequence.
+         */
+        public Instruction create(Clazz clazz, int index)
+        {
+            // Create the instruction.
+            replacementInstructions[index].accept(clazz,
+                                                  null,
+                                                  null,
+                                                  instructionSequenceMatcher.matchedInstructionOffset(index),
+                                                  this);
+
+            // Return it.
+            return replacementInstruction.shrink();
+        }
+
+
+        // Implementations for InstructionVisitor.
+
+        public void visitSimpleInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SimpleInstruction simpleInstruction)
+        {
+            replacementInstruction =
+                new SimpleInstruction(simpleInstruction.opcode,
+                                      matchedArgument(clazz, simpleInstruction.constant));
+        }
+
+
+        public void visitVariableInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VariableInstruction variableInstruction)
+        {
+            replacementInstruction =
+                new VariableInstruction(variableInstruction.opcode,
+                                        instructionSequenceMatcher.matchedArgument(variableInstruction.variableIndex),
+                                        instructionSequenceMatcher.matchedArgument(variableInstruction.constant));
+        }
+
+
+        public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
+        {
+            replacementInstruction =
+                new ConstantInstruction(constantInstruction.opcode,
+                                        matchedConstantIndex((ProgramClass)clazz,
+                                                             constantInstruction.constantIndex),
+                                        instructionSequenceMatcher.matchedArgument(constantInstruction.constant));
+        }
+
+
+        public void visitBranchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, BranchInstruction branchInstruction)
+        {
+            replacementInstruction =
+                new BranchInstruction(branchInstruction.opcode,
+                                      instructionSequenceMatcher.matchedBranchOffset(offset,
+                                                                                     branchInstruction.branchOffset));
+        }
+
+
+        public void visitTableSwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, TableSwitchInstruction tableSwitchInstruction)
+        {
+            replacementInstruction =
+                new TableSwitchInstruction(tableSwitchInstruction.opcode,
+                                           instructionSequenceMatcher.matchedBranchOffset(offset, tableSwitchInstruction.defaultOffset),
+                                           instructionSequenceMatcher.matchedArgument(tableSwitchInstruction.lowCase),
+                                           instructionSequenceMatcher.matchedArgument(tableSwitchInstruction.highCase),
+                                           instructionSequenceMatcher.matchedJumpOffsets(offset,
+                                                                                         tableSwitchInstruction.jumpOffsets));
+
+        }
+
+
+        public void visitLookUpSwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, LookUpSwitchInstruction lookUpSwitchInstruction)
+        {
+            replacementInstruction =
+                new LookUpSwitchInstruction(lookUpSwitchInstruction.opcode,
+                                            instructionSequenceMatcher.matchedBranchOffset(offset, lookUpSwitchInstruction.defaultOffset),
+                                            instructionSequenceMatcher.matchedArguments(lookUpSwitchInstruction.cases),
+                                            instructionSequenceMatcher.matchedJumpOffsets(offset, lookUpSwitchInstruction.jumpOffsets));
+        }
+
+
+        /**
+         * Returns the matched argument for the given pattern argument.
+         */
+        private int matchedArgument(Clazz clazz, int argument)
+        {
+            // Special case: do we have to compute the string length?
+            if (argument == STRING_A_LENGTH)
+            {
+                // Return the string length.
+                return clazz.getStringString(instructionSequenceMatcher.matchedArgument(A)).length();
+            }
+
+            // Otherwise, just return the matched argument.
+            return instructionSequenceMatcher.matchedArgument(argument);
+        }
+
+
+        /**
+         * Returns the matched or newly created constant index for the given
+         * pattern constant index.
+         */
+        private int matchedConstantIndex(ProgramClass programClass, int constantIndex)
+        {
+            // Special case: do we have to create a concatenated string?
+            if (constantIndex >= BOOLEAN_A_STRING &&
+                constantIndex <= (STRING_A_STRING  | STRING_B_STRING))
+            {
+                // Create a new string constant and return its index.
+                return new ConstantPoolEditor(programClass).addStringConstant(
+                    argumentAsString(programClass,  constantIndex        & 0xf, A) +
+                    argumentAsString(programClass, (constantIndex >>> 4) & 0xf, B),
+                    null,
+                    null);
+            }
+
+            int matchedConstantIndex =
+                instructionSequenceMatcher.matchedConstantIndex(constantIndex);
+
+            // Do we have a matched constant index?
+            if (matchedConstantIndex > 0)
+            {
+                // Return its index.
+                return matchedConstantIndex;
+            }
+
+            // Otherwise, we still have to create a new constant.
+            // This currently only works for constants without any wildcards.
+            ProgramClass dummyClass = new ProgramClass();
+            dummyClass.constantPool = patternConstants;
+
+            return new ConstantAdder(programClass).addConstant(dummyClass, constantIndex);
+        }
+
+
+        private String argumentAsString(ProgramClass programClass,
+                                        int          valueType,
+                                        int          argument)
+        {
+            switch (valueType)
+            {
+                case BOOLEAN_STRING:
+                    return Boolean.toString((instructionSequenceMatcher.wasConstant(argument) ?
+                        ((IntegerConstant)(programClass.getConstant(instructionSequenceMatcher.matchedConstantIndex(argument)))).getValue() :
+                        instructionSequenceMatcher.matchedArgument(argument)) != 0);
+
+                case CHAR_STRING:
+                    return Character.toString((char)(instructionSequenceMatcher.wasConstant(argument) ?
+                        ((IntegerConstant)(programClass.getConstant(instructionSequenceMatcher.matchedConstantIndex(argument)))).getValue() :
+                        instructionSequenceMatcher.matchedArgument(argument)));
+
+                case INT_STRING:
+                    return Integer.toString(instructionSequenceMatcher.wasConstant(argument) ?
+                        ((IntegerConstant)(programClass.getConstant(instructionSequenceMatcher.matchedConstantIndex(argument)))).getValue() :
+                        instructionSequenceMatcher.matchedArgument(argument));
+
+                case LONG_STRING:
+                    return Long.toString(instructionSequenceMatcher.wasConstant(argument) ?
+                        ((LongConstant)(programClass.getConstant(instructionSequenceMatcher.matchedConstantIndex(argument)))).getValue() :
+                        instructionSequenceMatcher.matchedArgument(argument));
+
+                case FLOAT_STRING:
+                    return Float.toString(instructionSequenceMatcher.wasConstant(argument) ?
+                        ((FloatConstant)(programClass.getConstant(instructionSequenceMatcher.matchedConstantIndex(argument)))).getValue() :
+                        instructionSequenceMatcher.matchedArgument(argument));
+
+                case DOUBLE_STRING:
+                    return Double.toString(instructionSequenceMatcher.wasConstant(argument) ?
+                        ((DoubleConstant)(programClass.getConstant(instructionSequenceMatcher.matchedConstantIndex(argument)))).getValue() :
+                        instructionSequenceMatcher.matchedArgument(argument));
+
+                case STRING_STRING:
+                    return
+                        programClass.getStringString(instructionSequenceMatcher.matchedConstantIndex(argument));
+
+                default:
+                    return "";
+            }
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/peephole/InstructionSequencesReplacer.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.peephole;
+
+import proguard.classfile.constant.Constant;
+import proguard.classfile.editor.CodeAttributeEditor;
+import proguard.classfile.instruction.Instruction;
+import proguard.classfile.instruction.visitor.*;
+
+/**
+ * This InstructionVisitor replaces multiple instruction sequences at once.
+ *
+ * @see InstructionSequenceReplacer
+ * @author Eric Lafortune
+ */
+public class InstructionSequencesReplacer
+extends      MultiInstructionVisitor
+implements   InstructionVisitor
+{
+    private static final int PATTERN_INDEX     = 0;
+    private static final int REPLACEMENT_INDEX = 1;
+
+
+    /**
+     * Creates a new InstructionSequencesReplacer.
+     * @param patternConstants        any constants referenced by the pattern
+     *                                instruction.
+     * @param instructionSequences    the instruction sequences to be replaced,
+     *                                with subsequently the sequence pair index,
+     *                                the patten/replacement index (0 or 1),
+     *                                and the instruction index in the sequence.
+     * @param branchTargetFinder      a branch target finder that has been
+     *                                initialized to indicate branch targets
+     *                                in the visited code.
+     * @param codeAttributeEditor     a code editor that can be used for
+     *                                accumulating changes to the code.
+     */
+    public InstructionSequencesReplacer(Constant[]          patternConstants,
+                                        Instruction[][][]   instructionSequences,
+                                        BranchTargetFinder  branchTargetFinder,
+                                        CodeAttributeEditor codeAttributeEditor)
+    {
+        this(patternConstants,
+             instructionSequences,
+             branchTargetFinder,
+             codeAttributeEditor,
+             null);
+    }
+
+
+    /**
+     * Creates a new InstructionSequenceReplacer.
+     * @param patternConstants        any constants referenced by the pattern
+     *                                instruction.
+     * @param instructionSequences    the instruction sequences to be replaced,
+     *                                with subsequently the sequence pair index,
+     *                                the patten/replacement index (0 or 1),
+     *                                and the instruction index in the sequence.
+     * @param branchTargetFinder      a branch target finder that has been
+     *                                initialized to indicate branch targets
+     *                                in the visited code.
+     * @param codeAttributeEditor     a code editor that can be used for
+     *                                accumulating changes to the code.
+     * @param extraInstructionVisitor an optional extra visitor for all deleted
+     *                                load instructions.
+     */
+    public InstructionSequencesReplacer(Constant[]          patternConstants,
+                                        Instruction[][][]   instructionSequences,
+                                        BranchTargetFinder  branchTargetFinder,
+                                        CodeAttributeEditor codeAttributeEditor,
+                                        InstructionVisitor  extraInstructionVisitor)
+    {
+        super(createInstructionSequenceReplacers(patternConstants,
+                                                 instructionSequences,
+                                                 branchTargetFinder,
+                                                 codeAttributeEditor,
+                                                 extraInstructionVisitor));
+    }
+
+
+    /**
+     * Creates an array of InstructionSequenceReplacer instances.
+     * @param patternConstants        any constants referenced by the pattern
+     *                                instruction.
+     * @param instructionSequences    the instruction sequences to be replaced,
+     *                                with subsequently the sequence pair index,
+     *                                the from/to index (0 or 1), and the
+     *                                instruction index in the sequence.
+     * @param branchTargetFinder      a branch target finder that has been
+     *                                initialized to indicate branch targets
+     *                                in the visited code.
+     * @param codeAttributeEditor     a code editor that can be used for
+     *                                accumulating changes to the code.
+     * @param extraInstructionVisitor an optional extra visitor for all deleted
+     *                                load instructions.
+     */
+    private static InstructionVisitor[] createInstructionSequenceReplacers(Constant[]          patternConstants,
+                                                                           Instruction[][][]   instructionSequences,
+                                                                           BranchTargetFinder  branchTargetFinder,
+                                                                           CodeAttributeEditor codeAttributeEditor,
+                                                                           InstructionVisitor  extraInstructionVisitor)
+    {
+        InstructionVisitor[] instructionSequenceReplacers =
+            new InstructionSequenceReplacer[instructionSequences.length];
+
+        for (int index = 0; index < instructionSequenceReplacers.length; index++)
+        {
+            Instruction[][] instructionSequencePair = instructionSequences[index];
+            instructionSequenceReplacers[index] =
+                new InstructionSequenceReplacer(patternConstants,
+                                                instructionSequencePair[PATTERN_INDEX],
+                                                instructionSequencePair[REPLACEMENT_INDEX],
+                                                branchTargetFinder,
+                                                codeAttributeEditor,
+                                                extraInstructionVisitor);
+        }
+
+        return instructionSequenceReplacers;
+    }
+}