llvm-reduce: Handle reducing FP values to nan

[arsenm]

Summary

I'm not sure what the precedence of this should be compared to
replacing with zero/one/undef. Currently this will win out over the
others if it doesn't matter to the reduction. This has similar
advantages to undef.

[aeubanks]

currently we prefer 0 over 1 over undef because having undef in reproducers makes the IR makes it more likely that the code has undefined behavior, causing future changes to potentially perturb optimized IR
I think we should prefer 0 over 1 over nan over undef

[arsenm]

Prefer 0/1

[arsenm]

261075590b2bde348922b402bf982c33fb6475a8

llvm/test/tools/llvm-reduce/remove-operands-fp.ll

 ; Test that llvm-reduce can reduce floating point operands
 ;
 ; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-one --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefixes=CHECK,ONE %s < %t
 
 ; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-zero --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefixes=CHECK,ZERO %s < %t
 
-; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=operands-nan --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
+; RUN: FileCheck --check-prefixes=CHECK,NAN %s < %t
+
+; RUN: llvm-reduce --abort-on-invalid-reduction --test FileCheck --test-arg --check-prefixes=CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
 ; RUN: FileCheck --check-prefixes=CHECK,ZERO %s < %t
 
 ; CHECK-INTERESTINGNESS: = fadd float %
 ; CHECK-INTERESTINGNESS: = fadd float
 ; CHECK-INTERESTINGNESS: = fadd float
 ; CHECK-INTERESTINGNESS: = fadd float
 ; CHECK-INTERESTINGNESS: = fadd float
 ; CHECK-INTERESTINGNESS: = fadd float

 ; ZERO: %fadd5 = fadd float 0.000000e+00, 0.000000e+00
 ; ZERO: %fadd6 = fadd <2 x float> %arg2, zeroinitializer
 ; ZERO: %fadd7 = fadd <2 x float> zeroinitializer, zeroinitializer
 ; ZERO: %fadd8 = fadd <2 x float> zeroinitializer, zeroinitializer
 ; ZERO: %fadd9 = fadd <2 x float> zeroinitializer, zeroinitializer
 ; ZERO: %fadd10 = fadd <2 x float> zeroinitializer, zeroinitializer
 ; ZERO: %fadd11 = fadd <2 x float> zeroinitializer, zeroinitializer
 
+
+; NAN: %fadd0 = fadd float %arg0, 0x7FF8000000000000
+; NAN: %fadd1 = fadd float 0x7FF8000000000000, 0x7FF8000000000000
+; NAN: %fadd2 = fadd float 0x7FF8000000000000, 0.000000e+00
+; NAN: %fadd3 = fadd float 0x7FF8000000000000, 1.000000e+00
+; NAN: %fadd4 = fadd float 0x7FF8000000000000, 0x7FF8000000000000
+; NAN: %fadd5 = fadd float 0x7FF8000000000000, 0x7FF8000000000000
+; NAN: %fadd6 = fadd <2 x float> %arg2, <float 0x7FF8000000000000, float 0x7FF8000000000000>
+; NAN: %fadd7 = fadd <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, <float 0x7FF8000000000000, float 0x7FF8000000000000>
+; NAN: %fadd8 = fadd <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, zeroinitializer
+; NAN: %fadd9 = fadd <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, <float 1.000000e+00, float 1.000000e+00>
+; NAN: %fadd10 = fadd <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, <float 0x7FF8000000000000, float 0x7FF8000000000000>
+; NAN: %fadd11 = fadd <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, <float 0x7FF8000000000000, float 0x7FF8000000000000>
+
 define void @foo(float %arg0, float %arg1, <2 x float> %arg2, <2 x float> %arg3) {
 bb0:
   %fadd0 = fadd float %arg0, %arg1
   %fadd1 = fadd float %arg0, %arg1
   %fadd2 = fadd float %arg0, 0.0
   %fadd3 = fadd float %arg0, 1.0
   %fadd4 = fadd float %arg0, 0x7FF8000000000000
   %fadd5 = fadd float %arg0, undef
   %fadd6 = fadd <2 x float> %arg2, %arg3
   %fadd7 = fadd <2 x float> %arg2, %arg3
   %fadd8 = fadd <2 x float> %arg2, zeroinitializer
   %fadd9 = fadd <2 x float> %arg2, <float 1.0, float 1.0>
   %fadd10 = fadd <2 x float> %arg2, undef
   %fadd11 = fadd <2 x float> %arg2, <float 0x7FF8000000000000, float 0x7FF8000000000000>
   ret void
 }

llvm/tools/llvm-reduce/DeltaManager.cpp

#define DELTA_PASSES                                                           \
   DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass)        \
   DELTA_PASS("global-variables", reduceGlobalsDeltaPass)                       \
   DELTA_PASS("metadata", reduceMetadataDeltaPass)                              \
   DELTA_PASS("arguments", reduceArgumentsDeltaPass)                            \
   DELTA_PASS("instructions", reduceInstructionsDeltaPass)                      \
   DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass)           \
   DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass)                     \
   DELTA_PASS("operands-one", reduceOperandsOneDeltaPass)                       \
+  DELTA_PASS("operands-nan", reduceOperandsNaNDeltaPass)                       \
   DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass)                \
   DELTA_PASS("operands-skip", reduceOperandsSkipDeltaPass)                     \
   DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass)                  \
   DELTA_PASS("attributes", reduceAttributesDeltaPass)                          \
   DELTA_PASS("module-data", reduceModuleDataDeltaPass)
 
 #define DELTA_PASSES_MIR                                                       \
   DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass)                   \

llvm/tools/llvm-reduce/deltas/ReduceOperands.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDS_H
 #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDS_H
 
 #include "Delta.h"
 
 namespace llvm {
 void reduceOperandsOneDeltaPass(TestRunner &Test);
 void reduceOperandsZeroDeltaPass(TestRunner &Test);
+void reduceOperandsNaNDeltaPass(TestRunner &Test);
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp

if (!shouldReduceOperand(Op))
       return nullptr;
     // Don't replace existing zeroes.
     return isZero(Op) ? nullptr : Constant::getNullValue(Op->getType());
   };
   runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
     extractOperandsFromModule(O, Program, ReduceValue);
   });
 }
+
+void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) {
+  errs() << "*** Reducing Operands to NaN...\n";
+  auto ReduceValue = [](Use &Op) -> Value * {
+    Type *Ty = Op->getType();
+    if (!Ty->isFPOrFPVectorTy())
+      return nullptr;
+
+    // Prefer 0.0 or 1.0 over NaN.
+    //
+    // TODO: Preferring NaN may make more sense because FP operations are more
+    // universally foldable.
+    if (match(Op.get(), m_NaN()) || isZeroOrOneFP(Op.get()))
+      return nullptr;
+
+    if (VectorType *VT = dyn_cast<VectorType>(Ty)) {
+      return ConstantVector::getSplat(VT->getElementCount(),
+                                      ConstantFP::getQNaN(VT->getElementType()));
+    }
+
+    return ConstantFP::getQNaN(Ty);
+  };
+  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
+    extractOperandsFromModule(O, Program, ReduceValue);
+  });
+}