clang: Guess at some platform FTZ/DAZ default settings

[arsenm]

Summary

This is to avoid performance regressions when the default attribute
behavior is fixed to assume ieee.

I tested the default on x86_64 ubuntu, which seems to default to
FTZ/DAZ, but am guessing for x86 and PS4.

[craig.topper]

I checked Redhat 7.4 that's on the server I'm using for work. And I had a coworker check his Ubuntu 18.04 system with this program. And both systems printed 1f80 as the value of MXCSR which shows FTZ and DAZ are both 0. Are you seeing something different?

#include <x86intrin.h>
#include <stdio.h>

int main() {
  int csr = _mm_getcsr();
  printf("%x\n", csr);
  return 0;
}

[spatel]

In D69979#1738099, @craig.topper wrote:

I checked Redhat 7.4 that's on the server I'm using for work. And I had a coworker check his Ubuntu 18.04 system with this program. And both systems printed 1f80 as the value of MXCSR which shows FTZ and DAZ are both 0. Are you seeing something different?

AFAIK, x86(-64) Linux is IEEE-compliant by default. It's only when compiling with -ffast-math that clang/gcc link in the startup routine to set FTZ/DAZ. So this patch should use that same mechanism to set the denorm mode. See:
https://reviews.llvm.org/rL165240

@RKSimon - is it the same on PS4?

[spatel]

Also, I may have missed some discussions. Does this patch series replace the proposal to add instruction-level FMF for denorms?
http://lists.llvm.org/pipermail/llvm-dev/2019-September/135183.html

Ie, did we decide that a function-level attribute is good enough?

[arsenm]

In D69979#1738723, @spatel wrote:

Also, I may have missed some discussions. Does this patch series replace the proposal to add instruction-level FMF for denorms?
http://lists.llvm.org/pipermail/llvm-dev/2019-September/135183.html

Ie, did we decide that a function-level attribute is good enough?

I think this is an orthogonal question. I would still find a ftz flag useful even in the presence of this attribute indicating flushing. For AMDGPU it would be useful with a specific instruction context to allow flushing even when the default mode is set to not flush. For example llvm.fmuladd could be emitted with an ftz flag which would select to an instruction that would ordinarily be illegal if denormals are enabled

[arsenm]

In D69979#1738099, @craig.topper wrote:

I checked Redhat 7.4 that's on the server I'm using for work. And I had a coworker check his Ubuntu 18.04 system with this program. And both systems printed 1f80 as the value of MXCSR which shows FTZ and DAZ are both 0. Are you seeing something different?

#include <x86intrin.h>
#include <stdio.h>

int main() {
  int csr = _mm_getcsr();
  printf("%x\n", csr);
  return 0;
}

I see the value as 1f80. However the test program I wrote suggests the default is to flush (and what the comments in bug 34994 suggest?):

In default FP mode
neg_subnormal + neg_subnormal: -0x0p+0
neg_subnormal + neg_zero: -0x0p+0
sqrtf subnormal: 0x0p+0
sqrtf neg_subnormal: -0x0p+0
sqrtf neg_zero: -0x0p+0

With denormals disabled
neg_subnormal + neg_subnormal: -0x0p+0
neg_subnormal + neg_zero: -0x0p+0
sqrtf subnormal: 0x0p+0
sqrtf neg_subnormal: -0x0p+0
sqrtf neg_zero: -0x0p+0

With denormals enabled
neg_subnormal + neg_subnormal: -0x1p-126
neg_subnormal + neg_zero: -0x1p-127
sqrtf subnormal: 0x1.6a09e6p-64
sqrtf neg_subnormal: -nan
sqrtf neg_zero: -0x0p+0

With daz only
neg_subnormal + neg_subnormal: -0x0p+0
neg_subnormal + neg_zero: -0x0p+0
sqrtf subnormal: 0x0p+0
sqrtf neg_subnormal: -0x0p+0
sqrtf neg_zero: -0x0p+0

With ftz only
neg_subnormal + neg_subnormal: -0x1p-126
neg_subnormal + neg_zero: -0x0p+0
sqrtf subnormal: 0x1.6a09e6p-64
sqrtf neg_subnormal: -nan
sqrtf neg_zero: -0x0p+0

[spatel]

In D69979#1740294, @arsenm wrote:

In D69979#1738099, @craig.topper wrote:

I checked Redhat 7.4 that's on the server I'm using for work. And I had a coworker check his Ubuntu 18.04 system with this program. And both systems printed 1f80 as the value of MXCSR which shows FTZ and DAZ are both 0. Are you seeing something different?

#include <x86intrin.h>
#include <stdio.h>

int main() {
  int csr = _mm_getcsr();
  printf("%x\n", csr);
  return 0;
}

I see the value as 1f80. However the test program I wrote suggests the default is to flush (and what the comments in bug 34994 suggest?):

