Refactor Libgraal and avoid reflection to improve startup.

Author: chumer

truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/hotspot/libgraal/LibGraal.java

@@ -42,10 +42,7 @@
 
 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-
+import org.graalvm.nativeimage.ImageInfo;
 import org.graalvm.nativeimage.IsolateThread;
 import org.graalvm.nativeimage.c.function.CEntryPoint;
 import org.graalvm.word.PointerBase;
@@ -58,62 +55,44 @@
 import jdk.vm.ci.hotspot.HotSpotResolvedJavaType;
 import jdk.vm.ci.hotspot.HotSpotSpeculationLog;
 import jdk.vm.ci.services.Services;
-import org.graalvm.nativeimage.ImageInfo;
 
 /**
  * Access to libgraal, a shared library containing an AOT compiled version of Graal produced by
  * GraalVM Native Image. The libgraal library is only available if the HotSpot
  * {@code UseJVMCINativeLibrary} flag is true and the current runtime includes the relevant JVMCI
  * API additions for accessing libgraal.
  *
- * The {@link #isAvailable()} method is provided to test these conditions. It must be used to guard
- * usage of all other methods in this class. In addition, only the following methods can be called
- * from within libgraal:
- * <ul>
- * <li>{@link #isAvailable()}</li>
- * <li>{@link #translate(Object)}</li>
- * <li>{@link #unhand(Class, long)}</li>
- * </ul>
- *
  * The typical usage of this class is to {@linkplain #registerNativeMethods link} and call
  * {@link CEntryPoint}s in libgraal. Each call to a {@link CEntryPoint} requires an
  * {@link IsolateThread} argument which can be {@linkplain LibGraalScope#getIsolateThread obtained}
  * from a {@link LibGraalScope}.
  */
 public class LibGraal {
 
-    // NOTE: The use of reflection to access JVMCI API is to support
-    // compiling on JDKs with varying versions of JVMCI.
-
     static {
         // Initialize JVMCI to ensure JVMCI opens its packages to Graal.
         ModulesSupport.exportJVMCI(LibGraal.class);
         Services.initializeJVMCI();
     }
 
-    private static final Method unhand = methodOrNull(HotSpotJVMCIRuntime.class, "unhand", sig(Class.class, Long.TYPE));
-    private static final Method translate = methodIf(unhand, HotSpotJVMCIRuntime.class, "translate", sig(Object.class));
-    private static final Method registerNativeMethods = methodIf(unhand, HotSpotJVMCIRuntime.class, "registerNativeMethods", sig(Class.class));
-    private static final Method isCurrentThreadAttached = methodIf(unhand, HotSpotJVMCIRuntime.class, "isCurrentThreadAttached");
-    private static final Method attachCurrentThread = methodIf(unhand, HotSpotJVMCIRuntime.class, "attachCurrentThread", sig(Boolean.TYPE, long[].class), sig(Boolean.TYPE));
-    private static final Method detachCurrentThread = methodIf(unhand, HotSpotJVMCIRuntime.class, "detachCurrentThread", sig(Boolean.TYPE), sig());
-    private static final Method getFailedSpeculationsAddress = methodIf(unhand, HotSpotSpeculationLog.class, "getFailedSpeculationsAddress");
+    static final long INITIAL_ISOLATE = ImageInfo.inImageBuildtimeCode() ? 0L : initializeLibgraal();
+    static final boolean AVAILABLE = INITIAL_ISOLATE != 0L;
 
-    private static final Method asResolvedJavaType = methodOrNull(HotSpotJVMCIRuntime.class, "asResolvedJavaType", sig(Long.TYPE));
-    private static final Method getJObjectValue = methodIf(asResolvedJavaType, HotSpotJVMCIRuntime.class, "getJObjectValue", sig(HotSpotObjectConstant.class));
+    private static long initializeLibgraal() {
+        try {
+            long[] javaVMInfo = runtime().registerNativeMethods(LibGraalScope.class);
+            long isolate = javaVMInfo[1];
+            return isolate;
+        } catch (UnsupportedOperationException e) {
+            return 0L;
+        }
+    }
 
     /**
      * Determines if libgraal is available for use.
      */
     public static boolean isAvailable() {
-        return available;
-    }
-
-    /**
-     * Determines if the current runtime supports building a libgraal image.
-     */
-    public static boolean isSupported() {
-        return getFailedSpeculationsAddress != null;
+        return AVAILABLE;
     }
 
     /**
@@ -136,13 +115,7 @@ public static void registerNativeMethods(Class<?> clazz) {
         if (!isAvailable()) {
             throw new IllegalStateException();
         }
-        try {
-            registerNativeMethods.invoke(runtime(), clazz);
-        } catch (Error e) {
-            throw e;
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        runtime().registerNativeMethods(clazz);
     }
 
     /**
@@ -160,11 +133,7 @@ public static long translate(Object obj) {
         if (!isAvailable()) {
             throw new IllegalStateException();
         }
-        try {
-            return (long) translate.invoke(runtime(), obj);
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        return runtime().translate(obj);
     }
 
     /**
@@ -181,73 +150,29 @@ public static <T> T unhand(Class<T> type, long handle) {
         if (!isAvailable()) {
             throw new IllegalStateException();
         }
-        try {
-            return (T) unhand.invoke(runtime(), type, handle);
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        return runtime().unhand(type, handle);
     }
 
-    private static long initializeLibgraal() {
-        if (registerNativeMethods == null) {
-            return 0L;
-        }
-        try {
-            long[] javaVMInfo = (long[]) registerNativeMethods.invoke(runtime(), LibGraalScope.class);
-            long isolate = javaVMInfo[1];
-            return isolate;
-        } catch (InvocationTargetException e) {
-            if (e.getTargetException() instanceof UnsupportedOperationException) {
-                // libgraal available but not enabled
-                return 0L;
-            }
-            throw new InternalError(e);
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
-    }
-
-    static final long initialIsolate = ImageInfo.inImageBuildtimeCode() ? 0L : initializeLibgraal();
-    static final boolean available = initialIsolate != 0L;
-
     /**
      * Determines if the current thread is {@linkplain #attachCurrentThread attached} to the peer
      * runtime.
      */
     static boolean isCurrentThreadAttached() {
-        try {
-            return (boolean) isCurrentThreadAttached.invoke(runtime());
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        return runtime().isCurrentThreadAttached();
     }
 
     /**
      * @see HotSpotJVMCIRuntime#getJObjectValue(HotSpotObjectConstant)
      */
     public static <T extends PointerBase> T getJObjectValue(HotSpotObjectConstant constant) {
-        if (getJObjectValue == null) {
-            return WordFactory.nullPointer();
-        }
-        try {
-            return WordFactory.pointer((long) getJObjectValue.invoke(runtime(), constant));
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        return WordFactory.pointer(runtime().getJObjectValue(constant));
     }
 
     /**
      * @see HotSpotJVMCIRuntime#asResolvedJavaType(long)
      */
     public static HotSpotResolvedJavaType asResolvedJavaType(PointerBase pointer) {
-        if (asResolvedJavaType == null) {
-            return null;
-        }
-        try {
-            return (HotSpotResolvedJavaType) asResolvedJavaType.invoke(runtime(), pointer.rawValue());
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        return runtime().asResolvedJavaType(pointer.rawValue());
     }
 
     /**
@@ -259,23 +184,12 @@ public static HotSpotResolvedJavaType asResolvedJavaType(PointerBase pointer) {
      *         thread was already attached
      */
     public static boolean attachCurrentThread(boolean isDaemon, long[] isolate) {
-        try {
-            if (attachCurrentThread.getParameterCount() == 2) {
-                long[] javaVMInfo = isolate != null ? new long[4] : null;
-                boolean res = (boolean) attachCurrentThread.invoke(runtime(), isDaemon, javaVMInfo);
-                if (isolate != null) {
-                    isolate[0] = javaVMInfo[1];
-                }
-                return res;
-            } else {
-                if (isolate != null) {
-                    isolate[0] = initialIsolate;
-                }
-                return (boolean) attachCurrentThread.invoke(runtime(), isDaemon);
-            }
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
+        long[] javaVMInfo = isolate != null ? new long[4] : null;
+        boolean res = runtime().attachCurrentThread(isDaemon, javaVMInfo);
+        if (isolate != null) {
+            isolate[0] = javaVMInfo[1];
         }
+        return res;
     }
 
     /**
@@ -289,16 +203,7 @@ public static boolean attachCurrentThread(boolean isDaemon, long[] isolate) {
      *         as a result of this call
      */
     public static boolean detachCurrentThread(boolean release) {
-        try {
-            if (detachCurrentThread.getParameterCount() == 1) {
-                return (Boolean) detachCurrentThread.invoke(runtime(), release);
-            } else {
-                detachCurrentThread.invoke(runtime());
-                return false;
-            }
-        } catch (Throwable throwable) {
-            throw new InternalError(throwable);
-        }
+        return runtime().detachCurrentThread(release);
     }
 
     /**
@@ -309,84 +214,7 @@ public static boolean detachCurrentThread(boolean release) {
      * @exception UnsupportedOperationException if unsupported
      */
     public static long getFailedSpeculationsAddress(HotSpotSpeculationLog log) {
-        if (getFailedSpeculationsAddress != null) {
-            try {
-                return (long) getFailedSpeculationsAddress.invoke(log);
-            } catch (Throwable e) {
-                throw new InternalError(e);
-            }
-        }
-        throw new UnsupportedOperationException();
-    }
-
-    /**
-     * Convenience function for wrapping varargs into an array for use in calls to
-     * {@link #method(Class, String, Class[][])}.
-     */
-    private static Class<?>[] sig(Class<?>... types) {
-        return types;
-    }
-
-    /**
-     * Gets the method in {@code declaringClass} with the unique name {@code name}.
-     *
-     * @param sigs the signatures the method may have
-     */
-    private static Method method(Class<?> declaringClass, String name, Class<?>[]... sigs) {
-        if (sigs.length == 1 || sigs.length == 0) {
-            try {
-                Class<?>[] sig = sigs.length == 1 ? sigs[0] : new Class<?>[0];
-                return declaringClass.getDeclaredMethod(name, sig);
-            } catch (NoSuchMethodException | SecurityException e) {
-                throw (NoSuchMethodError) new NoSuchMethodError(name).initCause(e);
-            }
-        }
-        Method match = null;
-        for (Method m : declaringClass.getDeclaredMethods()) {
-            if (m.getName().equals(name)) {
-                if (match != null) {
-                    throw new InternalError(String.format("Expected single method named %s, found %s and %s",
-                                    name, match, m));
-                }
-                match = m;
-            }
-        }
-        if (match == null) {
-            throw new NoSuchMethodError("Cannot find method " + name + " in " + declaringClass.getName());
-        }
-        Class<?>[] parameterTypes = match.getParameterTypes();
-        for (Class<?>[] sig : sigs) {
-            if (Arrays.equals(parameterTypes, sig)) {
-                return match;
-            }
-        }
-        throw new NoSuchMethodError(String.format("Unexpected signature for %s: %s", name, Arrays.toString(parameterTypes)));
+        return log.getFailedSpeculationsAddress();
     }
 
-    /**
-     * Gets the method in {@code declaringClass} with the unique name {@code name} or {@code null}
-     * if not found.
-     *
-     * @param sigs the signatures the method may have
-     */
-    private static Method methodOrNull(Class<?> declaringClass, String name, Class<?>[]... sigs) {
-        try {
-            return method(declaringClass, name, sigs);
-        } catch (NoSuchMethodError e) {
-            return null;
-        }
-    }
-
-    /**
-     * Gets the method in {@code declaringClass} with the unique name {@code name} or {@code null}
-     * if {@code guard == null}.
-     *
-     * @param sigs the signatures the method may have
-     */
-    private static Method methodIf(Object guard, Class<?> declaringClass, String name, Class<?>[]... sigs) {
-        if (guard == null) {
-            return null;
-        }
-        return method(declaringClass, name, sigs);
-    }
 }