30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Set;
36 import java.util.TreeSet;
37 import java.util.stream.Collectors;
38
39 import org.junit.Test;
40
41 import org.graalvm.compiler.api.test.Graal;
42 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
43 import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;
44 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
45 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins;
46 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin;
47 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins;
48 import org.graalvm.compiler.runtime.RuntimeProvider;
49 import org.graalvm.compiler.test.GraalTest;
50
51 import jdk.vm.ci.hotspot.HotSpotVMConfigStore;
52 import jdk.vm.ci.hotspot.VMIntrinsicMethod;
53 import jdk.vm.ci.meta.MetaAccessProvider;
54 import jdk.vm.ci.meta.MethodHandleAccessProvider.IntrinsicMethod;
55 import jdk.vm.ci.meta.ResolvedJavaMethod;
56
57 /**
58 * Checks the set of intrinsics implemented by Graal against the set of intrinsics declared by
59 * HotSpot. The purpose of this test is to detect when new intrinsics are added to HotSpot and
60 * process them appropriately in Graal. This will be achieved by working through
61 * {@link #TO_BE_INVESTIGATED} and either implementing the intrinsic or moving it to {@link #IGNORE}
62 * .
63 */
64 public class CheckGraalIntrinsics extends GraalTest {
65
66 public static boolean match(ResolvedJavaMethod method, VMIntrinsicMethod intrinsic) {
67 if (intrinsic.name.equals(method.getName())) {
68 if (intrinsic.descriptor.equals(method.getSignature().toMethodDescriptor())) {
69 String declaringClass = method.getDeclaringClass().toClassName().replace('.', '/');
70 if (declaringClass.equals(intrinsic.declaringClass)) {
71 return true;
72 }
73 }
74 }
75 return false;
76 }
77
78 private static ResolvedJavaMethod findMethod(Set<ResolvedJavaMethod> methods, VMIntrinsicMethod intrinsic) {
79 for (ResolvedJavaMethod method : methods) {
80 if (match(method, intrinsic)) {
81 return method;
82 }
83 }
84 return null;
85 }
86
87 private static ResolvedJavaMethod resolveIntrinsic(MetaAccessProvider metaAccess, VMIntrinsicMethod intrinsic) throws ClassNotFoundException {
88 Class<?> c = Class.forName(intrinsic.declaringClass.replace('/', '.'), false, CheckGraalIntrinsics.class.getClassLoader());
89 for (Method javaMethod : c.getDeclaredMethods()) {
90 if (javaMethod.getName().equals(intrinsic.name)) {
91 ResolvedJavaMethod method = metaAccess.lookupJavaMethod(javaMethod);
92 if (intrinsic.descriptor.equals("*")) {
93 // Signature polymorphic method - name match is enough
94 return method;
95 } else {
96 if (method.getSignature().toMethodDescriptor().equals(intrinsic.descriptor)) {
97 return method;
98 }
417 } else if (arch.equals("sparcv9")) {
418 arch = "sparc";
419 }
420 return arch;
421 }
422
423 @Test
424 @SuppressWarnings("try")
425 public void test() throws ClassNotFoundException {
426 HotSpotGraalRuntimeProvider rt = (HotSpotGraalRuntimeProvider) Graal.getRequiredCapability(RuntimeProvider.class);
427 HotSpotProviders providers = rt.getHostBackend().getProviders();
428 Map<ResolvedJavaMethod, Object> impl = new HashMap<>();
429 Plugins graphBuilderPlugins = providers.getGraphBuilderPlugins();
430 InvocationPlugins invocationPlugins = graphBuilderPlugins.getInvocationPlugins();
431 for (ResolvedJavaMethod method : invocationPlugins.getMethods()) {
432 InvocationPlugin plugin = invocationPlugins.lookupInvocation(method);
433 assert plugin != null;
434 impl.put(method, plugin);
435 }
436
437 Set<ResolvedJavaMethod> methods = invocationPlugins.getMethods();
438 HotSpotVMConfigStore store = rt.getVMConfig().getStore();
439 List<VMIntrinsicMethod> intrinsics = store.getIntrinsics();
440
441 List<String> missing = new ArrayList<>();
442 for (VMIntrinsicMethod intrinsic : intrinsics) {
443 ResolvedJavaMethod method = findMethod(methods, intrinsic);
444 if (method == null) {
445 method = resolveIntrinsic(providers.getMetaAccess(), intrinsic);
446
447 IntrinsicMethod intrinsicMethod = null;
448 if (method != null) {
449 intrinsicMethod = providers.getConstantReflection().getMethodHandleAccess().lookupMethodHandleIntrinsic(method);
450 if (intrinsicMethod != null) {
451 continue;
452 }
453 }
454 String m = String.format("%s.%s%s", intrinsic.declaringClass, intrinsic.name, intrinsic.descriptor);
455 if (!TO_BE_INVESTIGATED.contains(m) && !IGNORE.contains(m)) {
456 missing.add(m);
457 }
|
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Set;
36 import java.util.TreeSet;
37 import java.util.stream.Collectors;
38
39 import org.junit.Test;
40
41 import org.graalvm.compiler.api.test.Graal;
42 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
43 import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;
44 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
45 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins;
46 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin;
47 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins;
48 import org.graalvm.compiler.runtime.RuntimeProvider;
49 import org.graalvm.compiler.test.GraalTest;
50 import org.graalvm.util.EconomicSet;
51
52 import jdk.vm.ci.hotspot.HotSpotVMConfigStore;
53 import jdk.vm.ci.hotspot.VMIntrinsicMethod;
54 import jdk.vm.ci.meta.MetaAccessProvider;
55 import jdk.vm.ci.meta.MethodHandleAccessProvider.IntrinsicMethod;
56 import jdk.vm.ci.meta.ResolvedJavaMethod;
57
58 /**
59 * Checks the set of intrinsics implemented by Graal against the set of intrinsics declared by
60 * HotSpot. The purpose of this test is to detect when new intrinsics are added to HotSpot and
61 * process them appropriately in Graal. This will be achieved by working through
62 * {@link #TO_BE_INVESTIGATED} and either implementing the intrinsic or moving it to {@link #IGNORE}
63 * .
64 */
65 public class CheckGraalIntrinsics extends GraalTest {
66
67 public static boolean match(ResolvedJavaMethod method, VMIntrinsicMethod intrinsic) {
68 if (intrinsic.name.equals(method.getName())) {
69 if (intrinsic.descriptor.equals(method.getSignature().toMethodDescriptor())) {
70 String declaringClass = method.getDeclaringClass().toClassName().replace('.', '/');
71 if (declaringClass.equals(intrinsic.declaringClass)) {
72 return true;
73 }
74 }
75 }
76 return false;
77 }
78
79 private static ResolvedJavaMethod findMethod(EconomicSet<ResolvedJavaMethod> methods, VMIntrinsicMethod intrinsic) {
80 for (ResolvedJavaMethod method : methods) {
81 if (match(method, intrinsic)) {
82 return method;
83 }
84 }
85 return null;
86 }
87
88 private static ResolvedJavaMethod resolveIntrinsic(MetaAccessProvider metaAccess, VMIntrinsicMethod intrinsic) throws ClassNotFoundException {
89 Class<?> c = Class.forName(intrinsic.declaringClass.replace('/', '.'), false, CheckGraalIntrinsics.class.getClassLoader());
90 for (Method javaMethod : c.getDeclaredMethods()) {
91 if (javaMethod.getName().equals(intrinsic.name)) {
92 ResolvedJavaMethod method = metaAccess.lookupJavaMethod(javaMethod);
93 if (intrinsic.descriptor.equals("*")) {
94 // Signature polymorphic method - name match is enough
95 return method;
96 } else {
97 if (method.getSignature().toMethodDescriptor().equals(intrinsic.descriptor)) {
98 return method;
99 }
418 } else if (arch.equals("sparcv9")) {
419 arch = "sparc";
420 }
421 return arch;
422 }
423
424 @Test
425 @SuppressWarnings("try")
426 public void test() throws ClassNotFoundException {
427 HotSpotGraalRuntimeProvider rt = (HotSpotGraalRuntimeProvider) Graal.getRequiredCapability(RuntimeProvider.class);
428 HotSpotProviders providers = rt.getHostBackend().getProviders();
429 Map<ResolvedJavaMethod, Object> impl = new HashMap<>();
430 Plugins graphBuilderPlugins = providers.getGraphBuilderPlugins();
431 InvocationPlugins invocationPlugins = graphBuilderPlugins.getInvocationPlugins();
432 for (ResolvedJavaMethod method : invocationPlugins.getMethods()) {
433 InvocationPlugin plugin = invocationPlugins.lookupInvocation(method);
434 assert plugin != null;
435 impl.put(method, plugin);
436 }
437
438 EconomicSet<ResolvedJavaMethod> methods = invocationPlugins.getMethods();
439 HotSpotVMConfigStore store = rt.getVMConfig().getStore();
440 List<VMIntrinsicMethod> intrinsics = store.getIntrinsics();
441
442 List<String> missing = new ArrayList<>();
443 for (VMIntrinsicMethod intrinsic : intrinsics) {
444 ResolvedJavaMethod method = findMethod(methods, intrinsic);
445 if (method == null) {
446 method = resolveIntrinsic(providers.getMetaAccess(), intrinsic);
447
448 IntrinsicMethod intrinsicMethod = null;
449 if (method != null) {
450 intrinsicMethod = providers.getConstantReflection().getMethodHandleAccess().lookupMethodHandleIntrinsic(method);
451 if (intrinsicMethod != null) {
452 continue;
453 }
454 }
455 String m = String.format("%s.%s%s", intrinsic.declaringClass, intrinsic.name, intrinsic.descriptor);
456 if (!TO_BE_INVESTIGATED.contains(m) && !IGNORE.contains(m)) {
457 missing.add(m);
458 }
|