Synthesize the correct exception in case of incompatible class changes

Author: Christian Wimmer

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/BigBang.java

@@ -129,4 +129,9 @@ default void onTypeInitialized(AnalysisType type) {
     default void afterAnalysis() {
 
     }
+
+    @SuppressWarnings("unused")
+    default AnalysisMethod fallbackResolveConcreteMethod(AnalysisType resolvingType, AnalysisMethod method) {
+        return null;
+    }
 }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java

@@ -1046,6 +1046,9 @@ public AnalysisMethod resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJ
             ResolvedJavaType substCallerType = substMethod.getDeclaringClass();
 
             Object newResolvedMethod = universe.lookup(wrapped.resolveConcreteMethod(substMethod, substCallerType));
+            if (newResolvedMethod == null) {
+                newResolvedMethod = getUniverse().getBigbang().fallbackResolveConcreteMethod(this, (AnalysisMethod) method);
+            }
             if (newResolvedMethod == null) {
                 newResolvedMethod = NULL_METHOD;
             }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/analysis/NativeImagePointsToAnalysis.java

@@ -24,6 +24,9 @@
  */
 package com.oracle.svm.hosted.analysis;
 
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.concurrent.ForkJoinPool;
 
 import org.graalvm.compiler.options.OptionValues;
@@ -43,6 +46,7 @@
 import com.oracle.svm.core.graal.meta.SubstrateReplacements;
 import com.oracle.svm.hosted.HostedConfiguration;
 import com.oracle.svm.hosted.SVMHost;
+import com.oracle.svm.hosted.code.IncompatibleClassChangeFallbackMethod;
 import com.oracle.svm.hosted.meta.HostedType;
 import com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor;
 
