[Mlir-commits] [flang] [llvm] [mlir] [OpenMP][MLIR] Add thread_limit with dims modifier support (PR #171825)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Tue Jan 27 03:23:32 PST 2026
https://github.com/skc7 updated https://github.com/llvm/llvm-project/pull/171825
>From 80064c8ad4d99c4e49e00e45c14559d710d71716 Mon Sep 17 00:00:00 2001
From: skc7 <Krishna.Sankisa at amd.com>
Date: Fri, 28 Nov 2025 13:37:14 +0530
Subject: [PATCH 1/2] [OpenMP][MLIR] Add thread_limit with dims modifier
support
---
flang/lib/Lower/OpenMP/ClauseProcessor.cpp | 6 +-
flang/lib/Lower/OpenMP/Clauses.cpp | 13 +++-
flang/lib/Lower/OpenMP/OpenMP.cpp | 15 ++---
.../Optimizer/OpenMP/LowerWorkdistribute.cpp | 8 +--
flang/test/Lower/OpenMP/thread-limit-dims.f90 | 61 +++++++++++++++++++
llvm/include/llvm/Frontend/OpenMP/ClauseT.h | 4 +-
.../mlir/Dialect/OpenMP/OpenMPClauses.td | 38 +++++++++++-
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp | 6 +-
.../OpenMP/OpenMPToLLVMIRTranslation.cpp | 24 ++++++--
mlir/test/Dialect/OpenMP/ops.mlir | 13 ++++
mlir/test/Target/LLVMIR/openmp-todo.mlir | 11 ++++
11 files changed, 170 insertions(+), 29 deletions(-)
create mode 100644 flang/test/Lower/OpenMP/thread-limit-dims.f90
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index b29cfac857841..8094c6264b492 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -680,8 +680,10 @@ bool ClauseProcessor::processThreadLimit(
lower::StatementContext &stmtCtx,
mlir::omp::ThreadLimitClauseOps &result) const {
if (auto *clause = findUniqueClause<omp::clause::ThreadLimit>()) {
- result.threadLimit =
- fir::getBase(converter.genExprValue(clause->v, stmtCtx));
+ result.threadLimitVars.reserve(clause->v.size());
+ for (const ExprTy &vv : clause->v)
+ result.threadLimitVars.push_back(
+ fir::getBase(converter.genExprValue(vv, stmtCtx)));
return true;
}
return false;
diff --git a/flang/lib/Lower/OpenMP/Clauses.cpp b/flang/lib/Lower/OpenMP/Clauses.cpp
index 9a20fb5d006f8..fd7e3468ed504 100644
--- a/flang/lib/Lower/OpenMP/Clauses.cpp
+++ b/flang/lib/Lower/OpenMP/Clauses.cpp
@@ -1561,9 +1561,16 @@ TaskReduction make(const parser::OmpClause::TaskReduction &inp,
ThreadLimit make(const parser::OmpClause::ThreadLimit &inp,
semantics::SemanticsContext &semaCtx) {
// inp.v -> parser::OmpThreadLimitClause
- auto &t1 = std::get<std::list<parser::ScalarIntExpr>>(inp.v.t);
- assert(!t1.empty());
- return ThreadLimit{/*Threadlim=*/makeExpr(t1.front(), semaCtx)};
+ // With dims modifier: multiple values
+ // Without dims modifier: single value
+ auto &values = std::get<std::list<parser::ScalarIntExpr>>(inp.v.t);
+ assert(!values.empty());
+
+ List<ThreadLimit::Threadlim> v;
+ for (const auto &val : values) {
+ v.push_back(makeExpr(val, semaCtx));
+ }
+ return ThreadLimit{/*Threadlim=*/std::move(v)};
}
Threadset make(const parser::OmpClause::Threadset &inp,
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index 1902bd7a21f4a..3757fb440bfe9 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -103,8 +103,8 @@ class HostEvalInfo {
for (auto numThreads : ops.numThreadsVars)
vars.push_back(numThreads);
- if (ops.threadLimit)
- vars.push_back(ops.threadLimit);
+ for (mlir::Value val : ops.threadLimitVars)
+ vars.push_back(val);
}
/// Update \c ops, replacing all values with the corresponding block argument
@@ -117,7 +117,7 @@ class HostEvalInfo {
ops.loopLowerBounds.size() + ops.loopUpperBounds.size() +
ops.loopSteps.size() + (ops.numTeamsLower ? 1 : 0) +
ops.numTeamsUpperVars.size() + ops.numThreadsVars.size() +
- (ops.threadLimit ? 1 : 0) &&
+ ops.threadLimitVars.size() &&
"invalid block argument list");
int argIndex = 0;
for (size_t i = 0; i < ops.loopLowerBounds.size(); ++i)
@@ -138,8 +138,8 @@ class HostEvalInfo {
for (size_t i = 0; i < ops.numThreadsVars.size(); ++i)
ops.numThreadsVars[i] = args[argIndex++];
- if (ops.threadLimit)
- ops.threadLimit = args[argIndex++];
+ for (size_t i = 0; i < ops.threadLimitVars.size(); ++i)
+ ops.threadLimitVars[i] = args[argIndex++];
}
/// Update \p clauseOps and \p ivOut with the corresponding host-evaluated
@@ -186,12 +186,13 @@ class HostEvalInfo {
/// \returns whether an update was performed. If not, these clauses were not
/// evaluated in the host device.
bool apply(mlir::omp::TeamsOperands &clauseOps) {
- if (!ops.numTeamsLower && ops.numTeamsUpperVars.empty() && !ops.threadLimit)
+ if (!ops.numTeamsLower && ops.numTeamsUpperVars.empty() &&
+ ops.threadLimitVars.empty())
return false;
clauseOps.numTeamsLower = ops.numTeamsLower;
clauseOps.numTeamsUpperVars = ops.numTeamsUpperVars;
- clauseOps.threadLimit = ops.threadLimit;
+ clauseOps.threadLimitVars = ops.threadLimitVars;
return true;
}
diff --git a/flang/lib/Optimizer/OpenMP/LowerWorkdistribute.cpp b/flang/lib/Optimizer/OpenMP/LowerWorkdistribute.cpp
index 7b61539984232..2c7980064500f 100644
--- a/flang/lib/Optimizer/OpenMP/LowerWorkdistribute.cpp
+++ b/flang/lib/Optimizer/OpenMP/LowerWorkdistribute.cpp
@@ -766,7 +766,7 @@ FailureOr<omp::TargetOp> splitTargetData(omp::TargetOp targetOp,
targetOp.getInReductionSymsAttr(), targetOp.getIsDevicePtrVars(),
innerMapInfos, targetOp.getNowaitAttr(), targetOp.getPrivateVars(),
targetOp.getPrivateSymsAttr(), targetOp.getPrivateNeedsBarrierAttr(),
- targetOp.getThreadLimit(), targetOp.getPrivateMapsAttr());
+ targetOp.getThreadLimitVars(), targetOp.getPrivateMapsAttr());
rewriter.inlineRegionBefore(targetOp.getRegion(), newTargetOp.getRegion(),
newTargetOp.getRegion().begin());
rewriter.replaceOp(targetOp, targetDataOp);
@@ -1485,7 +1485,7 @@ genPreTargetOp(omp::TargetOp targetOp, SmallVector<Value> &preMapOperands,
targetOp.getInReductionByrefAttr(), targetOp.getInReductionSymsAttr(),
targetOp.getIsDevicePtrVars(), preMapOperands, targetOp.getNowaitAttr(),
targetOp.getPrivateVars(), targetOp.getPrivateSymsAttr(),
- targetOp.getPrivateNeedsBarrierAttr(), targetOp.getThreadLimit(),
+ targetOp.getPrivateNeedsBarrierAttr(), targetOp.getThreadLimitVars(),
targetOp.getPrivateMapsAttr());
auto *preTargetBlock = rewriter.createBlock(
&preTargetOp.getRegion(), preTargetOp.getRegion().begin(), {}, {});
@@ -1575,7 +1575,7 @@ genIsolatedTargetOp(omp::TargetOp targetOp, SmallVector<Value> &postMapOperands,
targetOp.getInReductionByrefAttr(), targetOp.getInReductionSymsAttr(),
targetOp.getIsDevicePtrVars(), postMapOperands, targetOp.getNowaitAttr(),
targetOp.getPrivateVars(), targetOp.getPrivateSymsAttr(),
- targetOp.getPrivateNeedsBarrierAttr(), targetOp.getThreadLimit(),
+ targetOp.getPrivateNeedsBarrierAttr(), targetOp.getThreadLimitVars(),
targetOp.getPrivateMapsAttr());
auto *isolatedTargetBlock =
rewriter.createBlock(&isolatedTargetOp.getRegion(),
@@ -1655,7 +1655,7 @@ static omp::TargetOp genPostTargetOp(omp::TargetOp targetOp,
targetOp.getInReductionByrefAttr(), targetOp.getInReductionSymsAttr(),
targetOp.getIsDevicePtrVars(), postMapOperands, targetOp.getNowaitAttr(),
targetOp.getPrivateVars(), targetOp.getPrivateSymsAttr(),
- targetOp.getPrivateNeedsBarrierAttr(), targetOp.getThreadLimit(),
+ targetOp.getPrivateNeedsBarrierAttr(), targetOp.getThreadLimitVars(),
targetOp.getPrivateMapsAttr());
// Create the block for postTargetOp
auto *postTargetBlock = rewriter.createBlock(
diff --git a/flang/test/Lower/OpenMP/thread-limit-dims.f90 b/flang/test/Lower/OpenMP/thread-limit-dims.f90
new file mode 100644
index 0000000000000..dd5e55f274094
--- /dev/null
+++ b/flang/test/Lower/OpenMP/thread-limit-dims.f90
@@ -0,0 +1,61 @@
+! RUN: %flang_fc1 -emit-hlfir %openmp_flags -fopenmp-version=61 %s -o - | FileCheck %s
+
+!===============================================================================
+! `thread_limit` clause with dims modifier (OpenMP 6.1)
+!===============================================================================
+
+! CHECK-LABEL: func @_QPteams_threadlimit_dims3
+subroutine teams_threadlimit_dims3()
+ ! CHECK: omp.teams
+ ! CHECK-SAME: thread_limit(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32)
+ !$omp teams thread_limit(dims(3): 16, 8, 4)
+ call f1()
+ ! CHECK: omp.terminator
+ !$omp end teams
+end subroutine teams_threadlimit_dims3
+
+! CHECK-LABEL: func @_QPteams_threadlimit_dims2
+subroutine teams_threadlimit_dims2()
+ ! CHECK: omp.teams
+ ! CHECK-SAME: thread_limit(%{{.*}}, %{{.*}} : i32, i32)
+ !$omp teams thread_limit(dims(2): 32, 16)
+ call f1()
+ ! CHECK: omp.terminator
+ !$omp end teams
+end subroutine teams_threadlimit_dims2
+
+! CHECK-LABEL: func @_QPteams_threadlimit_dims_var
+subroutine teams_threadlimit_dims_var(a, b, c)
+ integer, intent(in) :: a, b, c
+ ! CHECK: omp.teams
+ ! CHECK-SAME: thread_limit(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32)
+ !$omp teams thread_limit(dims(3): a, b, c)
+ call f1()
+ ! CHECK: omp.terminator
+ !$omp end teams
+end subroutine teams_threadlimit_dims_var
+
+!===============================================================================
+! `thread_limit` clause without dims modifier (legacy)
+!===============================================================================
+
+! CHECK-LABEL: func @_QPteams_threadlimit_legacy
+subroutine teams_threadlimit_legacy(n)
+ integer, intent(in) :: n
+ ! CHECK: omp.teams
+ ! CHECK-SAME: thread_limit(%{{.*}} : i32)
+ !$omp teams thread_limit(n)
+ call f1()
+ ! CHECK: omp.terminator
+ !$omp end teams
+end subroutine teams_threadlimit_legacy
+
+! CHECK-LABEL: func @_QPteams_threadlimit_const
+subroutine teams_threadlimit_const()
+ ! CHECK: omp.teams
+ ! CHECK-SAME: thread_limit(%{{.*}} : i32)
+ !$omp teams thread_limit(64)
+ call f1()
+ ! CHECK: omp.terminator
+ !$omp end teams
+end subroutine teams_threadlimit_const
diff --git a/llvm/include/llvm/Frontend/OpenMP/ClauseT.h b/llvm/include/llvm/Frontend/OpenMP/ClauseT.h
index 86353f0fe0bda..844aa932d859e 100644
--- a/llvm/include/llvm/Frontend/OpenMP/ClauseT.h
+++ b/llvm/include/llvm/Frontend/OpenMP/ClauseT.h
@@ -1226,11 +1226,13 @@ struct TaskReductionT {
};
// V5.2: [13.3] `thread_limit` clause
+// V6.1: Extended with dims modifier support
template <typename T, typename I, typename E> //
struct ThreadLimitT {
using Threadlim = E;
+ using List = ListT<Threadlim>;
using WrapperTrait = std::true_type;
- Threadlim v;
+ List v;
};
// V5.2: [15.10.3] `parallelization-level` clauses
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
index 0bfe36648c54d..9114d9c1f0ac1 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
@@ -1521,15 +1521,47 @@ class OpenMP_ThreadLimitClauseSkip<
> : OpenMP_Clause<traits, arguments, assemblyFormat, description,
extraClassDeclaration> {
let arguments = (ins
- Optional<AnyInteger>:$thread_limit
+ Variadic<IntLikeType>:$thread_limit_vars
);
let optAssemblyFormat = [{
- `thread_limit` `(` $thread_limit `:` type($thread_limit) `)`
+ `thread_limit` `(` $thread_limit_vars `:` type($thread_limit_vars) `)`
}];
let description = [{
- The optional `thread_limit` specifies the limit on the number of threads.
+ The `thread_limit` clause specifies the limit on the number of threads.
+
+ Multi-dimensional format (dims modifier):
+ - Multiple values can be specified for multi-dimensional thread limits.
+ - The number of dimensions is derived from the number of values.
+ - Values can have different integer types.
+ - Format: `thread_limit(%v1, %v2, ... : type1, type2, ...)`
+ - Example: `thread_limit(%n, %m : i32, i64)`
+
+ Single value format:
+ - A single value specifies the thread limit.
+ - Format: `thread_limit(%value : type)`
+ - Example: `thread_limit(%n : i32)`
+ }];
+
+ let extraClassDeclaration = [{
+ /// Returns true if using multi-dimensional values (more than one value)
+ bool hasThreadLimitMultiDim() {
+ return getThreadLimitVars().size() > 1;
+ }
+
+ /// Returns the number of dimensions specified for thread_limit
+ unsigned getThreadLimitDimsCount() {
+ return getThreadLimitVars().size();
+ }
+
+ /// Returns the value for a specific dimension
+ /// dim must be less than getThreadLimitDimsCount()
+ ::mlir::Value getThreadLimit(unsigned dim = 0) {
+ assert(dim < getThreadLimitDimsCount() &&
+ "Thread limit index out of bounds");
+ return getThreadLimitVars()[dim];
+ }
}];
}
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
index 349fc300e644d..c3916219d1c93 100644
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -2210,7 +2210,7 @@ void TargetOp::build(OpBuilder &builder, OperationState &state,
/*in_reduction_syms=*/nullptr, clauses.isDevicePtrVars,
clauses.mapVars, clauses.nowait, clauses.privateVars,
makeArrayAttr(ctx, clauses.privateSyms),
- clauses.privateNeedsBarrier, clauses.threadLimit,
+ clauses.privateNeedsBarrier, clauses.threadLimitVars,
/*private_maps=*/nullptr);
}
@@ -2243,7 +2243,7 @@ LogicalResult TargetOp::verifyRegions() {
// Check if used in num_teams_lower or any of num_teams_upper_vars
if (hostEvalArg == teamsOp.getNumTeamsLower() ||
llvm::is_contained(teamsOp.getNumTeamsUpperVars(), hostEvalArg) ||
- hostEvalArg == teamsOp.getThreadLimit())
+ llvm::is_contained(teamsOp.getThreadLimitVars(), hostEvalArg))
continue;
return emitOpError() << "host_eval argument only legal as 'num_teams' "
@@ -2632,7 +2632,7 @@ void TeamsOp::build(OpBuilder &builder, OperationState &state,
/*private_needs_barrier=*/nullptr, clauses.reductionMod,
clauses.reductionVars,
makeDenseBoolArrayAttr(ctx, clauses.reductionByref),
- makeArrayAttr(ctx, clauses.reductionSyms), clauses.threadLimit);
+ makeArrayAttr(ctx, clauses.reductionSyms), clauses.threadLimitVars);
}
// Verify num_teams clause
diff --git a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
index 924108d5702f7..022322502a755 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp
@@ -385,6 +385,11 @@ static LogicalResult checkImplementationStatus(Operation &op) {
result = todo("num_threads with multi-dimensional values");
};
+ auto checkThreadLimit = [&todo](auto op, LogicalResult &result) {
+ if (op.hasThreadLimitMultiDim())
+ result = todo("thread_limit with multi-dimensional values");
+ };
+
LogicalResult result = success();
llvm::TypeSwitch<Operation &>(op)
.Case([&](omp::DistributeOp op) {
@@ -409,6 +414,7 @@ static LogicalResult checkImplementationStatus(Operation &op) {
checkAllocate(op, result);
checkPrivate(op, result);
checkNumTeams(op, result);
+ checkThreadLimit(op, result);
})
.Case([&](omp::TaskOp op) {
checkAllocate(op, result);
@@ -447,6 +453,7 @@ static LogicalResult checkImplementationStatus(Operation &op) {
checkAllocate(op, result);
checkBare(op, result);
checkInReduction(op, result);
+ checkThreadLimit(op, result);
})
.Default([](Operation &) {
// Assume all clauses for an operation can be translated unless they are
@@ -2080,8 +2087,8 @@ convertOmpTeams(omp::TeamsOp op, llvm::IRBuilderBase &builder,
numTeamsUpper = moduleTranslation.lookupValue(op.getNumTeams(0));
llvm::Value *threadLimit = nullptr;
- if (Value threadLimitVar = op.getThreadLimit())
- threadLimit = moduleTranslation.lookupValue(threadLimitVar);
+ if (!op.getThreadLimitVars().empty())
+ threadLimit = moduleTranslation.lookupValue(op.getThreadLimit(0));
llvm::Value *ifExpr = nullptr;
if (Value ifVar = op.getIfExpr())
@@ -6050,7 +6057,8 @@ extractHostEvalClauses(omp::TargetOp targetOp, Value &numThreads,
else if (llvm::is_contained(teamsOp.getNumTeamsUpperVars(),
blockArg))
numTeamsUpper = hostEvalVar;
- else if (teamsOp.getThreadLimit() == blockArg)
+ else if (!teamsOp.getThreadLimitVars().empty() &&
+ teamsOp.getThreadLimit(0) == blockArg)
threadLimit = hostEvalVar;
else
llvm_unreachable("unsupported host_eval use");
@@ -6173,7 +6181,8 @@ initTargetDefaultAttrs(omp::TargetOp targetOp, Operation *capturedOp,
// Handle num_teams upper bounds (only first value for now)
if (!teamsOp.getNumTeamsUpperVars().empty())
numTeamsUpper = teamsOp.getNumTeams(0);
- threadLimit = teamsOp.getThreadLimit();
+ if (!teamsOp.getThreadLimitVars().empty())
+ threadLimit = teamsOp.getThreadLimit(0);
}
if (auto parallelOp = castOrGetParentOfType<omp::ParallelOp>(capturedOp)) {
@@ -6220,7 +6229,8 @@ initTargetDefaultAttrs(omp::TargetOp targetOp, Operation *capturedOp,
// Extract 'thread_limit' clause from 'target' and 'teams' directives.
int32_t targetThreadLimitVal = -1, teamsThreadLimitVal = -1;
- setMaxValueFromClause(targetOp.getThreadLimit(), targetThreadLimitVal);
+ if (!targetOp.getThreadLimitVars().empty())
+ setMaxValueFromClause(targetOp.getThreadLimit(0), targetThreadLimitVal);
setMaxValueFromClause(threadLimit, teamsThreadLimitVal);
// Extract 'max_threads' clause from 'parallel' or set to 1 if it's SIMD.
@@ -6299,9 +6309,11 @@ initTargetRuntimeAttrs(llvm::IRBuilderBase &builder,
teamsThreadLimit, &lowerBounds, &upperBounds, &steps);
// TODO: Handle constant 'if' clauses.
- if (Value targetThreadLimit = targetOp.getThreadLimit())
+ if (!targetOp.getThreadLimitVars().empty()) {
+ Value targetThreadLimit = targetOp.getThreadLimit(0);
attrs.TargetThreadLimit.front() =
moduleTranslation.lookupValue(targetThreadLimit);
+ }
// The __kmpc_push_num_teams_51 function expects int32 as the arguments. So,
// truncate or sign extend lower and upper num_teams bounds as well as
diff --git a/mlir/test/Dialect/OpenMP/ops.mlir b/mlir/test/Dialect/OpenMP/ops.mlir
index 563729039c762..1e8c9bdeb33ae 100644
--- a/mlir/test/Dialect/OpenMP/ops.mlir
+++ b/mlir/test/Dialect/OpenMP/ops.mlir
@@ -1148,6 +1148,19 @@ func.func @omp_teams(%lb : i32, %ub : i32, %if_cond : i1, %num_threads : i32,
omp.terminator
}
+ // CHECK: omp.teams thread_limit(%{{.*}}, %{{.*}} : i32, i32)
+ omp.teams thread_limit(%lb, %ub : i32, i32) {
+ // CHECK: omp.terminator
+ omp.terminator
+ }
+
+ // Test thread_limit with mixed types.
+ // CHECK: omp.teams thread_limit(%{{.*}}, %{{.*}}, %{{.*}} : i32, i64, i16)
+ omp.teams thread_limit(%lb, %ub64, %ub16 : i32, i64, i16) {
+ // CHECK: omp.terminator
+ omp.terminator
+ }
+
// Test reduction.
%c1 = arith.constant 1 : i32
%0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr
diff --git a/mlir/test/Target/LLVMIR/openmp-todo.mlir b/mlir/test/Target/LLVMIR/openmp-todo.mlir
index ca5ec559926a9..36338e5cb1bed 100644
--- a/mlir/test/Target/LLVMIR/openmp-todo.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-todo.mlir
@@ -454,6 +454,17 @@ llvm.func @parallel_num_threads_multi_dim(%lb : i32, %ub : i32) {
// -----
+llvm.func @teams_thread_limit_multi_dim(%lb : i32, %ub : i32) {
+ // expected-error at below {{not yet implemented: Unhandled clause thread_limit with multi-dimensional values in omp.teams operation}}
+ // expected-error at below {{LLVM Translation failed for operation: omp.teams}}
+ omp.teams thread_limit(%lb, %ub : i32, i32) {
+ omp.terminator
+ }
+ llvm.return
+}
+
+// -----
+
llvm.func @wsloop_allocate(%lb : i32, %ub : i32, %step : i32, %x : !llvm.ptr) {
// expected-error at below {{not yet implemented: Unhandled clause allocate in omp.wsloop operation}}
// expected-error at below {{LLVM Translation failed for operation: omp.wsloop}}
>From c19b0a164f3b422707f02ca3732338c374188951 Mon Sep 17 00:00:00 2001
From: skc7 <Krishna.Sankisa at amd.com>
Date: Tue, 27 Jan 2026 16:52:46 +0530
Subject: [PATCH 2/2] Fix llvm frontend unittest
---
llvm/unittests/Frontend/OpenMPDecompositionTest.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp b/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp
index 23c3c4d5d192c..3dd0734952caa 100644
--- a/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp
+++ b/llvm/unittests/Frontend/OpenMPDecompositionTest.cpp
@@ -671,7 +671,7 @@ TEST_F(OpenMPDecompositionTest, ThreadLimit1) {
omp::Object x{"x"};
omp::List<omp::Clause> Clauses{
- {OMPC_thread_limit, omp::clause::ThreadLimit{omp::ExprTy{}}},
+ {OMPC_thread_limit, omp::clause::ThreadLimit{{omp::ExprTy{}}}},
};
omp::ConstructDecomposition Dec(AnyVersion, Helper,
More information about the Mlir-commits
mailing list