8303431: [JVMCI] libgraal annotation API

Reviewed-by: kvn, never, darcy

Author: Doug Simon

src/hotspot/share/classfile/vmSymbols.hpp

@@ -756,6 +756,8 @@
   template(encodeThrowable_name,                       "encodeThrowable")                                         \
   template(encodeThrowable_signature,                  "(Ljava/lang/Throwable;JI)I")                              \
   template(decodeAndThrowThrowable_name,               "decodeAndThrowThrowable")                                 \
+  template(encodeAnnotations_name,                     "encodeAnnotations")                                       \
+  template(encodeAnnotations_signature,                "([BLjava/lang/Class;Ljdk/internal/reflect/ConstantPool;Z[Ljava/lang/Class;)[B")\
   template(decodeAndThrowThrowable_signature,          "(JZ)V")                                                   \
   template(classRedefinedCount_name,                   "classRedefinedCount")                                     \
   template(classLoader_name,                           "classLoader")                                             \

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -2672,9 +2672,7 @@ C2V_VMENTRY_NULL(jobject, asReflectionExecutable, (JNIEnv* env, jobject, ARGUMEN
   return JNIHandles::make_local(THREAD, executable);
 }
 
-C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint index))
-  requireInHotSpot("asReflectionField", JVMCI_CHECK_NULL);
-  Klass* klass = UNPACK_PAIR(Klass, klass);
+static InstanceKlass* check_field(Klass* klass, jint index, JVMCI_TRAPS) {
   if (!klass->is_instance_klass()) {
     JVMCI_THROW_MSG_NULL(IllegalArgumentException,
         err_msg("Expected non-primitive type, got %s", klass->external_name()));
@@ -2684,11 +2682,100 @@ C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, ARGUMENT_PAI
     JVMCI_THROW_MSG_NULL(IllegalArgumentException,
         err_msg("Field index %d out of bounds for %s", index, klass->external_name()));
   }
+  return iklass;
+}
+
+C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint index))
+  requireInHotSpot("asReflectionField", JVMCI_CHECK_NULL);
+  Klass* klass = UNPACK_PAIR(Klass, klass);
+  InstanceKlass* iklass = check_field(klass, index, JVMCIENV);
   fieldDescriptor fd(iklass, index);
   oop reflected = Reflection::new_field(&fd, CHECK_NULL);
   return JNIHandles::make_local(THREAD, reflected);
 }
 
