[flang][driver] Add -fdebug-module-writer option

[arnamoy10]

Summary

Add support for the following f18 options:

• -fdebug-module-writer

We also add a new Setter for the -J/module-dir option.

[tskeith]

flang/lib/Frontend/CompilerInvocation.cpp

234

In my opinion, using mutable references like this make the code hard to understand. Setters on CompilerInvocation would be clearer.

flang/test/Semantics/mod-file-rewriter.f90

9

Why do you need to duplicate these lines? Doesn't it work to use %flang?

[arnamoy10]

Added some setters to work with.

Modified the test case to include flang-new -fc1 as well.

flang/test/Semantics/mod-file-rewriter.f90

9

%flang will unfortunately invoke f18 currently.

[awarzynski]

Thank you for submitting this @arnamoy10 ! Comments inline.

clang/include/clang/Driver/Options.td

4232–4233

IMO this should be a frontend-only option. Compiler end-users are unlikely to need this in their regular workflows, right? I recommend moving it here.

flang/test/Semantics/mod-file-rewriter.f90

9

That depends on the value of FLANG_BUILD_NEW_DRIVER, which is translated into include_flang_new_driver_test here. I also think that this should work fine with %flang.

Also, I suggest that we only have tests with flang_fc1 and keep this as a frontend-only option.

[arnamoy10]

clang/include/clang/Driver/Options.td

4232–4233

Yes, it makes sense to keep it as frontend-only option, let me submit an updated patch.

flang/test/Semantics/mod-file-rewriter.f90

9

Sounds good.

[arnamoy10]

Set the option as a frontend-only option, also modified the test case accordingly.

[awarzynski]

clang/include/clang/Driver/Options.td

4224–4225

[nit] The convention here seems to be: no . at the end
[nit] Perhaps a bit shorter: Enable debug messages while writhing module files?

flang/include/flang/Frontend/CompilerInvocation.h

73–74

[nit] One empty line instead of 2

flang/lib/Frontend/CompilerInvocation.cpp

232–233

Unrelated change

[arnamoy10]

Minor changes as per comments, also updated commit message to include description of changes related to Setters.

[awarzynski]

LGTM, thank you!

(I believe that you've addressed all of Tim's comments too, but please wait a bit before merging in case I missed something)

[arnamoy10]

OK, I will merge it on Monday unless @tskeith has any other comments.

clang/include/clang/Driver/Options.td

4232–4233

IMO this should be a frontend-only option. Compiler end-users are unlikely to need this in their regular workflows, right? I recommend moving it here.

[tskeith]

LGTM

[arnamoy10]

Rebasing on main

[arnamoy10]

This has been merged, closing it.

[arnamoy10]

Abandon

clang/include/clang/Driver/Options.td

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 DOUBLE PRECISION type and double real constants like 1.d0 to an 8 byte wide type.">;
 def fdefault_integer_8 : Flag<["-"],"fdefault-integer-8">, Group<f_Group>, 
   HelpText<"Set the default integer and logical types to an 8 byte wide type.">;
 def fdefault_real_8 : Flag<["-"],"fdefault-real-8">, Group<f_Group>, 
   HelpText<"Set the default real type 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 fdebug_module_writer : Flag<["-"],"fdebug-module-writer">, Group<f_Group>, 
+  HelpText<"Enables showing debug messages while writing module files.">;
 }
 
 //===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {
 

clang/lib/Driver/ToolChains/Flang.cpp

 }
 
 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 {
-  Args.AddAllArgs(CmdArgs, options::OPT_module_dir);
+  Args.AddAllArgs(CmdArgs, {options::OPT_module_dir,options::OPT_fdebug_module_writer});
 }
 
 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();
   // TODO: Once code-generation is available, this will need to be commented
   // out.

flang/include/flang/Frontend/CompilerInvocation.h

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_ = ".";
 
+  bool debugModuleDir_ = false;
+
   // 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_; }
 
+  bool &debugModuleDir() { return debugModuleDir_; }
+  const bool &debugModuleDir() const { return debugModuleDir_; }
+
   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);
 