@@ -140,4 +144,71 @@ public boolean trackConcreteAnalysisObjects(AnalysisType type) {
     public SubstrateReplacements getReplacements() {
         return (SubstrateReplacements) super.getReplacements();
     }
+
+    /** See {@link IncompatibleClassChangeFallbackMethod} for documentation. */
+    @Override
+    public AnalysisMethod fallbackResolveConcreteMethod(AnalysisType resolvingType, AnalysisMethod method) {
+        if (!resolvingType.isAbstract() && !resolvingType.isInterface() && !method.isStatic() && method.getDeclaringClass().isAssignableFrom(resolvingType)) {
+            /*
+             * We are resolving an instance method for a concrete (non-abstract) class that is a
+             * subtype of the method's declared type. So this is a method invocation that can happen
+             * at run time, and we need to return a method that throws an exception when being
+             * executed.
+             */
+
+            if (method.getWrapped() instanceof IncompatibleClassChangeFallbackMethod) {
+                /*
+                 * We are re-resolving a method that we already processed. Nothing to do, we already
+                 * have the appropriate fallback method.
+                 */
+                return method;
+            }
+            return getUniverse().lookup(new IncompatibleClassChangeFallbackMethod(resolvingType.getWrapped(), method.getWrapped(), findResolutionError(resolvingType, method.getJavaMethod())));
+        }
+        return super.fallbackResolveConcreteMethod(resolvingType, method);
+    }
+
+    /**
+     * Finding the correct exception that needs to be thrown at run time is a bit tricky, since
+     * JVMCI does not report that information back when method resolution fails. We need to look
+     * down the class hierarchy to see if there would be an appropriate method with a matching
+     * signature which is just not accessible.
+     *
+     * We do all the method lookups (to search for a method with the same signature as searchMethod)
+     * using reflection and not JVMCI because the lookup can throw all sorts of errors, and we want
+     * to ignore the errors without any possible side effect on AnalysisType and AnalysisMethod.
+     */
+    private static Class<? extends IncompatibleClassChangeError> findResolutionError(AnalysisType resolvingType, Executable searchMethod) {
+        if (searchMethod != null) {
+            Class<?>[] searchSignature = searchMethod.getParameterTypes();
+            for (Class<?> cur = resolvingType.getJavaClass(); cur != null; cur = cur.getSuperclass()) {
+                Method found;
+                try {
+                    found = cur.getDeclaredMethod(searchMethod.getName(), searchSignature);
+                } catch (Throwable ex) {
+                    /*
+                     * Method does not exist, a linkage error was thrown, or something else random
+                     * is wrong with the class files. Ignore this class.
+                     */
+                    continue;
+                }
+                if (Modifier.isAbstract(found.getModifiers()) || Modifier.isPrivate(found.getModifiers()) || Modifier.isStatic(found.getModifiers())) {
+                    /*
+                     * We found a method with a matching signature, but it does not have an
+                     * implementation, or it is a private / static method that does not count from
+                     * the point of view of method resolution.
+                     */
+                    return AbstractMethodError.class;
+                } else {
+                    /*
+                     * We found a method with a matching signature, but it must have the wrong
+                     * access modifier (otherwise method resolution would have returned it).
+                     */
+                    return IllegalAccessError.class;
+                }
+            }
+        }
+        /* Not matching method found at all. */
+        return AbstractMethodError.class;
+    }
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/IncompatibleClassChangeFallbackMethod.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2022, 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.oracle.svm.hosted.code;
+
+import org.graalvm.compiler.debug.DebugContext;
+import org.graalvm.compiler.nodes.CallTargetNode.InvokeKind;
+import org.graalvm.compiler.nodes.StructuredGraph;
+import org.graalvm.compiler.nodes.UnwindNode;
+import org.graalvm.compiler.nodes.java.AbstractNewObjectNode;
+import org.graalvm.compiler.nodes.java.NewInstanceNode;
+
+import com.oracle.graal.pointsto.meta.HostedProviders;
+import com.oracle.svm.hosted.analysis.NativeImagePointsToAnalysis;
+import com.oracle.svm.hosted.phases.HostedGraphKit;
+import com.oracle.svm.util.ReflectionUtil;
+
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+import jdk.vm.ci.meta.ResolvedJavaType;
+
+/**
+ * When interface/virtual call resolution via JVMCI does not return a concrete implementation method
+ * for a concrete implementation type, then most likely some classes are in an incompatible state,
+ * i.e., a class was compiled against a different version of a dependent class than the class we got
+ * on the class path. Since we use vtable calls for all interface/virtual method calls, we cannot
+ * just leave such unresolved methods as "no method is invoked" in the static analysis and "null" in
+ * the vtable: that would lead to wrong static analysis results, wrong devirtualizations, and/or
+ * vtable calls to uninitialized vtable slots.
+ *
+ * The solution is to always resolve a concrete synthetic fallback method, which then throws the
+ * correct error at run time. This "fallback resolution" is implemented in
+ * {@link NativeImagePointsToAnalysis#fallbackResolveConcreteMethod}.
+ */
+public final class IncompatibleClassChangeFallbackMethod extends NonBytecodeMethod {
+
+    private final ResolvedJavaMethod original;
+    private final Class<? extends IncompatibleClassChangeError> resolutionError;
+
+    public IncompatibleClassChangeFallbackMethod(ResolvedJavaType declaringClass, ResolvedJavaMethod original, Class<? extends IncompatibleClassChangeError> resolutionError) {
+        super(original.getName(), false, declaringClass, original.getSignature(), original.getConstantPool());
+        this.original = original;
+        this.resolutionError = resolutionError;
+    }
+
+    public ResolvedJavaMethod getOriginal() {
+        return original;
+    }
+
+    @Override
+    public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) {
+        HostedGraphKit kit = new HostedGraphKit(debug, providers, method);
+        ResolvedJavaMethod constructor = providers.getMetaAccess().lookupJavaMethod(ReflectionUtil.lookupConstructor(resolutionError));
+
+        AbstractNewObjectNode newInstance = kit.append(new NewInstanceNode(constructor.getDeclaringClass(), true));
+        kit.createInvokeWithExceptionAndUnwind(constructor, InvokeKind.Special, kit.getFrameState(), kit.bci(), newInstance);
+        kit.append(new UnwindNode(newInstance));
+        return kit.finalizeGraph();
+    }
+}

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/SharedGraphBuilderPhase.java

@@ -24,6 +24,11 @@
  */
 package com.oracle.svm.hosted.phases;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
 import java.util.List;
 
 import org.graalvm.compiler.api.replacements.Fold;
@@ -63,7 +68,9 @@
 
 import com.oracle.graal.pointsto.constraints.TypeInstantiationException;
 import com.oracle.graal.pointsto.constraints.UnresolvedElementException;
+import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider;
 import com.oracle.graal.pointsto.infrastructure.UniverseMetaAccess;
+import com.oracle.graal.pointsto.util.GraalAccess;
 import com.oracle.svm.common.meta.MultiMethod;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.SubstrateUtil;
@@ -435,11 +442,76 @@ private void handleUnresolvedMethod(JavaMethod javaMethod) {
                 if (linkAtBuildTime) {
                     reportUnresolvedElement("method", javaMethod.format("%H.%n(%P)"));
                 } else {
-                    ExceptionSynthesizer.throwException(this, NoSuchMethodError.class, javaMethod.format("%H.%n(%P)"));
+                    ExceptionSynthesizer.throwException(this, findResolutionError((ResolvedJavaType) declaringClass, javaMethod), javaMethod.format("%H.%n(%P)"));
                 }
             }
         }
 
