add support for retrieving all annotations on an element

Author: dougxc

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -3033,13 +3033,16 @@ static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, Annotatio
   typeArrayOop annotations_oop = Annotations::make_java_array(annotations_array, CHECK_NULL);
   typeArrayHandle annotations = typeArrayHandle(THREAD, annotations_oop);
 
-  InstanceKlass** filter = filter_length == 1 ?
-      (InstanceKlass**) &filter_klass_pointers:
-      (InstanceKlass**) filter_klass_pointers;
-  objArrayOop filter_oop = oopFactory::new_objArray(vmClasses::Class_klass(), filter_length, CHECK_NULL);
-  objArrayHandle filter_classes(THREAD, filter_oop);
-  for (int i = 0; i < filter_length; i++) {
-    filter_classes->obj_at_put(i, filter[i]->java_mirror());
+  objArrayHandle filter_classes;
+  if (filter_length != 0) {
+    InstanceKlass** filter = filter_length == 1 ?
+        (InstanceKlass**) &filter_klass_pointers:
+        (InstanceKlass**) filter_klass_pointers;
+    objArrayOop filter_oop = oopFactory::new_objArray(vmClasses::Class_klass(), filter_length, CHECK_NULL);
+    filter_classes = objArrayHandle(THREAD, filter_oop);
+    for (int i = 0; i < filter_length; i++) {
+      filter_classes->obj_at_put(i, filter[i]->java_mirror());
+    }
   }
 
   // invoke VMSupport.encodeAnnotations

src/java.base/share/classes/jdk/internal/vm/VMSupport.java

@@ -191,9 +191,14 @@ public static byte[] encodeAnnotations(byte[] rawAnnotations,
                                            Class<?> declaringClass,
                                            ConstantPool cp,
                                            Class<? extends Annotation>[] selectAnnotationClasses) {
-        for (Class<?> c : selectAnnotationClasses) {
-            if (!c.isAnnotation()) {
-                throw new IllegalArgumentException(c + " is not an annotation interface");
+        if (selectAnnotationClasses != null) {
+            if (selectAnnotationClasses.length == 0) {
+                throw new IllegalArgumentException("annotation class selection must be null or non-empty");
+            }
+            for (Class<?> c : selectAnnotationClasses) {
+                if (!c.isAnnotation()) {
+                    throw new IllegalArgumentException(c + " is not an annotation interface");
+                }
             }
         }
         return encodeAnnotations(AnnotationParser.parseSelectAnnotations(rawAnnotations, cp, declaringClass, false, selectAnnotationClasses).values());

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/CompilerToVM.java

@@ -23,19 +23,14 @@
 
 package jdk.vm.ci.hotspot;
 
-import java.lang.reflect.Executable;
-import java.lang.reflect.Field;
-
 import jdk.internal.misc.Unsafe;
 import jdk.vm.ci.code.BytecodeFrame;
 import jdk.vm.ci.code.InstalledCode;
 import jdk.vm.ci.code.InvalidInstalledCodeException;
 import jdk.vm.ci.code.stack.InspectedFrameVisitor;
 import jdk.vm.ci.common.InitTimer;
-import static jdk.vm.ci.common.InitTimer.timer;
 import jdk.vm.ci.common.JVMCIError;
 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.Option;
-import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
 import jdk.vm.ci.meta.JavaConstant;
@@ -44,6 +39,12 @@
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+
+import static jdk.vm.ci.common.InitTimer.timer;
+import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
+
 /**
  * Calls from Java into HotSpot. The behavior of all the methods in this class that take a native
  * pointer as an argument (e.g., {@link #getSymbol(long)}) is undefined if the argument does not
@@ -1486,7 +1487,7 @@ native byte[] getEncodedFieldAnnotationValues(HotSpotResolvedObjectTypeImpl hold
                                                   Object filterTypes, int filterLength, long filterKlassPointers);
 
     /**
-     * Helper for passing {@Klass*} values to native code.
+     * Helper for passing {@code Klass*} values to native code.
      */
     static final class KlassPointers implements AutoCloseable {
         final ResolvedJavaType[] types;
@@ -1498,20 +1499,23 @@ static final class KlassPointers implements AutoCloseable {
         }
 
         /**
-         * Gets the buffer in which to pass the {@Klass*} values to JNI.
+         * Gets the buffer in which to pass the {@code Klass*} values to JNI.
          *
-         * @return a {@Klass*} value if {@code types.length == 1} otherwise the address of a native
-         *         buffer holding an array of {@Klass*} values
+         * @return 0L if {@code types.length == 0}, a {@code Klass*} value if {@code types.length == 1}
+         *         otherwise the address of a native buffer holding an array of {@code Klass*} values
          */
         long buffer() {
-            int length = types.length;
+            long length = types.length;
+            if (length == 0) {
+                return 0L;
+            }
             if (length == 1) {
                 return ((HotSpotResolvedObjectTypeImpl) types[0]).getKlassPointer();
             } else {
                 pointersArray = unsafe.allocateMemory(length * Long.BYTES);
                 long pos = pointersArray;
-                for (int i = 0; i < types.length; i++) {
-                    HotSpotResolvedObjectTypeImpl hsType = (HotSpotResolvedObjectTypeImpl) types[i];
+                for (ResolvedJavaType type : types) {
+                    HotSpotResolvedObjectTypeImpl hsType = (HotSpotResolvedObjectTypeImpl) type;
                     unsafe.putLong(pos, hsType.getKlassPointer());
                     pos += Long.BYTES;
                 }
@@ -1521,7 +1525,7 @@ long buffer() {
 
         @Override
         public void close() {
-            if (types.length != 1 && pointersArray != 0) {
+            if (types.length > 1 && pointersArray != 0) {
                 unsafe.freeMemory(pointersArray);
                 pointersArray = 0;
             }

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/annotation/Annotated.java

@@ -39,9 +39,9 @@ public interface Annotated {
      * Class initialization is not triggered for enum types referenced by the returned
      * annotation. This method ignores inherited annotations.
      *
-     * @param types annotation types to select
+     * @param types annotation types to select. If empty, then all declared annotations are returned.
      * @return an immutable map from annotation type to annotation of the annotations directly present
-     * on this element that match {@code types}
+     * on this element selected by {@code types}
      * @throws IllegalArgumentException      if any type in {@code types} is not an annotation interface type
      * @throws UnsupportedOperationException if this operation is not supported
      */

test/hotspot/jtreg/compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java

@@ -1305,7 +1305,7 @@ private static void getAnnotationValueExpectedToFail(Annotated annotated, Resolv
 
     /**
      * Tests that {@link AnnotationValue}s obtained from a {@link Class}, {@link Method} or
-     * {@link Field} matches {@link AnnotatedElement#getDeclaredAnnotations()} for the corresponding JVMCI
+     * {@link Field} match {@link AnnotatedElement#getDeclaredAnnotations()} for the corresponding JVMCI
      * object.
      *
      * @param annotatedElement a {@link Class}, {@link Method} or {@link Field} object
@@ -1331,6 +1331,10 @@ public static List<AnnotationValue> getAnnotationValueTest(AnnotatedElement anno
     private static List<AnnotationValue> testGetAnnotationValue(Annotated annotated, List<Annotation> annotations) throws AssertionError {
         ResolvedJavaType suppressWarningsType = metaAccess.lookupJavaType(SuppressWarnings.class);
         List<AnnotationValue> res = new ArrayList<>(annotations.size());
+
+        Map<ResolvedJavaType, AnnotationValue> allAnnotationValues = annotated.getDeclaredAnnotationValues();
+        assertEquals(annotations.size(), allAnnotationValues.size());
+
         for (Annotation a : annotations) {
             var annotationType = metaAccess.lookupJavaType(a.annotationType());
             AnnotationValue av = annotated.getDeclaredAnnotationValue(annotationType);
@@ -1340,6 +1344,9 @@ private static List<AnnotationValue> testGetAnnotationValue(Annotated annotated,
             AnnotationValue av2 = annotated.getDeclaredAnnotationValue(annotationType);
             assertEquals(av, av2);
 
+            av2 = allAnnotationValues.get(annotationType);
+            assertAnnotationsEquals(a, av2);
+
             Map<ResolvedJavaType, AnnotationValue> annotationValues = annotated.getDeclaredAnnotationValues(annotationType, suppressWarningsType, suppressWarningsType);
             assertEquals(1, annotationValues.size());