Remove reflection for constant pool accesses

Author: Zeavee

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/ResolveDynamicConstantTest.java

@@ -24,9 +24,11 @@
  */
 package jdk.graal.compiler.core.test;
 
-import jdk.graal.compiler.serviceprovider.GraalServices;
+import java.lang.reflect.Method;
+import java.time.Clock;
+import java.time.Instant;
+
 import org.junit.Assert;
-import org.junit.Assume;
 import org.junit.Test;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.ConstantDynamic;
@@ -37,17 +39,12 @@
 
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
-import java.lang.reflect.Method;
-import java.time.Clock;
-import java.time.Instant;
-
 public class ResolveDynamicConstantTest extends CustomizedBytecodePatternTest {
 
     private static final int PUBLIC_STATIC = ACC_PUBLIC | ACC_STATIC;
 
     @Test
     public void test00601m001() throws Throwable {
-        Assume.assumeTrue(GraalServices.supportsNonresolvingLookupConstant());
         runTest("test.resolveDynamicConstant00601m001");
     }
 
@@ -64,7 +61,6 @@ public static void main(String[] args) {
 
     @Test
     public void test00602m008() throws Throwable {
-        Assume.assumeTrue(GraalServices.supportsNonresolvingLookupConstant());
         runTest("test.resolveDynamicConstant00602m008");
     }
 

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/jfr/TestGetEventWriter.java

@@ -29,7 +29,6 @@
 import java.lang.reflect.InvocationTargetException;
 
 import org.junit.Assert;
-import org.junit.Assume;
 import org.junit.Test;
 import org.objectweb.asm.AnnotationVisitor;
 import org.objectweb.asm.ClassWriter;
@@ -38,7 +37,6 @@
 
 import jdk.graal.compiler.core.common.PermanentBailoutException;
 import jdk.graal.compiler.core.test.SubprocessTest;
-import jdk.graal.compiler.serviceprovider.GraalServices;
 import jdk.graal.compiler.test.AddExports;
 import jdk.graal.compiler.test.SubprocessUtil;
 import jdk.jfr.Event;
@@ -60,7 +58,6 @@
 public class TestGetEventWriter extends SubprocessTest {
 
     private static void initializeJFR() {
-        Assume.assumeTrue("Requires JDK-8290075", GraalServices.hasLookupMethodWithCaller());
         try (Recording r = new Recording()) {
             r.start();
             // Unlocks access to jdk.jfr.internal.event

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/bytecode/BytecodeDisassembler.java

@@ -79,7 +79,6 @@
 import static jdk.graal.compiler.bytecode.Bytecodes.TABLESWITCH;
 
 import org.graalvm.collections.EconomicMap;
-import jdk.graal.compiler.serviceprovider.GraalServices;
 
 import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.JavaConstant;
@@ -354,7 +353,7 @@ private void decodeOperand(StringBuilder buf, BytecodeStream stream, ConstantPoo
             case LDC_W          :
             case LDC2_W         : {
                 int cpi = stream.readCPI();
-                Object constant = GraalServices.lookupConstant(cp, cpi, false);
+                Object constant = cp.lookupConstant(cpi, false);
                 String desc = null;
                 if (constant == null) {
                     desc = "<unresolved>";

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/BytecodeParser.java

@@ -435,7 +435,6 @@
 import jdk.graal.compiler.phases.OptimisticOptimizations;
 import jdk.graal.compiler.phases.util.ValueMergeUtil;
 import jdk.graal.compiler.replacements.nodes.MacroInvokable;
-import jdk.graal.compiler.serviceprovider.GraalServices;
 import jdk.graal.compiler.serviceprovider.SpeculationReasonGroup;
 import jdk.vm.ci.code.BailoutException;
 import jdk.vm.ci.code.BytecodeFrame;
@@ -4393,14 +4392,11 @@ private JavaMethod lookupMethod(int cpi, int opcode) {
     }
 
     protected JavaMethod lookupMethodInPool(int cpi, int opcode) {
-        if (GraalServices.hasLookupMethodWithCaller()) {
-            try {
-                return GraalServices.lookupMethodWithCaller(constantPool, cpi, opcode, method);
-            } catch (IllegalAccessError e) {
-                throw new PermanentBailoutException(e, "cannot link call from %s", method.format("%H.%n(%p)"));
-            }
+        try {
+            return constantPool.lookupMethod(cpi, opcode, method);
+        } catch (IllegalAccessError e) {
+            throw new PermanentBailoutException(e, "cannot link call from %s", method.format("%H.%n(%p)"));
         }
-        return constantPool.lookupMethod(cpi, opcode);
     }
 
     protected JavaField lookupField(int cpi, int opcode) {
@@ -4436,7 +4432,7 @@ protected JavaField lookupField(JavaField result) {
      */
     protected Object lookupConstant(int cpi, int opcode, boolean allowBootstrapMethodInvocation) {
         maybeEagerlyResolve(cpi, opcode);
-        Object result = GraalServices.lookupConstant(constantPool, cpi, allowBootstrapMethodInvocation);
+        Object result = constantPool.lookupConstant(cpi, allowBootstrapMethodInvocation);
         if (result != null) {
             assert !graphBuilderConfig.unresolvedIsError() || !(result instanceof JavaType) || (result instanceof ResolvedJavaType) : result;
         }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/serviceprovider/GraalServices.java

@@ -30,8 +30,6 @@
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -40,11 +38,7 @@
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 
-import jdk.graal.compiler.debug.GraalError;
-import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.EncodedSpeculationReason;
-import jdk.vm.ci.meta.JavaMethod;
-import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.SpeculationLog.SpeculationReason;
 import jdk.vm.ci.runtime.JVMCI;
 import jdk.vm.ci.services.Services;
@@ -54,32 +48,8 @@
  */
 public final class GraalServices {
 
-    // NOTE: The use of reflection to access JVMCI API is to support
-    // compiling on JDKs with varying versions of JVMCI.
-
     private static final Map<Class<?>, List<?>> servicesCache = IS_BUILDING_NATIVE_IMAGE ? new HashMap<>() : null;
 
-    private static final Method constantPoolLookupMethodWithCaller;
-    private static final Method constantPoolLookupConstantWithResolve;
-
-    static {
-        Method lookupMethodWithCaller = null;
-        Method lookupConstantWithResolve = null;
-
-        try {
-            lookupMethodWithCaller = ConstantPool.class.getDeclaredMethod("lookupMethod", Integer.TYPE, Integer.TYPE, ResolvedJavaMethod.class);
-        } catch (NoSuchMethodException e) {
-        }
-
-        try {
-            lookupConstantWithResolve = ConstantPool.class.getDeclaredMethod("lookupConstant", Integer.TYPE, Boolean.TYPE);
-        } catch (NoSuchMethodException e) {
-        }
-
-        constantPoolLookupMethodWithCaller = lookupMethodWithCaller;
-        constantPoolLookupConstantWithResolve = lookupConstantWithResolve;
-    }
-
     private GraalServices() {
     }
 
@@ -449,55 +419,6 @@ public static int getJavaUpdateVersion() {
         return Runtime.version().update();
     }
 
-    /**
-     * Calls {@code ConstantPool#lookupMethod(int, int, ResolvedJavaMethod)}.
-     */
-    public static JavaMethod lookupMethodWithCaller(ConstantPool constantPool, int cpi, int opcode, ResolvedJavaMethod caller) {
-        if (constantPoolLookupMethodWithCaller != null) {
-            try {
-                return (JavaMethod) constantPoolLookupMethodWithCaller.invoke(constantPool, cpi, opcode, caller);
-            } catch (InvocationTargetException e) {
-                throw rethrow(e.getCause());
-            } catch (IllegalAccessException e) {
-                throw GraalError.shouldNotReachHere(e, "The method lookupMethod should be accessible.");
-            }
-        }
-        throw new InternalError("This JDK doesn't support ConstantPool.lookupMethod(int, int, ResolvedJavaMethod)");
-    }
-
-    public static Object lookupConstant(ConstantPool constantPool, int cpi, boolean resolve) {
-        if (constantPoolLookupConstantWithResolve != null) {
-            try {
-                return constantPoolLookupConstantWithResolve.invoke(constantPool, cpi, resolve);
-            } catch (InvocationTargetException e) {
-                throw rethrow(e.getCause());
-            } catch (IllegalAccessException e) {
-                throw GraalError.shouldNotReachHere(e, "The method lookupConstant should be accessible.");
-            }
-        }
-        return constantPool.lookupConstant(cpi);
-    }
-
-    @SuppressWarnings("unchecked")
-    static <E extends Throwable> RuntimeException rethrow(Throwable ex) throws E {
-        throw (E) ex;
-    }
-
-    /**
-     * Returns true if the JDK includes {@code ConstantPool.lookupConstant(int, boolean)}.
-     */
-    public static boolean supportsNonresolvingLookupConstant() {
-        return constantPoolLookupConstantWithResolve != null;
-    }
-
-    /**
-     * Returns true if the JDK includes
-     * {@code ConstantPool.lookupMethod(int, int, ResolvedJavaMethod)}.
-     */
-    public static boolean hasLookupMethodWithCaller() {
-        return constantPoolLookupMethodWithCaller != null;
-    }
-
     /**
      * Notifies that the compiler is at a point where memory usage is expected to be minimal like
      * after the completion of compilation.

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/WrappedConstantPool.java

@@ -26,18 +26,14 @@
 
 import static jdk.vm.ci.common.JVMCIError.unimplemented;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.util.List;
 import java.util.stream.Collectors;
 
 import com.oracle.graal.pointsto.constraints.UnresolvedElementException;
 import com.oracle.graal.pointsto.util.GraalAccess;
-import com.oracle.svm.util.ReflectionUtil;
 
 import jdk.graal.compiler.api.replacements.SnippetReflectionProvider;
 import jdk.graal.compiler.debug.GraalError;
-import jdk.graal.compiler.serviceprovider.GraalServices;
 import jdk.vm.ci.meta.ConstantPool;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaField;
@@ -87,12 +83,6 @@ public JavaConstant extractResolvedType(JavaConstant constant) {
         return constant;
     }
 
-    /**
-     * {@code jdk.vm.ci.meta.ConstantPool.lookupMethod(int cpi, int opcode, ResolvedJavaMethod caller)}
-     * was introduced in JVMCI 22.3.
-     */
-    private static final Method lookupMethodWithCaller = ReflectionUtil.lookupMethod(true, ConstantPool.class, "lookupMethod", int.class, int.class, ResolvedJavaMethod.class);
-
     @Override
     public void loadReferencedType(int cpi, int opcode, boolean initialize) {
         GraalError.guarantee(!initialize, "Must not initialize classes");
@@ -127,23 +117,17 @@ public JavaMethod lookupMethod(int cpi, int opcode) {
 
     @Override
     public JavaMethod lookupMethod(int cpi, int opcode, ResolvedJavaMethod caller) {
-        if (lookupMethodWithCaller == null) {
-            /* Resort to version without caller. */
-            return lookupMethod(cpi, opcode);
-        }
         try {
             /* Unwrap the caller method. */
             ResolvedJavaMethod substCaller = universe.resolveSubstitution(((WrappedJavaMethod) caller).getWrapped());
             /*
              * Delegate to the lookup with caller method of the wrapped constant pool (via
              * reflection).
              */
-            return universe.lookupAllowUnresolved((JavaMethod) lookupMethodWithCaller.invoke(wrapped, cpi, opcode, substCaller));
+            return universe.lookupAllowUnresolved(wrapped.lookupMethod(cpi, opcode, substCaller));
         } catch (Throwable ex) {
             Throwable cause = ex;
-            if (ex instanceof InvocationTargetException && ex.getCause() != null) {
-                cause = ex.getCause();
-            } else if (ex instanceof ExceptionInInitializerError && ex.getCause() != null) {
+            if (ex instanceof ExceptionInInitializerError && ex.getCause() != null) {
                 cause = ex.getCause();
             }
             throw new UnresolvedElementException("Error loading a referenced type: " + cause.toString(), cause);
@@ -177,7 +161,7 @@ public Object lookupConstant(int cpi) {
 
     @Override
     public Object lookupConstant(int cpi, boolean resolve) {
-        Object con = GraalServices.lookupConstant(wrapped, cpi, resolve);
+        Object con = wrapped.lookupConstant(cpi, resolve);
         if (con instanceof JavaType) {
             if (con instanceof ResolvedJavaType) {
                 return universe.lookup((ResolvedJavaType) con);