[flang] Add -ffp-contract option processing

[tblah]

Summary

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

Only the "off" and "fast" options are supported. "fast-honor-pragmas" is not applicable because we do not implement #pragma clang fp contract() in Fortran [1]. "on" is not supported because it is unclear how to fuse only within individual statements. gfortran also does not implement "on": treating it as an "off".

Currently the default value is "off" to preserve existing behavior. gfortran uses "fast" by default and that may be the right thing for flang-new after further discussion in the future, but that can be changed separately. gfortran's documentation is available here.

[1] https://clang.llvm.org/docs/LanguageExtensions.html#extensions-to-specify-floating-point-flags

[tblah]

clang-format plus cleaning up typos.

[awarzynski]

Thanks for implementing this, @tblah!

Two high level questions/requests:

• are you confident that we will need LangOptions.def?
• can you upload a patch with full context? (some details can be found here: https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface)

-Andrzej

clang/lib/Driver/ToolChains/Flang.cpp

85–86

What's RenderFloatingPointOptions?

flang/lib/Frontend/CompilerInvocation.cpp

664

res is a very confusing name (that I used myself in various places). Basically, it's the CompilerInvocation instance ... result. Perhaps use invoc?

665

[nit] "The compiler invocation args to parse"

flang/test/Driver/driver-help.f90

108

Why not expose this flag in flang-new? (as well as flang-new -fc1?)

flang/test/Driver/flang_fp_opts.f90

2–3

Sounds like a test for frontend-forwarding.f90

7–8

Could you use more descriptive prefixes?

[tblah]

Thanks for taking a look. I've updated accordingly and will upload the patch soon.

are you confident that we will need LangOptions.def?

Clang places this flag (and many other floating point options) in LangOptions so I thought I would follow the same convention here. Is there somewhere more appropriate to put them?

clang/lib/Driver/ToolChains/Flang.cpp

85–86

It is a static function in clang/lib/Driver/ToolChains/Clang.cpp which does the same job as AddFloatingPointOptions, except for clang. I couldn't use it right away because not all of the options it it processes are supported in flang, but once we get there it would make sense to share code.

[tblah]

Linux CI is passing. I suspect the CI failure on windows is unrelated to my code: the test failure is for clang-scan-deps and the previous version of the patch passed CI.

[awarzynski]

The omission of the fast-honor-pragmas argument from the compiler driver is deliberate.

Where is it omitted?

I suspect the CI failure on windows is unrelated to my code

I agree.

clang/lib/Driver/ToolChains/Flang.cpp

85–86

Ah! That function is over 400 LOC and looks super complex. I doubt Flang will be able to share that logic with Clang any time soon. If ever. I would actually skip this comment. Sometimes code duplication is the right approach ;-)

167

From LLVM Coding style

Function names should be verb phrases (as they represent actions), and command-like function should be imperative. The name should be camel case, and start with a lower case letter (e.g. openFile() or isFoo()).

I know that this style is not followed here 100%. But that's what we should aim for :)

flang/include/flang/Frontend/LangOptions.h

10–12

UPDATEME

30

What are these pragmas? Perhaps you can add a test that would include them?

50–51

flang/lib/Frontend/CompilerInvocation.cpp

661–662

populates the variables options accordingly

Perhaps this would be a bit more specific/descriptive:

"and configures the input CompilerInvocation accordingly". Ultimately, this is about ... configuring the current compiler invocation, which is represented by an instance of CompilerInvocaiton.

693

In here you only configure CompilerInvocation. This configuration will be used elsewhere (i.e. where codegen happens). So, I think, as far as this method is concerned the implementation is complete.

flang/test/Driver/flang_fp_opts.f90

2–3

No longer valid ;-)

5

Can you test with flang as well?

[DavidTruby]

Glad to see this flag being added to flang-new! As a note to self I've written some tests that should be updated once this lands that currently don't pass through the flang-new driver.

flang/test/Driver/driver-help.f90

