[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 ↗

(On Diff #488049)

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

174

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

[kiranchandramohan]

flang/lib/Frontend/FrontendActions.cpp

174

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

2

Nit: Change comment to match file.

58

A conditional check is probably required here.

64–66

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

174

Passing it directly now. Done.

flang/lib/Lower/Bridge.cpp

3826 ↗

(On Diff #488049)

Made the change. Thanks for the pointer.

[awarzynski]

Thanks Kiran! LGTM

flang/lib/Frontend/FrontendActions.cpp

174

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/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> createAddDebugFoundationPass(llvm::StringRef inputFilePath);
 
 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"
+  ];
+  let options = [
+    Option<"inputFilePath", "input-file-path", "std::string",
+           /*default=*/"",
+           "Full Path to input file.">
+  ];
+}
+
 // 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

inline void createDefaultFIROptimizerPassPipeline(
   pm.addPass(mlir::createConvertSCFToCFPass());
 
   pm.addPass(mlir::createCanonicalizerPass(config));
   pm.addPass(fir::createSimplifyRegionLitePass());
   pm.addPass(mlir::createCSEPass());
 }
 
 #if !defined(FLANG_EXCLUDE_CODEGEN)
-inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) {
+inline void createDefaultFIRCodeGenPassPipeline(
+    mlir::PassManager &pm, llvm::StringRef inputFilePath) {
   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);
+  pm.addPass(fir::createAddDebugFoundationPass(inputFilePath));
   fir::addFIRToLLVMPass(pm);
 }
 
 /// 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) {
+inline void createMLIRToLLVMPassPipeline(mlir::PassManager &pm,
+    llvm::StringRef inputFilePath,
+    llvm::OptimizationLevel optLevel = defaultOptLevel) {
   // Add default optimizer pass pipeline.
   fir::createDefaultFIROptimizerPassPipeline(pm, optLevel);
 
   // Add codegen pass pipeline.
-  fir::createDefaultFIRCodeGenPassPipeline(pm);
+  fir::createDefaultFIRCodeGenPassPipeline(pm, inputFilePath);
 }
 #undef FLANG_EXCLUDE_CODEGEN
 #endif
 
 } // namespace fir

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
 //
 //===----------------------------------------------------------------------===//
 //
bool CodeGenAction::beginSourceFileAction() {
   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);
 
   // 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() {
   fir::support::registerLLVMTranslation(*mlirCtx);
 
   // 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);
 
+  std::string filePath{getCurrentFileOrBufferName()};
   // Create the pass pipeline
-  fir::createMLIRToLLVMPassPipeline(pm, level);
+  fir::createMLIRToLLVMPassPipeline(pm, filePath, 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/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:
+  AddDebugFoundationPass(llvm::StringRef inputFilePath)
+      : inputFilePath(inputFilePath) {}
+  void runOnOperation() override;
+
+private:
+  std::string inputFilePath;
+};
+
+} // namespace
+
+void AddDebugFoundationPass::runOnOperation() {
+  mlir::ModuleOp module = getOperation();
+  mlir::MLIRContext *context = &getContext();
+  mlir::OpBuilder builder(context);
+  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::DIScopeAttr scopeAttr;
+    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(llvm::StringRef inputFilePath) {
+  return std::make_unique<AddDebugFoundationPass>(inputFilePath);
+}
+
+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/tools/tco/tco.cpp

 //===- tco.cpp - Tilikum Crossing Opt ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
auto errorHandler = [&](const Twine &msg) {
       mlir::emitError(mlir::UnknownLoc::get(pm.getContext())) << msg;
       return mlir::failure();
     };
     if (mlir::failed(passPipeline.addToPipeline(pm, errorHandler)))
       return mlir::failure();
   } else {
     if (codeGenLLVM) {
       // Run only CodeGen passes.
-      fir::createDefaultFIRCodeGenPassPipeline(pm);
+      fir::createDefaultFIRCodeGenPassPipeline(pm, inputFilename.c_str());
     } else {
       // Run tco with O2 by default.
-      fir::createMLIRToLLVMPassPipeline(pm, llvm::OptimizationLevel::O2);
+      fir::createMLIRToLLVMPassPipeline(pm, inputFilename.c_str(), llvm::OptimizationLevel::O2);
     }
     fir::addLLVMDialectToLLVMPass(pm, out.os());
   }
 
   // run the pass manager
   if (mlir::succeeded(pm.run(*owningRef))) {
     // passes ran successfully, so keep the output
     if ((emitFir || passPipeline.hasAnyOccurrences()) && !codeGenLLVM)