Exception proxy support

Author: loicottet

substratevm/src/com.oracle.svm.reflect/src/com/oracle/svm/reflect/hosted/AnnotationEncoder.java

@@ -25,44 +25,45 @@
 package com.oracle.svm.reflect.hosted;
 
 import java.util.function.Consumer;
-import java.util.function.Function;
 
 import org.graalvm.compiler.core.common.util.UnsafeArrayTypeWriter;
 import org.graalvm.compiler.debug.GraalError;
 
+import com.oracle.svm.core.code.CodeInfoEncoder.Encoders;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.AnnotationMemberValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.AnnotationValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.ArrayValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.ClassValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.EnumValue;
+import com.oracle.svm.util.SubstrateAnnotationExtracter.ExceptionProxyValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.PrimitiveValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.StringValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.TypeAnnotationValue;
 
 public class AnnotationEncoder {
-    static void encodeAnnotation(UnsafeArrayTypeWriter buf, AnnotationValue value, Function<Class<?>, Integer> classEncoder, Function<String, Integer> stringEncoder) {
-        buf.putS4(classEncoder.apply(value.getType()));
+    static void encodeAnnotation(UnsafeArrayTypeWriter buf, AnnotationValue value, Encoders encoders) {
+        buf.putS4(encoders.sourceClasses.getIndex(value.getType()));
         buf.putU2(value.getMemberCount());
         value.forEachMember((memberName, memberValue) -> {
-            buf.putS4(stringEncoder.apply(memberName));
-            encodeAnnotationMember(buf, memberValue, classEncoder, stringEncoder);
+            buf.putS4(encoders.sourceMethodNames.getIndex(memberName));
+            encodeAnnotationMember(buf, memberValue, encoders);
         });
     }
 
-    static void encodeAnnotationMember(UnsafeArrayTypeWriter buf, AnnotationMemberValue memberValue, Function<Class<?>, Integer> classEncoder, Function<String, Integer> stringEncoder) {
+    static void encodeAnnotationMember(UnsafeArrayTypeWriter buf, AnnotationMemberValue memberValue, Encoders encoders) {
         buf.putU1(memberValue.getTag());
         if (memberValue instanceof AnnotationValue) {
-            encodeAnnotation(buf, (AnnotationValue) memberValue, classEncoder, stringEncoder);
+            encodeAnnotation(buf, (AnnotationValue) memberValue, encoders);
         } else if (memberValue instanceof ClassValue) {
-            buf.putS4(classEncoder.apply(((ClassValue) memberValue).getValue()));
+            buf.putS4(encoders.sourceClasses.getIndex(((ClassValue) memberValue).getValue()));
         } else if (memberValue instanceof EnumValue) {
-            buf.putS4(classEncoder.apply(((EnumValue) memberValue).getType()));
-            buf.putS4(stringEncoder.apply(((EnumValue) memberValue).getName()));
+            buf.putS4(encoders.sourceClasses.getIndex(((EnumValue) memberValue).getType()));
+            buf.putS4(encoders.sourceMethodNames.getIndex(((EnumValue) memberValue).getName()));
         } else if (memberValue instanceof StringValue) {
-            buf.putS4(stringEncoder.apply(((StringValue) memberValue).getValue()));
+            buf.putS4(encoders.sourceMethodNames.getIndex(((StringValue) memberValue).getValue()));
         } else if (memberValue instanceof ArrayValue) {
             buf.putU2(((ArrayValue) memberValue).getElementCount());
-            ((ArrayValue) memberValue).forEachElement(element -> encodeAnnotationMember(buf, element, classEncoder, stringEncoder));
+            ((ArrayValue) memberValue).forEachElement(element -> encodeAnnotationMember(buf, element, encoders));
         } else if (memberValue instanceof PrimitiveValue) {
             Object value = ((PrimitiveValue) memberValue).getValue();
             switch (memberValue.getTag()) {
@@ -93,19 +94,21 @@ static void encodeAnnotationMember(UnsafeArrayTypeWriter buf, AnnotationMemberVa
                 default:
                     throw GraalError.shouldNotReachHere("Invalid annotation encoding");
             }
+        } else if (memberValue instanceof ExceptionProxyValue) {
+            buf.putS4(encoders.objectConstants.getIndex(((ExceptionProxyValue) memberValue).getObjectConstant()));
         } else {
             throw GraalError.shouldNotReachHere("Invalid annotation member type: " + memberValue.getClass());
         }
     }
 
-    static void encodeTypeAnnotation(UnsafeArrayTypeWriter buf, TypeAnnotationValue value, Function<Class<?>, Integer> classEncoder, Function<String, Integer> stringEncoder) {
+    static void encodeTypeAnnotation(UnsafeArrayTypeWriter buf, TypeAnnotationValue value, Encoders encoders) {
         for (byte b : value.getTargetInfo()) {
             buf.putU1(b);
         }
         for (byte b : value.getLocationInfo()) {
             buf.putU1(b);
         }
-        encodeAnnotation(buf, value.getAnnotationData(), classEncoder, stringEncoder);
+        encodeAnnotation(buf, value.getAnnotationData(), encoders);
     }
 
     static <T> void encodeArray(UnsafeArrayTypeWriter buf, T[] elements, Consumer<T> encoder) {

substratevm/src/com.oracle.svm.reflect/src/com/oracle/svm/reflect/hosted/ReflectionMetadataEncoderImpl.java

@@ -51,7 +51,6 @@
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
-import com.oracle.graal.pointsto.infrastructure.WrappedElement;
 import org.graalvm.compiler.core.common.util.TypeConversion;
 import org.graalvm.compiler.core.common.util.UnsafeArrayTypeWriter;
 import org.graalvm.compiler.debug.GraalError;
@@ -60,6 +59,7 @@
 import org.graalvm.nativeimage.impl.RuntimeReflectionSupport;
 import org.graalvm.util.GuardedAnnotationAccess;
 
+import com.oracle.graal.pointsto.infrastructure.WrappedElement;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
@@ -94,11 +94,13 @@
 import com.oracle.svm.util.SubstrateAnnotationExtracter;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.AnnotationMemberValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.AnnotationValue;
+import com.oracle.svm.util.SubstrateAnnotationExtracter.ExceptionProxyValue;
 import com.oracle.svm.util.SubstrateAnnotationExtracter.TypeAnnotationValue;
 
 import jdk.internal.reflect.Reflection;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.MetaAccessProvider;
+import sun.reflect.annotation.ExceptionProxy;
 
 /**
  * The reflection metadata encoder creates metadata for reflection objects (classes, fields, methods
@@ -132,6 +134,7 @@ public ReflectionMetadataEncoder create(CodeInfoEncoder.Encoders encoders) {
 
     private final CodeInfoEncoder.Encoders encoders;
     private final ReflectionDataAccessors accessors;
+    private final Map<ExceptionProxy, JavaConstant> annotationExceptionProxies = new HashMap<>();
     private final ReflectionDataBuilder dataBuilder;
     private final TreeSet<HostedType> sortedTypes = new TreeSet<>(Comparator.comparingLong(t -> t.getHub().getTypeID()));
     private final Map<HostedType, ClassMetadata> classData = new HashMap<>();
@@ -484,6 +487,13 @@ private void registerValues(AnnotationMemberValue annotationValue) {
         for (String string : annotationValue.getStrings()) {
             encoders.sourceMethodNames.addObject(string);
         }
+        if (annotationValue instanceof ExceptionProxyValue) {
+            ExceptionProxyValue exceptionProxy = (ExceptionProxyValue) annotationValue;
+            JavaConstant javaConstant = annotationExceptionProxies.computeIfAbsent(exceptionProxy.getExceptionProxy(),
+                            (ignored) -> SubstrateObjectConstant.forObject(exceptionProxy.getExceptionProxy()));
+            encoders.objectConstants.addObject(javaConstant);
+            exceptionProxy.setObjectConstant(javaConstant);
+        }
     }
 
     private ReflectParameterMetadata[] registerReflectParameters(Executable executable) {
@@ -905,7 +915,7 @@ public byte[] encodeAnnotations(AnnotationValue[] annotations) {
             return null;
         }
         UnsafeArrayTypeWriter buf = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess(), true);
-        AnnotationEncoder.encodeArray(buf, annotations, annotation -> AnnotationEncoder.encodeAnnotation(buf, annotation, encoders.sourceClasses::getIndex, encoders.sourceMethodNames::getIndex));
+        AnnotationEncoder.encodeArray(buf, annotations, annotation -> AnnotationEncoder.encodeAnnotation(buf, annotation, encoders));
         return buf.toArray();
     }
 
@@ -916,7 +926,7 @@ private byte[] encodeParameterAnnotations(AnnotationValue[][] parameterAnnotatio
         UnsafeArrayTypeWriter buf = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess(), true);
         buf.putU1(parameterAnnotations.length);
         for (AnnotationValue[] annotations : parameterAnnotations) {
-            AnnotationEncoder.encodeArray(buf, annotations, annotation -> AnnotationEncoder.encodeAnnotation(buf, annotation, encoders.sourceClasses::getIndex, encoders.sourceMethodNames::getIndex));
+            AnnotationEncoder.encodeArray(buf, annotations, annotation -> AnnotationEncoder.encodeAnnotation(buf, annotation, encoders));
         }
         return buf.toArray();
     }
@@ -926,7 +936,7 @@ private byte[] encodeAnnotationDefault(AnnotationMemberValue annotationDefault)
             return null;
         }
         UnsafeArrayTypeWriter buf = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess(), true);
-        AnnotationEncoder.encodeAnnotationMember(buf, annotationDefault, encoders.sourceClasses::getIndex, encoders.sourceMethodNames::getIndex);
+        AnnotationEncoder.encodeAnnotationMember(buf, annotationDefault, encoders);
         return buf.toArray();
     }
 
@@ -936,7 +946,7 @@ public byte[] encodeTypeAnnotations(TypeAnnotationValue[] typeAnnotations) {
         }
         UnsafeArrayTypeWriter buf = UnsafeArrayTypeWriter.create(ByteArrayReader.supportsUnalignedMemoryAccess(), true);
         AnnotationEncoder.encodeArray(buf, typeAnnotations,
-                        typeAnnotation -> AnnotationEncoder.encodeTypeAnnotation(buf, typeAnnotation, encoders.sourceClasses::getIndex, encoders.sourceMethodNames::getIndex));
+                        typeAnnotation -> AnnotationEncoder.encodeTypeAnnotation(buf, typeAnnotation, encoders));
         return buf.toArray();
     }