[Flang] Add/Restore basic debug support (1/n)

[kiranchandramohan]

Summary

Recent changes to MLIR meant that Flang does not generate any debug line
table information.

This patch adds a pass that provides some foundation work with which
basic line table debug info can be generated. A walk is performed on
all the func ops in the module and they are decorated with a fusedLoc
op that contains the debug metadata for the subroutine along with
location information.

Alternatives include populating this info during lowering or during FIR
to LLVM Dialect conversion.

Note: Patches in future will add

-> more realistic debug info for types and other fields.
-> driver flags to control generation of debug.

Fixes #58634.

[kiranchandramohan]

Minor fixes.

[kiranchandramohan]

Minor fixes, format and rebase.

[tschuett]

In https://reviews.llvm.org/D140415 there was similar question: pass or part of lowering? Could you register callbacks or some other magic into the lowering part to make it extensible for debug info, stack arrays, and more?

[vzakhari]

Thank you, Kiran! It looks good to me, except for the handling of file name/path.

flang/lib/Frontend/FrontendActions.cpp

545

I think it would be better to take the file name/path from the ModuleOp itself (e.g. via module.getLoc()). I know there is nothing ready for linking of multiple modules with FIR, but we would probably want to do this at some point. Thus, we'd better try to host all the needed information in the module itself. Setting the module source location should be easy, e.g. pass the input file name to LoweringBridge::create. I am not sure what we should do for MLIR input files - probably, preserve the source location read from MLIR and if it is empty, use the MLIR file location instead.

Can you please try this?

[vzakhari]

flang/lib/Frontend/FrontendActions.cpp

545

Actually, the path information seems to be already available via SemanticsContext.

[kiranchandramohan]

In D137956#4026354, @tschuett wrote:

In https://reviews.llvm.org/D140415 there was similar question: pass or part of lowering? Could you register callbacks or some other magic into the lowering part to make it extensible for debug info, stack arrays, and more?

We discussed that a bit in the RFC and can discuss more there. We also need to sync with what the MLIR team has in mind. In the mean-time, making some progress here is probably more beneficial (for engineers working on performance improvement) at this point than coming up with the perfect solution.

flang/lib/Frontend/FrontendActions.cpp

545

Sure. I am trying this.

Did you mean using the function semanticsContext.location()? That field is not set at this point in LowerBridge::create.

[vzakhari]

flang/lib/Frontend/FrontendActions.cpp

545

Yes, I thought we could use it, but I did not track it down completely.

[kiranchandramohan]

Address review comments. Add test.

[vzakhari]

Thank you, Kiran! It looks good to me.

flang/lib/Lower/Bridge.cpp

3826

nit: line 0, column 0 might be a better choice to indicate the beginning of the module (e.g. 0, 0 is used by the parser in mlir/lib/Parser/Parser.cpp). I guess 1, 1 may work as well.

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

175

Wouldn't llvm::StringRef be sufficient here? As in, filePath{getCurrentFileOrBufferName()} invoked in-place.

[kiranchandramohan]

flang/lib/Frontend/FrontendActions.cpp

175

Do you mean passing std::string(getCurrentFileOrBufferName()) instead of creating a string with a name filePath? Or do you mean whether passing getCurrentFileOrBufferName() is fine?

The former is fine. For the latter, I was not sure about the lifetime of the underlying string of getCurrentFileOrBufferName(). Is that guaranteed to exist till the MLIR flow is complete? All the places following from here uses StringRef.

flang/lib/Optimizer/Transforms/AddDebugFoundation.cpp

1

Nit: Change comment to match file.

57

A conditional check is probably required here.

63–65

Provide comments for any parameter without a name or type.

[kiranchandramohan]

Address comments about directly passing StringRef and using 0,0 as default location.

[kiranchandramohan]

flang/lib/Frontend/FrontendActions.cpp

175

Passing it directly now. Done.

flang/lib/Lower/Bridge.cpp

3826

Made the change. Thanks for the pointer.

[awarzynski]

