[FPEnv Core 01/14] Add flags and command-line switches for FPEnv

[sdmitrouk]

Summary

This patch open first set of patches aimed to add better support of floating-point environment to LLVM. Its previous version is present on llvm-commits, uploading the new one here as amount of changes reached about 4K lines (mostly additions) as reported by git. The 14th patch is the biggest one, but it's quite consistent and there is already too many patches in this set.

---

• Two flags for TargetOptions.
• Three command-line switches to enable flags separately or at the same time.

[scanon]

include/llvm/CodeGen/CommandFlags.h

134

Maybe "fenv-access" instead of "fpenv-access" to mirror the pragma spelling? I think the description could be improved somewhat. Perhaps "Disable optimizations that assume the default floating-point environment or might change observable floating-point exceptions."

145

I believe that you really want to say "disable optimizations that assume default floating-point rounding", rather than "optimizations that affect FP rounding" (the latter sounds like it licenses re-association, which I don't think you want).

More generally, this should probably include other non-default settings in the floating-point environment (DAZ, FTZ, default nan bits, etc). From a machine model perspective, the two settings are to "FP exceptions may be observed" and "FP control may be non-default". How about something like:

"enable-control-access-fp-math"
"Disable optimizations that assume the default floating-point environment, including rounding-mode"

[sdmitrouk]

Updated text of comments.

[mehdi_amini]

include/llvm/CodeGen/CommandFlags.h

137

clang-format

[mehdi_amini]

LGTM, Steve?

[scanon]

LGTM.

[Eugene.Zelenko]

Looks like patch was not committed. Same may be true for subsequent patches.

[mehdi_amini]

Yes this approach is unfortunately abandoned. We should close all this rev.

include/llvm/CodeGen/CommandFlags.h

EnableNoNaNsFPMath("enable-no-nans-fp-math",
                    cl::init(false));
 
 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));
 
+cl::opt<bool>
+EnableFEnvAccessFPMath("enable-fenv-access-fp-math",
+  cl::desc("Disable optimizations that assume the default floating-point "
+           "environment or might change observable floating-point exceptions"),
+  cl::init(false));
+
+cl::opt<bool>
+EnableExceptAccessFPMath("enable-except-access-fp-math",
+            cl::desc("Disable FP math optimizations that affect FP exceptions"),
+            cl::init(false));
+
+cl::opt<bool>
+EnableControlAccessFPMath("enable-control-access-fp-math",
+  cl::desc("Disable optimizations that assume the default floating-point "
+           "environment, including rounding-mode"),
+  cl::init(false));
+
 cl::opt<llvm::FloatABI::ABIType>
 FloatABIForCalls("float-abi",
                  cl::desc("Choose float ABI type"),
                  cl::init(FloatABI::Default),
                  cl::values(
                      clEnumValN(FloatABI::Default, "default",
                                 "Target default float ABI type"),
                      clEnumValN(FloatABI::Soft, "soft",
static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.LessPreciseFPMADOption = EnableFPMAD;
   Options.AllowFPOpFusion = FuseFPOps;
   Options.Reciprocals = TargetRecip(ReciprocalOps);
   Options.UnsafeFPMath = EnableUnsafeFPMath;
   Options.NoInfsFPMath = EnableNoInfsFPMath;
   Options.NoNaNsFPMath = EnableNoNaNsFPMath;
   Options.HonorSignDependentRoundingFPMathOption =
       EnableHonorSignDependentRoundingFPMath;
+  Options.AllowFPExceptAccess = EnableExceptAccessFPMath |
+      EnableFEnvAccessFPMath;
+  Options.AllowFPRoundAccess = EnableControlAccessFPMath |
+      EnableFEnvAccessFPMath;
   if (FloatABIForCalls != FloatABI::Default)
     Options.FloatABIType = FloatABIForCalls;
   Options.NoZerosInBSS = DontPlaceZerosInBSS;
   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
   Options.StackAlignmentOverride = OverrideStackAlignment;
   Options.PositionIndependentExecutable = EnablePIE;
   Options.UseInitArray = !UseCtors;
   Options.DataSections = DataSections;

include/llvm/Target/TargetOptions.h

enum class EABI {
     GNU
   };
 
   class TargetOptions {
   public:
     TargetOptions()
         : PrintMachineCode(false), LessPreciseFPMADOption(false),
           UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
+          AllowFPExceptAccess(false), AllowFPRoundAccess(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackAlignmentOverride(0),
           EnableFastISel(false), PositionIndependentExecutable(false),
           UseInitArray(false), DisableIntegratedAS(false),
           CompressDebugSections(false), FunctionSections(false),
           DataSections(false), UniqueSectionNames(true), TrapUnreachable(false),
           EmulatedTLS(false), FloatABIType(FloatABI::Default),
           AllowFPOpFusion(FPOpFusion::Standard), Reciprocals(TargetRecip()),
public:
     unsigned NoInfsFPMath : 1;
 
     /// NoNaNsFPMath - This flag is enabled when the
     /// -enable-no-nans-fp-math flag is specified on the command line. When
     /// this flag is off (the default), the code generator is not allowed to
     /// assume the FP arithmetic arguments and results are never NaNs.
     unsigned NoNaNsFPMath : 1;
 
+    /// AllowFPExceptAccess - This flag is enabled when the
+    /// -enable-except-access-fp-math or -enable-fenv-access-fp-math flag is
+    /// specified on the command line.  When this flag is off (the default), the
+    /// code generator is allowed to assume the exceptions part of
+    /// floating-point environment is not accessed by the program.
+    unsigned AllowFPExceptAccess : 1;
+
+    /// AllowFPRoundAccess - This flag is enabled when the
+    /// -enable-control-access-fp-math or -enable-fenv-access-fp-math flag is
+    /// specified on the command line. When this flag is off (the default), the
+    /// code generator is allowed to assume the rounding part of floating-point
+    /// environment is not accessed by the program.
+    unsigned AllowFPRoundAccess : 1;
+
     /// HonorSignDependentRoundingFPMath - This returns true when the
     /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns
     /// false (the default), the code generator is allowed to assume that the
     /// rounding behavior is the default (round-to-zero for all floating point
     /// to integer conversions, and round-to-nearest for all other arithmetic
     /// truncations).  If this is enabled (set to true), the code generator must
     /// assume that the rounding mode may dynamically change.
     unsigned HonorSignDependentRoundingFPMathOption : 1;