Is the test program attached somewhere?
Bug 34994 (https://bugs.llvm.org/show_bug.cgi?id=34994) was limited to changing cases where we are running in some kind of loose-FP environment (otherwise, we would not be generating a sqrt estimate sequence at all). In the default (IEEE-compliant) environment, x86 would use a full-precision sqrt instruction or make a call to libm sqrt.

[arsenm]

In D69979#1746043, @spatel wrote:

In D69979#1740294, @arsenm wrote:

In D69979#1738099, @craig.topper wrote:

I checked Redhat 7.4 that's on the server I'm using for work. And I had a coworker check his Ubuntu 18.04 system with this program. And both systems printed 1f80 as the value of MXCSR which shows FTZ and DAZ are both 0. Are you seeing something different?

#include <x86intrin.h>
#include <stdio.h>

int main() {
  int csr = _mm_getcsr();
  printf("%x\n", csr);
  return 0;
}

I see the value as 1f80. However the test program I wrote suggests the default is to flush (and what the comments in bug 34994 suggest?):

Is the test program attached somewhere?
Bug 34994 (https://bugs.llvm.org/show_bug.cgi?id=34994) was limited to changing cases where we are running in some kind of loose-FP environment (otherwise, we would not be generating a sqrt estimate sequence at all). In the default (IEEE-compliant) environment, x86 would use a full-precision sqrt instruction or make a call to libm sqrt.

I just posted the test I wrote here: https://github.com/arsenm/subnormal_test

[spatel]

In D69979#1749198, @arsenm wrote:

I just posted the test I wrote here: https://github.com/arsenm/subnormal_test

Thanks. I tried compiling with gcc (can't trust clang since it doesn't honor #pragma STDC FENV_ACCESS ON?).
And running that on a Ubuntu 17.10 x86-64 system, it's behaving as I would expect. If you compile without -ffast-math, it asserts:

With denormals disabled
a.out: subnormal_test.cpp:33: void fp32_denorm_test(): Assertion `std::fpclassify(subnormal) == FP_SUBNORMAL' failed.

And if you compile with -ffast-math, it asserts:

In default FP mode
a.out: subnormal_test.cpp:33: void fp32_denorm_test(): Assertion `std::fpclassify(subnormal) == FP_SUBNORMAL' failed.

This is what I see compiling Craig's csr tester:

$ cc -O2 csr.c && ./a.out
1f80
$ cc -O2 csr.c -ffast-math && ./a.out
9fc0

FZ is bit 15 (0x8000) and DAZ is bit 6 (0x0040), so they are clear in default (IEEE) mode and set with -ffast-math.

[arsenm]

DAZ/FTZ seem to be set in crtfastmath.o, so try to reproduce the logic for linking that

[spatel]

clang/include/clang/Driver/ToolChain.h

580

Formatting nit - prefer to start with verb and lower-case: isFastMathRuntimeAvailable() or hasFastMathRuntime().

587–588

Add -> add

clang/lib/Driver/ToolChains/PS4CPU.h

95–96

@probinson / @andreadb - is this correct for PS4? or is there some equivalent to the Linux startup file?

[arsenm]

Rename functions

[arsenm]

ping

[spatel]

clang/test/Driver/default-denormal-fp-math.c

8

The prefix should be PRESERVE_SIGN to match the flag?

[arsenm]

Rebase and fix check prefix name

[spatel]

LGTM - the PS4 behavior was confirmed off-list.

[arsenm]

fa7cd549d604bfd8f9dce5d649a19720cbc39cca

clang/include/clang/Driver/ToolChain.h

public:
   void AddFilePathLibArgs(const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs) const;
 
   /// AddCCKextLibArgs - Add the system specific linker arguments to use
   /// for kernel extensions (Darwin-specific).
   virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
                                 llvm::opt::ArgStringList &CmdArgs) const;
 
+  /// If a runtime library exists that sets global flags for unsafe floating
+  /// point math, return true.
+  ///
+  /// This checks for presence of the -Ofast, -ffast-math or -funsafe-math flags.
+  virtual bool isFastMathRuntimeAvailable(
+    const llvm::opt::ArgList &Args, std::string &Path) const;
+
   /// AddFastMathRuntimeIfAvailable - If a runtime library exists that sets
   /// global flags for unsafe floating point math, add it and return true.
   ///
   /// This checks for presence of the -Ofast, -ffast-math or -funsafe-math flags.
-  virtual bool AddFastMathRuntimeIfAvailable(
-      const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const;
+  bool addFastMathRuntimeIfAvailable(
 
   /// addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass
   /// a suitable profile runtime library to the linker.
   virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
                                 llvm::opt::ArgStringList &CmdArgs) const;
 
   /// Add arguments to use system-specific CUDA includes.
   virtual void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,

clang/lib/Driver/ToolChain.cpp

if(LibPath.length() > 0)
       CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
 }
 
 void ToolChain::AddCCKextLibArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-lcc_kext");
 }
 
-bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args,
-                                              ArgStringList &CmdArgs) const {
+bool ToolChain::isFastMathRuntimeAvailable(const ArgList &Args,
+                                           std::string &Path) const {
   // Do not check for -fno-fast-math or -fno-unsafe-math when -Ofast passed
   // (to keep the linker options consistent with gcc and clang itself).
   if (!isOptimizationLevelFast(Args)) {
     // Check if -ffast-math or -funsafe-math.
     Arg *A =
-        Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math,
-                        options::OPT_funsafe_math_optimizations,
-                        options::OPT_fno_unsafe_math_optimizations);
 
     if (!A || A->getOption().getID() == options::OPT_fno_fast_math ||
         A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations)
       return false;
   }
   // If crtfastmath.o exists add it to the arguments.
-  std::string Path = GetFilePath("crtfastmath.o");
-  if (Path == "crtfastmath.o") // Not found.
-    return false;
+  Path = GetFilePath("crtfastmath.o");
+  return (Path != "crtfastmath.o"); // Not found.
+}
 
