Java LocalVariableConversion.hasLiveConversion方法代码示例

import jdk.nashorn.internal.ir.LocalVariableConversion; //导入方法依赖的package包/类
private void optimizeLogicalOperand(final Expression expr, final Label label, final boolean state, final boolean isRhs) {
    final JoinPredecessorExpression jpexpr = (JoinPredecessorExpression)expr;
    if(LocalVariableConversion.hasLiveConversion(jpexpr)) {
        final Label after = new Label("after");
        branchOptimizer(jpexpr.getExpression(), after, !state);
        method.beforeJoinPoint(jpexpr);
        method._goto(label);
        method.label(after);
        if(isRhs) {
            method.beforeJoinPoint(jpexpr);
        }
    } else {
        branchOptimizer(jpexpr.getExpression(), label, state);
    }
}
 

import jdk.nashorn.internal.ir.LocalVariableConversion; //导入方法依赖的package包/类
private void enterDoWhile(final WhileNode whileNode) {
    final int liveLocalsOnContinueOrBreak = method.getUsedSlotsWithLiveTemporaries();
    method.beforeJoinPoint(whileNode);

    final Block body = whileNode.getBody();
    body.accept(this);

    emitContinueLabel(whileNode.getContinueLabel(), liveLocalsOnContinueOrBreak);
    if(method.isReachable()) {
        lineNumber(whileNode);
        final JoinPredecessorExpression test = whileNode.getTest();
        final Label bodyEntryLabel = body.getEntryLabel();
        final boolean testHasLiveConversion = LocalVariableConversion.hasLiveConversion(test);
        if(Expression.isAlwaysFalse(test)) {
            loadAndDiscard(test);
            if(testHasLiveConversion) {
                method.beforeJoinPoint(test);
            }
        } else if(testHasLiveConversion) {
            // If we have conversions after the test in do-while, they need to be effected on both branches.
            final Label beforeExit = new Label("do_while_preexit");
            emitBranch(test.getExpression(), beforeExit, false);
            method.beforeJoinPoint(test);
            method._goto(bodyEntryLabel);
            method.label(beforeExit);
            method.beforeJoinPoint(test);
        } else {
            emitBranch(test.getExpression(), bodyEntryLabel, true);
        }
    }
    method.breakLabel(whileNode.getBreakLabel(), liveLocalsOnContinueOrBreak);
}
 

import jdk.nashorn.internal.ir.LocalVariableConversion; //导入方法依赖的package包/类
private void enterForIn(final ForNode forNode) {
    loadExpression(forNode.getModify(), TypeBounds.OBJECT);
    method.invoke(forNode.isForEach() ? ScriptRuntime.TO_VALUE_ITERATOR : ScriptRuntime.TO_PROPERTY_ITERATOR);
    final Symbol iterSymbol = forNode.getIterator();
    final int iterSlot = iterSymbol.getSlot(Type.OBJECT);
    method.store(iterSymbol, ITERATOR_TYPE);

    method.beforeJoinPoint(forNode);

    final Label continueLabel = forNode.getContinueLabel();
    final Label breakLabel    = forNode.getBreakLabel();

    method.label(continueLabel);
    method.load(ITERATOR_TYPE, iterSlot);
    method.invoke(interfaceCallNoLookup(ITERATOR_CLASS, "hasNext", boolean.class));
    final JoinPredecessorExpression test = forNode.getTest();
    final Block body = forNode.getBody();
    if(LocalVariableConversion.hasLiveConversion(test)) {
        final Label afterConversion = new Label("for_in_after_test_conv");
        method.ifne(afterConversion);
        method.beforeJoinPoint(test);
        method._goto(breakLabel);
        method.label(afterConversion);
    } else {
        method.ifeq(breakLabel);
    }

    new Store<Expression>(forNode.getInit()) {
        @Override
        protected void storeNonDiscard() {
            // This expression is neither part of a discard, nor needs to be left on the stack after it was
            // stored, so we override storeNonDiscard to be a no-op.
        }

        @Override
        protected void evaluate() {
            new OptimisticOperation((Optimistic)forNode.getInit(), TypeBounds.UNBOUNDED) {
                @Override
                void loadStack() {
                    method.load(ITERATOR_TYPE, iterSlot);
                }

                @Override
                void consumeStack() {
                    method.invoke(interfaceCallNoLookup(ITERATOR_CLASS, "next", Object.class));
                    convertOptimisticReturnValue();
                }
            }.emit();
        }
    }.store();
    body.accept(this);

    if(method.isReachable()) {
        method._goto(continueLabel);
    }
    method.label(breakLabel);
}
 

