sometsome 3.10.48 → 3.10.50.35

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

@@ -1,195 +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.constant.RefConstant;
-import proguard.evaluation.BasicInvocationUnit;
-import proguard.evaluation.value.*;
-
-/**
- * This InvocationUbit loads parameter values and return values that were
- * previously stored with the methods that are invoked.
- *
- * @see StoringInvocationUnit
- * @author Eric Lafortune
- */
-public class LoadingInvocationUnit
-extends      BasicInvocationUnit
-{
-    private final boolean loadFieldValues;
-    private final boolean loadMethodParameterValues;
-    private final boolean loadMethodReturnValues;
-
-
-    /**
-     * Creates a new LoadingInvocationUnit with the given value factory.
-     */
-    public LoadingInvocationUnit(ValueFactory valueFactory)
-    {
-        this(valueFactory, false, false, false);
-    }
-
-
-    /**
-     * Creates a new LoadingInvocationUnit with the given value factory, for
-     * loading the specified values.
-     */
-    public LoadingInvocationUnit(ValueFactory valueFactory,
-                                 boolean      loadFieldValues,
-                                 boolean      loadMethodParameterValues,
-                                 boolean      loadMethodReturnValues)
-    {
-        super(valueFactory);
-
-        this.loadFieldValues           = loadFieldValues;
-        this.loadMethodParameterValues = loadMethodParameterValues;
-        this.loadMethodReturnValues    = loadMethodReturnValues;
-    }
-
-
-    // Implementations for BasicInvocationUnit.
-
-    protected Value getFieldClassValue(Clazz       clazz,
-                                       RefConstant refConstant,
-                                       String      type)
-    {
-        if (loadFieldValues)
-        {
-            // Do we know this field?
-            Member referencedMember = refConstant.referencedMember;
-            if (referencedMember != null)
-            {
-                // Retrieve the stored field class value.
-                ReferenceValue value = StoringInvocationUnit.getFieldClassValue((Field)referencedMember);
-                if (value != null &&
-                    value.isParticular())
-                {
-                    return value;
-                }
-            }
-        }
-
-        return super.getFieldClassValue(clazz, refConstant, type);
-    }
-
-
-    protected Value getFieldValue(Clazz       clazz,
-                                  RefConstant refConstant,
-                                  String      type)
-    {
-        if (loadFieldValues)
-        {
-            // Do we know this field?
-            Member referencedMember = refConstant.referencedMember;
-            if (referencedMember != null)
-            {
-                // Retrieve the stored field value.
-                Value value = StoringInvocationUnit.getFieldValue((Field)referencedMember);
-                if (value != null &&
-                    value.isParticular())
-                {
-                    return value;
-                }
-            }
-        }
-
-        return super.getFieldValue(clazz, refConstant, type);
-    }
-
-
-    protected Value getMethodParameterValue(Clazz  clazz,
-                                            Method method,
-                                            int    parameterIndex,
-                                            String type,
-                                            Clazz  referencedClass)
-    {
-        if (loadMethodParameterValues)
-        {
-            // Retrieve the stored method parameter value.
-            Value value = StoringInvocationUnit.getMethodParameterValue(method, parameterIndex);
-            if (value != null &&
-                value.isParticular())
-            {
-                return value;
-            }
-        }
-
-        return super.getMethodParameterValue(clazz,
-                                             method,
-                                             parameterIndex,
-                                             type,
-                                             referencedClass);
-    }
-
-
-    protected Value getMethodReturnValue(Clazz       clazz,
-                                         RefConstant refConstant,
-                                         String      type)
-    {
-        if (loadMethodReturnValues)
-        {
-            // Do we know this method?
-            Member referencedMember = refConstant.referencedMember;
-            if (referencedMember != null)
-            {
-                // Retrieve the stored method return value.
-                Value value = StoringInvocationUnit.getMethodReturnValue((Method)referencedMember);
-                if (value != null &&
-                    value.isParticular())
-                {
-                    return value;
-                }
-            }
-        }
-
-        return super.getMethodReturnValue(clazz,
-                                          refConstant,
-                                          type);
-    }
-
-
-//    // Small utility methods.
-//
-//    private Value refresh(Value value)
-//    {
-//        if (value.isParticular())
-//        {
-//            return value;
-//        }
-//
-//        switch (value.computationalType())
-//        {
-//            case Value.TYPE_INTEGER: return valueFactory.createIntegerValue();
-//            case Value.TYPE_LONG:    return valueFactory.createLongValue();
-//            case Value.TYPE_FLOAT:   return valueFactory.createFloatValue();
-//            case Value.TYPE_DOUBLE:  return valueFactory.createDoubleValue();
-//            default:
-//            {
-//                ReferenceValue referenceValue = value.referenceValue();
-//
-//                return valueFactory.createReferenceValue(referenceValue.getType(),
-//                                                         referenceValue.getReferencedClass(),
-//                                                         referenceValue.isNull() != Value.NEVER);
-//            }
-//        }
-//    }
-}

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

