[flang][driver] Add options for -fdefault* and -flarge-sizes

[arnamoy10]

Summary

Add support for the following Fortran dialect options:

• -default*
• -flarge-sizes

It also adds two test cases:

1. For checking whether flang-new is passing options correctly to flang-new -fc1.
2. For checking if fdefault- arguments are processed properly.

Also moves the Dialect related option parsing to a dedicated function and adds a member defaultKinds() to CompilerInvocation

Depends on: D96032

[awarzynski]

Hi @arnamoy10, thank you for working on this! Overall this looks good to me, but I'm wondering whether we could simplify it a bit? More comments inline.

clang/include/clang/Driver/Options.td

4240–4241

Could you add a help text? Note that once you add a help text, you will have to add FlangOnlyOption flag to make sure this option doesn't show up in:

clang -help

Some for other options here. Also, at that point, I suggest moving these options near other Flang options: https://github.com/llvm/llvm-project/blob/ec4fb5bcd3b92867156a5bd75fa0be4c74084f3c/clang/include/clang/Driver/Options.td#L4224-L4238.

AFAIK, these options are no longer forwarded to gfortran anyway (since this patch).

4243

Is this option available in gfortran? If not we shouldn't be adding Group<gfortran_Group> here.

flang/include/flang/Frontend/CompilerInvocation.h

22–28

Do we really need this? if yes, FrontendOptions.h would probably be a better place for this.

73–74

Wouldn't it be possible to just use defaultKinds_ here rather than defaultKinds_ _and_ dialectOpts_? Do you think that we will need both?

flang/lib/Frontend/CompilerInvocation.cpp

325

Is this requirement document anywhere?

flang/test/Flang-Driver/pipeline.f90

1–2 ↗

(On Diff #322390)

I suspect that this is C&P error from here :)

IIUC, this file tests that the compiler driver (flang-new) forwards all Flang frontend options to the compiler frontend driver (flang-new -fc1) as expected. Could you update the description?

[arnamoy10]

flang/lib/Frontend/CompilerInvocation.cpp

325

Just found out through running gfortran

[arnamoy10]

clang/include/clang/Driver/Options.td

4240–4241

What should be the help text for -flarge-sizes, given we cannot take reference from gfortran

[awarzynski]

Btw, could you clang-format your patch? I normally use git -lang-format HEAD~. Thank you!

flang/lib/Frontend/CompilerInvocation.cpp

325

Oh, indeed:

gfortran -fdefault-double-8 file.f
f951: Fatal Error: Use of ‘-fdefault-double-8’ requires ‘-fdefault-real-8’
compilation terminated.

Thanks you for being so thorough and checking this! :)

I think that it would help to:

• add a comment explaining _why_ this diagnostic is added (compatibility with gfortran is a good reason IMO)
• add a test to verify that it's indeed issued.

[arnamoy10]

Addressing reviewers' comments.

[awarzynski]

LGTM, thank you for working on this @arnamoy10 !

I left a few _minor_ comments. These can be addressed in the actual commit.

clang/include/clang/Driver/Options.td

4354–4355

As these options are defined within this let statement:

let Flags = [FC1Option, FlangOption, FlangOnlyOption] in {

}

there is no need to specify Flags independently for each.

flang/include/flang/Frontend/CompilerInvocation.h

73–74

Thank you for updating this.

One additional point - I would be tempted to use a regular member variable here rather than a pointer. I suspect that you were inspired by semanticContext_? Currently we have to use a pointer for semanticsContext_ as we can't use the default constructor for SemanticsContext (it requires arguments that we don't have access to at the point of constructing CompilerInvocation). That's not the case for IntrinsicTypeDefaultKinds.

But I might missing something here!

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

34

[nit] Unrelated change

[arnamoy10]

Addressed latest reviewer's comments, no longer using a pointer for defaultKinds

[tskeith]

clang/include/clang/Driver/Options.td

4361

That's not what -flarge-sizes does. Here is the description from flang/docs/Extensions.md:

