jdk.nashorn.internal.ir.Optimistic Java Examples

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int  programPoint = node.getProgramPoint();
    final Type validType    = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
        return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType      = getEvaluatedType(node);

    if (evaluatedType != null) {
        if (evaluatedType.widerThan(mostOptimisticType)) {
            final Type newValidType = evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
            // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is a heuristic
            // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it might
            // notice a widening in the type of the expression and thus prevent an unnecessary deoptimization later.
            // We'll presume though that the types of expressions are mostly stable, so if we evaluated it in one
            // compilation, we'll keep to that and risk a low-probability deoptimization if its type gets widened
            // in the future.
            compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
        }
        return evaluatedType;
    }
    return mostOptimisticType;
}
 

private void tagNeverOptimistic(final Expression expr) {
    if(expr instanceof Optimistic) {
        final int pp = ((Optimistic)expr).getProgramPoint();
        if(isValid(pp)) {
            neverOptimistic.peek().set(pp);
        }
    }
}
 

private Expression leaveOptimistic(final Optimistic opt) {
    final int pp = opt.getProgramPoint();
    if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
        return (Expression)opt.setType(compiler.getOptimisticType(opt));
    }
    return (Expression)opt;
}
 

@Override
protected Node leaveDefault(final Node node) {
    if(node instanceof Optimistic) {
        return leaveOptimistic((Optimistic)node);
    }
    return node;
}
 

private Expression setProgramPoint(final Optimistic optimistic) {
    if (noProgramPoint.contains(optimistic)) {
        return (Expression)optimistic;
    }
    return (Expression)(optimistic.canBeOptimistic() ? optimistic.setProgramPoint(next()) : optimistic);
}
 

private Type getEvaluatedType(final Optimistic expr) {
    if (expr instanceof IdentNode) {
        if (runtimeScope == null) {
            return null;
        }
        return getPropertyType(runtimeScope, ((IdentNode)expr).getName());
    } else if (expr instanceof AccessNode) {
        final AccessNode accessNode = (AccessNode)expr;
        final Object base = evaluateSafely(accessNode.getBase());
        if (!(base instanceof ScriptObject)) {
            return null;
        }
        return getPropertyType((ScriptObject)base, accessNode.getProperty());
    } else if (expr instanceof IndexNode) {
        final IndexNode indexNode = (IndexNode)expr;
        final Object    base = evaluateSafely(indexNode.getBase());
        if(base instanceof NativeArray || base instanceof ArrayBufferView) {
            // NOTE: optimistic array getters throw UnwarrantedOptimismException based on the type of their
            // underlying array storage, not based on values of individual elements. Thus, a LongArrayData will
            // throw UOE for every optimistic int linkage attempt, even if the long value being returned in the
            // first invocation would be representable as int. That way, we can presume that the array's optimistic
            // type is the most optimistic type for which an element getter has a chance of executing successfully.
            return ((ScriptObject)base).getArray().getOptimisticType();
        }
    } else if (expr instanceof CallNode) {
        // Currently, we'll only try to guess the return type of immediately invoked function expressions with no
        // parameters, that is (function() { ... })(). We could do better, but these are all heuristics and we can
        // gradually introduce them as needed. An easy one would be to do the same for .call(this) idiom.
        final CallNode callExpr = (CallNode)expr;
        final Expression fnExpr = callExpr.getFunction();
        // Skip evaluation if running with eager compilation as we may violate constraints in RecompilableScriptFunctionData
        if (fnExpr instanceof FunctionNode && compiler.getContext().getEnv()._lazy_compilation) {
            final FunctionNode fn = (FunctionNode)fnExpr;
            if (callExpr.getArgs().isEmpty()) {
                final RecompilableScriptFunctionData data = compiler.getScriptFunctionData(fn.getId());
                if (data != null) {
                    final Type returnType = Type.typeFor(data.getReturnType(EMPTY_INVOCATION_TYPE, runtimeScope));
                    if (returnType == Type.BOOLEAN) {
                        // We don't have optimistic booleans. In fact, optimistic call sites getting back boolean
                        // currently deoptimize all the way to Object.
                        return Type.OBJECT;
                    }
                    assert returnType == Type.INT || returnType == Type.NUMBER || returnType == Type.OBJECT;
                    return returnType;
                }
            }
        }
    }

    return null;
}