+        /**
+         * Finding the correct exception that needs to be thrown at run time is a bit tricky, since
+         * JVMCI does not report that information back when method resolution fails. We need to look
+         * down the class hierarchy to see if there would be an appropriate method with a matching
+         * signature which is just not accessible.
+         *
+         * We do all the method lookups (to search for a method with the same signature as
+         * searchMethod) using reflection and not JVMCI because the lookup can throw all sorts of
+         * errors, and we want to ignore the errors without any possible side effect on AnalysisType
+         * and AnalysisMethod.
+         */
+        private static Class<? extends IncompatibleClassChangeError> findResolutionError(ResolvedJavaType declaringType, JavaMethod searchMethod) {
+            Class<?>[] searchSignature = signatureToClasses(searchMethod);
+            Class<?> searchReturnType = null;
+            if (searchMethod.getSignature().getReturnType(null) instanceof ResolvedJavaType) {
+                searchReturnType = OriginalClassProvider.getJavaClass(GraalAccess.getOriginalSnippetReflection(), (ResolvedJavaType) searchMethod.getSignature().getReturnType(null));
+            }
+
+            Class<?> declaringClass = OriginalClassProvider.getJavaClass(GraalAccess.getOriginalSnippetReflection(), declaringType);
+            for (Class<?> cur = declaringClass; cur != null; cur = cur.getSuperclass()) {
+                Executable[] methods = null;
+                try {
+                    if (searchMethod.getName().equals("<init>")) {
+                        methods = cur.getDeclaredConstructors();
+                    } else {
+                        methods = cur.getDeclaredMethods();
+                    }
+                } catch (Throwable ignored) {
+                    /*
+                     * A linkage error was thrown, or something else random is wrong with the class
+                     * files. Ignore this class.
+                     */
+                }
+                if (methods != null) {
+                    for (Executable method : methods) {
+                        if (Arrays.equals(searchSignature, method.getParameterTypes()) &&
+                                        (method instanceof Constructor || (searchMethod.getName().equals(method.getName()) && searchReturnType == ((Method) method).getReturnType()))) {
+                            if (Modifier.isAbstract(method.getModifiers())) {
+                                return AbstractMethodError.class;
+                            } else {
+                                return IllegalAccessError.class;
+                            }
+                        }
+                    }
+                }
+                if (searchMethod.getName().equals("<init>")) {
+                    /* For constructors, do not search in superclasses. */
+                    break;
+                }
+            }
+            return NoSuchMethodError.class;
+        }
+
+        private static Class<?>[] signatureToClasses(JavaMethod method) {
+            int paramCount = method.getSignature().getParameterCount(false);
+            Class<?>[] result = new Class<?>[paramCount];
+            for (int i = 0; i < paramCount; i++) {
+                JavaType parameterType = method.getSignature().getParameterType(0, null);
+                if (parameterType instanceof ResolvedJavaType) {
+                    result[i] = OriginalClassProvider.getJavaClass(GraalAccess.getOriginalSnippetReflection(), (ResolvedJavaType) parameterType);
+                }
+            }
+            return result;
+        }
+
         private void reportUnresolvedElement(String elementKind, String elementAsString) {
             reportUnresolvedElement(elementKind, elementAsString, null);
         }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotationSubstitutionProcessor.java

@@ -75,6 +75,7 @@
 import com.oracle.svm.hosted.annotation.AnnotationSubstitutionType;
 import com.oracle.svm.hosted.annotation.CustomSubstitutionMethod;
 import com.oracle.svm.hosted.classinitialization.ClassInitializationSupport;
+import com.oracle.svm.hosted.code.IncompatibleClassChangeFallbackMethod;
 import com.oracle.svm.util.ReflectionUtil;
 import com.oracle.svm.util.ReflectionUtil.ReflectionUtilError;
 
@@ -299,14 +300,20 @@ public ResolvedJavaMethod lookup(ResolvedJavaMethod method) {
 
     @Override
     public ResolvedJavaMethod resolve(ResolvedJavaMethod method) {
-        if (method instanceof SubstitutionMethod) {
-            return ((SubstitutionMethod) method).getOriginal();
-        } else if (method instanceof CustomSubstitutionMethod) {
-            return ((CustomSubstitutionMethod) method).getOriginal();
-        } else if (method instanceof AnnotatedMethod) {
-            return ((AnnotatedMethod) method).getOriginal();
+        ResolvedJavaMethod cur = method;
+        while (true) {
+            if (cur instanceof SubstitutionMethod) {
+                cur = ((SubstitutionMethod) cur).getOriginal();
+            } else if (cur instanceof CustomSubstitutionMethod) {
+                cur = ((CustomSubstitutionMethod) cur).getOriginal();
+            } else if (cur instanceof AnnotatedMethod) {
+                cur = ((AnnotatedMethod) cur).getOriginal();
+            } else if (cur instanceof IncompatibleClassChangeFallbackMethod) {
+                cur = ((IncompatibleClassChangeFallbackMethod) cur).getOriginal();
+            } else {
+                return cur;
+            }
         }
-        return method;
     }
 
     /**