[Flang] Add debug flag to enable current debug information pass

[SBallantyne]

Summary

While a pass exists to generate basic debug information, currently there is not a corresponding flag to enable it.
This patch adds support for activating this pass at any debug level >= -g1, as well as emiting a warning for higher levels that the functionality is not yet fully implemented.

This patch also adds -g and -gline-tables-only to appear when flang-new --help is run

Depends on D142347.

[kiranchandramohan]

flang/include/flang/Frontend/CodeGenOptions.h

18

The following patch might be useful to avoid adding the clang header. Could you try it locally and see whether it works? If so you can either commandeer the following patch or alternatively include the following patch as part of the current one.
https://reviews.llvm.org/D142347

[tblah]

Thanks for adding this flag.

Please could you add a test checking that the pass is actually run when the flag is given. For example, see the tests on this patch https://reviews.llvm.org/D146278

flang/include/flang/Tools/CLOptions.inc

21

nit: clang is conceptually "above" LLVM in the dependency hierarchy:

https://llvm.org/docs/CodingStandards.html#include-style

LLVM project and subproject headers should be grouped from most specific to least specific, for the same reasons described above. For example, LLDB depends on both clang and LLVM, and clang depends on LLVM. So an LLDB source file should include lldb headers first, followed by clang headers, followed by llvm headers, to reduce the possibility (for example) of an LLDB header accidentally picking up a missing include due to the previous inclusion of that header in the main source file or some earlier header file.

flang/lib/Frontend/FrontendActions.cpp

58

nit: is this include required?

[awarzynski]

Thanks for submitting this! Please add tests for -g and all variants of -gline-tables-only.

[SBallantyne]

Add dependence on D142347 and update references to clang::codegenoptions to llvm::codegenoptions

[SBallantyne]

Attempt 2 to add previous work as stacked patch

[SBallantyne]

Add test to check that debug pass is run and not run with appropriate flags

[SBallantyne]

Update tests to check for warning at higher debug levels, as well as amend warning message

[awarzynski]

What's the overall design goal here? 100% consistency with Clang? Could this be documented?

clang/include/clang/Driver/ToolChain.h

23 ↗

(On Diff #508552)

Unrelated change?

clang/lib/Driver/ToolChains/Clang.h

16 ↗

(On Diff #508552)

Unrelated change?

clang/lib/Driver/ToolChains/Flang.cpp

33

Looks identical to https://github.com/llvm/llvm-project/blob/cf60d3f1a688671c8eb7859bf0572c403c3c0cca/clang/lib/Driver/ToolChains/Clang.cpp#L406-L420. Why not move to https://github.com/llvm/llvm-project/blob/main/clang/lib/Driver/ToolChains/CommonArgs.cpp?

flang/lib/Frontend/CompilerInvocation.cpp

127

1. Why unsigned instead of DebugInfoKind
2. Why not use std::optional, e.g. llvm::StringSwitch<std::optional<DebugInfoKind>>arg->getValue())? This way you could avoid magic numbers like ~0U.

137

Please test this diagnostic. Also, if this is an error then you should return immediately and signal that this method has failed (e.g. return false;).

144

Please improve it :)

In particular, you are testing for DebugLineTablesOnly and NoDebugInfo, yet the diagnostic refers to -g1.

145

Looks like you are creating a warning rather than an error: debugErr --> debugWarn

[SBallantyne]

Add test for invalid debug-info-kind and address other review comments

[SBallantyne]

In D146814#4223967, @awarzynski wrote:

What's the overall design goal here? 100% consistency with Clang? Could this be documented?

The goal of this patch is just to enable the current debug pass with an appropriate flag, and ensure that its fairly easy to expand this should more passes/work be done for flang. I've chosen to just copy the majority of the clang debug system on the assumption flang will follow the same path, but i don't think that is explicitly planned or the only way forwards.

clang/include/clang/Driver/ToolChain.h

23 ↗

