[flang] add -f[no-]trapping-math

[tblah]

Summary

Only add the option processing and store the result. No attributes are added to FIR yet.

Clang handles this option using -ffp-exception-behavior (and so never passes -fno-trapping-math to the frontend). We don't do that here because gfortran doesn't support -ffp-exception-behavior and I want to keep the scope limited to allow -ffast-math support to progress.

The change to the condition for forwarding -mreassociate is to match Clang.

[kiranchandramohan]

Since this flag does not directly map to an MLIR Operation or LLVM Instruction fast attribute, I think we need to have an understanding of how to model this in FIR/MLIR or how to generate code in the Flang Lowering code.

flang/test/Driver/flang_fp_opts.f90

14

This flag is implemented now, right?

[tblah]

flang/test/Driver/flang_fp_opts.f90

14

@vzakhari didn't want to remove these warnings when support was first added because the intrinsics simplification pass still ignored fastmath (https://reviews.llvm.org/D137391#3908424).

There has been work on the intrinsics since then in https://reviews.llvm.org/D138048 but I don't know if this is complete. @vzakhari would you like me to remove these warnings for the implemented flags now?

[tblah]

In D138410#3940673, @kiranchandramohan wrote:

Since this flag does not directly map to an MLIR Operation or LLVM Instruction fast attribute, I think we need to have an understanding of how to model this in FIR/MLIR or how to generate code in the Flang Lowering code.

This is modeled in LLVM IR by generating constrained floating point intrinsics instead of the usual floating point operations (fadd, fsub, etc). These constrained intrinsics have the fpexcept.* attributes which specify whether optimization passes are allowed to transform code in ways which could change the exception semantics of the original code. For example, a speculatively executed FP operation might generate an exception which would not have occurred in unoptimised code. All function calls done by a function using the constrained insrinsics must use the strictfp attribute. All function definitions using the constrained intrinsics must have the strictfp attribute. More information is available here https://llvm.org/docs/LangRef.html#constrained-floating-point-intrinsics

None of these constrained intrinsics, their attributes, nor the strictfp function attribute are in the llvm MLIR dialect so they will need to be added there. Further they will have to be added to the arithmetic dialect, and Flang will have to learn to generate these intrinsics and attributes as described.

The math dialect is a bit trickier. Maybe we should add an attribute corresponding to fpexcept, then make sure it is lowered correctly? The current math dialect operations all implement AlwaysSpeculateableImplTrait and so could be optimised in ways which are not compatible with strict floating point exceptions. Therefore the math dialect operations will have to be treated like the raw floating point operations in the math dialect and have new constrained versions added (including lowering of these).

clang/include/clang/Driver/Options.td

 def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>;
 // This option was originally misspelt "infinites" [sic].
 def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
 def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
 def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option, FC1Option]>,
   MarshallingInfoFlag<LangOpts<"RoundingMath">>,
   Normalizer<"makeFlagToValueNormalizer(llvm::RoundingMode::Dynamic)">;
 def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>;
-def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>;
+def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>, Flags<[FC1Option]>;
 def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>;
 def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>,
   Flags<[CC1Option, FC1Option, FlangOption]>,
   DocBrief<"Form fused FP ops (e.g. FMAs):"
   " fast (fuses across statements disregarding pragmas)"
   " | on (only fuses in the same statement unless dictated by pragmas)"
   " | off (never fuses)"
   " | fast-honor-pragmas (fuses across statements unless diectated by pragmas)."

clang/lib/Driver/ToolChains/Flang.cpp

