Java ResolvedJavaMethod.getAnnotation方法代码示例

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
private static void checkMethod(ResolvedJavaMethod method) {
    if (method.getAnnotation(Snippet.class) == null) {
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        for (int i = 0; i < parameterAnnotations.length; i++) {
            for (Annotation a : parameterAnnotations[i]) {
                Class<? extends Annotation> annotationType = a.annotationType();
                if (annotationType == ConstantParameter.class || annotationType == VarargsParameter.class || annotationType == NonNullParameter.class) {
                    VerificationError verificationError = new VerificationError("Parameter %d of %s is annotated with %s but the method is not annotated with %s", i, method,
                                    annotationType.getSimpleName(),
                                    Snippet.class.getSimpleName());
                    throw verificationError;
                }
            }
        }
    }
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * A helper for {@link ResolvedJavaMethod#getAnnotation(Class)} that handles the absence of
 * annotations on bridge methods where the bridged method has annotations.
 */
public static <T extends Annotation> T getAnnotation(Class<T> annotationClass, ResolvedJavaMethod method) {
    T a = method.getAnnotation(annotationClass);
    if (a == null && method.isBridge()) {
        ResolvedJavaMethod bridged = getBridgedMethod(method);
        if (bridged != null) {
            a = bridged.getAnnotation(annotationClass);
        }
    }
    return a;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
private static List<NodeCount> getNodeCountAnnotations(StructuredGraph graph) {
    ResolvedJavaMethod method = graph.method();
    AnchorSnippet snippet = method.getAnnotation(AnchorSnippet.class);
    if (snippet != null) {
        return Arrays.asList(snippet.value());
    }

    NodeCount single = method.getAnnotation(NodeCount.class);
    if (single != null) {
        return Collections.singletonList(single);
    }

    return Collections.emptyList();
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
protected void raiseInvalidFrameStateError(FrameState state) throws GraalGraphError {
    // This is a hard error since an incorrect state could crash hotspot
    NodeSourcePosition sourcePosition = state.getNodeSourcePosition();
    List<String> context = new ArrayList<>();
    ResolvedJavaMethod replacementMethodWithProblematicSideEffect = null;
    if (sourcePosition != null) {
        NodeSourcePosition pos = sourcePosition;
        while (pos != null) {
            StringBuilder sb = new StringBuilder("parsing ");
            ResolvedJavaMethod method = pos.getMethod();
            MetaUtil.appendLocation(sb, method, pos.getBCI());
            if (method.getAnnotation(MethodSubstitution.class) != null ||
                            method.getAnnotation(Snippet.class) != null) {
                replacementMethodWithProblematicSideEffect = method;
            }
            context.add(sb.toString());
            pos = pos.getCaller();
        }
    }
    String message = "Invalid frame state " + state;
    if (replacementMethodWithProblematicSideEffect != null) {
        message += " associated with a side effect in " + replacementMethodWithProblematicSideEffect.format("%H.%n(%p)") + " at a position that cannot be deoptimized to";
    }
    GraalGraphError error = new GraalGraphError(message);
    for (String c : context) {
        error.addContext(c);
    }
    throw error;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
@Test
@TestAnnotation(value = 1000L)
public void getAnnotationTest() throws NoSuchMethodException {
    ResolvedJavaMethod method = metaAccess.lookupJavaMethod(getClass().getDeclaredMethod("getAnnotationTest"));
    TestAnnotation annotation = method.getAnnotation(TestAnnotation.class);
    assertNotNull(annotation);
    assertEquals(1000L, annotation.value());
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
protected boolean hasGeneratedInvocationPluginAnnotation(ResolvedJavaMethod method) {
    return method.getAnnotation(Node.NodeIntrinsic.class) != null || method.getAnnotation(Fold.class) != null;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
protected boolean hasGenericInvocationPluginAnnotation(ResolvedJavaMethod method) {
    return method.getAnnotation(Word.Operation.class) != null;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
@Override
protected boolean hasGenericInvocationPluginAnnotation(ResolvedJavaMethod method) {
    return method.getAnnotation(HotSpotOperation.class) != null || super.hasGenericInvocationPluginAnnotation(method);
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
private static boolean isSignaturePolymorphic(ResolvedJavaMethod method) {
    return method.getAnnotation(SIGNATURE_POLYMORPHIC_CLASS) != null;
}