stacksizeupdater.java

proguard 3.5 java 混淆器 最新 免费 好用的 大家用用试一下吧 天行健-君子以自强不息 地势坤-君子以厚德载物

                                     methodInfo,
                                     codeAttrInfo,
                                     offset + branchInstruction.length(offset));
        }

        // Some branch instructions always end the current instruction block.
        exitInstructionBlock =
            opcode == InstructionConstants.OP_GOTO   ||
            opcode == InstructionConstants.OP_GOTO_W ||
            opcode == InstructionConstants.OP_JSR    ||
            opcode == InstructionConstants.OP_JSR_W;
    }


    public void visitTableSwitchInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, TableSwitchInstruction tableSwitchInstruction)
    {
        // Evaluate the target instruction blocks.
        evaluateInstructionBlocks(classFile,
                                  methodInfo,
                                  codeAttrInfo,
                                  offset,
                                  tableSwitchInstruction.jumpOffsets,
                                  tableSwitchInstruction.jumpOffsetCount,
                                  tableSwitchInstruction.defaultOffset);

        // The switch instruction always ends the current instruction block.
        exitInstructionBlock = true;
    }


    public void visitLookUpSwitchInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, LookUpSwitchInstruction lookUpSwitchInstruction)
    {
        // Evaluate the target instruction blocks.
        evaluateInstructionBlocks(classFile,
                                  methodInfo,
                                  codeAttrInfo,
                                  offset,
                                  lookUpSwitchInstruction.jumpOffsets,
                                  lookUpSwitchInstruction.jumpOffsetCount,
                                  lookUpSwitchInstruction.defaultOffset);

        // The switch instruction always ends the current instruction block.
        exitInstructionBlock = true;
    }


    // Implementations for ExceptionInfoVisitor.

    public void visitExceptionInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, ExceptionInfo exceptionInfo)
    {
        // The stack size when entering the exception handler is always 1.
        stackSize = 1;

        // Evaluate the instruction block starting at the entry point of the
        // exception handler.
        evaluateInstructionBlock(classFile,
                                 methodInfo,
                                 codeAttrInfo,
                                 exceptionInfo.u2handlerpc);
    }


    // Small utility methods.

    /**
     * Evaluates the blocks of instructions starting at the given jump offsets.
     */
    private void evaluateInstructionBlocks(ClassFile    classFile,
                                           MethodInfo   methodInfo,
                                           CodeAttrInfo codeAttrInfo,
                                           int          instructionOffset,
                                           int[]        jumpOffsets,
                                           int          jumpOffsetCount,
                                           int          defaultOffset)
    {
        // The jump offset arrays may be reused, so we have to make a local copy.
        int[] jumpOffsetsCopy = new int[jumpOffsetCount];
        System.arraycopy(jumpOffsets, 0, jumpOffsetsCopy, 0,  jumpOffsetCount);
        jumpOffsets = jumpOffsetsCopy;

        // Loop over all jump offsets.
        for (int index = 0; index < jumpOffsetCount; index++)
        {
            // Evaluate the jump instruction block.
            evaluateInstructionBlock(classFile,
                                     methodInfo,
                                     codeAttrInfo,
                                     instructionOffset + jumpOffsets[index]);
        }

        // Also evaluate the default instruction block.
        evaluateInstructionBlock(classFile,
                                 methodInfo,
                                 codeAttrInfo,
                                 instructionOffset + defaultOffset);
    }


    /**
     * Evaluates a block of instructions that hasn't been handled before,
     * starting at the given offset and ending a branch instruction, a return
     * instruction, or a throw instruction. Branch instructions are handled
     * recursively.
     */
    private void evaluateInstructionBlock(ClassFile    classFile,
                                          MethodInfo   methodInfo,
                                          CodeAttrInfo codeAttrInfo,
                                          int          instructionOffset)
    {
        if (DEBUG)
        {
            System.out.println("--");
        }

        // Remember the initial stack size.
        int initialStackSize = stackSize;

        // Remember the maximum stack size.
        if (maxStackSize < stackSize)
        {
            maxStackSize = stackSize;
        }

        // Evaluate any instructions that haven't been evaluated before.
        while (!evaluated[instructionOffset])
        {
            // Mark the instruction as evaluated.
            evaluated[instructionOffset] = true;

            Instruction instruction = InstructionFactory.create(codeAttrInfo.code,
                                                                instructionOffset);

            if (DEBUG)
            {
                int stackPushCount = instruction.stackPushCount(classFile);
                int stackPopCount  = instruction.stackPopCount(classFile);
                System.out.println("["+instructionOffset+"]: "+
                                   stackSize+" - "+
                                   stackPopCount+" + "+
                                   stackPushCount+" = "+
                                   (stackSize+stackPushCount-stackPopCount)+": "+
                                   instruction.toString());
            }

            // Compute the instruction's effect on the stack size.
            stackSize += instruction.stackPushCount(classFile) -
                         instruction.stackPopCount(classFile);

            // Remember the maximum stack size.
            if (maxStackSize < stackSize)
            {
                maxStackSize = stackSize;
            }

            // Remember the next instruction offset.
            int nextInstructionOffset = instructionOffset +
                                        instruction.length(instructionOffset);

            // Visit the instruction, in order to handle branches.
            instruction.accept(classFile, methodInfo, codeAttrInfo, instructionOffset, this);

            // Stop evaluating after a branch.
            if (exitInstructionBlock)
            {
                break;
            }

            // Continue with the next instruction.
            instructionOffset = nextInstructionOffset;

            if (DEBUG)
            {
                if (evaluated[instructionOffset])
                {
                    System.out.println("-- ("+instructionOffset+" already evaluated)");
                }
            }
        }

        // Restore the stack size for possible subsequent instruction blocks.
        this.stackSize = initialStackSize;
    }
}