[Mlir-commits] [flang] [mlir] [OpenMP][Flang][MLIR] Introduce omp.declare_simd op and emit from Flang (PR #175604)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Mon Jan 12 13:11:53 PST 2026
https://github.com/chichunchen updated https://github.com/llvm/llvm-project/pull/175604
>From 5783d5b394d02a7d05fe0c9e33ed9f756451682d Mon Sep 17 00:00:00 2001
From: cchen <chichun.chen at hpe.com>
Date: Fri, 9 Jan 2026 17:48:54 -0600
Subject: [PATCH 1/2] [OpenMP][Flang][MLIR] Introduce omp.declare_simd op and
emit from Flang
Changes:
- Adds a new `omp.declare_simd` operation to the OpenMP MLIR dialect
- Lowers Fortran `!$omp declare simd` into `omp.declare_simd` inside the
enclosing function body
mlir to LLVMIR translation and uniform clause will be added in follow-up PRs.
---
flang/lib/Lower/OpenMP/OpenMP.cpp | 13 +-
flang/test/Lower/OpenMP/declare-simd.f90 | 119 ++++++++++++++++++
mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td | 38 ++++++
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp | 32 +++++
mlir/test/Dialect/OpenMP/ops.mlir | 69 ++++++++++
5 files changed, 269 insertions(+), 2 deletions(-)
create mode 100644 flang/test/Lower/OpenMP/declare-simd.f90
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index 4381d1e9064cf..84377c26d30f6 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -3815,8 +3815,17 @@ static void
genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx, lower::pft::Evaluation &eval,
const parser::OpenMPDeclareSimdConstruct &declareSimdConstruct) {
- if (!semaCtx.langOptions().OpenMPSimd)
- TODO(converter.getCurrentLocation(), "OpenMPDeclareSimdConstruct");
+ mlir::Location loc = converter.getCurrentLocation();
+ const parser::OmpDirectiveSpecification &beginSpec = declareSimdConstruct.v;
+ List<Clause> clauses = makeClauses(beginSpec.Clauses(), semaCtx);
+
+ mlir::omp::DeclareSimdOperands clauseOps;
+ ClauseProcessor cp(converter, semaCtx, clauses);
+ cp.processAligned(clauseOps);
+ cp.processLinear(clauseOps);
+ cp.processSimdlen(clauseOps);
+
+ mlir::omp::DeclareSimdOp::create(converter.getFirOpBuilder(), loc, clauseOps);
}
static void genOpenMPDeclareMapperImpl(
diff --git a/flang/test/Lower/OpenMP/declare-simd.f90 b/flang/test/Lower/OpenMP/declare-simd.f90
new file mode 100644
index 0000000000000..264ac222801b9
--- /dev/null
+++ b/flang/test/Lower/OpenMP/declare-simd.f90
@@ -0,0 +1,119 @@
+! This test checks the lowering of the OpenMP `declare simd` directive with
+! different clauses (e.g. aligned, linear, simdlen). It also verifies that
+! the `omp.declare_simd` operation is emitted after the function prologue,
+! since the directive requires access to function arguments.
+
+! RUN: %flang_fc1 -emit-hlfir -fopenmp %s -o - | FileCheck %s
+
+subroutine declare_simd_no_clause(x, y, n, i)
+ !$omp declare simd
+ real(8), pointer, intent(inout) :: x(:)
+ real(8), pointer, intent(in) :: y(:)
+ integer, intent(in) :: n, i
+ if (i <= n) x(i) = x(i) + y(i)
+end subroutine declare_simd_no_clause
+
+! CHECK-LABEL: func.func @_QPdeclare_simd_no_clause(
+! CHECK: %[[SCOPE_NONE:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[I_NONE:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_NONE]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[N_NONE:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_NONE]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[X_NONE:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_NONE]] arg 1 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[Y_NONE:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_NONE]] arg 2 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: omp.declare_simd
+! CHECK-NOT: aligned(
+! CHECK-NOT: linear(
+! CHECK-NOT: simdlen(
+! CHECK: return
+
+subroutine declare_simd_aligned(x, y, n, i)
+ !$omp declare simd aligned(x, y : 64)
+ real(8), pointer, intent(inout) :: x(:)
+ real(8), pointer, intent(in) :: y(:)
+ integer, intent(in) :: n, i
+ if (i <= n) x(i) = x(i) + y(i)
+end subroutine declare_simd_aligned
+
+! CHECK-LABEL: func.func @_QPdeclare_simd_aligned(
+! CHECK: %[[SCOPE_A:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[I_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[N_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[X_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 1 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[Y_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 2 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: omp.declare_simd
+! CHECK-SAME: aligned(%[[X_A]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64,
+! CHECK-SAME: %[[Y_A]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64)
+! CHECK-NOT: linear(
+! CHECK-NOT: simdlen(
+! CHECK: return
+
+subroutine declare_simd_linear(x, y, n, i)
+ !$omp declare simd linear(i)
+ real(8), pointer, intent(inout) :: x(:)
+ real(8), pointer, intent(in) :: y(:)
+ integer, intent(in) :: n, i
+ if (i <= n) x(i) = x(i) + y(i)
+end subroutine declare_simd_linear
+
+! CHECK-LABEL: func.func @_QPdeclare_simd_linear(
+! CHECK: %[[SCOPE_L:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[I_L:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_L]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[N_L:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_L]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[X_L:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_L]] arg 1 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[Y_L:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_L]] arg 2 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[C1_L:.*]] = arith.constant 1 : i32
+! CHECK: omp.declare_simd
+! CHECK-NOT: aligned(
+! CHECK-SAME: linear(%[[I_L]]#0 = %[[C1_L]] : !fir.ref<i32>)
+! CHECK-SAME: {linear_var_types = [i32]}
+! CHECK-NOT: simdlen(
+! CHECK: return
+
+subroutine declare_simd_simdlen(x, y, n, i)
+ !$omp declare simd simdlen(8)
+ real(8), pointer, intent(inout) :: x(:)
+ real(8), pointer, intent(in) :: y(:)
+ integer, intent(in) :: n, i
+ if (i <= n) x(i) = x(i) + y(i)
+end subroutine declare_simd_simdlen
+
+! CHECK-LABEL: func.func @_QPdeclare_simd_simdlen(
+! CHECK: %[[SCOPE_S:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[I_S:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_S]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[N_S:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_S]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[X_S:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_S]] arg 1 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[Y_S:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_S]] arg 2 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: omp.declare_simd
+! CHECK-NOT: aligned(
+! CHECK-NOT: linear(
+! CHECK-SAME: simdlen(8)
+! CHECK: return
+
+subroutine declare_simd_combined(x, y, n, i)
+ !$omp declare simd aligned(x, y : 64) linear(i) simdlen(8)
+ real(8), pointer, intent(inout) :: x(:)
+ real(8), pointer, intent(in) :: y(:)
+ integer, intent(in) :: n, i
+
+ if (i <= n) then
+ x(i) = x(i) + y(i)
+end if
+end subroutine declare_simd_combined
+
+! CHECK-LABEL: func.func @_QPdeclare_simd_combined(
+! CHECK-SAME: %{{.*}}: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>{{.*}}fir.bindc_name = "x"
+! CHECK-SAME: %{{.*}}: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>{{.*}}fir.bindc_name = "y"
+! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}fir.bindc_name = "n"
+! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}fir.bindc_name = "i"
+! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[I_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[N_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: %[[X_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1 {{.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[Y_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 2 {{.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+! CHECK: %[[C1:.*]] = arith.constant 1 : i32
+
+! CHECK: omp.declare_simd
+! CHECK-SAME: aligned(%[[X_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64,
+! CHECK-SAME: %[[Y_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64)
+! CHECK-SAME: linear(%[[I_DECL]]#0 = %[[C1]] : !fir.ref<i32>)
+! CHECK-SAME: simdlen(8)
+! CHECK-SAME: {linear_var_types = [i32]}
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
index bbfe805eefe48..c77e08e1fb076 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
@@ -2240,4 +2240,42 @@ def WorkdistributeOp : OpenMP_Op<"workdistribute"> {
let assemblyFormat = "$region attr-dict";
}
+//===----------------------------------------------------------------------===//
+// declare simd Construct
+//===----------------------------------------------------------------------===//
+
+def DeclareSimdOp
+ : OpenMP_Op<"declare_simd",
+ traits = [AttrSizedOperandSegments, IsolatedFromAbove],
+ clauses = [OpenMP_AlignedClause, OpenMP_LinearClause,
+ OpenMP_SimdlenClause]> {
+ let summary = "declare simd directive";
+ let description = [{
+ "omp.declare_simd" models the OpenMP `declare simd` directive.
+
+ This is a declarative operation (no region) intended to appear inside
+ a function body. It attaches clauses of declare simd to the enclosing
+ function.
+
+ Example:
+ ```mlir
+ func.func @add(%a: memref<16xi32>) {
+ omp.declare_simd simdlen(8) aligned(%a : memref<16xi32> -> 64 : i64)
+ ...
+ }
+ ```
+ }]#clausesDescription;
+
+ let arguments = clausesArgs;
+
+ let builders = [OpBuilder<(
+ ins CArg<"const DeclareSimdOperands &">:$clauses)>];
+
+ let assemblyFormat =
+ clausesReqAssemblyFormat#" oilist("#clausesOptAssemblyFormat#") "#"attr-"
+ "dict";
+
+ let hasVerifier = 1;
+}
+
#endif // OPENMP_OPS
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
index 103295d136dbb..f23bb659ae88e 100644
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -4458,6 +4458,38 @@ LogicalResult WorkdistributeOp::verify() {
return success();
}
+//===----------------------------------------------------------------------===//
+// Declare simd [7.7]
+//===----------------------------------------------------------------------===//
+
+void DeclareSimdOp::build(OpBuilder &odsBuilder, OperationState &odsState,
+ const DeclareSimdOperands &clauses) {
+ MLIRContext *ctx = odsBuilder.getContext();
+ DeclareSimdOp::build(odsBuilder, odsState, clauses.alignedVars,
+ makeArrayAttr(ctx, clauses.alignments),
+ clauses.linearVars, clauses.linearStepVars,
+ clauses.linearVarTypes, clauses.simdlen);
+}
+
+LogicalResult DeclareSimdOp::verify() {
+ // Must be nested inside a function-like op
+ auto func = (*this)->getParentOfType<mlir::FunctionOpInterface>();
+ if (!func)
+ return emitOpError()
+ << "'omp.declare_simd' must be nested inside a function";
+
+ // omp.declare_simd must appear in the entry block of the enclosing function
+ Block &entry = func.getFunctionBody().front();
+ if (getOperation()->getBlock() != &entry)
+ return emitError()
+ << "must appear in the entry block of the enclosing function";
+
+ if (verifyAlignedClause(*this, getAlignments(), getAlignedVars()).failed())
+ return failure();
+
+ return success();
+}
+
#define GET_ATTRDEF_CLASSES
#include "mlir/Dialect/OpenMP/OpenMPOpsAttributes.cpp.inc"
diff --git a/mlir/test/Dialect/OpenMP/ops.mlir b/mlir/test/Dialect/OpenMP/ops.mlir
index ac29e20907b55..8ab2ed89e5ecc 100644
--- a/mlir/test/Dialect/OpenMP/ops.mlir
+++ b/mlir/test/Dialect/OpenMP/ops.mlir
@@ -3367,3 +3367,72 @@ func.func @omp_target_map_clause_type_test(%arg0 : memref<?xi32>) -> () {
return
}
+
+// CHECK-LABEL: func.func @omp_declare_simd
+func.func @omp_declare_simd(%a: f64, %b: f64) -> f64 {
+ // CHECK: omp.declare_simd
+ omp.declare_simd
+ %0 = arith.addf %a, %b : f64
+ return %0 : f64
+}
+
+// CHECK-LABEL: func.func @omp_declare_simd_simdlen
+func.func @omp_declare_simd_simdlen(%a: f64, %b: f64) -> f64 {
+ // CHECK: omp.declare_simd
+ // CHECK-SAME: simdlen(8)
+ omp.declare_simd simdlen(8)
+ %0 = arith.addf %a, %b : f64
+ return %0 : f64
+}
+
+// CHECK-LABEL: func.func @omp_declare_simd_aligned
+func.func @omp_declare_simd_aligned(%a: f64, %b: f64,
+ %p0: memref<i32>, %p1: memref<i32>) -> f64 {
+ // CHECK: omp.declare_simd
+ // CHECK-SAME: aligned(
+ // CHECK-SAME: %{{.*}} : memref<i32> -> 32 : i64,
+ // CHECK-SAME: %{{.*}} : memref<i32> -> 128 : i64)
+ omp.declare_simd aligned(%p0 : memref<i32> -> 32 : i64,
+ %p1 : memref<i32> -> 128 : i64)
+
+ %0 = arith.addf %a, %b : f64
+ return %0 : f64
+}
+
+// CHECK-LABEL: func.func @omp_declare_simd_aligned_list_generic
+func.func @omp_declare_simd_aligned_list_generic(%arg0: f64, %arg1: f64,
+ %arg2: memref<i32>, %arg3: memref<i32>) -> f64 {
+ // CHECK: omp.declare_simd
+ // CHECK-SAME: aligned(%{{.*}} : memref<i32> -> 32 : i64, %{{.*}} : memref<i32> -> 128 : i64)
+ omp.declare_simd aligned(%arg2 : memref<i32> -> 32 : i64, %arg3 : memref<i32> -> 128 : i64)
+ %0 = arith.addf %arg0, %arg1 : f64
+ return %0 : f64
+}
+
+// CHECK-LABEL: func.func @omp_declare_simd_linear
+func.func @omp_declare_simd_linear(%a: f64, %b: f64, %iv: i32, %step: i32) -> f64 {
+ // CHECK: omp.declare_simd
+ // CHECK-SAME: linear(%{{.*}} = %{{.*}} : i32)
+ omp.declare_simd linear(%iv = %step : i32)
+ %0 = arith.addf %a, %b : f64
+ return %0 : f64
+}
+
+// CHECK-LABEL: func.func @omp_declare_simd_all_clauses
+func.func @omp_declare_simd_all_clauses(%a: f64, %b: f64,
+ %p0: memref<i32>, %p1: memref<i32>,
+ %iv: i32, %step: i32) -> f64 {
+ // CHECK: omp.declare_simd
+ // CHECK-SAME: aligned(
+ // CHECK-SAME: %{{.*}} : memref<i32> -> 32 : i64,
+ // CHECK-SAME: %{{.*}} : memref<i32> -> 128 : i64)
+ // CHECK-SAME: linear(%{{.*}} = %{{.*}} : i32)
+ // CHECK-SAME: simdlen(8)
+ omp.declare_simd simdlen(8)
+ aligned(%p0 : memref<i32> -> 32 : i64,
+ %p1 : memref<i32> -> 128 : i64)
+ linear(%iv = %step : i32)
+
+ %0 = arith.addf %a, %b : f64
+ return %0 : f64
+}
>From 232c19dc29d8c1fab3cfaf71980221a1e70c1782 Mon Sep 17 00:00:00 2001
From: "Chi-Chun, Chen" <chichun.chen at hpe.com>
Date: Mon, 12 Jan 2026 15:10:03 -0600
Subject: [PATCH 2/2] [flang][mlir][OpenMP] Add support for uniform clause in
declare simd
---
flang/lib/Lower/OpenMP/ClauseProcessor.cpp | 17 ++++++++++
flang/lib/Lower/OpenMP/ClauseProcessor.h | 1 +
flang/lib/Lower/OpenMP/OpenMP.cpp | 1 +
flang/test/Lower/OpenMP/declare-simd.f90 | 31 +++++++++++++++++-
.../mlir/Dialect/OpenMP/OpenMPClauses.td | 24 ++++++++++++++
mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td | 2 +-
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp | 32 ++++++++++++++++++-
mlir/test/Dialect/OpenMP/ops.mlir | 17 ++++++++++
8 files changed, 122 insertions(+), 3 deletions(-)
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index b923e415231d6..eb24a9d936581 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -1722,6 +1722,23 @@ bool ClauseProcessor::processUseDevicePtr(
return clauseFound;
}
+static void
+addUniformClause(lower::AbstractConverter &converter,
+ const omp::clause::Uniform &clause,
+ llvm::SmallVectorImpl<mlir::Value> &uniformVars) {
+ const auto &objects = clause.v;
+ if (!objects.empty())
+ genObjectList(objects, converter, uniformVars);
+}
+
+bool ClauseProcessor::processUniform(
+ mlir::omp::UniformClauseOps &result) const {
+ return findRepeatableClause<omp::clause::Uniform>(
+ [&](const omp::clause::Uniform &clause, const parser::CharBlock &) {
+ addUniformClause(converter, clause, result.uniformVars);
+ });
+}
+
} // namespace omp
} // namespace lower
} // namespace Fortran
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.h b/flang/lib/Lower/OpenMP/ClauseProcessor.h
index a04cd4b79dd24..063da68fb5702 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.h
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.h
@@ -168,6 +168,7 @@ class ClauseProcessor {
lower::StatementContext &stmtCtx,
mlir::omp::UseDevicePtrClauseOps &result,
llvm::SmallVectorImpl<const semantics::Symbol *> &useDeviceSyms) const;
+ bool processUniform(mlir::omp::UniformClauseOps &result) const;
// Call this method for these clauses that should be supported but are not
// implemented yet. It triggers a compilation error if any of the given
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index 84377c26d30f6..71315e840b905 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -3824,6 +3824,7 @@ genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
cp.processAligned(clauseOps);
cp.processLinear(clauseOps);
cp.processSimdlen(clauseOps);
+ cp.processUniform(clauseOps);
mlir::omp::DeclareSimdOp::create(converter.getFirOpBuilder(), loc, clauseOps);
}
diff --git a/flang/test/Lower/OpenMP/declare-simd.f90 b/flang/test/Lower/OpenMP/declare-simd.f90
index 264ac222801b9..421db476ff71a 100644
--- a/flang/test/Lower/OpenMP/declare-simd.f90
+++ b/flang/test/Lower/OpenMP/declare-simd.f90
@@ -88,8 +88,35 @@ end subroutine declare_simd_simdlen
! CHECK-SAME: simdlen(8)
! CHECK: return
+subroutine declare_simd_uniform(x, y, n, i)
+ !$omp declare simd uniform(x, y)
+
+ real(8), pointer, intent(inout) :: x(:)
+ real(8), pointer, intent(in) :: y(:)
+ integer, intent(in) :: n, i
+
+ if (i <= n) then
+ x(i) = x(i) + y(i)
+ end if
+end subroutine declare_simd_uniform
+
+! CHECK-LABEL: func.func @_QPdeclare_simd_uniform(
+! CHECK-SAME: fir.bindc_name = "x"
+! CHECK-SAME: fir.bindc_name = "y"
+! CHECK-SAME: fir.bindc_name = "n"
+! CHECK-SAME: fir.bindc_name = "i"
+
+! Function prologue
+! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[IDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 4
+! CHECK: %[[NDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 3
+! CHECK: %[[XDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1
+! CHECK: %[[YDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 2
+
+! CHECK: omp.declare_simd uniform(%[[XDECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, %[[YDECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
+
subroutine declare_simd_combined(x, y, n, i)
- !$omp declare simd aligned(x, y : 64) linear(i) simdlen(8)
+ !$omp declare simd aligned(x, y : 64) linear(i) simdlen(8) uniform(x, y)
real(8), pointer, intent(inout) :: x(:)
real(8), pointer, intent(in) :: y(:)
integer, intent(in) :: n, i
@@ -116,4 +143,6 @@ end subroutine declare_simd_combined
! CHECK-SAME: %[[Y_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64)
! CHECK-SAME: linear(%[[I_DECL]]#0 = %[[C1]] : !fir.ref<i32>)
! CHECK-SAME: simdlen(8)
+! CHECK-SAME: uniform(%[[X_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>,
+! CHECK-SAME: %[[Y_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK-SAME: {linear_var_types = [i32]}
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
index 05e2ee4e5632b..720a259d268d1 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
@@ -1532,4 +1532,28 @@ class OpenMP_UseDevicePtrClauseSkip<
def OpenMP_UseDevicePtrClause : OpenMP_UseDevicePtrClauseSkip<>;
+//===----------------------------------------------------------------------===//
+// V5.2: [5.10] `uniform` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_UniformClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause<traits, arguments, assemblyFormat, description,
+ extraClassDeclaration> {
+ let arguments = (ins Variadic<OpenMP_PointerLikeType>:$uniform_vars);
+
+ let optAssemblyFormat = [{
+ `uniform` `(` custom<UniformClause>($uniform_vars, type($uniform_vars)) `)`
+ }];
+
+ let description = [{
+ The `uniform` clause declares one or more arguments to have an invariant
+ value for all concurrent invocations of the function in the execution of
+ a single SIMD loop.
+ }];
+}
+
+def OpenMP_UniformClause : OpenMP_UniformClauseSkip<>;
+
#endif // OPENMP_CLAUSES
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
index c77e08e1fb076..6c91ff4cfa00d 100644
--- a/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
@@ -2248,7 +2248,7 @@ def DeclareSimdOp
: OpenMP_Op<"declare_simd",
traits = [AttrSizedOperandSegments, IsolatedFromAbove],
clauses = [OpenMP_AlignedClause, OpenMP_LinearClause,
- OpenMP_SimdlenClause]> {
+ OpenMP_SimdlenClause, OpenMP_UniformClause]> {
let summary = "declare simd directive";
let description = [{
"omp.declare_simd" models the OpenMP `declare simd` directive.
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
index f23bb659ae88e..11443831b0c85 100644
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -544,6 +544,35 @@ static void printAlignedClause(OpAsmPrinter &p, Operation *op,
}
}
+//===----------------------------------------------------------------------===//
+// Parser and printer for Uniform Clause
+//===----------------------------------------------------------------------===//
+
+/// uniform ::= `uniform` `(` uniform-list `)`
+/// uniform-list := uniform-val (`,` uniform-val)*
+/// uniform-val := ssa-id `:` type
+static ParseResult
+parseUniformClause(OpAsmParser &parser,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &uniformVars,
+ SmallVectorImpl<Type> &uniformTypes) {
+ return parser.parseCommaSeparatedList([&]() -> mlir::ParseResult {
+ if (parser.parseOperand(uniformVars.emplace_back()) ||
+ parser.parseColonType(uniformTypes.emplace_back()))
+ return mlir::failure();
+ return mlir::success();
+ });
+}
+
+/// Print Uniform Clauses
+static void printUniformClause(OpAsmPrinter &p, Operation *op,
+ ValueRange uniformVars, TypeRange uniformTypes) {
+ for (unsigned i = 0; i < uniformVars.size(); ++i) {
+ if (i != 0)
+ p << ", ";
+ p << uniformVars[i] << " : " << uniformTypes[i];
+ }
+}
+
//===----------------------------------------------------------------------===//
// Parser, printer and verifier for Schedule Clause
//===----------------------------------------------------------------------===//
@@ -4468,7 +4497,8 @@ void DeclareSimdOp::build(OpBuilder &odsBuilder, OperationState &odsState,
DeclareSimdOp::build(odsBuilder, odsState, clauses.alignedVars,
makeArrayAttr(ctx, clauses.alignments),
clauses.linearVars, clauses.linearStepVars,
- clauses.linearVarTypes, clauses.simdlen);
+ clauses.linearVarTypes, clauses.simdlen,
+ clauses.uniformVars);
}
LogicalResult DeclareSimdOp::verify() {
diff --git a/mlir/test/Dialect/OpenMP/ops.mlir b/mlir/test/Dialect/OpenMP/ops.mlir
index 8ab2ed89e5ecc..133c6957bf2d5 100644
--- a/mlir/test/Dialect/OpenMP/ops.mlir
+++ b/mlir/test/Dialect/OpenMP/ops.mlir
@@ -3418,6 +3418,19 @@ func.func @omp_declare_simd_linear(%a: f64, %b: f64, %iv: i32, %step: i32) -> f6
return %0 : f64
}
+// CHECK-LABEL: func.func @omp_declare_simd_uniform
+func.func @omp_declare_simd_uniform(%a: f64, %b: f64,
+ %p0: memref<i32>, %p1: memref<i32>) -> f64 {
+ // CHECK: omp.declare_simd
+ // CHECK-SAME: uniform(
+ // CHECK-SAME: %{{.*}} : memref<i32>,
+ // CHECK-SAME: %{{.*}} : memref<i32>)
+ omp.declare_simd uniform(%p0 : memref<i32>, %p1 : memref<i32>)
+
+ %0 = arith.addf %a, %b : f64
+ return %0 : f64
+}
+
// CHECK-LABEL: func.func @omp_declare_simd_all_clauses
func.func @omp_declare_simd_all_clauses(%a: f64, %b: f64,
%p0: memref<i32>, %p1: memref<i32>,
@@ -3428,10 +3441,14 @@ func.func @omp_declare_simd_all_clauses(%a: f64, %b: f64,
// CHECK-SAME: %{{.*}} : memref<i32> -> 128 : i64)
// CHECK-SAME: linear(%{{.*}} = %{{.*}} : i32)
// CHECK-SAME: simdlen(8)
+ // CHECK-SAME: uniform(
+ // CHECK-SAME: %{{.*}} : memref<i32>,
+ // CHECK-SAME: %{{.*}} : memref<i32>)
omp.declare_simd simdlen(8)
aligned(%p0 : memref<i32> -> 32 : i64,
%p1 : memref<i32> -> 128 : i64)
linear(%iv = %step : i32)
+ uniform(%p0 : memref<i32>, %p1 : memref<i32>)
%0 = arith.addf %a, %b : f64
return %0 : f64
More information about the Mlir-commits
mailing list