The default INTEGER type is required by the standard to occupy
the same amount of storage as the default REAL type. Default
REAL is of course 32-bit IEEE-754 floating-point today. This legacy
rule imposes an artificially small constraint in some cases
where Fortran mandates that something have the default INTEGER
type: specifically, the results of references to the intrinsic functions
SIZE, STORAGE_SIZE,LBOUND, UBOUND, SHAPE, and the location reductions
FINDLOC, MAXLOC, and MINLOC in the absence of an explicit
KIND= actual argument. We return INTEGER(KIND=8) by default in
these cases when the -flarge-sizes option is enabled.
SIZEOF and C_SIZEOF always return INTEGER(KIND=8).

flang/lib/Frontend/CompilerInvocation.cpp

333

If -fdefault-double-8 requires -fdefault-real-8 then why is the default real kind set to 4?

I don't understand the purpose of this option. The kind of DOUBLE PRECISION is already 8 so there is no need to change it.

[awarzynski]

clang/include/clang/Driver/Options.td

4361

It will be tricky to capture all that in a short help text. Would this work:

Use INTEGER(KIND=8) for the result type in size-related intrinsics.

?

[arnamoy10]

Addresses proper handling of sizes

[awarzynski]

Thank you for updating this!

I've left a couple of small suggestions inline. Once those are addressed I believe that this is ready to land. @tskeith, any thoughts ?

flang/lib/Frontend/CompilerInvocation.cpp

318

From gfortran documentation:

This option promotes the default width of DOUBLE PRECISION and double real constants like 1.d0 to 16 bytes if possible.

So I believe that you are missing:

res.defaultKinds().set_doublePrecisionKind(16);

333–335

I think that it's more like:

// -fdefault-real-8 alone promotes the width for DOUBLE PRECISION to 16 bytes. -fdefault-double-8 overwrites that and sets the width back to 8 bytes.

Since this patch adds gfortran style semantics, it would be worth adding a link to the docs somewhere at the top.

[arnamoy10]

flang/lib/Frontend/CompilerInvocation.cpp

318

I thought it is not necessary because doublePrecisionKind is automatically initialized to double the size of defaultRealKind_ in here--> int doublePrecisionKind_{2 * defaultRealKind_};.

333–335

Sure, will do!

[awarzynski]

flang/lib/Frontend/CompilerInvocation.cpp

318

Yes, but the default value for defaultRealKind_ is 4 and here you are setting it to 8. So, correct me if I'm wrong, but when the driver is here, the following has happened:

int defaultIntegerKind_{4};
int defaultRealKind_{defaultIntegerKind_};
int doublePrecisionKind_{2 * defaultRealKind_};

So dublePrecisionKind_ is 8 rather than 16.

[arnamoy10]

• Added option for setting DOUBLE PRECISION when fdefault-real-8 is given
• Also added link to relevant gfortran doc

[tskeith]

flang/lib/Frontend/CompilerInvocation.cpp

318

You can test these are working correctly by compiling a module like this:

module m
  implicit none
  real :: x
  double precision :: y
  integer, parameter :: real_kind = kind(x)
  integer, parameter :: double_kind = kind(y)
end

Then check for double_kind=8_4 (or whatever) in the generated .mod file.

For -flarge-sizes:

real :: z(10)
integer, parameter :: size_kind = kind(ubound(z, 1))

[arnamoy10]

Updated test case to check module content

[awarzynski]

flang/test/Flang-Driver/fdefault.f90

2

I think that this test is a great improvement compared to what we had before. Thank you @tskeith for the suggestion and @arnamoy10 for implementing it!

A have a few additional ideas how to strengthen this:

1. It would be great to see FileCheck instead of grep (with FileCheck you can check more lines easily)

2. One RUN line per flag. When we mix flags (e.g. -fdefault-real-8 -flarge-sizes), it's not clear whether we are testing one particular flag (e.g. -flarge-sizes) or how various flags interact with each other (e.g. -fdefault-real-8 and -flarge-sizes).

What about:

