added support for annotation member default values

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,                "([BILjava/lang/Class;Ljdk/internal/reflect/ConstantPool;)[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

@@ -3014,8 +3014,9 @@ C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, ARGUMENT_PAI
   return JNIHandles::make_local(THREAD, reflected);
 C2V_END
 
-static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, AnnotationArray* annotations_array, jint category,
-                                              JavaThread* THREAD, JVMCI_TRAPS) {
+static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, AnnotationArray* annotations_array,
+                                                jint category, Klass* memberType,
+                                                JavaThread* THREAD, JVMCI_TRAPS) {
   // Get a ConstantPool object for annotation parsing
   Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
   reflect_ConstantPool::set_cp(jcp(), holder->constants());
@@ -3031,6 +3032,10 @@ 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);
+  Handle memberTypeMirror;
+  if (memberType != nullptr) {
+    memberTypeMirror = Handle(THREAD, memberType->java_mirror());
+  }
 
   // invoke VMSupport.encodeAnnotations
   JavaValue result(T_OBJECT);
@@ -3039,6 +3044,7 @@ static jbyteArray get_encoded_annotation_values(InstanceKlass* holder, Annotatio
   args.push_int(category);
   args.push_oop(Handle(THREAD, holder->java_mirror()));
   args.push_oop(jcp);
+  args.push_oop(memberTypeMirror);
   Symbol* signature = vmSymbols::encodeAnnotations_signature();
   JavaCalls::call_static(&result,
                          vm_support,
@@ -3078,23 +3084,27 @@ C2V_VMENTRY_NULL(jbyteArray, getEncodedClassAnnotationValues, (JNIEnv* env, jobj
     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
                   err_msg("%d", category));
   }
-  return get_encoded_annotation_values(holder, raw_annotations, category, THREAD, JVMCIENV);
+  return get_encoded_annotation_values(holder, raw_annotations, category, nullptr, THREAD, JVMCIENV);
 C2V_END
 
-C2V_VMENTRY_NULL(jbyteArray, getEncodedExecutableAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(method), jint category))
+C2V_VMENTRY_NULL(jbyteArray, getEncodedExecutableAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(method), ARGUMENT_PAIR(memberTypeKlass), jint category))
   CompilerThreadCanCallJava canCallJava(thread, true); // Requires Java support
   methodHandle method(THREAD, UNPACK_PAIR(Method, method));
   AnnotationArray* raw_annotations;
+  Klass* memberType = nullptr;
   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 if (category == CompilerToVM::ANNOTATION_MEMBER_VALUE) {
+    raw_annotations = method->annotation_default();
+    memberType = UNPACK_PAIR(Klass, memberTypeKlass);
   } else {
     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), err_msg("%d", category));
   }
-  return get_encoded_annotation_values(method->method_holder(), raw_annotations, category, THREAD, JVMCIENV);
+  return get_encoded_annotation_values(method->method_holder(), raw_annotations, category, memberType, THREAD, JVMCIENV);
 C2V_END
 
 C2V_VMENTRY_NULL(jbyteArray, getEncodedFieldAnnotationValues, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint index, jint category))
@@ -3110,7 +3120,7 @@ C2V_VMENTRY_NULL(jbyteArray, getEncodedFieldAnnotationValues, (JNIEnv* env, jobj
     THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
                   err_msg("%d", category));
   }
-  return get_encoded_annotation_values(holder, raw_annotations, category, THREAD, JVMCIENV);
+  return get_encoded_annotation_values(holder, raw_annotations, category, nullptr, THREAD, JVMCIENV);
 C2V_END
 
 C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