import jdk.nashorn.internal.ir.LocalVariableConversion; //导入方法依赖的package包/类
@Override
public boolean enterIfNode(final IfNode ifNode) {
    if(!method.isReachable()) {
        return false;
    }
    enterStatement(ifNode);

    final Expression test = ifNode.getTest();
    final Block pass = ifNode.getPass();
    final Block fail = ifNode.getFail();

    if (Expression.isAlwaysTrue(test)) {
        loadAndDiscard(test);
        pass.accept(this);
        return false;
    } else if (Expression.isAlwaysFalse(test)) {
        loadAndDiscard(test);
        if (fail != null) {
            fail.accept(this);
        }
        return false;
    }

    final boolean hasFailConversion = LocalVariableConversion.hasLiveConversion(ifNode);

    final Label failLabel  = new Label("if_fail");
    final Label afterLabel = (fail == null && !hasFailConversion) ? null : new Label("if_done");

    emitBranch(test, failLabel, false);

    pass.accept(this);
    if(method.isReachable() && afterLabel != null) {
        method._goto(afterLabel); //don't fallthru to fail block
    }
    method.label(failLabel);

    if (fail != null) {
        fail.accept(this);
    } else if(hasFailConversion) {
        method.beforeJoinPoint(ifNode);
    }

    if(afterLabel != null && afterLabel.isReachable()) {
        method.label(afterLabel);
    }

    return false;
}
 

import jdk.nashorn.internal.ir.LocalVariableConversion; //导入方法依赖的package包/类
private void enterForOrWhile(final LoopNode loopNode, final JoinPredecessorExpression modify) {
    // NOTE: the usual pattern for compiling test-first loops is "GOTO test; body; test; IFNE body". We use the less
    // conventional "test; IFEQ break; body; GOTO test; break;". It has one extra unconditional GOTO in each repeat
    // of the loop, but it's not a problem for modern JIT compilers. We do this because our local variable type
    // tracking is unfortunately not really prepared for out-of-order execution, e.g. compiling the following
    // contrived but legal JavaScript code snippet would fail because the test changes the type of "i" from object
    // to double: var i = {valueOf: function() { return 1} }; while(--i >= 0) { ... }
    // Instead of adding more complexity to the local variable type tracking, we instead choose to emit this
    // different code shape.
    final int liveLocalsOnBreak = method.getUsedSlotsWithLiveTemporaries();
    final JoinPredecessorExpression test = loopNode.getTest();
    if(Expression.isAlwaysFalse(test)) {
        loadAndDiscard(test);
        return;
    }

    method.beforeJoinPoint(loopNode);

    final Label continueLabel = loopNode.getContinueLabel();
    final Label repeatLabel = modify != null ? new Label("for_repeat") : continueLabel;
    method.label(repeatLabel);
    final int liveLocalsOnContinue = method.getUsedSlotsWithLiveTemporaries();

    final Block   body                  = loopNode.getBody();
    final Label   breakLabel            = loopNode.getBreakLabel();
    final boolean testHasLiveConversion = test != null && LocalVariableConversion.hasLiveConversion(test);

    if(Expression.isAlwaysTrue(test)) {
        if(test != null) {
            loadAndDiscard(test);
            if(testHasLiveConversion) {
                method.beforeJoinPoint(test);
            }
        }
    } else if (test != null) {
        if (testHasLiveConversion) {
            emitBranch(test.getExpression(), body.getEntryLabel(), true);
            method.beforeJoinPoint(test);
            method._goto(breakLabel);
        } else {
            emitBranch(test.getExpression(), breakLabel, false);
        }
    }

    body.accept(this);
    if(repeatLabel != continueLabel) {
        emitContinueLabel(continueLabel, liveLocalsOnContinue);
    }

    if (loopNode.hasPerIterationScope() && lc.getCurrentBlock().needsScope()) {
        // ES6 for loops with LET init need a new scope for each iteration. We just create a shallow copy here.
        method.loadCompilerConstant(SCOPE);
        method.invoke(virtualCallNoLookup(ScriptObject.class, "copy", ScriptObject.class));
        method.storeCompilerConstant(SCOPE);
    }

    if(method.isReachable()) {
        if(modify != null) {
            lineNumber(loopNode);
            loadAndDiscard(modify);
            method.beforeJoinPoint(modify);
        }
        method._goto(repeatLabel);
    }

    method.breakLabel(breakLabel, liveLocalsOnBreak);
}