fixup! Don't create JNINativeCallWrapperMethods for JNICallTrampoline…

…Methods

substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/JNIJavaCallTrampolines.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017, 2021, 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.jni;
+
+import com.oracle.svm.core.util.VMError;
+import com.oracle.svm.jni.hosted.JNIJavaCallWrapperMethod;
+import com.oracle.svm.jni.hosted.JNIJavaCallWrapperMethod.CallVariant;
+
+import jdk.vm.ci.meta.ConstantPool;
+import jdk.vm.ci.meta.MetaAccessProvider;
+
+/**
+ * Holder class for generated {@link JNIJavaCallWrapperMethod} code.
+ */
+public final class JNIJavaCallTrampolines {
+    public static ConstantPool getConstantPool(MetaAccessProvider metaAccess) {
+        // Each generated call wrapper needs an actual constant pool, so we provide our
+        // private constructor's
+        return metaAccess.lookupJavaType(JNIJavaCallWrappers.class).getDeclaredConstructors()[0].getConstantPool();
+    }
+
+    public static String getTrampolineName(CallVariant variant, boolean nonVirtual) {
+        StringBuilder name = new StringBuilder(48);
+        if (variant == CallVariant.VARARGS) {
+            name.append("varargs");
+        } else if (variant == CallVariant.ARRAY) {
+            name.append("array");
+        } else if (variant == CallVariant.VA_LIST) {
+            name.append("valist");
+        } else {
+            throw VMError.shouldNotReachHere();
+        }
+        if (nonVirtual) {
+            name.append("Nonvirtual");
+        }
+        name.append("JavaCallTrampoline");
+        return name.toString();
+    }
+
+    private JNIJavaCallTrampolines() {
+    }
+
+    private native void varargsJavaCallTrampoline();
+
+    private native void arrayJavaCallTrampoline();
+
+    private native void valistJavaCallTrampoline();
+
+    private native void varargsNonvirtualJavaCallTrampoline();
+
+    private native void arrayNonvirtualJavaCallTrampoline();
+
+    private native void valistNonvirtualJavaCallTrampoline();
+}

substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/JNIJavaCallWrappers.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2021, 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
@@ -24,15 +24,13 @@
  */
 package com.oracle.svm.jni;
 