@@ -3455,7 +3465,7 @@ JNINativeMethod CompilerToVM::methods[] = {
   {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 "I)[B",                                                              FN_PTR(getEncodedClassAnnotationValues)},
-  {CC "getEncodedExecutableAnnotationValues",         CC "(" HS_METHOD2 "I)[B",                                                             FN_PTR(getEncodedExecutableAnnotationValues)},
+  {CC "getEncodedExecutableAnnotationValues",         CC "(" HS_METHOD2 HS_KLASS2 "I)[B",                                                   FN_PTR(getEncodedExecutableAnnotationValues)},
   {CC "getEncodedFieldAnnotationValues",              CC "(" HS_KLASS2 "II)[B",                                                             FN_PTR(getEncodedFieldAnnotationValues)},
   {CC "getFailedSpeculations",                        CC "(J[[B)[[B",                                                                       FN_PTR(getFailedSpeculations)},
   {CC "getFailedSpeculationsAddress",                 CC "(" HS_METHOD2 ")J",                                                               FN_PTR(getFailedSpeculationsAddress)},

src/hotspot/share/jvmci/jvmciCompilerToVM.hpp

@@ -39,6 +39,7 @@ class CompilerToVM {
    static const int DECLARED_ANNOTATIONS = 0;
    static const int PARAMETER_ANNOTATIONS = 1;
    static const int TYPE_ANNOTATIONS = 2;
+   static const int ANNOTATION_MEMBER_VALUE = 3;
 
   class Data {
     friend class JVMCIVMStructs;

src/hotspot/share/jvmci/jvmciJavaClasses.cpp

@@ -564,7 +564,7 @@ static void register_natives_for_class(JNIEnv* env, jclass clazz, const char* na
 
 void JNIJVMCI::register_natives(JNIEnv* env) {
   if (env != JavaThread::current()->jni_environment()) {
-    JNINativeMethod CompilerToVM_nmethods[] = {{ CC"registerNatives", CC"(III)V", FN_PTR(JVM_RegisterJVMCINatives) }};
+    JNINativeMethod CompilerToVM_nmethods[] = {{ CC"registerNatives", CC"()V", FN_PTR(JVM_RegisterJVMCINatives) }};
     JNINativeMethod JVMCI_nmethods[] = {{ CC"initializeRuntime", CC"()Ljdk/vm/ci/runtime/JVMCIRuntime;", FN_PTR(JVM_GetJVMCIRuntime) }};
     JNINativeMethod Services_nmethods[] = {{ CC"readSystemPropertiesInfo", CC"([I)J", FN_PTR(JVM_ReadSystemPropertiesInfo) }};
 

src/hotspot/share/jvmci/jvmciJavaClasses.hpp

@@ -233,6 +233,10 @@
   start_class(VMSupport, jdk_internal_vm_VMSupport)                                                           \
     jvmci_method(CallStaticIntMethod, GetStaticMethodID, call_static, int, VMSupport, encodeThrowable, encodeThrowable_signature) \
     jvmci_method(CallStaticVoidMethod, GetStaticMethodID, call_static, void, VMSupport, decodeAndThrowThrowable, decodeAndThrowThrowable_signature) \
+    static_int_field(VMSupport, DECLARED_ANNOTATIONS)                                                         \
+    static_int_field(VMSupport, PARAMETER_ANNOTATIONS)                                                        \
+    static_int_field(VMSupport, TYPE_ANNOTATIONS)                                                             \
+    static_int_field(VMSupport, ANNOTATION_MEMBER_VALUE)                                                      \
   end_class                                                                                                   \
   start_class(ArrayIndexOutOfBoundsException, java_lang_ArrayIndexOutOfBoundsException)                       \
     jvmci_constructor(ArrayIndexOutOfBoundsException, "(Ljava/lang/String;)V")                                \

src/hotspot/share/jvmci/jvmciRuntime.cpp

@@ -1510,15 +1510,22 @@ JVMCIObject JVMCIRuntime::get_HotSpotJVMCIRuntime(JVMCI_TRAPS) {
   return _HotSpotJVMCIRuntime_instance;
 }
 
+#ifdef ASSERT
+static void assert_equals(const char* desc, int expect, int actual) {
+  assert(expect == actual, "%s: %d != %d", desc, expect, actual);
+
+}
+#endif
+
 // 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,
-                                                jint declaredAnnotations, jint parameterAnnotations, jint typeAnnotations))
+JVM_ENTRY_NO_ENV(void, JVM_RegisterJVMCINatives(JNIEnv *libjvmciOrHotspotEnv, jclass c2vmClass))
   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);
+  DEBUG_ONLY(assert_equals("DECLARED_ANNOTATIONS", CompilerToVM::DECLARED_ANNOTATIONS, JVMCIENV->get_VMSupport_DECLARED_ANNOTATIONS()));
+  DEBUG_ONLY(assert_equals("PARAMETER_ANNOTATIONS", CompilerToVM::PARAMETER_ANNOTATIONS, JVMCIENV->get_VMSupport_PARAMETER_ANNOTATIONS()));
+  DEBUG_ONLY(assert_equals("TYPE_ANNOTATIONS", CompilerToVM::TYPE_ANNOTATIONS, JVMCIENV->get_VMSupport_TYPE_ANNOTATIONSS()));
+  DEBUG_ONLY(assert_equals("ANNOTATION_MEMBER_VALUE", CompilerToVM::ANNOTATION_MEMBER_VALUE, JVMCIENV->get_VMSupport_ANNOTATION_MEMBER_VALUE()));
 
   if (!EnableJVMCI) {
     JVMCI_THROW_MSG(InternalError, JVMCI_NOT_ENABLED_ERROR_MESSAGE);

src/hotspot/share/jvmci/vmStructs_jvmci.cpp

@@ -710,6 +710,7 @@
   declare_constant(ConstMethodFlags::_misc_has_exception_table)           \
   declare_constant(ConstMethodFlags::_misc_has_method_annotations)        \
   declare_constant(ConstMethodFlags::_misc_has_parameter_annotations)     \
+  declare_constant(ConstMethodFlags::_misc_has_default_annotations)       \
   declare_constant(ConstMethodFlags::_misc_caller_sensitive)              \
   declare_constant(ConstMethodFlags::_misc_is_hidden)                     \
   declare_constant(ConstMethodFlags::_misc_intrinsic_candidate)           \

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, jint declaredAnnotations, jint parameterAnnotations, jint typeAnnotations);
+  void     JNICALL JVM_RegisterJVMCINatives(JNIEnv *env, jclass compilerToVMClass);
 #endif
 }