@@ -1,1282 +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.*;
-import proguard.classfile.constant.ClassConstant;
-import proguard.classfile.instruction.*;
-import proguard.classfile.util.*;
-import proguard.classfile.visitor.*;
-import proguard.evaluation.*;
-import proguard.evaluation.value.*;
-import proguard.optimize.peephole.BranchTargetFinder;
-
-import java.util.Arrays;
-
-/**
- * This AttributeVisitor performs partial evaluation on the code attributes
- * that it visits.
- *
- * @author Eric Lafortune
- */
-public class PartialEvaluator
-extends      SimplifiedVisitor
-implements   AttributeVisitor,
-             ExceptionInfoVisitor
-{
-    //*
-    private static final boolean DEBUG         = false;
-    private static final boolean DEBUG_RESULTS = false;
-    /*/
-    private static boolean DEBUG         = true;
-    private static boolean DEBUG_RESULTS = true;
-    //*/
-
-    private static final int MAXIMUM_EVALUATION_COUNT = 5;
-
-    public static final int NONE            = -2;
-    public static final int AT_METHOD_ENTRY = -1;
-    public static final int AT_CATCH_ENTRY  = -1;
-
-    private final ValueFactory   valueFactory;
-    private final InvocationUnit invocationUnit;
-    private final boolean        evaluateAllCode;
-
-    private InstructionOffsetValue[] branchOriginValues   = new InstructionOffsetValue[ClassConstants.TYPICAL_CODE_LENGTH];
-    private InstructionOffsetValue[] branchTargetValues   = new InstructionOffsetValue[ClassConstants.TYPICAL_CODE_LENGTH];
-    private TracedVariables[]        variablesBefore      = new TracedVariables[ClassConstants.TYPICAL_CODE_LENGTH];
-    private TracedStack[]            stacksBefore         = new TracedStack[ClassConstants.TYPICAL_CODE_LENGTH];
-    private TracedVariables[]        variablesAfter       = new TracedVariables[ClassConstants.TYPICAL_CODE_LENGTH];
-    private TracedStack[]            stacksAfter          = new TracedStack[ClassConstants.TYPICAL_CODE_LENGTH];
-    private boolean[]                generalizedContexts  = new boolean[ClassConstants.TYPICAL_CODE_LENGTH];
-    private int[]                    evaluationCounts     = new int[ClassConstants.TYPICAL_CODE_LENGTH];
-    private boolean                  evaluateExceptions;
-
-    private final BasicBranchUnit    branchUnit;
-    private final BranchTargetFinder branchTargetFinder;
-
-    private final java.util.Stack callingInstructionBlockStack;
-    private final java.util.Stack instructionBlockStack = new java.util.Stack();
-
-
-    /**
-     * Creates a simple PartialEvaluator.
-     */
-    public PartialEvaluator()
-    {
-        this(new ValueFactory(),
-             new BasicInvocationUnit(new ValueFactory()),
-             true);
-    }
-
-
-    /**
-     * Creates a new PartialEvaluator.
-     * @param valueFactory    the value factory that will create all values
-     *                        during evaluation.
-     * @param invocationUnit  the invocation unit that will handle all
-     *                        communication with other fields and methods.
-     * @param evaluateAllCode a flag that specifies whether all branch targets
-     *                        and exception handlers should be evaluated,
-     *                        even if they are unreachable.
-     */
-    public PartialEvaluator(ValueFactory   valueFactory,
-                            InvocationUnit invocationUnit,
-                            boolean        evaluateAllCode)
-    {
-        this(valueFactory,
-             invocationUnit,
-             evaluateAllCode,
-             evaluateAllCode ?
-                 new BasicBranchUnit() :
-                 new TracedBranchUnit(),
-             new BranchTargetFinder(),
-             null);
-    }
-
-
-    /**
-     * Creates a new PartialEvaluator, based on an existing one.
-     * @param partialEvaluator the subroutine calling partial evaluator.
-     */
-    private PartialEvaluator(PartialEvaluator partialEvaluator)
-    {
-        this(partialEvaluator.valueFactory,
-             partialEvaluator.invocationUnit,
-             partialEvaluator.evaluateAllCode,
-             partialEvaluator.branchUnit,
-             partialEvaluator.branchTargetFinder,
-             partialEvaluator.instructionBlockStack);
-    }
-
-
-    /**
-     * Creates a new PartialEvaluator.
-     * @param valueFactory            the value factory that will create all
-     *                                values during evaluation.
-     * @param invocationUnit          the invocation unit that will handle all
-     *                                communication with other fields and methods.
-     * @param evaluateAllCode         a flag that specifies whether all branch
-     *                                targets and exception handlers should be
-     *                                evaluated, even if they are unreachable.
-     * @param branchUnit              the branch unit that will handle all
-     *                                branches.
-     * @param branchTargetFinder      the utility class that will find all
-     *                                branches.
-     */
-    private PartialEvaluator(ValueFactory       valueFactory,
-                             InvocationUnit     invocationUnit,
-                             boolean            evaluateAllCode,
-                             BasicBranchUnit    branchUnit,
-                             BranchTargetFinder branchTargetFinder,
-                             java.util.Stack    callingInstructionBlockStack)
-    {
-        this.valueFactory       = valueFactory;
-        this.invocationUnit     = invocationUnit;
-        this.evaluateAllCode    = evaluateAllCode;
-        this.branchUnit         = branchUnit;
-        this.branchTargetFinder = branchTargetFinder;
-        this.callingInstructionBlockStack = callingInstructionBlockStack == null ?
-            this.instructionBlockStack :
-            callingInstructionBlockStack;
-    }
-
-
-    // Implementations for AttributeVisitor.
-
-    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-
-
-    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
-    {
-//        DEBUG = DEBUG_RESULTS =
-//            clazz.getName().equals("abc/Def") &&
-//            method.getName(clazz).equals("abc");
-
-        // TODO: Remove this when the partial evaluator 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 performing 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()+")");
-
-            if (DEBUG)
-            {
-                method.accept(clazz, new ClassPrinter());
-
-                System.out.println("Evaluation results:");
-
-                int offset = 0;
-                do
-                {
-                    if (isBranchOrExceptionTarget(offset))
-                    {
-                        System.out.println("Branch target from ["+branchOriginValues[offset]+"]:");
-                        if (isTraced(offset))
-                        {
-                            System.out.println("  Vars:  "+variablesBefore[offset]);
-                            System.out.println("  Stack: "+stacksBefore[offset]);
-                        }
-                    }
-
-                    Instruction instruction = InstructionFactory.create(codeAttribute.code,
-                                                                        offset);
-                    System.out.println(instruction.toString(offset));
-
-                    if (isTraced(offset))
-                    {
-                        int initializationOffset = branchTargetFinder.initializationOffset(offset);
-                        if (initializationOffset != NONE)
-                        {
-                            System.out.println("     is to be initialized at ["+initializationOffset+"]");
-                        }
-
-                        InstructionOffsetValue branchTargets = branchTargets(offset);
-                        if (branchTargets != null)
-                        {
-                            System.out.println("     has overall been branching to "+branchTargets);
-                        }
-
-                        System.out.println("  Vars:  "+variablesAfter[offset]);
-                        System.out.println("  Stack: "+stacksAfter[offset]);
-                    }
-
-                    offset += instruction.length(offset);
-                }
-                while (offset < codeAttribute.u4codeLength);
-            }
-
-            throw ex;
-        }
-    }
-
-
-    public void visitCodeAttribute0(Clazz clazz, Method method, CodeAttribute codeAttribute)
-    {
-        // Evaluate the instructions, starting at the entry point.
-        if (DEBUG)
-        {
-            System.out.println();
-            System.out.println("Partial evaluation: "+clazz.getName()+"."+method.getName(clazz)+method.getDescriptor(clazz));
-            System.out.println("  Max locals = "+codeAttribute.u2maxLocals);
-            System.out.println("  Max stack  = "+codeAttribute.u2maxStack);
-        }
-
-        // Reuse the existing variables and stack objects, ensuring the right size.
-        TracedVariables variables = new TracedVariables(codeAttribute.u2maxLocals);
-        TracedStack     stack     = new TracedStack(codeAttribute.u2maxStack);
-
-        // Initialize the reusable arrays and variables.
-        initializeArrays(codeAttribute);
-        initializeParameters(clazz, method, codeAttribute, variables);
-
-        // Find all instruction offsets,...
-        codeAttribute.accept(clazz, method, branchTargetFinder);
-
-        // Start executing the first instruction block.
-        evaluateInstructionBlockAndExceptionHandlers(clazz,
-                                                     method,
-                                                     codeAttribute,
-                                                     variables,
-                                                     stack,
-                                                     0,
-                                                     codeAttribute.u4codeLength);
-
-        if (DEBUG_RESULTS)
-        {
-            System.out.println("Evaluation results:");
-
-            int offset = 0;
-            do
-            {
-                if (isBranchOrExceptionTarget(offset))
-                {
-                    System.out.println("Branch target from ["+branchOriginValues[offset]+"]:");
-                    if (isTraced(offset))
-                    {
-                        System.out.println("  Vars:  "+variablesBefore[offset]);
-                        System.out.println("  Stack: "+stacksBefore[offset]);
-                    }
-                }
-
-                Instruction instruction = InstructionFactory.create(codeAttribute.code,
-                                                                    offset);
-                System.out.println(instruction.toString(offset));
-
-                if (isTraced(offset))
-                {
-                    int initializationOffset = branchTargetFinder.initializationOffset(offset);
-                    if (initializationOffset != NONE)
-                    {
-                        System.out.println("     is to be initialized at ["+initializationOffset+"]");
-                    }
-
-                    InstructionOffsetValue branchTargets = branchTargets(offset);
-                    if (branchTargets != null)
-                    {
-                        System.out.println("     has overall been branching to "+branchTargets);
-                    }
-
-                    System.out.println("  Vars:  "+variablesAfter[offset]);
-                    System.out.println("  Stack: "+stacksAfter[offset]);
-                }
-
-                offset += instruction.length(offset);
-            }
-            while (offset < codeAttribute.u4codeLength);
-        }
-    }
-
-
-    /**
-     * Returns whether a block of instructions is ever used.
-     */
-    public boolean isTraced(int startOffset, int endOffset)
-    {
-        for (int index = startOffset; index < endOffset; index++)
-        {
-            if (isTraced(index))
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-
-    /**
-     * Returns whether the instruction at the given offset has ever been
-     * executed during the partial evaluation.
-     */
-    public boolean isTraced(int instructionOffset)
-    {
-        return evaluationCounts[instructionOffset] > 0;
-    }
-
-
-    /**
-     * Returns whether there is an instruction at the given offset.
-     */
-    public boolean isInstruction(int instructionOffset)
-    {
-        return branchTargetFinder.isInstruction(instructionOffset);
-    }
-
-
-    /**
-     * Returns whether the instruction at the given offset is the target of a
-     * branch instruction or an exception.
-     */
-    public boolean isBranchOrExceptionTarget(int instructionOffset)
-    {
-        return branchTargetFinder.isBranchTarget(instructionOffset) ||
-               branchTargetFinder.isExceptionHandler(instructionOffset);
-    }
-
-
-    /**
-     * Returns whether the instruction at the given offset is the start of a
-     * subroutine.
-     */
-    public boolean isSubroutineStart(int instructionOffset)
-    {
-        return branchTargetFinder.isSubroutineStart(instructionOffset);
-    }
-
-
-    /**
-     * Returns whether the instruction at the given offset is a subroutine
-     * invocation.
-     */
-    public boolean isSubroutineInvocation(int instructionOffset)
-    {
-        return branchTargetFinder.isSubroutineInvocation(instructionOffset);
-    }
-
-
-    /**
-     * Returns whether the instruction at the given offset is part of a
-     * subroutine.
-     */
-    public boolean isSubroutine(int instructionOffset)
-    {
-        return branchTargetFinder.isSubroutine(instructionOffset);
-    }
-
-
-    /**
-     * Returns whether the subroutine at the given offset is ever returning
-     * by means of a regular 'ret' instruction.
-     */
-    public boolean isSubroutineReturning(int instructionOffset)
-    {
-        return branchTargetFinder.isSubroutineReturning(instructionOffset);
-    }
-
-
-    /**
-     * Returns the offset after the subroutine that starts at the given
-     * offset.
-     */
-    public int subroutineEnd(int instructionOffset)
-    {
-        return branchTargetFinder.subroutineEnd(instructionOffset);
-    }
-
-
-    /**
-     * Returns the instruction offset at which the object instance that is
-     * created at the given 'new' instruction offset is initialized, or
-     * <code>NONE</code> if it is not being created.
-     */
-    public int initializationOffset(int instructionOffset)
-    {
-        return branchTargetFinder.initializationOffset(instructionOffset);
-    }
-
-
-    /**
-     * Returns whether the method is an instance initializer.
-     */
-    public boolean isInitializer()
-    {
-        return branchTargetFinder.isInitializer();
-    }
-
-
-    /**
-     * Returns the instruction offset at which this initializer is calling
-     * the "super" or "this" initializer method, or <code>NONE</code> if it is
-     * not an initializer.
-     */
-    public int superInitializationOffset()
-    {
-        return branchTargetFinder.superInitializationOffset();
-    }
-
-
-    /**
-     * Returns the offset of the 'new' instruction that corresponds to the
-     * invocation of the instance initializer at the given offset, or
-     * <code>AT_METHOD_ENTRY</code> if the invocation is calling the "super" or
-     * "this" initializer method, , or <code>NONE</code> if it is not a 'new'
-     * instruction.
-     */
-    public int creationOffset(int offset)
-    {
-        return branchTargetFinder.creationOffset(offset);
-    }
-
-
-    /**
-     * Returns the variables before execution of the instruction at the given
-     * offset.
-     */
-    public TracedVariables getVariablesBefore(int instructionOffset)
-    {
-        return variablesBefore[instructionOffset];
-    }
-
-
-    /**
-     * Returns the variables after execution of the instruction at the given
-     * offset.
-     */
-    public TracedVariables getVariablesAfter(int instructionOffset)
-    {
-        return variablesAfter[instructionOffset];
-    }
-
-
-    /**
-     * Returns the stack before execution of the instruction at the given
-     * offset.
-     */
-    public TracedStack getStackBefore(int instructionOffset)
-    {
-        return stacksBefore[instructionOffset];
-    }
-
-
-    /**
-     * Returns the stack after execution of the instruction at the given
-     * offset.
-     */
-    public TracedStack getStackAfter(int instructionOffset)
-    {
-        return stacksAfter[instructionOffset];
-    }
-
-
-    /**
-     * Returns the instruction offsets that branch to the given instruction
-     * offset.
-     */
-    public InstructionOffsetValue branchOrigins(int instructionOffset)
-    {
-        return branchOriginValues[instructionOffset];
-    }
-
-
-    /**
-     * Returns the instruction offsets to which the given instruction offset
-     * branches.
-     */
-    public InstructionOffsetValue branchTargets(int instructionOffset)
-    {
-        return branchTargetValues[instructionOffset];
-    }
-
-
-    // Utility methods to evaluate instruction blocks.
-
-    /**
-     * Pushes block of instructions to be executed in the calling partial
-     * evaluator.
-     */
-    private void pushCallingInstructionBlock(TracedVariables variables,
-                                             TracedStack     stack,
-                                             int             startOffset)
-    {
-        callingInstructionBlockStack.push(new MyInstructionBlock(variables,
-                                                                 stack,
-                                                                 startOffset));
-    }
-
-
-    /**
-     * Pushes block of instructions to be executed in this partial evaluator.
-     */
-    private void pushInstructionBlock(TracedVariables variables,
-                                      TracedStack     stack,
-                                      int             startOffset)
-    {
-        instructionBlockStack.push(new MyInstructionBlock(variables,
-                                                          stack,
-                                                          startOffset));
-    }
-
-
-    /**
-     * Evaluates the instruction block and the exception handlers covering the
-     * given instruction range in the given code.
-     */
-    private void evaluateInstructionBlockAndExceptionHandlers(Clazz           clazz,
-                                                              Method          method,
-                                                              CodeAttribute   codeAttribute,
-                                                              TracedVariables variables,
-                                                              TracedStack     stack,
-                                                              int             startOffset,
-                                                              int             endOffset)
-    {
-        evaluateInstructionBlock(clazz,
-                                 method,
-                                 codeAttribute,
-                                 variables,
-                                 stack,
-                                 startOffset);
-
-        evaluateExceptionHandlers(clazz,
-                                  method,
-                                  codeAttribute,
-                                  startOffset,
-                                  endOffset);
-    }
-
-
-    /**
-     * Evaluates a block of instructions, starting at the given offset and ending
-     * at a branch instruction, a return instruction, or a throw instruction.
-     */
-    private void evaluateInstructionBlock(Clazz           clazz,
-                                          Method          method,
-                                          CodeAttribute   codeAttribute,
-                                          TracedVariables variables,
-                                          TracedStack     stack,
-                                          int             startOffset)
-    {
-        // Execute the initial instruction block.
-        evaluateSingleInstructionBlock(clazz,
-                                       method,
-                                       codeAttribute,
-                                       variables,
-                                       stack,
-                                       startOffset);
-
-        // Execute all resulting instruction blocks on the execution stack.
-        while (!instructionBlockStack.empty())
-        {
-            if (DEBUG) System.out.println("Popping alternative branch out of "+instructionBlockStack.size()+" blocks");
-
-            MyInstructionBlock instructionBlock =
-                (MyInstructionBlock)instructionBlockStack.pop();
-
-            evaluateSingleInstructionBlock(clazz,
-                                           method,
-                                           codeAttribute,
-                                           instructionBlock.variables,
-                                           instructionBlock.stack,
-                                           instructionBlock.startOffset);
-        }
-    }
-
-
-    /**
-     * Evaluates a block of instructions, starting at the given offset and ending
-     * at a branch instruction, a return instruction, or a throw instruction.
-     * Instruction blocks that are to be evaluated as a result are pushed on
-     * the given stack.
-     */
-    private void evaluateSingleInstructionBlock(Clazz            clazz,
-                                                Method           method,
-                                                CodeAttribute    codeAttribute,
-                                                TracedVariables  variables,
-                                                TracedStack      stack,
-                                                int              startOffset)
-    {
-        byte[] code = codeAttribute.code;
-
-        if (DEBUG)
-        {
-             System.out.println("Instruction block starting at ["+startOffset+"] in "+
-                                ClassUtil.externalFullMethodDescription(clazz.getName(),
-                                                                        0,
-                                                                        method.getName(clazz),
-                                                                        method.getDescriptor(clazz)));
-             System.out.println("Init vars:  "+variables);
-             System.out.println("Init stack: "+stack);
-        }
-
-        Processor processor = new Processor(variables,
-                                            stack,
-                                            valueFactory,
-                                            branchUnit,
-                                            invocationUnit);
-
-        int instructionOffset = startOffset;
-
-        int maxOffset = startOffset;
-
-        // Evaluate the subsequent instructions.
-        while (true)
-        {
-            if (maxOffset < instructionOffset)
-            {
-                maxOffset = instructionOffset;
-            }
-
-            // Maintain a generalized local variable frame and stack at this
-            // instruction offset, before execution.
-            int evaluationCount = evaluationCounts[instructionOffset];
-            if (evaluationCount == 0)
-            {
-                // First time we're passing by this instruction.
-                if (variablesBefore[instructionOffset] == null)
-                {
-                    // There's not even a context at this index yet.
-                    variablesBefore[instructionOffset] = new TracedVariables(variables);
-                    stacksBefore[instructionOffset]    = new TracedStack(stack);
-                }
-                else
-                {
-                    // Reuse the context objects at this index.
-                    variablesBefore[instructionOffset].initialize(variables);
-                    stacksBefore[instructionOffset].copy(stack);
-                }
-
-                // We'll execute in the generalized context, because it is
-                // the same as the current context.
-                generalizedContexts[instructionOffset] = true;
-            }
-            else
-            {
-                // Merge in the current context.
-                boolean variablesChanged = variablesBefore[instructionOffset].generalize(variables, true);
-                boolean stackChanged     = stacksBefore[instructionOffset].generalize(stack);
-
-                //System.out.println("GVars:  "+variablesBefore[instructionOffset]);
-                //System.out.println("GStack: "+stacksBefore[instructionOffset]);
-
-                // Bail out if the current context is the same as last time.
-                if (!variablesChanged &&
-                    !stackChanged     &&
-                    generalizedContexts[instructionOffset])
-                {
-                    if (DEBUG) System.out.println("Repeated variables, stack, and branch targets");
-
-                    break;
-                }
-
-                // See if this instruction has been evaluated an excessive number
-                // of times.
-                if (evaluationCount >= MAXIMUM_EVALUATION_COUNT)
-                {
-                    if (DEBUG) System.out.println("Generalizing current context after "+evaluationCount+" evaluations");
-
-                    // Continue, but generalize the current context.
-                    // Note that the most recent variable values have to remain
-                    // last in the generalizations, for the sake of the ret
-                    // instruction.
-                    variables.generalize(variablesBefore[instructionOffset], false);
-                    stack.generalize(stacksBefore[instructionOffset]);
-
-                    // We'll execute in the generalized context.
-                    generalizedContexts[instructionOffset] = true;
-                }
-                else
-                {
-                    // We'll execute in the current context.
-                    generalizedContexts[instructionOffset] = false;
-                }
-            }
-
-            // We'll evaluate this instruction.
-            evaluationCounts[instructionOffset]++;
-
-            // Remember this instruction's offset with any stored value.
-            Value storeValue = new InstructionOffsetValue(instructionOffset);
-            variables.setProducerValue(storeValue);
-            stack.setProducerValue(storeValue);
-
-            // Reset the trace value.
-            InstructionOffsetValue traceValue = InstructionOffsetValue.EMPTY_VALUE;
-
-            // Note that the instruction is only volatile.
-            Instruction instruction = InstructionFactory.create(code, instructionOffset);
-
-            // By default, the next instruction will be the one after this
-            // instruction.
-            int nextInstructionOffset = instructionOffset +
-                                        instruction.length(instructionOffset);
-            InstructionOffsetValue nextInstructionOffsetValue = new InstructionOffsetValue(nextInstructionOffset);
-            branchUnit.resetCalled();
-            branchUnit.setTraceBranchTargets(nextInstructionOffsetValue);
-
-            if (DEBUG)
-            {
-                System.out.println(instruction.toString(instructionOffset));
-            }
-
-            try
-            {
-                // Process the instruction. The processor may modify the
-                // variables and the stack, and it may call the branch unit
-                // and the invocation unit.
-                instruction.accept(clazz,
-                                   method,
-                                   codeAttribute,
-                                   instructionOffset,
-                                   processor);
-            }
-            catch (RuntimeException ex)
-            {
-                System.err.println("Unexpected error while evaluating instruction:");
-                System.err.println("  Class       = ["+clazz.getName()+"]");
-                System.err.println("  Method      = ["+method.getName(clazz)+method.getDescriptor(clazz)+"]");
-                System.err.println("  Instruction = "+instruction.toString(instructionOffset));
-                System.err.println("  Exception   = ["+ex.getClass().getName()+"] ("+ex.getMessage()+")");
-
-                throw ex;
-            }
-
-            // Collect the branch targets from the branch unit.
-            InstructionOffsetValue branchTargets = branchUnit.getTraceBranchTargets();
-            int branchTargetCount = branchTargets.instructionOffsetCount();
-
-            // Stop tracing.
-            branchUnit.setTraceBranchTargets(traceValue);
-
-            if (DEBUG)
-            {
-                if (branchUnit.wasCalled())
-                {
-                    System.out.println("     is branching to "+branchTargets);
-                }
-                if (branchTargetValues[instructionOffset] != null)
-                {
-                    System.out.println("     has up till now been branching to "+branchTargetValues[instructionOffset]);
-                }
-
-                System.out.println(" Vars:  "+variables);
-                System.out.println(" Stack: "+stack);
-            }
-
-            // Maintain a generalized local variable frame and stack at this
-            // instruction offset, after execution.
-            if (evaluationCount == 0)
-            {
-                // First time we're passing by this instruction.
-                if (variablesAfter[instructionOffset] == null)
-                {
-                    // There's not even a context at this index yet.
-                    variablesAfter[instructionOffset] = new TracedVariables(variables);
-                    stacksAfter[instructionOffset]    = new TracedStack(stack);
-                }
-                else
-                {
-                    // Reuse the context objects at this index.
-                    variablesAfter[instructionOffset].initialize(variables);
-                    stacksAfter[instructionOffset].copy(stack);
-                }
-            }
-            else
-            {
-                // Merge in the current context.
-                variablesAfter[instructionOffset].generalize(variables, true);
-                stacksAfter[instructionOffset].generalize(stack);
-            }
-
-            // Did the branch unit get called?
-            if (branchUnit.wasCalled())
-            {
-                // Accumulate the branch targets at this offset.
-                branchTargetValues[instructionOffset] = branchTargetValues[instructionOffset] == null ?
-                    branchTargets :
-                    branchTargetValues[instructionOffset].generalize(branchTargets).instructionOffsetValue();
-
-                // Are there no branch targets at all?
-                if (branchTargetCount == 0)
-                {
-                    // Exit from this code block.
-                    break;
-                }
-
-                // Accumulate the branch origins at the branch target offsets.
-                InstructionOffsetValue instructionOffsetValue = new InstructionOffsetValue(instructionOffset);
-                for (int index = 0; index < branchTargetCount; index++)
-                {
-                    int branchTarget = branchTargets.instructionOffset(index);
-                    branchOriginValues[branchTarget] = branchOriginValues[branchTarget] == null ?
-                        instructionOffsetValue:
-                        branchOriginValues[branchTarget].generalize(instructionOffsetValue).instructionOffsetValue();
-                }
-
-                // Are there multiple branch targets?
-                if (branchTargetCount > 1)
-                {
-                    // Push them on the execution stack and exit from this block.
-                    for (int index = 0; index < branchTargetCount; index++)
-                    {
-                        if (DEBUG) System.out.println("Pushing alternative branch #"+index+" out of "+branchTargetCount+", from ["+instructionOffset+"] to ["+branchTargets.instructionOffset(index)+"]");
-
-                        pushInstructionBlock(new TracedVariables(variables),
-                                             new TracedStack(stack),
-                                             branchTargets.instructionOffset(index));
-                    }
-
-                    break;
-                }
-
-                if (DEBUG) System.out.println("Definite branch from ["+instructionOffset+"] to ["+branchTargets.instructionOffset(0)+"]");
-            }
-
-            // Just continue with the next instruction.
-            instructionOffset = branchTargets.instructionOffset(0);
-
-            // Is this a subroutine invocation?
-            if (instruction.opcode == InstructionConstants.OP_JSR ||
-                instruction.opcode == InstructionConstants.OP_JSR_W)
-            {
-                // Evaluate the subroutine, possibly in another partial
-                // evaluator.
-                evaluateSubroutine(clazz,
-                                   method,
-                                   codeAttribute,
-                                   variables,
-                                   stack,
-                                   instructionOffset,
-                                   instructionBlockStack);
-
-                break;
-            }
-            else if (instruction.opcode == InstructionConstants.OP_RET)
-            {
-                // Let the partial evaluator that has called the subroutine
-                // handle the evaluation after the return.
-                pushCallingInstructionBlock(new TracedVariables(variables),
-                                            new TracedStack(stack),
-                                            instructionOffset);
-                break;
-            }
-        }
-
-        if (DEBUG) System.out.println("Ending processing of instruction block starting at ["+startOffset+"]");
-    }
-
-
-    /**
-     * Evaluates a subroutine and its exception handlers, starting at the given
-     * offset and ending at a subroutine return instruction.
-     */
-    private void evaluateSubroutine(Clazz           clazz,
-                                    Method          method,
-                                    CodeAttribute   codeAttribute,
-                                    TracedVariables variables,
-                                    TracedStack     stack,
-                                    int             subroutineStart,
-                                    java.util.Stack instructionBlockStack)
-    {
-        int subroutineEnd = branchTargetFinder.subroutineEnd(subroutineStart);
-
-        if (DEBUG) System.out.println("Evaluating subroutine from "+subroutineStart+" to "+subroutineEnd);
-
-        PartialEvaluator subroutinePartialEvaluator = this;
-
-        // Create a temporary partial evaluator if necessary.
-        if (evaluationCounts[subroutineStart] > 0)
-        {
-            if (DEBUG) System.out.println("Creating new partial evaluator for subroutine");
-
-            subroutinePartialEvaluator = new PartialEvaluator(this);
-
-            subroutinePartialEvaluator.initializeArrays(codeAttribute);
-        }
-
-        // Evaluate the subroutine.
-        subroutinePartialEvaluator.evaluateInstructionBlockAndExceptionHandlers(clazz,
-                                                                                method,
-                                                                                codeAttribute,
-                                                                                variables,
-                                                                                stack,
-                                                                                subroutineStart,
-                                                                                subroutineEnd);
-
-        // Merge back the temporary partial evaluator if necessary.
-        if (subroutinePartialEvaluator != this)
-        {
-            generalize(subroutinePartialEvaluator, 0, codeAttribute.u4codeLength);
-        }
-
-        if (DEBUG) System.out.println("Ending subroutine from "+subroutineStart+" to "+subroutineEnd);
-    }
-
-
-    /**
-     * Generalizes the results of this partial evaluator with those of another
-     * given partial evaluator, over a given range of instructions.
-     */
-    private void generalize(PartialEvaluator other,
-                            int              codeStart,
-                            int              codeEnd)
-    {
-        if (DEBUG) System.out.println("Generalizing with temporary partial evaluation");
-
-        for (int offset = codeStart; offset < codeEnd; offset++)
-        {
-            if (other.branchOriginValues[offset] != null)
-            {
-                branchOriginValues[offset] = branchOriginValues[offset] == null ?
-                    other.branchOriginValues[offset] :
-                    branchOriginValues[offset].generalize(other.branchOriginValues[offset]).instructionOffsetValue();
-            }
-
-            if (other.isTraced(offset))
-            {
-                if (other.branchTargetValues[offset] != null)
-                {
-                    branchTargetValues[offset] = branchTargetValues[offset] == null ?
-                        other.branchTargetValues[offset] :
-                        branchTargetValues[offset].generalize(other.branchTargetValues[offset]).instructionOffsetValue();
-                }
-
-                if (evaluationCounts[offset] == 0)
-                {
-                    variablesBefore[offset]     = other.variablesBefore[offset];
-                    stacksBefore[offset]        = other.stacksBefore[offset];
-                    variablesAfter[offset]      = other.variablesAfter[offset];
-                    stacksAfter[offset]         = other.stacksAfter[offset];
-                    generalizedContexts[offset] = other.generalizedContexts[offset];
-                    evaluationCounts[offset]    = other.evaluationCounts[offset];
-                }
-                else
-                {
-                    variablesBefore[offset].generalize(other.variablesBefore[offset], false);
-                    stacksBefore[offset]   .generalize(other.stacksBefore[offset]);
-                    variablesAfter[offset] .generalize(other.variablesAfter[offset], false);
-                    stacksAfter[offset]    .generalize(other.stacksAfter[offset]);
-                    //generalizedContexts[offset]
-                    evaluationCounts[offset] += other.evaluationCounts[offset];
-                }
-            }
-        }
-    }
-
-
-    /**
-     * Evaluates the exception handlers covering and targeting the given
-     * instruction range in the given code.
-     */
-    private void evaluateExceptionHandlers(Clazz         clazz,
-                                           Method        method,
-                                           CodeAttribute codeAttribute,
-                                           int           startOffset,
-                                           int           endOffset)
-    {
-        if (DEBUG) System.out.println("Evaluating exceptions covering ["+startOffset+" -> "+endOffset+"]:");
-
-        ExceptionHandlerFilter exceptionEvaluator =
-            new ExceptionHandlerFilter(startOffset,
-                                       endOffset,
-                                       this);
-
-        // Evaluate the exception catch blocks, until their entry variables
-        // have stabilized.
-        do
-        {
-            // Reset the flag to stop evaluating.
-            evaluateExceptions = false;
-
-            // Evaluate all relevant exception catch blocks once.
-            codeAttribute.exceptionsAccept(clazz,
-                                           method,
-                                           startOffset,
-                                           endOffset,
-                                           exceptionEvaluator);
-        }
-        while (evaluateExceptions);
-    }
-
-
-    // Implementations for ExceptionInfoVisitor.
-
-    public void visitExceptionInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, ExceptionInfo exceptionInfo)
-    {
-        int startPC = exceptionInfo.u2startPC;
-        int endPC   = exceptionInfo.u2endPC;
-
-        // Do we have to evaluate this exception catch block?
-        if (isTraced(startPC, endPC))
-        {
-            int handlerPC = exceptionInfo.u2handlerPC;
-            int catchType = exceptionInfo.u2catchType;
-
-            if (DEBUG) System.out.println("Evaluating exception ["+startPC +" -> "+endPC +": "+handlerPC+"]:");
-
-            // Reuse the existing variables and stack objects, ensuring the
-            // right size.
-            TracedVariables variables = new TracedVariables(codeAttribute.u2maxLocals);
-            TracedStack     stack     = new TracedStack(codeAttribute.u2maxStack);
-
-            // Initialize the trace values.
-            Value storeValue = new InstructionOffsetValue(AT_CATCH_ENTRY);
-            variables.setProducerValue(storeValue);
-            stack.setProducerValue(storeValue);
-
-            // Initialize the variables by generalizing the variables of the
-            // try block. Make sure to include the results of the last
-            // instruction for preverification.
-            generalizeVariables(startPC,
-                                endPC,
-                                evaluateAllCode,
-                                variables);
-
-            // Initialize the the stack.
-            //stack.push(valueFactory.createReference((ClassConstant)((ProgramClass)clazz).getConstant(exceptionInfo.u2catchType), false));
-            String catchClassName = catchType != 0 ?
-                 clazz.getClassName(catchType) :
-                 ClassConstants.INTERNAL_NAME_JAVA_LANG_THROWABLE;
-
-            Clazz catchClass = catchType != 0 ?
-                ((ClassConstant)((ProgramClass)clazz).getConstant(catchType)).referencedClass :
-                null;
-
-            stack.push(valueFactory.createReferenceValue(catchClassName,
-                                                         catchClass,
-                                                         false));
-
-            int evaluationCount = evaluationCounts[handlerPC];
-
-            // Evaluate the instructions, starting at the entry point.
-            evaluateInstructionBlock(clazz,
-                                     method,
-                                     codeAttribute,
-                                     variables,
-                                     stack,
-                                     handlerPC);
-
-            // Remember to evaluate all exception handlers once more.
-            if (!evaluateExceptions)
-            {
-                evaluateExceptions = evaluationCount < evaluationCounts[handlerPC];
-            }
-        }
-//        else if (evaluateAllCode)
-//        {
-//            if (DEBUG) System.out.println("No information for partial evaluation of exception ["+startPC +" -> "+endPC +": "+exceptionInfo.u2handlerPC+"] yet");
-//
-//            // We don't have any information on the try block yet, but we do
-//            // have to evaluate the exception handler.
-//            // Remember to evaluate all exception handlers once more.
-//            evaluateExceptions = true;
-//        }
-        else
-        {
-            if (DEBUG) System.out.println("No information for partial evaluation of exception ["+startPC +" -> "+endPC +": "+exceptionInfo.u2handlerPC+"]");
-        }
-    }
-
-
-    // Small utility methods.
-
-    /**
-     * Initializes the data structures for the variables, stack, etc.
-     */
-    private void initializeArrays(CodeAttribute codeAttribute)
-    {
-        int codeLength = codeAttribute.u4codeLength;
-
-        // Create new arrays for storing information at each instruction offset.
-        if (variablesAfter.length < codeLength)
-        {
-            // Create new arrays.
-            branchOriginValues  = new InstructionOffsetValue[codeLength];
-            branchTargetValues  = new InstructionOffsetValue[codeLength];
-            variablesBefore     = new TracedVariables[codeLength];
-            stacksBefore        = new TracedStack[codeLength];
-            variablesAfter      = new TracedVariables[codeLength];
-            stacksAfter         = new TracedStack[codeLength];
-            generalizedContexts = new boolean[codeLength];
-            evaluationCounts    = new int[codeLength];
-        }
-        else
-        {
-            // Reset the arrays.
-            Arrays.fill(branchOriginValues,  null);
-            Arrays.fill(branchTargetValues,  null);
-            Arrays.fill(generalizedContexts, false);
-            Arrays.fill(evaluationCounts,    0);
-
-            for (int index = 0; index < codeLength; index++)
-            {
-                if (variablesBefore[index] != null)
-                {
-                    variablesBefore[index].reset(codeAttribute.u2maxLocals);
-                }
-
-                if (stacksBefore[index] != null)
-                {
-                    stacksBefore[index].reset(codeAttribute.u2maxStack);
-                }
-
-                if (variablesAfter[index] != null)
-                {
-                    variablesAfter[index].reset(codeAttribute.u2maxLocals);
-                }
-
-                if (stacksAfter[index] != null)
-                {
-                    stacksAfter[index].reset(codeAttribute.u2maxStack);
-                }
-            }
-        }
-    }
-
-
-    /**
-     * Initializes the data structures for the variables, stack, etc.
-     */
-    private void initializeParameters(Clazz           clazz,
-                                      Method          method,
-                                      CodeAttribute   codeAttribute,
-                                      TracedVariables variables)
-    {
-        // Create the method parameters.
-        TracedVariables parameters = new TracedVariables(codeAttribute.u2maxLocals);
-
-        // Remember this instruction's offset with any stored value.
-        Value storeValue = new InstructionOffsetValue(AT_METHOD_ENTRY);
-        parameters.setProducerValue(storeValue);
-
-        // Initialize the method parameters.
-        invocationUnit.enterMethod(clazz, method, parameters);
-
-        if (DEBUG)
-        {
-            System.out.println("  Params: "+parameters);
-        }
-
-        // Initialize the variables with the parameters.
-        variables.initialize(parameters);
-
-        // Set the store value of each parameter variable.
-        InstructionOffsetValue atMethodEntry = new InstructionOffsetValue(AT_METHOD_ENTRY);
-
-        for (int index = 0; index < parameters.size(); index++)
-        {
-            variables.setProducerValue(index, atMethodEntry);
-        }
-    }
-
-
-    /**
-     * Generalize the local variable frames of a block of instructions.
-     */
-    private void generalizeVariables(int             startOffset,
-                                     int             endOffset,
-                                     boolean         includeAfterLastInstruction,
-                                     TracedVariables generalizedVariables)
-    {
-        boolean first     = true;
-        int     lastIndex = -1;
-
-        // Generalize the variables before each of the instructions in the block.
-        for (int index = startOffset; index < endOffset; index++)
-        {
-            if (isTraced(index))
-            {
-                TracedVariables tracedVariables = variablesBefore[index];
-
-                if (first)
-                {
-                    // Initialize the variables with the first traced local
-                    // variable frame.
-                    generalizedVariables.initialize(tracedVariables);
-
-                    first = false;
-                }
-                else
-                {
-                    // Generalize the variables with the traced local variable
-                    // frame. We can't use the return value, because local
-                    // generalization can be different a couple of times,
-                    // with the global generalization being the same.
-                    generalizedVariables.generalize(tracedVariables, false);
-                }
-
-                lastIndex = index;
-            }
-        }
-
-        // Generalize the variables after the last instruction in the block,
-        // if required.
-        if (includeAfterLastInstruction &&
-            lastIndex >= 0)
-        {
-            TracedVariables tracedVariables = variablesAfter[lastIndex];
-
-            if (first)
-            {
-                // Initialize the variables with the local variable frame.
-                generalizedVariables.initialize(tracedVariables);
-            }
-            else
-            {
-                // Generalize the variables with the local variable frame.
-                generalizedVariables.generalize(tracedVariables, false);
-            }
-        }
-
-        // Just clear the variables if there aren't any traced instructions
-        // in the block.
-        if (first)
-        {
-            generalizedVariables.reset(generalizedVariables.size());
-        }
-    }
-
-
-    private static class MyInstructionBlock
-    {
-        private TracedVariables variables;
-        private TracedStack     stack;
-        private int             startOffset;
-
-
-        private MyInstructionBlock(TracedVariables variables,
-                                   TracedStack     stack,
-                                   int             startOffset)
-        {
-            this.variables   = variables;
-            this.stack       = stack;
-            this.startOffset = startOffset;
-        }
-    }
-}