added JVMCI support for parameter annotations

Author: dougxc

src/hotspot/share/classfile/vmSymbols.hpp

@@ -706,7 +706,7 @@ class SerializeClosure;
   template(encodeThrowable_signature,                  "(Ljava/lang/Throwable;JI)I")                              \
   template(decodeAndThrowThrowable_name,               "decodeAndThrowThrowable")                                 \
   template(encodeAnnotations_name,                     "encodeAnnotations")                                       \
-  template(encodeAnnotations_signature,                "([BZLjava/lang/Class;Ljdk/internal/reflect/ConstantPool;[Ljava/lang/Class;)[B")\
+  template(encodeAnnotations_signature,                "([BILjava/lang/Class;Ljdk/internal/reflect/ConstantPool;[Ljava/lang/Class;)[B")\
   template(decodeAndThrowThrowable_signature,          "(IJZZ)V")                                                 \
   template(classRedefinedCount_name,                   "classRedefinedCount")                                     \
   template(classLoader_name,                           "classLoader")                                             \

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -3015,7 +3015,7 @@ C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, ARGUMENT_PAI
 C2V_END
 
 static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, AnnotationArray* annotations_array,
-                                              jboolean is_type_annotations,
+                                              jint category,
                                               jint filter_length, jlong filter_klass_pointers,
                                               JavaThread* THREAD, JVMCI_TRAPS) {
   // Get a ConstantPool object for annotation parsing
@@ -3050,7 +3050,7 @@ static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, Annotatio
   JavaValue result(T_OBJECT);
   JavaCallArguments args;
   args.push_oop(annotations);
-  args.push_int(is_type_annotations);
+  args.push_int(category);
   args.push_oop(Handle(THREAD, holder->java_mirror()));
   args.push_oop(jcp);
   args.push_oop(filter_classes);
@@ -3081,29 +3081,54 @@ static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, Annotatio
   return JVMCIENV->get_jbyteArray(ba_dest);
 }
 
-C2V_VMENTRY_NULL(jbyteArray, getEncodedClassAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jboolean is_type_annotations,
+C2V_VMENTRY_NULL(jbyteArray, getEncodedClassAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint category,
                  jobject filter, jint filter_length, jlong filter_klass_pointers))
   CompilerThreadCanCallJava canCallJava(thread, true); // Requires Java support
   InstanceKlass* holder = InstanceKlass::cast(UNPACK_PAIR(Klass, klass));
