Java TracedStack类代码示例

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * 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);
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * Marks the stack entries and their producing instructions of the
 * consumer at the given offset.
 * @param clazz          the containing class.
 * @param consumerOffset the offset of the consumer.
 * @param consumer       the consumer of the stack entries.
 */
private void markStackProducers(Clazz       clazz,
                                int         consumerOffset,
                                Instruction consumer)
{
    TracedStack tracedStack =
        partialEvaluator.getStackBefore(consumerOffset);

    int stackSize = tracedStack.size();

    // Mark the producers of the popped values.
    int popCount = consumer.stackPopCount(clazz);
    for (int stackIndex = stackSize - popCount; stackIndex < stackSize; stackIndex++)
    {
        markStackEntryProducers(consumerOffset, stackIndex);
    }
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
{
    // Get the total size of the parameters.
    int parameterSize = ParameterUsageMarker.getParameterSize(programMethod);

    // Make the method invocation static, if possible.
    if ((programMethod.getAccessFlags() & ClassConstants.INTERNAL_ACC_STATIC) == 0 &&
        !ParameterUsageMarker.isParameterUsed(programMethod, 0))
    {
        replaceByStaticInvocation(programClass,
                                  invocationOffset,
                                  invocationInstruction);
    }

    // Remove unused parameters.
    for (int index = 0; index < parameterSize; index++)
    {
        if (!ParameterUsageMarker.isParameterUsed(programMethod, index))
        {
            TracedStack stack =
                partialEvaluator.getStackBefore(invocationOffset);

            int stackIndex = stack.size() - parameterSize + index;

            if (DEBUG)
            {
                System.out.println("  ["+invocationOffset+"] Ignoring parameter #"+index+" of "+programClass.getName()+"."+programMethod.getName(programClass)+programMethod.getDescriptor(programClass)+"] (stack entry #"+stackIndex+" ["+stack.getBottom(stackIndex)+"])");
                System.out.println("    Full stack: "+stack);
            }

            markStackSimplificationBefore(invocationOffset, stackIndex);
        }
    }
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * Marks the stack entry and the corresponding producing instructions
 * of the consumer at the given offset.
 * @param consumerOffset the offset of the consumer.
 * @param stackIndex     the index of the stack entry to be marked
 *                        (counting from the top).
 */
private void markStackEntryProducers(int consumerOffset,
                                     int stackIndex)
{
    TracedStack tracedStack =
        partialEvaluator.getStackBefore(consumerOffset);

    int stackBottomIndex = tracedStack.size() - 1 - stackIndex;

    if (!isStackSimplifiedBefore(consumerOffset, stackBottomIndex))
    {
        markStackEntryProducers(tracedStack.getTopProducerValue(stackIndex).instructionOffsetValue(),
                                stackBottomIndex);
    }
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * Marks the stack entry and its initializing instruction
 * ('invokespecial *.<init>') for the given 'new' instruction offset.
 * @param newInstructionOffset the offset of the 'new' instruction.
 */
private void markInitialization(int newInstructionOffset)
{
    int initializationOffset =
        partialEvaluator.initializationOffset(newInstructionOffset);

    TracedStack tracedStack =
        partialEvaluator.getStackAfter(newInstructionOffset);

    markStackEntryAfter(initializationOffset, tracedStack.size() - 1);
    markInstruction(initializationOffset);
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * 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));
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * 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));
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
private MyInstructionBlock(TracedVariables variables,
                           TracedStack     stack,
                           int             startOffset)
{
    this.variables   = variables;
    this.stack       = stack;
    this.startOffset = startOffset;
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
{
    // Get the total size of the parameters.
    int parameterSize = ParameterUsageMarker.getParameterSize(programMethod);

    // Make the method invocation static, if possible.
    if ((programMethod.getAccessFlags() & ClassConstants.ACC_STATIC) == 0 &&
        !ParameterUsageMarker.isParameterUsed(programMethod, 0))
    {
        replaceByStaticInvocation(programClass,
                                  invocationOffset,
                                  invocationInstruction);
    }

    // Remove unused parameters.
    for (int index = 0; index < parameterSize; index++)
    {
        if (!ParameterUsageMarker.isParameterUsed(programMethod, index))
        {
            TracedStack stack =
                partialEvaluator.getStackBefore(invocationOffset);

            int stackIndex = stack.size() - parameterSize + index;

            if (DEBUG)
            {
                System.out.println("  ["+invocationOffset+"] Ignoring parameter #"+index+" of "+programClass.getName()+"."+programMethod.getName(programClass)+programMethod.getDescriptor(programClass)+"] (stack entry #"+stackIndex+" ["+stack.getBottom(stackIndex)+"])");
                System.out.println("    Full stack: "+stack);
            }

            markStackSimplificationBefore(invocationOffset, stackIndex);
        }
    }
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * Returns whether the specified stack entry before the given offset is
 * present.
 * @param instructionOffset the offset of the stack entry to be checked.
 * @param stackIndex        the index of the stack entry to be checked
 *                          (counting from the bottom).
 */
private boolean isStackEntryPresentBefore(int instructionOffset,
                                          int stackIndex)
{
    TracedStack tracedStack =
        partialEvaluator.getStackBefore(instructionOffset);

    InstructionOffsetValue producerOffsets =
        tracedStack.getBottomProducerValue(stackIndex).instructionOffsetValue();

    return isAnyStackEntryNecessaryAfter(producerOffsets, stackIndex);
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
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);
    }
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * Returns the stack before execution of the instruction at the given
 * offset.
 */
public TracedStack getStackBefore(int instructionOffset)
{
    return stacksBefore[instructionOffset];
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * Returns the stack after execution of the instruction at the given
 * offset.
 */
public TracedStack getStackAfter(int instructionOffset)
{
    return stacksAfter[instructionOffset];
}
 

import proguard.evaluation.TracedStack; //导入依赖的package包/类
/**
 * 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);
}