[OpenMP] Lowering to MLIR of ordered threads directive

[peixin]

Summary

This patch supports lowering parse-tree to MLIR of ordered threads
directive following Section 2.19.9 of the OpenMP 5.1 standard.

This is part of the upstreaming effort from the fir-dev branch in [1].
[1] https://github.com/flang-compiler/f18-llvm-project

[peixin]

flang/lib/Lower/OpenMP.cpp

254

Currently, this gaint for loop looks not good. Considering one PR (D121583) has been created to refactor the clause, is it ok to you @shraiysh to also refactor these clauses operands collection in D121583 after upstreaming work finishes?

[shraiysh]

LGTM

flang/lib/Lower/OpenMP.cpp

250

nit: This is going as-is to the builder - in the sense that, there is no handling for simd clause at the moment. So, instead of putting this here, can we simply pass nullptr to the builder while it isn't handled? Having this here gives the impression that it is somehow handled which is not true.

254

Sure, I will try to handle these too while refactoring.

[kiranchandramohan]

The test is failing currently.

[peixin]

Fix the CI fail by replacing tco with fir-opt since tco has not been supported fully yet.

[peixin]

flang/lib/Lower/OpenMP.cpp

250

Fixed.

254

Thanks.

flang/lib/Lower/OpenMP.cpp

genOMP(Fortran::lower::AbstractConverter &converter,
   mlir::Location currentLocation = converter.getCurrentLocation();
 
   Fortran::lower::StatementContext stmtCtx;
   llvm::ArrayRef<mlir::Type> argTy;
   mlir::Value ifClauseOperand, numThreadsClauseOperand;
   mlir::omp::ClauseProcBindKindAttr procBindKindAttr;
   SmallVector<Value> allocateOperands, allocatorOperands;
   mlir::UnitAttr nowaitAttr;
+  mlir::Attribute simdClauseOperand;
 
   const auto &opClauseList =
       std::get<Fortran::parser::OmpClauseList>(beginBlockDirective.t);
   for (const auto &clause : opClauseList.v) {
     if (const auto &ifClause =
             std::get_if<Fortran::parser::OmpClause::If>(&clause.u)) {
       auto &expr = std::get<Fortran::parser::ScalarLogicalExpr>(ifClause->v.t);
       ifClauseOperand = fir::getBase(
           converter.genExprValue(*Fortran::semantics::GetExpr(expr), stmtCtx));
     } else if (const auto &numThreadsClause =
                    std::get_if<Fortran::parser::OmpClause::NumThreads>(
                        &clause.u)) {
if (const auto &ifClause =
                        &clause.u)) {
       genAllocateClause(converter, allocateClause->v, allocatorOperands,
                         allocateOperands);
     } else if (std::get_if<Fortran::parser::OmpClause::Private>(&clause.u) ||
                std::get_if<Fortran::parser::OmpClause::Firstprivate>(
                    &clause.u)) {
       // Privatisation clauses are handled elsewhere.
       continue;
+    } else if (std::get_if<Fortran::parser::OmpClause::Threads>(&clause.u)) {
+      // Nothing needs to be done for threads clause.
+      continue;
     } else {
       TODO(currentLocation, "OpenMP Block construct clauses");
     }
   }
 
   for (const auto &clause :
        std::get<Fortran::parser::OmpClauseList>(endBlockDirective.t).v) {
     if (std::get_if<Fortran::parser::OmpClause::Nowait>(&clause.u))
genOMP(Fortran::lower::AbstractConverter &converter,
   } else if (blockDirective.v == llvm::omp::OMPD_master) {
     auto masterOp =
         firOpBuilder.create<mlir::omp::MasterOp>(currentLocation, argTy);
     createBodyOfOp<omp::MasterOp>(masterOp, converter, currentLocation);
   } else if (blockDirective.v == llvm::omp::OMPD_single) {
     auto singleOp = firOpBuilder.create<mlir::omp::SingleOp>(
         currentLocation, allocateOperands, allocatorOperands, nowaitAttr);
     createBodyOfOp<omp::SingleOp>(singleOp, converter, currentLocation);
+  } else if (blockDirective.v == llvm::omp::OMPD_ordered) {
+    auto orderedOp = firOpBuilder.create<mlir::omp::OrderedRegionOp>(
+        currentLocation, simdClauseOperand.dyn_cast_or_null<UnitAttr>());
+    createBodyOfOp<omp::OrderedRegionOp>(orderedOp, converter, currentLocation);
   } else {
     TODO(converter.getCurrentLocation(), "Unhandled block directive");
   }
 }
 
 static void
 genOMP(Fortran::lower::AbstractConverter &converter,
        Fortran::lower::pft::Evaluation &eval,

flang/test/Lower/OpenMP/omp-ordered-threads.f90

+! This test checks lowering of OpenMP ordered directive with threads Clause.
+! Without clause in ordered direcitve, it behaves as if threads clause is
+! specified.
+
+! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s --check-prefix=FIRDialect
+! RUN: bbc -fopenmp -emit-fir %s -o - | \
+! RUN:   tco --disable-llvm --print-ir-after=fir-to-llvm-ir 2>&1 | \
+! RUN:   FileCheck %s --check-prefix=LLVMIRDialect
+! RUN: bbc -fopenmp -emit-fir %s -o - | tco | FileCheck %s --check-prefix=LLVMIR
+
+subroutine ordered
+        integer :: i
+        integer :: a(20)
+
+!FIRDialect: omp.ordered_region  {
+!LLVMIRDialect: omp.ordered_region  {
+!LLVMIR: [[TMP0:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB0:[0-9]+]]), !dbg !{{.*}}
+!LLVMIR-NEXT: call void @__kmpc_ordered(%struct.ident_t* @[[GLOB0]], i32 [[TMP0]]), !dbg !{{.*}}
+!$OMP ORDERED
+        a(i) = a(i-1) + 1
+!FIRDialect:   omp.terminator
+!FIRDialect-NEXT: }
+!LLVMIRDialect:   omp.terminator
+!LLVMIRDialect-NEXT: }
+!LLVMIR: call void @__kmpc_end_ordered(%struct.ident_t* @[[GLOB0]], i32 [[TMP0]]), !dbg !{{.*}}
+!$OMP END ORDERED
+
+!FIRDialect: omp.ordered_region  {
+!LLVMIRDialect: omp.ordered_region  {
+!LLVMIR: [[TMP1:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB1:[0-9]+]]), !dbg !{{.*}}
+!LLVMIR-NEXT: call void @__kmpc_ordered(%struct.ident_t* @[[GLOB1]], i32 [[TMP1]]), !dbg !{{.*}}
+!$OMP ORDERED THREADS
+        a(i) = a(i-1) + 1
+!FIRDialect:   omp.terminator
+!FIRDialect-NEXT: }
+!LLVMIRDialect:   omp.terminator
+!LLVMIRDialect-NEXT: }
+!LLVMIR: call void @__kmpc_end_ordered(%struct.ident_t* @[[GLOB1]], i32 [[TMP1]]), !dbg !{{.*}}
+!LLVMIR-NEXT: ret void, !dbg !{{.*}}
+!$OMP END ORDERED
+
+end