Thanks Kiran! LGTM

flang/lib/Frontend/FrontendActions.cpp

175

For the latter, I was not sure about the lifetime of the underlying string of getCurrentFileOrBufferName(). Is that guaranteed to exist till the MLIR flow is complete?

That string is managed by the driver. As long as the driver is "on", that string is guaranteed to exist. And the driver is guaranteed to be "on" until the end of the compilation :)

[PeteSteinfeld]

@kiranchandramohan, I notice that the path being passed to LoweringBridge.create is a relative path. Is this what you wanted?

[kiranchandramohan]

In D137956#4047530, @PeteSteinfeld wrote:

@kiranchandramohan, I notice that the path being passed to LoweringBridge.create is a relative path. Is this what you wanted?

Thanks for bringing this up. I think we need the full path for the debugger to find the file. I will check whether the full path is available and provide an update.

[vzakhari]

flang/lib/Optimizer/Transforms/AddDebugFoundation.cpp

81

Jean mentinoned the preprocessing include directives that might bring code from other files - in this case, I think, we cannot use fileAttr here. We need to create new DIFileAttr based on the actual location of the FuncOp.

[kiranchandramohan]

flang/lib/Optimizer/Transforms/AddDebugFoundation.cpp

81

Thanks @vzakhari. I will make the suggested change.

[klausler]

How to get the initial source file path from the Fortran::semantics::SemanticsContext instance:

std::optional<std::string> path;
const auto &allSources{semanticsContext.allCookedSources().allSources()};
if (auto initial{allSources.GetFirstFileProvenance()};
    initial && !initial->empty()) {
  if (const auto *sourceFile{allSources.GetSourceFile(initial->begin())}) {
    path = sourceFile->path();
  }
}

[kiranchandramohan]

In D137956#4048196, @klausler wrote:

How to get the initial source file path from the Fortran::semantics::SemanticsContext instance:

std::optional<std::string> path;
const auto &allSources{semanticsContext.allCookedSources().allSources()};
if (auto initial{allSources.GetFirstFileProvenance()};
    initial && !initial->empty()) {
  if (const auto *sourceFile{allSources.GetSourceFile(initial->begin())}) {
    path = sourceFile->path();
  }
}

Thanks Peter.

flang/include/flang/Lower/Bridge.h

 //===-- Lower/Bridge.h -- main interface to lowering ------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
public:
   create(mlir::MLIRContext &ctx,
          Fortran::semantics::SemanticsContext &semanticsContext,
          const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
          const Fortran::evaluate::IntrinsicProcTable &intrinsics,
          const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
          const Fortran::parser::AllCookedSources &allCooked,
          llvm::StringRef triple, fir::KindMapping &kindMap,
          const Fortran::lower::LoweringOptions &loweringOptions,
-         const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults) {
+         const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
+         llvm::StringRef filePath) {
     return LoweringBridge(ctx, semanticsContext, defaultKinds, intrinsics,
                           targetCharacteristics, allCooked, triple, kindMap,
-                          loweringOptions, envDefaults);
+                          loweringOptions, envDefaults, filePath);
   }
 
   //===--------------------------------------------------------------------===//
   // Getters
   //===--------------------------------------------------------------------===//
 
   mlir::MLIRContext &getMLIRContext() { return context; }
 
explicit LoweringBridge(
       mlir::MLIRContext &ctx,
       Fortran::semantics::SemanticsContext &semanticsContext,
       const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
       const Fortran::evaluate::IntrinsicProcTable &intrinsics,
       const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
       const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
       fir::KindMapping &kindMap,
       const Fortran::lower::LoweringOptions &loweringOptions,
-      const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults);
+      const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
+      llvm::StringRef filePath);
   LoweringBridge() = delete;
   LoweringBridge(const LoweringBridge &) = delete;
 
   Fortran::semantics::SemanticsContext &semanticsContext;
   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds;
   const Fortran::evaluate::IntrinsicProcTable &intrinsics;
   const Fortran::evaluate::TargetCharacteristics &targetCharacteristics;
   const Fortran::parser::AllCookedSources *cooked;

