[flang-commits] [flang] [flang][FIR] allow mem2reg over fir.declare (PR #181848)
via flang-commits
flang-commits at lists.llvm.org
Tue Feb 17 08:15:34 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-codegen
@llvm/pr-subscribers-flang-fir-hlfir
Author: None (jeanPerier)
<details>
<summary>Changes</summary>
This patch adds the possibility for MLIR mem2reg to work over fir.declare.
Note that mem2reg is not part of FIR pipeline, and this is just part of work to be able to leverage it.
The patch:
- Adds a fir.declare_value operation
- Implements the PromotableOpInterface for fir.declare simple scalars and replace it by fir.declare_value.
- Generates llvm.dbg.debug_value from it (when a FusedLoc with a DILocalVariableAttr is created for it in AddDebugInfo, like for fir.declare).
---
Patch is 25.75 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/181848.diff
8 Files Affected:
- (modified) flang/include/flang/Optimizer/Dialect/FIROps.td (+32)
- (modified) flang/lib/Optimizer/CodeGen/CodeGen.cpp (+22-1)
- (modified) flang/lib/Optimizer/Dialect/FIROps.cpp (+80-6)
- (modified) flang/lib/Optimizer/Transforms/AddDebugInfo.cpp (+75-23)
- (added) flang/test/Fir/declare_value-codegen.fir (+17)
- (modified) flang/test/Fir/fir-ops.fir (+12)
- (modified) flang/test/Fir/invalid.fir (+8)
- (modified) flang/test/Fir/mem2reg.mlir (+117)
``````````diff
diff --git a/flang/include/flang/Optimizer/Dialect/FIROps.td b/flang/include/flang/Optimizer/Dialect/FIROps.td
index 02a204c9a6e26..ea7e0c2936672 100644
--- a/flang/include/flang/Optimizer/Dialect/FIROps.td
+++ b/flang/include/flang/Optimizer/Dialect/FIROps.td
@@ -3399,6 +3399,9 @@ def fir_DeclareOp
MemoryEffects<[MemAlloc<DebuggingResource>]>,
DeclareOpInterfaceMethods<
fir_FortranVariableStorageOpInterface>,
+ DeclareOpInterfaceMethods<PromotableOpInterface,
+ ["requiresReplacedValues",
+ "visitReplacedValues"]>,
fir_FortranObjectViewOpInterface]> {
let summary = "declare a variable";
@@ -3473,6 +3476,35 @@ def fir_DeclareOp
let hasVerifier = 1;
}
+def fir_DeclareValueOp
+ : fir_Op<"declare_value", [MemoryEffects<[MemAlloc<DebuggingResource>]>]> {
+ let summary = "declare a value";
+
+ let description = [{
+ Tie the properties of a simple scalar Fortran variable to a value.
+ The value must be a scalar integer, real, complex, or logical.
+ This is the value based version of fir.declare. It is used to keep track
+ of variable properties and debug info after mem2reg promotion.
+ }];
+
+ let arguments = (ins AnyType:$value,
+ Optional<fir_DummyScopeType>:$dummy_scope,
+ Builtin_StringAttr:$uniq_name,
+ OptionalAttr<fir_FortranVariableFlagsAttr>:$fortran_attrs,
+ OptionalAttr<cuf_DataAttributeAttr>:$data_attr,
+ OptionalAttr<UI32Attr>:$dummy_arg_no);
+
+ let results = (outs);
+
+ let assemblyFormat = [{
+ $value
+ (`dummy_scope` $dummy_scope^ (`arg` $dummy_arg_no^)?)?
+ attr-dict `:` type($value)
+ }];
+
+ let hasVerifier = 1;
+}
+
def fir_BoxOffsetOp : fir_Op<"box_offset", [NoMemoryEffect]> {
let summary = "Get the address of a field in a fir.ref<fir.box>";
diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
index f9d469f869619..93f3806b18648 100644
--- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp
+++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
@@ -237,6 +237,27 @@ struct DeclareOpConversion : public fir::FIROpConversion<fir::cg::XDeclareOp> {
return mlir::success();
}
};
+
+struct DeclareValueOpConversion
+ : public fir::FIROpConversion<fir::DeclareValueOp> {
+public:
+ using FIROpConversion::FIROpConversion;
+ llvm::LogicalResult
+ matchAndRewrite(fir::DeclareValueOp declareOp, OpAdaptor adaptor,
+ mlir::ConversionPatternRewriter &rewriter) const override {
+ auto value = adaptor.getOperands()[0];
+ if (auto fusedLoc = mlir::dyn_cast<mlir::FusedLoc>(declareOp.getLoc())) {
+ if (auto varAttr =
+ mlir::dyn_cast_or_null<mlir::LLVM::DILocalVariableAttr>(
+ fusedLoc.getMetadata())) {
+ mlir::LLVM::DbgValueOp::create(rewriter, value.getLoc(), value, varAttr,
+ nullptr);
+ }
+ }
+ rewriter.eraseOp(declareOp);
+ return mlir::success();
+ }
+};
} // namespace
namespace {
@@ -4528,7 +4549,7 @@ void fir::populateFIRToLLVMConversionPatterns(
BoxTypeCodeOpConversion, BoxTypeDescOpConversion, CallOpConversion,
CmpcOpConversion, VolatileCastOpConversion, ConvertOpConversion,
CoordinateOpConversion, CopyOpConversion, DTEntryOpConversion,
- DeclareOpConversion,
+ DeclareOpConversion, DeclareValueOpConversion,
DoConcurrentSpecifierOpConversion<fir::LocalitySpecifierOp>,
DoConcurrentSpecifierOpConversion<fir::DeclareReductionOp>,
DivcOpConversion, EmboxOpConversion, EmboxCharOpConversion,
diff --git a/flang/lib/Optimizer/Dialect/FIROps.cpp b/flang/lib/Optimizer/Dialect/FIROps.cpp
index 9c22b614d0cf9..03deba420ec4c 100644
--- a/flang/lib/Optimizer/Dialect/FIROps.cpp
+++ b/flang/lib/Optimizer/Dialect/FIROps.cpp
@@ -227,7 +227,25 @@ mlir::Value fir::AllocaOp::getDefaultValue(const mlir::MemorySlot &slot,
void fir::AllocaOp::handleBlockArgument(const mlir::MemorySlot &slot,
mlir::BlockArgument argument,
- mlir::OpBuilder &builder) {}
+ mlir::OpBuilder &builder) {
+ // When there is a fir.declare, fir.debug_value must be emitted at each value
+ // change and at each beginning of a block where the reaching value is
+ // propagated as a block argument.
+ // TODO: in order to get proper inter-dialect mem2reg, the
+ // PromotableOpInterface should be provided with a
+ // requiresInsertedBlockArguments similar to requiresReplacedValues so that
+ // fir::DeclareOp can be the one dictating that this needs to happen instead
+ // of the allocation. There are other challenges to inter dialect mem2reg to
+ // solve first, like having a common concept for going through converts and
+ // no-ops like fir.declare (i.e., to replace the FIR specific
+ // isSlotOrDeclaredSlot).
+ for (mlir::Operation *user : getOperation()->getUsers())
+ if (auto declareOp = mlir::dyn_cast<fir::DeclareOp>(user))
+ fir::DeclareValueOp::create(
+ builder, declareOp.getLoc(), argument, declareOp.getDummyScope(),
+ declareOp.getUniqNameAttr(), declareOp.getFortranAttrsAttr(),
+ declareOp.getDataAttrAttr(), declareOp.getDummyArgNoAttr());
+}
std::optional<mlir::PromotableAllocationOpInterface>
fir::AllocaOp::handlePromotionComplete(const mlir::MemorySlot &slot,
@@ -2961,8 +2979,17 @@ llvm::SmallVector<mlir::Attribute> fir::LenParamIndexOp::getAttributes() {
// LoadOp
//===----------------------------------------------------------------------===//
+static bool isSlotOrDeclaredSlot(mlir::Value val,
+ const mlir::MemorySlot &slot) {
+ if (val == slot.ptr)
+ return true;
+ if (auto declareOp = val.getDefiningOp<fir::DeclareOp>())
+ return declareOp.getMemref() == slot.ptr;
+ return false;
+}
+
bool fir::LoadOp::loadsFrom(const mlir::MemorySlot &slot) {
- return getMemref() == slot.ptr;
+ return isSlotOrDeclaredSlot(getMemref(), slot);
}
bool fir::LoadOp::storesTo(const mlir::MemorySlot &slot) { return false; }
@@ -2982,7 +3009,7 @@ bool fir::LoadOp::canUsesBeRemoved(
if (blockingUses.size() != 1)
return false;
mlir::Value blockingUse = (*blockingUses.begin())->get();
- return blockingUse == slot.ptr && getMemref() == slot.ptr;
+ return isSlotOrDeclaredSlot(blockingUse, slot) && getMemref() == blockingUse;
}
mlir::DeletionKind fir::LoadOp::removeBlockingUses(
@@ -4397,7 +4424,7 @@ llvm::LogicalResult fir::SliceOp::verify() {
bool fir::StoreOp::loadsFrom(const mlir::MemorySlot &slot) { return false; }
bool fir::StoreOp::storesTo(const mlir::MemorySlot &slot) {
- return getMemref() == slot.ptr;
+ return isSlotOrDeclaredSlot(getMemref(), slot);
}
mlir::Value fir::StoreOp::getStored(const mlir::MemorySlot &slot,
@@ -4415,8 +4442,8 @@ bool fir::StoreOp::canUsesBeRemoved(
if (blockingUses.size() != 1)
return false;
mlir::Value blockingUse = (*blockingUses.begin())->get();
- return blockingUse == slot.ptr && getMemref() == slot.ptr &&
- getValue() != slot.ptr;
+ return isSlotOrDeclaredSlot(blockingUse, slot) &&
+ getMemref() == blockingUse && getValue() != blockingUse;
}
mlir::DeletionKind fir::StoreOp::removeBlockingUses(
@@ -5247,6 +5274,22 @@ std::optional<int64_t> fir::getAllocaByteSize(fir::AllocaOp alloca,
return std::nullopt;
}
+//===----------------------------------------------------------------------===//
+// DeclareValueOp
+//===----------------------------------------------------------------------===//
+
+static bool isLegalTypeForValueDeclare(mlir::Type type) {
+ return mlir::isa<mlir::IntegerType, mlir::FloatType, mlir::ComplexType,
+ fir::LogicalType>(type);
+}
+
+llvm::LogicalResult fir::DeclareValueOp::verify() {
+ if (!isLegalTypeForValueDeclare(getValue().getType()))
+ return emitOpError(
+ "value must be a simple scalar (integer, real, complex, or logical)");
+ return mlir::success();
+}
+
//===----------------------------------------------------------------------===//
// DeclareOp
//===----------------------------------------------------------------------===//
@@ -5257,6 +5300,37 @@ llvm::LogicalResult fir::DeclareOp::verify() {
return fortranVar.verifyDeclareLikeOpImpl(getMemref());
}
+bool fir::DeclareOp::canUsesBeRemoved(
+ const mlir::SmallPtrSetImpl<mlir::OpOperand *> &blockingUses,
+ mlir::SmallVectorImpl<mlir::OpOperand *> &newBlockingUses,
+ const mlir::DataLayout &dataLayout) {
+ if (!isLegalTypeForValueDeclare(fir::unwrapRefType(getType())))
+ return false;
+ // Forward uses to the users of the fir.declare.
+ for (mlir::OpOperand &use : getResult().getUses())
+ newBlockingUses.push_back(&use);
+ return true;
+}
+
+mlir::DeletionKind fir::DeclareOp::removeBlockingUses(
+ const mlir::SmallPtrSetImpl<mlir::OpOperand *> &blockingUses,
+ mlir::OpBuilder &builder) {
+ return mlir::DeletionKind::Delete;
+}
+
+bool fir::DeclareOp::requiresReplacedValues() { return true; }
+
+void fir::DeclareOp::visitReplacedValues(
+ llvm::ArrayRef<std::pair<mlir::Operation *, mlir::Value>> definitions,
+ mlir::OpBuilder &builder) {
+ for (auto [op, value] : definitions) {
+ builder.setInsertionPointAfter(op);
+ fir::DeclareValueOp::create(builder, getLoc(), value, getDummyScope(),
+ getUniqNameAttr(), getFortranAttrsAttr(),
+ getDataAttrAttr(), getDummyArgNoAttr());
+ }
+}
+
//===----------------------------------------------------------------------===//
// PackArrayOp
//===----------------------------------------------------------------------===//
diff --git a/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp b/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp
index 35d8a2f6c3aa9..42080dacc731a 100644
--- a/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp
+++ b/flang/lib/Optimizer/Transforms/AddDebugInfo.cpp
@@ -54,6 +54,12 @@ class AddDebugInfoPass : public fir::impl::AddDebugInfoBase<AddDebugInfoPass> {
mlir::LLVM::DIScopeAttr scopeAttr,
fir::DebugTypeGenerator &typeGen,
mlir::SymbolTable *symbolTable, mlir::Value dummyScope);
+ void handleDeclareValueOp(fir::DeclareValueOp declOp,
+ mlir::LLVM::DIFileAttr fileAttr,
+ mlir::LLVM::DIScopeAttr scopeAttr,
+ fir::DebugTypeGenerator &typeGen,
+ mlir::SymbolTable *symbolTable,
+ mlir::Value dummyScope);
public:
AddDebugInfoPass(fir::AddDebugInfoOptions options) : Base(options) {}
@@ -112,6 +118,14 @@ class AddDebugInfoPass : public fir::impl::AddDebugInfoBase<AddDebugInfoPass> {
getModuleAttrFromGlobalOp(fir::GlobalOp globalOp,
mlir::LLVM::DIFileAttr fileAttr,
mlir::LLVM::DIScopeAttr scope);
+
+ template <typename Op>
+ void handleLocalVariable(Op declOp, llvm::StringRef name,
+ mlir::LLVM::DIFileAttr fileAttr,
+ mlir::LLVM::DIScopeAttr scopeAttr,
+ fir::DebugTypeGenerator &typeGen,
+ mlir::Value dummyScope, mlir::Type typeToConvert,
+ fir::cg::XDeclareOp typeGenDeclOp);
};
bool debugInfoIsAlreadySet(mlir::Location loc) {
@@ -266,14 +280,40 @@ bool AddDebugInfoPass::createCommonBlockGlobal(
return true;
}
+template <typename Op>
+void AddDebugInfoPass::handleLocalVariable(Op declOp, llvm::StringRef name,
+ mlir::LLVM::DIFileAttr fileAttr,
+ mlir::LLVM::DIScopeAttr scopeAttr,
+ fir::DebugTypeGenerator &typeGen,
+ mlir::Value dummyScope,
+ mlir::Type typeToConvert,
+ fir::cg::XDeclareOp typeGenDeclOp) {
+ mlir::MLIRContext *context = &getContext();
+ mlir::OpBuilder builder(context);
+
+ // Get the dummy argument position from the explicit attribute.
+ unsigned argNo = 0;
+ if (dummyScope && declOp.getDummyScope() == dummyScope) {
+ if (auto argNoOpt = declOp.getDummyArgNo())
+ argNo = *argNoOpt;
+ }
+
+ auto tyAttr =
+ typeGen.convertType(typeToConvert, fileAttr, scopeAttr, typeGenDeclOp);
+
+ auto localVarAttr = mlir::LLVM::DILocalVariableAttr::get(
+ context, scopeAttr, mlir::StringAttr::get(context, name), fileAttr,
+ getLineFromLoc(declOp.getLoc()), argNo, /* alignInBits*/ 0, tyAttr,
+ mlir::LLVM::DIFlags::Zero);
+ declOp->setLoc(builder.getFusedLoc({declOp->getLoc()}, localVarAttr));
+}
+
void AddDebugInfoPass::handleDeclareOp(fir::cg::XDeclareOp declOp,
mlir::LLVM::DIFileAttr fileAttr,
mlir::LLVM::DIScopeAttr scopeAttr,
fir::DebugTypeGenerator &typeGen,
mlir::SymbolTable *symbolTable,
mlir::Value dummyScope) {
- mlir::MLIRContext *context = &getContext();
- mlir::OpBuilder builder(context);
auto result = fir::NameUniquer::deconstruct(declOp.getUniqName());
if (result.first != fir::NameUniquer::NameKind::VARIABLE)
@@ -293,21 +333,23 @@ void AddDebugInfoPass::handleDeclareOp(fir::cg::XDeclareOp declOp,
}
}
- // Get the dummy argument position from the explicit attribute.
- unsigned argNo = 0;
- if (dummyScope && declOp.getDummyScope() == dummyScope) {
- if (auto argNoOpt = declOp.getDummyArgNo())
- argNo = *argNoOpt;
- }
+ handleLocalVariable(declOp, result.second.name, fileAttr, scopeAttr, typeGen,
+ dummyScope, fir::unwrapRefType(declOp.getType()), declOp);
+}
- auto tyAttr = typeGen.convertType(fir::unwrapRefType(declOp.getType()),
- fileAttr, scopeAttr, declOp);
+void AddDebugInfoPass::handleDeclareValueOp(fir::DeclareValueOp declOp,
+ mlir::LLVM::DIFileAttr fileAttr,
+ mlir::LLVM::DIScopeAttr scopeAttr,
+ fir::DebugTypeGenerator &typeGen,
+ mlir::SymbolTable *symbolTable,
+ mlir::Value dummyScope) {
+ auto result = fir::NameUniquer::deconstruct(declOp.getUniqName());
- auto localVarAttr = mlir::LLVM::DILocalVariableAttr::get(
- context, scopeAttr, mlir::StringAttr::get(context, result.second.name),
- fileAttr, getLineFromLoc(declOp.getLoc()), argNo, /* alignInBits*/ 0,
- tyAttr, mlir::LLVM::DIFlags::Zero);
- declOp->setLoc(builder.getFusedLoc({declOp->getLoc()}, localVarAttr));
+ if (result.first != fir::NameUniquer::NameKind::VARIABLE)
+ return;
+
+ handleLocalVariable(declOp, result.second.name, fileAttr, scopeAttr, typeGen,
+ dummyScope, declOp.getValue().getType(), nullptr);
}
mlir::LLVM::DICommonBlockAttr AddDebugInfoPass::getOrCreateCommonBlockAttr(
@@ -428,6 +470,18 @@ void AddDebugInfoPass::handleGlobalOp(fir::GlobalOp globalOp,
globalOp->setLoc(builder.getFusedLoc({globalOp.getLoc()}, arrayAttr));
}
+static mlir::LLVM::DISubprogramAttr
+getScope(mlir::Operation *op, mlir::LLVM::DISubprogramAttr defaultScope) {
+ if (auto tOp = op->getParentOfType<mlir::omp::TargetOp>()) {
+ if (auto fusedLoc = llvm::dyn_cast<mlir::FusedLoc>(tOp.getLoc())) {
+ if (auto sp = llvm::dyn_cast<mlir::LLVM::DISubprogramAttr>(
+ fusedLoc.getMetadata()))
+ return sp;
+ }
+ }
+ return defaultScope;
+}
+
void AddDebugInfoPass::handleFuncOp(mlir::func::FuncOp funcOp,
mlir::LLVM::DIFileAttr fileAttr,
mlir::LLVM::DICompileUnitAttr cuAttr,
@@ -687,16 +741,14 @@ void AddDebugInfoPass::handleFuncOp(mlir::func::FuncOp funcOp,
});
funcOp.walk([&](fir::cg::XDeclareOp declOp) {
- mlir::LLVM::DISubprogramAttr spTy = spAttr;
- if (auto tOp = declOp->getParentOfType<mlir::omp::TargetOp>()) {
- if (auto fusedLoc = llvm::dyn_cast<mlir::FusedLoc>(tOp.getLoc())) {
- if (auto sp = llvm::dyn_cast<mlir::LLVM::DISubprogramAttr>(
- fusedLoc.getMetadata()))
- spTy = sp;
- }
- }
+ mlir::LLVM::DISubprogramAttr spTy = getScope(declOp, spAttr);
handleDeclareOp(declOp, fileAttr, spTy, typeGen, symbolTable, dummyScope);
});
+ funcOp.walk([&](fir::DeclareValueOp declOp) {
+ mlir::LLVM::DISubprogramAttr spTy = getScope(declOp, spAttr);
+ handleDeclareValueOp(declOp, fileAttr, spTy, typeGen, symbolTable,
+ dummyScope);
+ });
// commonBlockMap ensures that we don't create multiple DICommonBlockAttr of
// the same name in one function. But it is ok (rather required) to create
// them in different functions if common block of the same name has been used
diff --git a/flang/test/Fir/declare_value-codegen.fir b/flang/test/Fir/declare_value-codegen.fir
new file mode 100644
index 0000000000000..4b50c6f535c1f
--- /dev/null
+++ b/flang/test/Fir/declare_value-codegen.fir
@@ -0,0 +1,17 @@
+// RUN: fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s | FileCheck %s
+
+module attributes {dlti.dl_spec = #dlti.dl_spec<>} {
+ func.func @test_codegen(%arg0: i32) {
+ fir.declare_value %arg0 {uniq_name = "test"} : i32 loc(#loc1)
+ return
+ }
+}
+
+#di_file = #llvm.di_file<"test.f90" in "">
+#di_compile_unit = #llvm.di_compile_unit<id = distinct[0]<>, sourceLanguage = DW_LANG_Fortran95, file = #di_file, producer = "Flang", isOptimized = false, emissionKind = Full>
+#di_subprogram = #llvm.di_subprogram<compileUnit = #di_compile_unit, scope = #di_file, name = "test_codegen", file = #di_file, subprogramFlags = Definition>
+#di_local_variable = #llvm.di_local_variable<scope = #di_subprogram, name = "test", file = #di_file, line = 1, arg = 1, alignInBits = 0, type = #llvm.di_basic_type<tag = DW_TAG_base_type, name = "integer", sizeInBits = 32, encoding = DW_ATE_signed>>
+#loc1 = loc(fused<#di_local_variable>["test.f90":1:1])
+
+// CHECK-LABEL: llvm.func @test_codegen
+// CHECK: llvm.intr.dbg.value
diff --git a/flang/test/Fir/fir-ops.fir b/flang/test/Fir/fir-ops.fir
index 8336b6d89e721..51c064290de35 100644
--- a/flang/test/Fir/fir-ops.fir
+++ b/flang/test/Fir/fir-ops.fir
@@ -1048,3 +1048,15 @@ func.func @test_if_weights(%cond: i1) {
}
return
}
+
+// CHECK-LABEL: func @test_declare_value(
+// CHECK-SAME: %[[VAL_0:.*]]: i32, %[[VAL_1:.*]]: !fir.dscope) {
+func.func @test_declare_value(%arg0: i32, %scope: !fir.dscope) {
+// CHECK: fir.declare_value %[[VAL_0]] {uniq_name = "test"} : i32
+ fir.declare_value %arg0 {uniq_name = "test"} : i32
+// CHECK: fir.declare_value %[[VAL_0]] dummy_scope %[[VAL_1]] {uniq_name = "test"} : i32
+ fir.declare_value %arg0 dummy_scope %scope {uniq_name = "test"} : i32
+// CHECK: fir.declare_value %[[VAL_0]] dummy_scope %[[VAL_1]] arg 1 {uniq_name = "test"} : i32
+ fir.declare_value %arg0 dummy_scope %scope arg 1 {uniq_name = "test"} : i32
+ return
+}
diff --git a/flang/test/Fir/invalid.fir b/flang/test/Fir/invalid.fir
index 553f69ccf83fd..e37e8ec77fcb7 100644
--- a/flang/test/Fir/invalid.fir
+++ b/flang/test/Fir/invalid.fir
@@ -1483,3 +1483,11 @@ func.func @fir_declare_bad_storage_offset(%arg0: !fir.ref<i8>, %arg1: !fir.ref<!
%decl = fir.declare %arg0 storage (%arg1[2]) {uniq_name = "a"} : (!fir.ref<i8>, !fir.ref<!fir.array<1xi8>>) -> !fir.ref<i8>
return
}
+
+// -----
+
+func.func @bad_declare_value(%arg0: !fir.ref<i32>) {
+ // expected-error at +1 {{'fir.declare_value' op value must be a simple scalar (integer, real, complex, or logical)}}
+ fir.declare_value %arg0 {uniq_name = "test"} : !fir.ref<i32>
+ return
+}
diff --git a/flang/test/Fir/mem2reg.mlir b/flang/test/Fir/mem2reg.mlir
index 25d114a55e1a4..0329dfc6f26d2 100644
--- a/flang/test/Fir/mem2reg.mlir
+++ b/flang/test/Fir/mem2reg.mlir
@@ -66,3 +66,...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/181848
More information about the flang-commits
mailing list