+  /// Useful setters
+  void SetModuleDir(std::string &moduleDir) {
+      moduleDir_ = moduleDir;
+  }
+
+  void SetDebugModuleDir(bool flag) {
+      debugModuleDir_ = flag;
+  }
+
   /// Set the Fortran options to predifined defaults. These defaults are
   /// consistend with f18/f18.cpp.
   // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
   // need to extend frontendOpts_ first. Next, we need to add the corresponding
   // compiler driver options in libclangDriver.
   void SetDefaultFortranOpts();
 
   /// Set the default predefinitions.

flang/lib/Frontend/CompilerInvocation.cpp

static void parsePreprocessorArgs(
 
   // Add the ordered list of -I's.
   for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I))
     opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
 }
 
 /// Parses all semantic related arguments and populates the variables
 /// options accordingly.
-static void parseSemaArgs(std::string &moduleDir, llvm::opt::ArgList &args,
+static void parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
     clang::DiagnosticsEngine &diags) {
 
+  // -J/module-dir option
   auto moduleDirList =
       args.getAllArgValues(clang::driver::options::OPT_module_dir);
   // User can only specify -J/-module-dir once
   // https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html
   if (moduleDirList.size() > 1) {
     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];
+    res.SetModuleDir(moduleDirList[0]);
+
+  // -fdebug-module-writer option
+  if (args.hasArg(clang::driver::options::OPT_fdebug_module_writer)) {
+    res.SetDebugModuleDir(true);
+  }
 }
 
 /// 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
for (const auto *a : args.filtered(clang::driver::options::OPT_UNKNOWN)) {
     success = false;
   }
 
   // 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);
+  parseSemaArgs(res, 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.

 
 void CompilerInvocation::setSemanticsOpts(
     Fortran::parser::AllCookedSources &allCookedSources) {
   const auto &fortranOptions = fortranOpts();
 
   semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
       defaultKinds(), fortranOptions.features, allCookedSources);
 
-  auto &moduleDirJ = moduleDir();
-  semanticsContext_->set_moduleDirectory(moduleDirJ)
+  semanticsContext_->set_moduleDirectory(moduleDir())
       .set_searchDirectories(fortranOptions.searchDirectories);
 }

flang/lib/Frontend/FrontendActions.cpp

void ParseSyntaxOnlyAction::ExecuteAction() {
 
   // Report the diagnostics from parsing
   ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
 
   auto &parseTree{*ci.parsing().parseTree()};
 
   // Prepare semantics
   Fortran::semantics::Semantics semantics{ci.invocation().semanticsContext(),
-      parseTree, ci.parsing().cooked().AsCharBlock()};
+      parseTree, ci.parsing().cooked().AsCharBlock(),ci.invocation().debugModuleDir()};
 
   // Run semantic checks
   semantics.Perform();
 
   // Report the diagnostics from the semantic checks
   semantics.EmitMessages(ci.semaOutputStream());
 
   if (semantics.AnyFatalError()) {

flang/test/Semantics/mod-file-rewriter.f90

 ! RUN: rm -fr %t && mkdir %t && cd %t
 ! RUN: %f18 -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
 ! RUN: %f18 -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
 ! RUN: %f18 -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-unchanged.f90 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
 ! RUN: %f18 -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-changed.f90 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %flang-new -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %flang-new -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %flang-new -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-unchanged.f90 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %flang-new -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-changed.f90 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %flang-new -fc1 -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
+! RUN: %flang-new -fc1 -fsyntax-only -fdebug-module-writer %s 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %flang-new -fc1 -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-unchanged.f90 2>&1 | FileCheck %s --check-prefix CHECK_UNCHANGED
+! RUN: %flang-new -fc1 -fsyntax-only -fdebug-module-writer %p/Inputs/mod-file-changed.f90 2>&1 | FileCheck %s --check-prefix CHECK_CHANGED
 
 module m
   real :: x(10)
 end module m
 
 ! CHECK_CHANGED: Processing module {{.*}}.mod: module written
 ! CHECK_UNCHANGED: Processing module {{.*}}.mod: module unchanged, not writing