Merge FloatingPointMode and FPEnv headers

[cameron.mcinally]

The fp:: qualifier is kind of verbose. I'm not familiar with LLVM's C++ rules, but can we replace them with using namespace fp;? Or can we remove the fp namespace completely?

[arsenm]

In D77247#1955942, @cameron.mcinally wrote:

The fp:: qualifier is kind of verbose. I'm not familiar with LLVM's C++ rules, but can we replace them with using namespace fp;? Or can we remove the fp namespace completely?

I’m not sure, I just merged into FPEnv and followed what it was doing.

[arsenm]

In D77247#1957027, @arsenm wrote:

In D77247#1955942, @cameron.mcinally wrote:

The fp:: qualifier is kind of verbose. I'm not familiar with LLVM's C++ rules, but can we replace them with using namespace fp;? Or can we remove the fp namespace completely?

I’m not sure, I just merged into FPEnv and followed what it was doing.

I think llvm tends to use namespaces around enums as a substitute to have qualified enum values (which I guess is a poor substitute for enum class). I would be fine eliminating the namespace and switching the existing enums to use enum class.

[cameron.mcinally]

LGTM

That sounds good. I'm okay with doing it in this patch or leaving it for later. Your call. Everything else looks good.

[sepavloff]

In D77247#1957276, @arsenm wrote:

In D77247#1957027, @arsenm wrote:

In D77247#1955942, @cameron.mcinally wrote:

The fp:: qualifier is kind of verbose. I'm not familiar with LLVM's C++ rules, but can we replace them with using namespace fp;? Or can we remove the fp namespace completely?

I’m not sure, I just merged into FPEnv and followed what it was doing.

I think llvm tends to use namespaces around enums as a substitute to have qualified enum values (which I guess is a poor substitute for enum class). I would be fine eliminating the namespace and switching the existing enums to use enum class.

Using C++ strict enums looks a better way than namespaces.

Interestingly, I am working on similar patch, that unifies rounding mode enums. But I have to move the enum RondingMode to ADT/FloatingPointMode.h because the rounding mode enum is used in APFloat and it is not a good thing to refer IR header in Support library. If you consider using DenormalMode in APFloat (for example to implement constant folding dependent on this mode) you might consider keeping its definition in more common place.

[arsenm]

In D77247#1957368, @sepavloff wrote:

In D77247#1957276, @arsenm wrote:

In D77247#1957027, @arsenm wrote:

In D77247#1955942, @cameron.mcinally wrote:

The fp:: qualifier is kind of verbose. I'm not familiar with LLVM's C++ rules, but can we replace them with using namespace fp;? Or can we remove the fp namespace completely?

I’m not sure, I just merged into FPEnv and followed what it was doing.

I think llvm tends to use namespaces around enums as a substitute to have qualified enum values (which I guess is a poor substitute for enum class). I would be fine eliminating the namespace and switching the existing enums to use enum class.

Using C++ strict enums looks a better way than namespaces.

Interestingly, I am working on similar patch, that unifies rounding mode enums. But I have to move the enum RondingMode to ADT/FloatingPointMode.h because the rounding mode enum is used in APFloat and it is not a good thing to refer IR header in Support library. If you consider using DenormalMode in APFloat (for example to implement constant folding dependent on this mode) you might consider keeping its definition in more common place.

I think the denormal and rounding modes should be kept together, so I'm fine merging in either direction

[sepavloff]

I put my patch here: D77379. Taking rounding mode from IR/FPEnv.h may look awkward as rounding modes are used in APFloat implementation, which is in Support library. It however does not break anything as it is only header use. Moving content of IR/FPEnv.h to Support library is not an option because it contains IR specific declarations and companion source file FPEnv.cpp references things from IR library. We also could move rounding mode enumeration into APFloat.h but it would put RoundingMode and DenormalMode into different headers.

[arsenm]

Need to merge in the other direction, so this is backwards

clang/include/clang/Basic/CodeGenOptions.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_CODEGENOPTIONS_H
 #define LLVM_CLANG_BASIC_CODEGENOPTIONS_H
 
 #include "clang/Basic/DebugInfoOptions.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Basic/XRayInstr.h"
-#include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Target/TargetOptions.h"
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
public:
   std::string RecordCommandLine;
 
   std::map<std::string, std::string> DebugPrefixMap;
 
   /// The ABI to use for passing floating point arguments.
   std::string FloatABI;
 
   /// The floating-point denormal mode to use.
-  llvm::DenormalMode FPDenormalMode = llvm::DenormalMode::getIEEE();
+  llvm::fp::DenormalMode FPDenormalMode = llvm::fp::DenormalMode::getIEEE();
 
   /// The floating-point denormal mode to use, for float.
-  llvm::DenormalMode FP32DenormalMode = llvm::DenormalMode::getIEEE();
+  llvm::fp::DenormalMode FP32DenormalMode = llvm::fp::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

clang/include/clang/Driver/ToolChain.h

 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Multilib.h"
 #include "clang/Driver/Types.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cassert>
 #include <memory>
 #include <string>
 #include <utility>
public:
 
   /// Returns true when it's possible to split LTO unit to use whole
   /// program devirtualization and CFI santiizers.
   virtual bool canSplitThinLTOUnit() const { return true; }
 
   /// Returns the output denormal handling type in the default floating point
   /// environment for the given \p FPType if given. Otherwise, the default
   /// assumed mode for any floating point type.