108

I think @awarzynski is right here, this is an option we want to expose to end users so I think the top-level driver should have it as well.

As a general rule of thumb: if a flag is in clang as well as clang -cc1 it should be in flang as well as flang -fc1
In this case -ffp-contract is a clang flag as well as a clang -cc1 flag, and so should probably be a flang flag as well as flang -fc1

[tblah]

The omission of the fast-honor-pragmas argument from the compiler driver is deliberate.

Where is it omitted?

This argument is only supported in the frontend driver, not the compiler driver:

flang-new -ffp-contract=fast-honor-pragmas test.f90 
flang-new: error: unsupported argument 'fast-honor-pragmas' to option '-ffp-contract='

flang-new -fc1 -ffp-contract=fast-honor-pragmas test.f90
warning: ffp-contract= is not currently implemented

flang/include/flang/Frontend/LangOptions.h

30

I copied this comment from clang. I believe the pragma is

#pragma clang fp contract(fast)

See https://clang.llvm.org/docs/LanguageExtensions.html#extensions-to-specify-floating-point-flags

This patch only adds support for argument processing, so I can't test for the pragmas.

flang/test/Driver/flang_fp_opts.f90

5

We already test that these flags are passed to the frontend driver from the compiler driver in flang/test/Driver/frontend-forwarding.f90

[vzakhari]

flang/include/flang/Frontend/LangOptions.h

30

I do not think we should blindly copy this from clang. I believe -ffp-contract=on is there to do the contraction complying to the language standard - but Fortran standard says nothing about contraction. I am also not aware about a Fortran compiler that supports directives related to contraction, so fast-honor-pragmas does not seem to be applicable as well. Basically, we end up with just off and fast.

Now, it may be reasonable to support the same -ffp-contract= arguments so that users can apply the same options sets for C/C++ and Fortran compilations. If we want to do this, we need to map on and fast-honor-pragmas to something, e.g. fast. A driver warning (not an error) may be useful to make the option's behavior clear when on and fast-honor-pragmas are passed.

flang/test/Driver/driver-help-hidden.f90

34

Is it easy to emit a different help message for Flang to say that there are only two modes for Fortran?

[tblah]

flang/include/flang/Frontend/LangOptions.h

30

From the clang help text:

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)
Default is 'on'

So if we removed on and set the default to off we would no longer fuse within the same statement by default.

Classic-flang seems to support on, off and fast: https://github.com/flang-compiler/flang/blob/master/test/llvm_ir_correct/fma.f90

flang/test/Driver/driver-help-hidden.f90

34

@awarzynski tells me there is no way to do this short of having separate Options.td for flang and clang. Once we have settled on which arguments to support, I will update the shared help text to mention flang.

[awarzynski]

flang/test/Driver/driver-help-hidden.f90

34

Both clang -help and flang-new -help must be 100% correct. As this help text is not valid in the case of LLVM Flang, it needs to be updated accordingly.

As @tblah points out, there's no straightforward mechanism for having a custom help texts for clang and flang-new in Clang's driver library ATM. But I think that this can be achieved even without creating a separate "Options.td" file. One would have to define a new tablegen record in "Options.td". That would be a separate patch though, probably accompanied by an RFC.

