sometsome 3.10.49 → 3.10.50.36

data/lib/proguard4.7/src/proguard/optimize/evaluation/EvaluationSimplifier.java

@@ -1,973 +0,0 @@
-/*
- * 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;
-            }
-        }
-    }
-}