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

[tblah]

Summary

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

Forwarding is a bit different to Clang: Clang will forward -fno-rounding-math if RoundingFPMath is false (the default). This commit does not add a flag in the default case: only adding -frounding-math to pass on a non-default value.

[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.

clang/include/clang/Driver/Options.td

defm signed_zeros : BoolFOption<"signed-zeros",
   PosFlag<SetFalse>>;
 def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>;
 def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>;
 def fhonor_infinities : Flag<["-"], "fhonor-infinities">, Group<f_Group>;
 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]>,
+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 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):"

clang/lib/Driver/ToolChains/Flang.cpp

static void addFloatingPointOptions(const Driver &D, const ArgList &Args,
                                     ArgStringList &CmdArgs) {
   StringRef FPContract;
   bool HonorINFs = true;
   bool HonorNaNs = true;
   bool ApproxFunc = false;
   bool SignedZeros = true;
   bool AssociativeMath = false;
   bool ReciprocalMath = false;
+  bool RoundingFPMath = 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_associative_math:
       AssociativeMath = false;
       break;
     case options::OPT_freciprocal_math:
       ReciprocalMath = true;
       break;
     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;
     }
 
     // If we handled this option claim it
     A->claim();
   }
 
   if (!FPContract.empty())
     CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
static void addFloatingPointOptions(const Driver &D, const ArgList &Args,
   if (!SignedZeros)
     CmdArgs.push_back("-fno-signed-zeros");
 
   if (AssociativeMath && !SignedZeros)
     CmdArgs.push_back("-mreassociate");
 
   if (ReciprocalMath)
     CmdArgs.push_back("-freciprocal-math");
+
+  if (RoundingFPMath)
+    CmdArgs.push_back("-frounding-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(NoSignedZeros, unsigned, 1, 0)
 
 /// Allow reassociation transformations for floating-point instructions
 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)
+
 #undef ENUM_MATHOPT

flang/include/flang/Frontend/LangOptions.def

 /// calculation
 LANGOPT(ApproxFunc, 1, false)
 /// 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)
 
 #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_freciprocal_math)) {
     diags.Report(diagUnimplemented) << a->getOption().getName();
     opts.ReciprocalMath = true;
   }
 
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_frounding_math)) {
+    diags.Report(diagUnimplemented) << a->getOption().getName();
+    opts.RoundingMath = true;
+  }
+
   return true;
 }
 
 bool CompilerInvocation::createFromArgs(
     CompilerInvocation &res, llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
void CompilerInvocation::setLoweringOptions() {
   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);
+      .setReciprocalMath(langOptions.ReciprocalMath)
+      .setRoundingMath(langOptions.RoundingMath);
 }

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()
   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:      %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

flang/test/Driver/frontend-forwarding.f90

 ! RUN:     -fconvert=little-endian \
 ! RUN:     -ffp-contract=fast \
 ! RUN:     -fno-honor-infinities \
 ! RUN:     -fno-honor-nans \
 ! RUN:     -fapprox-func \
 ! RUN:     -fno-signed-zeros \
 ! RUN:     -fassociative-math \
 ! RUN:     -freciprocal-math \
+! RUN:     -frounding-math \
 ! RUN:     -fpass-plugin=Bye%pluginext \
 ! RUN:     -mllvm -print-before-all\
 ! RUN:     -P \
 ! RUN:   | FileCheck %s
 
 ! CHECK: "-P"
 ! CHECK: "-finput-charset=utf-8"
 ! CHECK: "-fdefault-double-8"
 ! CHECK: "-fdefault-integer-8"
 ! CHECK: "-fdefault-real-8"
 ! CHECK: "-flarge-sizes"
 ! CHECK: "-ffp-contract=fast"
 ! CHECK: "-menable-no-infs"
 ! CHECK: "-menable-no-nans"
 ! 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"