CodeGen: Add -denormal-fp-math-f32 flag

[arsenm]

Summary

Make the set of FP relatted attributes and command flags closer.

[arsenm]

ping

[spatel]

llvm/include/llvm/CodeGen/CommandFlags.inc

448–449

If I'm seeing this and the test correctly, the function attribute overrides any command-line debug flag. That could use a comment; if that's consistent across all of the attributes handled here, make that a function-level comment?

llvm/test/Other/opt-override-denormal-fp-math.ll

24

Add a test or separate file where the function contains both of the denorm attrs simultaneously?

[arsenm]

Rebase and address comments

[spatel]

LGTM

[arsenm]

a8cc9047de090352d244c0e1d1db8b4d9b4b7502

llvm/include/llvm/CodeGen/CommandFlags.inc

static cl::opt<bool> EnableNoSignedZerosFPMath(
     cl::init(false));
 
 static cl::opt<bool>
     EnableNoTrappingFPMath("enable-no-trapping-fp-math",
                            cl::desc("Enable setting the FP exceptions build "
                                     "attribute not to use exceptions"),
                            cl::init(false));
 
-// FIXME: Doesn't have way to specify separate input and output modes.
-static cl::opt<DenormalMode::DenormalModeKind> DenormalFPMath(
-    "denormal-fp-math",
-    cl::desc("Select which denormal numbers the code is permitted to require"),
-    cl::init(DenormalMode::IEEE),
-    cl::values(clEnumValN(DenormalMode::IEEE, "ieee",
-                          "IEEE 754 denormal numbers"),
-               clEnumValN(DenormalMode::PreserveSign, "preserve-sign",
-                          "the sign of a  flushed-to-zero number is preserved "
-                          "in the sign of 0"),
-               clEnumValN(DenormalMode::PositiveZero, "positive-zero",
-                          "denormals are flushed to positive zero")));
+static const auto DenormFlagEnumOptions =
+                        "denormals are flushed to positive zero"));
+
+// FIXME: Doesn't have way to specify separate input and output modes.
+static cl::opt<DenormalMode::DenormalModeKind> DenormalFPMath(
+    "denormal-fp-math",
+    cl::desc("Select which denormal numbers the code is permitted to require"),
+    cl::init(DenormalMode::IEEE),
+    DenormFlagEnumOptions);
+
+static cl::opt<DenormalMode::DenormalModeKind> DenormalFP32Math(
+    "denormal-fp-math-f32",
+    cl::desc("Select which denormal numbers the code is permitted to require for float"),
+    cl::init(DenormalMode::Invalid),
+    DenormFlagEnumOptions);
 
 static cl::opt<bool> EnableHonorSignDependentRoundingFPMath(
     "enable-sign-dependent-rounding-fp-math", cl::Hidden,
     cl::desc("Force codegen to assume rounding mode can change dynamically"),
     cl::init(false));
 
 static cl::opt<llvm::FloatABI::ABIType> FloatABIForCalls(
     "float-abi", cl::desc("Choose float ABI type"), cl::init(FloatABI::Default),

 
 #define HANDLE_BOOL_ATTR(CL, AttrName)                              \
   do {                                                              \
     if (CL.getNumOccurrences() > 0 && !F.hasFnAttribute(AttrName))  \
       renderBoolStringAttr(NewAttrs, AttrName, CL);                 \
   } while (0)
 
 
-/// Set function attributes of function \p F based on CPU, Features, and command
-/// line flags.
+/// Add function attributes to function \p F based on CPU, Features, and command
+/// line flags. If there is a pre-existing attribute, leave it as-is. This only
+/// sets the corresponding attribute if the function does not already have the
+/// attribute.
 LLVM_ATTRIBUTE_UNUSED static void
 setFunctionAttributes(StringRef CPU, StringRef Features, Function &F) {
   auto &Ctx = F.getContext();
   AttributeList Attrs = F.getAttributes();
   AttrBuilder NewAttrs;
 
   if (!CPU.empty() && !F.hasFnAttribute("target-cpu"))
     NewAttrs.addAttribute("target-cpu", CPU);
setFunctionAttributes(StringRef CPU, StringRef Features, Function &F) {
   if (StackRealign)
     NewAttrs.addAttribute("stackrealign");
 
   HANDLE_BOOL_ATTR(EnableUnsafeFPMath, "unsafe-fp-math");
   HANDLE_BOOL_ATTR(EnableNoInfsFPMath, "no-infs-fp-math");
   HANDLE_BOOL_ATTR(EnableNoNaNsFPMath, "no-nans-fp-math");
   HANDLE_BOOL_ATTR(EnableNoSignedZerosFPMath, "no-signed-zeros-fp-math");
 
   if (DenormalFPMath.getNumOccurrences() > 0 &&
       !F.hasFnAttribute("denormal-fp-math")) {
     // FIXME: Command line flag should expose separate input/output modes.
     NewAttrs.addAttribute("denormal-fp-math",
                           DenormalMode(DenormalFPMath, DenormalFPMath).str());
   }
 
+  if (DenormalFP32Math.getNumOccurrences() > 0 &&
+      !F.hasFnAttribute("denormal-fp-math-f32")) {
+    // FIXME: Command line flag should expose separate input/output modes.
+    NewAttrs.addAttribute(
+      "denormal-fp-math-f32",
+      DenormalMode(DenormalFP32Math, DenormalFP32Math).str());
+  }
+
   if (TrapFuncName.getNumOccurrences() > 0)
     for (auto &B : F)
       for (auto &I : B)
         if (auto *Call = dyn_cast<CallInst>(&I))
           if (const auto *F = Call->getCalledFunction())
             if (F->getIntrinsicID() == Intrinsic::debugtrap ||
                 F->getIntrinsicID() == Intrinsic::trap)
               Call->addAttribute(

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

cl::desc("NVPTX Specifies: 0 use div.approx, 1 use div.full, 2 use"
              " IEEE Compliant F32 div.rnd if available."),
     cl::init(2));
 
 static cl::opt<bool> UsePrecSqrtF32(
     "nvptx-prec-sqrtf32", cl::Hidden,
     cl::desc("NVPTX Specific: 0 use sqrt.approx, 1 use sqrt.rn."),
     cl::init(true));
 
-static cl::opt<bool> FtzEnabled(
-    "nvptx-f32ftz", cl::ZeroOrMore, cl::Hidden,
-    cl::desc("NVPTX Specific: Flush f32 subnormals to sign-preserving zero."),
-    cl::init(false));
-
 int NVPTXTargetLowering::getDivF32Level() const {
   if (UsePrecDivF32.getNumOccurrences() > 0) {
     // If nvptx-prec-div32=N is used on the command-line, always honor it
     return UsePrecDivF32;
   } else {
     // Otherwise, use div.approx if fast math is enabled
     if (getTargetMachine().Options.UnsafeFPMath)
       return 0;
     else
       return 2;
   }
 }
 
 bool NVPTXTargetLowering::usePrecSqrtF32() const {
   if (UsePrecSqrtF32.getNumOccurrences() > 0) {
     // If nvptx-prec-sqrtf32 is used on the command-line, always honor it
     return UsePrecSqrtF32;
   } else {
     // Otherwise, use sqrt.approx if fast math is enabled
     return !getTargetMachine().Options.UnsafeFPMath;
   }
 }
 
 bool NVPTXTargetLowering::useF32FTZ(const MachineFunction &MF) const {
-  // TODO: Get rid of this flag; there can be only one way to do this.
-  if (FtzEnabled.getNumOccurrences() > 0) {
-    // If nvptx-f32ftz is used on the command-line, always honor it
-    return FtzEnabled;
-  }
-
   DenormalMode Denorm =
     getTargetMachine().Options.getDenormalMode(APFloat::IEEEsingle());
   return Denorm.Output == DenormalMode::PreserveSign;
 }
 
 static bool IsPTXVectorType(MVT VT) {
   switch (VT.SimpleTy) {
   default:

llvm/lib/Target/TargetMachine.cpp

do {                                                                  \
     Options.X = (F.getFnAttribute(Y).getValueAsString() == "true");     \
   } while (0)
 
   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
   RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
 
-  Options.setFP32DenormalMode(DenormalMode::getInvalid());
   if (F.hasFnAttribute("denormal-fp-math-f32")) {
     Options.setFP32DenormalMode(
       parseDenormalFPAttribute(
         F.getFnAttribute("denormal-fp-math-f32").getValueAsString()));
-  }
+  } else
+    Options.setFP32DenormalMode(DefaultOptions.getRawFP32DenormalMode());
 
   if (F.hasFnAttribute("denormal-fp-math")) {
     Options.setFPDenormalMode(
       parseDenormalFPAttribute(
         F.getFnAttribute("denormal-fp-math").getValueAsString()));
   } else
     Options.setFPDenormalMode(DefaultOptions.getRawFPDenormalMode());
 }

llvm/test/CodeGen/NVPTX/f16-instructions.ll

 ; ## Full FP16 support enabled by default.
 ; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_53 -asm-verbose=false \
 ; RUN:          -O0 -disable-post-ra -frame-pointer=all -verify-machineinstrs \
 ; RUN: | FileCheck -check-prefixes CHECK,CHECK-NOFTZ,CHECK-F16,CHECK-F16-NOFTZ %s
 ; ## Full FP16 with FTZ
 ; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_53 -asm-verbose=false \
 ; RUN:          -O0 -disable-post-ra -frame-pointer=all -verify-machineinstrs \
-; RUN:          -nvptx-f32ftz \
+; RUN:          -denormal-fp-math-f32=preserve-sign \
 ; RUN: | FileCheck -check-prefixes CHECK,CHECK-F16,CHECK-F16-FTZ %s
 ; ## FP16 support explicitly disabled.
 ; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_53 -asm-verbose=false \
 ; RUN:          -O0 -disable-post-ra -frame-pointer=all --nvptx-no-f16-math \
 ; RUN:           -verify-machineinstrs \
 ; RUN: | FileCheck -check-prefixes CHECK,CHECK-NOFTZ,CHECK-NOF16 %s
 ; ## FP16 is not supported by hardware.
 ; RUN: llc < %s -O0 -mtriple=nvptx64-nvidia-cuda -mcpu=sm_52 -asm-verbose=false \

llvm/test/Other/opt-override-denormal-fp-math-f32.ll

+; RUN: opt -S -denormal-fp-math-f32=ieee %s | FileCheck -check-prefixes=IEEE,ALL %s
+; RUN: opt -S -denormal-fp-math-f32=preserve-sign %s | FileCheck -check-prefixes=PRESERVESIGN,ALL %s
+; RUN: opt -S -denormal-fp-math-f32=positive-zero %s | FileCheck -check-prefixes=POSZERO,ALL %s
+
+; ALL: @no_denormal_fp_math_f32_attr() [[NOATTR:#[0-9]+]] {
+define i32 @no_denormal_fp_math_f32_attr() #0 {
+entry:
+  ret i32 0
+}
+
+; ALL: denormal_fp_math_attr_preserve_sign_ieee() [[ATTR:#[0-9]+]] {
+define i32 @denormal_fp_math_attr_preserve_sign_ieee() #1 {
+entry:
+  ret i32 0
+}
+
+; ALL-DAG: attributes [[ATTR]] = { nounwind "denormal-fp-math-f32"="preserve-sign,ieee" }
+; IEEE-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math-f32"="ieee,ieee" }
+; PRESERVESIGN-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
+; POSITIVEZERO-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math-f32"="positive-zero,positive-zero" }
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind "denormal-fp-math-f32"="preserve-sign,ieee" }

llvm/test/Other/opt-override-denormal-fp-math-mixed.ll

+; RUN: opt -S -denormal-fp-math=ieee %s | FileCheck -check-prefixes=IEEE,ALL %s
+; RUN: opt -S -denormal-fp-math=preserve-sign %s | FileCheck -check-prefixes=PRESERVESIGN,ALL %s
+; RUN: opt -S -denormal-fp-math=positive-zero %s | FileCheck -check-prefixes=POSZERO,ALL %s
+
+; RUN: opt -S -denormal-fp-math-f32=ieee %s | FileCheck -check-prefixes=IEEEF32,ALL %s
+; RUN: opt -S -denormal-fp-math-f32=preserve-sign %s | FileCheck -check-prefixes=PRESERVESIGNF32,ALL %s
+; RUN: opt -S -denormal-fp-math-f32=positive-zero %s | FileCheck -check-prefixes=POSZEROF32,ALL %s
+
+; RUN: opt -S -denormal-fp-math=ieee -denormal-fp-math-f32=ieee %s | FileCheck -check-prefixes=IEEE-BOTH,ALL %s
+; RUN: opt -S -denormal-fp-math=preserve-sign -denormal-fp-math-f32=preserve-sign %s | FileCheck -check-prefixes=PRESERVESIGN-BOTH,ALL %s
+; RUN: opt -S -denormal-fp-math=positive-zero -denormal-fp-math-f32=positive-zero %s | FileCheck -check-prefixes=POSZERO-BOTH,ALL %s
+
+
+
+; ALL: @no_denormal_fp_math_attrs() [[NOATTR:#[0-9]+]] {
+define i32 @no_denormal_fp_math_attrs() #0 {
+entry:
+  ret i32 0
+}
+
+; ALL: both_denormal_fp_math_attrs_preserve_sign_ieee() [[ATTR:#[0-9]+]] {
+define i32 @both_denormal_fp_math_attrs_preserve_sign_ieee() #1 {
+entry:
+  ret i32 0
+}
+
+; ALL-DAG: attributes [[ATTR]] = { nounwind "denormal-fp-math"="preserve-sign,ieee" "denormal-fp-math-f32"="preserve-sign,ieee" }
+
+; IEEE-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="ieee,ieee" }
+; PRESERVESIGN-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="preserve-sign,preserve-sign" }
+; POSITIVEZERO-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="positive-zero,positive-zero" }
+
+; IEEEF32-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math-f32"="ieee,ieee" }
+; PRESERVESIGNF32-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
+; POSITIVEZEROF32-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math-f32"="positive-zero,positive-zero" }
+
+; IEEE-BOTH-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,ieee" }
+; PRESERVESIGN-BOTH-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="preserve-sign,preserve-sign" "denormal-fp-math-f32"="preserve-sign,preserve-sign" }
+; POSITIVEZERO-BOTH-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="positive-zero,positive-zero" "denormal-fp-math-f32"="positive-zero,positive-zero" }
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind "denormal-fp-math"="preserve-sign,ieee" "denormal-fp-math-f32"="preserve-sign,ieee" }

