diff options
Diffstat (limited to 'src/proguard/optimize/peephole/InstructionSequenceReplacer.java')
| -rw-r--r-- | src/proguard/optimize/peephole/InstructionSequenceReplacer.java | 278 |
1 files changed, 278 insertions, 0 deletions
diff --git a/src/proguard/optimize/peephole/InstructionSequenceReplacer.java b/src/proguard/optimize/peephole/InstructionSequenceReplacer.java new file mode 100644 index 0000000..bce06e2 --- /dev/null +++ b/src/proguard/optimize/peephole/InstructionSequenceReplacer.java @@ -0,0 +1,278 @@ +/* + * ProGuard -- shrinking, optimization, obfuscation, and preverification + * of Java bytecode. + * + * Copyright (c) 2002-2009 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.Constant; +import proguard.classfile.constant.visitor.ConstantVisitor; +import proguard.classfile.editor.CodeAttributeEditor; +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 +{ + private static final boolean DEBUG = false; + + + private final InstructionSequenceMatcher instructionSequenceMatcher; + 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.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(index).shrink().toString(matchedOffset)); + } + } + + // Replace the instruction sequence. + for (int index = 0; index < replacementInstructions.length; index++) + { + codeAttributeEditor.replaceInstruction(instructionSequenceMatcher.matchedInstructionOffset(index), + replacementInstructionFactory.create(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(int index) + { + // Create the instruction. + replacementInstructions[index].accept(null, + 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, + instructionSequenceMatcher.matchedArgument(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, + instructionSequenceMatcher.matchedConstantIndex(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)); + } + } +} |