There's a different solution too. Note that currently the definition uses the HelpText field. However, you could use DocBrief instead (which we used to solve a similar issue with -I). That's what I suggest that you do. Basically, copy the contents of HelpText for -ffp-contract into a DocBrief field (we don't use this field in Flang and it should probably be renamed as DocBriefClang). HelpText should be replaced with something brief that applies both to Clang and Flang.

Btw, what's the help-text/spelling in gfortran?

[vzakhari]

flang/include/flang/Frontend/LangOptions.h

30

Not talking about defaults just yet, I think Flang cannot currently support the on mode as documented.

I do not have the latest classic flang readily availalbe, but I am curious what it will generate for this example:

function fn(x,y,z)
  real :: x,y,z
  fn = x * y
  fn = fn + z
end function

With a very old classic flang I get just fast math flags on the multiple and add instructions, which is obviously not what on is supposed to do:

$ flang -target aarch64-linux-gnu -O1 -c -S -emit-llvm -ffp-contract=on fma.f90
$ cat fma.ll
  %4 = fmul fast float %3, %1, !dbg !10
  %5 = bitcast i64* %z to float*, !dbg !11
  %6 = load float, float* %5, align 4, !dbg !11
  %7 = fadd fast float %6, %4, !dbg !11

Maybe the latest classic flang does support it properly, e.g. it only contracts operations from the same statement. But I do not see a way to support this in Flang right now, so documenting the on mode as it is in clang seems confusing.

We can still support on in the Flang option, but I think we need to issue a warning saying that it defaults to something else, e.g. to fast. If mapping on to fast is not appropriate to some users, then they will have to explicitly specify -ffp-contract=off for Fortran compilations in their build system.

I am also curious what fuses in the same statement means for Fortran. For example:

x1 = DOT_PRODUCT(x2, x3)+x4*x5+x6

If Fortran processor decides to implement DOT_PRODUCT as inline multiply+add loop, does -ffp-contract=on apply to them or it only applies to x4*x5+x6?

[tblah]

flang/include/flang/Frontend/LangOptions.h

30

Thanks for your feedback.

I've updated my patch. Now flang only supports off and fast. The other two map to fast and we default to off.

gfortran seems to default to fast:

-ffp-contract=style

    -ffp-contract=off disables floating-point expression contraction. -ffp-contract=fast enables floating-point expression contraction such as forming of fused multiply-add operations if the target has native support for them. -ffp-contract=on enables floating-point expression contraction if allowed by the language standard. This is currently not implemented and treated equal to -ffp-contract=off.

    The default is -ffp-contract=fast.

https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html

flang/test/Driver/driver-help-hidden.f90

34

Thanks for the feedback.

I have added a mention of flang to the old help, which has been moved to DocBrief. The new HelpText just mentions which options are supported by each frontend without explaining them.

[awarzynski]

clang/include/clang/Driver/Options.td

1926

As far as users are concerned, flang-new is just a Fortran compiler. Once we start adding references to Clang in flang-new --help, we might be confusing users (i.e. where's the boundary between Clang and Flang?) and exposing implementation details (i.e. that flang-new is implemented using clangDriver). Ideally we should avoid that.

flang/include/flang/Frontend/LangOptions.h

30

gfortran seems to default to fast:

Thanks for checking those docs - it's now becoming clear that -ffp-contract=style should only support: on, off, fast. https://reviews.llvm.org/D90174 introduced fast-honor-pragmas to solve a particular problem for a particular backend, i.e. HIP. From the commit message for D90174:

'fast-honor-pragmas' is equivalent to 'fast' in frontend but let the backend to use 'Standard' fp fuse option.

To me this sounds like --ffp-contract=fast-honor-pragrmas should be replaced with:

• --ffp-contract=fast --ffp-fusion=standard (i.e. add a new flag to provide extra control to the end users)
• --ffp-control=fast -x hip --> FPM_FastHonorPragmas somewhere in Clang's CompilerInvocartion.cpp

As in, I believe that the issue in HIP can be solved without --ffp-contract=fast-honor-pragrmas. And if we avoid that approach, we can have a flag that's consistent with GCC and also make the help text much clearer.

@vzakhari

Now, it may be reasonable to support the same -ffp-contract= arguments so that users can apply the same options sets for C/C++ and Fortran compilations.

Yes, but I am not aware of anyone experimenting with mixed-source projects yet. So currently flang-new should only be used for Fortran sources and clang for C family of languages. So I would leave that for later.

[tblah]

Updated diff with a further reduced help text after discussions with @awarzynski

[vzakhari]

clang/lib/Driver/ToolChains/Flang.cpp

94

I know I suggested myself mapping on to fast, but it seems it will be more reasonable to map it to off. Both my old classic flang and gfortran (12.2.0) do not generate FMAs under on. Moreover, mapping it to off may allow us to adapt gcc's help message "if allowed by the language standard" (maybe not in this commit).

[vzakhari]

Thank you! LGTM

[awarzynski]

Added Clang reviewers who touched the definition of --fp-contract most recently. Mostly for visibility, but lets give them at least a couple of days to take a look at the changes in Options.td.

[awarzynski]

Thanks for all the updates, Tom! I have a few more suggestions.

From the summary:

implement these pragmas

Could you explain what pragmas you are referring to here? (i.e. Clang pragmas for C and C++ + link)

gfortran uses "fast" by default

For our future self, could you add a link as well?

clang/include/clang/Driver/Options.td

1925–1926

I still think that we shouldn't be making references to Flang in Clang documentation. And this DocBrief is only used by Clang. Also, "flang" is problematic - what do you mean by "flang"?

clang/lib/Driver/ToolChains/Flang.cpp

91–98

Some "unsupported" options are treated as errors and some are warnings. I think that for the sake of consistency it would be better to keep them all as errors. Also, why not use Val instead of e.g. "off"?

[MaskRay]

clang/lib/Driver/ToolChains/Flang.cpp

89

We prefer == to equals

[awarzynski]

LGTM, thanks for implementing this!

clang/lib/Driver/ToolChains/Flang.cpp

98–99

[nit] "... and pragmas are not relevant to Fortran." Fortran has directives rather than pragmas. So it's not quite like pragmas are not supported. It's just that there's different mechanism instead.

[tblah]

I've updated the patch with @awarzynski's nit and an up-to-date context.

@kiranchandramohan please could you commit for me

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_bad_offload_arch_combo : Error<
   "offload archs)">;
 def warn_drv_unsupported_option_for_offload_arch_req_feature : Warning<
   "ignoring '%0' option for offload arch '%1' as it is not currently supported "
   "there. Use it with an offload arch containing '%2' instead">,
   InGroup<OptionIgnored>;
 def warn_drv_unsupported_option_for_target : Warning<
   "ignoring '%0' option as it is not currently supported for target '%1'">,
   InGroup<OptionIgnored>;
+def warn_drv_unsupported_option_for_flang : Warning<
+  "the argument '%0' is not supported for option '%1'. Mapping to '%1%2'">,
+  InGroup<OptionIgnored>;
 
 def err_drv_invalid_thread_model_for_target : Error<
   "invalid thread model '%0' in '%1' for this target">;
 def err_drv_invalid_linker_name : Error<
   "invalid linker name in argument '%0'">;
 def err_drv_invalid_rtlib_name : Error<
   "invalid runtime library name in argument '%0'">;
 def err_drv_unsupported_rtlib_for_platform : Error<

clang/include/clang/Driver/Options.td

 def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
 def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>,
   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]>, HelpText<"Form fused FP ops (e.g. FMAs):"
+  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)."
-  " Default is 'fast' for CUDA, 'fast-honor-pragmas' for HIP, and 'on' otherwise.">,
+  " Default is 'fast' for CUDA, 'fast-honor-pragmas' for HIP, 'off' for flang, and 'on' otherwise.">,
+  HelpText<"Form fused FP ops (e.g. FMAs)">,
   Values<"fast,on,off,fast-honor-pragmas">;
 
 defm strict_float_cast_overflow : BoolFOption<"strict-float-cast-overflow",
   CodeGenOpts<"StrictFloatCastOverflow">, DefaultTrue,
   NegFlag<SetFalse, [CC1Option], "Relax language rules and try to match the behavior"
             " of the target's native float-to-int conversion instructions">,
   PosFlag<SetTrue, [], "Assume that overflowing float-to-int casts are undefined (default)">>;
 