-  virtual llvm::DenormalMode getDefaultDenormalModeForType(
+  virtual llvm::fp::DenormalMode getDefaultDenormalModeForType(
       const llvm::opt::ArgList &DriverArgs,
       Action::OffloadKind DeviceOffloadKind,
       const llvm::fltSemantics *FPType = nullptr) const {
-    return llvm::DenormalMode::getIEEE();
+    return llvm::fp::DenormalMode::getIEEE();
   }
 };
 
 /// Set a ToolChain's effective triple. Reset it when the registration object
 /// is destroyed.
 class RegisterEffectiveTriple {
   const ToolChain &TC;
 

clang/lib/CodeGen/CGCall.cpp

if (AttrOnCallSite) {
     FuncAttrs.addAttribute("frame-pointer", FpKind);
 
     FuncAttrs.addAttribute("less-precise-fpmad",
                            llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
 
     if (CodeGenOpts.NullPointerIsValid)
       FuncAttrs.addAttribute("null-pointer-is-valid", "true");
 
-    if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE())
+    if (CodeGenOpts.FPDenormalMode != llvm::fp::DenormalMode::getIEEE())
       FuncAttrs.addAttribute("denormal-fp-math",
                              CodeGenOpts.FPDenormalMode.str());
     if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) {
       FuncAttrs.addAttribute(
           "denormal-fp-math-f32",
           CodeGenOpts.FP32DenormalMode.str());
     }
 

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::Release() {
   }
 
   if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
     // Indicate whether __nvvm_reflect should be configured to flush denormal
     // floating point values to 0.  (This corresponds to its "__CUDA_FTZ"
     // property.)
     getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
                               CodeGenOpts.FP32DenormalMode.Output !=
-                                  llvm::DenormalMode::IEEE);
+                                  llvm::fp::DenormalMode::IEEE);
   }
 
   // Emit OpenCL specific module metadata: OpenCL/SPIR version.
   if (LangOpts.OpenCL) {
     EmitOpenCLMetadata();
     // Emit SPIR version.
     if (getTriple().isSPIR()) {
       // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the

clang/lib/Driver/ToolChains/AMDGPU.h

public:
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind DeviceOffloadKind) const override;
 
   /// Return whether denormals should be flushed, and treated as 0 by default
   /// for the subtarget.
   static bool getDefaultDenormsAreZeroForTarget(llvm::AMDGPU::GPUKind GPUKind);
 
-  llvm::DenormalMode getDefaultDenormalModeForType(
+  llvm::fp::DenormalMode getDefaultDenormalModeForType(
       const llvm::opt::ArgList &DriverArgs,
       Action::OffloadKind DeviceOffloadKind,
       const llvm::fltSemantics *FPType = nullptr) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AMDGPU_H

clang/lib/Driver/ToolChains/AMDGPU.cpp

bool AMDGPUToolChain::getDefaultDenormsAreZeroForTarget(
   // Default to enabling f32 denormals by default on subtargets where fma is
   // fast with denormals
   const bool BothDenormAndFMAFast =
       (ArchAttr & llvm::AMDGPU::FEATURE_FAST_FMA_F32) &&
       (ArchAttr & llvm::AMDGPU::FEATURE_FAST_DENORMAL_F32);
   return !BothDenormAndFMAFast;
 }
 
-llvm::DenormalMode AMDGPUToolChain::getDefaultDenormalModeForType(
+llvm::fp::DenormalMode AMDGPUToolChain::getDefaultDenormalModeForType(
     const llvm::opt::ArgList &DriverArgs, Action::OffloadKind DeviceOffloadKind,
     const llvm::fltSemantics *FPType) const {
   // Denormals should always be enabled for f16 and f64.
   if (!FPType || FPType != &llvm::APFloat::IEEEsingle())
-    return llvm::DenormalMode::getIEEE();
+    return llvm::fp::DenormalMode::getIEEE();
 
   if (DeviceOffloadKind == Action::OFK_Cuda) {
     if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
         DriverArgs.hasFlag(options::OPT_fcuda_flush_denormals_to_zero,
                            options::OPT_fno_cuda_flush_denormals_to_zero,
                            false))
-      return llvm::DenormalMode::getPreserveSign();
+      return llvm::fp::DenormalMode::getPreserveSign();
   }
 
   const StringRef GpuArch = DriverArgs.getLastArgValue(options::OPT_mcpu_EQ);
   auto Kind = llvm::AMDGPU::parseArchAMDGCN(GpuArch);
 
   // TODO: There are way too many flags that change this. Do we need to check
   // them all?
   bool DAZ = DriverArgs.hasArg(options::OPT_cl_denorms_are_zero) ||
              getDefaultDenormsAreZeroForTarget(Kind);
   // Outputs are flushed to zero, preserving sign
-  return DAZ ? llvm::DenormalMode::getPreserveSign() :
-               llvm::DenormalMode::getIEEE();
+  return DAZ ? llvm::fp::DenormalMode::getPreserveSign()
+             : llvm::fp::DenormalMode::getIEEE();
 }
 
 void AMDGPUToolChain::addClangTargetOptions(
     const llvm::opt::ArgList &DriverArgs,
     llvm::opt::ArgStringList &CC1Args,
     Action::OffloadKind DeviceOffloadingKind) const {
   // Default to "hidden" visibility, as object level linking will not be
   // supported for the foreseeable future.
   if (!DriverArgs.hasArg(options::OPT_fvisibility_EQ,
                          options::OPT_fvisibility_ms_compat)) {
     CC1Args.push_back("-fvisibility");
     CC1Args.push_back("hidden");
     CC1Args.push_back("-fapply-global-visibility-to-externs");
   }
 }

clang/lib/Driver/ToolChains/Clang.cpp

static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   bool TrappingMathPresent = false; // Is trapping-math in args, and not
                                     // overriden by ffp-exception-behavior?
   bool RoundingFPMath = false;
   bool RoundingMathPresent = false; // Is rounding-math in args?
   // -ffp-model values: strict, fast, precise
   StringRef FPModel = "";
   // -ffp-exception-behavior options: strict, maytrap, ignore
   StringRef FPExceptionBehavior = "";
-  const llvm::DenormalMode DefaultDenormalFPMath =
+  const llvm::fp::DenormalMode DefaultDenormalFPMath =
       TC.getDefaultDenormalModeForType(Args, DeviceOffloadKind);
-  const llvm::DenormalMode DefaultDenormalFP32Math =
+  const llvm::fp::DenormalMode DefaultDenormalFP32Math =
     TC.getDefaultDenormalModeForType(Args, DeviceOffloadKind,
                                      &llvm::APFloat::IEEEsingle());
 
-  llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
-  llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
+  llvm::fp::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
+  llvm::fp::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
   StringRef FPContract = "";
   bool StrictFPModel = false;
 
 
   if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
     CmdArgs.push_back("-mlimit-float-precision");
     CmdArgs.push_back(A->getValue());
   }
case options::OPT_ffp_model_EQ: {
       HonorNaNs = true;
       // Turning *off* -ffast-math restores the toolchain default.
       MathErrno = TC.IsMathErrnoDefault();
       AssociativeMath = false;
       ReciprocalMath = false;
       SignedZeros = true;
       // -fno_fast_math restores default denormal and fpcontract handling
       FPContract = "";
-      DenormalFPMath = llvm::DenormalMode::getIEEE();
+      DenormalFPMath = llvm::fp::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();
+      DenormalFP32Math = llvm::fp::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_fno_unsafe_math_optimizations:
       AssociativeMath = false;
       ReciprocalMath = false;
       SignedZeros = true;
       TrappingMath = true;
       FPExceptionBehavior = "strict";
 
       // The target may have opted to flush by default, so force IEEE.
-      DenormalFPMath = llvm::DenormalMode::getIEEE();
-      DenormalFP32Math = llvm::DenormalMode::getIEEE();
+      DenormalFPMath = llvm::fp::DenormalMode::getIEEE();
+      DenormalFP32Math = llvm::fp::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;
       SignedZeros = true;
       TrappingMath = false;
       RoundingFPMath = false;
       // -fno_fast_math restores default denormal and fpcontract handling
       DenormalFPMath = DefaultDenormalFPMath;
-      DenormalFP32Math = llvm::DenormalMode::getIEEE();
+      DenormalFP32Math = llvm::fp::DenormalMode::getIEEE();
       FPContract = "";
       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 &&
         (FPContract.equals("off") || FPContract.empty()) &&
-        DenormalFPMath == llvm::DenormalMode::getIEEE() &&
-        DenormalFP32Math == llvm::DenormalMode::getIEEE())
+        DenormalFPMath == llvm::fp::DenormalMode::getIEEE() &&
+        DenormalFP32Math == llvm::fp::DenormalMode::getIEEE())
         // 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" <<
             ((A->getNumValues() == 0) ?  A->getSpelling()
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   if (TrappingMath) {
     // FP Exception Behavior is also set to strict
     assert(FPExceptionBehavior.equals("strict"));
     CmdArgs.push_back("-ftrapping-math");
   } else if (TrappingMathPresent)
     CmdArgs.push_back("-fno-trapping-math");
 
   // The default is IEEE.
-  if (DenormalFPMath != llvm::DenormalMode::getIEEE()) {
+  if (DenormalFPMath != llvm::fp::DenormalMode::getIEEE()) {
     llvm::SmallString<64> DenormFlag;
     llvm::raw_svector_ostream ArgStr(DenormFlag);
     ArgStr << "-fdenormal-fp-math=" << DenormalFPMath;
     CmdArgs.push_back(Args.MakeArgString(ArgStr.str()));
   }
 
   // Add f32 specific denormal mode flag if it's different.
   if (DenormalFP32Math != DenormalFPMath) {

clang/lib/Driver/ToolChains/Cuda.h

public:
 
   llvm::opt::DerivedArgList *
   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
                 Action::OffloadKind DeviceOffloadKind) const override;
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind DeviceOffloadKind) const override;
 
-  llvm::DenormalMode getDefaultDenormalModeForType(
+  llvm::fp::DenormalMode getDefaultDenormalModeForType(
       const llvm::opt::ArgList &DriverArgs,
       Action::OffloadKind DeviceOffloadKind,
       const llvm::fltSemantics *FPType = nullptr) const override;
 
   // Never try to use the integrated assembler with CUDA; always fork out to
   // ptxas.
   bool useIntegratedAs() const override { return false; }
   bool isCrossCompiling() const override { return true; }

clang/lib/Driver/ToolChains/Cuda.cpp

for (StringRef LibraryPath : LibraryPaths) {
       }
     }
     if (!FoundBCLibrary)
       getDriver().Diag(diag::warn_drv_omp_offload_target_missingbcruntime)
           << LibOmpTargetName;
   }
 }
 
