[InstSimplify] propagate poison through FP ops

[spatel]

Summary

We already have this fold:

fadd float poison, 1.0 --> poison

...via ConstantFolding, so this makes the behavior consistent if the other operand(s) are non-constant.

The fold for undef was added before poison existed as a value/type in IR.

This came up in D102673 / D103169 because we're trying to sort out the more complicated handling for constrained math ops.
We should have the handling for the regular instructions done first, so we can build on that (or diverge as needed).

[nlopes]

LGTM!

llvm/lib/Analysis/InstructionSimplify.cpp

if (!In->isNaN())
     return ConstantFP::getNaN(In->getType());
 
   // Propagate the existing NaN constant when possible.
   // TODO: Should we quiet a signaling NaN?
   return In;
 }
 
 /// Perform folds that are common to any floating-point operation. This implies
-/// transforms based on undef/NaN because the operation itself makes no
+/// transforms based on poison/undef/NaN because the operation itself makes no
 /// difference to the result.
-static Constant *simplifyFPOp(ArrayRef<Value *> Ops,
-                              FastMathFlags FMF,
+static Constant *simplifyFPOp(ArrayRef<Value *> Ops, FastMathFlags FMF,
                               const SimplifyQuery &Q) {
   for (Value *V : Ops) {
+    // Poison is independent of anything else. It always propagates from an
+    // operand to a math result.
+    if (match(V, m_Poison()))
+      return PoisonValue::get(V->getType());
+
     bool IsNan = match(V, m_NaN());
     bool IsInf = match(V, m_Inf());
     bool IsUndef = Q.isUndefValue(V);
 
     // If this operation has 'nnan' or 'ninf' and at least 1 disallowed operand
     // (an undef operand can be chosen to be Nan/Inf), then the result of
     // this operation is poison.
     if (FMF.noNaNs() && (IsNan || IsUndef))

llvm/test/Transforms/InstSimplify/call.ll

 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double undef, double %x, double %y)
   ret double %r
 }
 
 define double @fma_poison_op0(double %x, double %y) {
 ; CHECK-LABEL: @fma_poison_op0(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double poison
 ;
   %r = call double @llvm.fma.f64(double poison, double %x, double %y)
   ret double %r
 }
 
 define double @fma_undef_op1(double %x, double %y) {
 ; CHECK-LABEL: @fma_undef_op1(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double %x, double undef, double %y)
   ret double %r
 }
 
 define double @fma_poison_op1(double %x, double %y) {
 ; CHECK-LABEL: @fma_poison_op1(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double poison
 ;
   %r = call double @llvm.fma.f64(double %x, double poison, double %y)
   ret double %r
 }
 
 define double @fma_undef_op2(double %x, double %y) {
 ; CHECK-LABEL: @fma_undef_op2(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fma.f64(double %x, double %y, double undef)
   ret double %r
 }
 
 define double @fma_poison_op2(double %x, double %y) {
 ; CHECK-LABEL: @fma_poison_op2(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double poison
 ;
   %r = call double @llvm.fma.f64(double %x, double %y, double poison)
   ret double %r
 }
 
 define double @fmuladd_undef_op0(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_undef_op0(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fmuladd.f64(double undef, double %x, double %y)
   ret double %r
 }
 
 define double @fmuladd_poison_op0(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_poison_op0(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double poison
 ;
   %r = call double @llvm.fmuladd.f64(double poison, double %x, double %y)
   ret double %r
 }
 
 define double @fmuladd_undef_op1(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_undef_op1(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double undef, double %y)
   ret double %r
 }
 
 define double @fmuladd_poison_op1(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_poison_op1(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double poison
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double poison, double %y)
   ret double %r
 }
 
 define double @fmuladd_undef_op2(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_undef_op2(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double %y, double undef)
   ret double %r
 }
 
 define double @fmuladd_poison_op2(double %x, double %y) {
 ; CHECK-LABEL: @fmuladd_poison_op2(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double poison
 ;
   %r = call double @llvm.fmuladd.f64(double %x, double %y, double poison)
   ret double %r
 }
 
 define double @fma_nan_op0(double %x, double %y) {
 ; CHECK-LABEL: @fma_nan_op0(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000

llvm/test/Transforms/InstSimplify/fp-undef-poison.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
-; TODO: the instructions with poison operands should return poison
-
 define float @fadd_undef_op0(float %x) {
 ; CHECK-LABEL: @fadd_undef_op0(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fadd float undef, %x
   ret float %r
 }
 
 define float @fadd_poison_op0(float %x) {
 ; CHECK-LABEL: @fadd_poison_op0(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fadd float poison, %x
   ret float %r
 }
 
 define float @fadd_undef_op1(float %x) {
 ; CHECK-LABEL: @fadd_undef_op1(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fadd float %x, undef
   ret float %r
 }
 
 define float @fadd_poison_op1(float %x) {
 ; CHECK-LABEL: @fadd_poison_op1(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fadd float %x, poison
   ret float %r
 }
 
 define float @fsub_undef_op0(float %x) {
 ; CHECK-LABEL: @fsub_undef_op0(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fsub float undef, %x
   ret float %r
 }
 
 define float @fsub_poison_op0(float %x) {
 ; CHECK-LABEL: @fsub_poison_op0(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fsub float poison, %x
   ret float %r
 }
 
 define float @fsub_undef_op1(float %x) {
 ; CHECK-LABEL: @fsub_undef_op1(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fsub float %x, undef
   ret float %r
 }
 
 define float @fsub_poison_op1(float %x) {
 ; CHECK-LABEL: @fsub_poison_op1(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fsub float %x, poison
   ret float %r
 }
 
 define float @fmul_undef_op0(float %x) {
 ; CHECK-LABEL: @fmul_undef_op0(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fmul float undef, %x
   ret float %r
 }
 
 define float @fmul_poison_op0(float %x) {
 ; CHECK-LABEL: @fmul_poison_op0(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fmul float poison, %x
   ret float %r
 }
 
 define float @fmul_undef_op1(float %x) {
 ; CHECK-LABEL: @fmul_undef_op1(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fmul float %x, undef
   ret float %r
 }
 
 define float @fmul_poison_op1(float %x) {
 ; CHECK-LABEL: @fmul_poison_op1(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fmul float %x, poison
   ret float %r
 }
 
 define float @fdiv_undef_op0(float %x) {
 ; CHECK-LABEL: @fdiv_undef_op0(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fdiv float undef, %x
   ret float %r
 }
 
 define float @fdiv_poison_op0(float %x) {
 ; CHECK-LABEL: @fdiv_poison_op0(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fdiv float poison, %x
   ret float %r
 }
 
 define float @fdiv_undef_op1(float %x) {
 ; CHECK-LABEL: @fdiv_undef_op1(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = fdiv float %x, undef
   ret float %r
 }
 
 define float @fdiv_poison_op1(float %x) {
 ; CHECK-LABEL: @fdiv_poison_op1(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = fdiv float %x, poison
   ret float %r
 }
 
 define float @frem_undef_op0(float %x) {
 ; CHECK-LABEL: @frem_undef_op0(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = frem float undef, %x
   ret float %r
 }
 
 define float @frem_poison_op0(float %x) {
 ; CHECK-LABEL: @frem_poison_op0(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = frem float poison, %x
   ret float %r
 }
 
 define float @frem_undef_op1(float %x) {
 ; CHECK-LABEL: @frem_undef_op1(
 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %r = frem float %x, undef
   ret float %r
 }
 
 define float @frem_poison_op1(float %x) {
 ; CHECK-LABEL: @frem_poison_op1(
-; CHECK-NEXT:    ret float 0x7FF8000000000000
+; CHECK-NEXT:    ret float poison
 ;
   %r = frem float %x, poison
   ret float %r
 }
 
 ; Repeat all tests with fast-math-flags. Alternate 'nnan' and 'fast' for more coverage.
 
 define float @fadd_undef_op0_nnan(float %x) {