Java ResolvedJavaMethod.canBeInlined方法代码示例

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
@Override
public InlineInfo shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) {
    // @formatter:off
    if (method.hasBytecodes() &&
        method.getDeclaringClass().isLinked() &&
        method.canBeInlined()) {

        // Test force inlining first
        if (method.shouldBeInlined()) {
            return createStandardInlineInfo(method);
        }

        if (!method.isSynchronized() &&
            checkSize(method, args, b.getGraph()) &&
            b.getDepth() < InlineDuringParsingMaxDepth.getValue(b.getOptions())) {
            return createStandardInlineInfo(method);
        }
    }
    // @formatter:on
    return null;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
private String checkTargetConditionsHelper(ResolvedJavaMethod method, int invokeBci) {
    OptionValues options = rootGraph.getOptions();
    if (method == null) {
        return "the method is not resolved";
    } else if (method.isNative() && (!Intrinsify.getValue(options) || !InliningUtil.canIntrinsify(context.getReplacements(), method, invokeBci))) {
        return "it is a non-intrinsic native method";
    } else if (method.isAbstract()) {
        return "it is an abstract method";
    } else if (!method.getDeclaringClass().isInitialized()) {
        return "the method's class is not initialized";
    } else if (!method.canBeInlined()) {
        return "it is marked non-inlinable";
    } else if (countRecursiveInlining(method) > MaximumRecursiveInlining.getValue(options)) {
        return "it exceeds the maximum recursive inlining depth";
    } else {
        if (new OptimisticOptimizations(rootGraph.getProfilingInfo(method), options).lessOptimisticThan(context.getOptimisticOptimizations())) {
            return "the callee uses less optimistic optimizations than caller";
        } else {
            return null;
        }
    }
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * Try to inline a method. If the method was inlined, returns {@link #SUCCESSFULLY_INLINED}.
 * Otherwise, it returns the {@link InlineInfo} that lead to the decision to not inline it, or
 * {@code null} if there is no {@link InlineInfo} for this method.
 */
private InlineInfo tryInline(ValueNode[] args, ResolvedJavaMethod targetMethod) {
    boolean canBeInlined = forceInliningEverything || parsingIntrinsic() || targetMethod.canBeInlined();
    if (!canBeInlined) {
        return null;
    }

    if (forceInliningEverything) {
        if (inline(targetMethod, targetMethod, null, args)) {
            return SUCCESSFULLY_INLINED;
        } else {
            return null;
        }
    }

    for (InlineInvokePlugin plugin : graphBuilderConfig.getPlugins().getInlineInvokePlugins()) {
        InlineInfo inlineInfo = plugin.shouldInlineInvoke(this, targetMethod, args);
        if (inlineInfo != null) {
            if (inlineInfo.getMethodToInline() != null) {
                if (inline(targetMethod, inlineInfo.getMethodToInline(), inlineInfo.getIntrinsicBytecodeProvider(), args)) {
                    return SUCCESSFULLY_INLINED;
                }
                inlineInfo = null;
            }
            /* Do not inline, and do not ask the remaining plugins. */
            return inlineInfo;
        }
    }

    // There was no inline plugin with a definite answer to whether or not
    // to inline. If we're parsing an intrinsic, then we need to enforce the
    // invariant here that methods are always force inlined in intrinsics/snippets.
    if (parsingIntrinsic()) {
        if (inline(targetMethod, targetMethod, this.bytecodeProvider, args)) {
            return SUCCESSFULLY_INLINED;
        }
    }
    return null;
}