-import com.oracle.svm.core.util.VMError;
-import com.oracle.svm.jni.hosted.JNIJavaCallWrapperMethod;
-import com.oracle.svm.jni.hosted.JNIJavaCallWrapperMethod.CallVariant;
+import com.oracle.svm.jni.hosted.JNICallTrampolineMethod;
 
 import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.MetaAccessProvider;
 
 /**
- * Holder class for generated {@link JNIJavaCallWrapperMethod} code.
+ * Holder class for generated {@link JNICallTrampolineMethod} code.
  */
 public final class JNIJavaCallWrappers {
     public static ConstantPool getConstantPool(MetaAccessProvider metaAccess) {
@@ -41,36 +39,6 @@ public static ConstantPool getConstantPool(MetaAccessProvider metaAccess) {
         return metaAccess.lookupJavaType(JNIJavaCallWrappers.class).getDeclaredConstructors()[0].getConstantPool();
     }
 
-    public static String getTrampolineName(CallVariant variant, boolean nonVirtual) {
-        StringBuilder name = new StringBuilder(48);
-        if (variant == CallVariant.VARARGS) {
-            name.append("varargs");
-        } else if (variant == CallVariant.ARRAY) {
-            name.append("array");
-        } else if (variant == CallVariant.VA_LIST) {
-            name.append("valist");
-        } else {
-            throw VMError.shouldNotReachHere();
-        }
-        if (nonVirtual) {
-            name.append("Nonvirtual");
-        }
-        name.append("JavaCallTrampoline");
-        return name.toString();
-    }
-
     private JNIJavaCallWrappers() {
     }
-
-    private native void varargsJavaCallTrampoline();
-
-    private native void arrayJavaCallTrampoline();
-
-    private native void valistJavaCallTrampoline();
-
-    private native void varargsNonvirtualJavaCallTrampoline();
-
-    private native void arrayNonvirtualJavaCallTrampoline();
-
-    private native void valistNonvirtualJavaCallTrampoline();
 }

substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/access/JNIAccessFeature.java

@@ -28,6 +28,7 @@
 
 import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collections;
@@ -37,7 +38,8 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Stream;
 
-import com.oracle.svm.core.util.VMError;
+import com.oracle.svm.jni.JNIJavaCallTrampolines;
+import com.oracle.svm.util.ReflectionUtil;
 import org.graalvm.compiler.api.replacements.Fold;
 import org.graalvm.compiler.options.Option;
 import org.graalvm.nativeimage.ImageSingletons;
@@ -68,7 +70,6 @@
 import com.oracle.svm.hosted.config.ConfigurationParserUtils;
 import com.oracle.svm.hosted.meta.MaterializedConstantFields;
 import com.oracle.svm.hosted.substitute.SubstitutionReflectivityFilter;
-import com.oracle.svm.jni.JNIJavaCallWrappers;
 import com.oracle.svm.jni.JNISupport;
 import com.oracle.svm.jni.hosted.JNICallTrampolineMethod;
 import com.oracle.svm.jni.hosted.JNIFieldAccessorMethod;
@@ -186,20 +187,16 @@ private void createJavaCallTrampoline(BeforeAnalysisAccessImpl access, CallVaria
         ResolvedJavaField field = JNIAccessibleMethod.getCallWrapperField(wrappedMetaAccess, variant, nonVirtual);
         access.getUniverse().lookup(field.getDeclaringClass()).registerAsReachable();
         access.registerAsAccessed(access.getUniverse().lookup(field));
-        String trampolineName = JNIJavaCallWrappers.getTrampolineName(variant, nonVirtual);
-        ResolvedJavaMethod method;
-        try {
-            method = wrappedMetaAccess.lookupJavaMethod(JNIJavaCallWrappers.class.getDeclaredMethod(trampolineName));
-        } catch (NoSuchMethodException e) {
-            throw VMError.shouldNotReachHere(e);
-        }
+        String trampolineName = JNIJavaCallTrampolines.getTrampolineName(variant, nonVirtual);
+        Method reflectionMethod = ReflectionUtil.lookupMethod(JNIJavaCallTrampolines.class, trampolineName);
+        ResolvedJavaMethod method = wrappedMetaAccess.lookupJavaMethod(reflectionMethod);
         JNICallTrampolineMethod trampoline = new JNICallTrampolineMethod(method, field, nonVirtual);
         access.registerAsCompiled(access.getUniverse().lookup(trampoline));
         trampolineMethods.put(trampolineName, trampoline);
     }
 
     public JNICallTrampolineMethod getCallTrampolineMethod(CallVariant variant, boolean nonVirtual) {
-        String trampolineName = JNIJavaCallWrappers.getTrampolineName(variant, nonVirtual);
+        String trampolineName = JNIJavaCallTrampolines.getTrampolineName(variant, nonVirtual);
         return getCallTrampolineMethod(trampolineName);
     }
 

substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/hosted/JNINativeCallWrapperSubstitutionProcessor.java

@@ -29,7 +29,9 @@
 
 import com.oracle.graal.pointsto.infrastructure.SubstitutionProcessor;
 
+import com.oracle.svm.jni.JNIJavaCallTrampolines;
 import com.oracle.svm.jni.access.JNIAccessFeature;
+import jdk.vm.ci.meta.MetaUtil;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 /**
@@ -42,7 +44,8 @@ class JNINativeCallWrapperSubstitutionProcessor extends SubstitutionProcessor {
     @Override
     public ResolvedJavaMethod lookup(ResolvedJavaMethod method) {
         assert method.isNative() : "Must have been registered as a native substitution processor";
-        if (method.getDeclaringClass().getName().equals("Lcom/oracle/svm/jni/JNIJavaCallWrappers;")) {
+        String jniJavaCallWrappersInternalName = MetaUtil.toInternalName(JNIJavaCallTrampolines.class.getTypeName());
+        if (method.getDeclaringClass().getName().equals(jniJavaCallWrappersInternalName)) {
             // Avoid generating JNINativeCallWrapperMethods for trampolines
             JNICallTrampolineMethod callTrampolineMethod = JNIAccessFeature.singleton().getCallTrampolineMethod(method.getName());
             if (callTrampolineMethod != null) {
@@ -56,6 +59,8 @@ public ResolvedJavaMethod lookup(ResolvedJavaMethod method) {
     public ResolvedJavaMethod resolve(ResolvedJavaMethod method) {
         if (method instanceof JNINativeCallWrapperMethod) {
             return ((JNINativeCallWrapperMethod) method).getOriginal();
+        } else if (method instanceof JNICallTrampolineMethod) {
+            return ((JNICallTrampolineMethod) method).getOriginal();
         }
         return method;
     }