Add denormal-fp-math attribute for f16

[dcandler]

Summary

Denormal flushing behavior is currently controlled with the
denormal-fp-math attribute, with a denormal-fp-math-f32 variant for
targets such as AMDGPU where f32 denormals are controlled separately
from f16/f64. However there are other targets such as Arm (and I
think x86) where f16 denormals can be distinct from f32/f64. As the
attributes are now used for constant folding, this can lead to
incorrect folded values for half precision floats on those targets.

This patch adds a denormal-fp-math-f16 attribute, which functions
identically to denormal-fp-math-f32, but overrides the denormal
handling mode for f16 only. Constant folding tests have been
expanded to include half floats, and check both f16 and f32
variants of the attribute.

[arsenm]

Missing ARM changes that demonstrate the use of the control?

[dcandler]

There are currently no Arm specific changes, this is just being able to more accurately describe the floating point environment via attributes in the case where singles and doubles should be flushed, but not halves.

With three precisions to control, an alternative may be to specify them individually (denormal-fp-math-f64, denormal-fp-math-f32 and denormal-fp-math-f16) so that one doesn't override another, but that would be a much larger and more intrusive change.

[arsenm]

In D129298#3638759, @dcandler wrote:

There are currently no Arm specific changes, this is just being able to more accurately describe the floating point environment via attributes in the case where singles and doubles should be flushed, but not halves.

But presumably this corresponds with a directive in the assembly output needed to get a consistent FP mode at start. e.g. ARMAsmPrinter has checks for denormal-fp-math and emits something from it. I would expect a similar check and corresponding test if you can change these separately

[arsenm]

Reverse ping

[dcandler]

Sorry for the quiet on this. I'm going to abandon this for the moment, as what I eventually found was that there was some ambiguity in the ARM ABI regarding half-floats which would be better to address first, so that the attributes can map directly. There is currently only one ARM build attribute for denormals which reads as though it affects all precisions, but may not have been updated after half-float support was added. Since that maps to denormal-fp-math, which also controls all precisions, both may need splitting rather than just the function level attribute.

clang/docs/UsersManual.rst

.. csv-table:: Floating Point Semantic Modes
   :widths: 15, 30, 30
 
   "ffp-exception-behavior", "{ignore, strict, may_trap}",
   "fenv_access", "{off, on}", "(none)"
   "frounding-math", "{dynamic, tonearest, downward, upward, towardzero}"
   "ffp-contract", "{on, off, fast, fast-honor-pragmas}"
   "fdenormal-fp-math", "{IEEE, PreserveSign, PositiveZero}"
   "fdenormal-fp-math-fp32", "{IEEE, PreserveSign, PositiveZero}"
+  "fdenormal-fp-math-fp16", "{IEEE, PreserveSign, PositiveZero}"
   "fmath-errno", "{on, off}"
   "fhonor-nans", "{on, off}"
   "fhonor-infinities", "{on, off}"
   "fsigned-zeros", "{on, off}"
   "freciprocal-math", "{on, off}"
   "allow_approximate_fns", "{on, off}"
   "fassociative-math", "{on, off}"
 
 This table describes the option settings that correspond to the three
 floating point semantic models: precise (the default), strict, and fast.
 
 
 .. csv-table:: Floating Point Models
   :header: "Mode", "Precise", "Strict", "Fast"
   :widths: 25, 15, 15, 15
 
   "except_behavior", "ignore", "strict", "ignore"
   "fenv_access", "off", "on", "off"
   "rounding_mode", "tonearest", "dynamic", "tonearest"
   "contract", "on", "off", "fast"
   "denormal_fp_math", "IEEE", "IEEE", "PreserveSign"
   "denormal_fp32_math", "IEEE","IEEE", "PreserveSign"
+  "denormal_fp16_math", "IEEE","IEEE", "PreserveSign"
   "support_math_errno", "on", "on", "off"
   "no_honor_nans", "off", "off", "on"
   "no_honor_infinities", "off", "off", "on"
   "no_signed_zeros", "off", "off", "on"
   "allow_reciprocal", "off", "off", "on"
   "allow_approximate_fns", "off", "off", "on"
   "allow_reassociation", "off", "off", "on"
 

clang/include/clang/Basic/CodeGenOptions.h

public:
   std::string DIBugsReportFilePath;
 
   /// The floating-point denormal mode to use.
   llvm::DenormalMode FPDenormalMode = llvm::DenormalMode::getIEEE();
 
   /// The floating-point denormal mode to use, for float.
   llvm::DenormalMode FP32DenormalMode = llvm::DenormalMode::getIEEE();
 
+  /// The floating-point denormal mode to use, for half float.
+  llvm::DenormalMode FP16DenormalMode = llvm::DenormalMode::getIEEE();
+
   /// The float precision limit to use, if non-empty.
   std::string LimitFloatPrecision;
 
   struct BitcodeFileToLink {
     /// The filename of the bitcode file to link in.
     std::string Filename;
     /// If true, we set attributes functions in the bitcode library according to
     /// our CodeGenOptions, much as we set attrs on functions that we generate

clang/include/clang/Driver/Options.td

def cfguard : Flag<["-"], "cfguard">,
     HelpText<"Emit Windows Control Flow Guard tables and checks">,
     MarshallingInfoFlag<CodeGenOpts<"ControlFlowGuard">>;
 def ehcontguard : Flag<["-"], "ehcontguard">,
     HelpText<"Emit Windows EH Continuation Guard tables">,
     MarshallingInfoFlag<CodeGenOpts<"EHContGuard">>;
 
 def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">,
    Group<f_Group>;
+def fdenormal_fp_math_f16_EQ : Joined<["-"], "fdenormal-fp-math-f16=">,
+   Group<f_Group>;
 
 } // let Flags = [CC1Option, NoDriverOption]
 
 //===----------------------------------------------------------------------===//
 // Dependency Output Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {

clang/lib/CodeGen/CGCall.cpp

if (AttrOnCallSite) {
     if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE())
       FuncAttrs.addAttribute("denormal-fp-math",
                              CodeGenOpts.FPDenormalMode.str());
     if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) {
       FuncAttrs.addAttribute(
           "denormal-fp-math-f32",
           CodeGenOpts.FP32DenormalMode.str());
     }
+    if (CodeGenOpts.FP16DenormalMode != CodeGenOpts.FPDenormalMode) {
+      FuncAttrs.addAttribute("denormal-fp-math-f16",
+                             CodeGenOpts.FP16DenormalMode.str());
+    }
 
     if (LangOpts.getDefaultExceptionMode() == LangOptions::FPE_Ignore)
       FuncAttrs.addAttribute("no-trapping-math", "true");
 
     // TODO: Are these all needed?
     // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags.
     if (LangOpts.NoHonorInfs)
       FuncAttrs.addAttribute("no-infs-fp-math", "true");