(On Diff #508552)

Accidental include from D142347, I've removed it there so it shouldn't have to be removed here.

flang/lib/Frontend/CompilerInvocation.cpp

127

Sure i'm happy to implement that here. This code originally comes from the clang frontend

144

I previously had it emit these debug names, but i think its more confusing for the user as they will be passing -g2 / -g3 in order to get this error, and the internal name is not as helpful. The TODO was from a previous patch and i just forgot to remove it, i am happy with the current state of warning.

[awarzynski]

Thanks for the updates! A few more pointers, but nothing major.

Btw, are there any tests that check for debug info in the compiled files? For example:

! RUN: flang -g1 -S %s | FileCheck -check-prefixes=DEBUG-INFO-PRESENT
! RUN: flang -g0 -S %s | FileCheck -check-prefixes=DEBUG-INFO-MISSING

end program

clang/lib/Driver/ToolChains/Flang.cpp

32

There isn't anything Fortran specific here, is there? And this method basically implements https://github.com/llvm/llvm-project/blob/cf60d3f1a688671c8eb7859bf0572c403c3c0cca/clang/lib/Driver/ToolChains/Clang.cpp#L975-L1000, right? Why not extract it into e.g. renderDebugEnablingArgs and move to CommonArgs.cpp?

flang/lib/Frontend/CompilerInvocation.cpp

144

Thanks for the explanation! My main reservation is that it's not obvious how -g2 and -g3 map onto llvm::codegenoptions. This warnings refers to -g1, but there's no mention of -g1 in this function.

TBH, I would replace "Debug options greater than -g1 not yet implemented" with something a bit more generic and future-proof, e.g. "Unsupported debug option: %0" << arg.getValue()

864

WDYT? I think that it makes sense to keep these separate.

[SBallantyne]

Add common function addDebugKindInfo, update warning message

[awarzynski]

LGTM, thanks for working on this! (please fix the name in CommonArgs.h before landing this)

It would be great to see a test that checks for debug info in the generated FIR/MLIR/LLVM-IR/ASM file. But that could happen in a separate patch.

clang/lib/Driver/ToolChains/CommonArgs.h

111 ↗

(On Diff #508949)

CamelCase or camelCase? ;-)

[SBallantyne]

Fix case issue. As for tests for debug information being generated, these are already covered by various tests in flang/tests/Transforms, namely debug-line-table.fir, debug-line-table-existing.fir etc.
While the tests are invoked through fir-opt instead of a flang flag, it is the same pass that is verified to be run in the tests added so is covered.

[awarzynski]

Thanks for the explanation! Still looking good apart from the function names ;)

clang/lib/Driver/ToolChains/CommonArgs.h

111 ↗