• 1 RUN line without any flags + FileCheck checks for both REAL and DOUBLE
• 1 RUN line with -fdefault-real-8 + FileCheck` checks for both REAL and DOUBLE
• 1 RUN line with -fdefault-double-8 -fdefault-real-8 + FileCheck checks for both REAL and DOUBLE
• 1 RUN line with -fdefault-double-8 + FileCheck check to demonstrates that this is an error

3. Separate file for -flarge-sizes. Otherwise there's a lot being tested here. No need to mix with other flags.

59

FIXME

[tskeith]

flang/test/Flang-Driver/fdefault.f90

5

Can't this work with the f18 driver too? That's the best way to ensure they are consistent.

11

I don't think you need to create a subdirectory. %t is a temp directory specific to this test.

So I'm suggesting:

! RUN: %flang -fsyntax-only -fdefault-real-8 %s

[awarzynski]

flang/test/Flang-Driver/fdefault.f90

11

From LIT docs:

%t	temporary file name unique to the test
%T	parent directory of %t (not unique, deprecated, do not use)

So, IIUC, we do need to create a directory. We could skip <dir-flang-new> in the directory name, but it does no harm and can be really helpful when parsing CI logs.

I might be missing something though. @tskeith ?

[tskeith]

flang/test/Flang-Driver/fdefault.f90

11

I thought lit created an empty directory for %t but apparently not. You just get whatever was left over from last run. So the safest thing to do is this for each compilation command:
! RUN: rm -rf %t && mkdir %t && %flang -module-dir %t ...

It's true that adding an extra subdirectory does no harm besides clutter, but what's the benefit?

[arnamoy10]

• Rewritten the test cases
• Moved flarge-sizes to a standalone test file

[awarzynski]

I've left a few comments, but these are nice-to-haves from my perspective. @tskeith , what do you think about the suggested changes in f18? We could upload a separate patch for that.

flang/test/Flang-Driver/fdefault.f90

5

I think that this is a good idea, but there are two things that need to be addressed first:

OPTION NAMES

f18 uses -module rather than -module-dir. I suggest adding an alias, -module-dir, to f18 (e.g. similarly to how -fparse-only and -fsyntax-only are handled)

IMPLEMENTATION
If I understand correctly, the current implementation of -fdefault-real-8 in f18 is incomplete, see here:

} else if (arg == "-r8" || arg == "-fdefault-real-8") {
  defaultKinds.set_defaultRealKind(8);

I think that there should be defaultKinds.set_defaultRealKind(16); as well.

@tskeith could you confirm?

11

%t is normally used as a temporary file name. By using e.g. %t/dir-flang-new instead, we communicate it clearly that we are using it as a directory name. This is obvious now (and may seem unnecessary), but it might be less so in 6 months or when somebody works on this project (or particular test) in the future.

Either way, this test is functionally correct and in fact incredibly helpful. Both %t and %t/dir-flang-new will work perfectly fine.

flang/test/Flang-Driver/flarge_sizes.f90

2

Could you add a NOOPTION variant like you did in fdefault.f90?

[tskeith]

flang/test/Flang-Driver/fdefault.f90

5

I think that this is a good idea, but there are two things that need to be addressed first:

OPTION NAMES

f18 uses -module rather than -module-dir. I suggest adding an alias, -module-dir, to f18 (e.g. similarly to how -fparse-only and -fsyntax-only are handled)

Yes, in general when an option is given a different name in the new driver that option should be added to f18. Not only for testing consistent behavior but also because f18 gets more usage so any problems are more likely to turn up.

IMPLEMENTATION
If I understand correctly, the current implementation of -fdefault-real-8 in f18 is incomplete, see here:

} else if (arg == "-r8" || arg == "-fdefault-real-8") {
  defaultKinds.set_defaultRealKind(8);

I think that there should be defaultKinds.set_defaultRealKind(16); as well.

Do you mean set_doublePrecisionKind(16)? Yes, if that's how -fdefault-real-8 is supposed to behave, it should work that way in f18 too.

[arnamoy10]

Added a missing option test for -flarge-sizes

flang/test/Flang-Driver/flarge_sizes.f90

2

Done!

[arnamoy10]

Rebased on main

[awarzynski]

This patch won't build with BUILD_SHARED_LIBS set to On. That's because a new dependency in CompilerInvocation is introduced (on IntrinsicTypeDefaultKinds). This dependency is currently not satisfied in the unit tests. This should fix it:

diff --git a/flang/unittests/Frontend/CMakeLists.txt b/flang/unittests/Frontend/CMakeLists.txt
index 88ec86f49291..a288aa0c99c9 100644
--- a/flang/unittests/Frontend/CMakeLists.txt
+++ b/flang/unittests/Frontend/CMakeLists.txt
@@ -10,4 +10,5 @@ target_link_libraries(FlangFrontendTests
   flangFrontendTool
   FortranParser
   FortranSemantics
+  FortranCommon
 )

I've left a few other comments inline.

clang/include/clang/Driver/Options.td

4307–4314

[nit] I believe that you copied the long version from here. I would instead use the short versions from this:

gcc --help=fortran | grep default
 -Wreturn-type               Warn whenever a function's return type defaults to "int" (C), or about inconsistent return types (C++).
 -fdefault-double-8          Set the default double precision kind to an 8 byte wide type.
 -fdefault-integer-8         Set the default integer kind to an 8 byte wide type.
 -fdefault-real-8            Set the default real kind to an 8 byte wide type.
 -fmodule-private            Set default accessibility of module entities to PRIVATE.
 -fopenacc-dim=              Specify default OpenACC compute dimensions.

flang/test/Flang-Driver/fdefault.f90

54

Fails for f18 as it does not print error here.

flang/test/Flang-Driver/pipeline.f90

1 ↗

(On Diff #327572)

This test will fail with FLANG_BUILD_NEW_DRIVER set to Off (because it should not be run with f18). If you add ! REQUIRES: new-flang-driver then everything will be fine.

Instead of adding that ^^^, could you move it to frontend-forwarding.f90?

[arnamoy10]

Fixing build failures, also moved the pipeline check to an existing file.

[awarzynski]

I tested this with FLANG_BUILD_NEW_DRIVER set to`On` and Off - all works fine. It's been a tricky patch @arnamoy10 , thank you for all the effort!

I believe that you've addressed all of @tskeith comments too. In my opinion this is ready to be merged (though I'd wait 1 day just in case).

clang/include/clang/Driver/Options.td

 defm align_commons : BooleanFFlag<"align-commons">, Group<gfortran_Group>;
 defm all_intrinsics : BooleanFFlag<"all-intrinsics">, Group<gfortran_Group>;
 defm automatic : BooleanFFlag<"automatic">, Group<gfortran_Group>;
 defm backtrace : BooleanFFlag<"backtrace">, Group<gfortran_Group>;
 defm bounds_check : BooleanFFlag<"bounds-check">, Group<gfortran_Group>;
 defm check_array_temporaries : BooleanFFlag<"check-array-temporaries">, Group<gfortran_Group>;
 defm cray_pointer : BooleanFFlag<"cray-pointer">, Group<gfortran_Group>;
 defm d_lines_as_code : BooleanFFlag<"d-lines-as-code">, Group<gfortran_Group>;
 defm d_lines_as_comments : BooleanFFlag<"d-lines-as-comments">, Group<gfortran_Group>;
-defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>;
-defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>;
-defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>;
 defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>;
 defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>;
 defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>;
 defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>;
 defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>;
 defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>;
 defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>;
 defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>;
 defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>;
 defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>;
 defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>;
def ffree_form : Flag<["-"], "ffree-form">, Group<f_Group>,
   HelpText<"Process source files in free form">;
 def ffixed_line_length_EQ : Joined<["-"], "ffixed-line-length=">, Group<f_Group>,
   HelpText<"Use <value> as character line width in fixed mode">,
   DocBrief<[{Set column after which characters are ignored in typical fixed-form lines in the source
 file}]>;
 def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<f_Group>, Alias<ffixed_line_length_EQ>;
 def fopenacc : Flag<["-"], "fopenacc">, Group<f_Group>,
   HelpText<"Enable OpenACC">;
+def fdefault_double_8 : Flag<["-"],"fdefault-double-8">, Group<f_Group>,
+  HelpText<"Set the default double precision kind to an 8 byte wide type">;
+def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group<f_Group>,
+  HelpText<"Set the default integer kind to an 8 byte wide type">;
+def fdefault_real_8 : Flag<["-"],"fdefault-real-8">, Group<f_Group>,
+  HelpText<"Set the default real kind to an 8 byte wide type">;
+def flarge_sizes : Flag<["-"],"flarge-sizes">, Group<f_Group>,
+  HelpText<"Use INTEGER(KIND=8) for the result type in size-related intrinsics">;
 def fbackslash : Flag<["-"], "fbackslash">, Group<f_Group>,
   HelpText<"Specify that backslash in string introduces an escape character">,
   DocBrief<[{Change the interpretation of backslashes in string literals from
 a single backslash character to "C-style" escape characters.}]>;
 def fno_backslash : Flag<["-"], "fno-backslash">, Group<f_Group>;
 def fxor_operator : Flag<["-"], "fxor-operator">, Group<f_Group>,
   HelpText<"Enable .XOR. as a synonym of .NEQV.">;
 def fno_xor_operator : Flag<["-"], "fno-xor-operator">, Group<f_Group>;

 def fdebug_dump_parse_tree : Flag<["-"], "fdebug-dump-parse-tree">, Group<Action_Group>,
   HelpText<"Dump the parse tree">;
 def fdebug_dump_provenance : Flag<["-"], "fdebug-dump-provenance">, Group<Action_Group>,
   HelpText<"Dump provenance">;
 def fdebug_measure_parse_tree : Flag<["-"], "fdebug-measure-parse-tree">, Group<Action_Group>,
   HelpText<"Measure the parse tree">;
 def fdebug_pre_fir_tree : Flag<["-"], "fdebug-pre-fir-tree">, Group<Action_Group>,
   HelpText<"Dump the pre-FIR tree">;
 
 }
 
 //===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 //===----------------------------------------------------------------------===//
 // Target Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 def target_cpu : Separate<["-"], "target-cpu">,

clang/lib/Driver/ToolChains/Flang.cpp

 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 void Flang::AddFortranDialectOptions(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
-  Args.AddAllArgs(CmdArgs,
-                  {options::OPT_ffixed_form, options::OPT_ffree_form,
-                   options::OPT_ffixed_line_length_EQ, options::OPT_fopenmp,
-                   options::OPT_fopenacc, options::OPT_finput_charset_EQ,
-                   options::OPT_fimplicit_none, options::OPT_fno_implicit_none,
-                   options::OPT_fbackslash, options::OPT_fno_backslash,
-                   options::OPT_flogical_abbreviations,
-                   options::OPT_fno_logical_abbreviations,
-                   options::OPT_fxor_operator, options::OPT_fno_xor_operator,
-                   options::OPT_falternative_parameter_statement});
+  Args.AddAllArgs(
+      CmdArgs, {options::OPT_ffixed_form, options::OPT_ffree_form,
+                options::OPT_falternative_parameter_statement,
+                options::OPT_fdefault_real_8, options::OPT_fdefault_integer_8,
+                options::OPT_fdefault_double_8, options::OPT_flarge_sizes});
 }
 
 void Flang::AddPreprocessingOptions(const ArgList &Args,
                                     ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
 }
 
 void Flang::AddOtherOptions(const ArgList &Args, ArgStringList &CmdArgs) const {

flang/include/flang/Frontend/CompilerInvocation.h

 #include "flang/Semantics/semantics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "llvm/Option/ArgList.h"
 #include <memory>
 
 namespace Fortran::frontend {
 
 /// Fill out Opts based on the options given in Args.
 ///
 /// When errors are encountered, return false and, if Diags is non-null,
 /// report the error(s).
 bool ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
     llvm::opt::ArgList &args, bool defaultDiagColor = true);
 
 class CompilerInvocationBase {
 public:
   /// Options controlling the diagnostic engine.
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagnosticOpts_;
   /// Options for the preprocessor.
   std::shared_ptr<Fortran::frontend::PreprocessorOptions> preprocessorOpts_;
 
   CompilerInvocationBase();
class CompilerInvocation : public CompilerInvocationBase {
   // 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_ = ".";
 
+  // Fortran Dialect options
+  Fortran::common::IntrinsicTypeDefaultKinds defaultKinds_;
+
 public:
   CompilerInvocation() = default;
 
   FrontendOptions &frontendOpts() { return frontendOpts_; }
   const FrontendOptions &frontendOpts() const { return frontendOpts_; }
 
   Fortran::parser::Options &fortranOpts() { return parserOpts_; }
   const Fortran::parser::Options &fortranOpts() const { return parserOpts_; }
 
   Fortran::semantics::SemanticsContext &semanticsContext() {
     return *semanticsContext_;
   }
   const Fortran::semantics::SemanticsContext &semanticsContext() const {
     return *semanticsContext_;
   }
 
   std::string &moduleDir() { return moduleDir_; }
   const std::string &moduleDir() const { return moduleDir_; }
 
+  Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds() {
+    return defaultKinds_;
+  }
+  const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds() const {
+    return defaultKinds_;
+  }
+
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
   /// \returns false if an error was encountered while parsing the arguments
   /// \param [out] res - The resulting invocation.
   static bool CreateFromArgs(CompilerInvocation &res,
       llvm::ArrayRef<const char *> commandLineArgs,
       clang::DiagnosticsEngine &diags);
 

flang/lib/Frontend/CompilerInvocation.cpp

if (columns < 0) {
       diags.Report(clang::diag::err_drv_invalid_value_with_suggestion)
           << arg->getOption().getName() << arg->getValue()
           << "value must be at least seven";
     } else {
       opts.fixedFormColumns_ = columns;
     }
   }
 
-  // Extensions
-  if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
-    opts.features_.Enable(Fortran::common::LanguageFeature::OpenACC);
-  }
-  if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
-    opts.features_.Enable(Fortran::common::LanguageFeature::OpenMP);
-  }
   if (const llvm::opt::Arg *arg =
           args.getLastArg(clang::driver::options::OPT_fimplicit_none,
               clang::driver::options::OPT_fno_implicit_none)) {
     opts.features_.Enable(
         Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
         arg->getOption().matches(clang::driver::options::OPT_fimplicit_none));
   }
   if (const llvm::opt::Arg *arg =
const unsigned diagID =
         diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
             "Only one '-module-dir/-J' option allowed");
     diags.Report(diagID);
   }
   if (moduleDirList.size() == 1)
     moduleDir = moduleDirList[0];
 }
 
+/// Parses all Dialect related arguments and populates the variables
+/// options accordingly.
+static void parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
+    clang::DiagnosticsEngine &diags) {
+
+  // -fdefault* family
+  if (args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
+    res.defaultKinds().set_defaultRealKind(8);
+    res.defaultKinds().set_doublePrecisionKind(16);
+  }
+  if (args.hasArg(clang::driver::options::OPT_fdefault_integer_8)) {
+    res.defaultKinds().set_defaultIntegerKind(8);
+    res.defaultKinds().set_subscriptIntegerKind(8);
+    res.defaultKinds().set_sizeIntegerKind(8);
+  }
+  if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
+    if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
+      // -fdefault-double-8 has to be used with -fdefault-real-8
+      // to be compatible with gfortran
+      const unsigned diagID =
+          diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
+              "Use of `-fdefault-double-8` requires `-fdefault-real-8`");
+      diags.Report(diagID);
+    }
+    // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
+    res.defaultKinds().set_doublePrecisionKind(8);
+  }
+  if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
+    res.defaultKinds().set_sizeIntegerKind(8);
+
+  // -fopenmp and -fopenacc
+  if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
+    res.frontendOpts().features_.Enable(
+        Fortran::common::LanguageFeature::OpenACC);
+  }
+  if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
+    res.frontendOpts().features_.Enable(
+        Fortran::common::LanguageFeature::OpenMP);
+  }
+  return;
+}
+
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
     llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
 
   // Parse the arguments
   const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable();
bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
   }
 
   // Parse the frontend args
   ParseFrontendArgs(res.frontendOpts(), args, diags);
   // Parse the preprocessor args
   parsePreprocessorArgs(res.preprocessorOpts(), args);
   // Parse semantic args
   parseSemaArgs(res.moduleDir(), args, diags);
+  // Parse dialect arguments
+  parseDialectArgs(res, args, diags);
 
   return success;
 }
 
 /// Collect the macro definitions provided by the given preprocessor
 /// options into the parser options.
 ///
 /// \param [in] ppOpts The preprocessor options
if (moduleDirJ.compare(".") != 0)
     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
 }
 
 void CompilerInvocation::setSemanticsOpts(
     Fortran::parser::AllCookedSources &allCookedSources) {
   const auto &fortranOptions = fortranOpts();
 
   semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
-      *(new Fortran::common::IntrinsicTypeDefaultKinds()),
-      fortranOptions.features, allCookedSources);
+      defaultKinds(), fortranOptions.features, allCookedSources);
 
   auto &moduleDirJ = moduleDir();
   semanticsContext_->set_moduleDirectory(moduleDirJ)
       .set_searchDirectories(fortranOptions.searchDirectories);
 }

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

 ! CHECK-NEXT: -###      Print (but do not run) the commands to run for this compilation
 ! CHECK-NEXT: -c        Only run preprocess, compile, and assemble steps
 ! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! CHECK-NEXT: -E        Only run the preprocessor
 ! CHECK-NEXT: -falternative-parameter-statement
 ! CHECK-NEXT: Enable the old style PARAMETER statement
 ! CHECK-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
 ! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! 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: -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: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! CHECK-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! CHECK-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! CHECK-NEXT: -fopenacc              Enable OpenACC
 ! CHECK-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! CHECK-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! CHECK-NEXT: -module-dir <dir>      Put MODULE files in <dir>

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

 ! HELP-NEXT: -###                   Print (but do not run) the commands to run for this compilation
 ! HELP-NEXT: -c                     Only run preprocess, compile, and assemble steps
 ! HELP-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-NEXT: -E                     Only run the preprocessor
 ! HELP-NEXT: -falternative-parameter-statement
 ! HELP-NEXT: Enable the old style PARAMETER statement
 ! HELP-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
 ! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! 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: -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: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! HELP-NEXT: -fopenacc              Enable OpenACC
 ! HELP-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-NEXT: -help                  Display available options
 ! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-NEXT: -module-dir <dir>      Put MODULE files in <dir>

 ! HELP-FC1-NEXT: -fdebug-dump-provenance Dump provenance
 ! HELP-FC1-NEXT: -fdebug-dump-symbols    Dump symbols after the semantic analysis
 ! HELP-FC1-NEXT: -fdebug-measure-parse-tree
 ! HELP-FC1-NEXT:                         Measure the parse tree
 ! HELP-FC1-NEXT: -fdebug-pre-fir-tree    Dump the pre-FIR tree
 ! 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: -ffree-form            Process source files in free form
 ! 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: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-FC1-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
 ! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -test-io               Run the InputOuputTest action. Use for development and testing only.
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Flang-Driver/fdefault.f90

+! Ensure argument -fdefault* work as expected.
+! TODO: Add checks when actual codegen is possible for this family
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOOPTION
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -fdefault-real-8 -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=REAL8
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -fdefault-real-8 -fdefault-double-8 -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=DOUBLE8
+! RUN: not %flang -fsyntax-only -fdefault-double-8 %s  2>&1 | FileCheck %s --check-prefix=ERROR
+
+!-----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!-----------------------------------------
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOOPTION
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -fdefault-real-8 -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=REAL8
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -fdefault-real-8 -fdefault-double-8 -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=DOUBLE8
+! RUN: not %flang_fc1 -fsyntax-only -fdefault-double-8 %s  2>&1 | FileCheck %s --check-prefix=ERROR
+
+!-----------------------------------------
+! EXPECTED OUTPUT FOR NO SPECIFICATION
+!-----------------------------------------
+! NOOPTION: integer(4),parameter::real_kind=4_4
+! NOOPTION-NEXT: intrinsic::kind
+! NOOPTION-NEXT: integer(4),parameter::double_kind=8_4
+
+!-------------------------------------------
+! EXPECTED OUTPUT FOR ONLY -fdefault-real-8
+!-------------------------------------------
+! REAL8: integer(4),parameter::real_kind=8_4
+! REAL8-NEXT: intrinsic::kind
+! REAL8-NEXT: integer(4),parameter::double_kind=16_4
+
+!-------------------------------------------------------------
+! EXPECTED OUTPUT FOR -fdefault-real-8 AND -fdefault-double-8
+!-------------------------------------------------------------
+! DOUBLE8: integer(4),parameter::real_kind=8_4
+! DOUBLE8-NEXT: intrinsic::kind
+! DOUBLE8-NEXT: integer(4),parameter::double_kind=8_4
+
+!------------------------------------------------------
+! EXPECTED OUTPUT FOR PROVIDING ONLY -fdefault-double-8
+!------------------------------------------------------
+! ERROR: Use of `-fdefault-double-8` requires `-fdefault-real-8`
+
+module m
+  implicit none
+  real :: x
+  double precision :: y
+  integer, parameter :: real_kind = kind(x)            !-fdefault-real-8
+  integer, parameter :: double_kind = kind(y)          !-fdefault-double-8
+end

flang/test/Flang-Driver/flarge_sizes.f90

+! Ensure argument -flarge-sizes works as expected.
+! TODO: Add checks when actual codegen is possible.
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOLARGE
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang -fsyntax-only -flarge-sizes -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=LARGE
+
+!-----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!-----------------------------------------
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=NOLARGE
+! RUN: rm -rf %t/dir-flang-new  && mkdir -p %t/dir-flang-new && %flang_fc1 -fsyntax-only -flarge-sizes -module-dir %t/dir-flang-new %s  2>&1
+! RUN: cat %t/dir-flang-new/m.mod | FileCheck %s --check-prefix=LARGE
+
+!-----------------------------------------
+! EXPECTED OUTPUT WITHOUT -flarge-sizes
+!-----------------------------------------
+! NOLARGE: real(4)::z(1_8:10_8)
+! NOLARGE-NEXT: integer(4),parameter::size_kind=4_4
+
+!-----------------------------------------
+! EXPECTED OUTPUT FOR -flarge-sizes
+!-----------------------------------------
+! LARGE: real(4)::z(1_8:10_8)
+! LARGE-NEXT: integer(4),parameter::size_kind=8_4
+
+module m
+  implicit none
+  real :: z(10)
+  integer, parameter :: size_kind = kind(ubound(z, 1)) !-flarge-sizes
+end

flang/test/Flang-Driver/frontend-forwarding.f90

 ! Test that flang-new forwards Flang frontend
 ! options to flang-new -fc1 as expected.
 
 ! REQUIRES: new-flang-driver
 
 ! RUN: %flang-new -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:   | FileCheck %s
 
 ! CHECK: "-finput-charset=utf-8"
+! CHECK: "-fdefault-double-8"
+! CHECK: "-fdefault-integer-8"
+! CHECK: "-fdefault-real-8"
+! CHECK: "-flarge-sizes"

flang/unittests/Frontend/CMakeLists.txt

 add_flang_unittest(FlangFrontendTests
   CompilerInstanceTest.cpp
   FrontendActionTest.cpp
 )
 
 target_link_libraries(FlangFrontendTests
   PRIVATE
   clangBasic
   flangFrontend
   flangFrontendTool
   FortranParser
   FortranSemantics
+  FortranCommon
 )