[flang-commits] [flang] [flang][debug] Generate DWARF debug info using fir.use_stmt. (PR #168541)
via flang-commits
flang-commits at lists.llvm.org
Fri Jan 2 13:19:58 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: Abid Qadeer (abidh)
<details>
<summary>Changes</summary>
This patch uses the fir.use_stmt operations to generate correct debug metadata for use statement when `only` and `=>` are used. The debug flow is changed a bit where we process the module globals first so that we have the global variables when we start to process `fir.use_stmt`.
Fixes #<!-- -->160923.
---
Patch is 23.40 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/168541.diff
5 Files Affected:
- (modified) flang/lib/Optimizer/Transforms/AddDebugInfo.cpp (+213-57)
- (added) flang/test/Integration/debug-use-stmt.f90 (+38)
- (modified) flang/test/Transforms/debug-imported-entity.fir (+1)
- (modified) flang/test/Transforms/debug-local-global-storage-1.fir (+1)
- (added) flang/test/Transforms/debug-use-stmt.fir (+69)
``````````diff
diff --git a/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp b/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp
index 7491b7b6d52d2..dd0af88c656d1 100644
--- a/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp
+++ b/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp
@@ -84,6 +84,20 @@ class AddDebugInfoPass : public fir::impl::AddDebugInfoBase<AddDebugInfoPass> {
mlir::LLVM::DICompileUnitAttr cuAttr,
fir::DebugTypeGenerator &typeGen,
mlir::SymbolTable *symbolTable);
+ void handleOnlyClause(
+ fir::UseStmtOp useOp, mlir::LLVM::DISubprogramAttr spAttr,
+ mlir::LLVM::DIFileAttr fileAttr, mlir::SymbolTable *symbolTable,
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> &importedModules);
+ void handleRenamesWithoutOnly(
+ fir::UseStmtOp useOp, mlir::LLVM::DISubprogramAttr spAttr,
+ mlir::LLVM::DIModuleAttr modAttr, mlir::LLVM::DIFileAttr fileAttr,
+ mlir::SymbolTable *symbolTable,
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> &importedModules);
+ void handleUseStatements(
+ mlir::func::FuncOp funcOp, mlir::LLVM::DISubprogramAttr spAttr,
+ mlir::LLVM::DIFileAttr fileAttr, mlir::LLVM::DICompileUnitAttr cuAttr,
+ mlir::SymbolTable *symbolTable,
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> &importedEntities);
bool createCommonBlockGlobal(fir::cg::XDeclareOp declOp,
const std::string &name,
mlir::LLVM::DIFileAttr fileAttr,
@@ -136,6 +150,34 @@ mlir::StringAttr getTargetFunctionName(mlir::MLIRContext *context,
deviceId, fileId, parentName, line)));
}
+/// Check if a global represents a module variable
+bool isModuleVariable(fir::GlobalOp globalOp) {
+ std::pair result = fir::NameUniquer::deconstruct(globalOp.getSymName());
+ return result.first == fir::NameUniquer::NameKind::VARIABLE &&
+ result.second.procs.empty() && !result.second.modules.empty();
+}
+
+// Look up DIGlobalVariable from a global symbol
+std::optional<mlir::LLVM::DIGlobalVariableAttr>
+lookupDIGlobalVariable(llvm::StringRef symbolName,
+ mlir::SymbolTable *symbolTable) {
+ if (auto globalOp = symbolTable->lookup<fir::GlobalOp>(symbolName)) {
+ if (auto fusedLoc = mlir::dyn_cast<mlir::FusedLoc>(globalOp.getLoc())) {
+ if (auto metadata = fusedLoc.getMetadata()) {
+ if (auto arrayAttr = mlir::dyn_cast<mlir::ArrayAttr>(metadata)) {
+ for (auto elem : arrayAttr) {
+ if (auto gvExpr =
+ mlir::dyn_cast<mlir::LLVM::DIGlobalVariableExpressionAttr>(
+ elem))
+ return gvExpr.getVar();
+ }
+ }
+ }
+ }
+ }
+ return std::nullopt;
+}
+
} // namespace
bool AddDebugInfoPass::createCommonBlockGlobal(
@@ -526,7 +568,7 @@ void AddDebugInfoPass::handleFuncOp(mlir::func::FuncOp funcOp,
CC = llvm::dwarf::getCallingConvention("DW_CC_normal");
mlir::LLVM::DISubroutineTypeAttr spTy =
mlir::LLVM::DISubroutineTypeAttr::get(context, CC, types);
- if (lineTableOnly) {
+ if (lineTableOnly || entities.empty()) {
auto spAttr = mlir::LLVM::DISubprogramAttr::get(
context, id, compilationUnit, Scope, name, name, funcFileAttr, line,
line, flags, spTy, /*retainedNodes=*/{}, /*annotations=*/{});
@@ -546,9 +588,9 @@ void AddDebugInfoPass::handleFuncOp(mlir::func::FuncOp funcOp,
for (mlir::LLVM::DINodeAttr N : entities) {
if (auto entity = mlir::dyn_cast<mlir::LLVM::DIImportedEntityAttr>(N)) {
auto importedEntity = mlir::LLVM::DIImportedEntityAttr::get(
- context, llvm::dwarf::DW_TAG_imported_module, spAttr,
- entity.getEntity(), fileAttr, /*line=*/1, /*name=*/nullptr,
- /*elements*/ {});
+ context, entity.getTag(), spAttr, entity.getEntity(),
+ entity.getFile(), entity.getLine(), entity.getName(),
+ entity.getElements());
opEntities.push_back(importedEntity);
}
}
@@ -573,61 +615,57 @@ void AddDebugInfoPass::handleFuncOp(mlir::func::FuncOp funcOp,
return;
}
- mlir::DistinctAttr recId =
- mlir::DistinctAttr::create(mlir::UnitAttr::get(context));
-
- // The debug attribute in MLIR are readonly once created. But in case of
- // imported entities, we have a circular dependency. The
- // DIImportedEntityAttr requires scope information (DISubprogramAttr in this
- // case) and DISubprogramAttr requires the list of imported entities. The
- // MLIR provides a way where a DISubprogramAttr an be created with a certain
- // recID and be used in places like DIImportedEntityAttr. After that another
- // DISubprogramAttr can be created with same recID but with list of entities
- // now available. The MLIR translation code takes care of updating the
- // references. Note that references will be updated only in the things that
- // are part of DISubprogramAttr (like DIImportedEntityAttr) so we have to
- // create the final DISubprogramAttr before we process local variables.
- // Look at DIRecursiveTypeAttrInterface for more details.
-
- auto spAttr = mlir::LLVM::DISubprogramAttr::get(
- context, recId, /*isRecSelf=*/true, id, compilationUnit, Scope, funcName,
- fullName, funcFileAttr, line, line, subprogramFlags, subTypeAttr,
- /*retainedNodes=*/{}, /*annotations=*/{});
-
- // There is no direct information in the IR for any 'use' statement in the
- // function. We have to extract that information from the DeclareOp. We do
- // a pass on the DeclareOp and generate ModuleAttr and corresponding
- // DIImportedEntityAttr for that module.
- // FIXME: As we are depending on the variables to see which module is being
- // 'used' in the function, there are certain limitations.
- // For things like 'use mod1, only: v1', whole module will be brought into the
- // namespace in the debug info. It is not a problem as such unless there is a
- // clash of names.
- // There is no information about module variable renaming
- llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> importedModules;
- funcOp.walk([&](fir::cg::XDeclareOp declOp) {
- if (&funcOp.front() == declOp->getBlock())
- if (auto global =
- symbolTable->lookup<fir::GlobalOp>(declOp.getUniqName())) {
- std::optional<mlir::LLVM::DIModuleAttr> modOpt =
- getModuleAttrFromGlobalOp(global, fileAttr, cuAttr);
- if (modOpt) {
- auto importedEntity = mlir::LLVM::DIImportedEntityAttr::get(
- context, llvm::dwarf::DW_TAG_imported_module, spAttr, *modOpt,
- fileAttr, /*line=*/1, /*name=*/nullptr, /*elements*/ {});
- importedModules.insert(importedEntity);
- }
- }
+ // Check if there are any USE statements
+ bool hasUseStmts = false;
+ funcOp.walk([&](fir::UseStmtOp useOp) {
+ hasUseStmts = true;
+ return mlir::WalkResult::interrupt();
});
- llvm::SmallVector<mlir::LLVM::DINodeAttr> entities(importedModules.begin(),
- importedModules.end());
- // We have the imported entities now. Generate the final DISubprogramAttr.
- spAttr = mlir::LLVM::DISubprogramAttr::get(
- context, recId, /*isRecSelf=*/false, id2, compilationUnit, Scope,
- funcName, fullName, funcFileAttr, line, line, subprogramFlags,
- subTypeAttr, entities, /*annotations=*/{});
+
+ mlir::LLVM::DISubprogramAttr spAttr;
+ llvm::SmallVector<mlir::LLVM::DINodeAttr> retainedNodes;
+
+ if (hasUseStmts) {
+ mlir::DistinctAttr recId =
+ mlir::DistinctAttr::create(mlir::UnitAttr::get(context));
+ // The debug attribute in MLIR are readonly once created. But in case of
+ // imported entities, we have a circular dependency. The
+ // DIImportedEntityAttr requires scope information (DISubprogramAttr in this
+ // case) and DISubprogramAttr requires the list of imported entities. The
+ // MLIR provides a way where a DISubprogramAttr an be created with a certain
+ // recID and be used in places like DIImportedEntityAttr. After that another
+ // DISubprogramAttr can be created with same recID but with list of entities
+ // now available. The MLIR translation code takes care of updating the
+ // references. Note that references will be updated only in the things that
+ // are part of DISubprogramAttr (like DIImportedEntityAttr) so we have to
+ // create the final DISubprogramAttr before we process local variables.
+ // Look at DIRecursiveTypeAttrInterface for more details.
+ spAttr = mlir::LLVM::DISubprogramAttr::get(
+ context, recId, /*isRecSelf=*/true, id, compilationUnit, Scope,
+ funcName, fullName, funcFileAttr, line, line, subprogramFlags,
+ subTypeAttr, /*retainedNodes=*/{}, /*annotations=*/{});
+
+ // Process USE statements (module globals are already processed)
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> importedEntities;
+ handleUseStatements(funcOp, spAttr, fileAttr, cuAttr, symbolTable,
+ importedEntities);
+
+ retainedNodes.append(importedEntities.begin(), importedEntities.end());
+
+ // Create final DISubprogramAttr with imported entities and same recId
+ spAttr = mlir::LLVM::DISubprogramAttr::get(
+ context, recId, /*isRecSelf=*/false, id2, compilationUnit, Scope,
+ funcName, fullName, funcFileAttr, line, line, subprogramFlags,
+ subTypeAttr, retainedNodes, /*annotations=*/{});
+ } else
+ // No USE statements - create final DISubprogramAttr directly
+ spAttr = mlir::LLVM::DISubprogramAttr::get(
+ context, id, compilationUnit, Scope, funcName, fullName, funcFileAttr,
+ line, line, subprogramFlags, subTypeAttr, /*retainedNodes=*/{},
+ /*annotations=*/{});
+
funcOp->setLoc(builder.getFusedLoc({l}, spAttr));
- addTargetOpDISP(/*lineTableOnly=*/false, entities);
+ addTargetOpDISP(/*lineTableOnly=*/false, retainedNodes);
// Find the first dummy_scope definition. This is the one of the current
// function. The other ones may come from inlined calls. The variables inside
@@ -662,6 +700,104 @@ void AddDebugInfoPass::handleFuncOp(mlir::func::FuncOp funcOp,
commonBlockMap.clear();
}
+// Process USE with ONLY clause
+void AddDebugInfoPass::handleOnlyClause(
+ fir::UseStmtOp useOp, mlir::LLVM::DISubprogramAttr spAttr,
+ mlir::LLVM::DIFileAttr fileAttr, mlir::SymbolTable *symbolTable,
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> &importedModules) {
+ mlir::MLIRContext *context = &getContext();
+
+ auto createImportedDecl = [&](llvm::StringRef symbolName,
+ mlir::StringAttr localNameAttr) {
+ if (auto gvAttr = lookupDIGlobalVariable(symbolName, symbolTable)) {
+ auto importedDecl = mlir::LLVM::DIImportedEntityAttr::get(
+ context, llvm::dwarf::DW_TAG_imported_declaration, spAttr, *gvAttr,
+ fileAttr, /*line=*/1, /*name=*/localNameAttr, /*elements*/ {});
+ importedModules.insert(importedDecl);
+ }
+ };
+
+ // Process ONLY symbols (without renames)
+ if (auto onlySymbols = useOp.getOnlySymbols()) {
+ for (mlir::Attribute attr : *onlySymbols) {
+ auto symbolRef = mlir::cast<mlir::FlatSymbolRefAttr>(attr);
+ createImportedDecl(symbolRef.getValue(), mlir::StringAttr());
+ }
+ }
+
+ // Process renames within ONLY clause
+ if (auto renames = useOp.getRenames()) {
+ for (auto attr : *renames) {
+ auto renameAttr = mlir::cast<fir::UseRenameAttr>(attr);
+ createImportedDecl(renameAttr.getSymbol().getValue(),
+ renameAttr.getLocalName());
+ }
+ }
+}
+
+// Process USE with renames but no ONLY clause
+void AddDebugInfoPass::handleRenamesWithoutOnly(
+ fir::UseStmtOp useOp, mlir::LLVM::DISubprogramAttr spAttr,
+ mlir::LLVM::DIModuleAttr modAttr, mlir::LLVM::DIFileAttr fileAttr,
+ mlir::SymbolTable *symbolTable,
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> &importedModules) {
+ mlir::MLIRContext *context = &getContext();
+ llvm::SmallVector<mlir::LLVM::DINodeAttr> childDeclarations;
+
+ if (auto renames = useOp.getRenames()) {
+ for (auto attr : *renames) {
+ auto renameAttr = mlir::cast<fir::UseRenameAttr>(attr);
+ llvm::StringRef symbolName = renameAttr.getSymbol().getValue();
+ mlir::StringAttr localNameAttr = renameAttr.getLocalName();
+
+ if (auto gvAttr = lookupDIGlobalVariable(symbolName, symbolTable)) {
+ auto importedDecl = mlir::LLVM::DIImportedEntityAttr::get(
+ context, llvm::dwarf::DW_TAG_imported_declaration, spAttr, *gvAttr,
+ fileAttr, /*line=*/1, /*name=*/localNameAttr, /*elements*/ {});
+ childDeclarations.push_back(importedDecl);
+ }
+ }
+ }
+
+ // Create module import with renamed declarations as children
+ auto moduleImport = mlir::LLVM::DIImportedEntityAttr::get(
+ context, llvm::dwarf::DW_TAG_imported_module, spAttr, modAttr, fileAttr,
+ /*line=*/1, /*name=*/nullptr, childDeclarations);
+ importedModules.insert(moduleImport);
+}
+
+// Process all USE statements in a function and collect imported entities
+void AddDebugInfoPass::handleUseStatements(
+ mlir::func::FuncOp funcOp, mlir::LLVM::DISubprogramAttr spAttr,
+ mlir::LLVM::DIFileAttr fileAttr, mlir::LLVM::DICompileUnitAttr cuAttr,
+ mlir::SymbolTable *symbolTable,
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> &importedEntities) {
+ mlir::MLIRContext *context = &getContext();
+
+ funcOp.walk([&](fir::UseStmtOp useOp) {
+ mlir::LLVM::DIModuleAttr modAttr = getOrCreateModuleAttr(
+ useOp.getModuleName().str(), fileAttr, cuAttr, /*line=*/1,
+ /*decl=*/true);
+
+ llvm::DenseSet<mlir::LLVM::DIImportedEntityAttr> importedModules;
+
+ if (useOp.hasOnlyClause())
+ handleOnlyClause(useOp, spAttr, fileAttr, symbolTable, importedModules);
+ else if (useOp.hasRenames())
+ handleRenamesWithoutOnly(useOp, spAttr, modAttr, fileAttr, symbolTable,
+ importedModules);
+ else {
+ // Simple module import
+ auto importedEntity = mlir::LLVM::DIImportedEntityAttr::get(
+ context, llvm::dwarf::DW_TAG_imported_module, spAttr, modAttr,
+ fileAttr, /*line=*/1, /*name=*/nullptr, /*elements*/ {});
+ importedModules.insert(importedEntity);
+ }
+
+ importedEntities.insert(importedModules.begin(), importedModules.end());
+ });
+}
+
void AddDebugInfoPass::runOnOperation() {
mlir::ModuleOp module = getOperation();
mlir::MLIRContext *context = &getContext();
@@ -725,6 +861,26 @@ void AddDebugInfoPass::runOnOperation() {
splitDwarfFile.empty() ? mlir::StringAttr()
: mlir::StringAttr::get(context, splitDwarfFile));
+ // Process module globals early.
+ // Walk through all DeclareOps in functions and process globals that are
+ // module variables. This ensures that when we process USE statements,
+ // the DIGlobalVariable lookups will succeed.
+ if (debugLevel == mlir::LLVM::DIEmissionKind::Full) {
+ module.walk([&](fir::cg::XDeclareOp declOp) {
+ mlir::Operation *defOp = declOp.getMemref().getDefiningOp();
+ if (defOp && llvm::isa<fir::AddrOfOp>(defOp)) {
+ if (auto globalOp =
+ symbolTable.lookup<fir::GlobalOp>(declOp.getUniqName())) {
+ // Only process module variables here, not SAVE variables
+ if (isModuleVariable(globalOp)) {
+ handleGlobalOp(globalOp, fileAttr, cuAttr, typeGen, &symbolTable,
+ declOp);
+ }
+ }
+ }
+ });
+ }
+
module.walk([&](mlir::func::FuncOp funcOp) {
handleFuncOp(funcOp, fileAttr, cuAttr, typeGen, &symbolTable);
});
diff --git a/flang/test/Integration/debug-use-stmt.f90 b/flang/test/Integration/debug-use-stmt.f90
new file mode 100644
index 0000000000000..db20dd94e85d1
--- /dev/null
+++ b/flang/test/Integration/debug-use-stmt.f90
@@ -0,0 +1,38 @@
+! RUN: %flang_fc1 -emit-llvm -debug-info-kind=standalone %s -o - | FileCheck %s
+
+module testmod
+ integer :: var_a = 10, var_b = 20, var_c = 30
+end module testmod
+
+module testmod2
+ real :: var_x = 1.0, var_y = 2.0
+end module testmod2
+
+program test_use
+ use testmod, only: var_b, var_d => var_c
+ use testmod2, var_z => var_y
+ implicit none
+ print *, var_b
+ print *, var_d
+ print *, var_z
+end program
+
+! CHECK-DAG: [[TESTMOD:![0-9]+]] = !DIModule(scope: !{{.*}}, name: "testmod"
+! CHECK-DAG: [[TESTMOD2:![0-9]+]] = !DIModule(scope: !{{.*}}, name: "testmod2"
+
+! CHECK-DAG: [[VAR_B:![0-9]+]] = distinct !DIGlobalVariable(name: "var_b", linkageName: "_QMtestmodEvar_b"
+! CHECK-DAG: [[VAR_C:![0-9]+]] = distinct !DIGlobalVariable(name: "var_c", linkageName: "_QMtestmodEvar_c"
+! CHECK-DAG: [[VAR_Y:![0-9]+]] = distinct !DIGlobalVariable(name: "var_y", linkageName: "_QMtestmod2Evar_y"
+
+! CHECK-DAG: [[SP:![0-9]+]] = distinct !DISubprogram(name: "TEST_USE", linkageName: "_QQmain"{{.*}}retainedNodes:
+
+! Check testmod imports: var_b directly (no rename), var_d as rename of var_c
+! CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: [[SP]], entity: [[VAR_B]],{{.*}}file:{{.*}}line:
+! CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var_d", scope: [[SP]], entity: [[VAR_C]],{{.*}}file:{{.*}}line:
+
+! Check testmod2 import: module imported with rename in elements array
+! The module import should have elements containing the var_z rename
+! CHECK-DAG: [[MOD2_IMPORT:![0-9]+]] = !DIImportedEntity(tag: DW_TAG_imported_module, scope: [[SP]], entity: [[TESTMOD2]],{{.*}}elements: [[ELEMENTS:![0-9]+]]
+! CHECK-DAG: [[ELEMENTS]] = !{[[VAR_Z:![0-9]+]]}
+! CHECK-DAG: [[VAR_Z]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var_z",{{.*}}entity: [[VAR_Y]],
+
diff --git a/flang/test/Transforms/debug-imported-entity.fir b/flang/test/Transforms/debug-imported-entity.fir
index 194bc82724583..246bdd8bf4e95 100644
--- a/flang/test/Transforms/debug-imported-entity.fir
+++ b/flang/test/Transforms/debug-imported-entity.fir
@@ -11,6 +11,7 @@ module {
fir.has_value %c12_i32 : i32
} loc(#loc4)
func.func @test() attributes {fir.bindc_name = "test"} {
+ fir.use_stmt "foo"
%0 = fir.address_of(@_QMfooEv1) : !fir.ref<i32>
%1 = fircg.ext_declare %0 {uniq_name = "_QMfooEv1"} : (!fir.ref<i32>) -> !fir.ref<i32> loc(#loc1)
%4 = fir.address_of(@_QFtestExyz) : !fir.ref<i32>
diff --git a/flang/test/Transforms/debug-local-global-storage-1.fir b/flang/test/Transforms/debug-local-global-storage-1.fir
index 2638464dbab0b..6b9ea5b9dbb2d 100644
--- a/flang/test/Transforms/debug-local-global-storage-1.fir
+++ b/flang/test/Transforms/debug-local-global-storage-1.fir
@@ -2,6 +2,7 @@
module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<i64, dense<64> : vector<2xi64>>, #dlti.dl_entry<!llvm.ptr<272>, dense<64> : vector<4xi64>>, #dlti.dl_entry<!llvm.ptr<271>, dense<32> : vector<4xi64>>, #dlti.dl_entry<!llvm.ptr<270>, dense<32> : vector<4xi64>>, #dlti.dl_entry<f128, dense<128> : vector<2xi64>>, #dlti.dl_entry<f80, dense<128> : vector<2xi64>>, #dlti.dl_entry<i128, dense<128> : vector<2xi64>>, #dlti.dl_entry<i8, dense<8> : vector<2xi64>>, #dlti.dl_entry<!llvm.ptr, dense<64> : vector<4xi64>>, #dlti.dl_entry<i1, dense<8> : vector<2xi64>>, #dlti.dl_entry<f16, dense<16> : vector<2xi64>>, #dlti.dl_entry<f64, dense<64> : vector<2xi64>>, #dlti.dl_entry<i32, dense<32> : vector<2xi64>>, #dlti.dl_entry<i16, dense<16> : vector<2xi64>>, #dlti.dl_entry<"dlti.stack_alignment", 128 : i64>, #dlti.dl_entry<"dlti.endianness", "little">>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"} {
func.func @_QMexamplePmod_sub() {
+ fir.use_stmt "example"
%c2 = arith.constant 2 : index
%1 = fir.address_of(@_QMexampleEmod_arr) : !fir.ref<!fir.array<2x2xi32>>
%2 = fircg.ext_declare %1(%c2, %c2) {uniq_name = "_QMexampleEmod_arr"} : (!fir.ref<!fir.array<2x2xi32>>, index, index) -> !fir.ref<!fir.array<2x2xi32>> loc(#loc4)
diff --git a/flang/test/Transforms/debug-use-stmt.fir b/flang/test/Transforms/debug-use-stmt.fir
new file mode 100644
index 0000000000000..c1db92af072f4
--- /dev/null
+++ b/flang/test/Transforms/debug-use-stmt.fir
@@ ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/168541
More information about the flang-commits
mailing list