(On Diff #508949)

Sorry, I meant that this function uses wrong casing. It ought to be debugLevelToInfoKind and addDebugInfoKind: https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

[SBallantyne]

clang/lib/Driver/ToolChains/CommonArgs.h

111 ↗

(On Diff #508949)

I thought that the general rule was that the style guide should be followed apart from when there is already code in a particular style in a file, however i have realised that while most functions in this file are CamelCase, there are some that are camelCase, so i am unsure of what is the right way.

[awarzynski]

clang/lib/Driver/ToolChains/CommonArgs.h

111 ↗

(On Diff #508949)

Yes, it's very confusing :(

You are right about the official guidelines (at least that's how I understand them). In this case the style used in this file is inconsistent so you can't follow that (i.e. because there are multiple styles used here). In situations like this I would follow the official style guideline instead.

[SBallantyne]

Update style to mach style guidelines

clang/lib/Driver/ToolChains/CommonArgs.h

111 ↗

(On Diff #508949)

Sounds reasonable, I've changed it to follow style guideline instead.

[SBallantyne]

Clang format

clang/include/clang/Driver/Options.td

 def femit_dwarf_unwind_EQ : Joined<["-"], "femit-dwarf-unwind=">,
   Group<f_Group>, Flags<[CC1Option, CC1AsOption]>,
   HelpText<"When to emit DWARF unwind (EH frame) info">,
   Values<"always,no-compact-unwind,default">,
   NormalizedValues<["Always", "NoCompactUnwind", "Default"]>,
   NormalizedValuesScope<"llvm::EmitDwarfUnwindType">,
   MarshallingInfoEnum<CodeGenOpts<"EmitDwarfUnwind">, "Default">;
 def g_Flag : Flag<["-"], "g">, Group<g_Group>,
-  HelpText<"Generate source-level debug information">;
+    Flags<[CoreOption,FlangOption]>, HelpText<"Generate source-level debug information">;
 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
-  Flags<[CoreOption]>, HelpText<"Emit debug line number tables only">;
+  Flags<[CoreOption,FlangOption]>, HelpText<"Emit debug line number tables only">;
 def gline_directives_only : Flag<["-"], "gline-directives-only">, Group<gN_Group>,
   Flags<[CoreOption]>, HelpText<"Emit debug line info directives only">;
 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
 def g0 : Flag<["-"], "g0">, Group<gN_Group>;
 def g1 : Flag<["-"], "g1">, Group<gN_Group>, Alias<gline_tables_only>;
 def g2 : Flag<["-"], "g2">, Group<gN_Group>;
 def g3 : Flag<["-"], "g3">, Group<gN_Group>;
 def ggdb : Flag<["-"], "ggdb">, Group<gTune_Group>;

 
 let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption] in {
 
 def mrelocation_model : Separate<["-"], "mrelocation-model">,
   HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
   NormalizedValuesScope<"llvm::Reloc">,
   NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
   MarshallingInfoEnum<CodeGenOpts<"RelocationModel">, "PIC_">;
+def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">;
 
 } // let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption]
 
 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
-def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">;
 def debug_info_macro : Flag<["-"], "debug-info-macro">,
   HelpText<"Emit macro debug information">,
   MarshallingInfoFlag<CodeGenOpts<"MacroDebugInfo">>;
 def default_function_attr : Separate<["-"], "default-function-attr">,
   HelpText<"Apply given attribute to all functions">,
   MarshallingInfoStringVector<CodeGenOpts<"DefaultFunctionAttrs">>;
 def dwarf_version_EQ : Joined<["-"], "dwarf-version=">,
   MarshallingInfoInt<CodeGenOpts<"DwarfVersion">>;

clang/lib/Driver/ToolChains/Flang.cpp

 //===-- Flang.cpp - Flang+LLVM ToolChain Implementations --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "Flang.h"
 #include "CommonArgs.h"
 
+#include "clang/Basic/DebugInfoOptions.h"
 #include "clang/Driver/Options.h"
 
 #include <cassert>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 /// Add -x lang to \p CmdArgs for \p Input.
 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
                              ArgStringList &CmdArgs) {
   CmdArgs.push_back("-x");
   // Map the driver type to the frontend type.
   CmdArgs.push_back(types::getTypeName(Input.getType()));
 }
 
+// Convert an arg of the form "-gN" or one of their aliases
+// to the corresponding DebugInfoKind.
+static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A) {
+  assert(A.getOption().matches(options::OPT_gN_Group) &&
+         "Not a -g option that specifies a debug-info level");
+  if (A.getOption().matches(options::OPT_g0) ||
+      A.getOption().matches(options::OPT_ggdb0))
+    return codegenoptions::NoDebugInfo;
+  if (A.getOption().matches(options::OPT_gline_tables_only) ||
+      A.getOption().matches(options::OPT_ggdb1))
+    return codegenoptions::DebugLineTablesOnly;
+  if (A.getOption().matches(options::OPT_gline_directives_only))
+    return codegenoptions::DebugDirectivesOnly;
+  return codegenoptions::DebugInfoConstructor;
+}
+
+static void
+addFortranDebugOptions(ArgStringList &CmdArgs,
+                       codegenoptions::DebugInfoKind DebugInfoKind) {
+  switch (DebugInfoKind) {
+  case codegenoptions::DebugDirectivesOnly:
+    CmdArgs.push_back("-debug-info-kind=line-directives-only");
+    break;
+  case codegenoptions::DebugLineTablesOnly:
+    CmdArgs.push_back("-debug-info-kind=line-tables-only");
+    break;
+  case codegenoptions::DebugInfoConstructor:
+    CmdArgs.push_back("-debug-info-kind=constructor");
+    break;
+  case codegenoptions::LimitedDebugInfo:
+    CmdArgs.push_back("-debug-info-kind=limited");
+    break;
+  case codegenoptions::FullDebugInfo:
+    CmdArgs.push_back("-debug-info-kind=standalone");
+    break;
+  case codegenoptions::UnusedTypeInfo:
+    CmdArgs.push_back("-debug-info-kind=unused-types");
+    break;
+  default:
+    break;
+  }
+}
+
 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,
Arg *stackArrays =
       Args.getLastArg(options::OPT_Ofast, options::OPT_fstack_arrays,
                       options::OPT_fno_stack_arrays);
   if (stackArrays &&
       !stackArrays->getOption().matches(options::OPT_fno_stack_arrays))
     CmdArgs.push_back("-fstack-arrays");
 
   if (Args.hasArg(options::OPT_flang_experimental_hlfir))
     CmdArgs.push_back("-flang-experimental-hlfir");
+
+  codegenoptions::DebugInfoKind DebugInfoKind;
+  if (Args.hasArg(options::OPT_gN_Group)) {
+    Arg *gNArg = Args.getLastArg(options::OPT_gN_Group);
+    DebugInfoKind = DebugLevelToInfoKind(*gNArg);
+  } else if (Args.hasArg(options::OPT_g_Flag)) {
+    DebugInfoKind = codegenoptions::DebugLineTablesOnly;
+  } else {
+    DebugInfoKind = codegenoptions::NoDebugInfo;
+  }
+  addFortranDebugOptions(CmdArgs, DebugInfoKind);
 }
 
 void Flang::addPicOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
   // ParsePICArgs parses -fPIC/-fPIE and their variants and returns a tuple of
   // (RelocationModel, PICLevel, IsPIE).
   llvm::Reloc::Model RelocationModel;
   unsigned PICLevel;
   bool IsPIE;

flang/include/flang/Frontend/CodeGenOptions.h

 //  configuration for LLVM's middle-end and back-end. It controls LLVM's code
 //  generation into assembly or machine code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_CODEGENOPTIONS_H
 #define LLVM_CLANG_BASIC_CODEGENOPTIONS_H
 
+#include "clang/Basic/DebugInfoOptions.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>

flang/include/flang/Frontend/CodeGenOptions.def

 CODEGENOPT(PrepareForFullLTO , 1, 0) ///< Set when -flto is enabled on the
                                      ///< compile step.
 CODEGENOPT(PrepareForThinLTO , 1, 0) ///< Set when -flto=thin is enabled on the
                                      ///< compile step.
 CODEGENOPT(StackArrays, 1, 0) ///< -fstack-arrays (enable the stack-arrays pass)
 
 CODEGENOPT(Underscoring, 1, 1)
 ENUM_CODEGENOPT(RelocationModel, llvm::Reloc::Model, 3, llvm::Reloc::PIC_) ///< Name of the relocation model to use.
+ENUM_CODEGENOPT(DebugInfo,  clang::codegenoptions::DebugInfoKind, 4,  clang::codegenoptions::NoDebugInfo) ///< Level of debug info to generate
 
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT

flang/include/flang/Tools/CLOptions.inc

 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/HLFIR/Passes.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CommandLine.h"
+#include <clang/Basic/DebugInfoOptions.h>
 
 #define DisableOption(DOName, DOOption, DODescription) \
   static llvm::cl::opt<bool> disable##DOName("disable-" DOOption, \
       llvm::cl::desc("disable " DODescription " pass"), llvm::cl::init(false), \
       llvm::cl::Hidden)
 
 /// Shared option in tools to control whether dynamically sized array
 /// allocations should always be on the heap.