clang/lib/Driver/ToolChains/Flang.cpp

void Flang::AddPicOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
   if (PICLevel > 0) {
     CmdArgs.push_back("-pic-level");
     CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
     if (IsPIE)
       CmdArgs.push_back("-pic-is-pie");
   }
 }
 
+static void addFloatingPointOptions(const Driver &D, const ArgList &Args,
+                                    ArgStringList &CmdArgs) {
+  StringRef FPContract;
+
+  if (const Arg *A = Args.getLastArg(options::OPT_ffp_contract)) {
+    const StringRef Val = A->getValue();
+    if (Val.equals("fast") || Val.equals("off")) {
+      FPContract = Val;
+    } else if (Val.equals("on") || Val.equals("fast-honor-pragmas")) {
+      D.Diag(diag::warn_drv_unsupported_option_for_flang)
+          << Val << A->getOption().getName() << "fast";
+      FPContract = "fast";
+    } else
+      D.Diag(diag::err_drv_unsupported_option_argument)
+          << A->getOption().getName() << Val;
+  }
+
+  if (!FPContract.empty())
+    CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
+}
+
 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();
 
   const Driver &D = TC.getDriver();
void Flang::ConstructJob(Compilation &C, const JobAction &JA,
   Args.getLastArg(options::OPT_fcolor_diagnostics,
                   options::OPT_fno_color_diagnostics);
   if (D.getDiags().getDiagnosticOptions().ShowColors)
     CmdArgs.push_back("-fcolor-diagnostics");
 
   // -fPIC and related options.
   AddPicOptions(Args, CmdArgs);
 
+  // Floating point related options
+  addFloatingPointOptions(D, Args, CmdArgs);
+
   // Handle options which are simply forwarded to -fc1.
   forwardOptions(Args, CmdArgs);
 
   // Forward -Xflang arguments to -fc1
   Args.AddAllArgValues(CmdArgs, options::OPT_Xflang);
 
   // Forward -mllvm options to the LLVM option parser. In practice, this means
   // forwarding to `-fc1` as that's where the LLVM parser is run.

flang/include/flang/Frontend/CompilerInvocation.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_FRONTEND_COMPILERINVOCATION_H
 #define FORTRAN_FRONTEND_COMPILERINVOCATION_H
 
 #include "flang/Frontend/CodeGenOptions.h"
 #include "flang/Frontend/FrontendOptions.h"
+#include "flang/Frontend/LangOptions.h"
 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Frontend/TargetOptions.h"
 #include "flang/Lower/LoweringOptions.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Semantics/semantics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "llvm/Option/ArgList.h"
class CompilerInvocation : public CompilerInvocationBase {
   Fortran::lower::LoweringOptions loweringOpts;
 
   /// Options controlling the target.
   Fortran::frontend::TargetOptions targetOpts;
 
   /// Options controlling IRgen and the backend.
   Fortran::frontend::CodeGenOptions codeGenOpts;
 
+  /// Options controlling language dialect.
+  Fortran::frontend::LangOptions langOpts;
+
   // Semantics context
   std::unique_ptr<Fortran::semantics::SemanticsContext> semanticsContext;
 
   /// Semantic options
   // TODO: Merge with or translate to frontendOpts. We shouldn't need two sets
   // of options.
   std::string moduleDir = ".";
 
public:
   const Fortran::parser::Options &getFortranOpts() const { return parserOpts; }
 
   TargetOptions &getTargetOpts() { return targetOpts; }
   const TargetOptions &getTargetOpts() const { return targetOpts; }
 
   CodeGenOptions &getCodeGenOpts() { return codeGenOpts; }
   const CodeGenOptions &getCodeGenOpts() const { return codeGenOpts; }
 
+  LangOptions &getLangOpts() { return langOpts; }
+  const LangOptions &getLangOpts() const { return langOpts; }
+
   Fortran::lower::LoweringOptions &getLoweringOpts() { return loweringOpts; }
   const Fortran::lower::LoweringOptions &getLoweringOpts() const {
     return loweringOpts;
   }
 
   Fortran::semantics::SemanticsContext &getSemanticsContext() {
     return *semanticsContext;
   }

flang/include/flang/Frontend/LangOptions.h

+//===------ LangOptions.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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the LangOptions interface, which holds the
+//  configuration for LLVM's middle-end and back-end. It controls LLVM's code
+//  generation into assembly or machine code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_FRONTEND_LANGOPTIONS_H
+#define LLVM_FLANG_FRONTEND_LANGOPTIONS_H
+
+namespace Fortran::frontend {
+
+/// Bitfields of LangOptions, split out from LangOptions to ensure
+/// that this large collection of bitfields is a trivial class type.
+class LangOptionsBase {
+
+public:
+  enum FPModeKind {
+    // Do not fuse FP ops
+    FPM_Off,
+
+    // Aggressively fuse FP ops (E.g. FMA).
+    FPM_Fast,
+  };
+
+#define LANGOPT(Name, Bits, Default) unsigned Name : Bits;
+#define ENUM_LANGOPT(Name, Type, Bits, Default)
+#include "flang/Frontend/LangOptions.def"
+
+protected:
+#define LANGOPT(Name, Bits, Default)
+#define ENUM_LANGOPT(Name, Type, Bits, Default) unsigned Name : Bits;
+#include "flang/Frontend/LangOptions.def"
+};
+
+/// Tracks various options which control the dialect of Fortran that is
+/// accepted. Based on clang::LangOptions
+class LangOptions : public LangOptionsBase {
+
+public:
+  // Define accessors/mutators for code generation options of enumeration type.
+#define LANGOPT(Name, Bits, Default)
+#define ENUM_LANGOPT(Name, Type, Bits, Default)                                \
+  Type get##Name() const { return static_cast<Type>(Name); }                   \
+  void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
+#include "flang/Frontend/LangOptions.def"
+
+  LangOptions();
+};
+
+} // end namespace Fortran::frontend
+
+#endif

flang/include/flang/Frontend/LangOptions.def

+//===------ LangOptions.def - Code generation option database ----- 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 the language dialect options. Users of this file
+// must define the LANGOPT macro to make use of this information.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LANGOPT
+#  error Define the LANGOPT macro to handle language options
+#endif
+
+#ifndef ENUM_LANGOPT
+#  define ENUM_LANGOPT(Name, Type, Bits, Default) \
+LANGOPT(Name, Bits, Default)
+#endif
+
+ENUM_LANGOPT(FPContractMode, FPModeKind, 2, FPM_Off) ///< FP Contract Mode (off/fast)
+
+#undef LANGOPT
+#undef ENUM_LANGOPT

flang/lib/Frontend/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   CodeGenOptions.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
+  LangOptions.cpp
   TextDiagnosticPrinter.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnostic.cpp
 
   DEPENDS
   clangBasic
   FIRBuilder
   FIRDialect

flang/lib/Frontend/CompilerInvocation.cpp

if (standard.equals("f2018")) {
           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
               "Only -std=f2018 is allowed currently.");
       diags.Report(diagID);
     }
   }
   return diags.getNumErrors() == numErrorsBefore;
 }
 