clang/lib/Driver/ToolChains/Clang.cpp

static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   // -ffp-exception-behavior options: strict, maytrap, ignore
   StringRef FPExceptionBehavior = "";
   // -ffp-eval-method options: double, extended, source
   StringRef FPEvalMethod = "";
   const llvm::DenormalMode DefaultDenormalFPMath =
       TC.getDefaultDenormalModeForType(Args, JA);
   const llvm::DenormalMode DefaultDenormalFP32Math =
       TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEsingle());
+  const llvm::DenormalMode DefaultDenormalFP16Math =
+      TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEhalf());
 
   llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
   llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
+  llvm::DenormalMode DenormalFP16Math = DefaultDenormalFP16Math;
   // CUDA and HIP don't rely on the frontend to pass an ffp-contract option.
   // If one wasn't given by the user, don't pass it here.
   StringRef FPContract;
   if (!JA.isDeviceOffloading(Action::OFK_Cuda) &&
       !JA.isOffloading(Action::OFK_HIP))
     FPContract = "on";
   bool StrictFPModel = false;
 
case options::OPT_ffp_model_EQ: {
       // -fno_fast_math restores default denormal and fpcontract handling
       FPContract = "on";
       DenormalFPMath = llvm::DenormalMode::getIEEE();
 
       // FIXME: The target may have picked a non-IEEE default mode here based on
       // -cl-denorms-are-zero. Should the target consider -fp-model interaction?
       DenormalFP32Math = llvm::DenormalMode::getIEEE();
 
+      DenormalFP16Math = llvm::DenormalMode::getIEEE();
+
       StringRef Val = A->getValue();
       if (OFastEnabled && !Val.equals("fast")) {
           // Only -ffp-model=fast is compatible with OFast, ignore.
         D.Diag(clang::diag::warn_drv_overriding_flag_option)
           << Args.MakeArgString("-ffp-model=" + Val)
           << "-Ofast";
         break;
       }
for (const Arg *A : Args) {
     case options::OPT_fdenormal_fp_math_f32_EQ:
       DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue());
       if (!DenormalFP32Math.isValid()) {
         D.Diag(diag::err_drv_invalid_value)
             << A->getAsString(Args) << A->getValue();
       }
       break;
 
+    case options::OPT_fdenormal_fp_math_f16_EQ:
+      DenormalFP16Math = llvm::parseDenormalFPAttribute(A->getValue());
+      if (!DenormalFP16Math.isValid()) {
+        D.Diag(diag::err_drv_invalid_value)
+            << A->getAsString(Args) << A->getValue();
+      }
+      break;
+
     // Validate and pass through -ffp-contract option.
     case options::OPT_ffp_contract: {
       StringRef Val = A->getValue();
       if (PreciseFPModel) {
         // -ffp-model=precise enables ffp-contract=on.
         // -ffp-model=precise sets PreciseFPModel to on and Val to
         // "precise". FPContract is set.
         ;
case options::OPT_fno_unsafe_math_optimizations:
       SignedZeros = true;
       ApproxFunc = false;
       TrappingMath = true;
       FPExceptionBehavior = "strict";
 
       // The target may have opted to flush by default, so force IEEE.
       DenormalFPMath = llvm::DenormalMode::getIEEE();
       DenormalFP32Math = llvm::DenormalMode::getIEEE();
+      DenormalFP16Math = llvm::DenormalMode::getIEEE();
       break;
 
     case options::OPT_Ofast:
       // If -Ofast is the optimization level, then -ffast-math should be enabled
       if (!OFastEnabled)
         continue;
       LLVM_FALLTHROUGH;
     case options::OPT_ffast_math:
case options::OPT_fno_fast_math:
       MathErrno = TC.IsMathErrnoDefault();
       AssociativeMath = false;
       ReciprocalMath = false;
       ApproxFunc = false;
       SignedZeros = true;
       // -fno_fast_math restores default denormal and fpcontract handling
       DenormalFPMath = DefaultDenormalFPMath;
       DenormalFP32Math = llvm::DenormalMode::getIEEE();
+      DenormalFP16Math = llvm::DenormalMode::getIEEE();
       if (!JA.isDeviceOffloading(Action::OFK_Cuda) &&
           !JA.isOffloading(Action::OFK_HIP))
         if (FPContract == "fast") {
           FPContract = "on";
           D.Diag(clang::diag::warn_drv_overriding_flag_option)
               << "-ffp-contract=fast"
               << "-ffp-contract=on";
         }
       break;
     }
     if (StrictFPModel) {
       // If -ffp-model=strict has been specified on command line but
       // subsequent options conflict then emit warning diagnostic.
       if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
           SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
           DenormalFPMath == llvm::DenormalMode::getIEEE() &&
           DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
+          DenormalFP16Math == llvm::DenormalMode::getIEEE() &&
           FPContract.equals("off"))
         // OK: Current Arg doesn't conflict with -ffp-model=strict
         ;
       else {
         StrictFPModel = false;
         FPModel = "";
         D.Diag(clang::diag::warn_drv_overriding_flag_option)
             << "-ffp-model=strict" <<
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   // Add f32 specific denormal mode flag if it's different.
   if (DenormalFP32Math != DenormalFPMath) {
     llvm::SmallString<64> DenormFlag;
     llvm::raw_svector_ostream ArgStr(DenormFlag);
     ArgStr << "-fdenormal-fp-math-f32=" << DenormalFP32Math;
     CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
   }
 
+  // Add f16 specific denormal mode flag if it's different.
+  if (DenormalFP16Math != DenormalFPMath) {
+    llvm::SmallString<64> DenormFlag;
+    llvm::raw_svector_ostream ArgStr(DenormFlag);
+    ArgStr << "-fdenormal-fp-math-f16=" << DenormalFP16Math;
+    CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
+  }
+
   if (!FPContract.empty())
     CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
 
   if (!RoundingFPMath)
     CmdArgs.push_back(Args.MakeArgString("-fno-rounding-math"));
 
   if (RoundingFPMath && RoundingMathPresent)
     CmdArgs.push_back(Args.MakeArgString("-frounding-math"));

clang/lib/Frontend/CompilerInvocation.cpp

#undef CODEGEN_OPTION_WITH_MARSHALLING
   if (Opts.FPDenormalMode != llvm::DenormalMode::getIEEE())
     GenerateArg(Args, OPT_fdenormal_fp_math_EQ, Opts.FPDenormalMode.str(), SA);
 
   if ((Opts.FPDenormalMode != Opts.FP32DenormalMode) ||
       (Opts.FP32DenormalMode != llvm::DenormalMode::getIEEE()))
     GenerateArg(Args, OPT_fdenormal_fp_math_f32_EQ, Opts.FP32DenormalMode.str(),
                 SA);
 
+  if ((Opts.FPDenormalMode != Opts.FP16DenormalMode) ||
+      (Opts.FP16DenormalMode != llvm::DenormalMode::getIEEE()))
+    GenerateArg(Args, OPT_fdenormal_fp_math_f16_EQ, Opts.FP16DenormalMode.str(),
+                SA);
+
   if (Opts.StructReturnConvention == CodeGenOptions::SRCK_OnStack) {
     OptSpecifier Opt =
         T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
     GenerateArg(Args, Opt, SA);
   } else if (Opts.StructReturnConvention == CodeGenOptions::SRCK_InRegs) {
     OptSpecifier Opt =
         T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
     GenerateArg(Args, Opt, SA);
if (T.isOSAIX()) {
         Diags.Report(diag::err_aix_unsupported_tls_model) << Name;
     }
   }
 
   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
     StringRef Val = A->getValue();
     Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val);
     Opts.FP32DenormalMode = Opts.FPDenormalMode;
+    Opts.FP16DenormalMode = Opts.FPDenormalMode;
     if (!Opts.FPDenormalMode.isValid())
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
   }
 
   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
     StringRef Val = A->getValue();
     Opts.FP32DenormalMode = llvm::parseDenormalFPAttribute(Val);
     if (!Opts.FP32DenormalMode.isValid())
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
   }
 
