Crema: implement getExceptionHandlers() for crema-loaded types

gilles-duboscq · gilles-duboscq · commit f1fcdcd21fe8 · 2025-10-02T09:30:06.000+02:00
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/registry/SVMSymbols.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/registry/SVMSymbols.java
@@ -47,6 +47,7 @@ public static void ensureInitialized() {
 
     public static final class SVMTypes {
         public static final Symbol<Type> com_oracle_svm_core_hub_Hybrid = SYMBOLS.putType("Lcom/oracle/svm/core/hub/Hybrid;");
+        public static final Symbol<Type> java_lang_Throwable = SYMBOLS.putType("Ljava/lang/Throwable;");
 
         private SVMTypes() {
         }
diff --git a/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/CremaResolvedJavaMethodImpl.java b/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/CremaResolvedJavaMethodImpl.java
@@ -24,24 +24,83 @@
  */
 package com.oracle.svm.interpreter.metadata;
 
+import java.lang.invoke.VarHandle;
+
 import com.oracle.svm.core.hub.crema.CremaResolvedJavaMethod;
+import com.oracle.svm.core.hub.registry.SVMSymbols;
 import com.oracle.svm.core.reflect.CremaConstructorAccessor;
 import com.oracle.svm.core.reflect.CremaMethodAccessor;
 import com.oracle.svm.core.util.VMError;
+import com.oracle.svm.espresso.classfile.ExceptionHandler;
 import com.oracle.svm.espresso.classfile.ParserMethod;
+import com.oracle.svm.espresso.classfile.attributes.CodeAttribute;
+import com.oracle.svm.espresso.classfile.descriptors.Symbol;
+import com.oracle.svm.espresso.classfile.descriptors.Type;
 
 import jdk.vm.ci.meta.JavaType;
+import jdk.vm.ci.meta.ResolvedJavaType;
 
 public final class CremaResolvedJavaMethodImpl extends InterpreterResolvedJavaMethod implements CremaResolvedJavaMethod {
+    private final ExceptionHandler[] rawExceptionHandlers;
 
     private CremaResolvedJavaMethodImpl(InterpreterResolvedObjectType declaringClass, ParserMethod parserMethod, int vtableIndex) {
         super(declaringClass, parserMethod, vtableIndex);
+        CodeAttribute codeAttribute = (CodeAttribute) parserMethod.getAttribute(CodeAttribute.NAME);
+        if (codeAttribute != null) {
+            this.rawExceptionHandlers = codeAttribute.getExceptionHandlers();
+        } else {
+            this.rawExceptionHandlers = null;
+        }
     }
 
     public static InterpreterResolvedJavaMethod create(InterpreterResolvedObjectType declaringClass, ParserMethod m, int vtableIndex) {
         return new CremaResolvedJavaMethodImpl(declaringClass, m, vtableIndex);
     }
 
+    @Override
+    public jdk.vm.ci.meta.ExceptionHandler[] getExceptionHandlers() {
+        /*
+         * GR-70247 The interpreter should primarily use classfile.ExceptionHandler. This would
+         * avoid having to deal with the JavaType which is not needed during interpretation.
+         */
+        jdk.vm.ci.meta.ExceptionHandler[] result = exceptionHandlers;
+        if (result == null) {
+            boolean canCache = true;
+            if (rawExceptionHandlers == null || rawExceptionHandlers.length == 0) {
+                result = EMPTY_EXCEPTION_HANDLERS;
+            } else {
+                result = new jdk.vm.ci.meta.ExceptionHandler[rawExceptionHandlers.length];
+                InterpreterConstantPool constantPool = getConstantPool();
+                for (int i = 0; i < rawExceptionHandlers.length; i++) {
+                    ExceptionHandler exceptionHandler = rawExceptionHandlers[i];
+                    Symbol<Type> catchTypeSymbol = exceptionHandler.getCatchType();
+                    int catchTypeCPI = exceptionHandler.catchTypeCPI();
+                    JavaType catchType;
+                    if (SVMSymbols.SVMTypes.java_lang_Throwable.equals(catchTypeSymbol)) {
+                        catchTypeCPI = 0;
+                        catchType = null;
+                    } else if (catchTypeCPI != 0) {
+                        catchType = constantPool.findClassAt(catchTypeCPI);
+                        canCache = canCache && (catchType instanceof ResolvedJavaType);
+                    } else {
+                        assert catchTypeSymbol == null;
+                        catchType = null;
+                    }
+                    result[i] = new jdk.vm.ci.meta.ExceptionHandler(exceptionHandler.getStartBCI(),
+                                    exceptionHandler.getEndBCI(),
+                                    exceptionHandler.getHandlerBCI(),
+                                    catchTypeCPI,
+                                    catchType);
+                }
+                VarHandle.fullFence();
+            }
+            if (canCache) {
+                this.exceptionHandlers = result;
+            }
+        }
+        return result;
+    }
+
     @Override
     public JavaType[] getDeclaredExceptions() {
         // (GR-69097)
diff --git a/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterConstantPool.java b/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterConstantPool.java
@@ -35,9 +35,17 @@
 
 import com.oracle.svm.core.BuildPhaseProvider.AfterAnalysis;
 import com.oracle.svm.core.heap.UnknownObjectField;
+import com.oracle.svm.core.hub.DynamicHub;
+import com.oracle.svm.core.hub.crema.CremaSupport;
+import com.oracle.svm.core.hub.registry.SymbolsSupport;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.espresso.classfile.ConstantPool;
 import com.oracle.svm.espresso.classfile.ParserConstantPool;
+import com.oracle.svm.espresso.classfile.descriptors.ByteSequence;
+import com.oracle.svm.espresso.classfile.descriptors.Name;
+import com.oracle.svm.espresso.classfile.descriptors.Symbol;
+import com.oracle.svm.espresso.classfile.descriptors.Type;
+import com.oracle.svm.espresso.classfile.descriptors.TypeSymbols;
 import com.oracle.svm.interpreter.metadata.serialization.VisibleForSerialization;
 
 import jdk.vm.ci.meta.JavaConstant;
@@ -331,4 +339,22 @@ public long longAt(int index) {
         }
         return super.longAt(index);
     }
+
+    public JavaType findClassAt(int cpi) {
+        if (peekCachedEntry(cpi) instanceof InterpreterResolvedObjectType type) {
+            return type;
+        }
+        Symbol<Name> nameSymbol = className(cpi);
+        ByteSequence typeBytes = TypeSymbols.nameToType(nameSymbol);
+        Symbol<Type> typeSymbol = SymbolsSupport.getTypes().lookupValidType(typeBytes);
+        if (typeSymbol == null) {
+            return null;
+        }
+        Class<?> cls = CremaSupport.singleton().findLoadedClass(typeSymbol, getHolder());
+        if (cls == null) {
+            return UnresolvedJavaType.create(typeBytes.toString());
+        } else {
+            return DynamicHub.fromClass(cls).getInterpreterType();
+        }
+    }
 }
diff --git a/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterResolvedJavaMethod.java b/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterResolvedJavaMethod.java
@@ -68,6 +68,7 @@
 public class InterpreterResolvedJavaMethod implements ResolvedJavaMethod, CremaMethodAccess {
     public static final InterpreterResolvedJavaMethod[] EMPTY_ARRAY = new InterpreterResolvedJavaMethod[0];
     public static final LocalVariableTable EMPTY_LOCAL_VARIABLE_TABLE = new LocalVariableTable(new Local[0]);
+    public static final ExceptionHandler[] EMPTY_EXCEPTION_HANDLERS = new ExceptionHandler[0];
 
     public static final int UNKNOWN_METHOD_ID = 0;
 
@@ -89,7 +90,7 @@ public class InterpreterResolvedJavaMethod implements ResolvedJavaMethod, CremaM
 
     private final LineNumberTable lineNumberTable;
 
-    private ExceptionHandler[] exceptionHandlers;
+    protected ExceptionHandler[] exceptionHandlers;
 
     private LocalVariableTable localVariableTable;
 
@@ -340,7 +341,7 @@ public final boolean isConstructor() {
     }
 
     @Override
-    public final ExceptionHandler[] getExceptionHandlers() {
+    public ExceptionHandler[] getExceptionHandlers() {
         ExceptionHandler[] result = exceptionHandlers;
         VMError.guarantee(result != null);
         return result;
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/BuildTimeConstantPool.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/BuildTimeConstantPool.java
@@ -41,6 +41,7 @@
 import static com.oracle.svm.interpreter.metadata.Bytecodes.NEW;
 import static com.oracle.svm.interpreter.metadata.Bytecodes.PUTFIELD;
 import static com.oracle.svm.interpreter.metadata.Bytecodes.PUTSTATIC;
+import static com.oracle.svm.interpreter.metadata.InterpreterResolvedJavaMethod.EMPTY_EXCEPTION_HANDLERS;
 
 import java.util.List;
 
@@ -88,9 +89,6 @@
  */
 @Platforms(Platform.HOSTED_ONLY.class)
 final class BuildTimeConstantPool {
-
-    private static final ExceptionHandler[] EMPTY_EXCEPTION_HANDLERS = new ExceptionHandler[0];
-
     private final ConstantPoolBuilder poolBuilder;
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@ public static void ensureInitialized() {`
`47`	`47`
`48`	`48`	`public static final class SVMTypes {`
`49`	`49`	`public static final Symbol<Type> com_oracle_svm_core_hub_Hybrid = SYMBOLS.putType("Lcom/oracle/svm/core/hub/Hybrid;");`
	`50`	`+ public static final Symbol<Type> java_lang_Throwable = SYMBOLS.putType("Ljava/lang/Throwable;");`
`50`	`51`
`51`	`52`	`private SVMTypes() {`
`52`	`53`	`}`