flang/include/flang/Optimizer/Transforms/Passes.h

 //===-- Optimizer/Transforms/Passes.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
 //
 //===----------------------------------------------------------------------===//
 

 std::unique_ptr<mlir::Pass> createArrayValueCopyPass();
 std::unique_ptr<mlir::Pass> createFirToCfgPass();
 std::unique_ptr<mlir::Pass> createCharacterConversionPass();
 std::unique_ptr<mlir::Pass> createExternalNameConversionPass();
 std::unique_ptr<mlir::Pass> createMemDataFlowOptPass();
 std::unique_ptr<mlir::Pass> createPromoteToAffinePass();
 std::unique_ptr<mlir::Pass> createMemoryAllocationPass();
 std::unique_ptr<mlir::Pass> createSimplifyIntrinsicsPass();
+std::unique_ptr<mlir::Pass> createAddDebugFoundationPass();
 
 std::unique_ptr<mlir::Pass>
 createMemoryAllocationPass(bool dynOnHeap, std::size_t maxStackSize);
 std::unique_ptr<mlir::Pass> createAnnotateConstantOperandsPass();
 std::unique_ptr<mlir::Pass> createSimplifyRegionLitePass();
 std::unique_ptr<mlir::Pass> createAlgebraicSimplificationPass();
 std::unique_ptr<mlir::Pass>
 createAlgebraicSimplificationPass(const mlir::GreedyRewriteConfig &config);
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H

flang/include/flang/Optimizer/Transforms/Passes.td

let description = [{
     potentially the entire allocation if all the accesses are forwarded.
   }];
   let constructor = "::fir::createMemDataFlowOptPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect"
   ];
 }
 