+  if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f16_EQ)) {
+    StringRef Val = A->getValue();
+    Opts.FP16DenormalMode = llvm::parseDenormalFPAttribute(Val);
+    if (!Opts.FP16DenormalMode.isValid())
+      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
+  }
+
   // X86_32 has -fppc-struct-return and -freg-struct-return.
   // PPC32 has -maix-struct-return and -msvr4-struct-return.
   if (Arg *A =
           Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
                           OPT_maix_struct_return, OPT_msvr4_struct_return)) {
     // TODO: We might want to consider enabling these options on AIX in the
     // future.
     if (T.isOSAIX())

llvm/docs/LangRef.rst

 ``"denormal-fp-math-f32"``
     Same as ``"denormal-fp-math"``, but only controls the behavior of
     the 32-bit float type (or vectors of 32-bit floats). If both are
     are present, this overrides ``"denormal-fp-math"``. Not all targets
     support separately setting the denormal mode per type, and no
     attempt is made to diagnose unsupported uses. Currently this
     attribute is respected by the AMDGPU and NVPTX backends.
 
+``"denormal-fp-math-f16"``
+    Same as ``"denormal-fp-math"``, but only controls the behavior of
+    the 16-bit float type (or vectors of 16-bit floats). If both are
+    are present, this overrides ``"denormal-fp-math"``. Not all targets
+    support separately setting the denormal mode per type, and no
+    attempt is made to diagnose unsupported uses.
+
 ``"thunk"``
     This attribute indicates that the function will delegate to some other
     function with a tail call. The prototype of a thunk should not be used for
     optimization purposes. The caller is expected to cast the thunk prototype to
     match the thunk target prototype.
 
 ``"tls-load-hoist"``
     This attribute indicates that the function will try to reduce redundant

llvm/include/llvm/CodeGen/CommandFlags.h

 bool getEnableNoSignedZerosFPMath();
 
 bool getEnableApproxFuncFPMath();
 
 bool getEnableNoTrappingFPMath();
 
 DenormalMode::DenormalModeKind getDenormalFPMath();
 DenormalMode::DenormalModeKind getDenormalFP32Math();
+DenormalMode::DenormalModeKind getDenormalFP16Math();
 
 bool getEnableHonorSignDependentRoundingFPMath();
 
 llvm::FloatABI::ABIType getFloatABIForCalls();
 
 llvm::FPOpFusion::FPOpFusionMode getFuseFPOps();
 
 SwiftAsyncFramePointerMode getSwiftAsyncFramePointer();

llvm/include/llvm/Target/TargetOptions.h

namespace llvm {
   private:
     /// Flushing mode to assume in default FP environment.
     DenormalMode FPDenormalMode;
 
     /// Flushing mode to assume in default FP environment, for float/vector of
     /// float.
     DenormalMode FP32DenormalMode;
 
+    /// Flushing mode to assume in default FP environment, for half float/vector
+    /// of half float.
+    DenormalMode FP16DenormalMode;
+
   public:
     void setFPDenormalMode(DenormalMode Mode) {
       FPDenormalMode = Mode;
     }
 
     void setFP32DenormalMode(DenormalMode Mode) {
       FP32DenormalMode = Mode;
     }
 
+    void setFP16DenormalMode(DenormalMode Mode) { FP16DenormalMode = Mode; }
+
     DenormalMode getRawFPDenormalMode() const {
       return FPDenormalMode;
     }
 
     DenormalMode getRawFP32DenormalMode() const {
       return FP32DenormalMode;
     }
 
+    DenormalMode getRawFP16DenormalMode() const { return FP16DenormalMode; }
+
     DenormalMode getDenormalMode(const fltSemantics &FPType) const;
 
     /// What exception model to use
     ExceptionHandling ExceptionModel = ExceptionHandling::None;
 
     /// Machine level options.
     MCTargetOptions MCOptions;
 

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(bool, EnableNoInfsFPMath)
 CGOPT(bool, EnableNoNaNsFPMath)
 CGOPT(bool, EnableNoSignedZerosFPMath)
 CGOPT(bool, EnableApproxFuncFPMath)
 CGOPT(bool, EnableNoTrappingFPMath)
 CGOPT(bool, EnableAIXExtendedAltivecABI)
 CGOPT(DenormalMode::DenormalModeKind, DenormalFPMath)
 CGOPT(DenormalMode::DenormalModeKind, DenormalFP32Math)
+CGOPT(DenormalMode::DenormalModeKind, DenormalFP16Math)
 CGOPT(bool, EnableHonorSignDependentRoundingFPMath)
 CGOPT(FloatABI::ABIType, FloatABIForCalls)
 CGOPT(FPOpFusion::FPOpFusionMode, FuseFPOps)
 CGOPT(SwiftAsyncFramePointerMode, SwiftAsyncFramePointer)
 CGOPT(bool, DontPlaceZerosInBSS)
 CGOPT(bool, EnableGuaranteedTailCallOpt)
 CGOPT(bool, DisableTailCalls)
 CGOPT(bool, StackSymbolOrdering)
#define CGBINDOPT(NAME)                                                        \
 
   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);
   CGBINDOPT(DenormalFP32Math);
 
+  static cl::opt<DenormalMode::DenormalModeKind> DenormalFP16Math(
+      "denormal-fp-math-f16",
+      cl::desc("Select which denormal numbers the code is permitted to require "
+               "for half float"),
+      cl::init(DenormalMode::Invalid), DenormFlagEnumOptions);
+  CGBINDOPT(DenormalFP16Math);
+
   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));
   CGBINDOPT(EnableHonorSignDependentRoundingFPMath);
 
   static cl::opt<FloatABI::ABIType> FloatABIForCalls(
       "float-abi", cl::desc("Choose float ABI type"),
if (DenormalFP32MathView->getNumOccurrences() > 0 &&
     // FIXME: Command line flag should expose separate input/output modes.
     DenormalMode::DenormalModeKind DenormKind = getDenormalFP32Math();
 
     NewAttrs.addAttribute(
       "denormal-fp-math-f32",
       DenormalMode(DenormKind, DenormKind).str());
   }
 
+  if (DenormalFP16MathView->getNumOccurrences() > 0 &&
+      !F.hasFnAttribute("denormal-fp-math-f16")) {
+    // FIXME: Command line flag should expose separate input/output modes.
+    DenormalMode::DenormalModeKind DenormKind = getDenormalFP16Math();
+
+    NewAttrs.addAttribute("denormal-fp-math-f16",
+                          DenormalMode(DenormKind, DenormKind).str());
+  }
+
   if (TrapFuncNameView->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->addFnAttr(

llvm/lib/IR/Function.cpp

 }
 
 DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const {
   if (&FPType == &APFloat::IEEEsingle()) {
     Attribute Attr = getFnAttribute("denormal-fp-math-f32");
     StringRef Val = Attr.getValueAsString();
     if (!Val.empty())
       return parseDenormalFPAttribute(Val);
-
-    // If the f32 variant of the attribute isn't specified, try to use the
-    // generic one.
   }
+  if (&FPType == &APFloat::IEEEhalf()) {
+    Attribute Attr = getFnAttribute("denormal-fp-math-f16");
+    StringRef Val = Attr.getValueAsString();
+    if (!Val.empty())
+      return parseDenormalFPAttribute(Val);
+  }
+  // If the f32 or f16 variant of the attribute isn't specified, try to use
+  // the generic one.
 
   Attribute Attr = getFnAttribute("denormal-fp-math");
   return parseDenormalFPAttribute(Attr.getValueAsString());
 }
 
 const std::string &Function::getGC() const {
   assert(hasGC() && "Function has no collector");
   return getContext().getGC(*this);

llvm/test/Transforms/InstSimplify/constant-fold-fp-denormal.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instsimplify < %s | FileCheck %s
 
 ; Test cases for denormal handling mode when constant folding floating point
 ; operations. Input and output modes are checked seperately.
 
 ; ============================================================================ ;
 ; fadd tests
 ; Denormal operand added to normal operand produces denormal result.
 ; If denormal outputs should be flushed to zero, the result should be zero.
 ; If denormal inputs should be treated as zero, the result should be the
 ; normal operand (a number plus zero is the same number).
 ; ============================================================================ ;
 
+define half @test_half_fadd_ieee() #0 {
+; CHECK-LABEL: @test_half_fadd_ieee(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; default ieee mode leaves result as a denormal
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
+define half @test_half_fadd_pzero_out() #1 {
+; CHECK-LABEL: @test_half_fadd_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal result is flushed to positive zero
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
+define half @test_half_fadd_psign_out() #2 {
+; CHECK-LABEL: @test_half_fadd_psign_out(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal result is flushed to sign preserved zero
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
+define half @test_half_fadd_pzero_in() #3 {
+; CHECK-LABEL: @test_half_fadd_pzero_in(
+; CHECK-NEXT:    ret half 0xH8400
+;
+; denormal operand is treated as zero
+; normal operand added to zero results in the same operand as a result
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
+define half @test_half_fadd_psign_in() #4 {
+; CHECK-LABEL: @test_half_fadd_psign_in(
+; CHECK-NEXT:    ret half 0xH8400
+;
+; denormal operand is treated as zero
+; normal operand added to zero results in the same operand as a result
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
+define half @test_half_fadd_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_half_fadd_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; f16 only attribute should flush half float output
+; same as pzero_out above
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
+define half @test_half_fadd_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_half_fadd_pzero_f32_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; f32 only attribute should not flush half float output
+; default ieee mode leaves result as a denormal
+  %result = fadd half 0xH8400, 0xH0200
+  ret half %result
+}
+
 define float @test_float_fadd_ieee() #0 {
 ; CHECK-LABEL: @test_float_fadd_ieee(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
 ; default ieee mode leaves result as a denormal
   %result = fadd float 0xB810000000000000, 0x3800000000000000
   ret float %result
 }

 ; CHECK-NEXT:    ret float 0xB810000000000000
 ;
 ; denormal operand is treated as zero
 ; normal operand added to zero results in the same operand as a result
   %result = fadd float 0xB810000000000000, 0x3800000000000000
   ret float %result
 }
 
-define float @test_float_fadd_pzero_f32_out() #5 {
-; CHECK-LABEL: @test_float_fadd_pzero_f32_out(
+define float @test_float_fadd_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_float_fadd_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret float 0xB800000000000000
+;
+; f16 only attribute should not flush float output
+; default ieee mode leaves result as a denormal
+  %result = fadd float 0xB810000000000000, 0x3800000000000000
+  ret float %result
+}
+
+define float @test_float_fadd_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_float_fadd_pzero_f32_pzero_out(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
 ; f32 only attribute should flush float output
-; default ieee mode leaves result as a denormal
+; same as pzero_out above
   %result = fadd float 0xB810000000000000, 0x3800000000000000
   ret float %result
 }
 
 define double @test_double_fadd_ieee() #0 {
 ; CHECK-LABEL: @test_double_fadd_ieee(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;

 ; CHECK-NEXT:    ret double 0x8010000000000000
 ;
 ; denormal operand is treated as zero
 ; normal operand added to zero results in the same operand as a result
   %result = fadd double 0x8010000000000000, 0x0008000000000000
   ret double %result
 }
 
-define double @test_double_fadd_f32_ieee() #5 {
-; CHECK-LABEL: @test_double_fadd_f32_ieee(
+define double @test_double_fadd_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_double_fadd_f16_pzero_out(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
-; f32 only attribute should not flush doubles
+; f16 only attribute should not flush double output
+; default ieee mode leaves result as a denormal
+  %result = fadd double 0x8010000000000000, 0x0008000000000000
+  ret double %result
+}
+
+define double @test_double_fadd_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_double_fadd_f32_pzero_out(
+; CHECK-NEXT:    ret double 0x8008000000000000
+;
+; f32 only attribute should not flush double output
 ; default ieee mode leaves result as a denormal
   %result = fadd double 0x8010000000000000, 0x0008000000000000
   ret double %result
 }
 
 ; ============================================================================ ;
 ; fsub tests
 ; Normal operand subtracted from denormal operand produces denormal result
 ; If denormal outputs should be flushed to zero, the result should be zero.
 ; If denormal inputs should be treated as zero, the result should be the
 ; negated normal operand (zero minus the original operand).
 ; ============================================================================ ;
 
+define half @test_half_fsub_ieee() #0 {
+; CHECK-LABEL: @test_half_fsub_ieee(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; default ieee mode leaves result as a denormal
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
+define half @test_half_fsub_pzero_out() #1 {
+; CHECK-LABEL: @test_half_fsub_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal result is flushed to positive zero
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
+define half @test_half_fsub_psign_out() #2 {
+; CHECK-LABEL: @test_half_fsub_psign_out(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal result is flushed to sign preserved zero
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
+define half @test_half_fsub_pzero_in() #3 {
+; CHECK-LABEL: @test_half_fsub_pzero_in(
+; CHECK-NEXT:    ret half 0xH8400
+;
+; denormal operand is treated as zero
+; normal operand subtracted from zero produces the same operand, negated
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
+define half @test_half_fsub_psign_in() #4 {
+; CHECK-LABEL: @test_half_fsub_psign_in(
+; CHECK-NEXT:    ret half 0xH8400
+;
+; denormal operand is treated as zero
+; normal operand subtracted from zero produces the same operand, negated
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
+define half @test_half_fsub_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_half_fsub_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; f16 only attribute should flush half float output
+; same as pzero_out above
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
+define half @test_half_fsub_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_half_fsub_pzero_f32_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; f32 only attribute should not flush half float output
+; default ieee mode leaves result as a denormal
+  %result = fsub half 0xH0200, 0xH0400
+  ret half %result
+}
+
 define float @test_float_fsub_ieee() #0 {
 ; CHECK-LABEL: @test_float_fsub_ieee(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
 ; default ieee mode leaves result as a denormal
   %result = fsub float 0x3800000000000000, 0x3810000000000000
   ret float %result
 }

 ; CHECK-NEXT:    ret float 0xB810000000000000
 ;
 ; denormal operand is treated as zero
 ; normal operand subtracted from zero produces the same operand, negated
   %result = fsub float 0x3800000000000000, 0x3810000000000000
   ret float %result
 }
 
-define float @test_float_fsub_pzero_f32_out() #5 {
-; CHECK-LABEL: @test_float_fsub_pzero_f32_out(
+define float @test_float_fsub_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_float_fsub_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret float 0xB800000000000000
+;
+; f16 only attribute should not flush float output
+; default ieee mode leaves result as a denormal
+  %result = fsub float 0x3800000000000000, 0x3810000000000000
+  ret float %result
+}
+
+define float @test_float_fsub_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_float_fsub_pzero_f32_pzero_out(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
 ; f32 only attribute should flush float output
 ; same as pzero_out above
   %result = fsub float 0x3800000000000000, 0x3810000000000000
   ret float %result
 }
 

 ; CHECK-NEXT:    ret double 0x8010000000000000
 ;
 ; denormal operand is treated as zero
 ; normal operand subtracted from zero produces the same operand, negated
   %result = fsub double 0x0008000000000000, 0x0010000000000000
   ret double %result
 }
 
-define double @test_double_fsub_f32_ieee() #5 {
-; CHECK-LABEL: @test_double_fsub_f32_ieee(
+define double @test_double_fsub_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_double_fsub_f16_pzero_out(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
-; f32 only attribute should not flush doubles
+; f16 only attribute should not flush double output
+; default ieee mode leaves result as a denormal
+  %result = fsub double 0x0008000000000000, 0x0010000000000000
+  ret double %result
+}
+
+define double @test_double_fsub_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_double_fsub_f32_pzero_out(
+; CHECK-NEXT:    ret double 0x8008000000000000
+;
+; f32 only attribute should not flush double output
 ; default ieee mode leaves result as a denormal
   %result = fsub double 0x0008000000000000, 0x0010000000000000
   ret double %result
 }
 
 ; ============================================================================ ;
 ; fmul tests
 ; Output modes are tested by multiplying the smallest normal number by 0.5,
 ; producing a denormal result. If denormal outputs should be flushed to zero,
 ; the result should be zero.
 ; Input modes are tested by the reverse operation: taking the denormal and
 ; multiplying by 2 to produce a normal number. If denormal inputs should be
 ; treated as zero, the result should also be zero.
 ; ============================================================================ ;
 
+define half @test_half_fmul_ieee() #0 {
+; CHECK-LABEL: @test_half_fmul_ieee(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; default ieee mode leaves result as a denormal
+  %result = fmul half 0xH0400, 0xHB800
+  ret half %result
+}
+
+define half @test_half_fmul_pzero_out() #1 {
+; CHECK-LABEL: @test_half_fmul_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal result is flushed to positive zero
+  %result = fmul half 0xH0400, 0xHB800
+  ret half %result
+}
+
+define half @test_half_fmul_psign_out() #2 {
+; CHECK-LABEL: @test_half_fmul_psign_out(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal result is flushed to sign preserved zero
+  %result = fmul half 0xH0400, 0xHB800
+  ret half %result
+}
+
+define half @test_half_fmul_pzero_in() #3 {
+; CHECK-LABEL: @test_half_fmul_pzero_in(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal operand is treated as positive zero
+; anything multiplied by zero gives a zero result
+  %result = fmul half 0xH8200, 0xH4000
+  ret half %result
+}
+
+define half @test_half_fmul_psign_in() #4 {
+; CHECK-LABEL: @test_half_fmul_psign_in(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal operand is treated as signed zero
+; anything multiplied by zero gives a zero result
+  %result = fmul half 0xH8200, 0xH4000
+  ret half %result
+}
+
+define half @test_half_fmul_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_half_fmul_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; f16 only attribute should flush half float output
+; same as pzero_out above
+  %result = fmul half 0xH0400, 0xHB800
+  ret half %result
+}
+
+define half @test_half_fmul_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_half_fmul_pzero_f32_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; f32 only attribute should not flush half float output
+; default ieee mode leaves result as a denormal
+  %result = fmul half 0xH0400, 0xHB800
+  ret half %result
+}
+
 define float @test_float_fmul_ieee() #0 {
 ; CHECK-LABEL: @test_float_fmul_ieee(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
 ; default ieee mode leaves result as a denormal
   %result = fmul float 0x3810000000000000, -5.000000e-01
   ret float %result
 }

 ; CHECK-NEXT:    ret float -0.000000e+00
 ;
 ; denormal operand is treated as signed zero
 ; anything multiplied by zero gives a zero result
   %result = fmul float 0xB800000000000000, 2.000000e-00
   ret float %result
 }
 
-define float @test_float_fmul_pzero_f32_out() #1 {
-; CHECK-LABEL: @test_float_fmul_pzero_f32_out(
+define float @test_float_fmul_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_float_fmul_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret float 0xB800000000000000
+;
+; f16 only attribute should not flush float output
+; default ieee mode leaves result as a denormal
+  %result = fmul float 0x3810000000000000, -5.000000e-01
+  ret float %result
+}
+
+define float @test_float_fmul_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_float_fmul_pzero_f32_pzero_out(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
 ; f32 only attribute should flush float output
 ; same as pzero_out above
   %result = fmul float 0x3810000000000000, -5.000000e-01
   ret float %result
 }
 

 ; CHECK-NEXT:    ret double -0.000000e+00
 ;
 ; denormal operand is treated as signed zero
 ; anything multiplied by zero gives a zero result
   %result = fmul double 0x8008000000000000, 2.000000e-00
   ret double %result
 }
 
-define double @test_double_fmul_f32_ieee() #5 {
-; CHECK-LABEL: @test_double_fmul_f32_ieee(
+define double @test_double_fmul_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_double_fmul_f16_pzero_out(
+; CHECK-NEXT:    ret double 0x8008000000000000
+;
+; f16 only attribute should not flush double output
+; default ieee mode leaves result as a denormal
+  %result = fmul double 0x0010000000000000, -5.000000e-01
+  ret double %result
+}
+
+define double @test_double_fmul_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_double_fmul_f32_pzero_out(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
-; f32 only attribute should not flush doubles
+; f32 only attribute should not flush double output
 ; default ieee mode leaves result as a denormal
   %result = fmul double 0x0010000000000000, -5.000000e-01
   ret double %result
 }
 
 ; ============================================================================ ;
 ; fdiv tests
 ; Output modes are tested by dividing the smallest normal number by 2,
 ; producing a denormal result. If denormal outputs should be flushed to zero,
 ; the result should be zero.
 ; Input modes are tested by the reverse operation: taking the denormal and
 ; dividing by 0.5 to produce a normal number. If denormal inputs should be
 ; treated as zero, the result should also be zero.
 ; ============================================================================ ;
 
+define half @test_half_fdiv_ieee() #0 {
+; CHECK-LABEL: @test_half_fdiv_ieee(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; default ieee mode leaves result as a denormal
+  %result = fdiv half 0xH0400, 0xHC000
+  ret half %result
+}
+
+define half @test_half_fdiv_pzero_out() #1 {
+; CHECK-LABEL: @test_half_fdiv_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal result is flushed to positive zero
+  %result = fdiv half 0xH0400, 0xHC000
+  ret half %result
+}
+
+define half @test_half_fdiv_psign_out() #2 {
+; CHECK-LABEL: @test_half_fdiv_psign_out(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal result is flushed to sign preserved zero
+  %result = fdiv half 0xH0400, 0xHC000
+  ret half %result
+}
+
+define half @test_half_fdiv_pzero_in() #3 {
+; CHECK-LABEL: @test_half_fdiv_pzero_in(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal operand is treated as zero
+; zero divided by anything gives a zero result
+  %result = fdiv half 0xH8200, 0xH3800
+  ret half %result
+}
+
+define half @test_half_fdiv_psign_in() #4 {
+; CHECK-LABEL: @test_half_fdiv_psign_in(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal operand is treated as zero
+; zero divided by anything gives a zero result
+  %result = fmul half 0xH8200, 0xH3800
+  ret half %result
+}
+
+define half @test_half_fdiv_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_half_fdiv_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; f16 only attribute should flush half float output
+; same as pzero_out above
+  %result = fdiv half 0xH0400, 0xHC000
+  ret half %result
+}
+
+define half @test_half_fdiv_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_half_fdiv_pzero_f32_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; f32 only attribute should not flush half float output
+; default ieee mode leaves result as a denormal
+  %result = fdiv half 0xH0400, 0xHC000
+  ret half %result
+}
+
 define float @test_float_fdiv_ieee() #0 {
 ; CHECK-LABEL: @test_float_fdiv_ieee(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
 ; default ieee mode leaves result as a denormal
   %result = fdiv float 0x3810000000000000, -2.000000e-00
   ret float %result
 }

 ; CHECK-NEXT:    ret float -0.000000e+00
 ;
 ; denormal operand is treated as zero
 ; zero divided by anything gives a zero result
   %result = fmul float 0xB800000000000000, 5.000000e-01
   ret float %result
 }
 