-llvm::DenormalMode CudaToolChain::getDefaultDenormalModeForType(
+llvm::fp::DenormalMode CudaToolChain::getDefaultDenormalModeForType(
     const llvm::opt::ArgList &DriverArgs, Action::OffloadKind DeviceOffloadKind,
     const llvm::fltSemantics *FPType) const {
   if (DeviceOffloadKind == Action::OFK_Cuda) {
     if (FPType && FPType == &llvm::APFloat::IEEEsingle() &&
         DriverArgs.hasFlag(options::OPT_fcuda_flush_denormals_to_zero,
                            options::OPT_fno_cuda_flush_denormals_to_zero,
                            false))
-      return llvm::DenormalMode::getPreserveSign();
+      return llvm::fp::DenormalMode::getPreserveSign();
   }
 
   assert(DeviceOffloadKind != Action::OFK_Host);
-  return llvm::DenormalMode::getIEEE();
+  return llvm::fp::DenormalMode::getIEEE();
 }
 
 bool CudaToolChain::supportsDebugInfoOption(const llvm::opt::Arg *A) const {
   const Option &O = A->getOption();
   return (O.matches(options::OPT_gN_Group) &&
           !O.matches(options::OPT_gmodules)) ||
          O.matches(options::OPT_g_Flag) ||
          O.matches(options::OPT_ggdbN_Group) || O.matches(options::OPT_ggdb) ||

clang/lib/Driver/ToolChains/Linux.h

public:
   virtual std::string computeSysRoot() const;
 
   std::string getDynamicLinker(const llvm::opt::ArgList &Args) const override;
 
   void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const override;
 
   std::vector<std::string> ExtraOpts;
 
-  llvm::DenormalMode getDefaultDenormalModeForType(
+  llvm::fp::DenormalMode getDefaultDenormalModeForType(
     const llvm::opt::ArgList &DriverArgs,
     Action::OffloadKind DeviceOffloadKind,
     const llvm::fltSemantics *FPType = nullptr) const override;
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 

clang/lib/Driver/ToolChains/Linux.cpp

void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
   // initialization module to be linked in.
   if ((!Args.hasArg(options::OPT_coverage)) &&
       (!Args.hasArg(options::OPT_ftest_coverage)))
     CmdArgs.push_back(Args.MakeArgString(
         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
   ToolChain::addProfileRTLibs(Args, CmdArgs);
 }
 
-llvm::DenormalMode Linux::getDefaultDenormalModeForType(
+llvm::fp::DenormalMode Linux::getDefaultDenormalModeForType(
   const llvm::opt::ArgList &DriverArgs,
   Action::OffloadKind DeviceOffloadKind,
   const llvm::fltSemantics *FPType) const {
   switch (getTriple().getArch()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64: {
     std::string Unused;
     // DAZ and FTZ are turned on in crtfastmath.o
     if (!DriverArgs.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
         isFastMathRuntimeAvailable(DriverArgs, Unused))
-      return llvm::DenormalMode::getPreserveSign();
-    return llvm::DenormalMode::getIEEE();
+      return llvm::fp::DenormalMode::getPreserveSign();
+    return llvm::fp::DenormalMode::getIEEE();
   }
   default:
-    return llvm::DenormalMode::getIEEE();
+    return llvm::fp::DenormalMode::getIEEE();
   }
 }
 
 void Linux::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {
   for (const auto &Opt : ExtraOpts)
     CmdArgs.push_back(Opt.c_str());
 }

clang/lib/Driver/ToolChains/PS4CPU.h

public:
   // capable of unit splitting.
   bool canSplitThinLTOUnit() const override { return false; }
 
   void addClangTargetOptions(
     const llvm::opt::ArgList &DriverArgs,
     llvm::opt::ArgStringList &CC1Args,
     Action::OffloadKind DeviceOffloadingKind) const override;
 
-  llvm::DenormalMode getDefaultDenormalModeForType(
+  llvm::fp::DenormalMode getDefaultDenormalModeForType(
     const llvm::opt::ArgList &DriverArgs,
     Action::OffloadKind DeviceOffloadKind,
     const llvm::fltSemantics *FPType) const override {
     // DAZ and FTZ are on by default.
-    return llvm::DenormalMode::getPreserveSign();
+    return llvm::fp::DenormalMode::getPreserveSign();
   }
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_PS4CPU_H

llvm/include/llvm/ADT/FloatingPointMode.h

-//===- llvm/Support/FloatingPointMode.h -------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Utilities for dealing with flags related to floating point mode controls.
-//
-//===----------------------------------------------------------------------===/
-
-#ifndef LLVM_FLOATINGPOINTMODE_H
-#define LLVM_FLOATINGPOINTMODE_H
-
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace llvm {
-
-/// Represent ssubnormal handling kind for floating point instruction inputs and
-/// outputs.
-struct DenormalMode {
-  /// Represent handled modes for denormal (aka subnormal) modes in the floating
-  /// point environment.
-  enum DenormalModeKind : int8_t {
-    Invalid = -1,
-
-    /// IEEE-754 denormal numbers preserved.
-    IEEE,
-
-    /// The sign of a flushed-to-zero number is preserved in the sign of 0
-    PreserveSign,
-
-    /// Denormals are flushed to positive zero.
-    PositiveZero
-  };
-
-  /// Denormal flushing mode for floating point instruction results in the
-  /// default floating point environment.
-  DenormalModeKind Output = DenormalModeKind::Invalid;
-
-  /// Denormal treatment kind for floating point instruction inputs in the
-  /// default floating-point environment. If this is not DenormalModeKind::IEEE,
-  /// floating-point instructions implicitly treat the input value as 0.
-  DenormalModeKind Input = DenormalModeKind::Invalid;
-
-  constexpr DenormalMode() = default;
-  constexpr DenormalMode(DenormalModeKind Out, DenormalModeKind In) :
-    Output(Out), Input(In) {}
-
-
-  static constexpr DenormalMode getInvalid() {
-    return DenormalMode(DenormalModeKind::Invalid, DenormalModeKind::Invalid);
-  }
-
-  static constexpr DenormalMode getIEEE() {
-    return DenormalMode(DenormalModeKind::IEEE, DenormalModeKind::IEEE);
-  }
-
-  static constexpr DenormalMode getPreserveSign() {
-    return DenormalMode(DenormalModeKind::PreserveSign,
-                        DenormalModeKind::PreserveSign);
-  }
-
-  static constexpr DenormalMode getPositiveZero() {
-    return DenormalMode(DenormalModeKind::PositiveZero,
-                        DenormalModeKind::PositiveZero);
-  }
-
-  bool operator==(DenormalMode Other) const {
-    return Output == Other.Output && Input == Other.Input;
-  }
-
-  bool operator!=(DenormalMode Other) const {
-    return !(*this == Other);
-  }
-
-  bool isSimple() const {
-    return Input == Output;
-  }
-
-  bool isValid() const {
-    return Output != DenormalModeKind::Invalid &&
-           Input != DenormalModeKind::Invalid;
-  }
-
-  inline void print(raw_ostream &OS) const;
-
-  inline std::string str() const {
-    std::string storage;
-    raw_string_ostream OS(storage);
-    print(OS);
-    return OS.str();
-  }
-};
-
-inline raw_ostream& operator<<(raw_ostream &OS, DenormalMode Mode) {
-  Mode.print(OS);
-  return OS;
-}
-
-/// Parse the expected names from the denormal-fp-math attribute.
-inline DenormalMode::DenormalModeKind
-parseDenormalFPAttributeComponent(StringRef Str) {
-  // Assume ieee on unspecified attribute.
-  return StringSwitch<DenormalMode::DenormalModeKind>(Str)
-    .Cases("", "ieee", DenormalMode::IEEE)
-    .Case("preserve-sign", DenormalMode::PreserveSign)
-    .Case("positive-zero", DenormalMode::PositiveZero)
-    .Default(DenormalMode::Invalid);
-}
-
-/// Return the name used for the denormal handling mode used by the the
-/// expected names from the denormal-fp-math attribute.
-inline StringRef denormalModeKindName(DenormalMode::DenormalModeKind Mode) {
-  switch (Mode) {
-  case DenormalMode::IEEE:
-    return "ieee";
-  case DenormalMode::PreserveSign:
-    return "preserve-sign";
-  case DenormalMode::PositiveZero:
-    return "positive-zero";
-  default:
-    return "";
-  }
-}
-
-/// Returns the denormal mode to use for inputs and outputs.
-inline DenormalMode parseDenormalFPAttribute(StringRef Str) {
-  StringRef OutputStr, InputStr;
-  std::tie(OutputStr, InputStr) = Str.split(',');
-
-  DenormalMode Mode;
-  Mode.Output = parseDenormalFPAttributeComponent(OutputStr);
-
-  // Maintain compatability with old form of the attribute which only specified
-  // one component.
-  Mode.Input = InputStr.empty() ? Mode.Output  :
-               parseDenormalFPAttributeComponent(InputStr);
-
-  return Mode;
-}
-
-void DenormalMode::print(raw_ostream &OS) const {
-  OS << denormalModeKindName(Output) << ',' << denormalModeKindName(Input);
-}
-
-}
-
-#endif // LLVM_FLOATINGPOINTMODE_H

llvm/include/llvm/CodeGen/CommandFlags.h

 //===-- CommandFlags.h - Command Line Flags Interface -----------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains codegen-specific flags that are shared between different
 // command line tools. The tools "llc" and "opt" both use this file to prevent
 // flag duplication.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Host.h"

 bool getEnableNoInfsFPMath();
 
 bool getEnableNoNaNsFPMath();
 
 bool getEnableNoSignedZerosFPMath();
 
 bool getEnableNoTrappingFPMath();
 
-DenormalMode::DenormalModeKind getDenormalFPMath();
-DenormalMode::DenormalModeKind getDenormalFP32Math();
+fp::DenormalMode::DenormalModeKind getDenormalFPMath();
+fp::DenormalMode::DenormalModeKind getDenormalFP32Math();
 
 bool getEnableHonorSignDependentRoundingFPMath();
 
 llvm::FloatABI::ABIType getFloatABIForCalls();
 
 llvm::FPOpFusion::FPOpFusionMode getFuseFPOps();
 
 bool getDontPlaceZerosInBSS();

llvm/include/llvm/CodeGen/MachineFunction.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_MACHINEFUNCTION_H
 #define LLVM_CODEGEN_MACHINEFUNCTION_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ArrayRecycler.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Recycler.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cassert>
public:
 
   template<typename Ty>
   const Ty *getInfo() const {
      return const_cast<MachineFunction*>(this)->getInfo<Ty>();
   }
 
   /// Returns the denormal handling type for the default rounding mode of the
   /// function.
-  DenormalMode getDenormalMode(const fltSemantics &FPType) const;
+  fp::DenormalMode getDenormalMode(const fltSemantics &FPType) const;
 
   /// getBlockNumbered - MachineBasicBlocks are automatically numbered when they
   /// are inserted into the machine function.  The block number for a machine
   /// basic block can be found by using the MBB::getNumber method, this method
   /// provides the inverse mapping.
   MachineBasicBlock *getBlockNumbered(unsigned N) const {
     assert(N < MBBNumbering.size() && "Illegal block number");
     assert(MBBNumbering[N] && "Block was removed from the machine function!");

llvm/include/llvm/CodeGen/SelectionDAG.h

MDNode *getHeapAllocSite(const SDNode *Node) {
     auto It = SDCallSiteDbgInfo.find(Node);
     if (It == SDCallSiteDbgInfo.end())
       return nullptr;
     return It->second.HeapAllocSite;
   }
 
   /// Return the current function's default denormal handling kind for the given
   /// floating point type.
-  DenormalMode getDenormalMode(EVT VT) const {
+  fp::DenormalMode getDenormalMode(EVT VT) const {
     return MF->getDenormalMode(EVTToAPFloatSemantics(VT));
   }
 
   bool shouldOptForSize() const;
 
 private:
   void InsertNode(SDNode *N);
   bool RemoveNodeFromCSEMaps(SDNode *N);

llvm/include/llvm/IR/FPEnv.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_FLOATINGPOINT_H
 #define LLVM_IR_FLOATINGPOINT_H
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/StringRef.h"
-#include <stdint.h>
+#include "llvm/Support/raw_ostream.h"
+
+#include <cstdint>
 
 namespace llvm {
 
 namespace fp {
 
 /// Rounding mode used for floating point operations.
 ///
 /// Each of these values correspond to some metadata argument value of a

 /// constrained floating point intrinsic. See the LLVM Language Reference Manual
 /// for details.
 enum ExceptionBehavior : uint8_t {
   ebIgnore,  ///< This corresponds to "fpexcept.ignore".
   ebMayTrap, ///< This corresponds to "fpexcept.maytrap".
   ebStrict   ///< This corresponds to "fpexcept.strict".
 };
 
+/// Represent denormal/subnormal handling kind for floating point instruction
+/// inputs and outputs.
+struct DenormalMode {
+  /// Represent handled modes for denormal (aka subnormal) modes in the floating
+  /// point environment.
+  enum DenormalModeKind : int8_t {
+    Invalid = -1,
+
+    /// IEEE-754 denormal numbers preserved.
+    IEEE,
+
+    /// The sign of a flushed-to-zero number is preserved in the sign of 0
+    PreserveSign,
+
+    /// Denormals are flushed to positive zero.
+    PositiveZero
+  };
+
+  /// Denormal flushing mode for floating point instruction results in the
+  /// default floating point environment.
+  DenormalModeKind Output = DenormalModeKind::Invalid;
+
+  /// Denormal treatment kind for floating point instruction inputs in the
+  /// default floating-point environment. If this is not DenormalModeKind::IEEE,
+  /// floating-point instructions implicitly treat the input value as 0.
+  DenormalModeKind Input = DenormalModeKind::Invalid;
+
+  constexpr DenormalMode() = default;
+  constexpr DenormalMode(DenormalModeKind Out, DenormalModeKind In) :
+    Output(Out), Input(In) {}
+
+
+  static constexpr DenormalMode getInvalid() {
+    return DenormalMode(DenormalModeKind::Invalid, DenormalModeKind::Invalid);
+  }
+
+  static constexpr DenormalMode getIEEE() {
+    return DenormalMode(DenormalModeKind::IEEE, DenormalModeKind::IEEE);
+  }
+
+  static constexpr DenormalMode getPreserveSign() {
+    return DenormalMode(DenormalModeKind::PreserveSign,
+                        DenormalModeKind::PreserveSign);
+  }
+
+  static constexpr DenormalMode getPositiveZero() {
+    return DenormalMode(DenormalModeKind::PositiveZero,
+                        DenormalModeKind::PositiveZero);
+  }
+
+  bool operator==(DenormalMode Other) const {
+    return Output == Other.Output && Input == Other.Input;
+  }
+
+  bool operator!=(DenormalMode Other) const {
+    return !(*this == Other);
+  }
+
+  bool isSimple() const {
+    return Input == Output;
   }
 
+  bool isValid() const {
+    return Output != DenormalModeKind::Invalid &&
+           Input != DenormalModeKind::Invalid;
+  }
+
+  inline void print(raw_ostream &OS) const;
+
+  inline std::string str() const {
+    std::string storage;
+    raw_string_ostream OS(storage);
+    print(OS);
+    return OS.str();
+  }
+};
+
+} // namespace fp
+
 /// Returns a valid RoundingMode enumerator when given a string
 /// that is valid as input in constrained intrinsic rounding mode
 /// metadata.
 Optional<fp::RoundingMode> StrToRoundingMode(StringRef);
 
 /// For any RoundingMode enumerator, returns a string valid as input in
 /// constrained intrinsic rounding mode metadata.
 Optional<StringRef> RoundingModeToStr(fp::RoundingMode);
 
 /// Returns a valid ExceptionBehavior enumerator when given a string
 /// valid as input in constrained intrinsic exception behavior metadata.
 Optional<fp::ExceptionBehavior> StrToExceptionBehavior(StringRef);
 
 /// For any ExceptionBehavior enumerator, returns a string valid as
 /// input in constrained intrinsic exception behavior metadata.
 Optional<StringRef> ExceptionBehaviorToStr(fp::ExceptionBehavior);
 
 /// Converts rounding mode represented by fp::RoundingMode to the rounding mode
 /// index used by APFloat. For fp::rmDynamic it returns None.
 Optional<APFloatBase::roundingMode> getAPFloatRoundingMode(fp::RoundingMode);
+
+inline raw_ostream &operator<<(raw_ostream &OS, fp::DenormalMode Mode) {
+  Mode.print(OS);
+  return OS;
+}
+
+/// Parse the expected names from the denormal-fp-math attribute.
+inline fp::DenormalMode::DenormalModeKind
+parseDenormalFPAttributeComponent(StringRef Str) {
+  // Assume ieee on unspecified attribute.
+  return StringSwitch<fp::DenormalMode::DenormalModeKind>(Str)
+    .Cases("", "ieee", fp::DenormalMode::IEEE)
+    .Case("preserve-sign", fp::DenormalMode::PreserveSign)
+    .Case("positive-zero", fp::DenormalMode::PositiveZero)
+    .Default(fp::DenormalMode::Invalid);
+}
+
+/// Return the name used for the denormal handling mode used by the the
+/// expected names from the denormal-fp-math attribute.
+inline StringRef denormalModeKindName(fp::DenormalMode::DenormalModeKind Mode) {
+  switch (Mode) {
+  case fp::DenormalMode::IEEE:
+    return "ieee";
+  case fp::DenormalMode::PreserveSign:
+    return "preserve-sign";
+  case fp::DenormalMode::PositiveZero:
+    return "positive-zero";
+  default:
+    return "";
+  }
+}
+
+/// Returns the denormal mode to use for inputs and outputs.
+inline fp::DenormalMode parseDenormalFPAttribute(StringRef Str) {
+  StringRef OutputStr, InputStr;
+  std::tie(OutputStr, InputStr) = Str.split(',');
+
+  fp::DenormalMode Mode;
+  Mode.Output = parseDenormalFPAttributeComponent(OutputStr);
+
+  // Maintain compatability with old form of the attribute which only specified
+  // one component.
+  Mode.Input = InputStr.empty() ? Mode.Output  :
+               parseDenormalFPAttributeComponent(InputStr);
+
+  return Mode;
+}
+
+void fp::DenormalMode::print(raw_ostream &OS) const {
+  OS << denormalModeKindName(Output) << ',' << denormalModeKindName(Input);
+}
 }
 #endif

llvm/include/llvm/Target/TargetOptions.h

 //===-- llvm/Target/TargetOptions.h - Target Options ------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines command line option flags that are shared across various
 // targets.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_TARGETOPTIONS_H
 #define LLVM_TARGET_TARGETOPTIONS_H
 
-#include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/MC/MCTargetOptions.h"
 
 #include <memory>
 
 namespace llvm {
   struct fltSemantics;
   class MachineFunction;
   class MemoryBuffer;
TargetOptions()
           FunctionSections(false), DataSections(false),
           UniqueSectionNames(true), UniqueBBSectionNames(false),
           TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
           EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           SupportsDefaultOutlining(false), EmitAddrsig(false),
           EmitCallSiteInfo(false), SupportsDebugEntryValues(false),
           EnableDebugEntryValues(false), ForceDwarfFrameSection(false),
-          FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
+          FPDenormalMode(fp::DenormalMode::IEEE, fp::DenormalMode::IEEE) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
public:
     /// EABIVersion - This flag specifies the EABI version
     EABI EABIVersion = EABI::Default;
 
     /// Which debugger to tune for.
     DebuggerKind DebuggerTuning = DebuggerKind::Default;
 
   private:
     /// Flushing mode to assume in default FP environment.
-    DenormalMode FPDenormalMode;
+    fp::DenormalMode FPDenormalMode;
 
     /// Flushing mode to assume in default FP environment, for float/vector of
     /// float.
-    DenormalMode FP32DenormalMode;
+    fp::DenormalMode FP32DenormalMode;
 
   public:
-    void setFPDenormalMode(DenormalMode Mode) {
+    void setFPDenormalMode(fp::DenormalMode Mode) {
       FPDenormalMode = Mode;
     }
 
-    void setFP32DenormalMode(DenormalMode Mode) {
+    void setFP32DenormalMode(fp::DenormalMode Mode) {
       FP32DenormalMode = Mode;
     }
 
-    DenormalMode getRawFPDenormalMode() const {
+    fp::DenormalMode getRawFPDenormalMode() const {
       return FPDenormalMode;
     }
 
-    DenormalMode getRawFP32DenormalMode() const {
+    fp::DenormalMode getRawFP32DenormalMode() const {
       return FP32DenormalMode;
     }
 
-    DenormalMode getDenormalMode(const fltSemantics &FPType) const;
+    fp::DenormalMode getDenormalMode(const fltSemantics &FPType) const;
 
     /// What exception model to use
     ExceptionHandling ExceptionModel = ExceptionHandling::None;
 
     /// Machine level options.
     MCTargetOptions MCOptions;
   };
 
 } // End llvm namespace
 
 #endif

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(ExceptionHandling, ExceptionModel)
 CGOPT_EXP(CodeGenFileType, FileType)
 CGOPT(FramePointer::FP, FramePointerUsage)
 CGOPT(bool, EnableUnsafeFPMath)
 CGOPT(bool, EnableNoInfsFPMath)
 CGOPT(bool, EnableNoNaNsFPMath)
 CGOPT(bool, EnableNoSignedZerosFPMath)
 CGOPT(bool, EnableNoTrappingFPMath)
-CGOPT(DenormalMode::DenormalModeKind, DenormalFPMath)
-CGOPT(DenormalMode::DenormalModeKind, DenormalFP32Math)
+CGOPT(fp::DenormalMode::DenormalModeKind, DenormalFPMath)
+CGOPT(fp::DenormalMode::DenormalModeKind, DenormalFP32Math)
 CGOPT(bool, EnableHonorSignDependentRoundingFPMath)
 CGOPT(FloatABI::ABIType, FloatABIForCalls)
 CGOPT(FPOpFusion::FPOpFusionMode, FuseFPOps)
 CGOPT(bool, DontPlaceZerosInBSS)
 CGOPT(bool, EnableGuaranteedTailCallOpt)
 CGOPT(bool, DisableTailCalls)
 CGOPT(bool, StackSymbolOrdering)
 CGOPT(unsigned, OverrideStackAlignment)
#define CGBINDOPT(NAME)                                                        \
 
   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));
   CGBINDOPT(EnableNoTrappingFPMath);
 
-  static const auto DenormFlagEnumOptions =
-  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 = cl::values(
+      clEnumValN(fp::DenormalMode::IEEE, "ieee", "IEEE 754 denormal numbers"),
+      clEnumValN(fp::DenormalMode::PreserveSign, "preserve-sign",
+      clEnumValN(fp::DenormalMode::PositiveZero, "positive-zero",
 
   // FIXME: Doesn't have way to specify separate input and output modes.
-  static cl::opt<DenormalMode::DenormalModeKind> DenormalFPMath(
+  static cl::opt<fp::DenormalMode::DenormalModeKind> DenormalFPMath(
       "denormal-fp-math",
-    cl::desc("Select which denormal numbers the code is permitted to require"),
-    cl::init(DenormalMode::IEEE),
-    DenormFlagEnumOptions);
+      cl::desc(
+          "Select which denormal numbers the code is permitted to require"),
+      cl::init(fp::DenormalMode::IEEE), DenormFlagEnumOptions);
   CGBINDOPT(DenormalFPMath);
 
-  static cl::opt<DenormalMode::DenormalModeKind> DenormalFP32Math(
+  static cl::opt<fp::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);
+      cl::desc("Select which denormal numbers the code is permitted to require "
+               "for float"),
+      cl::init(fp::DenormalMode::Invalid), DenormFlagEnumOptions);
   CGBINDOPT(DenormalFP32Math);
 
   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);
 
TargetOptions codegen::InitTargetOptionsFromCodeGenFlags() {
   TargetOptions Options;
   Options.AllowFPOpFusion = getFuseFPOps();
   Options.UnsafeFPMath = getEnableUnsafeFPMath();
   Options.NoInfsFPMath = getEnableNoInfsFPMath();
   Options.NoNaNsFPMath = getEnableNoNaNsFPMath();
   Options.NoSignedZerosFPMath = getEnableNoSignedZerosFPMath();
   Options.NoTrappingFPMath = getEnableNoTrappingFPMath();
 
-  DenormalMode::DenormalModeKind DenormKind = getDenormalFPMath();
+  fp::DenormalMode::DenormalModeKind DenormKind = getDenormalFPMath();
 
   // FIXME: Should have separate input and output flags
-  Options.setFPDenormalMode(DenormalMode(DenormKind, DenormKind));
+  Options.setFPDenormalMode(fp::DenormalMode(DenormKind, DenormKind));
 
   Options.HonorSignDependentRoundingFPMathOption =
       getEnableHonorSignDependentRoundingFPMath();
   if (getFloatABIForCalls() != FloatABI::Default)
     Options.FloatABIType = getFloatABIForCalls();
   Options.NoZerosInBSS = getDontPlaceZerosInBSS();
   Options.GuaranteedTailCallOpt = getEnableGuaranteedTailCallOpt();
   Options.StackAlignmentOverride = getOverrideStackAlignment();
void codegen::setFunctionAttributes(StringRef CPU, StringRef Features,
 
   HANDLE_BOOL_ATTR(EnableUnsafeFPMathView, "unsafe-fp-math");
   HANDLE_BOOL_ATTR(EnableNoInfsFPMathView, "no-infs-fp-math");
   HANDLE_BOOL_ATTR(EnableNoNaNsFPMathView, "no-nans-fp-math");
   HANDLE_BOOL_ATTR(EnableNoSignedZerosFPMathView, "no-signed-zeros-fp-math");
 
   if (DenormalFPMathView->getNumOccurrences() > 0 &&
       !F.hasFnAttribute("denormal-fp-math")) {
-    DenormalMode::DenormalModeKind DenormKind = getDenormalFPMath();
+    fp::DenormalMode::DenormalModeKind DenormKind = getDenormalFPMath();
 
     // FIXME: Command line flag should expose separate input/output modes.
     NewAttrs.addAttribute("denormal-fp-math",
-                          DenormalMode(DenormKind, DenormKind).str());
+                          fp::DenormalMode(DenormKind, DenormKind).str());
   }
 
   if (DenormalFP32MathView->getNumOccurrences() > 0 &&
       !F.hasFnAttribute("denormal-fp-math-f32")) {
     // FIXME: Command line flag should expose separate input/output modes.
-    DenormalMode::DenormalModeKind DenormKind = getDenormalFP32Math();
+    fp::DenormalMode::DenormalModeKind DenormKind = getDenormalFP32Math();
 
-    NewAttrs.addAttribute(
-      "denormal-fp-math-f32",
-      DenormalMode(DenormKind, DenormKind).str());
+    NewAttrs.addAttribute("denormal-fp-math-f32",
+                          fp::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 ||

llvm/lib/CodeGen/MachineFunction.cpp

 getOrCreateJumpTableInfo(unsigned EntryKind) {
   if (JumpTableInfo) return JumpTableInfo;
 
   JumpTableInfo = new (Allocator)
     MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind);
   return JumpTableInfo;
 }
 
-DenormalMode MachineFunction::getDenormalMode(const fltSemantics &FPType) const {
+fp::DenormalMode
+MachineFunction::getDenormalMode(const fltSemantics &FPType) const {
   if (&FPType == &APFloat::IEEEsingle()) {
     Attribute Attr = F.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.

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

if (Iterations) {
             : buildSqrtNRTwoConst(Op, Est, Iterations, Flags, Reciprocal);
 
       if (!Reciprocal) {
         // The estimate is now completely wrong if the input was exactly 0.0 or
         // possibly a denormal. Force the answer to 0.0 for those cases.
         SDLoc DL(Op);
         EVT CCVT = getSetCCResultType(VT);
         ISD::NodeType SelOpcode = VT.isVector() ? ISD::VSELECT : ISD::SELECT;
-        DenormalMode DenormMode = DAG.getDenormalMode(VT);
-        if (DenormMode.Input == DenormalMode::IEEE) {
+        fp::DenormalMode DenormMode = DAG.getDenormalMode(VT);
+        if (DenormMode.Input == fp::DenormalMode::IEEE) {
           // This is specifically a check for the handling of denormal inputs,
           // not the result.
 
           // fabs(X) < SmallestNormal ? 0.0 : Est
           const fltSemantics &FltSem = DAG.EVTToAPFloatSemantics(VT);
           APFloat SmallestNorm = APFloat::getSmallestNormalized(FltSem);
           SDValue NormC = DAG.getConstantFP(SmallestNorm, DL, VT);
           SDValue FPZero = DAG.getConstantFP(0.0, DL, VT);

llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

 /// This pass does misc. AMDGPU optimizations on IR before instruction
 /// selection.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
 #include "AMDGPUSubtarget.h"
 #include "AMDGPUTargetMachine.h"
-#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"

llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp

SIModeRegisterDefaults::SIModeRegisterDefaults(const Function &F) {
 
   StringRef DX10ClampAttr
     = F.getFnAttribute("amdgpu-dx10-clamp").getValueAsString();
   if (!DX10ClampAttr.empty())
     DX10Clamp = DX10ClampAttr == "true";
 
   StringRef DenormF32Attr = F.getFnAttribute("denormal-fp-math-f32").getValueAsString();
   if (!DenormF32Attr.empty()) {
-    DenormalMode DenormMode = parseDenormalFPAttribute(DenormF32Attr);
-    FP32InputDenormals = DenormMode.Input == DenormalMode::IEEE;
-    FP32OutputDenormals = DenormMode.Output == DenormalMode::IEEE;
+    fp::DenormalMode DenormMode = parseDenormalFPAttribute(DenormF32Attr);
+    FP32InputDenormals = DenormMode.Input == fp::DenormalMode::IEEE;
+    FP32OutputDenormals = DenormMode.Output == fp::DenormalMode::IEEE;
   }
 
   StringRef DenormAttr = F.getFnAttribute("denormal-fp-math").getValueAsString();
   if (!DenormAttr.empty()) {
-    DenormalMode DenormMode = parseDenormalFPAttribute(DenormAttr);
+    fp::DenormalMode DenormMode = parseDenormalFPAttribute(DenormAttr);
 
     if (DenormF32Attr.empty()) {
-      FP32InputDenormals = DenormMode.Input == DenormalMode::IEEE;
-      FP32OutputDenormals = DenormMode.Output == DenormalMode::IEEE;
+      FP32InputDenormals = DenormMode.Input == fp::DenormalMode::IEEE;
+      FP32OutputDenormals = DenormMode.Output == fp::DenormalMode::IEEE;
     }
 
-    FP64FP16InputDenormals = DenormMode.Input == DenormalMode::IEEE;
-    FP64FP16OutputDenormals = DenormMode.Output == DenormalMode::IEEE;
+    FP64FP16InputDenormals = DenormMode.Input == fp::DenormalMode::IEEE;
+    FP64FP16OutputDenormals = DenormMode.Output == fp::DenormalMode::IEEE;
   }
 }
 
 namespace {
 
 struct SourceOfDivergence {
   unsigned Intr;
 };

llvm/lib/Target/ARM/ARMAsmPrinter.cpp

 static bool checkFunctionsAttributeConsistency(const Module &M, StringRef Attr,
                                                StringRef Value) {
    return !any_of(M, [&](const Function &F) {
        return F.getFnAttribute(Attr).getValueAsString() != Value;
    });
 }
 // Returns true if all functions have the same denormal mode.
 // It also returns true when the module has no functions.
-static bool checkDenormalAttributeConsistency(const Module &M,
-                                              StringRef Attr,
-                                              DenormalMode Value) {
+static bool checkDenormalAttributeConsistency(const Module &M, StringRef Attr,
+                                              fp::DenormalMode Value) {
   return !any_of(M, [&](const Function &F) {
     StringRef AttrVal = F.getFnAttribute(Attr).getValueAsString();
     return parseDenormalFPAttribute(AttrVal) != Value;
   });
 }
 
 void ARMAsmPrinter::emitAttributes() {
   MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
ATS.emitAttribute(ARMBuildAttrs::ABI_PCS_GOT_use,
                       ARMBuildAttrs::AddressGOT);
   } else {
     ATS.emitAttribute(ARMBuildAttrs::ABI_PCS_GOT_use,
                       ARMBuildAttrs::AddressDirect);
   }
 
   // Set FP Denormals.
   if (checkDenormalAttributeConsistency(*MMI->getModule(), "denormal-fp-math",
-                                        DenormalMode::getPreserveSign()))
+                                        fp::DenormalMode::getPreserveSign()))
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::PreserveFPSign);
-  else if (checkDenormalAttributeConsistency(*MMI->getModule(),
-                                             "denormal-fp-math",
-                                             DenormalMode::getPositiveZero()))
+  else if (checkDenormalAttributeConsistency(
+               *MMI->getModule(), "denormal-fp-math",
+               fp::DenormalMode::getPositiveZero()))
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::PositiveZero);
   else if (!TM.Options.UnsafeFPMath)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::IEEEDenormals);
   else {
     if (!STI.hasVFP2Base()) {
       // When the target doesn't have an FPU (by design or

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

bool NVPTXTargetLowering::usePrecSqrtF32() const {
   } else {
     // Otherwise, use sqrt.approx if fast math is enabled
     return !getTargetMachine().Options.UnsafeFPMath;
   }
 }
 
 bool NVPTXTargetLowering::useF32FTZ(const MachineFunction &MF) const {
   return MF.getDenormalMode(APFloat::IEEEsingle()).Output ==
-         DenormalMode::PreserveSign;
+         fp::DenormalMode::PreserveSign;
 }
 
 static bool IsPTXVectorType(MVT VT) {
   switch (VT.SimpleTy) {
   default:
     return false;
   case MVT::v2i1:
   case MVT::v4i1:

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "InstCombineInternal.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IntrinsicsX86.h"
static Instruction *SimplifyNVVMIntrinsic(IntrinsicInst *II, InstCombiner &IC) {
   // If Action.FtzRequirementTy is not satisfied by the module's ftz state, we
   // can bail out now.  (Notice that in the case that IID is not an NVVM
   // intrinsic, we don't have to look up any module metadata, as
   // FtzRequirementTy will be FTZ_Any.)
   if (Action.FtzRequirement != FTZ_Any) {
     StringRef Attr = II->getFunction()
                          ->getFnAttribute("denormal-fp-math-f32")
                          .getValueAsString();
-    DenormalMode Mode = parseDenormalFPAttribute(Attr);
-    bool FtzEnabled = Mode.Output != DenormalMode::IEEE;
+    fp::DenormalMode Mode = parseDenormalFPAttribute(Attr);
+    bool FtzEnabled = Mode.Output != fp::DenormalMode::IEEE;
 
     if (FtzEnabled != (Action.FtzRequirement == FTZ_MustBeOn))
       return nullptr;
   }
 
   // Simplify to target-generic intrinsic.
   if (Action.IID) {
     SmallVector<Value *, 4> Args(II->arg_operands());

llvm/unittests/ADT/CMakeLists.txt

add_llvm_unittest(ADTTests
   DeltaAlgorithmTest.cpp
   DenseMapTest.cpp
   DenseSetTest.cpp
   DepthFirstIteratorTest.cpp
   DirectedGraphTest.cpp
   EnumeratedArrayTest.cpp
   EquivalenceClassesTest.cpp
   FallibleIteratorTest.cpp
-  FloatingPointMode.cpp
   FoldingSet.cpp
   FunctionExtrasTest.cpp
   FunctionRefTest.cpp
   HashingTest.cpp
   IListBaseTest.cpp
   IListIteratorTest.cpp
   IListNodeBaseTest.cpp
   IListNodeTest.cpp

llvm/unittests/IR/CMakeLists.txt

add_llvm_unittest(IRTests
   CFGBuilder.cpp
   ConstantRangeTest.cpp
   ConstantsTest.cpp
   DataLayoutTest.cpp
   DebugInfoTest.cpp
   DebugTypeODRUniquingTest.cpp
   DominatorTreeTest.cpp
   DominatorTreeBatchUpdatesTest.cpp
+  FPEnv.cpp
   FunctionTest.cpp
   PassBuilderCallbacksTest.cpp
   IRBuilderTest.cpp
   InstructionsTest.cpp
   IntrinsicsTest.cpp
   KnowledgeRetentionTest.cpp
   LegacyPassManagerTest.cpp
   MDBuilderTest.cpp

llvm/unittests/IR/FPEnv.cpp

-//===- llvm/unittest/ADT/FloatingPointMode.cpp ----------------------------===//
+//===- llvm/unittest/IR/FPEnv.cpp ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/IR/FPEnv.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
+using namespace fp;
 
-TEST(FloatingPointModeTest, ParseDenormalFPAttributeComponent) {
+TEST(FPEnvTest, ParseDenormalFPAttributeComponent) {
   EXPECT_EQ(DenormalMode::IEEE, parseDenormalFPAttributeComponent("ieee"));
   EXPECT_EQ(DenormalMode::IEEE, parseDenormalFPAttributeComponent(""));
   EXPECT_EQ(DenormalMode::PreserveSign,
             parseDenormalFPAttributeComponent("preserve-sign"));
   EXPECT_EQ(DenormalMode::PositiveZero,
             parseDenormalFPAttributeComponent("positive-zero"));
   EXPECT_EQ(DenormalMode::Invalid, parseDenormalFPAttributeComponent("foo"));
 }
 
-TEST(FloatingPointModeTest, DenormalAttributeName) {
+TEST(FPEnvTest, DenormalAttributeName) {
   EXPECT_EQ("ieee", denormalModeKindName(DenormalMode::IEEE));
   EXPECT_EQ("preserve-sign", denormalModeKindName(DenormalMode::PreserveSign));
   EXPECT_EQ("positive-zero", denormalModeKindName(DenormalMode::PositiveZero));
   EXPECT_EQ("", denormalModeKindName(DenormalMode::Invalid));
 }
 
-TEST(FloatingPointModeTest, ParseDenormalFPAttribute) {
+TEST(FPEnvTest, ParseDenormalFPAttribute) {
   EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
             parseDenormalFPAttribute("ieee"));
   EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
             parseDenormalFPAttribute("ieee,ieee"));
   EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
             parseDenormalFPAttribute("ieee,"));
   EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
             parseDenormalFPAttribute(""));
TEST(FPEnvTest, ParseDenormalFPAttribute) {
   EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
             parseDenormalFPAttribute("foo"));
   EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
             parseDenormalFPAttribute("foo,foo"));
   EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
             parseDenormalFPAttribute("foo,bar"));
 }
 
-TEST(FloatingPointModeTest, RenderDenormalFPAttribute) {
+TEST(FPEnvTest, RenderDenormalFPAttribute) {
   EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
             parseDenormalFPAttribute("foo"));
 
   EXPECT_EQ("ieee,ieee",
             DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE).str());
   EXPECT_EQ(",",
             DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid).str());
 
EXPECT_EQ(
     "preserve-sign,ieee",
     DenormalMode(DenormalMode::PreserveSign, DenormalMode::IEEE).str());
 
   EXPECT_EQ(
     "preserve-sign,positive-zero",
     DenormalMode(DenormalMode::PreserveSign, DenormalMode::PositiveZero).str());
 }
 
-TEST(FloatingPointModeTest, DenormalModeIsSimple) {
+TEST(FPEnvTest, DenormalModeIsSimple) {
   EXPECT_TRUE(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE).isSimple());
   EXPECT_FALSE(DenormalMode(DenormalMode::IEEE,
                             DenormalMode::Invalid).isSimple());
   EXPECT_FALSE(DenormalMode(DenormalMode::PreserveSign,
                             DenormalMode::PositiveZero).isSimple());
 }
 
-TEST(FloatingPointModeTest, DenormalModeIsValid) {
+TEST(FPEnvTest, DenormalModeIsValid) {
   EXPECT_TRUE(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE).isValid());
   EXPECT_FALSE(DenormalMode(DenormalMode::IEEE, DenormalMode::Invalid).isValid());
   EXPECT_FALSE(DenormalMode(DenormalMode::Invalid, DenormalMode::IEEE).isValid());
   EXPECT_FALSE(DenormalMode(DenormalMode::Invalid,
                             DenormalMode::Invalid).isValid());
 }
 
-TEST(FloatingPointModeTest, DenormalModeConstructor) {
+TEST(FPEnvTest, DenormalModeConstructor) {
   EXPECT_EQ(DenormalMode(DenormalMode::Invalid, DenormalMode::Invalid),
             DenormalMode::getInvalid());
   EXPECT_EQ(DenormalMode(DenormalMode::IEEE, DenormalMode::IEEE),
             DenormalMode::getIEEE());
   EXPECT_EQ(DenormalMode(DenormalMode::PreserveSign, DenormalMode::PreserveSign),
             DenormalMode::getPreserveSign());
   EXPECT_EQ(DenormalMode(DenormalMode::PositiveZero, DenormalMode::PositiveZero),
             DenormalMode::getPositiveZero());
 }
 
 }

llvm/utils/gn/secondary/llvm/unittests/ADT/BUILD.gn

sources = [
     "DeltaAlgorithmTest.cpp",
     "DenseMapTest.cpp",
     "DenseSetTest.cpp",
     "DepthFirstIteratorTest.cpp",
     "DirectedGraphTest.cpp",
     "EnumeratedArrayTest.cpp",
     "EquivalenceClassesTest.cpp",
     "FallibleIteratorTest.cpp",
-    "FloatingPointMode.cpp",
     "FoldingSet.cpp",
     "FunctionExtrasTest.cpp",
     "FunctionRefTest.cpp",
     "HashingTest.cpp",
     "IListBaseTest.cpp",
     "IListIteratorTest.cpp",
     "IListNodeBaseTest.cpp",
     "IListNodeTest.cpp",

llvm/utils/gn/secondary/llvm/unittests/IR/BUILD.gn

sources = [
     "CFGBuilder.cpp",
     "ConstantRangeTest.cpp",
     "ConstantsTest.cpp",
     "DataLayoutTest.cpp",
     "DebugInfoTest.cpp",
     "DebugTypeODRUniquingTest.cpp",
     "DominatorTreeBatchUpdatesTest.cpp",
     "DominatorTreeTest.cpp",
+    "FPEnv.cpp",
     "FunctionTest.cpp",
     "IRBuilderTest.cpp",
     "InstructionsTest.cpp",
     "IntrinsicsTest.cpp",
     "KnowledgeRetentionTest.cpp",
     "LegacyPassManagerTest.cpp",
     "MDBuilderTest.cpp",
     "ManglerTest.cpp",