llvm::cl::desc("ignore failures to find derived type descriptors when "
                    "translating FIR to LLVM"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
 namespace {
 /// Default optimization level used to create Flang pass pipeline is O0.
 const static llvm::OptimizationLevel &defaultOptLevel{
     llvm::OptimizationLevel::O0};
 
+const static clang::codegenoptions::DebugInfoKind &NoDebugInfo{
+    clang::codegenoptions::NoDebugInfo};
+
 /// Optimizer Passes
 DisableOption(CfgConversion, "cfg-conversion", "disable FIR to CFG pass");
 DisableOption(FirAvc, "avc", "array value copy analysis and transformation");
 DisableOption(
     FirMao, "memory-allocation-opt", "memory allocation optimization");
 
 /// CodeGen Passes
 #if !defined(FLANG_EXCLUDE_CODEGEN)
inline void createHLFIRToFIRPassPipeline(
   if (optLevel.isOptimizingForSpeed())
     pm.addPass(mlir::createCanonicalizerPass());
   pm.addPass(hlfir::createLowerHLFIRIntrinsicsPass());
   pm.addPass(hlfir::createBufferizeHLFIRPass());
   pm.addPass(hlfir::createConvertHLFIRtoFIRPass());
 }
 
 #if !defined(FLANG_EXCLUDE_CODEGEN)
+inline void createDebugPasses(
+    mlir::PassManager &pm, clang::codegenoptions::DebugInfoKind debugLevel) {
+  // Currently only -g1, -g, -gline-tables-only supported
+  switch(debugLevel) {
+    case clang::codegenoptions::DebugLineTablesOnly:
+      addDebugFoundationPass(pm);
+      return;
+    case clang::codegenoptions::NoDebugInfo:
+      return;
+    default:
+      // TODO: Add cases and passes for other debug options.
+      // All other debug options not implemented yet, currently emits warning
+      // and generates as much debug information as possible.
+      addDebugFoundationPass(pm);
+      return;
+  }
+}
+
 inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm,
     llvm::OptimizationLevel optLevel = defaultOptLevel,
-    bool underscoring = true) {
+    bool underscoring = true,
+    clang::codegenoptions::DebugInfoKind debugInfo = NoDebugInfo) {
   fir::addBoxedProcedurePass(pm);
   pm.addNestedPass<mlir::func::FuncOp>(
       fir::createAbstractResultOnFuncOptPass());
   pm.addNestedPass<fir::GlobalOp>(fir::createAbstractResultOnGlobalOptPass());
   fir::addCodeGenRewritePass(pm);
   fir::addTargetRewritePass(pm);
   fir::addExternalNameConversionPass(pm, underscoring);
+  fir::createDebugPasses(pm, debugInfo);
   fir::addFIRToLLVMPass(pm, optLevel);
 }
 
 /// Create a pass pipeline for lowering from MLIR to LLVM IR
 ///
 /// \param pm - MLIR pass manager that will hold the pipeline definition
 /// \param optLevel - optimization level used for creating FIR optimization
 ///   passes pipeline
 inline void createMLIRToLLVMPassPipeline(mlir::PassManager &pm,
     llvm::OptimizationLevel optLevel = defaultOptLevel,
-    bool stackArrays = false, bool underscoring = true) {
+    bool stackArrays = false, bool underscoring = true,
+    clang::codegenoptions::DebugInfoKind debugInfo = NoDebugInfo) {
   fir::createHLFIRToFIRPassPipeline(pm, optLevel);
 
   // Add default optimizer pass pipeline.
   fir::createDefaultFIROptimizerPassPipeline(pm, optLevel, stackArrays);
 
   // Add codegen pass pipeline.
-  fir::createDefaultFIRCodeGenPassPipeline(pm, optLevel, underscoring);
+  fir::createDefaultFIRCodeGenPassPipeline(pm, optLevel, underscoring, debugInfo);
 }
 #undef FLANG_EXCLUDE_CODEGEN
 #endif
 
 } // namespace fir