-define float @test_float_fdiv_pzero_f32_out() #1 {
-; CHECK-LABEL: @test_float_fdiv_pzero_f32_out(
+define float @test_float_fdiv_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_float_fdiv_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret float 0xB800000000000000
+;
+; f32 only attribute should not flush float output
+; default ieee mode leaves result as a denormal
+  %result = fdiv float 0x3810000000000000, -2.000000e-00
+  ret float %result
+}
+
+define float @test_float_fdiv_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_float_fdiv_pzero_f32_pzero_out(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
 ; f32 only attribute should flush float output
 ; same as pzero_out above
   %result = fdiv float 0x3810000000000000, -2.000000e-00
   ret float %result
 }
 

 ; CHECK-NEXT:    ret double -0.000000e+00
 ;
 ; denormal operand is treated as zero
 ; zero divided by anything gives a zero result
   %result = fdiv double 0x8008000000000000, 5.000000e-01
   ret double %result
 }
 
-define double @test_double_fdiv_f32_ieee() #5 {
-; CHECK-LABEL: @test_double_fdiv_f32_ieee(
+define double @test_double_fdiv_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_double_fdiv_f16_pzero_out(
+; CHECK-NEXT:    ret double 0x8008000000000000
+;
+; f16 only attribute should not flush double output
+; default ieee mode leaves result as a denormal
+  %result = fdiv double 0x0010000000000000, -2.000000e-00
+  ret double %result
+}
+
+define double @test_double_fdiv_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_double_fdiv_f32_pzero_out(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
-; f32 only attribute should not flush doubles
+; f32 only attribute should not flush double output
 ; default ieee mode leaves result as a denormal
   %result = fdiv double 0x0010000000000000, -2.000000e-00
   ret double %result
 }
 
 ; ============================================================================ ;
 ; frem tests
 ; Output modes are tested by using two small normal numbers to produce a
 ; denormal result. If denormal outputs should be flushed to zero, the result
 ; should be zero.
 ; Input modes are tested by calculating the remainder of a denormal number
 ; and a larger normal number. If denormal inputs should be treated as zero
 ; the result also becomes zero.
 ; ============================================================================ ;
 
+define half @test_half_frem_ieee_out() #0 {
+; CHECK-LABEL: @test_half_frem_ieee_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; default ieee mode leaves result as a denormal
+  %result = frem half 0xH8600, 0xH0400
+  ret half %result
+}
+
+define half @test_half_frem_pzero_out() #1 {
+; CHECK-LABEL: @test_half_frem_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal result is flushed to positive zero
+  %result = frem half 0xH8600, 0xH0400
+  ret half %result
+}
+
+define half @test_half_frem_psign_out() #2 {
+; CHECK-LABEL: @test_half_frem_psign_out(
+; CHECK-NEXT:    ret half 0xH8000
+;
+; denormal result is flushed to sign preserved zero
+  %result = frem half 0xH8600, 0xH0400
+  ret half %result
+}
+
+define half @test_half_frem_ieee_in() #0 {
+; CHECK-LABEL: @test_half_frem_ieee_in(
+; CHECK-NEXT:    ret half 0xH0200
+;
+; default ieee mode leaves result same as input
+  %result = frem half 0xH0200, 0xH4000
+  ret half %result
+}
+
+define half @test_half_frem_pzero_in() #3 {
+; CHECK-LABEL: @test_half_frem_pzero_in(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal operand is treated as zero
+; remainder is now zero
+  %result = frem half 0xH0200, 0xH4000
+  ret half %result
+}
+
+define half @test_half_frem_psign_in() #4 {
+; CHECK-LABEL: @test_half_frem_psign_in(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; denormal operand is treated as zero
+; remainder is now zero
+  %result = frem half 0xH0200, 0xH4000
+  ret half %result
+}
+
+define half @test_half_frem_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_half_frem_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret half 0xH0000
+;
+; f16 only attribute should flush half float output
+; same as pzero_out above
+  %result = frem half 0xH8600, 0xH0400
+  ret half %result
+}
+
+define half @test_half_frem_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_half_frem_pzero_f32_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+; f32 only attribute should not flush half float output
+; default ieee mode leaves result as a denormal
+  %result = frem half 0xH8600, 0xH0400
+  ret half %result
+}
+
 define float @test_float_frem_ieee_out() #0 {
 ; CHECK-LABEL: @test_float_frem_ieee_out(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
 ; default ieee mode leaves result as a denormal
   %result = frem float 0xB818000000000000, 0x3810000000000000
   ret float %result
 }

 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
 ; denormal operand is treated as zero
 ; remainder is now zero
   %result = frem float 0x3800000000000000, 2.000000e+00
   ret float %result
 }
 