+static jbyteArray get_encoded_annotation_data(InstanceKlass* holder, AnnotationArray* annotations_array, bool for_class,
+                                              jint filter_length, jlong filter_klass_pointers,
+                                              JavaThread* THREAD, JVMCIEnv* JVMCIENV) {
+  // Get a ConstantPool object for annotation parsing
+  Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
+  reflect_ConstantPool::set_cp(jcp(), holder->constants());
+
+  // load VMSupport
+  Symbol* klass = vmSymbols::jdk_internal_vm_VMSupport();
+  Klass* k = SystemDictionary::resolve_or_fail(klass, true, CHECK_NULL);
+
+  InstanceKlass* vm_support = InstanceKlass::cast(k);
+  if (vm_support->should_be_initialized()) {
+    vm_support->initialize(CHECK_NULL);
+  }
+
+  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_objectArray(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());
+  }
+
+  // invoke VMSupport.encodeAnnotations
+  JavaValue result(T_OBJECT);
+  JavaCallArguments args;
+  args.push_oop(annotations);
+  args.push_oop(Handle(THREAD, holder->java_mirror()));
+  args.push_oop(jcp);
+  args.push_int(for_class);
+  args.push_oop(filter_classes);
+  Symbol* signature = vmSymbols::encodeAnnotations_signature();
+  JavaCalls::call_static(&result,
+                         vm_support,
+                         vmSymbols::encodeAnnotations_name(),
+                         signature,
+                         &args,
+                         CHECK_NULL);
+
+  oop res = result.get_oop();
+  if (JVMCIENV->is_hotspot()) {
+    return (jbyteArray) JNIHandles::make_local(THREAD, res);
+  }
+
+  typeArrayOop ba = typeArrayOop(res);
+  int ba_len = ba->length();
+  jbyte* ba_buf = NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(THREAD, jbyte, ba_len);
+  if (ba_buf == nullptr) {
+    JVMCI_THROW_MSG_NULL(InternalError,
+              err_msg("could not allocate %d bytes", ba_len));
+
+  }
+  memcpy(ba_buf, ba->byte_at_addr(0), ba_len);
+  JVMCIPrimitiveArray ba_dest = JVMCIENV->new_byteArray(ba_len, JVMCI_CHECK_NULL);
+  JVMCIENV->copy_bytes_from(ba_buf, ba_dest, 0, ba_len);
+  return JVMCIENV->get_jbyteArray(ba_dest);
+}
+
+C2V_VMENTRY_NULL(jbyteArray, getEncodedClassAnnotationData, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass),
+                 jobject filter, jint filter_length, jlong filter_klass_pointers))
+  InstanceKlass* holder = InstanceKlass::cast(UNPACK_PAIR(Klass, klass));
+  return get_encoded_annotation_data(holder, holder->class_annotations(), true, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
+C2V_END
+
+C2V_VMENTRY_NULL(jbyteArray, getEncodedExecutableAnnotationData, (JNIEnv* env, jobject, ARGUMENT_PAIR(method),
+                 jobject filter, jint filter_length, jlong filter_klass_pointers))
+  methodHandle method(THREAD, UNPACK_PAIR(Method, method));
+  return get_encoded_annotation_data(method->method_holder(), method->annotations(), false, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
+C2V_END
+
+C2V_VMENTRY_NULL(jbyteArray, getEncodedFieldAnnotationData, (JNIEnv* env, jobject, ARGUMENT_PAIR(klass), jint index,
+                 jobject filter, jint filter_length, jlong filter_klass_pointers))
+  InstanceKlass* holder = check_field(InstanceKlass::cast(UNPACK_PAIR(Klass, klass)), index, JVMCIENV);
+  fieldDescriptor fd(holder, index);
+  return get_encoded_annotation_data(holder, fd.annotations(), false, filter_length, filter_klass_pointers, THREAD, JVMCIENV);
+C2V_END
+
 C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
   FailedSpeculation* head = *((FailedSpeculation**)(address) failed_speculations_address);
   int result_length = 0;
@@ -2969,6 +3056,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 "getEncodedClassAnnotationData",                CC "(" HS_KLASS2 OBJECT "IJ)[B",                                                      FN_PTR(getEncodedClassAnnotationData)},
+  {CC "getEncodedExecutableAnnotationData",           CC "(" HS_METHOD2 OBJECT "IJ)[B",                                                     FN_PTR(getEncodedExecutableAnnotationData)},
+  {CC "getEncodedFieldAnnotationData",                CC "(" HS_KLASS2 "I" OBJECT "IJ)[B",                                                  FN_PTR(getEncodedFieldAnnotationData)},
   {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/vmStructs_jvmci.cpp

@@ -104,6 +104,7 @@
                                                                                                                                      \
   static_field(Abstract_VM_Version,            _features,                              uint64_t)                                     \
                                                                                                                                      \
+  nonstatic_field(Annotations,                 _class_annotations,                     AnnotationArray*)                             \
   nonstatic_field(Annotations,                 _fields_annotations,                    Array<AnnotationArray*>*)                     \
                                                                                                                                      \
   nonstatic_field(Array<int>,                  _length,                                int)                                          \

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

@@ -259,7 +259,8 @@
         jdk.incubator.concurrent,
         jdk.internal.jvmstat,
         jdk.management,
-        jdk.management.agent;
+        jdk.management.agent,
+        jdk.internal.vm.ci;
     exports jdk.internal.vm.annotation to
         java.instrument,
         jdk.internal.vm.ci,

src/java.base/share/classes/module-info.java

@@ -677,6 +677,13 @@ private void readObject(java.io.ObjectInputStream s)
         UnsafeAccessor.setMemberValues(this, mv);
     }
 
+    /**
+     * Gets an unmodifiable view on the member values.
+     */
+    Map<String, Object> memberValues() {
+        return Collections.unmodifiableMap(memberValues);
+    }
+
     private static class UnsafeAccessor {
         private static final jdk.internal.misc.Unsafe unsafe
                 = jdk.internal.misc.Unsafe.getUnsafe();

src/java.base/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java

@@ -83,14 +83,14 @@ public static Map<Class<? extends Annotation>, Annotation> parseAnnotations(
      * Like {@link #parseAnnotations(byte[], sun.reflect.ConstantPool, Class)}
      * with an additional parameter {@code selectAnnotationClasses} which selects the
      * annotation types to parse (other than selected are quickly skipped).<p>
-     * This method is only used to parse select meta annotations in the construction
+     * This method is used to parse select meta annotations in the construction
      * phase of {@link AnnotationType} instances to prevent infinite recursion.
      *
      * @param selectAnnotationClasses an array of annotation types to select when parsing
      */
     @SafeVarargs
     @SuppressWarnings("varargs") // selectAnnotationClasses is used safely
-    static Map<Class<? extends Annotation>, Annotation> parseSelectAnnotations(
+    public static Map<Class<? extends Annotation>, Annotation> parseSelectAnnotations(
                 byte[] rawAnnotations,
                 ConstantPool constPool,
                 Class<?> container,
@@ -336,6 +336,8 @@ public static Object parseMemberValue(Class<?> memberType,
                                           ByteBuffer buf,
                                           ConstantPool constPool,
                                           Class<?> container) {
+        // Note that VMSupport.encodeAnnotation (used by JVMCI) may need to
+        // be updated if new annotation member types are added.
         Object result = null;
         int tag = buf.get();
         switch(tag) {

src/java.base/share/classes/sun/reflect/annotation/AnnotationParser.java

@@ -281,4 +281,13 @@ private static <A extends Annotation> void checkTypes(A[] annotations,
             }
         }
     }
+
+    /**
+     * Gets an unmodifiable view of {@code a}'s elements.
+     *
+     * @return a map from element names to element values
+     */
+    public static Map<String, Object> memberValues(Annotation a) {
+        return ((AnnotationInvocationHandler) Proxy.getInvocationHandler(a)).memberValues();
+    }
 }

src/java.base/share/classes/sun/reflect/annotation/AnnotationSupport.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.vm.ci.hotspot;
+
+import java.util.Map;
+
+import jdk.internal.vm.VMSupport.AnnotationDecoder;
+import jdk.vm.ci.meta.AnnotationData;
+import jdk.vm.ci.meta.EnumData;
+import jdk.vm.ci.meta.ErrorData;
+import jdk.vm.ci.meta.JavaType;
+import jdk.vm.ci.meta.MetaUtil;
+import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.UnresolvedJavaType;
+
+/**
+ * Implementation of {@link AnnotationDecoder} that resolves type names to {@link JavaType} values
+ * and employs {@link AnnotationData} and {@link EnumData} to represent decoded annotations and enum
+ * constants respectively.
+ */
+final class AnnotationDataDecoder implements AnnotationDecoder<JavaType, AnnotationData, EnumData, ErrorData> {
+
+    static final AnnotationDataDecoder INSTANCE = new AnnotationDataDecoder();
+
+    @Override
+    public JavaType resolveType(String name) {
+        String internalName = MetaUtil.toInternalName(name);
+        return UnresolvedJavaType.create(internalName);
+    }
+
+    @Override
+    public AnnotationData newAnnotation(JavaType type, Map.Entry<String, Object>[] elements) {
+        return new AnnotationData(type, elements);
+    }
+
+    @Override
+    public EnumData newEnumValue(JavaType enumType, String name) {
+        return new EnumData(enumType, name);
+    }
+
+    @Override
+    public ErrorData newErrorValue(String description) {
+        return new ErrorData(description);
+    }
+
+    static ResolvedJavaType[] asArray(ResolvedJavaType type1, ResolvedJavaType type2, ResolvedJavaType... types) {
+        ResolvedJavaType[] filter = new ResolvedJavaType[2 + types.length];
+        filter[0] = type1;
+        filter[1] = type2;
+        System.arraycopy(types, 0, filter, 2, types.length);
+        return filter;
+    }
+}

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

@@ -29,6 +29,7 @@
 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;
@@ -48,6 +49,12 @@
  * 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
  * denote a valid native object.
+ *
+ * Note also that some calls pass a raw VM value to avoid a JNI upcall. For example,
+ * {@link #getBytecode(HotSpotResolvedJavaMethodImpl, long)} needs the raw {@code Method*} value
+ * (stored in {@link HotSpotResolvedJavaMethodImpl#methodHandle}) in the C++ implementation. The
+ * {@link HotSpotResolvedJavaMethodImpl} wrapper is still passed as well as it may be the last
+ * reference keeping the raw value alive.
  */
 final class CompilerToVM {
     /**
@@ -1303,4 +1310,89 @@ void notifyCompilerInliningEvent(int compileId, HotSpotResolvedJavaMethodImpl ca
 
     native void notifyCompilerInliningEvent(int compileId, HotSpotResolvedJavaMethodImpl caller, long callerPointer,
                     HotSpotResolvedJavaMethodImpl callee, long calleePointer, boolean succeeded, String message, int bci);
+
+    /**
+     * Gets the serialized annotation info for {@code type} by calling
+     * {@code VMSupport.encodeAnnotations} in the HotSpot heap.
+     */
+    byte[] getEncodedClassAnnotationData(HotSpotResolvedObjectTypeImpl type, ResolvedJavaType[] filter) {
+        try (KlassPointers a = new KlassPointers(filter)) {
+            return getEncodedClassAnnotationData(type, type.getKlassPointer(),
+                            a.types, a.types.length, a.buffer());
+        }
+    }
+
+    native byte[] getEncodedClassAnnotationData(HotSpotResolvedObjectTypeImpl type, long klassPointer,
+                    Object filter, int filterLength, long filterKlassPointers);
+
+    /**
+     * Gets the serialized annotation info for {@code method} by calling
+     * {@code VMSupport.encodeAnnotations} in the HotSpot heap.
+     */
+    byte[] getEncodedExecutableAnnotationData(HotSpotResolvedJavaMethodImpl method, ResolvedJavaType[] filter) {
+        try (KlassPointers a = new KlassPointers(filter)) {
+            return getEncodedExecutableAnnotationData(method, method.getMethodPointer(),
+                            a.types, a.types.length, a.buffer());
+        }
+    }
+
+    native byte[] getEncodedExecutableAnnotationData(HotSpotResolvedJavaMethodImpl method, long methodPointer,
+                    Object filter, int filterLength, long filterKlassPointers);
+
+    /**
+     * Gets the serialized annotation info for the field denoted by {@code holder} and
+     * {@code fieldIndex} by calling {@code VMSupport.encodeAnnotations} in the HotSpot heap.
+     */
+    byte[] getEncodedFieldAnnotationData(HotSpotResolvedObjectTypeImpl holder, int fieldIndex, ResolvedJavaType[] filter) {
+        try (KlassPointers a = new KlassPointers(filter)) {
+            return getEncodedFieldAnnotationData(holder, holder.getKlassPointer(), fieldIndex,
+                            a.types, a.types.length, a.buffer());
+        }
+    }
+
+    native byte[] getEncodedFieldAnnotationData(HotSpotResolvedObjectTypeImpl holder, long klassPointer, int fieldIndex,
+                    Object filterTypes, int filterLength, long filterKlassPointers);
+
+    /**
+     * Helper for passing {@Klass*} values to native code.
+     */
+    static final class KlassPointers implements AutoCloseable {
+        final ResolvedJavaType[] types;
+        long pointersArray;
+        final Unsafe unsafe = UnsafeAccess.UNSAFE;
+
+        KlassPointers(ResolvedJavaType[] types) {
+            this.types = types;
+        }
+
+        /**
+         * Gets the buffer in which to pass the {@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
+         */
+        long buffer() {
+            int length = types.length;
+            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];
+                    unsafe.putLong(pos, hsType.getKlassPointer());
+                    pos += Long.BYTES;
+                }
+            }
+            return pointersArray;
+        }
+
+        @Override
+        public void close() {
+            if (types.length != 1 && pointersArray != 0) {
+                unsafe.freeMemory(pointersArray);
+                pointersArray = 0;
+            }
+        }
+    }
 }

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

@@ -23,14 +23,17 @@
 package jdk.vm.ci.hotspot;
 
 import static jdk.internal.misc.Unsafe.ADDRESS_SIZE;
+import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
 import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
 
 import java.lang.annotation.Annotation;
+import java.util.Collections;
+import java.util.List;
 
-import jdk.internal.vm.annotation.Stable;
-
+import jdk.internal.vm.VMSupport;
+import jdk.vm.ci.meta.AnnotationData;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.ResolvedJavaType;
@@ -227,4 +230,25 @@ public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
     public JavaConstant getConstantValue() {
         return holder.getFieldInfo(index).getConstantValue(holder);
     }
+
+    @Override
+    public AnnotationData getAnnotationData(ResolvedJavaType annotationType) {
+        if (!hasAnnotations()) {
+            return null;
+        }
+        return getAnnotationData0(annotationType).get(0);
+    }
+
+    @Override
+    public List<AnnotationData> getAnnotationData(ResolvedJavaType type1, ResolvedJavaType type2, ResolvedJavaType... types) {
+        if (!hasAnnotations()) {
+            return Collections.emptyList();
+        }
+        return getAnnotationData0(AnnotationDataDecoder.asArray(type1, type2, types));
+    }
+
+    private List<AnnotationData> getAnnotationData0(ResolvedJavaType... filter) {
+        byte[] encoded = compilerToVM().getEncodedFieldAnnotationData(holder, index, filter);
+        return VMSupport.decodeAnnotations(encoded, AnnotationDataDecoder.INSTANCE);
+    }
 }

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

@@ -35,10 +35,14 @@
 import java.lang.reflect.Executable;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.List;
 import java.util.Objects;
 
+import jdk.internal.vm.VMSupport;
 import jdk.vm.ci.common.JVMCIError;
 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.Option;
+import jdk.vm.ci.meta.AnnotationData;
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.DefaultProfilingInfo;
@@ -523,28 +527,35 @@ public Annotation[][] getParameterAnnotations() {
 
     @Override
     public Annotation[] getAnnotations() {
-        if ((getConstMethodFlags() & config().constMethodHasMethodAnnotations) == 0 || isClassInitializer()) {
+        if (!hasAnnotations()) {
             return new Annotation[0];
         }
         return runtime().reflection.getMethodAnnotations(this);
     }
 
     @Override
     public Annotation[] getDeclaredAnnotations() {
-        if ((getConstMethodFlags() & config().constMethodHasMethodAnnotations) == 0 || isClassInitializer()) {
+        if (!hasAnnotations()) {
             return new Annotation[0];
         }
         return runtime().reflection.getMethodDeclaredAnnotations(this);
     }
 
     @Override
     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        if ((getConstMethodFlags() & config().constMethodHasMethodAnnotations) == 0 || isClassInitializer()) {
+        if (!hasAnnotations()) {
             return null;
         }
         return runtime().reflection.getMethodAnnotation(this, annotationClass);
     }
 
+    /**
+     * Returns whether this method has annotations.
+     */
+    private boolean hasAnnotations() {
+        return (getConstMethodFlags() & config().constMethodHasMethodAnnotations) != 0 && !isClassInitializer();
+    }
+
     @Override
     public boolean isBridge() {
         return (BRIDGE & getModifiers()) != 0;
@@ -752,4 +763,25 @@ public boolean hasCodeAtLevel(int entryBCI, int level) {
     public int methodIdnum() {
         return UNSAFE.getChar(getConstMethod() + config().constMethodMethodIdnumOffset);
     }
+
+    @Override
+    public AnnotationData getAnnotationData(ResolvedJavaType type) {
+        if (!hasAnnotations()) {
+            return null;
+        }
+        return getAnnotationData0(type).get(0);
+    }
+
+    @Override
+    public List<AnnotationData> getAnnotationData(ResolvedJavaType type1, ResolvedJavaType type2, ResolvedJavaType... types) {
+        if (!hasAnnotations()) {
+            return Collections.emptyList();
+        }
+        return getAnnotationData0(AnnotationDataDecoder.asArray(type1, type2, types));
+    }
+
+    private List<AnnotationData> getAnnotationData0(ResolvedJavaType... filter) {
+        byte[] encoded = compilerToVM().getEncodedExecutableAnnotationData(this, filter);
+        return VMSupport.decodeAnnotations(encoded, AnnotationDataDecoder.INSTANCE);
+    }
 }

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

@@ -35,10 +35,14 @@
 import java.lang.reflect.Modifier;
 import java.nio.ByteOrder;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.List;
 
+import jdk.internal.vm.VMSupport;
 import jdk.vm.ci.common.JVMCIError;
+import jdk.vm.ci.meta.AnnotationData;
 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
 import jdk.vm.ci.meta.Assumptions.ConcreteMethod;
 import jdk.vm.ci.meta.Assumptions.ConcreteSubtype;
@@ -871,18 +875,56 @@ public String getSourceFileName() {
         return getConstantPool().getSourceFileName();
     }
 
+    /**
+     * Determines if this type may have annotations. A positive result does not mean this type has
+     * annotations but a negative result guarantees this type has no annotations.
+     *
+     * @param includingInherited if true, expand this query to include superclasses of this type
+     */
+    private boolean mayHaveAnnotations(boolean includingInherited) {
+        if (isArray()) {
+            return false;
+        }
+        HotSpotVMConfig config = config();
+        final long metaspaceAnnotations = UNSAFE.getAddress(getKlassPointer() + config.instanceKlassAnnotationsOffset);
+        if (metaspaceAnnotations != 0) {
+            long classAnnotations = UNSAFE.getAddress(metaspaceAnnotations + config.annotationsClassAnnotationsOffset);
+            if (classAnnotations != 0) {
+                return true;
+            }
+        }
+        if (includingInherited) {
+            HotSpotResolvedObjectTypeImpl superClass = getSuperclass();
+            if (superClass != null) {
+                return superClass.mayHaveAnnotations(true);
+            }
+        }
+        return false;
+    }
+
+    private static final Annotation[] NO_ANNOTATIONS = {};
+
     @Override
     public Annotation[] getAnnotations() {
+        if (!mayHaveAnnotations(true)) {
+            return NO_ANNOTATIONS;
+        }
         return runtime().reflection.getAnnotations(this);
     }
 
     @Override
     public Annotation[] getDeclaredAnnotations() {
+        if (!mayHaveAnnotations(false)) {
+            return NO_ANNOTATIONS;
+        }
         return runtime().reflection.getDeclaredAnnotations(this);
     }
 
     @Override
     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
+        if (!mayHaveAnnotations(true)) {
+            return null;
+        }
         return runtime().reflection.getAnnotation(this, annotationClass);
     }
 
@@ -1062,4 +1104,25 @@ public ResolvedJavaField resolveField(UnresolvedJavaField unresolvedJavaField, R
     public boolean isCloneableWithAllocation() {
         return (getAccessFlags() & config().jvmAccIsCloneableFast) != 0;
     }
+
+    @Override
+    public AnnotationData getAnnotationData(ResolvedJavaType annotationType) {
+        if (!mayHaveAnnotations(true)) {
+            return null;
+        }
+        return getAnnotationData0(annotationType).get(0);
+    }
+
+    @Override
+    public List<AnnotationData> getAnnotationData(ResolvedJavaType type1, ResolvedJavaType type2, ResolvedJavaType... types) {
+        if (!mayHaveAnnotations(true)) {
+            return Collections.emptyList();
+        }
+        return getAnnotationData0(AnnotationDataDecoder.asArray(type1, type2, types));
+    }
+
+    private List<AnnotationData> getAnnotationData0(ResolvedJavaType... filter) {
+        byte[] encoded = compilerToVM().getEncodedClassAnnotationData(this, filter);
+        return VMSupport.decodeAnnotations(encoded, AnnotationDataDecoder.INSTANCE);
+    }
 }

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

@@ -27,9 +27,12 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.List;
 
 import jdk.vm.ci.common.JVMCIError;
 import jdk.vm.ci.common.NativeImageReinitialize;
+import jdk.vm.ci.meta.AnnotationData;
 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
@@ -317,4 +320,15 @@ public boolean equals(Object obj) {
     JavaConstant getJavaMirror() {
         return mirror;
     }
+
+    @Override
+    public AnnotationData getAnnotationData(ResolvedJavaType type) {
+        return null;
+    }
+
+    @Override
+    public List<AnnotationData> getAnnotationData(ResolvedJavaType type1, ResolvedJavaType type2, ResolvedJavaType... types) {
+        return Collections.emptyList();
+    }
+
 }

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

@@ -110,6 +110,7 @@ String getHostArchitectureName() {
     final int instanceKlassStateBeingInitialized = getConstant("InstanceKlass::being_initialized", Integer.class);
 
     final int annotationsFieldAnnotationsOffset = getFieldOffset("Annotations::_fields_annotations", Integer.class, "Array<AnnotationArray*>*");
+    final int annotationsClassAnnotationsOffset = getFieldOffset("Annotations::_class_annotations", Integer.class, "AnnotationArray*");
     final int fieldsAnnotationsBaseOffset = getFieldValue("CompilerToVM::Data::_fields_annotations_base_offset", Integer.class, "int");
 
     final int arrayU1LengthOffset = getFieldOffset("Array<int>::_length", Integer.class, "int");

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

@@ -40,7 +40,7 @@
  */
 final class IndirectHotSpotObjectConstantImpl extends HotSpotObjectConstantImpl {
     /**
-     * An object handle in {@code JVMCI::_object_handles}.
+     * An object handle in {@code JVMCIRuntime::_oop_handles}.
      */
     private long objectHandle;
 

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.vm.ci.meta;
+
+import java.lang.annotation.Inherited;
+import java.util.List;
+
+/**
+ * Represents a program element such as a method, constructor, field or class for which annotations
+ * may be present.
+ */
+public interface Annotated {
+
+    /**
+     * Constructs the annotations present on this element whose types are in the set composed of {@code type1},
+     * {@code type2} and {@code types}. All enum types referenced by the returned annotation are
+     * initialized. Class initialization is not triggered for enum types referenced by other
+     * annotations of this element.
+     *
+     * If this element is a class, then {@link Inherited} annotations are included in the set of
+     * annotations considered.
+     *
+     * See {@link java.lang.reflect.AnnotatedElement} for the definition of <em>present</em>.
+     *
+     * @param type1 an annotation type
+     * @param type2 an annotation type
+     * @param types more annotation types
+     * @return an immutable list of the annotations present on this element that match one of the
+     *         given types
+     * @throws IllegalArgumentException if any type in the set composed of {@code type1},
+     *             {@code type2} and {@code types} is not an annotation interface type
+     * @throws UnsupportedOperationException if this operation is not supported
+     */
+    default List<AnnotationData> getAnnotationData(ResolvedJavaType type1, ResolvedJavaType type2, ResolvedJavaType... types) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Constructs the annotation present on this element of type {@code type}.
+     *
+     * See {@link java.lang.reflect.AnnotatedElement} for the definition of <em>present</em>.
+     *
+     * @param type the type object corresponding to the annotation interface type
+     * @return this element's annotation for the specified annotation type if present on this
+     *         element, else null
+     * @throws IllegalArgumentException if {@code type} is not an annotation interface type
+     * @throws UnsupportedOperationException if this operation is not supported
+     */
+    default AnnotationData getAnnotationData(ResolvedJavaType type) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.vm.ci.meta;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Represents an annotation where element values are represented with the types described
+ * {@linkplain #get here}.
+ *
+ * In contrast to the standard annotation API based on {@link Annotation}, use of
+ * {@link AnnotationData} allows annotations to be queried without the JVMCI runtime having to
+ * support dynamic loading of arbitrary {@link Annotation} classes. Such support is impossible in a
+ * closed world, ahead-of-time compiled environment such as libgraal.
+ */
+public final class AnnotationData {
+
+    private final JavaType type;
+    private final Map<String, Object> elements;
+
+    private static final Set<Class<?>> ELEMENT_TYPES = Set.of(
+                    Boolean.class,
+                    Byte.class,
+                    Character.class,
+                    Short.class,
+                    Integer.class,
+                    Float.class,
+                    Long.class,
+                    Double.class,
+                    String.class,
+                    EnumData.class,
+                    AnnotationData.class);
+
+    /**
+     * Creates an annotation.
+     *
+     * @param type the annotation interface of this annotation, represented as a {@link JavaType}
+     * @param elements the names and values of this annotation's element values. Each value's type
+     *            must be one of the {@code AnnotationData} types described {@linkplain #get here}
+     *            or it must be a {@link ErrorData} object whose {@code toString()} value describes
+     *            the error raised while parsing the element. There is no distinction between a
+     *            value explicitly present in the annotation and an element's default value.
+     * @throws IllegalArgumentException if the value of an entry in {@code elements} is not of an
+     *             accepted type
+     * @throws NullPointerException if any of the above parameters is null or any entry in
+     *             {@code elements} is null
+     */
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    public AnnotationData(JavaType type, Map.Entry<String, Object>[] elements) {
+        this.type = Objects.requireNonNull(type);
+        for (Map.Entry<String, Object> e : elements) {
+            Object value = e.getValue();
+            if (!(value instanceof ErrorData) &&
+                            !(value instanceof JavaType) &&
+                            !(value instanceof List) &&
+                            !ELEMENT_TYPES.contains(value.getClass())) {
+                throw new IllegalArgumentException("illegal type for element " + e.getKey() + ": " + value.getClass().getName());
+            }
+        }
+        this.elements = Map.ofEntries(elements);
+    }
+
+    /**
+     * @return the annotation interface of this annotation, represented as a {@link JavaType}
+     */
+    public JavaType getAnnotationType() {
+        return type;
+    }
+
+    // @formatter:off
+    /**
+     * Gets the annotation element denoted by {@code name}. The following table shows the
+     * correspondence between the type of an element as declared by a method in the annotation
+     * interface and the type of value returned by this method:
+     * <table>
+     * <thead>
+     * <tr><th>Annotation</th> <th>AnnotationData</th></tr>
+     * </thead><tbody>
+     * <tr><td>boolean</td>    <td>Boolean</td></tr>
+     * <tr><td>byte</td>       <td>Byte</td></tr>
+     * <tr><td>char</td>       <td>Character</td></tr>
+     * <tr><td>short</td>      <td>Short</td></tr>
+     * <tr><td>int</td>        <td>Integer</td></tr>
+     * <tr><td>float</td>      <td>Float</td></tr>
+     * <tr><td>long</td>       <td>Long</td></tr>
+     * <tr><td>double</td>     <td>Double</td></tr>
+     * <tr><td>String</td>     <td>String</td></tr>
+     * <tr><td>Class</td>      <td>JavaType</td></tr>
+     * <tr><td>Enum</td>       <td>EnumData</td></tr>
+     * <tr><td>Annotation</td> <td>AnnotationData</td></tr>
+     * <tr><td>[]</td><td>immutable List&lt;T&gt; where T is one of the above types</td></tr>
+     * </tbody>
+     * </table>
+     *
+     * @param <V> the type of the element as per the {@code AnnotationData} column in the above
+     *            table or {@link Object}
+     * @param elementType the class for the type of the element
+     * @return the annotation element denoted by {@code name}
+     * @throws ClassCastException if the element is not of type {@code V}
+     * @throws IllegalArgumentException if this annotation has no element named {@code name} or if
+     *             there was an error parsing or creating the element value
+     */
+    // @formatter:on
+    @SuppressWarnings("unchecked")
+    public <V> V get(String name, Class<V> elementType) {
+        Object val = elements.get(name);
+        if (val == null) {
+            throw new IllegalArgumentException("no element named " + name);
+        }
+        Class<? extends Object> valClass = val.getClass();
+        if (valClass == ErrorData.class) {
+            throw new IllegalArgumentException(val.toString());
+        }
+        return elementType.cast(val);
+    }
+
+    @Override
+    public String toString() {
+        return "@" + type.getName() + "(" + elements + ")";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof AnnotationData) {
+            AnnotationData that = (AnnotationData) obj;
+            return this.type.equals(that.type) && this.elements.equals(that.elements);
+
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return type.hashCode() ^ elements.hashCode();
+    }
+}

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/AnnotationData.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.vm.ci.meta;
+
+/**
+ * Represents an enum constant within {@link AnnotationData}.
+ */
+public final class EnumData {
+    private final JavaType type;
+    private final String name;
+
+    /**
+     * Creates an enum constant.
+     *
+     * @param type the {@linkplain Enum enum type}
+     * @param name the {@linkplain Enum#name() name} of the enum
+     */
+    public EnumData(JavaType type, String name) {
+        this.type = type;
+        this.name = name;
+    }
+
+    /**
+     * Gets the {@linkplain Enum enum type}.
+     */
+    public JavaType getEnumType() {
+        return type;
+    }
+
+    /**
+     * Gets the {@linkplain Enum#name() name} of the enum.
+     */
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof EnumData) {
+            EnumData that = (EnumData) obj;
+            return this.type.equals(that.type) && this.name.equals(that.name);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return this.type.hashCode() ^ this.name.hashCode();
+    }
+}

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/EnumData.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.vm.ci.meta;
+
+/**
+ * Represents an error constant within {@link AnnotationData}.
+ *
+ * Similar to {@code sun.reflect.annotation.ExceptionProxy}.
+ */
+public final class ErrorData {
+    private final String description;
+
+    /**
+     * Creates an error constant.
+     *
+     * @param description description of the error
+     */
+    public ErrorData(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String toString() {
+        return description;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof ErrorData) {
+            ErrorData that = (ErrorData) obj;
+            return this.description.equals(that.description);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return description.hashCode();
+    }
+}

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ErrorData.java

@@ -29,7 +29,7 @@
  * Represents a reference to a resolved Java field. Fields, like methods and types, are resolved
  * through {@link ConstantPool constant pools}.
  */
-public interface ResolvedJavaField extends JavaField, ModifiersProvider, AnnotatedElement {
+public interface ResolvedJavaField extends JavaField, ModifiersProvider, AnnotatedElement, Annotated {
 
     /**
      * {@inheritDoc}

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ResolvedJavaField.java

@@ -33,7 +33,7 @@
  * Represents a resolved Java method. Methods, like fields and types, are resolved through
  * {@link ConstantPool constant pools}.
  */
-public interface ResolvedJavaMethod extends JavaMethod, InvokeTarget, ModifiersProvider, AnnotatedElement {
+public interface ResolvedJavaMethod extends JavaMethod, InvokeTarget, ModifiersProvider, AnnotatedElement, Annotated {
 
     /**
      * Returns the method's bytecode. The returned bytecode does not contain breakpoints or non-Java

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ResolvedJavaMethod.java

@@ -31,7 +31,7 @@
  * thereof. Types, like fields and methods, are resolved through {@link ConstantPool constant pools}
  * .
  */
-public interface ResolvedJavaType extends JavaType, ModifiersProvider, AnnotatedElement {
+public interface ResolvedJavaType extends JavaType, ModifiersProvider, AnnotatedElement, Annotated {
     /**
      * Checks whether this type has a finalizer method.
      *
@@ -137,8 +137,8 @@ default boolean declaresDefaultMethods() {
     boolean isAssignableFrom(ResolvedJavaType other);
 
     /**
-     * Returns {@code null} since support for VM anonymous class was removed by JDK-8243287.
-     * This method is preserved for JVMCI backwards compatibility.
+     * Returns {@code null} since support for VM anonymous class was removed by JDK-8243287. This
+     * method is preserved for JVMCI backwards compatibility.
      */
     @Deprecated
     default ResolvedJavaType getHostClass() {

src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ResolvedJavaType.java

@@ -25,10 +25,20 @@
  * @test
  * @requires vm.jvmci
  * @library ../../../../../
+ * @compile ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/AnnotationTestInput.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberDeleted.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberTypeChanged.java
+ *          TestResolvedJavaType.java
+ * @clean jdk.internal.vm.test.AnnotationTestInput$Missing
+ * @compile ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberDeleted.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberTypeChanged.java
  * @modules jdk.internal.vm.ci/jdk.vm.ci.meta
  *          jdk.internal.vm.ci/jdk.vm.ci.runtime
  *          jdk.internal.vm.ci/jdk.vm.ci.common
+ *          java.base/jdk.internal.reflect
  *          java.base/jdk.internal.misc
+ *          java.base/jdk.internal.vm
+ *          java.base/sun.reflect.annotation
  * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:-UseJVMCICompiler jdk.vm.ci.runtime.test.TestResolvedJavaField
  */
 
@@ -57,6 +67,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import jdk.internal.vm.test.AnnotationTestInput;
 import jdk.vm.ci.common.JVMCIError;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
 import jdk.vm.ci.meta.JavaConstant;
@@ -181,6 +192,14 @@ private Method findTestMethod(Method apiMethod) {
         return null;
     }
 
+    @Test
+    public void getAnnotationDataTest() throws Exception {
+        TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredField("annotatedField"));
+        for (Field f : fields.keySet()) {
+            TestResolvedJavaType.getAnnotationDataTest(f);
+        }
+    }
+
     // @formatter:off
     private static final String[] untestedApiMethods = {
     };

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,9 +25,20 @@
  * @test
  * @requires vm.jvmci
  * @library ../../../../../
+ * @compile ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/AnnotationTestInput.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberDeleted.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberTypeChanged.java
+ *          TestResolvedJavaType.java
+ * @clean jdk.internal.vm.test.AnnotationTestInput$Missing
+ * @compile ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberDeleted.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberTypeChanged.java
  * @modules jdk.internal.vm.ci/jdk.vm.ci.meta
  *          jdk.internal.vm.ci/jdk.vm.ci.runtime
+ *          jdk.internal.vm.ci/jdk.vm.ci.common
+ *          java.base/jdk.internal.reflect
  *          java.base/jdk.internal.misc
+ *          java.base/jdk.internal.vm
+ *          java.base/sun.reflect.annotation
  * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:-UseJVMCICompiler jdk.vm.ci.runtime.test.TestResolvedJavaMethod
  */
 
@@ -61,11 +72,16 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import jdk.internal.vm.test.AnnotationTestInput;
 import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.ExceptionHandler;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaMethod.Parameter;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.runtime.test.TestResolvedJavaMethod.AnnotationDataTest.Annotation1;
+import jdk.vm.ci.runtime.test.TestResolvedJavaMethod.AnnotationDataTest.Annotation2;
+import jdk.vm.ci.runtime.test.TestResolvedJavaMethod.AnnotationDataTest.Annotation3;
+import jdk.vm.ci.runtime.test.TestResolvedJavaMethod.AnnotationDataTest.NumbersDE;
 
 /**
  * Tests for {@link ResolvedJavaMethod}.
@@ -474,6 +490,83 @@ public void testVirtualMethodTableAccess() {
         }
     }
 
+    /**
+     * Encapsulates input for {@link TestResolvedJavaMethod#getAnnotationDataTest}.
+     */
+    static class AnnotationDataTest {
+
+        public enum NumbersEN {
+            One,
+            Two;
+        }
+
+        public enum NumbersDE {
+            Eins,
+            Zwei;
+        }
+
+        public enum NumbersUA {
+            Odyn,
+            Dva;
+        }
+
+        @Retention(RetentionPolicy.RUNTIME)
+        public @interface Annotation1 {
+            NumbersEN value() default NumbersEN.One;
+        }
+
+        @Retention(RetentionPolicy.RUNTIME)
+        public @interface Annotation2 {
+            NumbersDE value() default NumbersDE.Eins;
+        }
+
+        @Retention(RetentionPolicy.RUNTIME)
+        public @interface Annotation3 {
+            NumbersUA value() default NumbersUA.Odyn;
+        }
+
+        @Annotation1
+        @Annotation2
+        @Annotation3(NumbersUA.Dva)
+        static void methodWithThreeAnnotations() {
+
+        }
+    }
+
+    @Test
+    public void getAnnotationDataTest() throws Exception {
+        TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredMethod("annotatedMethod"));
+        TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredMethod("missingAnnotation"));
+        try {
+            TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredMethod("missingNestedAnnotation"));
+            throw new AssertionError("expected " + NoClassDefFoundError.class.getName());
+        } catch (NoClassDefFoundError e) {
+            Assert.assertEquals("jdk/internal/vm/test/AnnotationTestInput$Missing", e.getMessage());
+        }
+        TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredMethod("missingTypeOfClassMember"));
+        TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredMethod("missingMember"));
+        TestResolvedJavaType.getAnnotationDataTest(AnnotationTestInput.class.getDeclaredMethod("changeTypeOfMember"));
+
+        for (Method m : methods.keySet()) {
+            TestResolvedJavaType.getAnnotationDataTest(m);
+        }
+
+        ResolvedJavaMethod m = metaAccess.lookupJavaMethod(AnnotationDataTest.class.getDeclaredMethod("methodWithThreeAnnotations"));
+        ResolvedJavaType a1 = metaAccess.lookupJavaType(Annotation1.class);
+        ResolvedJavaType a2 = metaAccess.lookupJavaType(Annotation2.class);
+        ResolvedJavaType a3 = metaAccess.lookupJavaType(Annotation3.class);
+        ResolvedJavaType a4 = metaAccess.lookupJavaType(AnnotationDataTest.class);
+        ResolvedJavaType numbersDEType = metaAccess.lookupJavaType(NumbersDE.class);
+
+        // Ensure NumbersDE is not initialized before Annotation2 is requested
+        Assert.assertFalse(numbersDEType.isInitialized());
+        Assert.assertEquals(2, m.getAnnotationData(a1, a3).size());
+
+        // Ensure NumbersDE is initialized after Annotation2 is requested
+        Assert.assertNotNull(m.getAnnotationData(a2));
+        Assert.assertTrue(numbersDEType.isInitialized());
+    }
+
     private Method findTestMethod(Method apiMethod) {
         String testName = apiMethod.getName() + "Test";
         for (Method m : getClass().getDeclaredMethods()) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,12 +25,20 @@
  * @test
  * @requires vm.jvmci
  * @library ../../../../../
+ * @compile ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/AnnotationTestInput.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberDeleted.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberTypeChanged.java
+ * @clean jdk.internal.vm.test.AnnotationTestInput$Missing
+ * @compile ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberDeleted.java
+ *          ../../../../../../../../../../../jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberTypeChanged.java
  * @modules java.base/jdk.internal.org.objectweb.asm
  *          java.base/jdk.internal.reflect
  *          jdk.internal.vm.ci/jdk.vm.ci.meta
  *          jdk.internal.vm.ci/jdk.vm.ci.runtime
  *          jdk.internal.vm.ci/jdk.vm.ci.common
  *          java.base/jdk.internal.misc
+ *          java.base/jdk.internal.vm
+ *          java.base/sun.reflect.annotation
  * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:-UseJVMCICompiler jdk.vm.ci.runtime.test.TestResolvedJavaType
  */
 
@@ -57,30 +65,43 @@
 import java.lang.annotation.Annotation;
 import java.lang.invoke.MethodHandles.Lookup;
 import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.function.BiConsumer;
 import java.util.function.Supplier;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.junit.Assert;
 import org.junit.Test;
 
-import jdk.internal.org.objectweb.asm.*;
 import jdk.internal.reflect.ConstantPool;
+import jdk.internal.vm.test.AnnotationTestInput;
 import jdk.vm.ci.common.JVMCIError;
+import jdk.vm.ci.meta.Annotated;
+import jdk.vm.ci.meta.AnnotationData;
+import jdk.vm.ci.meta.EnumData;
 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
+import jdk.vm.ci.meta.JavaType;
+import jdk.vm.ci.meta.MetaUtil;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.UnresolvedJavaType;
+import sun.reflect.annotation.AnnotationSupport;
 
 /**
  * Tests for {@link ResolvedJavaType}.
@@ -177,7 +198,8 @@ public void isArrayTest() {
 
     @Test
     public void lambdaInternalNameTest() {
-        // Verify that the last dot in lambda types is properly handled when transitioning from internal name to java
+        // Verify that the last dot in lambda types is properly handled when transitioning from
+        // internal name to java
         // name and vice versa.
         Supplier<Runnable> lambda = () -> () -> System.out.println("run");
         ResolvedJavaType lambdaType = metaAccess.lookupJavaType(lambda.getClass());
@@ -903,11 +925,11 @@ private static boolean isHiddenFromReflection(ResolvedJavaField f) {
             return f.getName().equals("allowedModes") || f.getName().equals("lookupClass");
         }
         if (f.getDeclaringClass().equals(metaAccess.lookupJavaType(ClassLoader.class)) ||
-            f.getDeclaringClass().equals(metaAccess.lookupJavaType(AccessibleObject.class)) ||
-            f.getDeclaringClass().equals(metaAccess.lookupJavaType(Constructor.class)) ||
-            f.getDeclaringClass().equals(metaAccess.lookupJavaType(Field.class)) ||
-            f.getDeclaringClass().equals(metaAccess.lookupJavaType(Method.class)) ||
-            f.getDeclaringClass().equals(metaAccess.lookupJavaType(Module.class))) {
+                        f.getDeclaringClass().equals(metaAccess.lookupJavaType(AccessibleObject.class)) ||
+                        f.getDeclaringClass().equals(metaAccess.lookupJavaType(Constructor.class)) ||
+                        f.getDeclaringClass().equals(metaAccess.lookupJavaType(Field.class)) ||
+                        f.getDeclaringClass().equals(metaAccess.lookupJavaType(Method.class)) ||
+                        f.getDeclaringClass().equals(metaAccess.lookupJavaType(Module.class))) {
             return true;
         }
         return false;
@@ -1131,6 +1153,40 @@ private Method findTestMethod(Method apiMethod) {
         return null;
     }
 
+    @Test
+    public void getAnnotationDataTest() throws Exception {
+        getAnnotationDataTest(AnnotationTestInput.AnnotatedClass.class);
+        getAnnotationDataTest(int.class);
+        getAnnotationDataTest(void.class);
+        for (Class<?> c : classes) {
+            getAnnotationDataTest(c);
+        }
+
+        // Primitive classes have no annotations but we cannot directly
+        // test absence of annotations. Instead, just ensure empty answers
+        // are returned when looking up an arbitrary annotation type.
+        Class<?>[] prims = {void.class, byte.class, int.class, double.class, float.class, short.class, char.class, long.class};
+        ResolvedJavaType overrideType = metaAccess.lookupJavaType(Override.class);
+        for (Class<?> c : prims) {
+            ResolvedJavaType type = metaAccess.lookupJavaType(c);
+            AnnotationData ad = type.getAnnotationData(overrideType);
+            Assert.assertNull(String.valueOf(ad), ad);
+            List<AnnotationData> adArray = type.getAnnotationData(overrideType, overrideType);
+            Assert.assertEquals(0, adArray.size());
+        }
+
+        // Test that inherited annotations are handled properly.
+        ResolvedJavaType namedType = metaAccess.lookupJavaType(AnnotationTestInput.Named.class);
+        AnnotationData ad = metaAccess.lookupJavaType(AnnotationTestInput.OwnName.class).getAnnotationData(namedType);
+        Assert.assertEquals("NonInheritedValue", ad.get("value", String.class));
+        ad = metaAccess.lookupJavaType(AnnotationTestInput.InheritedName1.class).getAnnotationData(namedType);
+        Assert.assertEquals("Super1", ad.get("value", String.class));
+        ad = metaAccess.lookupJavaType(AnnotationTestInput.InheritedName2.class).getAnnotationData(namedType);
+        Assert.assertEquals("Super2", ad.get("value", String.class));
+        ad = metaAccess.lookupJavaType(AnnotationTestInput.InheritedName3.class).getAnnotationData(namedType);
+        Assert.assertEquals("Super1", ad.get("value", String.class));
+    }
+
     // @formatter:off
     private static final String[] untestedApiMethods = {
         "initialize",
@@ -1174,4 +1230,129 @@ public void testCoverage() {
     private static boolean isSignaturePolymorphic(ResolvedJavaMethod method) {
         return method.getAnnotation(SIGNATURE_POLYMORPHIC_CLASS) != null;
     }
+
+    /**
+     * Tests that {@link AnnotationData} obtained from a {@link Class}, {@link Method} or
+     * {@link Field} matches {@link AnnotatedElement#getAnnotations()} for the corresponding JVMCI
+     * object.
+     *
+     * @param annotated a {@link Class}, {@link Method} or {@link Field} object
+     */
+    public static void getAnnotationDataTest(AnnotatedElement annotated) throws Exception {
+        testGetAnnotationData(annotated, List.of(annotated.getAnnotations()));
+    }
+
+    private static void testGetAnnotationData(AnnotatedElement annotated, List<Annotation> annotations) throws AssertionError {
+        for (Annotation a : annotations) {
+            AnnotationData ad = toAnnotated(annotated).getAnnotationData(metaAccess.lookupJavaType(a.annotationType()));
+            assertAnnotationsEquals(a, ad);
+
+            // Check that encoding/decoding produces a stable result
+            AnnotationData ad2 = toAnnotated(annotated).getAnnotationData(metaAccess.lookupJavaType(a.annotationType()));
+            assertEquals(ad, ad2);
+        }
+        if (annotations.size() < 2) {
+            return;
+        }
+        ResolvedJavaType type1 = metaAccess.lookupJavaType(annotations.get(0).annotationType());
+        ResolvedJavaType type2 = metaAccess.lookupJavaType(annotations.get(1).annotationType());
+        for (int i = 2; i < annotations.size(); i++) {
+
+            ResolvedJavaType[] types = annotations.//
+                            subList(2, i + 1).//
+                            stream().map(a -> metaAccess.lookupJavaType(a.annotationType())).//
+                            toArray(ResolvedJavaType[]::new);
+            List<AnnotationData> annotationData = toAnnotated(annotated).getAnnotationData(type1, type2, types);
+            assertEquals(2 + types.length, annotationData.size());
+
+            for (int j = 0; j < annotationData.size(); j++) {
+                Annotation a = annotations.get(j);
+                AnnotationData ad = annotationData.get(j);
+                assertAnnotationsEquals(a, ad);
+            }
+        }
+    }
+
+    private static Annotated toAnnotated(AnnotatedElement element) {
+        if (element instanceof Class<?> t) {
+            return metaAccess.lookupJavaType(t);
+        } else if (element instanceof Method m) {
+            return metaAccess.lookupJavaMethod(m);
+        } else {
+            Field f = (Field) element;
+            return metaAccess.lookupJavaField(f);
+        }
+    }
+
+    private static UnresolvedJavaType asType(Class<?> valueType) {
+        return UnresolvedJavaType.create(MetaUtil.toInternalName(valueType.getName()));
+    }
+
+    private static void assertAnnotationsEquals(Annotation a, AnnotationData ad) {
+        Map<String, Object> values = AnnotationSupport.memberValues(a);
+        for (Map.Entry<String, Object> e : values.entrySet()) {
+            String name = e.getKey();
+            Object aValue = e.getValue();
+            Object adValue;
+            try {
+                adValue = ad.get(name, Object.class);
+            } catch (IllegalArgumentException ex) {
+                assertEquals(aValue.toString(), ex.getMessage());
+                continue;
+            }
+            try {
+                assertAnnotationElementsEqual(aValue, adValue);
+            } catch (ClassCastException ex) {
+                throw new AssertionError(a.getClass().getName() + "." + name + " has wrong type: " + adValue.getClass().getName(), ex);
+            }
+        }
+    }
+
+    private static void assertAnnotationElementsEqual(Object aValue, Object adValue) {
+        Class<?> valueType = aValue.getClass();
+        if (valueType.isEnum()) {
+            assertEnumObjectsEquals(aValue, adValue);
+        } else if (aValue instanceof Class) {
+            assertClassObjectsEquals(aValue, adValue);
+        } else if (aValue instanceof Annotation) {
+            assertAnnotationObjectsEquals(aValue, adValue);
+        } else if (valueType.isArray()) {
+            List<?> adList = (List<?>) adValue;
+            int length = Array.getLength(aValue);
+            assertEquals(length, adList.size());
+            for (int i = 0; i < length; i++) {
+                assertAnnotationElementsEqual(Array.get(aValue, i), adList.get(i));
+            }
+        } else {
+            assertEquals(aValue.getClass(), adValue.getClass());
+            assertEquals(aValue, adValue);
+        }
+    }
+
+    private static void assertClassObjectsEquals(Object aValue, Object adValue) {
+        String aName = ((Class<?>) aValue).getName();
+        String adName = ((JavaType) adValue).toClassName();
+        assertEquals(aName, adName);
+    }
+
+    private static void assertEnumObjectsEquals(Object aValue, Object adValue) {
+        EnumData adEnum = (EnumData) adValue;
+        String adEnumName = adEnum.getName();
+        String aEnumName = ((Enum<?>) aValue).name();
+        assertEquals(adEnumName, aEnumName);
+    }
+
+    private static void assertAnnotationObjectsEquals(Object aValue, Object adValue) {
+        Annotation aAnnotation = (Annotation) aValue;
+        AnnotationData adAnnotation = (AnnotationData) adValue;
+        assertAnnotationsEquals(aAnnotation, adAnnotation);
+    }
+
+    private static void assertArraysEqual(Object aValue, Object adValue, int length, BiConsumer<Object, Object> assertEqualty) {
+        Object[] aArray = (Object[]) aValue;
+        Object[] adArray = (Object[]) adValue;
+        for (int i = 0; i < length; i++) {
+            assertEqualty.accept(aArray[i], adArray[i]);
+        }
+    }
 }

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

@@ -22,14 +22,8 @@
  */
 package jdk.vm.ci.runtime.test;
 
-import jdk.internal.misc.Unsafe;
-import jdk.vm.ci.meta.ConstantReflectionProvider;
-import jdk.vm.ci.meta.JavaConstant;
-import jdk.vm.ci.meta.MetaAccessProvider;
-import jdk.vm.ci.meta.ResolvedJavaField;
-import jdk.vm.ci.meta.ResolvedJavaType;
-import jdk.vm.ci.runtime.JVMCI;
-import org.junit.Test;
+import static java.lang.reflect.Modifier.isFinal;
+import static java.lang.reflect.Modifier.isStatic;
 
 import java.io.Serializable;
 import java.lang.reflect.Array;
@@ -54,8 +48,15 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-import static java.lang.reflect.Modifier.isFinal;
-import static java.lang.reflect.Modifier.isStatic;
+import org.junit.Test;
+
+import jdk.internal.misc.Unsafe;
+import jdk.vm.ci.meta.ConstantReflectionProvider;
+import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.MetaAccessProvider;
+import jdk.vm.ci.meta.ResolvedJavaField;
+import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.runtime.JVMCI;
 
 /**
  * Context for type related tests.

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

@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.vm.test;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class AnnotationTestInput {
+
+    enum Mood {
+        HAPPY,
+        SAD,
+        CONFUSED;
+    }
+
+    private class PrivateClass {}
+
+    @Single(string = "a",
+            stringArray = {"a", "b"},
+            classValue = String.class,
+            classArray = {String.class, Exception.class},
+            byteValue = 1,
+            byteArray = {1, 2, Byte.MIN_VALUE, Byte.MAX_VALUE},
+            charValue = 'a',
+            charArray = {'a', 'b',
+                         Character.MIN_VALUE, Character.MAX_VALUE,
+                         '\b', '\f', '\n', '\r', '\t', '\\', '\'', '\"', '\u012A'},
+            doubleValue = 3.3D,
+            doubleArray = {3.3D, 4.4D,
+                           Double.MIN_VALUE, Double.MAX_VALUE,
+                           Double.NaN,
+                           Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            floatValue = 4.4F,
+            floatArray = {4.4F, 5.5F,
+                          Float.MIN_VALUE, Float.MAX_VALUE,
+                          Float.NaN,
+                          Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY},
+            intValue = 5,
+            intArray = {5, 6, Integer.MIN_VALUE, Integer.MAX_VALUE},
+            longValue = 6L,
+            longArray = {6L, 7L, Long.MIN_VALUE, Long.MAX_VALUE},
+            shortValue = 7,
+            shortArray = {7, 8, Short.MIN_VALUE, Short.MAX_VALUE},
+            booleanValue = true,
+            booleanArray = {true, false},
+            mood = Mood.SAD,
+            moodArray = {Mood.CONFUSED, Mood.HAPPY},
+            nested = @NestedAnno("nested1"),
+            nestedArray = {@NestedAnno("nested2"), @NestedAnno("nested3")})
+    @Single(string = "A",
+            stringArray = {"A", "B"},
+            classValue = Thread.class,
+            classArray = {Thread.class, PrivateClass.class},
+            byteValue = -1,
+            byteArray = {-1, -2},
+            charValue = 'A',
+            charArray = {'a', 'b'},
+            doubleValue = -3.3D,
+            doubleArray = {3.3D, 4.4D},
+            floatValue = -4.4F,
+            floatArray = {4.4F, 5.5F},
+            intValue = -5,
+            intArray = {5, 6},
+            longValue = -6L,
+            longArray = {6L, 7L},
+            shortValue = -7,
+            shortArray = {7, 8},
+            booleanValue = true,
+            booleanArray = {true, false},
+            mood = Mood.CONFUSED,
+            moodArray = {Mood.SAD, Mood.CONFUSED},
+            nested = @NestedAnno("nested4"),
+            nestedArray = {@NestedAnno("nested5"), @NestedAnno("nested6")})
+    @SingleWithDefaults
+    @Deprecated
+    @SuppressWarnings("unchecked")
+    public void annotatedMethod() {
+    }
+
+    @Named("Super1")
+    public static class Super1 {}
+    @Named("Super2")
+    public static class Super2 extends Super1 {}
+    public static class Super3 extends Super1 {}
+
+    @Named("NonInheritedValue")
+    public static class OwnName extends Super1 {}
+
+    public static class InheritedName1 extends Super1 {}
+    public static class InheritedName2 extends Super2 {}
+    public static class InheritedName3 extends Super3 {}
+
+    @Named("AnnotatedClass")
+    @Single(string = "a",
+            stringArray = {"a", "b"},
+            classValue = String.class,
+            classArray = {String.class, Exception.class},
+            byteValue = 1,
+            byteArray = {1, 2, Byte.MIN_VALUE, Byte.MAX_VALUE},
+            charValue = 'a',
+            charArray = {'a', 'b',
+                    Character.MIN_VALUE, Character.MAX_VALUE,
+                    '\b', '\f', '\n', '\r', '\t', '\\', '\'', '\"', '\u012A'},
+            doubleValue = 3.3D,
+            doubleArray = {3.3D, 4.4D,
+                    Double.MIN_VALUE, Double.MAX_VALUE,
+                    Double.NaN,
+                    Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            floatValue = 4.4F,
+            floatArray = {4.4F, 5.5F,
+                    Float.MIN_VALUE, Float.MAX_VALUE,
+                    Float.NaN,
+                    Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY},
+            intValue = 5,
+            intArray = {5, 6, Integer.MIN_VALUE, Integer.MAX_VALUE},
+            longValue = 6L,
+            longArray = {6L, 7L, Long.MIN_VALUE, Long.MAX_VALUE},
+            shortValue = 7,
+            shortArray = {7, 8, Short.MIN_VALUE, Short.MAX_VALUE},
+            booleanValue = true,
+            booleanArray = {true, false},
+            mood = Mood.SAD,
+            moodArray = {Mood.CONFUSED, Mood.HAPPY},
+            nested = @NestedAnno("nested7"),
+            nestedArray = {@NestedAnno("nested8"), @NestedAnno("nested9")})
+    @Single(string = "A",
+            stringArray = {"A", "B"},
+            classValue = Thread.class,
+            classArray = {Thread.class, PrivateClass.class},
+            byteValue = -1,
+            byteArray = {-1, -2},
+            charValue = 'A',
+            charArray = {'a', 'b'},
+            doubleValue = -3.3D,
+            doubleArray = {3.3D, 4.4D},
+            floatValue = -4.4F,
+            floatArray = {4.4F, 5.5F},
+            intValue = -5,
+            intArray = {5, 6},
+            longValue = -6L,
+            longArray = {6L, 7L},
+            shortValue = -7,
+            shortArray = {7, 8},
+            booleanValue = true,
+            booleanArray = {true, false},
+            mood = Mood.CONFUSED,
+            moodArray = {Mood.SAD, Mood.CONFUSED},
+            nested = @NestedAnno("nested10"),
+            nestedArray = {@NestedAnno("nested11"), @NestedAnno("nested12")})
+    @Deprecated
+    @SuppressWarnings({"rawtypes", "all"})
+    public static class AnnotatedClass {}
+
+    @Single(string = "a",
+            stringArray = {"a", "b"},
+            classValue = String.class,
+            classArray = {String.class, Exception.class},
+            byteValue = 1,
+            byteArray = {1, 2, Byte.MIN_VALUE, Byte.MAX_VALUE},
+            charValue = 'a',
+            charArray = {'a', 'b',
+                    Character.MIN_VALUE, Character.MAX_VALUE,
+                    '\b', '\f', '\n', '\r', '\t', '\\', '\'', '\"', '\u012A'},
+            doubleValue = 3.3D,
+            doubleArray = {3.3D, 4.4D,
+                    Double.MIN_VALUE, Double.MAX_VALUE,
+                    Double.NaN,
+                    Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY},
+            floatValue = 4.4F,
+            floatArray = {4.4F, 5.5F,
+                    Float.MIN_VALUE, Float.MAX_VALUE,
+                    Float.NaN,
+                    Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY},
+            intValue = 5,
+            intArray = {5, 6, Integer.MIN_VALUE, Integer.MAX_VALUE},
+            longValue = 6L,
+            longArray = {6L, 7L, Long.MIN_VALUE, Long.MAX_VALUE},
+            shortValue = 7,
+            shortArray = {7, 8, Short.MIN_VALUE, Short.MAX_VALUE},
+            booleanValue = true,
+            booleanArray = {true, false},
+            mood = Mood.SAD,
+            moodArray = {Mood.CONFUSED, Mood.HAPPY},
+            nested = @NestedAnno("nested12"),
+            nestedArray = {@NestedAnno("nested13"), @NestedAnno("nested14")})
+    @Single(string = "A",
+            stringArray = {"A", "B"},
+            classValue = Thread.class,
+            classArray = {Thread.class, PrivateClass.class},
+            byteValue = -1,
+            byteArray = {-1, -2},
+            charValue = 'A',
+            charArray = {'a', 'b'},
+            doubleValue = -3.3D,
+            doubleArray = {3.3D, 4.4D},
+            floatValue = -4.4F,
+            floatArray = {4.4F, 5.5F},
+            intValue = -5,
+            intArray = {5, 6},
+            longValue = -6L,
+            longArray = {6L, 7L},
+            shortValue = -7,
+            shortArray = {7, 8},
+            booleanValue = true,
+            booleanArray = {true, false},
+            mood = Mood.CONFUSED,
+            moodArray = {Mood.SAD, Mood.CONFUSED},
+            nested = @NestedAnno("nested15"),
+            nestedArray = {@NestedAnno("nested16"), @NestedAnno("nested17")})
+    private static final int annotatedField = 45;
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface NestedAnno {
+        String value();
+    }
+
+    @Inherited
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface Named {
+        String value();
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Repeatable(SingleList.class)
+    public @interface Single {
+        Class<?> classValue();
+        Class<?>[] classArray();
+
+        String string();
+        String[] stringArray();
+
+        byte byteValue();
+        byte[] byteArray();
+
+        char charValue();
+        char[] charArray();
+
+        double doubleValue();
+        double[] doubleArray();
+
+        float floatValue();
+        float[] floatArray();
+
+        int intValue();
+        int[] intArray();
+
+        long longValue();
+        long[] longArray();
+
+        short shortValue();
+        short[] shortArray();
+
+        boolean booleanValue();
+        boolean[] booleanArray();
+
+        Mood mood();
+        Mood[] moodArray();
+
+        NestedAnno nested();
+        NestedAnno[] nestedArray();
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface SingleWithDefaults {
+        Class<?> classValue() default SingleWithDefaults.class;
+        Class<?>[] classArray() default {};
+
+        String string() default "anonymous";
+        String[] stringArray() default {};
+
+        byte byteValue() default 101;
+        byte[] byteArray() default {};
+
+        char charValue() default 'Z';
+        char[] charArray() default {};
+
+        double doubleValue() default 102.102D;
+        double[] doubleArray() default {};
+
+        float floatValue() default 103.103F;
+        float[] floatArray() default {};
+
+        int intValue() default 104;
+        int[] intArray() default {};
+
+        long longValue() default 105L;
+        long[] longArray() default {};
+
+        short shortValue() default 105;
+        short[] shortArray() default {};
+
+        boolean booleanValue() default true;
+        boolean[] booleanArray() default {};
+
+        Mood mood() default Mood.HAPPY;
+        Mood[] moodArray() default {};
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface SingleList {
+        Single[] value();
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface Missing {}
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MissingWrapper {
+        Missing value();
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MissingContainer {
+        Class<?> value();
+    }
+
+    /**
+     * Method with a directly missing annotation.
+     */
+    @Missing
+    public void missingAnnotation() {}
+
+    /**
+     * Method with an indirectly missing nested annotation.
+     */
+    @MissingWrapper(@Missing)
+    public void missingNestedAnnotation() {}
+
+    /**
+     * Method with an annotation that has a Class member
+     * that cannot be resolved.
+     */
+    @MissingContainer(Missing.class)
+    public void missingTypeOfClassMember() {}
+
+    /**
+     * Method with an annotation that has a member
+     * that is deleted in a newer version of the annotation.
+     */
+    @MemberDeleted(value = "evolving", retained = -34, deleted = 56)
+    public void missingMember() {}
+
+    /**
+     * Method with an annotation that has a member named "any"
+     * whose type is changed from int to String in a newer version
+     * of the annotation.
+     */
+    @MemberTypeChanged(value = "evolving", retained = -34, any = 56)
+    public void changeTypeOfMember() {}
+
+}
+

test/jdk/jdk/internal/vm/AnnotationEncodingDecoding/AnnotationTestInput.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.vm.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MemberDeleted {
+    String value();
+    int retained();
+    int deleted();
+}

test/jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberDeleted.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.vm.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MemberTypeChanged {
+    String value();
+    int retained();
+    int any();
+}

test/jdk/jdk/internal/vm/AnnotationEncodingDecoding/MemberTypeChanged.java

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @compile AnnotationTestInput.java MemberDeleted.java MemberTypeChanged.java
+ * @modules java.base/jdk.internal.vm
+ *          java.base/sun.reflect.annotation
+ * @clean jdk.internal.vm.test.AnnotationTestInput$Missing
+ * @compile alt/MemberDeleted.java alt/MemberTypeChanged.java
+ * @run testng/othervm
+ *      jdk.internal.vm.test.TestAnnotationEncodingDecoding
+ */
+package jdk.internal.vm.test;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.LinkedHashMap;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.TreeMap;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import sun.reflect.annotation.AnnotationSupport;
+import sun.reflect.annotation.AnnotationParser;
+import sun.reflect.annotation.ExceptionProxy;
+
+import jdk.internal.vm.VMSupport;
+import jdk.internal.vm.VMSupport.AnnotationDecoder;
+
+public class TestAnnotationEncodingDecoding {
+
+    @Test
+    public void encodeDecodeTest() throws Exception {
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredField("annotatedField"));
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredMethod("annotatedMethod"));
+        checkDecodedEqualsEncoded(AnnotationTestInput.AnnotatedClass.class);
+
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredMethod("missingAnnotation"));
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredMethod("missingNestedAnnotation"), true);
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredMethod("missingTypeOfClassMember"), false);
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredMethod("missingMember"));
+        checkDecodedEqualsEncoded(AnnotationTestInput.class.getDeclaredMethod("changeTypeOfMember"), false);
+    }
+
+    private void checkDecodedEqualsEncoded(AnnotatedElement annotated) {
+        checkDecodedEqualsEncoded(annotated, false);
+    }
+
+    private void checkDecodedEqualsEncoded(AnnotatedElement annotated, boolean expectNCDFE) {
+        Annotation[] annotations = getAnnotations(annotated, expectNCDFE);
+        if (annotations == null) {
+            return;
+        }
+
+        byte[] encoded = VMSupport.encodeAnnotations(List.of(annotations));
+        MyDecoder decoder = new MyDecoder();
+        List<AnnotationConst> decoded = VMSupport.decodeAnnotations(encoded, decoder);
+        int i = 0;
+        for (AnnotationConst actual : decoded) {
+            AnnotationConst expect = new AnnotationConst(annotations[i]);
+            checkEquals(actual, expect);
+            checkEquals(actual.toString(), expect.toString());
+            i++;
+        }
+    }
+
+    private static Annotation[] getAnnotations(AnnotatedElement annotated, boolean expectNCDFE) throws AssertionError {
+        try {
+            Annotation[] annotations = annotated.getAnnotations();
+            Assert.assertFalse(expectNCDFE, annotated.toString());
+            return annotations;
+        } catch (NoClassDefFoundError e) {
+            if (!expectNCDFE) {
+                throw new AssertionError(annotated.toString(), e);
+            }
+            return null;
+        }
+    }
+
+    private static void checkEquals(Object actual, Object expect) {
+        if (!actual.equals(expect)) {
+            throw new AssertionError(String.format("actual != expect%nactual: %s%n%nexpect: %s", actual, expect));
+        }
+    }
+
+    public static final class AnnotationConst {
+        final Class<?> type;
+        final Map<String, Object> elements;
+
+        AnnotationConst(Class<?> type, Map.Entry<String, Object>[] elements) {
+            this.type = type;
+            this.elements = Map.ofEntries(elements);
+        }
+
+        AnnotationConst(Annotation a) {
+            Map<String, Object> values = AnnotationSupport.memberValues(a);
+            this.type = a.annotationType();
+            Map.Entry[] elements = new Map.Entry[values.size()];
+            int i = 0;
+            for (Map.Entry<String, Object> e : values.entrySet()) {
+                elements[i++] = Map.entry(e.getKey(), decodeValue(e.getValue()));
+            }
+            this.elements = Map.ofEntries(elements);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof AnnotationConst) {
+                AnnotationConst that = (AnnotationConst) obj;
+                return this.type.equals(that.type) &&
+                        this.elements.equals(that.elements);
+            }
+            return false;
+        }
+
+        @Override
+        public String toString() {
+            return "@" + type.getName() + "(" + elements + ")";
+        }
+
+        private Object decodeValue(Object value) {
+            Class<?> valueType = value.getClass();
+            if (value instanceof Enum) {
+                return new EnumConst(valueType, ((Enum<?>) value).name());
+            } else if (value instanceof Annotation) {
+                return new AnnotationConst((Annotation) value);
+            } else if (valueType.isArray()) {
+                int len = Array.getLength(value);
+                Object[] arr = new Object[len];
+                for (int i = 0; i < len; i++) {
+                    arr[i] = decodeValue(Array.get(value, i));
+                }
+                return List.of(arr);
+            } else if (value instanceof ExceptionProxy) {
+                return new ErrorConst(value.toString());
+            } else {
+                return value;
+            }
+        }
+
+        public Class<?> getType() {
+            return type;
+        }
+    }
+
+    public static final class ErrorConst {
+        final String desc;
+        public ErrorConst(String desc) {
+            this.desc = Objects.requireNonNull(desc);
+        }
+
+        @Override
+        public String toString() {
+            return desc;
+        }
+
+        @Override
+        public int hashCode() {
+            return desc.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof ErrorConst) {
+                return ((ErrorConst) obj).desc.equals(desc);
+            }
+            return false;
+        }
+    }
+
+    public static final class EnumConst {
+        final Class<?> type;
+        final String name;
+
+        public EnumConst(Class<?> type, String name) {
+            this.type = type;
+            this.name = name;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof EnumConst) {
+                EnumConst that = (EnumConst) obj;
+                return this.type.equals(that.type) &&
+                        this.name.equals(that.name);
+            }
+            return false;
+        }
+
+        @Override
+        public String toString() {
+            return type.getName() + "." + name;
+        }
+
+        public Class<?> getEnumType() {
+            return type;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    static class MyDecoder implements AnnotationDecoder<Class<?>, AnnotationConst, EnumConst, ErrorConst> {
+        @Override
+        public Class<?> resolveType(String name) {
+            try {
+                return Class.forName(name);
+            } catch (ClassNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        @Override
+        public AnnotationConst newAnnotation(Class<?> type, Map.Entry<String, Object>[] elements) {
+            return new AnnotationConst(type, elements);
+        }
+
+        @Override
+        public EnumConst newEnumValue(Class<?> enumType, String name) {
+            return new EnumConst(enumType, name);
+        }
+
+        @Override
+        public ErrorConst newErrorValue(String description) {
+            return new ErrorConst(description);
+        }
+    }
+}

test/jdk/jdk/internal/vm/AnnotationEncodingDecoding/TestAnnotationEncodingDecoding.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.vm.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MemberDeleted {
+    String value();
+    int retained();
+}

test/jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberDeleted.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.vm.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MemberTypeChanged {
+    String value();
+    int retained();
+    String any();
+}

test/jdk/jdk/internal/vm/AnnotationEncodingDecoding/alt/MemberTypeChanged.java

@@ -58,15 +58,6 @@ public void encodeDecodeTest() throws Exception {
         }
         encodeDecode(throwable);
     }
-    @SuppressWarnings("unchecked")
-    @Test
-    public void encodeDecodeTest2() throws Exception {
-        Throwable throwable = new ExceptionInInitializerError(new InvocationTargetException(new Untranslatable("test exception", new NullPointerException()), "invoke"));
-        for (int i = 0; i < 10; i++) {
-            throwable = new ExceptionInInitializerError(new InvocationTargetException(new RuntimeException(String.valueOf(i), throwable), "invoke"));
-        }
-        encodeDecode(throwable);
-    }
 
     private void encodeDecode(Throwable throwable) throws Exception {
         Unsafe unsafe = Unsafe.getUnsafe();