Kilim源码分析之四 ---- 织入之内联subroutine

        小于1.5编译级别时，如果不显示inline try/catch/finally块，try/catch和any会产生的jsr指令跳转到finally。此处分析kilim如何对这种情况下的jsr指令进行内联：finally块中有pausable则会被拷贝一份；finally块中有pausable则会把jsr/ret指令都替换为goto指令，但是并没有像1.5及以后编译级别那样，拷贝一份代码try/catch代码块编译后的指令块中。下面看下analyze中调用的kilim.analysis.MethodFlow.inlineSubroutines()的实现：

   private void inlineSubroutines() throws KilimException {
        markPausableJSRs();//处理finally块，打标记
        while (true) {
            ArrayList<BasicBlock> newBBs = null;
            for (BasicBlock bb: basicBlocks) {
                if (bb.hasFlag(INLINE_CHECKED)) continue;
                bb.setFlag(INLINE_CHECKED);//所有块都是INLINE_CHECKED
                if (bb.lastInstruction() == JSR) {//bb是try/catch代码块的最后一个bb，才inline
                    newBBs = bb.inline();//bb内联
                    if (newBBs != null) {
                        break;
                    }
                }
            }
            if (newBBs == null) { 
                break;
            }
            int id = basicBlocks.size();
            for (BasicBlock bb: newBBs) {
                bb.setId(id++);
                basicBlocks.add(bb);
            }
        }
        // If there are any pausable subroutines, modify the JSRs/RETs to
        // GOTOs
        for (BasicBlock bb: basicBlocks) {
            bb.changeJSR_RET_toGOTOs();//把出现pausable调用的finally块相关的jsr/ret指令换成goto指令来实现
        }
        
    }
    
    private void markPausableJSRs() throws KilimException {
        for (BasicBlock bb: basicBlocks) {
            bb.checkPausableJSR();//这里调用了BasicBlock.checkPausableJSR()
        }
    }
    
    /*
     * If any BB belonging to a subroutine makes a pausable
     * block, it taints all the blocks within the subroutine's
     * purview as PAUSABLE_SUB. 如果subroutine有一个bb是PAUSABLE，那么其所有bbs都是PAUSABLE_SUB的，何用？
     */
    void checkPausableJSR() throws KilimException {
        BasicBlock sub = getJSRTarget();//如果当前bb的最后一条指令是jsr指令，那么第一个后继结点就是jsr Target，jsr指令所在块也只有一个后继结点，即finally代码块的第一个bb。第一次运行到这里时，如果当前分析的方法没有返回值，则当前块是type为any的异常handler，jvm编译期生成的，following bb里边会把异常抛出；如果方法有返回值，当前块保存了返回值在局部变量表，following bb会return局部变量表内容。sub即为finally块内容
        boolean isPausableJSR = false;
        if (sub != null) {
            ArrayList<BasicBlock> subBlocks = sub.getSubBlocks();//finally代码块对应的basicBlocks，如果finally代码块中还有try/catch/finally块，会在jsr指令处终止的，即subBlocks不会包含子finally代码块对应的bb
            for (BasicBlock b: subBlocks) {
                if (b.hasFlag(PAUSABLE)) {//initialize的时候，pausable方法所在bb是PAUSABLE的
                    isPausableJSR = true;
                    break;
                }
            }
            if (isPausableJSR) {
                for (BasicBlock b: subBlocks) {//finally块中有一个是PAUSABLE,整个finally所有subBlocks都是PAUSABLE_SUB
                    b.setFlag(PAUSABLE_SUB);
                }
            }
        }
    }


    /*
     * Invoked on the subroutine entry point's BB. Returns all the BBs
     * linked to it.
     */
    public ArrayList<BasicBlock> getSubBlocks() throws KilimException {
        if (subBlocks == null) {
            if (!hasFlag(IS_SUBROUTINE))//还记得在BasicBlock.initialize的时候我们把jsr指令的目标地址开始的块设置为IS_SUBROUTINE的
                return null;
            subBlocks = new ArrayList<BasicBlock>(10);
            Stack<BasicBlock> stack = new Stack<BasicBlock>();
            this.setFlag(SUB_BLOCK);//IS_SUBROUTINE 也就是 SUB_BLOCK
            stack.add(this);
            while (!stack.isEmpty()) {//如果finally语句块的那一堆代码又被划分成了很多块，那么所有块都是SUB_BLOCK
                BasicBlock b = stack.pop();
                subBlocks.add(b);
                if (b.lastInstruction() == JSR) {//当前块是jsrTarget块，即finally代码块的第一个bb。而在initialize的时候，我们并没有处理过ret指令的目标地址，没有处理过jsr指令的物理following指令，即jsr的物理following指令跟jsr指令是没有关联起来的，所以这里需要关联起来。
                    // add the following block, but not its target
                    BasicBlock follower = b.getFollowingBlock();//获取bb.endPos+1开始的块，一般来说，jsr块的物理following块通常是load、athrow、return等，这些是jsr的目标块运行完需要ret回来的地址。
                    if (!follower.hasFlag(SUB_BLOCK)) {//都标记为SUB_BLOCK
                        follower.setFlag(SUB_BLOCK);
                        stack.push(follower);
                    }
                    continue;//意味着我们跳过了jsr指令的successors，即finally块中的finally块是被跳过了
                }
                for (BasicBlock succ : b.successors) {//jsr指令结尾的块也是有successor的，即它的target块。finally块的结尾是有ret指令的，这个指令所在块是没有后继节点的，subBlocks也就到此位置了。finally块中的try/catch/finally块也会被分析
                    if (succ == this) {
                        thrownew KilimException("JSRs looping back to themselves are not supported");
                    }
                    if (!succ.hasFlag(SUB_BLOCK)) {
                        succ.setFlag(SUB_BLOCK);
                        stack.push(succ);
                    }
                }
            }
            Collections.sort(subBlocks);//按照指令块的物理顺序排序，在consolidate 块的时候按顺序设置了bb的id的，这个id在bb.compareTo中有用到
        }
        return subBlocks;
    }
    /**
     * This basic block's last instruction is JSR. This method initiates a
     * subgraph traversal to identify the called subroutine's boundaries and to
     * make all encountered RET instructions point back to this BB's follower,
     * in essence turning it to a goto. The reason for not actually turning it
     * into a GOTO is that if we don't find any pausable methods in a
     * subroutine, then during code generation we'll simply use the original
     * code. The duplication is still required for flow analysis.
     * 
     * The VM spec is fuzzy on what constitutes the boundaries of a subroutine.
     * We consider the following situations invalid, even though the verifier is
     * ok with it: (a) looping back to itself (b) encountering xRETURN in a subroutine
     * 
     * inline() traverses the graph creating copies of BasicBlocks and labels
     * and keeps a mapping between the old and the new. In the second round, it
     * copies instructions translating any that have labels (branch and switch
     * instructions).
     * 
     * @return mapping of orig basic blocks to new.
     * 
     */
    ArrayList<BasicBlock> inline() throws KilimException {
        HashMap<BasicBlock, BasicBlock> bbCopyMap = null;
        HashMap<Label, Label> labelCopyMap = null;
        BasicBlock targetBB = successors.get(0);//jsr目标块
        Label returnToLabel = flow.getOrCreateLabelAtPos(endPos+1);//jsr指令下边的指令，如果jsr在try块中，就是return；如果jsr是在type为any的异常处理块中，就是aload_X athrow;
        BasicBlock returnToBB = flow.getOrCreateBasicBlock(returnToLabel);
        boolean isPausableSub = targetBB.hasFlag(PAUSABLE_SUB);
        if (!targetBB.hasFlag(SUBROUTINE_CLAIMED)) {
            // This JSR call gets to claim the subroutine's blocks, so no
            // copying required. If another JSR wants to point to the same
            // subroutine, it'll copy BBs on demand)
            targetBB.setFlag(SUBROUTINE_CLAIMED);
            // Tell the RET blocks about the returnTo address and we are done.
            for (BasicBlock b : targetBB.getSubBlocks()) {
                if (b.lastInstruction() == RET) {
                    assert b.successors.size() == 0 : this.toString();
                    b.addSuccessor(returnToBB);//把jsr的下一条指令开始块作为ret指令结束的块的后继结点，即把ret指令和jsr指令关联起来
                }
            }
            return null;
        }
        bbCopyMap = new HashMap<BasicBlock, BasicBlock>(10);
        labelCopyMap = new HashMap<Label, Label>(10);
        successors.clear();
        // first pass
        targetBB.dupBBAndLabels(isPausableSub, bbCopyMap, labelCopyMap, returnToBB);
        addSuccessor(bbCopyMap.get(targetBB));
        // second pass
        return dupCopyContents(isPausableSub, targetBB, returnToBB, bbCopyMap, labelCopyMap);
    }
    //把jsr指令改造成goto指令
    void changeJSR_RET_toGOTOs() throws KilimException {
        int lastInsn = getInstruction(endPos).getOpcode(); 
        if (lastInsn == JSR) {//块的最后一条指令为jsr指令
            BasicBlock targetBB = successors.get(0);
            if (!targetBB.hasFlag(PAUSABLE_SUB)) return;//不是pausable就不处理，因为不会织入，不做改变的。在checkPausableJSR的时候，PAUSABLE bb的所有subBB都是PAUSABLE_SUB的
            changeLastInsnToGOTO(targetBB.startLabel);//把当前块最后一个指令替换成goto，goto的目标是targetBB。其实这里就是替换jsr为goto
            successors.clear();//clear一次有什么用？
            successors.add(targetBB);


            // change the first ASTORE instruction in targetBB to a NOP
            assert targetBB.getInstruction(targetBB.startPos).getOpcode() == ASTORE;//targetBB的第一条指令一定是astroe，存的是jsr后边的指令地址
            targetBB.setInstruction(targetBB.startPos, new NopInsn());//把楼上这个存储jsr下一条指令的地址的指令替换成空指令。这个地址原本会被ret指令用到
            targetBB.unsetFlag(IS_SUBROUTINE);
        } else if (lastInsn == RET && hasFlag(PAUSABLE_SUB)) {
            changeLastInsnToGOTO(successors.get(0).startLabel);//处理jsr targetBB里边的ret指令，改为goto，目标指令是ret的目标块，即jsr的下一条指令所在块。在initialize的时候，ret指令结尾的块是没有successor的，这个在inline的时候关联起来的。
        }//这么整个下来，把jsr、ret指令给替换成了goto，把jsr目标块第一条指令给删掉了。
    }