-define float @test_float_frem_pzero_f32_out() #1 {
-; CHECK-LABEL: @test_float_frem_pzero_f32_out(
+define float @test_float_frem_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_float_frem_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret float 0xB800000000000000
+;
+; f16 only attribute should not flush float output
+; default ieee mode leaves result as a denormal
+  %result = frem float 0xB818000000000000, 0x3810000000000000
+  ret float %result
+}
+
+define float @test_float_frem_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_float_frem_pzero_f32_pzero_out(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
 ; f32 only attribute should flush float output
 ; same as pzero_out above
   %result = frem float 0xB818000000000000, 0x3810000000000000
   ret float %result
 }
 

 ; CHECK-NEXT:    ret double 0.000000e+00
 ;
 ; denormal operand is treated as zero
 ; remainder is now zero
   %result = frem double 0x0008000000000000, 2.000000e+00
   ret double %result
 }
 
-define double @test_double_frem_f32_ieee() #5 {
-; CHECK-LABEL: @test_double_frem_f32_ieee(
+define double @test_double_frem_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_double_frem_f16_pzero_out(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
-; f32 only attribute should not flush doubles
+; f16 only attribute should not flush double output
+; default ieee mode leaves result as a denormal
+  %result = frem double 0x8018000000000000, 0x0010000000000000
+  ret double %result
+}
+
+define double @test_double_frem_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_double_frem_f32_pzero_out(
+; CHECK-NEXT:    ret double 0x8008000000000000
+;
+; f32 only attribute should not flush double output
 ; default ieee mode leaves result as a denormal
   %result = frem double 0x8018000000000000, 0x0010000000000000
   ret double %result
 }
 
 ; ============================================================================ ;
 ; fneg tests
 ; fneg should NOT be affected by denormal handling mode
 ; these tests confirm fneg results are unchanged
 ; ============================================================================ ;
 
+define half @test_half_fneg_ieee() #0 {
+; CHECK-LABEL: @test_half_fneg_ieee(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
+define half @test_half_fneg_pzero_out() #1 {
+; CHECK-LABEL: @test_half_fneg_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
+define half @test_half_fneg_psign_out() #2 {
+; CHECK-LABEL: @test_half_fneg_psign_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
+define half @test_half_fneg_pzero_in() #3 {
+; CHECK-LABEL: @test_half_fneg_pzero_in(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
+define half @test_half_fneg_psign_in() #4 {
+; CHECK-LABEL: @test_half_fneg_psign_in(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
+define half @test_half_fneg_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_half_fneg_f16_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
+define half @test_half_fneg_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_half_fneg_f32_pzero_out(
+; CHECK-NEXT:    ret half 0xH8200
+;
+  %result = fneg half 0xH0200
+  ret half %result
+}
+
 define float @test_float_fneg_ieee() #0 {
 ; CHECK-LABEL: @test_float_fneg_ieee(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
   %result = fneg float 0x3800000000000000
   ret float %result
 }
 
-define float @test_float_fneg_pzero_out() #0 {
+define float @test_float_fneg_pzero_out() #1 {
 ; CHECK-LABEL: @test_float_fneg_pzero_out(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
   %result = fneg float 0x3800000000000000
   ret float %result
 }
 
-define float @test_float_fneg_psign_out() #0 {
+define float @test_float_fneg_psign_out() #2 {
 ; CHECK-LABEL: @test_float_fneg_psign_out(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
   %result = fneg float 0x3800000000000000
   ret float %result
 }
 
-define float @test_float_fneg_pzero_in() #0 {
+define float @test_float_fneg_pzero_in() #3 {
 ; CHECK-LABEL: @test_float_fneg_pzero_in(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
   %result = fneg float 0x3800000000000000
   ret float %result
 }
 
-define float @test_float_fneg_psign_in() #0 {
+define float @test_float_fneg_psign_in() #4 {
 ; CHECK-LABEL: @test_float_fneg_psign_in(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
   %result = fneg float 0x3800000000000000
   ret float %result
 }
 
-define float @test_float_fneg_pzero_f32_out() #5 {
-; CHECK-LABEL: @test_float_fneg_pzero_f32_out(
+define float @test_float_fneg_pzero_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_float_fneg_pzero_f16_pzero_out(
+; CHECK-NEXT:    ret float 0xB800000000000000
+;
+  %result = fneg float 0x3800000000000000
+  ret float %result
+}
+
+define float @test_float_fneg_pzero_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_float_fneg_pzero_f32_pzero_out(
 ; CHECK-NEXT:    ret float 0xB800000000000000
 ;
   %result = fneg float 0x3800000000000000
   ret float %result
 }
 
 define double @test_double_fneg_ieee() #0 {
 ; CHECK-LABEL: @test_double_fneg_ieee(

 define double @test_double_fneg_psign_in() #4 {
 ; CHECK-LABEL: @test_double_fneg_psign_in(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
   %result = fneg double 0x0008000000000000
   ret double %result
 }
 
-define double @test_double_fneg_f32_ieee() #5 {
-; CHECK-LABEL: @test_double_fneg_f32_ieee(
+define double @test_double_fneg_f16_pzero_out() #9 {
+; CHECK-LABEL: @test_double_fneg_f16_pzero_out(
+; CHECK-NEXT:    ret double 0x8008000000000000
+;
+  %result = fneg double 0x0008000000000000
+  ret double %result
+}
+
+define double @test_double_fneg_f32_pzero_out() #5 {
+; CHECK-LABEL: @test_double_fneg_f32_pzero_out(
 ; CHECK-NEXT:    ret double 0x8008000000000000
 ;
   %result = fneg double 0x0008000000000000
   ret double %result
 }
 
+; ============================================================================ ;
+; fcmp tests
+; ============================================================================ ;
+
 define i1 @fcmp_double_ieee_in_ieee_out() #0 {
 ; CHECK-LABEL: @fcmp_double_ieee_in_ieee_out(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret i1 true
 ;
 entry:
   %cmp = fcmp une double 0x0008000000000000, 0x0
   ret i1 %cmp

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret i1 false
 ;
 entry:
   %cmp = fcmp uno double 0x0008000000000000, 0x1ff1000000000000
   ret i1 %cmp
 }
 
+; check all types don't flush when set to ieee
+define i1 @fcmp_half_ieee_in() #0 {
+; CHECK-LABEL: @fcmp_half_ieee_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une half 0xH0200, 0xH000
+  ret i1 %cmp
+}
+
+define i1 @fcmp_float_ieee_in() #0 {
+; CHECK-LABEL: @fcmp_float_ieee_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une float 0x3800000000000000, 0x0
+  ret i1 %cmp
+}
+
+define i1 @fcmp_double_ieee_in() #0 {
+; CHECK-LABEL: @fcmp_double_ieee_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une double 0x0008000000000000, 0x0
+  ret i1 %cmp
+}
+
+; check all types do flush inputs when set to positive zero
+define i1 @fcmp_half_pzero_in() #3 {
+; CHECK-LABEL: @fcmp_half_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 false
+;
+entry:
+  %cmp = fcmp une half 0xH0200, 0xH000
+  ret i1 %cmp
+}
+
+define i1 @fcmp_float_pzero_in() #3 {
+; CHECK-LABEL: @fcmp_float_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 false
+;
+entry:
+  %cmp = fcmp une float 0x3800000000000000, 0x0
+  ret i1 %cmp
+}
+
+define i1 @fcmp_double_pzero_in() #3 {
+; CHECK-LABEL: @fcmp_double_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 false
+;
+entry:
+  %cmp = fcmp une double 0x0008000000000000, 0x0
+  ret i1 %cmp
+}
+
+; check only f32 flushes when f32 attribute is set
+define i1 @fcmp_half_f32_pzero_in() #10 {
+; CHECK-LABEL: @fcmp_half_f32_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une half 0xH0200, 0xH000
+  ret i1 %cmp
+}
+
+define i1 @fcmp_float_f32_pzero_in() #10 {
+; CHECK-LABEL: @fcmp_float_f32_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 false
+;
+entry:
+  %cmp = fcmp une float 0x3800000000000000, 0x0
+  ret i1 %cmp
+}
+
+define i1 @fcmp_double_f32_pzero_in() #10 {
+; CHECK-LABEL: @fcmp_double_f32_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une double 0x0008000000000000, 0x0
+  ret i1 %cmp
+}
+
+; check only f16 flushes when f16 attribute is set
+define i1 @fcmp_half_f16_pzero_in() #11 {
+; CHECK-LABEL: @fcmp_half_f16_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 false
+;
+entry:
+  %cmp = fcmp une half 0xH0200, 0xH000
+  ret i1 %cmp
+}
+
+define i1 @fcmp_float_f16_pzero_in() #11 {
+; CHECK-LABEL: @fcmp_float_f16_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une float 0x3800000000000000, 0x0
+  ret i1 %cmp
+}
+
+define i1 @fcmp_double_f16_pzero_in() #11 {
+; CHECK-LABEL: @fcmp_double_f16_pzero_in(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret i1 true
+;
+entry:
+  %cmp = fcmp une double 0x0008000000000000, 0x0
+  ret i1 %cmp
+}
+
 attributes #0 = { nounwind "denormal-fp-math"="ieee,ieee" }
 attributes #1 = { nounwind "denormal-fp-math"="positive-zero,ieee" }
 attributes #2 = { nounwind "denormal-fp-math"="preserve-sign,ieee" }
 attributes #3 = { nounwind "denormal-fp-math"="ieee,positive-zero" }
 attributes #4 = { nounwind "denormal-fp-math"="ieee,preserve-sign" }
 attributes #5 = { nounwind "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="positive-zero,ieee" }
 attributes #6 = { nounwind "denormal-fp-math"="positive-zero,positive-zero" }
 attributes #7 = { nounwind "denormal-fp-math"="preserve-sign,preserve-sign" }
 attributes #8 = { nounwind "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="positive-zero,positive-zero" }
+attributes #9 = { nounwind "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f16"="positive-zero,ieee" }
+attributes #10 = { nounwind "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f32"="ieee,positive-zero" }
+attributes #11 = { nounwind "denormal-fp-math"="ieee,ieee" "denormal-fp-math-f16"="ieee,positive-zero" }