src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/FloatDivNode.java

@@ -23,10 +23,11 @@
 package org.graalvm.compiler.nodes.calc;
 
 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_32;
 
 import org.graalvm.compiler.core.common.type.ArithmeticOpTable;
+import org.graalvm.compiler.core.common.type.FloatStamp;
 import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp;
 import org.graalvm.compiler.core.common.type.ArithmeticOpTable.BinaryOp.Div;
 import org.graalvm.compiler.core.common.type.Stamp;
 import org.graalvm.compiler.graph.NodeClass;
 import org.graalvm.compiler.graph.spi.CanonicalizerTool;

@@ -34,25 +35,24 @@
 import org.graalvm.compiler.nodeinfo.NodeInfo;
 import org.graalvm.compiler.nodes.ConstantNode;
 import org.graalvm.compiler.nodes.ValueNode;
 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
 
-import jdk.vm.ci.code.CodeUtil;
 import jdk.vm.ci.meta.Constant;
-import jdk.vm.ci.meta.PrimitiveConstant;
 
 @NodeInfo(shortName = "/", cycles = CYCLES_32)
-public class DivNode extends BinaryArithmeticNode<Div> {
+public class FloatDivNode extends BinaryArithmeticNode<Div> {
 
-    public static final NodeClass<DivNode> TYPE = NodeClass.create(DivNode.class);
+    public static final NodeClass<FloatDivNode> TYPE = NodeClass.create(FloatDivNode.class);
 
-    public DivNode(ValueNode x, ValueNode y) {
-        super(TYPE, ArithmeticOpTable::getDiv, x, y);
+    public FloatDivNode(ValueNode x, ValueNode y) {
+        this(TYPE, x, y);
     }
 
-    protected DivNode(NodeClass<? extends DivNode> c, ValueNode x, ValueNode y) {
+    protected FloatDivNode(NodeClass<? extends FloatDivNode> c, ValueNode x, ValueNode y) {
         super(c, ArithmeticOpTable::getDiv, x, y);
+        assert stamp instanceof FloatStamp;
     }
 
     public static ValueNode create(ValueNode x, ValueNode y) {
         BinaryOp<Div> op = ArithmeticOpTable.forStamp(x.stamp()).getDiv();
         Stamp stamp = op.foldStamp(x.stamp(), y.stamp());

@@ -71,37 +71,18 @@
         }
 
         return canonical(this, getOp(forX, forY), forX, forY);
     }
 
-    private static ValueNode canonical(DivNode self, BinaryOp<Div> op, ValueNode forX, ValueNode forY) {
+    private static ValueNode canonical(FloatDivNode self, BinaryOp<Div> op, ValueNode forX, ValueNode forY) {
         if (forY.isConstant()) {
             Constant c = forY.asConstant();
             if (op.isNeutral(c)) {
                 return forX;
             }
-            if (c instanceof PrimitiveConstant && ((PrimitiveConstant) c).getJavaKind().isNumericInteger()) {
-                long i = ((PrimitiveConstant) c).asLong();
-                boolean signFlip = false;
-                if (i < 0) {
-                    i = -i;
-                    signFlip = true;
                 }
-                ValueNode divResult = null;
-                if (CodeUtil.isPowerOf2(i)) {
-                    divResult = new RightShiftNode(forX, ConstantNode.forInt(CodeUtil.log2(i)));
-                }
-                if (divResult != null) {
-                    if (signFlip) {
-                        return NegateNode.create(divResult);
-                    } else {
-                        return divResult;
-                    }
-                }
-            }
-        }
-        return self != null ? self : new DivNode(forX, forY);
+        return self != null ? self : new FloatDivNode(forX, forY);
     }
 
     @Override
     public void generate(NodeLIRBuilderTool nodeValueMap, ArithmeticLIRGeneratorTool gen) {
         nodeValueMap.setResult(this, gen.emitDiv(nodeValueMap.operand(getX()), nodeValueMap.operand(getY()), null));