-  AnnotationArray* raw_annotations = is_type_annotations ? holder->class_type_annotations() : holder->class_annotations();
-  return get_encoded_annotation_values(holder, raw_annotations, is_type_annotations, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
+  AnnotationArray* raw_annotations;
+  if (category == CompilerToVM::DECLARED_ANNOTATIONS) {
+    raw_annotations = holder->class_annotations();
+  } else if (category == CompilerToVM::TYPE_ANNOTATIONS) {
+    raw_annotations = holder->class_type_annotations();
+  } else {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
+                  err_msg("%d", category));
+  }
+  return get_encoded_annotation_values(holder, raw_annotations, category, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
 C2V_END
 
-C2V_VMENTRY_NULL(jbyteArray, getEncodedExecutableAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(method), jboolean is_type_annotations,
+C2V_VMENTRY_NULL(jbyteArray, getEncodedExecutableAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(method), jint category,
                  jobject filter, jint filter_length, jlong filter_klass_pointers))
   CompilerThreadCanCallJava canCallJava(thread, true); // Requires Java support
   methodHandle method(THREAD, UNPACK_PAIR(Method, method));
-  AnnotationArray* raw_annotations = is_type_annotations ? method->type_annotations() : method->annotations();
-  return get_encoded_annotation_values(method->method_holder(), raw_annotations, is_type_annotations, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
+  AnnotationArray* raw_annotations;
+  if (category == CompilerToVM::DECLARED_ANNOTATIONS) {
+    raw_annotations = method->annotations();
+  } else if (category == CompilerToVM::PARAMETER_ANNOTATIONS) {
+    raw_annotations = method->parameter_annotations();
+  } else if (category == CompilerToVM::TYPE_ANNOTATIONS) {
+    raw_annotations = method->type_annotations();
+  } else {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), err_msg("%d", category));
+  }
+  return get_encoded_annotation_values(method->method_holder(), raw_annotations, category, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
 C2V_END
 
-C2V_VMENTRY_NULL(jbyteArray, getEncodedFieldAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint index, jboolean is_type_annotations,
+C2V_VMENTRY_NULL(jbyteArray, getEncodedFieldAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint index, jint category,
                  jobject filter, jint filter_length, jlong filter_klass_pointers))
   CompilerThreadCanCallJava canCallJava(thread, true); // Requires Java support
   InstanceKlass* holder = check_field(InstanceKlass::cast(UNPACK_PAIR(Klass, klass)), index, JVMCI_CHECK_NULL);
   fieldDescriptor fd(holder, index);
-  AnnotationArray* raw_annotations = is_type_annotations ? fd.type_annotations() : fd.annotations();
-  return get_encoded_annotation_values(holder, raw_annotations, is_type_annotations, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
+  AnnotationArray* raw_annotations;
+  if (category == CompilerToVM::DECLARED_ANNOTATIONS) {
+    raw_annotations = fd.annotations();
+  } else if (category == CompilerToVM::TYPE_ANNOTATIONS) {
+    raw_annotations = fd.type_annotations();
+  } else {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
+                  err_msg("%d", category));
+  }
+  return get_encoded_annotation_values(holder, raw_annotations, category, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
 C2V_END
 
 C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
@@ -3447,9 +3472,9 @@ JNINativeMethod CompilerToVM::methods[] = {
   {CC "getCode",                                      CC "(" HS_INSTALLED_CODE ")[B",                                                       FN_PTR(getCode)},
   {CC "asReflectionExecutable",                       CC "(" HS_METHOD2 ")" REFLECTION_EXECUTABLE,                                          FN_PTR(asReflectionExecutable)},
   {CC "asReflectionField",                            CC "(" HS_KLASS2 "I)" REFLECTION_FIELD,                                               FN_PTR(asReflectionField)},
-  {CC "getEncodedClassAnnotationValues",              CC "(" HS_KLASS2 "Z" OBJECT "IJ)[B",                                                  FN_PTR(getEncodedClassAnnotationValues)},
-  {CC "getEncodedExecutableAnnotationValues",         CC "(" HS_METHOD2 "Z" OBJECT "IJ)[B",                                                 FN_PTR(getEncodedExecutableAnnotationValues)},
-  {CC "getEncodedFieldAnnotationValues",              CC "(" HS_KLASS2 "IZ" OBJECT "IJ)[B",                                                 FN_PTR(getEncodedFieldAnnotationValues)},
+  {CC "getEncodedClassAnnotationValues",              CC "(" HS_KLASS2 "I" OBJECT "IJ)[B",                                                  FN_PTR(getEncodedClassAnnotationValues)},
+  {CC "getEncodedExecutableAnnotationValues",         CC "(" HS_METHOD2 "I" OBJECT "IJ)[B",                                                 FN_PTR(getEncodedExecutableAnnotationValues)},
+  {CC "getEncodedFieldAnnotationValues",              CC "(" HS_KLASS2 "II" OBJECT "IJ)[B",                                                 FN_PTR(getEncodedFieldAnnotationValues)},
   {CC "getFailedSpeculations",                        CC "(J[[B)[[B",                                                                       FN_PTR(getFailedSpeculations)},
   {CC "getFailedSpeculationsAddress",                 CC "(" HS_METHOD2 ")J",                                                               FN_PTR(getFailedSpeculationsAddress)},
   {CC "releaseFailedSpeculations",                    CC "(J)V",                                                                            FN_PTR(releaseFailedSpeculations)},

src/hotspot/share/jvmci/jvmciCompilerToVM.hpp

@@ -35,6 +35,11 @@ class JVMCIObjectArray;
 
 class CompilerToVM {
  public:
+   // Keep in sync with constants in VMSupport.java
+   static const int DECLARED_ANNOTATIONS = 0;
+   static const int PARAMETER_ANNOTATIONS = 1;
+   static const int TYPE_ANNOTATIONS = 2;
+
   class Data {
     friend class JVMCIVMStructs;
 

src/hotspot/share/jvmci/jvmciJavaClasses.cpp

@@ -403,7 +403,7 @@ void JNIJVMCI::initialize_field_id(JNIEnv* env, jfieldID &fieldid, jclass clazz,
   GET_JNI_CONSTRUCTOR(className, signature)
 
 extern "C" {
-  void     JNICALL JVM_RegisterJVMCINatives(JNIEnv *env, jclass compilerToVMClass);
+  void     JNICALL JVM_RegisterJVMCINatives(JNIEnv *env, jclass compilerToVMClass, jint declaredAnnotations, jint parameterAnnotations, jint typeAnnotations);
   jobject  JNICALL JVM_GetJVMCIRuntime(JNIEnv *env, jclass c);
   jlong    JNICALL JVM_ReadSystemPropertiesInfo(JNIEnv *env, jclass c, jintArray offsets_handle);
 }

src/hotspot/share/jvmci/jvmciRuntime.cpp

@@ -1512,9 +1512,14 @@ JVMCIObject JVMCIRuntime::get_HotSpotJVMCIRuntime(JVMCI_TRAPS) {
 
 // Implementation of CompilerToVM.registerNatives()
 // When called from libjvmci, `libjvmciOrHotspotEnv` is a libjvmci env so use JVM_ENTRY_NO_ENV.
-JVM_ENTRY_NO_ENV(void, JVM_RegisterJVMCINatives(JNIEnv *libjvmciOrHotspotEnv, jclass c2vmClass))
+JVM_ENTRY_NO_ENV(void, JVM_RegisterJVMCINatives(JNIEnv *libjvmciOrHotspotEnv, jclass c2vmClass,
+                                                jint declaredAnnotations, jint parameterAnnotations, jint typeAnnotations))
   JVMCIENV_FROM_JNI(thread, libjvmciOrHotspotEnv);
 
+  assert(CompilerToVM::DECLARED_ANNOTATIONS == declaredAnnotations, "%d != %d", CompilerToVM::DECLARED_ANNOTATIONS, declaredAnnotations);
+  assert(CompilerToVM::PARAMETER_ANNOTATIONS == parameterAnnotations, "%d != %d", CompilerToVM::PARAMETER_ANNOTATIONS, parameterAnnotations);
+  assert(CompilerToVM::TYPE_ANNOTATIONS == typeAnnotations, "%d != %d", CompilerToVM::TYPE_ANNOTATIONS, typeAnnotations);
+
   if (!EnableJVMCI) {
     JVMCI_THROW_MSG(InternalError, JVMCI_NOT_ENABLED_ERROR_MESSAGE);
   }

src/hotspot/share/prims/nativeLookup.cpp

@@ -210,7 +210,7 @@ extern "C" {
 #if INCLUDE_JVMCI
   jobject  JNICALL JVM_GetJVMCIRuntime(JNIEnv *env, jclass c);
   jlong    JNICALL JVM_ReadSystemPropertiesInfo(JNIEnv *env, jclass c, jintArray offsets);
-  void     JNICALL JVM_RegisterJVMCINatives(JNIEnv *env, jclass compilerToVMClass);
+  void     JNICALL JVM_RegisterJVMCINatives(JNIEnv *env, jclass compilerToVMClass, jint declaredAnnotations, jint parameterAnnotations, jint typeAnnotations);
 #endif
 }
 

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

@@ -186,31 +186,58 @@ public static int encodeThrowable(Throwable throwable, long buffer, int bufferSi
     }
 
     /**
-     * Parses {@code rawAnnotations} into a list of {@link Annotation}s (isTypeAnnotations == false)
-     * or {@link TypeAnnotation}s (isTypeAnnotations == true) and then
-     * serializes them to a byte array with {@link #encodeAnnotations(Collection)} or
-     * {@link #encodeTypeAnnotations(TypeAnnotation[])}.
+     * Denotes a byte array that is parsed into a {@code Annotations[]}.
+     */
+    public static final int DECLARED_ANNOTATIONS = 0;
+
+    /**
+     * Denotes a byte array that is parsed into a {@code Annotations[][]}.
+     */
+    public static final int PARAMETER_ANNOTATIONS = 1;
+
+    /**
+     * Denotes a byte array that is parsed into a {@code TypeAnnotations[]}.
+     */
+    public static final int TYPE_ANNOTATIONS = 2;
+
+    /**
+     * Parses {@code rawAnnotations} according to {@code category} and returns the parse
+     * result encoded as a byte array.
+     * <pre>
+     *     category              | parse result type   | decoding method
+     *     ----------------------|--------------------|------------------------------------------
+     *     DECLARED_ANNOTATIONS  | Annotation[]        | {@link #decodeAnnotations(byte[], AnnotationDecoder)}
+     *     PARAMETER_ANNOTATIONS | Annotation[][]      | {@link #decodeAnnotations(byte[], AnnotationDecoder)}
+     *     TYPE_ANNOTATIONS      | TypeAnnotation[]    | {@link #decodeTypeAnnotations(byte[], AnnotationDecoder)}
+     * </pre>
+     *
+     * @param category {@link #DECLARED_ANNOTATIONS}, {@link #PARAMETER_ANNOTATIONS} or {@link #TYPE_ANNOTATIONS}
      */
     public static byte[] encodeAnnotations(byte[] rawAnnotations,
-                                           boolean isTypeAnnotations,
+                                           int category,
                                            Class<?> declaringClass,
                                            ConstantPool cp,
                                            Class<? extends Annotation>[] selectAnnotationClasses) {
-        if (!isTypeAnnotations && 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 switch (category) {
+            case DECLARED_ANNOTATIONS -> {
+                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");
+                        }
+                    }
                 }
+                yield encodeAnnotations(AnnotationParser.parseSelectAnnotations(rawAnnotations, cp, declaringClass, false, selectAnnotationClasses).values());
             }
-        }
-        if (isTypeAnnotations) {
-            return encodeTypeAnnotations(TypeAnnotationParser.parseTypeAnnotations(rawAnnotations, cp, null, false, declaringClass));
-        } else {
-            return encodeAnnotations(AnnotationParser.parseSelectAnnotations(rawAnnotations, cp, declaringClass, false, selectAnnotationClasses).values());
-        }
+            case PARAMETER_ANNOTATIONS ->
+                    encodeParameterAnnotations(AnnotationParser.parseParameterAnnotations(rawAnnotations, cp, declaringClass));
+            case TYPE_ANNOTATIONS ->
+                    encodeTypeAnnotations(TypeAnnotationParser.parseTypeAnnotations(rawAnnotations, cp, null, false, declaringClass));
+            default -> throw new IllegalArgumentException("illegal category: " + category);
+        };
     }
 
     /**
@@ -231,6 +258,27 @@ public static byte[] encodeAnnotations(Collection<Annotation> annotations) {
         }
     }
 
+    /**
+     * Encodes parameter annotations to a byte array. The byte array can be decoded with {@link #decodeParameterAnnotations(byte[], AnnotationDecoder)}.
+     */
+    public static byte[] encodeParameterAnnotations(Annotation[][] parameterAnnotations) {
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream(128);
+            try (DataOutputStream dos = new DataOutputStream(baos)) {
+                writeLength(dos, parameterAnnotations.length);
+                for (Annotation[] annotations : parameterAnnotations) {
+                    writeLength(dos, annotations.length);
+                    for (Annotation a : annotations) {
+                        encodeAnnotation(dos, a);
+                    }
+                }
+            }
+            return baos.toByteArray();
+        } catch (Exception e) {
+            throw new InternalError(e);
+        }
+    }
+
     private static void encodeAnnotation(DataOutputStream dos, Annotation a) throws Exception {
         Class<? extends Annotation> type = a.annotationType();
         Map<String, Object> values = AnnotationSupport.memberValues(a);
@@ -433,10 +481,9 @@ private static void encodeTypeAnnotation(DataOutputStream dos, TypeAnnotation ta
         dos.writeInt(ti.getCount());
         dos.writeInt(ti.getSecondaryIndex());
         TypeAnnotation.LocationInfo li = ta.getLocationInfo();
-        int depth = li.getDepth();
-        dos.writeInt(depth);
-        for (int i = 0; i < depth; i++) {
-            TypeAnnotation.LocationInfo.Location loc = li.getLocationAt(i);
+        List<TypeAnnotation.LocationInfo.Location> locs = li.getLocations();
+        dos.writeInt(locs.size());
+        for (TypeAnnotation.LocationInfo.Location loc : locs) {
             dos.write(loc.tag);
             dos.writeShort(loc.index);
         }
@@ -528,12 +575,40 @@ public static <T, A, TA, E, EA, MT, ETM> List<A> decodeAnnotations(byte[] encode
         }
     }
 
+    /**
+     * Decodes parameter annotations serialized in {@code encoded} to objects.
+     *
+     * @param <T> type to which a type name is resolved
+     * @param <A> type of the object representing a decoded annotation
+     * @param <E> type of the object representing a decoded enum constant
+     * @param <MT> type of the object representing a missing type
+     * @param <ETM> type of the object representing a decoded element type mismatch
+     * @return an immutable list of immutable lists of {@code A} objects
+     */
+    @SuppressWarnings("unchecked")
+    public static <T, A, TA, E, EA, MT, ETM> List<List<A>> decodeParameterAnnotations(byte[] encoded, AnnotationDecoder<T, A, TA, E, EA, MT, ETM> decoder) {
+        try {
+            ByteArrayInputStream bais = new ByteArrayInputStream(encoded);
+            DataInputStream dis = new DataInputStream(bais);
+            return (List<List<A>>) readArray(dis, () -> decodeAnnotations(dis, decoder));
+        } catch (Exception e) {
+            throw new InternalError(e);
+        }
+    }
+    @SuppressWarnings({"unchecked"})
+    private static <T, A, TA, E, EA, MT, ETM> List<A> decodeAnnotations(DataInputStream dis, AnnotationDecoder<T, A, TA, E, EA, MT, ETM> decoder) throws IOException {
+        return (List<A>) readArray(dis, () -> decodeAnnotation(dis, decoder));
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static final Map.Entry[] NO_ELEMENTS = {};
+
     @SuppressWarnings({"rawtypes", "unchecked"})
     private static <T, A, TA, E, EA, MT, ETM> A decodeAnnotation(DataInputStream dis, AnnotationDecoder<T, A, TA, E, EA, MT, ETM> decoder) throws IOException {
         String typeName = dis.readUTF();
         T type = decoder.resolveType(typeName);
         int n = readLength(dis);
-        Map.Entry[] elements = new Map.Entry[n];
+        Map.Entry[] elements = n == 0 ? NO_ELEMENTS : new Map.Entry[n];
         for (int i = 0; i < n; i++) {
             String name = dis.readUTF();
             byte tag = dis.readByte();
@@ -681,7 +756,7 @@ private static <T, A, TA, E, EA, MT, ETM> TA decodeTypeAnnotation(DataInputStrea
             for (int i = 0; i != depth; i++) {
                 locs[i] = new TypeAnnotation.LocationInfo.Location(dis.readByte(), dis.readShort());
             }
-            li = new TypeAnnotation.LocationInfo(depth, locs);
+            li = new TypeAnnotation.LocationInfo(locs);
         }
         A annotation = decodeAnnotation(dis, decoder);
         return decoder.newTypeAnnotation(ti, li, annotation);