+bool ToolChain::addFastMathRuntimeIfAvailable(const ArgList &Args,
+                                              ArgStringList &CmdArgs) const {
+  std::string Path;
+  if (isFastMathRuntimeAvailable(Args, Path)) {
     CmdArgs.push_back(Args.MakeArgString(Path));
     return true;
   }
 
+  return false;
+}
+
 SanitizerMask ToolChain::getSupportedSanitizers() const {
   // Return sanitizers which don't require runtime support and are not
   // platform dependent.
 
   SanitizerMask Res = (SanitizerKind::Undefined & ~SanitizerKind::Vptr &
                        ~SanitizerKind::Function) |
                       (SanitizerKind::CFI & ~SanitizerKind::CFIICall) |
                       SanitizerKind::CFICastStrict |

clang/lib/Driver/ToolChains/Gnu.cpp

else if (HasCRTBeginEndFiles) {
         else
           crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
         P = ToolChain.GetFilePath(crtbegin);
       }
       CmdArgs.push_back(Args.MakeArgString(P));
     }
 
     // Add crtfastmath.o if available and fast math is enabled.
-    ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
+    ToolChain.addFastMathRuntimeIfAvailable(Args, CmdArgs);
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_u);
 
   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
 
   if (D.isUsingLTO()) {

clang/lib/Driver/ToolChains/Linux.h

public:
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
   virtual std::string computeSysRoot() const;
 
   virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const;
 
   std::vector<std::string> ExtraOpts;
 
+  llvm::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;
 
   std::string getMultiarchTriple(const Driver &D,
                                  const llvm::Triple &TargetTriple,
                                  StringRef SysRoot) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_LINUX_H

clang/lib/Driver/ToolChains/Linux.cpp

void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
   // Add linker option -u__llvm_runtime_variable to cause runtime
   // 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(
+  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();
+  }
+  default:
+    return llvm::DenormalMode::getIEEE();
+  }
+}

clang/lib/Driver/ToolChains/MinGW.cpp

if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       if (Args.hasArg(options::OPT_static))
         CmdArgs.push_back("--end-group");
       else
         AddLibGCC(Args, CmdArgs);
     }
 
     if (!Args.hasArg(options::OPT_nostartfiles)) {
       // Add crtfastmath.o if available and fast math is enabled.
-      TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
+      TC.addFastMathRuntimeIfAvailable(Args, CmdArgs);
 
       CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
     }
   }
   const char *Exec = Args.MakeArgString(TC.GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 

clang/lib/Driver/ToolChains/PS4CPU.h

public:
   }
 
   SanitizerMask getSupportedSanitizers() const override;
 
   // PS4 toolchain uses legacy thin LTO API, which is not
   // capable of unit splitting.
   bool canSplitThinLTOUnit() const override { return false; }
 
+  llvm::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();
+  }
+
 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

clang/test/Driver/default-denormal-fp-math.c

+// RUN: %clang -### -target arm-unknown-linux-gnu -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-IEEE %s
+// RUN: %clang -### -target i386-unknown-linux-gnu -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-IEEE %s
+
+// RUN: %clang -### -target x86_64-unknown-linux-gnu --sysroot=%S/Inputs/basic_linux_tree -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-IEEE %s
+
+// crtfastmath enables ftz and daz
+// RUN: %clang -### -target x86_64-unknown-linux-gnu -ffast-math --sysroot=%S/Inputs/basic_linux_tree -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-PRESERVESIGN %s
+
+// crt not linked in with nostartfiles
+// RUN: %clang -### -target x86_64-unknown-linux-gnu -ffast-math -nostartfiles --sysroot=%S/Inputs/basic_linux_tree -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-IEEE %s
+
+// If there's no crtfastmath, don't assume ftz/daz
+// RUN: %clang -### -target x86_64-unknown-linux-gnu -ffast-math --sysroot=/dev/null -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-IEEE %s
+
+// RUN: %clang -### -target x86_64-scei-ps4 -c %s -v 2>&1 | FileCheck -check-prefix=CHECK-PRESERVESIGN %s
+
+
+// CHECK-IEEE: -fdenormal-fp-math=ieee,ieee
+// CHECK-PRESERVESIGN: -fdenormal-fp-math=preserve-sign,preserve-sign