[llvm-branch-commits] [flang] [flang] Add fir.assert and its LLVM code generation (PR #231245)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Oct 12 10:54:11 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: jeanPerier
<details>
<summary>Changes</summary>
Add the new fir.assert operation for which the design was introduced in https://github.com/llvm/llvm-project/pull/228502
Verify its message and diagnostic operands, and erase constant-true assertions. Keep attribute and optionality queries able to inspect guarded values without making rewriting operations transparent to the guard.
For the LLVM code generation, generate assertions to a weighted branch, a noreturn runtime call on failure, and guarded operands on success. Pack larger diagnostic payloads into an array on the failure path and preserve source locations and device symbol scope. Add dialect, code generation, effect, and variable-query tests.
This introduces the operation without emitting it from source lowering.
Assisted-by: AI
---
Patch is 37.27 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/231245.diff
12 Files Affected:
- (modified) flang/include/flang/Optimizer/Dialect/FIRAttr.td (+19)
- (modified) flang/include/flang/Optimizer/Dialect/FIROps.h (+7)
- (modified) flang/include/flang/Optimizer/Dialect/FIROps.td (+45)
- (modified) flang/lib/Optimizer/CodeGen/CodeGen.cpp (+145-1)
- (modified) flang/lib/Optimizer/Dialect/FIROps.cpp (+74-3)
- (added) flang/test/Fir/assert-array-codegen.fir (+75)
- (added) flang/test/Fir/assert-codegen.fir (+68)
- (added) flang/test/Fir/assert-invalid.fir (+71)
- (added) flang/test/Fir/assert-memory.fir (+45)
- (added) flang/test/Fir/assert-no-fold-through.fir (+16)
- (added) flang/test/Fir/assert.fir (+72)
- (modified) flang/unittests/Optimizer/FortranVariableTest.cpp (+66)
``````````diff
diff --git a/flang/include/flang/Optimizer/Dialect/FIRAttr.td b/flang/include/flang/Optimizer/Dialect/FIRAttr.td
index 88d7964768b5a..581c831c8985e 100644
--- a/flang/include/flang/Optimizer/Dialect/FIRAttr.td
+++ b/flang/include/flang/Optimizer/Dialect/FIRAttr.td
@@ -189,6 +189,25 @@ def fir_ReduceAttr : fir_Attr<"Reduce"> {
// mlir::SideEffects::Resource for modelling operations which add debugging information
def DebuggingResource : Resource<"::fir::DebuggingResource">;
+def FortranRuntimeResource : Resource<"::fir::FortranRuntimeResource">;
+
+def fir_RuntimeCheckKind : I32EnumAttr<"RuntimeCheckKind",
+ "Fortran runtime check category", [
+ I32EnumAttrCase<"status", 0>,
+ I32EnumAttrCase<"conformance", 1>,
+ I32EnumAttrCase<"argument", 2>,
+ I32EnumAttrCase<"bounds", 3>,
+ I32EnumAttrCase<"pointer", 4>,
+ I32EnumAttrCase<"doLoop", 5, "do">,
+ I32EnumAttrCase<"bits", 6>,
+ I32EnumAttrCase<"divide", 7>
+ ]> {
+ let genSpecializedAttr = 0;
+ let cppNamespace = "::fir";
+}
+def fir_RuntimeCheckKindAttr
+ : EnumAttr<FIROpsDialect, fir_RuntimeCheckKind, "runtime_check_kind">;
+
def fir_LowerBoundModifierAttribute : I32EnumAttr<
"LowerBoundModifierAttribute",
"Describes how to modify lower bounds",
diff --git a/flang/include/flang/Optimizer/Dialect/FIROps.h b/flang/include/flang/Optimizer/Dialect/FIROps.h
index 9d771b1e60604..5ea6cb81587ba 100644
--- a/flang/include/flang/Optimizer/Dialect/FIROps.h
+++ b/flang/include/flang/Optimizer/Dialect/FIROps.h
@@ -54,6 +54,13 @@ struct DebuggingResource
bool isAddressable() const override { return false; }
};
+/// Runtime checks can terminate execution, but do not access user memory.
+struct FortranRuntimeResource
+ : public mlir::SideEffects::Resource::Base<FortranRuntimeResource> {
+ mlir::StringRef getName() const final { return "FortranRuntimeResource"; }
+ bool isAddressable() const override { return false; }
+};
+
/// Model operations which read from/write to volatile memory
struct VolatileMemoryResource
: public mlir::SideEffects::Resource::Base<VolatileMemoryResource> {
diff --git a/flang/include/flang/Optimizer/Dialect/FIROps.td b/flang/include/flang/Optimizer/Dialect/FIROps.td
index 7fc12430d0663..9d9ffe4ee9b3b 100644
--- a/flang/include/flang/Optimizer/Dialect/FIROps.td
+++ b/flang/include/flang/Optimizer/Dialect/FIROps.td
@@ -81,6 +81,51 @@ def AnyRefOfConstantSizeAggregateType : TypeConstraint<
// Memory SSA operations
//===----------------------------------------------------------------------===//
+def fir_AssertOp : fir_Op<"assert", [
+ AttrSizedOperandSegments,
+ TypesMatchWith<"result types match guarded operand types", "guarded",
+ "results", "$_self">,
+ MemoryEffects<[MemWrite<FortranRuntimeResource>]>]> {
+ let summary = "check a condition and guard values used by subsequent operations";
+ let description = [{
+ If `condition` is true, each result equals the corresponding `guarded`
+ operand. Otherwise, execution terminates through the Fortran runtime,
+ reporting `message` at the operation's source location. The message may
+ contain `%lld` directives, one for each integer or index operand
+ in `values`, and `%%` for a literal percent sign. Diagnostic values are
+ interpreted as signed integers and must fit in 64 bits.
+
+ Consumers of the results depend on the check. The operation is deliberately
+ not speculatable or a view: looking through it in a rewrite would discard
+ that dependence. Analyses may inspect the guarded operands. Its write to
+ a non-addressable runtime resource preserves checks without obstructing
+ memory optimizations.
+
+ Guard array bases and scalar operands used by the protected computation.
+ FIR users of shape and slice metadata may require direct constructor
+ operands; guard the underlying extents or indices before constructing that
+ metadata instead.
+ }];
+ let arguments = (ins I1:$condition, fir_RuntimeCheckKindAttr:$kind,
+ StrAttr:$message,
+ Variadic<AnySignlessIntegerOrIndex>:$values,
+ Variadic<AnyType>:$guarded);
+ let results = (outs Variadic<AnyType>:$results);
+ let assemblyFormat = [{
+ $condition `,` enum($kind) `,` $message
+ (`values` `(` $values^ `:` type($values) `)`)?
+ (`guard` `(` $guarded^ `:` type($guarded) `)`)? attr-dict
+ }];
+ let builders = [OpBuilder<(ins "mlir::Value":$condition,
+ "fir::RuntimeCheckKind":$kind, "llvm::StringRef":$message,
+ "mlir::ValueRange":$values, "mlir::ValueRange":$guarded), [{
+ build($_builder, $_state, guarded.getTypes(), condition, kind, message,
+ values, guarded);
+ }]>];
+ let hasVerifier = 1;
+ let hasCanonicalizer = 1;
+}
+
def fir_AllocaOp : fir_Op<"alloca", [
AttrSizedOperandSegments,
DeclareOpInterfaceMethods<PromotableAllocationOpInterface>
diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
index 3eec423b5669b..29a5ef06cc732 100644
--- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp
+++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
@@ -4415,6 +4415,150 @@ struct UnreachableOpConversion
}
};
+/// Prefer the original source of an inlined operation to its call site.
+static mlir::FileLineColLoc findAssertSourceLocation(mlir::Location loc) {
+ if (auto file = mlir::dyn_cast<mlir::FileLineColLoc>(loc))
+ return file;
+ if (auto call = mlir::dyn_cast<mlir::CallSiteLoc>(loc)) {
+ if (auto file = findAssertSourceLocation(call.getCallee()))
+ return file;
+ return findAssertSourceLocation(call.getCaller());
+ }
+ if (auto fused = mlir::dyn_cast<mlir::FusedLoc>(loc))
+ for (mlir::Location nested : fused.getLocations())
+ if (auto file = findAssertSourceLocation(nested))
+ return file;
+ if (auto named = mlir::dyn_cast<mlir::NameLoc>(loc))
+ return findAssertSourceLocation(named.getChildLoc());
+ return {};
+}
+
+struct AssertOpConversion : public fir::FIROpConversion<fir::AssertOp> {
+ using FIROpConversion::FIROpConversion;
+
+ llvm::LogicalResult
+ matchAndRewrite(fir::AssertOp op, OpAdaptor adaptor,
+ mlir::ConversionPatternRewriter &rewriter) const override {
+ mlir::Location loc = op.getLoc();
+ // A device function's strings and runtime declaration must remain in its
+ // GPU module when host and device modules are subsequently separated.
+ mlir::Operation *scope = mlir::SymbolTable::getNearestSymbolTable(op);
+ auto ptrTy = getLlvmPtrType(op.getContext());
+ auto i64Ty = rewriter.getI64Type();
+ auto countTy = rewriter.getIntegerType(lowerTy().getPointerBitwidth(0));
+ bool useArray = adaptor.getValues().size() > 4;
+ llvm::SmallVector<mlir::Type> argumentTypes{ptrTy, ptrTy,
+ rewriter.getI32Type()};
+ if (useArray)
+ argumentTypes.append({countTy, ptrTy});
+ else
+ argumentTypes.append(4, i64Ty);
+ auto functionType = mlir::LLVM::LLVMFunctionType::get(
+ mlir::LLVM::LLVMVoidType::get(op.getContext()), argumentTypes);
+ llvm::StringRef runtimeName =
+ useArray ? "_FortranAReportFatalUserErrorValueArray"
+ : "_FortranAReportFatalUserErrorValues";
+ mlir::Operation *declaration =
+ mlir::SymbolTable::lookupSymbolIn(scope, runtimeName);
+ if (declaration) {
+ if (auto function = mlir::dyn_cast<mlir::LLVM::LLVMFuncOp>(declaration)) {
+ if (function.getFunctionType() != functionType)
+ return op.emitOpError("incompatible runtime function declaration");
+ rewriter.modifyOpInPlace(function, [&] { function.setNoreturn(true); });
+ } else if (auto function =
+ mlir::dyn_cast<mlir::func::FuncOp>(declaration)) {
+ if (function.getNumResults() != 0 ||
+ function.getNumArguments() != functionType.getNumParams())
+ return op.emitOpError("incompatible runtime function declaration");
+ for (auto [input, expected] : llvm::zip_equal(
+ function.getArgumentTypes(), functionType.getParams()))
+ if (convertType(input) != expected)
+ return op.emitOpError("incompatible runtime function declaration");
+ rewriter.modifyOpInPlace(function, [&] {
+ function->setAttr("llvm.noreturn", rewriter.getUnitAttr());
+ });
+ } else {
+ return op.emitOpError("runtime function name conflicts with a symbol");
+ }
+ } else {
+ mlir::OpBuilder::InsertionGuard guard(rewriter);
+ rewriter.setInsertionPointToStart(&scope->getRegion(0).front());
+ auto function = mlir::LLVM::LLVMFuncOp::create(rewriter, loc, runtimeName,
+ functionType);
+ function.setNoreturn(true);
+ }
+
+ mlir::Block *before = op->getBlock();
+ mlir::Block *continuation =
+ rewriter.splitBlock(before, mlir::Block::iterator(op));
+ mlir::Block *failure = rewriter.createBlock(before->getParent());
+
+ auto stringAddress = [&](llvm::StringRef text) -> mlir::Value {
+ std::string terminated = text.str() + '\0';
+ std::string name = fir::factory::uniqueCGIdent("assert", terminated);
+ if (!mlir::SymbolTable::lookupSymbolIn(scope, name)) {
+ mlir::OpBuilder::InsertionGuard guard(rewriter);
+ rewriter.setInsertionPointToStart(&scope->getRegion(0).front());
+ auto arrayTy = mlir::LLVM::LLVMArrayType::get(rewriter.getI8Type(),
+ terminated.size());
+ mlir::LLVM::GlobalOp::create(rewriter, loc, arrayTy, /*constant=*/true,
+ mlir::LLVM::Linkage::Internal, name,
+ rewriter.getStringAttr(terminated));
+ }
+ return mlir::LLVM::AddressOfOp::create(rewriter, loc, ptrTy, name);
+ };
+
+ mlir::Value message = stringAddress(op.getMessage());
+ mlir::FileLineColLoc source = findAssertSourceLocation(loc);
+ mlir::Value filename =
+ source ? stringAddress(source.getFilename().getValue())
+ : mlir::LLVM::ZeroOp::create(rewriter, loc, ptrTy);
+ mlir::Value line =
+ genI32Constant(loc, rewriter, source ? source.getLine() : 0);
+ llvm::SmallVector<mlir::Value> arguments{message, filename, line};
+ if (useArray) {
+ // Materialize diagnostic storage only on the failure path. Keep the
+ // values in SSA form until here so they add no memory dependencies to
+ // the high-level assertion.
+ mlir::Value count = fir::genConstantIndex(loc, countTy, rewriter,
+ adaptor.getValues().size());
+ auto storagePtrTy =
+ getLlvmPtrType(op.getContext(), getAllocaAddressSpace(rewriter));
+ mlir::Value storage = mlir::LLVM::AllocaOp::create(
+ rewriter, loc, storagePtrTy, i64Ty, count);
+ for (auto [index, value] : llvm::enumerate(adaptor.getValues())) {
+ mlir::Value offset =
+ fir::genConstantIndex(loc, countTy, rewriter, index);
+ mlir::Value address = mlir::LLVM::GEPOp::create(
+ rewriter, loc, storagePtrTy, i64Ty, storage,
+ llvm::ArrayRef<mlir::LLVM::GEPArg>{offset});
+ mlir::LLVM::StoreOp::create(
+ rewriter, loc, integerCast(loc, rewriter, i64Ty, value), address);
+ }
+ if (storagePtrTy != ptrTy)
+ storage =
+ mlir::LLVM::AddrSpaceCastOp::create(rewriter, loc, ptrTy, storage);
+ arguments.append({count, storage});
+ } else {
+ for (mlir::Value value : adaptor.getValues())
+ arguments.push_back(integerCast(loc, rewriter, i64Ty, value));
+ while (arguments.size() < 7)
+ arguments.push_back(mlir::LLVM::ConstantOp::create(
+ rewriter, loc, i64Ty, rewriter.getI64IntegerAttr(0)));
+ }
+ mlir::LLVM::CallOp::create(rewriter, loc, functionType, runtimeName,
+ arguments);
+ mlir::LLVM::UnreachableOp::create(rewriter, loc);
+
+ rewriter.setInsertionPointToEnd(before);
+ mlir::LLVM::CondBrOp::create(rewriter, loc, adaptor.getCondition(),
+ continuation, mlir::ValueRange{}, failure,
+ mlir::ValueRange{}, std::make_pair(2000u, 1u));
+ rewriter.replaceOp(op, adaptor.getGuarded());
+ return mlir::success();
+ }
+};
+
/// `fir.is_present` -->
/// ```
/// %0 = llvm.mlir.constant(0 : i64)
@@ -5193,7 +5337,7 @@ void fir::populateFIRToLLVMConversionPatterns(
StoreOpConversion, StringLitOpConversion, SubcOpConversion,
TypeDescOpConversion, TypeInfoOpConversion, UnboxCharOpConversion,
UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion,
- UseStmtOpConversion, ModuleDebugImportsOpConversion,
+ AssertOpConversion, UseStmtOpConversion, ModuleDebugImportsOpConversion,
XArrayCoorOpConversion, XEmboxOpConversion, XReboxOpConversion,
ZeroOpConversion>(converter, options);
diff --git a/flang/lib/Optimizer/Dialect/FIROps.cpp b/flang/lib/Optimizer/Dialect/FIROps.cpp
index 606d47631488b..4f3ab9984f99e 100644
--- a/flang/lib/Optimizer/Dialect/FIROps.cpp
+++ b/flang/lib/Optimizer/Dialect/FIROps.cpp
@@ -56,6 +56,59 @@ bool fir::useStrictVolatileVerification() {
return clUseStrictVolatileVerification;
}
+//===----------------------------------------------------------------------===//
+// AssertOp
+//===----------------------------------------------------------------------===//
+
+llvm::LogicalResult fir::AssertOp::verify() {
+ if (getGuarded().getTypes() != getResultTypes())
+ return emitOpError("result types must match guarded operand types");
+ for (mlir::Type type : getValues().getTypes())
+ if (auto integer = mlir::dyn_cast<mlir::IntegerType>(type))
+ if (integer.getWidth() > 64)
+ return emitOpError("diagnostic integers must be at most 64 bits wide");
+
+ llvm::StringRef message = getMessage();
+ if (message.contains('\0'))
+ return emitOpError("message must not contain an embedded null character");
+ unsigned directives = 0;
+ while (!message.empty()) {
+ size_t percent = message.find('%');
+ if (percent == llvm::StringRef::npos)
+ break;
+ message = message.drop_front(percent + 1);
+ if (message.consume_front("%"))
+ continue;
+ if (!message.consume_front("lld"))
+ return emitOpError("message supports only %lld and %% format directives");
+ ++directives;
+ }
+ if (directives != getValues().size())
+ return emitOpError(
+ "number of %lld directives must match diagnostic values");
+ return mlir::success();
+}
+
+namespace {
+struct RemoveTrueAssert : mlir::OpRewritePattern<fir::AssertOp> {
+ using OpRewritePattern::OpRewritePattern;
+
+ llvm::LogicalResult
+ matchAndRewrite(fir::AssertOp op,
+ mlir::PatternRewriter &rewriter) const override {
+ if (!mlir::matchPattern(op.getCondition(), mlir::m_One()))
+ return mlir::failure();
+ rewriter.replaceOp(op, op.getGuarded());
+ return mlir::success();
+ }
+};
+} // namespace
+
+void fir::AssertOp::getCanonicalizationPatterns(
+ mlir::RewritePatternSet &patterns, mlir::MLIRContext *context) {
+ patterns.add<RemoveTrueAssert>(context);
+}
+
static void propagateAttributes(mlir::Operation *fromOp,
mlir::Operation *toOp) {
if (!fromOp || !toOp)
@@ -247,6 +300,13 @@ bool fir::mayBeAbsentBox(mlir::Value val) {
if (auto varIface = mlir::dyn_cast<fir::FortranVariableOpInterface>(defOp))
return varIface.isOptional();
+ if (auto assertOp = mlir::dyn_cast<fir::AssertOp>(defOp)) {
+ val =
+ assertOp
+ .getGuarded()[mlir::cast<mlir::OpResult>(val).getResultNumber()];
+ continue;
+ }
+
// Check for fir.embox and fir.rebox before checking for
// FortranObjectViewOpInterface, which they support.
// A box created by fir.embox/fir.rebox/fir.rebox_assumed_rank is only
@@ -6104,10 +6164,21 @@ valueCheckFirAttributes(mlir::Value value,
};
// If this is a fir.box that was loaded, the fir attributes will be on the
// related fir.ref<fir.box> creation.
- if (mlir::isa<fir::BoxType>(value.getType()))
- if (auto definingOp = value.getDefiningOp())
- if (auto loadOp = mlir::dyn_cast<fir::LoadOp>(definingOp))
+ // This is an attribute query only. Do not make rewriting helpers transparent
+ // to guards: replacing a guarded use with its origin loses the check.
+ while (true) {
+ if (auto assertOp = value.getDefiningOp<fir::AssertOp>()) {
+ value = assertOp.getGuarded()[mlir::cast<mlir::OpResult>(value)
+ .getResultNumber()];
+ continue;
+ }
+ if (mlir::isa<fir::BoxType>(value.getType()))
+ if (auto loadOp = value.getDefiningOp<fir::LoadOp>()) {
value = loadOp.getMemref();
+ continue;
+ }
+ break;
+ }
// If this is a function argument, look in the argument attributes.
if (auto blockArg = mlir::dyn_cast<mlir::BlockArgument>(value)) {
if (blockArg.getOwner() && blockArg.getOwner()->isEntryBlock())
diff --git a/flang/test/Fir/assert-array-codegen.fir b/flang/test/Fir/assert-array-codegen.fir
new file mode 100644
index 0000000000000..4824a77f23940
--- /dev/null
+++ b/flang/test/Fir/assert-array-codegen.fir
@@ -0,0 +1,75 @@
+// RUN: fir-opt --split-input-file --fir-to-llvm-ir %s | FileCheck %s
+// RUN: fir-opt --split-input-file --fir-to-llvm-ir="datalayout=e-p:64:64-p5:32:32-A5" %s | FileCheck %s --check-prefix=PRIVATE
+// RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=i386-unknown-linux-gnu datalayout=e-p:32:32" %s | FileCheck %s --check-prefix=COUNT32
+
+// Five values select the array entry. Conversion, allocation and stores must
+// stay on the failure path, and the guarded result survives on success.
+func.func @array_values(%ok: i1, %a: i8, %b: i16, %c: i32, %d: index, %e: i64, %base: !fir.ref<i32>) -> !fir.ref<i32> {
+ %g = fir.assert %ok, bounds, "dimension %lld, position %lld, index %lld, bounds %lld:%lld (100%%)" values(%a, %b, %c, %d, %e : i8, i16, i32, index, i64) guard(%base : !fir.ref<i32>) loc("bounds.f90":17:2)
+ return %g : !fir.ref<i32>
+}
+// CHECK: llvm.func @_FortranAReportFatalUserErrorValueArray(!llvm.ptr, !llvm.ptr, i32, i64, !llvm.ptr) attributes {noreturn}
+// CHECK-LABEL: llvm.func @array_values(
+// CHECK-SAME: %[[OK:.*]]: i1, %[[A:.*]]: i8, %[[B:.*]]: i16, %[[C:.*]]: i32, %[[D:.*]]: i64, %[[E:.*]]: i64, %[[BASE:.*]]: !llvm.ptr)
+// CHECK-NEXT: llvm.cond_br %[[OK]] weights([2000, 1]), ^[[CONT:bb[0-9]+]], ^[[FAIL:bb[0-9]+]]
+// CHECK: ^[[CONT]]:
+// CHECK-NEXT: llvm.return %[[BASE]] : !llvm.ptr
+// CHECK: ^[[FAIL]]:
+// CHECK: %[[COUNT:.*]] = llvm.mlir.constant(5 : i64)
+// CHECK-NEXT: %[[STORAGE:.*]] = llvm.alloca %[[COUNT]] x i64 : (i64) -> !llvm.ptr
+// CHECK: %[[P0:.*]] = llvm.getelementptr %[[STORAGE]][%{{.*}}]
+// CHECK: %[[V0:.*]] = llvm.sext %[[A]] : i8 to i64
+// CHECK-NEXT: llvm.store %[[V0]], %[[P0]]
+// CHECK: %[[P1:.*]] = llvm.getelementptr %[[STORAGE]][%{{.*}}]
+// CHECK: %[[V1:.*]] = llvm.sext %[[B]] : i16 to i64
+// CHECK-NEXT: llvm.store %[[V1]], %[[P1]]
+// CHECK: %[[P2:.*]] = llvm.getelementptr %[[STORAGE]][%{{.*}}]
+// CHECK: %[[V2:.*]] = llvm.sext %[[C]] : i32 to i64
+// CHECK-NEXT: llvm.store %[[V2]], %[[P2]]
+// CHECK: %[[P3:.*]] = llvm.getelementptr %[[STORAGE]][%{{.*}}]
+// CHECK-NEXT: llvm.store %[[D]], %[[P3]]
+// CHECK: %[[P4:.*]] = llvm.getelementptr %[[STORAGE]][%{{.*}}]
+// CHECK-NEXT: llvm.store %[[E]], %[[P4]]
+// CHECK: llvm.call @_FortranAReportFatalUserErrorValueArray(%{{.*}}, %{{.*}}, %{{.*}}, %[[COUNT]], %[[STORAGE]])
+// CHECK-NEXT: llvm.unreachable
+// PRIVATE-LABEL: llvm.func @array_values
+// PRIVATE: %[[STORAGE:.*]] = llvm.alloca %{{.*}} x i64 : (i64) -> !llvm.ptr<5>
+// PRIVATE: %[[GENERIC:.*]] = llvm.addrspacecast %[[STORAGE]] : !llvm.ptr<5> to !llvm.ptr
+// PRIVATE-NEXT: llvm.call @_FortranAReportFatalUserErrorValueArray(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %[[GENERIC]])
+// COUNT32: llvm.func @_FortranAReportFatalUserErrorValueArray(!llvm.ptr, !llvm.ptr, i32, i32, !llvm.ptr) attributes {noreturn}
+// COUNT32-LABEL: llvm.func @array_values
+// COUNT32: %[[COUNT:.*]] = llvm.mlir.constant(5 : i32)
+// COUNT32-NEXT: llvm.alloca %[[COUNT]] x i64 : (i32) -> !llvm...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/231245
More information about the llvm-branch-commits
mailing list