llvm/test/Other/opt-override-denormal-fp-math.ll

+; RUN: opt -S -denormal-fp-math=ieee %s | FileCheck -check-prefixes=IEEE,ALL %s
+; RUN: opt -S -denormal-fp-math=preserve-sign %s | FileCheck -check-prefixes=PRESERVESIGN,ALL %s
+; RUN: opt -S -denormal-fp-math=positive-zero %s | FileCheck -check-prefixes=POSZERO,ALL %s
+
+; ALL: @no_denormal_fp_math_attr() [[NOATTR:#[0-9]+]] {
+define i32 @no_denormal_fp_math_attr() #0 {
+entry:
+  ret i32 0
+}
+
+; ALL: denormal_fp_math_attr_preserve_sign_ieee() [[ATTR:#[0-9]+]] {
+define i32 @denormal_fp_math_attr_preserve_sign_ieee() #1 {
+entry:
+  ret i32 0
+}
+
+; ALL-DAG: attributes [[ATTR]] = { nounwind "denormal-fp-math"="preserve-sign,ieee" }
+; IEEE-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="ieee,ieee" }
+; PRESERVESIGN-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="preserve-sign,preserve-sign" }
+; POSITIVEZERO-DAG: attributes [[NOATTR]] = { nounwind "denormal-fp-math"="positive-zero,positive-zero" }
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind "denormal-fp-math"="preserve-sign,ieee" }