+/// Parses all floating point related arguments and populates the
+/// CompilerInvocation accordingly.
+/// Returns false if new errors are generated.
+///
+/// \param [out] invoc Stores the processed arguments
+/// \param [in] args The compiler invocation arguments to parse
+/// \param [out] diags DiagnosticsEngine to report erros with
+static bool parseFloatingPointArgs(CompilerInvocation &invoc,
+                                   llvm::opt::ArgList &args,
+                                   clang::DiagnosticsEngine &diags) {
+  LangOptions &opts = invoc.getLangOpts();
+  const unsigned diagUnimplemented = diags.getCustomDiagID(
+      clang::DiagnosticsEngine::Warning, "%0 is not currently implemented");
+
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_ffp_contract)) {
+    const llvm::StringRef val = a->getValue();
+    enum LangOptions::FPModeKind fpContractMode;
+
+    if (val.equals("off"))
+      fpContractMode = LangOptions::FPM_Off;
+    else if (val.equals("fast"))
+      fpContractMode = LangOptions::FPM_Fast;
+    else {
+      diags.Report(clang::diag::err_drv_unsupported_option_argument)
+          << a->getOption().getName() << val;
+      return false;
+    }
+
+    diags.Report(diagUnimplemented) << a->getOption().getName();
+    opts.setFPContractMode(fpContractMode);
+  }
+
+  return true;
+}
+
 bool CompilerInvocation::createFromArgs(
     CompilerInvocation &res, llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
 
   // Set the default triple for this CompilerInvocation. This might be
   // overridden by users with `-triple` (see the call to `ParseTargetArgs`
bool CompilerInvocation::createFromArgs(
   success &= parseDialectArgs(res, args, diags);
   success &= parseDiagArgs(res, args, diags);
   res.frontendOpts.llvmArgs =
       args.getAllArgValues(clang::driver::options::OPT_mllvm);
 
   res.frontendOpts.mlirArgs =
       args.getAllArgValues(clang::driver::options::OPT_mmlir);
 
+  success &= parseFloatingPointArgs(res, args, diags);
+
   return success;
 }
 
 void CompilerInvocation::collectMacroDefinitions() {
   auto &ppOpts = this->getPreprocessorOpts();
 
   for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) {
     llvm::StringRef macro = ppOpts.macros[i].first;

flang/lib/Frontend/LangOptions.cpp

+//===------ LangOptions.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Frontend/LangOptions.h"
+#include <string.h>
+
+namespace Fortran::frontend {
+
+LangOptions::LangOptions() {
+#define LANGOPT(Name, Bits, Default) Name = Default;
+#define ENUM_LANGOPT(Name, Type, Bits, Default) set##Name(Default);
+#include "flang/Frontend/LangOptions.def"
+}
+
+} // end namespace Fortran::frontend

flang/test/Driver/driver-help-hidden.f90

 ! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
 ! CHECK-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
 ! CHECK-NEXT: -fdefault-double-8     Set the default double precision kind to an 8 byte wide type
 ! CHECK-NEXT: -fdefault-integer-8    Set the default integer kind to an 8 byte wide type
 ! CHECK-NEXT: -fdefault-real-8       Set the default real kind to an 8 byte wide type
 ! CHECK-NEXT: -ffixed-form           Process source files in fixed form
 ! CHECK-NEXT: -ffixed-line-length=<value>
 ! CHECK-NEXT: Use <value> as character line width in fixed mode
+! CHECK-NEXT: -ffp-contract=<value> Form fused FP ops (e.g. FMAs): fast | off (clang, flang), on | fast-honor-pragmas (clang only)
 ! CHECK-NEXT: -ffree-form            Process source files in free form
 ! CHECK-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
 ! CHECK-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! CHECK-NEXT: -fintrinsic-modules-path <dir>
 ! CHECK-NEXT:                        Specify where to find the compiled intrinsic modules
 ! CHECK-NEXT: -flang-experimental-exec
 ! CHECK-NEXT:                        Enable support for generating executables (experimental)
 ! CHECK-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics

flang/test/Driver/driver-help.f90

 ! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
 ! HELP-NEXT: -fconvert=<value>      Set endian conversion of data for unformatted files
 ! HELP-NEXT: -fdefault-double-8     Set the default double precision kind to an 8 byte wide type
 ! HELP-NEXT: -fdefault-integer-8    Set the default integer kind to an 8 byte wide type
 ! HELP-NEXT: -fdefault-real-8       Set the default real kind to an 8 byte wide type
 ! HELP-NEXT: -ffixed-form           Process source files in fixed form
 ! HELP-NEXT: -ffixed-line-length=<value>
 ! HELP-NEXT: Use <value> as character line width in fixed mode
+! HELP-NEXT: -ffp-contract=<value> Form fused FP ops (e.g. FMAs): fast | off (clang, flang), on | fast-honor-pragmas (clang only)
 ! HELP-NEXT: -ffree-form            Process source files in free form
 ! HELP-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
 ! HELP-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! HELP-NEXT: -fintrinsic-modules-path <dir>
 ! HELP-NEXT:                        Specify where to find the compiled intrinsic modules
 ! HELP-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE

 ! HELP-FC1-NEXT: -fdebug-unparse-with-symbols
 ! HELP-FC1-NEXT:                        Unparse and stop.
 ! HELP-FC1-NEXT: -fdebug-unparse        Unparse and stop.
 ! HELP-FC1-NEXT: -fdefault-double-8  Set the default double precision kind to an 8 byte wide type
 ! HELP-FC1-NEXT: -fdefault-integer-8 Set the default integer kind to an 8 byte wide type
 ! HELP-FC1-NEXT: -fdefault-real-8    Set the default real kind to an 8 byte wide type
 ! HELP-FC1-NEXT: -ffixed-form           Process source files in fixed form
 ! HELP-FC1-NEXT: -ffixed-line-length=<value>
 ! HELP-FC1-NEXT: Use <value> as character line width in fixed mode
+! HELP-FC1-NEXT: -ffp-contract=<value> Form fused FP ops (e.g. FMAs): fast | off (clang, flang), on | fast-honor-pragmas (clang only)
 ! HELP-FC1-NEXT: -ffree-form            Process source files in free form
 ! HELP-FC1-NEXT: -fget-definition <value> <value> <value>
 ! HELP-FC1-NEXT:                        Get the symbol definition from <line> <start-column> <end-column>
 ! HELP-FC1-NEXT: -fget-symbols-sources   Dump symbols and their source code locations
 ! HELP-FC1-NEXT: -fimplicit-none        No implicit typing allowed unless overridden by IMPLICIT statements
 ! HELP-FC1-NEXT: -finput-charset=<value> Specify the default character set for source files
 ! HELP-FC1-NEXT: -fintrinsic-modules-path <dir>
 ! HELP-FC1-NEXT:                        Specify where to find the compiled intrinsic modules

flang/test/Driver/flang_f_opts.f90

 ! Test for warnings generated when parsing driver options. You can use this file for relatively small tests and to avoid creating
 ! new test files.
 
-! RUN: %flang -### -S -O4 %s 2>&1 | FileCheck %s
+! RUN: %flang -### -S -O4 -ffp-contract=on %s 2>&1 | FileCheck %s
 
+! CHECK: warning: the argument 'on' is not supported for option 'ffp-contract='. Mapping to 'ffp-contract=fast'
 ! CHECK: warning: -O4 is equivalent to -O3
 ! CHECK-LABEL: "-fc1"
+! CHECK: -ffp-contract=fast
 ! CHECK: -O3

flang/test/Driver/flang_fp_opts.f90

+! Test for handling of floating point options within the frontend driver
+
+! RUN: %flang_fc1 -ffp-contract=fast %s 2>&1 | FileCheck %s
+! CHECK: ffp-contract= is not currently implemented

flang/test/Driver/frontend-forwarding.f90

 ! Test that flang-new forwards Flang frontend
 ! options to flang-new -fc1 as expected.
 
 ! RUN: %flang -fsyntax-only -### %s -o %t 2>&1 \
 ! RUN:     -finput-charset=utf-8 \
 ! RUN:     -fdefault-double-8 \
 ! RUN:     -fdefault-integer-8 \
 ! RUN:     -fdefault-real-8 \
 ! RUN:     -flarge-sizes \
 ! RUN:     -fconvert=little-endian \
+! RUN:     -ffp-contract=fast \
 ! 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: "-fconvert=little-endian"
 ! CHECK:  "-mllvm" "-print-before-all"