static void addFloatingPointOptions(const Driver &D, const ArgList &Args,
   StringRef FPContract;
   bool HonorINFs = true;
   bool HonorNaNs = true;
   bool ApproxFunc = false;
   bool SignedZeros = true;
   bool AssociativeMath = false;
   bool ReciprocalMath = false;
   bool RoundingFPMath = false;
+  bool TrappingMath = false;
 
   if (const Arg *A = Args.getLastArg(options::OPT_ffp_contract)) {
     const StringRef Val = A->getValue();
     if (Val == "fast" || Val == "off") {
       FPContract = Val;
     } else if (Val == "on") {
       // Warn instead of error because users might have makefiles written for
       // gfortran (which accepts -ffp-contract=on)
case options::OPT_fno_reciprocal_math:
       ReciprocalMath = false;
       break;
     case options::OPT_frounding_math:
       RoundingFPMath = true;
       break;
     case options::OPT_fno_rounding_math:
       RoundingFPMath = false;
       break;
+    case options::OPT_ftrapping_math:
+      TrappingMath = true;
+      break;
+    case options::OPT_fno_trapping_math:
+      TrappingMath = false;
+      break;
     }
 
     // If we handled this option claim it
     A->claim();
   }
 
   if (!FPContract.empty())
     CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
 
   if (!HonorINFs)
     CmdArgs.push_back("-menable-no-infs");
 
   if (!HonorNaNs)
     CmdArgs.push_back("-menable-no-nans");
 
   if (ApproxFunc)
     CmdArgs.push_back("-fapprox-func");
 
   if (!SignedZeros)
     CmdArgs.push_back("-fno-signed-zeros");
 
-  if (AssociativeMath && !SignedZeros)
+  if (AssociativeMath && !SignedZeros && !TrappingMath)
     CmdArgs.push_back("-mreassociate");
 
   if (ReciprocalMath)
     CmdArgs.push_back("-freciprocal-math");
 
   if (RoundingFPMath)
     CmdArgs.push_back("-frounding-math");
+
+  if (TrappingMath)
+    CmdArgs.push_back("-ftrapping-math");
 }
 
 void Flang::ConstructJob(Compilation &C, const JobAction &JA,
                          const InputInfo &Output, const InputInfoList &Inputs,
                          const ArgList &Args, const char *LinkingOutput) const {
   const auto &TC = getToolChain();
   const llvm::Triple &Triple = TC.getEffectiveTriple();
   const std::string &TripleStr = Triple.getTriple();

flang/include/flang/Common/MathOptionsBase.def

 ENUM_MATHOPT(AssociativeMath, unsigned, 1, 0)
 
 /// Allow division operations to be reassociated
 ENUM_MATHOPT(ReciprocalMath, unsigned, 1, 0)
 
 /// Do not assume default floating-point rounding behavior
 ENUM_MATHOPT(RoundingMath, unsigned, 1, 0)
 
+/// Tells the compiler whether to assume that floating point operations can trap
+ENUM_MATHOPT(TrappingMath, unsigned, 1, 0)
+
 #undef ENUM_MATHOPT

flang/include/flang/Frontend/LangOptions.def

 /// Allow optimizations that ignore the sign of floating point zeros
 LANGOPT(NoSignedZeros, 1, false)
 /// Allow reassociation transformations for floating-point instructions
 LANGOPT(AssociativeMath, 1, false)
 /// Allow division operations to be reassociated
 LANGOPT(ReciprocalMath, 1, false)
 /// Do not assume default floating-point rounding behavior
 LANGOPT(RoundingMath, 1, false)
+/// Tells the compiler whether to assume that floating point operations can trap
+LANGOPT(TrappingMath, 1, false)
 
 #undef LANGOPT
 #undef ENUM_LANGOPT

flang/lib/Frontend/CompilerInvocation.cpp

static bool parseFloatingPointArgs(CompilerInvocation &invoc,
   }
 
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_frounding_math)) {
     diags.Report(diagUnimplemented) << a->getOption().getName();
     opts.RoundingMath = true;
   }
 
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_ftrapping_math)) {
+    diags.Report(diagUnimplemented) << a->getOption().getName();
+    opts.TrappingMath = true;
+  }
+
   return true;
 }
 
 bool CompilerInvocation::createFromArgs(
     CompilerInvocation &res, llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
mathOpts
       .setFPContractEnabled(langOptions.getFPContractMode() ==
                             LangOptions::FPM_Fast)
       .setNoHonorInfs(langOptions.NoHonorInfs)
       .setNoHonorNaNs(langOptions.NoHonorNaNs)
       .setApproxFunc(langOptions.ApproxFunc)
       .setNoSignedZeros(langOptions.NoSignedZeros)
       .setAssociativeMath(langOptions.AssociativeMath)
       .setReciprocalMath(langOptions.ReciprocalMath)
-      .setRoundingMath(langOptions.RoundingMath);
+      .setRoundingMath(langOptions.RoundingMath)
+      .setTrappingMath(langOptions.TrappingMath);
 }

flang/lib/Optimizer/Builder/FIRBuilder.cpp

if (options.getNoSignedZeros()) {
     arithFMF = arithFMF | mlir::arith::FastMathFlags::nsz;
   }
   if (options.getAssociativeMath()) {
     arithFMF = arithFMF | mlir::arith::FastMathFlags::reassoc;
   }
   if (options.getReciprocalMath()) {
     arithFMF = arithFMF | mlir::arith::FastMathFlags::arcp;
   }
-  // TODO: getRoundingMath()
+  // TODO: getRoundingMath(), getTrappingMath()
   setFastMathFlags(arithFMF);
 }
 
 //===--------------------------------------------------------------------===//
 // ExtendedValue inquiry helper implementation
 //===--------------------------------------------------------------------===//
 
 mlir::Value fir::factory::readCharLen(fir::FirOpBuilder &builder,

flang/test/Driver/flang_fp_opts.f90

 ! Test for handling of floating point options within the frontend driver
 
 ! RUN: %flang_fc1 \
 ! RUN:      -ffp-contract=fast \
 ! RUN:      -menable-no-infs \
 ! RUN:      -menable-no-nans \
 ! RUN:      -fapprox-func \
 ! RUN:      -fno-signed-zeros \
 ! RUN:      -mreassociate \
 ! RUN:      -freciprocal-math \
 ! RUN:      -frounding-math \
+! RUN:      -ftrapping-math \
 ! RUN:      %s 2>&1 | FileCheck %s
 ! CHECK: ffp-contract= is not currently implemented
 ! CHECK: menable-no-infs is not currently implemented
 ! CHECK: menable-no-nans is not currently implemented
 ! CHECK: fapprox-func is not currently implemented
 ! CHECK: fno-signed-zeros is not currently implemented
 ! CHECK: mreassociate is not currently implemented
 ! CHECK: freciprocal-math is not currently implemented
 ! CHECK: frounding-math is not currently implemented
+! CHECK: ftrapping-math is not currently implemented

flang/test/Driver/frontend-forwarding.f90

 ! CHECK: "-fapprox-func"
 ! CHECK: "-fno-signed-zeros"
 ! CHECK: "-mreassociate"
 ! CHECK: "-freciprocal-math"
 ! CHECK: "-frounding-math"
 ! CHECK: "-fconvert=little-endian"
 ! CHECK: "-fpass-plugin=Bye
 ! CHECK: "-mllvm" "-print-before-all"
+
+! Check -ftrapping-math. This has to be done separately because it prevents
+! -mreassociate from being forwarded
+! RUN: %flang -fsyntax-only -### %s -o %t 2>&1 \
+! RUN:     -ftrapping-math \
+! RUN:   | FileCheck --check-prefix=CHECK-TRAP %s
+! CHECK-TRAP: "-ftrapping-math"