bb-tools/proguard4.7/src/proguard/optimize/evaluation/EvaluationSimplifier.java
/*
* 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.evaluation;
import proguard.classfile.*;
import proguard.classfile.attribute.*;
import proguard.classfile.attribute.visitor.AttributeVisitor;
import proguard.classfile.editor.*;
import proguard.classfile.instruction.*;
import proguard.classfile.instruction.visitor.InstructionVisitor;
import proguard.classfile.util.*;
import proguard.classfile.visitor.*;
import proguard.evaluation.*;
import proguard.evaluation.value.*;
import proguard.optimize.info.*;
/**
* This AttributeVisitor simplifies the code attributes that it visits, based
* on partial evaluation.
*
* @author Eric Lafortune
*/
public class EvaluationSimplifier
extends SimplifiedVisitor
implements AttributeVisitor,
InstructionVisitor
{
private static int POS_ZERO_FLOAT_BITS = Float.floatToIntBits(0.0f);
private static long POS_ZERO_DOUBLE_BITS = Double.doubleToLongBits(0.0);
//*
private static final boolean DEBUG = false;
/*/
private static boolean DEBUG = true;
//*/
private final InstructionVisitor extraInstructionVisitor;
private final PartialEvaluator partialEvaluator;
private final SideEffectInstructionChecker sideEffectInstructionChecker = new SideEffectInstructionChecker(true);
private final CodeAttributeEditor codeAttributeEditor = new CodeAttributeEditor(false);
/**
* Creates a new EvaluationSimplifier.
*/
public EvaluationSimplifier()
{
this(new PartialEvaluator(), null);
}
/**
* Creates a new EvaluationSimplifier.
* @param partialEvaluator the partial evaluator that will
* execute the code and provide
* information about the results.
* @param extraInstructionVisitor an optional extra visitor for all
* simplified instructions.
*/
public EvaluationSimplifier(PartialEvaluator partialEvaluator,
InstructionVisitor extraInstructionVisitor)
{
this.partialEvaluator = partialEvaluator;
this.extraInstructionVisitor = extraInstructionVisitor;
}
// Implementations for AttributeVisitor.
public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
{
// DEBUG =
// clazz.getName().equals("abc/Def") &&
// method.getName(clazz).equals("abc");
// TODO: Remove this when the evaluation simplifier 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 simplifying instructions after partial evaluation:");
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()+")");
System.err.println("Not optimizing this method");
if (DEBUG)
{
method.accept(clazz, new ClassPrinter());
throw ex;
}
}
}
public void visitCodeAttribute0(Clazz clazz, Method method, CodeAttribute codeAttribute)
{
if (DEBUG)
{
System.out.println();
System.out.println("Class "+ClassUtil.externalClassName(clazz.getName()));
System.out.println("Method "+ClassUtil.externalFullMethodDescription(clazz.getName(),
0,
method.getName(clazz),
method.getDescriptor(clazz)));
}
// Evaluate the method.
partialEvaluator.visitCodeAttribute(clazz, method, codeAttribute);
int codeLength = codeAttribute.u4codeLength;
// Reset the code changes.
codeAttributeEditor.reset(codeLength);
// Replace any instructions that can be simplified.
for (int offset = 0; offset < codeLength; offset++)
{
if (partialEvaluator.isTraced(offset))
{
Instruction instruction = InstructionFactory.create(codeAttribute.code,
offset);
instruction.accept(clazz, method, codeAttribute, offset, this);
}
}
// Apply all accumulated changes to the code.
codeAttributeEditor.visitCodeAttribute(clazz, method, codeAttribute);
}
// Implementations for InstructionVisitor.
public void visitSimpleInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SimpleInstruction simpleInstruction)
{
switch (simpleInstruction.opcode)
{
case InstructionConstants.OP_IALOAD:
case InstructionConstants.OP_BALOAD:
case InstructionConstants.OP_CALOAD:
case InstructionConstants.OP_SALOAD:
case InstructionConstants.OP_IADD:
case InstructionConstants.OP_ISUB:
case InstructionConstants.OP_IMUL:
case InstructionConstants.OP_IDIV:
case InstructionConstants.OP_IREM:
case InstructionConstants.OP_INEG:
case InstructionConstants.OP_ISHL:
case InstructionConstants.OP_ISHR:
case InstructionConstants.OP_IUSHR:
case InstructionConstants.OP_IAND:
case InstructionConstants.OP_IOR:
case InstructionConstants.OP_IXOR:
case InstructionConstants.OP_L2I:
case InstructionConstants.OP_F2I:
case InstructionConstants.OP_D2I:
case InstructionConstants.OP_I2B:
case InstructionConstants.OP_I2C:
case InstructionConstants.OP_I2S:
replaceIntegerPushInstruction(clazz, offset, simpleInstruction);
break;
case InstructionConstants.OP_LALOAD:
case InstructionConstants.OP_LADD:
case InstructionConstants.OP_LSUB:
case InstructionConstants.OP_LMUL:
case InstructionConstants.OP_LDIV:
case InstructionConstants.OP_LREM:
case InstructionConstants.OP_LNEG:
case InstructionConstants.OP_LSHL:
case InstructionConstants.OP_LSHR:
case InstructionConstants.OP_LUSHR:
case InstructionConstants.OP_LAND:
case InstructionConstants.OP_LOR:
case InstructionConstants.OP_LXOR:
case InstructionConstants.OP_I2L:
case InstructionConstants.OP_F2L:
case InstructionConstants.OP_D2L:
replaceLongPushInstruction(clazz, offset, simpleInstruction);
break;
case InstructionConstants.OP_FALOAD:
case InstructionConstants.OP_FADD:
case InstructionConstants.OP_FSUB:
case InstructionConstants.OP_FMUL:
case InstructionConstants.OP_FDIV:
case InstructionConstants.OP_FREM:
case InstructionConstants.OP_FNEG:
case InstructionConstants.OP_I2F:
case InstructionConstants.OP_L2F:
case InstructionConstants.OP_D2F:
replaceFloatPushInstruction(clazz, offset, simpleInstruction);
break;
case InstructionConstants.OP_DALOAD:
case InstructionConstants.OP_DADD:
case InstructionConstants.OP_DSUB:
case InstructionConstants.OP_DMUL:
case InstructionConstants.OP_DDIV:
case InstructionConstants.OP_DREM:
case InstructionConstants.OP_DNEG:
case InstructionConstants.OP_I2D:
case InstructionConstants.OP_L2D:
case InstructionConstants.OP_F2D:
replaceDoublePushInstruction(clazz, offset, simpleInstruction);
break;
case InstructionConstants.OP_AALOAD:
replaceReferencePushInstruction(clazz, offset, simpleInstruction);
break;
}
}
public void visitVariableInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VariableInstruction variableInstruction)
{
int variableIndex = variableInstruction.variableIndex;
switch (variableInstruction.opcode)
{
case InstructionConstants.OP_ILOAD:
case InstructionConstants.OP_ILOAD_0:
case InstructionConstants.OP_ILOAD_1:
case InstructionConstants.OP_ILOAD_2:
case InstructionConstants.OP_ILOAD_3:
replaceIntegerPushInstruction(clazz, offset, variableInstruction, variableIndex);
break;
case InstructionConstants.OP_LLOAD:
case InstructionConstants.OP_LLOAD_0:
case InstructionConstants.OP_LLOAD_1:
case InstructionConstants.OP_LLOAD_2:
case InstructionConstants.OP_LLOAD_3:
replaceLongPushInstruction(clazz, offset, variableInstruction, variableIndex);
break;
case InstructionConstants.OP_FLOAD:
case InstructionConstants.OP_FLOAD_0:
case InstructionConstants.OP_FLOAD_1:
case InstructionConstants.OP_FLOAD_2:
case InstructionConstants.OP_FLOAD_3:
replaceFloatPushInstruction(clazz, offset, variableInstruction, variableIndex);
break;
case InstructionConstants.OP_DLOAD:
case InstructionConstants.OP_DLOAD_0:
case InstructionConstants.OP_DLOAD_1:
case InstructionConstants.OP_DLOAD_2:
case InstructionConstants.OP_DLOAD_3:
replaceDoublePushInstruction(clazz, offset, variableInstruction, variableIndex);
break;
case InstructionConstants.OP_ALOAD:
case InstructionConstants.OP_ALOAD_0:
case InstructionConstants.OP_ALOAD_1:
case InstructionConstants.OP_ALOAD_2:
case InstructionConstants.OP_ALOAD_3:
replaceReferencePushInstruction(clazz, offset, variableInstruction);
break;
case InstructionConstants.OP_ASTORE:
case InstructionConstants.OP_ASTORE_0:
case InstructionConstants.OP_ASTORE_1:
case InstructionConstants.OP_ASTORE_2:
case InstructionConstants.OP_ASTORE_3:
deleteReferencePopInstruction(clazz, offset, variableInstruction);
break;
case InstructionConstants.OP_RET:
replaceBranchInstruction(clazz, offset, variableInstruction);
break;
}
}
public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
{
switch (constantInstruction.opcode)
{
case InstructionConstants.OP_GETSTATIC:
case InstructionConstants.OP_GETFIELD:
replaceAnyPushInstruction(clazz, offset, constantInstruction);
break;
case InstructionConstants.OP_INVOKEVIRTUAL:
case InstructionConstants.OP_INVOKESPECIAL:
case InstructionConstants.OP_INVOKESTATIC:
case InstructionConstants.OP_INVOKEINTERFACE:
if (constantInstruction.stackPushCount(clazz) > 0 &&
!sideEffectInstructionChecker.hasSideEffects(clazz,
method,
codeAttribute,
offset,
constantInstruction))
{
replaceAnyPushInstruction(clazz, offset, constantInstruction);
}
break;
case InstructionConstants.OP_CHECKCAST:
replaceReferencePushInstruction(clazz, offset, constantInstruction);
break;
}
}
public void visitBranchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, BranchInstruction branchInstruction)
{
switch (branchInstruction.opcode)
{
case InstructionConstants.OP_GOTO:
case InstructionConstants.OP_GOTO_W:
// Don't replace unconditional branches.
break;
case InstructionConstants.OP_JSR:
case InstructionConstants.OP_JSR_W:
replaceJsrInstruction(clazz, offset, branchInstruction);
break;
default:
replaceBranchInstruction(clazz, offset, branchInstruction);
break;
}
}
public void visitAnySwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SwitchInstruction switchInstruction)
{
// First try to simplify it to a simple branch.
replaceBranchInstruction(clazz, offset, switchInstruction);
// Otherwise make sure all branch targets are valid.
if (!codeAttributeEditor.isModified(offset))
{
replaceSwitchInstruction(clazz, offset, switchInstruction);
}
}
// Small utility methods.
/**
* Replaces the push instruction at the given offset by a simpler push
* instruction, if possible.
*/
private void replaceAnyPushInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
Value pushedValue = partialEvaluator.getStackAfter(offset).getTop(0);
if (pushedValue.isParticular())
{
switch (pushedValue.computationalType())
{
case Value.TYPE_INTEGER:
replaceIntegerPushInstruction(clazz, offset, instruction);
break;
case Value.TYPE_LONG:
replaceLongPushInstruction(clazz, offset, instruction);
break;
case Value.TYPE_FLOAT:
replaceFloatPushInstruction(clazz, offset, instruction);
break;
case Value.TYPE_DOUBLE:
replaceDoublePushInstruction(clazz, offset, instruction);
break;
case Value.TYPE_REFERENCE:
replaceReferencePushInstruction(clazz, offset, instruction);
break;
}
}
}
/**
* Replaces the integer pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceIntegerPushInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
replaceIntegerPushInstruction(clazz,
offset,
instruction,
partialEvaluator.getVariablesBefore(offset).size());
}
/**
* Replaces the integer pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceIntegerPushInstruction(Clazz clazz,
int offset,
Instruction instruction,
int maxVariableIndex)
{
Value pushedValue = partialEvaluator.getStackAfter(offset).getTop(0);
if (pushedValue.isParticular())
{
int value = pushedValue.integerValue().value();
if (value << 16 >> 16 == value)
{
replaceConstantPushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_SIPUSH,
value);
}
else
{
ConstantPoolEditor constantPoolEditor =
new ConstantPoolEditor((ProgramClass)clazz);
Instruction replacementInstruction =
new ConstantInstruction(InstructionConstants.OP_LDC,
constantPoolEditor.addIntegerConstant(value)).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
}
else if (pushedValue.isSpecific())
{
TracedVariables variables = partialEvaluator.getVariablesBefore(offset);
for (int variableIndex = 0; variableIndex < maxVariableIndex; variableIndex++)
{
if (pushedValue.equals(variables.load(variableIndex)))
{
replaceVariablePushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_ILOAD,
variableIndex);
}
}
}
}
/**
* Replaces the long pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceLongPushInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
replaceLongPushInstruction(clazz,
offset,
instruction,
partialEvaluator.getVariablesBefore(offset).size());
}
/**
* Replaces the long pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceLongPushInstruction(Clazz clazz,
int offset,
Instruction instruction,
int maxVariableIndex)
{
Value pushedValue = partialEvaluator.getStackAfter(offset).getTop(0);
if (pushedValue.isParticular())
{
long value = pushedValue.longValue().value();
if (value == 0L ||
value == 1L)
{
replaceConstantPushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_LCONST_0,
(int)value);
}
else
{
ConstantPoolEditor constantPoolEditor =
new ConstantPoolEditor((ProgramClass)clazz);
Instruction replacementInstruction =
new ConstantInstruction(InstructionConstants.OP_LDC2_W,
constantPoolEditor.addLongConstant(value)).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
}
else if (pushedValue.isSpecific())
{
TracedVariables variables = partialEvaluator.getVariablesBefore(offset);
for (int variableIndex = 0; variableIndex < maxVariableIndex; variableIndex++)
{
if (pushedValue.equals(variables.load(variableIndex)))
{
replaceVariablePushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_LLOAD,
variableIndex);
}
}
}
}
/**
* Replaces the float pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceFloatPushInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
replaceFloatPushInstruction(clazz,
offset,
instruction,
partialEvaluator.getVariablesBefore(offset).size());
}
/**
* Replaces the float pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceFloatPushInstruction(Clazz clazz,
int offset,
Instruction instruction,
int maxVariableIndex)
{
Value pushedValue = partialEvaluator.getStackAfter(offset).getTop(0);
if (pushedValue.isParticular())
{
// Make sure to distinguish between +0.0 and -0.0.
float value = pushedValue.floatValue().value();
if (value == 0.0f && Float.floatToIntBits(value) == POS_ZERO_FLOAT_BITS ||
value == 1.0f ||
value == 2.0f)
{
replaceConstantPushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_FCONST_0,
(int)value);
}
else
{
ConstantPoolEditor constantPoolEditor =
new ConstantPoolEditor((ProgramClass)clazz);
Instruction replacementInstruction =
new ConstantInstruction(InstructionConstants.OP_LDC,
constantPoolEditor.addFloatConstant(value)).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
}
else if (pushedValue.isSpecific())
{
TracedVariables variables = partialEvaluator.getVariablesBefore(offset);
for (int variableIndex = 0; variableIndex < maxVariableIndex; variableIndex++)
{
if (pushedValue.equals(variables.load(variableIndex)))
{
replaceVariablePushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_FLOAD,
variableIndex);
}
}
}
}
/**
* Replaces the double pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceDoublePushInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
replaceDoublePushInstruction(clazz,
offset,
instruction,
partialEvaluator.getVariablesBefore(offset).size());
}
/**
* Replaces the double pushing instruction at the given offset by a simpler
* push instruction, if possible.
*/
private void replaceDoublePushInstruction(Clazz clazz,
int offset,
Instruction instruction,
int maxVariableIndex)
{
Value pushedValue = partialEvaluator.getStackAfter(offset).getTop(0);
if (pushedValue.isParticular())
{
// Make sure to distinguish between +0.0 and -0.0.
double value = pushedValue.doubleValue().value();
if (value == 0.0 && Double.doubleToLongBits(value) == POS_ZERO_DOUBLE_BITS ||
value == 1.0)
{
replaceConstantPushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_DCONST_0,
(int)value);
}
else
{
ConstantPoolEditor constantPoolEditor =
new ConstantPoolEditor((ProgramClass)clazz);
Instruction replacementInstruction =
new ConstantInstruction(InstructionConstants.OP_LDC2_W,
constantPoolEditor.addDoubleConstant(value)).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
}
else if (pushedValue.isSpecific())
{
TracedVariables variables = partialEvaluator.getVariablesBefore(offset);
for (int variableIndex = 0; variableIndex < maxVariableIndex; variableIndex++)
{
if (pushedValue.equals(variables.load(variableIndex)))
{
replaceVariablePushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_DLOAD,
variableIndex);
}
}
}
}
/**
* Replaces the reference pushing instruction at the given offset by a
* simpler push instruction, if possible.
*/
private void replaceReferencePushInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
Value pushedValue = partialEvaluator.getStackAfter(offset).getTop(0);
if (pushedValue.isParticular())
{
// A reference value can only be specific if it is null.
replaceConstantPushInstruction(clazz,
offset,
instruction,
InstructionConstants.OP_ACONST_NULL,
0);
}
}
/**
* Replaces the instruction at a given offset by a given push instruction
* of a constant.
*/
private void replaceConstantPushInstruction(Clazz clazz,
int offset,
Instruction instruction,
byte replacementOpcode,
int value)
{
Instruction replacementInstruction =
new SimpleInstruction(replacementOpcode, value).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
/**
* Replaces the instruction at a given offset by a given push instruction
* of a variable.
*/
private void replaceVariablePushInstruction(Clazz clazz,
int offset,
Instruction instruction,
byte replacementOpcode,
int variableIndex)
{
Instruction replacementInstruction =
new VariableInstruction(replacementOpcode, variableIndex).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
/**
* Replaces the given 'jsr' instruction by a simpler branch instruction,
* if it jumps to a subroutine that doesn't return or a subroutine that
* is only called from one place.
*/
private void replaceJsrInstruction(Clazz clazz,
int offset,
BranchInstruction branchInstruction)
{
// Is the subroutine ever returning?
int subroutineStart = offset + branchInstruction.branchOffset;
if (!partialEvaluator.isSubroutineReturning(subroutineStart) ||
partialEvaluator.branchOrigins(subroutineStart).instructionOffsetCount() == 1)
{
// All 'jsr' instructions to this subroutine can be replaced
// by unconditional branch instructions.
replaceBranchInstruction(clazz, offset, branchInstruction);
}
else if (!partialEvaluator.isTraced(offset + branchInstruction.length(offset)))
{
// We have to make sure the instruction after this 'jsr'
// instruction is valid, even if it is never reached.
replaceByInfiniteLoop(clazz, offset + branchInstruction.length(offset), branchInstruction);
}
}
/**
* Deletes the reference popping instruction at the given offset, if
* it is at the start of a subroutine that doesn't return or a subroutine
* that is only called from one place.
*/
private void deleteReferencePopInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
if (partialEvaluator.isSubroutineStart(offset) &&
(!partialEvaluator.isSubroutineReturning(offset) ||
partialEvaluator.branchOrigins(offset).instructionOffsetCount() == 1))
{
if (DEBUG) System.out.println(" Deleting store of subroutine return address "+instruction.toString(offset));
// A reference value can only be specific if it is null.
codeAttributeEditor.deleteInstruction(offset);
}
}
/**
* Deletes the given branch instruction, or replaces it by a simpler branch
* instruction, if possible.
*/
private void replaceBranchInstruction(Clazz clazz,
int offset,
Instruction instruction)
{
InstructionOffsetValue branchTargets = partialEvaluator.branchTargets(offset);
// Is there exactly one branch target (not from a goto or jsr)?
if (branchTargets != null &&
branchTargets.instructionOffsetCount() == 1)
{
// Is it branching to the next instruction?
int branchOffset = branchTargets.instructionOffset(0) - offset;
if (branchOffset == instruction.length(offset))
{
if (DEBUG) System.out.println(" Ignoring zero branch instruction at ["+offset+"]");
}
else
{
// Replace the branch instruction by a simple branch instruction.
Instruction replacementInstruction =
new BranchInstruction(InstructionConstants.OP_GOTO_W,
branchOffset).shrink();
replaceInstruction(clazz, offset, instruction, replacementInstruction);
}
}
}
/**
* Makes sure all branch targets of the given switch instruction are valid.
*/
private void replaceSwitchInstruction(Clazz clazz,
int offset,
SwitchInstruction switchInstruction)
{
// Get the actual branch targets.
InstructionOffsetValue branchTargets = partialEvaluator.branchTargets(offset);
// Get an offset that can serve as a valid default offset.
int defaultOffset =
branchTargets.instructionOffset(branchTargets.instructionOffsetCount()-1) -
offset;
Instruction replacementInstruction = null;
// Check the jump offsets.
int[] jumpOffsets = switchInstruction.jumpOffsets;
for (int index = 0; index < jumpOffsets.length; index++)
{
if (!branchTargets.contains(offset + jumpOffsets[index]))
{
// Replace the unused offset.
jumpOffsets[index] = defaultOffset;
// Remember to replace the instruction.
replacementInstruction = switchInstruction;
}
}
// Check the default offset.
if (!branchTargets.contains(offset + switchInstruction.defaultOffset))
{
// Replace the unused offset.
switchInstruction.defaultOffset = defaultOffset;
// Remember to replace the instruction.
replacementInstruction = switchInstruction;
}
if (replacementInstruction != null)
{
replaceInstruction(clazz, offset, switchInstruction, replacementInstruction);
}
}
/**
* Replaces the given instruction by an infinite loop.
*/
private void replaceByInfiniteLoop(Clazz clazz,
int offset,
Instruction instruction)
{
// Replace the instruction by an infinite loop.
Instruction replacementInstruction =
new BranchInstruction(InstructionConstants.OP_GOTO, 0);
if (DEBUG) System.out.println(" Replacing unreachable instruction by infinite loop "+replacementInstruction.toString(offset));
codeAttributeEditor.replaceInstruction(offset, replacementInstruction);
// Visit the instruction, if required.
if (extraInstructionVisitor != null)
{
// Note: we're not passing the right arguments for now, knowing that
// they aren't used anyway.
instruction.accept(clazz, null, null, offset, extraInstructionVisitor);
}
}
/**
* Replaces the instruction at a given offset by a given push instruction.
*/
private void replaceInstruction(Clazz clazz,
int offset,
Instruction instruction,
Instruction replacementInstruction)
{
// Pop unneeded stack entries if necessary.
int popCount =
instruction.stackPopCount(clazz) -
replacementInstruction.stackPopCount(clazz);
insertPopInstructions(offset, popCount);
if (DEBUG) System.out.println(" Replacing instruction "+instruction.toString(offset)+" -> "+replacementInstruction.toString()+(popCount == 0 ? "" : " ("+popCount+" pops)"));
codeAttributeEditor.replaceInstruction(offset, replacementInstruction);
// Visit the instruction, if required.
if (extraInstructionVisitor != null)
{
// Note: we're not passing the right arguments for now, knowing that
// they aren't used anyway.
instruction.accept(clazz, null, null, offset, extraInstructionVisitor);
}
}
/**
* Pops the given number of stack entries before the instruction at the
* given offset.
*/
private void insertPopInstructions(int offset, int popCount)
{
switch (popCount)
{
case 0:
{
break;
}
case 1:
{
// Insert a single pop instruction.
Instruction popInstruction =
new SimpleInstruction(InstructionConstants.OP_POP);
codeAttributeEditor.insertBeforeInstruction(offset,
popInstruction);
break;
}
case 2:
{
// Insert a single pop2 instruction.
Instruction popInstruction =
new SimpleInstruction(InstructionConstants.OP_POP2);
codeAttributeEditor.insertBeforeInstruction(offset,
popInstruction);
break;
}
default:
{
// Insert the specified number of pop instructions.
Instruction[] popInstructions =
new Instruction[popCount / 2 + popCount % 2];
Instruction popInstruction =
new SimpleInstruction(InstructionConstants.OP_POP2);
for (int index = 0; index < popCount / 2; index++)
{
popInstructions[index] = popInstruction;
}
if (popCount % 2 == 1)
{
popInstruction =
new SimpleInstruction(InstructionConstants.OP_POP);
popInstructions[popCount / 2] = popInstruction;
}
codeAttributeEditor.insertBeforeInstruction(offset,
popInstructions);
break;
}
}
}
}