+// This needs to be a "mlir::ModuleOp" pass, because we are creating debug for
+// the module in this pass.
+def AddDebugFoundation : Pass<"add-debug-foundation", "mlir::ModuleOp"> {
+  let summary = "Add the foundation for debug info";
+  let description = [{
+    Add the foundation for emitting debug info that can be understood by llvm.
+  }];
+  let constructor = "::fir::createAddDebugFoundationPass()";
+  let dependentDialects = [
+    "fir::FIROpsDialect", "mlir::func::FuncDialect", "mlir::LLVM::LLVMDialect"
+  ];
+}
+
 // This needs to be a "mlir::ModuleOp" pass, because it inserts simplified
 // functions into the module, which is invalid if a finer grain mlir::Operation
 // is used as the pass specification says to not touch things outside hte scope
 // of the operation being processed.
 def SimplifyIntrinsics : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
   let summary = "Intrinsics simplification";
   let description = [{
     Qualifying intrinsics calls are replaced with calls to a specialized and

flang/include/flang/Tools/CLOptions.inc

 DisableOption(FirAvc, "avc", "array value copy analysis and transformation");
 DisableOption(
     FirMao, "memory-allocation-opt", "memory allocation optimization");
 
 /// CodeGen Passes
 #if !defined(FLANG_EXCLUDE_CODEGEN)
 DisableOption(CodeGenRewrite, "codegen-rewrite", "rewrite FIR for codegen");
 DisableOption(TargetRewrite, "target-rewrite", "rewrite FIR for target");
+DisableOption(DebugFoundation, "debug-foundation", "Add debug foundation");
 DisableOption(FirToLlvmIr, "fir-to-llvmir", "FIR to LLVM-IR dialect");
 DisableOption(LlvmIrToLlvm, "llvm", "conversion to LLVM");
 DisableOption(BoxedProcedureRewrite, "boxed-procedure-rewrite",
     "rewrite boxed procedures");
 #endif
 
 DisableOption(ExternalNameConversion, "external-name-interop", "convert names with external convention");
 

 }
 
 inline void addTargetRewritePass(mlir::PassManager &pm) {
   addPassConditionally(pm, disableTargetRewrite, []() {
     return fir::createFirTargetRewritePass(fir::TargetRewriteOptions{});
   });
 }
 
+inline void addDebugFoundationPass(mlir::PassManager &pm) {
+  addPassConditionally(pm, disableDebugFoundation,
+      [&]() { return fir::createAddDebugFoundationPass(); });
+}
+
 inline void addFIRToLLVMPass(mlir::PassManager &pm) {
   fir::FIRToLLVMPassOptions options;
   options.ignoreMissingTypeDescriptors = ignoreMissingTypeDescriptors;
   addPassConditionally(pm, disableFirToLlvmIr,
       [&]() { return fir::createFIRToLLVMPass(options); });
 }
 
 inline void addLLVMDialectToLLVMPass(

flang/lib/Frontend/FrontendActions.cpp

 //===--- FrontendActions.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
 //
 //===----------------------------------------------------------------------===//
 //
if (getCurrentInput().getKind().getLanguage() != Language::Fortran) {
     ci.getDiagnostics().Report(diagID);
     return false;
   }
   bool res = runPrescan() && runParse() && runSemanticChecks() &&
              generateRtTypeTables();
   if (!res)
     return res;
 
+  std::string filePath{getCurrentFileOrBufferName()};
   // Create a LoweringBridge
   const common::IntrinsicTypeDefaultKinds &defKinds =
       ci.getInvocation().getSemanticsContext().defaultKinds();
   fir::KindMapping kindMap(mlirCtx.get(), llvm::ArrayRef<fir::KindTy>{
                                               fir::fromDefaultKinds(defKinds)});
   lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(
       *mlirCtx, ci.getInvocation().getSemanticsContext(), defKinds,
       ci.getInvocation().getSemanticsContext().intrinsics(),
       ci.getInvocation().getSemanticsContext().targetCharacteristics(),
       ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,
       kindMap, ci.getInvocation().getLoweringOpts(),
-      ci.getInvocation().getFrontendOpts().envDefaults);
+      ci.getInvocation().getFrontendOpts().envDefaults, filePath);
 
   // Fetch module from lb, so we can set
   mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
   setUpTargetMachine();
   const llvm::DataLayout &dl = tm->createDataLayout();
   setMLIRDataLayout(*mlirModule, dl);
 
   // Create a parse tree and lower it to FIR
void CodeGenAction::generateLLVMIR() {
 
   // Set-up the MLIR pass manager
   mlir::PassManager pm(mlirCtx.get(), mlir::OpPassManager::Nesting::Implicit);
 
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
   pm.enableVerifier(/*verifyPasses=*/true);
 
   // Create the pass pipeline
   fir::createMLIRToLLVMPassPipeline(pm, level);
   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/lib/Lower/Bridge.cpp

 //===-- Bridge.cpp -- bridge to lower to MLIR -----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
Fortran::lower::LoweringBridge::LoweringBridge(
     mlir::MLIRContext &context,
     Fortran::semantics::SemanticsContext &semanticsContext,
     const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
     const Fortran::evaluate::IntrinsicProcTable &intrinsics,
     const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
     const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
     fir::KindMapping &kindMap,
     const Fortran::lower::LoweringOptions &loweringOptions,
-    const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults)
+    const std::vector<Fortran::lower::EnvironmentDefault> &envDefaults,
+    llvm::StringRef filePath)
     : semanticsContext{semanticsContext}, defaultKinds{defaultKinds},
       intrinsics{intrinsics}, targetCharacteristics{targetCharacteristics},
       cooked{&cooked}, context{context}, kindMap{kindMap},
       loweringOptions{loweringOptions}, envDefaults{envDefaults} {
   // Register the diagnostic handler.
   context.getDiagEngine().registerHandler([](mlir::Diagnostic &diag) {
     llvm::raw_ostream &os = llvm::errs();
     switch (diag.getSeverity()) {
context.getDiagEngine().registerHandler([](mlir::Diagnostic &diag) {
     if (!diag.getLocation().isa<mlir::UnknownLoc>())
       os << diag.getLocation() << ": ";
     os << diag << '\n';
     os.flush();
     return mlir::success();
   });
 
   // Create the module and attach the attributes.
-  module = std::make_unique<mlir::ModuleOp>(
-      mlir::ModuleOp::create(mlir::UnknownLoc::get(&context)));
+  module = std::make_unique<mlir::ModuleOp>(mlir::ModuleOp::create(
+      mlir::FileLineColLoc::get(&getMLIRContext(), filePath, 1, 1)));
   assert(module.get() && "module was not created");
   fir::setTargetTriple(*module.get(), triple);
   fir::setKindMapping(*module.get(), kindMap);
 }

flang/lib/Optimizer/Transforms/AddDebugFoundation.cpp

+//===- SimplifyIntrinsics.cpp -- replace intrinsics with simpler form -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+/// \file
+/// This pass populates some debug information for the module and functions.
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/Matchers.h"
+#include "mlir/IR/TypeUtilities.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "mlir/Transforms/RegionUtils.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace fir {
+#define GEN_PASS_DEF_ADDDEBUGFOUNDATION
+#define GEN_PASS_DECL_ADDDEBUGFOUNDATION
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
+#define DEBUG_TYPE "flang-add-debug-foundation"
+
+namespace {
+
+class AddDebugFoundationPass
+    : public fir::impl::AddDebugFoundationBase<AddDebugFoundationPass> {
+public:
+  void runOnOperation() override;
+};
+
+} // namespace
+
+void AddDebugFoundationPass::runOnOperation() {
+  mlir::ModuleOp module = getOperation();
+  mlir::MLIRContext *context = &getContext();
+  mlir::OpBuilder builder(context);
+  auto fileLoc = module.getLoc().dyn_cast<mlir::FileLineColLoc>();
+  std::string inputFilePath(fileLoc.getFilename().getValue());
+  mlir::LLVM::DIFileAttr fileAttr = mlir::LLVM::DIFileAttr::get(
+      context, llvm::sys::path::filename(inputFilePath),
+      llvm::sys::path::parent_path(inputFilePath));
+  mlir::StringAttr producer = mlir::StringAttr::get(context, "Flang");
+  mlir::LLVM::DICompileUnitAttr cuAttr = mlir::LLVM::DICompileUnitAttr::get(
+      context, llvm::dwarf::getLanguage("DW_LANG_Fortran95"), fileAttr,
+      producer, false, mlir::LLVM::DIEmissionKind::LineTablesOnly);
+  module.walk([&](mlir::func::FuncOp funcOp) {
+    mlir::StringAttr funcName =
+        mlir::StringAttr::get(context, funcOp.getName());
+    mlir::LLVM::DIBasicTypeAttr bT = mlir::LLVM::DIBasicTypeAttr::get(
+        context, llvm::dwarf::DW_TAG_base_type, "void", 0, 1);
+    mlir::LLVM::DISubroutineTypeAttr subTypeAttr =
+        mlir::LLVM::DISubroutineTypeAttr::get(
+            context, llvm::dwarf::getCallingConvention("DW_CC_normal"), bT,
+            {bT});
+    mlir::LLVM::DISubprogramAttr spAttr = mlir::LLVM::DISubprogramAttr::get(
+        context, cuAttr, fileAttr, funcName, funcName, fileAttr, 1, 1,
+        mlir::LLVM::DISubprogramFlags::Definition, subTypeAttr);
+    funcOp->setLoc(builder.getFusedLoc({funcOp->getLoc()}, spAttr));
+  });
+}
+
+std::unique_ptr<mlir::Pass> fir::createAddDebugFoundationPass() {
+  return std::make_unique<AddDebugFoundationPass>();
+}

flang/lib/Optimizer/Transforms/CMakeLists.txt

 add_flang_library(FIRTransforms
   AbstractResult.cpp
   AffinePromotion.cpp
   AffineDemotion.cpp
   AnnotateConstant.cpp
   CharacterConversion.cpp
   ControlFlowConverter.cpp
   ArrayValueCopy.cpp
   ExternalNameConversion.cpp
   MemoryAllocation.cpp
   MemRefDataFlowOpt.cpp
   SimplifyRegionLite.cpp
   AlgebraicSimplification.cpp
   SimplifyIntrinsics.cpp
+  AddDebugFoundation.cpp
 
   DEPENDS
   FIRBuilder
   FIRDialect
   FIRSupport
   FIROptTransformsPassIncGen
 
   LINK_LIBS

flang/test/Lower/module-debug-file-loc.f90

+! Test that the module has the location information
+
+! RUN: %flang_fc1 -mmlir --mlir-print-debuginfo -emit-fir -o - %s | FileCheck %s
+
+subroutine sb1()
+end subroutine
+
+! CHECK: module attributes
+! CHECK:   func.func @_QPsb1() {
+! CHECK:   }
+! CHECK: } loc(#[[MODULE_LOC:.*]])
+! CHECK: #[[MODULE_LOC]] = loc("{{.*}}module-debug-file-loc.f90":1:1)

flang/test/Transforms/debug-line-table.fir

+
+// RUN: fir-opt --add-debug-foundation --mlir-print-debuginfo %s | FileCheck %s
+
+module attributes { fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128", llvm.target_triple = "aarch64-unknown-linux-gnu"} {
+  func.func @_QPsb() {
+    return loc(#loc_sb)
+  } loc(#loc_sb)
+} loc(#loc_module)
+#loc_module = loc("./simple.f90":1:1)
+#loc_sb = loc("./simple.f90":2:1)
+
+// CHECK: module attributes
+// CHECK:   func.func @[[SB_NAME:.*]]() {
+// CHECK:     return loc(#[[SB_LOC:.*]])
+// CHECK:   } loc(#[[FUSED_SB_LOC:.*]])
+// CHECK: } loc(#[[MODULE_LOC:.*]])
+// CHECK: #di_basic_type = #llvm.di_basic_type<tag = DW_TAG_base_type, name = "void", encoding = DW_ATE_address>
+// CHECK: #di_file = #llvm.di_file<"[[FILE_NAME:.*]]" in "[[DIR_NAME:.*]]">
+// CHECK: #[[MODULE_LOC]] = loc("[[DIR_NAME]]/[[FILE_NAME]]":1:1)
+// CHECK: #[[SB_LOC]] = loc("./simple.f90":2:1)
+// CHECK: #di_compile_unit = #llvm.di_compile_unit<sourceLanguage = DW_LANG_Fortran95, file = #di_file, producer = "Flang", isOptimized = false, emissionKind = LineTablesOnly>
+// CHECK: #di_subroutine_type = #llvm.di_subroutine_type<callingConvention = DW_CC_normal, resultType = #di_basic_type, argumentTypes = #di_basic_type>
+// CHECK: #di_subprogram = #llvm.di_subprogram<compileUnit = #di_compile_unit, scope = #di_file, name = "[[SB_NAME]]", linkageName = "[[SB_NAME]]", file = #di_file, line = 1, scopeLine = 1, subprogramFlags = Definition, type = #di_subroutine_type>
+// CHECK: #[[FUSED_SB_LOC]] = loc(fused<#di_subprogram>[#[[SB_LOC]]])

flang/tools/bbc/bbc.cpp

 //===- bbc.cpp - Burnside Bridge Compiler -----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
   loweringOptions.setPolymorphicTypeImpl(enablePolymorphic);
   loweringOptions.setLowerToHighLevelFIR(useHLFIR);
   auto burnside = Fortran::lower::LoweringBridge::create(
       ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
-      kindMap, loweringOptions, {});
+      kindMap, loweringOptions, {}, inputFilename);
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
   std::string outputName = outputFilename;
   if (!outputName.size())
     outputName = llvm::sys::path::stem(inputFilename).str().append(".mlir");
   llvm::raw_fd_ostream out(outputName, ec);
   if (ec)