flang/lib/Frontend/CompilerInvocation.cpp

 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/Triple.h"
+#include <clang/Basic/DebugInfoOptions.h>
 #include <memory>
 #include <optional>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
 // Initialization.
 //===----------------------------------------------------------------------===//

 
 bool Fortran::frontend::parseDiagnosticArgs(clang::DiagnosticOptions &opts,
                                             llvm::opt::ArgList &args) {
   opts.ShowColors = parseShowColorsArgs(args);
 
   return true;
 }
 
+static void parseDebugArgs(Fortran::frontend::CodeGenOptions &opts,
+                           llvm::opt::ArgList &args,
+                           clang::DiagnosticsEngine &diags) {
+  if (llvm::opt::Arg *arg =
+          args.getLastArg(clang::driver::options::OPT_debug_info_kind_EQ)) {
+    unsigned val =
+        llvm::StringSwitch<unsigned>(arg->getValue())
+            .Case("line-tables-only",
+                  clang::codegenoptions::DebugLineTablesOnly)
+            .Case("line-directives-only",
+                  clang::codegenoptions::DebugDirectivesOnly)
+            .Case("constructor", clang::codegenoptions::DebugInfoConstructor)
+            .Case("limited", clang::codegenoptions::LimitedDebugInfo)
+            .Case("standalone", clang::codegenoptions::FullDebugInfo)
+            .Case("unused-types", clang::codegenoptions::UnusedTypeInfo)
+            .Default(~0U);
+    if (val == ~0U) {
+      diags.Report(clang::diag::err_drv_invalid_value)
+          << arg->getAsString(args) << arg->getValue();
+    } else {
+      opts.setDebugInfo(static_cast<clang::codegenoptions::DebugInfoKind>(val));
+    }
+    if (val != clang::codegenoptions::DebugLineTablesOnly &&
+        val != clang::codegenoptions::NoDebugInfo) {
+      // TODO: This is not great, could be improved
+      const auto debugErr =
+          diags.getCustomDiagID(clang::DiagnosticsEngine::Warning,
+                                "Debug option '%0' is not implemented");
+      diags.Report(debugErr) << arg->getAsString(args);
+    }
+  }
+}
+
 static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
                              llvm::opt::ArgList &args,
                              clang::DiagnosticsEngine &diags) {
+  parseDebugArgs(opts, args, diags);
   opts.OptimizationLevel = getOptimizationLevel(args, diags);
 
   if (args.hasFlag(clang::driver::options::OPT_fdebug_pass_manager,
                    clang::driver::options::OPT_fno_debug_pass_manager, false))
     opts.DebugPassManager = 1;
 
   if (args.hasFlag(clang::driver::options::OPT_fstack_arrays,
                    clang::driver::options::OPT_fno_stack_arrays, false)) {
bool CompilerInvocation::createFromArgs(
   // -flang-experimental-hlfir
   if (args.hasArg(clang::driver::options::OPT_flang_experimental_hlfir)) {
     res.loweringOpts.setLowerToHighLevelFIR(true);
   }
 
   success &= parseFrontendArgs(res.getFrontendOpts(), args, diags);
   parseTargetArgs(res.getTargetOpts(), args);
   parsePreprocessorArgs(res.getPreprocessorOpts(), args);
   parseCodeGenArgs(res.getCodeGenOpts(), args, diags);
   success &= parseSemaArgs(res, args, diags);
   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);

flang/lib/Frontend/FrontendActions.cpp

 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
+#include <clang/Basic/DebugInfoOptions.h>
 #include <memory>
 
 using namespace Fortran::frontend;
 
 // Declare plugin extension function declarations.
 #define HANDLE_EXTENSION(Ext)                                                  \
   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
 #include "llvm/Support/Extension.def"
void CodeGenAction::generateLLVMIR() {
   mlir::PassManager pm((*mlirModule)->getName(),
                        mlir::OpPassManager::Nesting::Implicit);
 
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
   pm.enableVerifier(/*verifyPasses=*/true);
 
   // Create the pass pipeline
   fir::createMLIRToLLVMPassPipeline(pm, level, opts.StackArrays,
-                                    opts.Underscoring);
+                                    opts.Underscoring, opts.getDebugInfo());
   mlir::applyPassManagerCLOptions(pm);
 
   // run the pass manager
   if (!mlir::succeeded(pm.run(*mlirModule))) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "Lowering to LLVM IR failed");
     ci.getDiagnostics().Report(diagID);
   }

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

 ! CHECK-NEXT: -fopenacc              Enable OpenACC
 ! CHECK-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! CHECK-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
 ! CHECK-NEXT: -freciprocal-math      Allow division operations to be reassociated
 ! CHECK-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
 ! CHECK-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
 ! CHECK-NEXT: -funderscoring         Appends one trailing underscore to external names
 ! CHECK-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
+! CHECK-NEXT: -gline-tables-only     Emit debug line number tables only
+! CHECK-NEXT: -g                     Generate source-level debug information
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! CHECK-NEXT: -mllvm=<arg>           Alias for -mllvm
 ! CHECK-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
 ! CHECK-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
 ! CHECK-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! CHECK-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! CHECK-NEXT: -o <file> Write output to <file>

flang/test/Driver/driver-help.f90

 ! HELP-NEXT: -fopenacc              Enable OpenACC
 ! HELP-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
 ! HELP-NEXT: -freciprocal-math      Allow division operations to be reassociated
 ! HELP-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
 ! HELP-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
 ! HELP-NEXT: -funderscoring         Appends one trailing underscore to external names
 ! HELP-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
+! HELP-NEXT: -gline-tables-only     Emit debug line number tables only
+! HELP-NEXT: -g                     Generate source-level debug information
 ! HELP-NEXT: -help                  Display available options
 ! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-NEXT: -mllvm=<arg>           Alias for -mllvm
 ! HELP-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
 ! HELP-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
 ! HELP-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! HELP-NEXT: -o <file>              Write output to <file>