Add reachability handler registration for class initializers

yangdaotan · Jan 5, 2021 · b8b757c · b8b757c
1 parent 8ba9bde
commit b8b757c
Show file tree

Hide file tree

Showing 5 changed files with 31 additions and 8 deletions.
diff --git a/sdk/src/org.graalvm.nativeimage/snapshot.sigtest b/sdk/src/org.graalvm.nativeimage/snapshot.sigtest
@@ -819,6 +819,7 @@ meth public abstract void registerAsUnsafeAccessed(java.lang.reflect.Field)
 meth public abstract void registerAsUsed(java.lang.Class<?>)
 meth public abstract void registerMethodOverrideReachabilityHandler(java.util.function.BiConsumer<org.graalvm.nativeimage.hosted.Feature$DuringAnalysisAccess,java.lang.reflect.Executable>,java.lang.reflect.Executable)
 meth public abstract void registerSubtypeReachabilityHandler(java.util.function.BiConsumer<org.graalvm.nativeimage.hosted.Feature$DuringAnalysisAccess,java.lang.Class<?>>,java.lang.Class<?>)
+meth public abstract void registerClassInitializerReachabilityHandler(java.util.function.Consumer<org.graalvm.nativeimage.hosted.Feature$DuringAnalysisAccess>,java.lang.Class<?>)
 
 CLSS public abstract interface static org.graalvm.nativeimage.hosted.Feature$BeforeCompilationAccess
  outer org.graalvm.nativeimage.hosted.Feature

diff --git a/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/Feature.java b/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/Feature.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -252,6 +252,14 @@ interface BeforeAnalysisAccess extends FeatureAccess {
          * @since 19.3
          */
         void registerSubtypeReachabilityHandler(BiConsumer<DuringAnalysisAccess, Class<?>> callback, Class<?> baseClass);
+
+        /**
+         * Registers a callback that is invoked once {@link Feature#duringAnalysis during analysis}
+         * when the class initializer for the given type is determined to be reachable at run time.
+         *
+         * @since 21.0
+         */
+        void registerClassInitializerReachabilityHandler(Consumer<DuringAnalysisAccess> callback, Class<?> clazz);
     }
 
     /**

diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FeatureImpl.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/FeatureImpl.java
@@ -426,6 +426,11 @@ public void registerMethodOverrideReachabilityHandler(BiConsumer<DuringAnalysisA
         public void registerSubtypeReachabilityHandler(BiConsumer<DuringAnalysisAccess, Class<?>> callback, Class<?> baseClass) {
             ReachabilityHandlerFeature.singleton().registerSubtypeReachabilityHandler(this, callback, baseClass);
         }
+
+        @Override
+        public void registerClassInitializerReachabilityHandler(Consumer<DuringAnalysisAccess> callback, Class<?> clazz) {
+            ReachabilityHandlerFeature.singleton().registerClassInitializerReachabilityHandler(this, callback, clazz);
+        }
     }
 
     public static class DuringAnalysisAccessImpl extends BeforeAnalysisAccessImpl implements Feature.DuringAnalysisAccess {

diff --git a/...atevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ReachabilityHandlerFeature.java b/...atevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ReachabilityHandlerFeature.java
@@ -59,18 +59,22 @@ public static ReachabilityHandlerFeature singleton() {
     }
 
     public void registerMethodOverrideReachabilityHandler(BeforeAnalysisAccessImpl a, BiConsumer<DuringAnalysisAccess, Executable> callback, Executable baseMethod) {
-        registerReachabilityHandler(a, callback, new Executable[]{baseMethod});
+        registerReachabilityHandler(a, callback, new Executable[]{baseMethod}, false);
     }
 
     public void registerSubtypeReachabilityHandler(BeforeAnalysisAccess a, BiConsumer<DuringAnalysisAccess, Class<?>> callback, Class<?> baseClass) {
-        registerReachabilityHandler(a, callback, new Class<?>[]{baseClass});
+        registerReachabilityHandler(a, callback, new Class<?>[]{baseClass}, false);
+    }
+
+    public void registerClassInitializerReachabilityHandler(BeforeAnalysisAccess a, Consumer<DuringAnalysisAccess> callback, Class<?> clazz) {
+        registerReachabilityHandler(a, callback, new Class<?>[]{clazz}, true);
     }
 
     public void registerReachabilityHandler(BeforeAnalysisAccess a, Consumer<DuringAnalysisAccess> callback, Object[] triggers) {
-        registerReachabilityHandler(a, (Object) callback, triggers);
+        registerReachabilityHandler(a, callback, triggers, false);
     }
 
-    private void registerReachabilityHandler(BeforeAnalysisAccess a, Object callback, Object[] triggers) {
+    private void registerReachabilityHandler(BeforeAnalysisAccess a, Object callback, Object[] triggers, boolean triggerOnClassInitializer) {
         if (triggeredHandlers.containsKey(callback)) {
             /* Handler has already been triggered from another registration, so nothing to do. */
             return;
@@ -83,7 +87,8 @@ private void registerReachabilityHandler(BeforeAnalysisAccess a, Object callback
 
         for (Object trigger : triggers) {
             if (trigger instanceof Class) {
-                triggerSet.add(metaAccess.lookupJavaType((Class<?>) trigger));
+                AnalysisType aType = metaAccess.lookupJavaType((Class<?>) trigger);
+                triggerSet.add(triggerOnClassInitializer ? aType.getClassInitializer() : aType);
             } else if (trigger instanceof Field) {
                 triggerSet.add(metaAccess.lookupJavaField((Field) trigger));
             } else if (trigger instanceof Executable) {
@@ -140,7 +145,11 @@ private static boolean isTriggered(DuringAnalysisAccessImpl access, Set<Object>
                     return true;
                 }
             } else if (trigger instanceof AnalysisMethod) {
-                if (access.isReachable((AnalysisMethod) trigger)) {
+                AnalysisMethod triggerMethod = (AnalysisMethod) trigger;
+                if (access.isReachable(triggerMethod)) {
+                    return true;
+                }
+                if (triggerMethod.isClassInitializer() && triggerMethod.getDeclaringClass().isInitialized()) {
                     return true;
                 }
             } else {

diff --git a/...rc/com.oracle.svm.methodhandles/src/com/oracle/svm/methodhandles/MethodHandleFeature.java b/...rc/com.oracle.svm.methodhandles/src/com/oracle/svm/methodhandles/MethodHandleFeature.java
@@ -108,7 +108,7 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
         access.registerReachabilityHandler(MethodHandleFeature::registerValueConversionIgnoreForReflection,
                         ReflectionUtil.lookupMethod(ValueConversions.class, "ignore"));
 
-        access.registerReachabilityHandler(MethodHandleFeature::registerDelegatingMHFunctionsForReflection,
+        access.registerClassInitializerReachabilityHandler(MethodHandleFeature::registerDelegatingMHFunctionsForReflection,
                         access.findClassByName("java.lang.invoke.DelegatingMethodHandle"));
 
         access.registerReachabilityHandler(MethodHandleFeature::registerCallSiteGetTargetForReflection,