[GR-34687] Canonicalize Class.isAssignableFrom(Object.getClass()) to Class.isInstanceOf(Object).

PullRequest: graal/10120

Author: ansalond

compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/ClassIsAssignableFromNode.java

@@ -30,6 +30,7 @@
 import org.graalvm.compiler.core.common.type.Stamp;
 import org.graalvm.compiler.graph.Node;
 import org.graalvm.compiler.graph.NodeClass;
+import org.graalvm.compiler.nodes.extended.GetClassNode;
 import org.graalvm.compiler.nodes.spi.Canonicalizable;
 import org.graalvm.compiler.nodes.spi.CanonicalizerTool;
 import org.graalvm.compiler.nodeinfo.NodeInfo;
@@ -74,6 +75,14 @@ public ValueNode getOtherClass() {
 
     @Override
     public Node canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
+        if (forY instanceof GetClassNode) {
+            // Canonicalize `Class.isAssignableFrom(Object.getClass())` to
+            // `Class.isInstance(Object)`.
+            // For non-leaf types, `Object.getClass()` cannot only return a ValueNode stamped
+            // java.lang.Class, which prevents folding to a isNull check when the Object argument is
+            // constant and complicates ClassIsAssignableFrom in the other cases.
+            return InstanceOfDynamicNode.create(tool.getAssumptions(), tool.getConstantReflection(), forX, ((GetClassNode) forY).getObject(), false);
+        }
         if (forX.isConstant() && forY.isConstant()) {
             ConstantReflectionProvider constantReflection = tool.getConstantReflection();
             ResolvedJavaType thisType = constantReflection.asJavaType(forX.asJavaConstant());

compiler/src/org.graalvm.micro.benchmarks/src/micro/benchmarks/TypecheckBenchmark.java

@@ -306,4 +306,66 @@ public int repetitiveInstanceOfDynamic(ThreadState state) {
         return res;
     }
 
+    @Benchmark
+    public boolean classIsAssignableFromShouldFold(ThreadState state) {
+        return AA.class.isAssignableFrom(state.aa1.getClass());
+    }
+
+    @Benchmark
+    public boolean classIsInstanceShouldFold(ThreadState state) {
+        return AA.class.isInstance(state.aa1);
+    }
+
+    @Benchmark
+    public boolean instanceOfClassShouldFold(ThreadState state) {
+        return state.aa1 instanceof AA;
+    }
+
+    @Benchmark
+    public int classIsAssignableFrom(ThreadState state) {
+        int res = 0;
+        Object[] objects = state.object;
+        for (int i = 0; i < objects.length; i++) {
+            if (classIsAssignableFrom(objects[i])) {
+                res++;
+            }
+        }
+        return res;
+    }
+
+    boolean classIsAssignableFrom(Object obj) {
+        return AA1.class.isAssignableFrom(obj.getClass());
+    }
+
+    @Benchmark
+    public int classIsInstance(ThreadState state) {
+        int res = 0;
+        Object[] objects = state.object;
+        for (int i = 0; i < objects.length; i++) {
+            if (classIsInstance(objects[i])) {
+                res++;
+            }
+        }
+        return res;
+    }
+
+    boolean classIsInstance(Object obj) {
+        return AA1.class.isInstance(obj);
+    }
+
+    @Benchmark
+    public int instanceOfClass(ThreadState state) {
+        int res = 0;
+        Object[] objects = state.object;
+        for (int i = 0; i < objects.length; i++) {
+            if (instanceOfClass(objects[i])) {
+                res++;
+            }
+        }
+        return res;
+    }
+
+    boolean instanceOfClass(Object obj) {
+        return obj instanceof AA1;
+    }
 }