[MLIR][OpenMP] Add support for ordered construct

[peixin]

Summary

This patch supports the ordered construct in OpenMP dialect following
Section 2.19.9 of the OpenMP 5.1 standard. Also lowering to LLVM IR
using OpenMP IRBduiler. Lowering to LLVM IR for ordered simd directive
is not supported yet since LLVM optimization passes do not support it
for now.

[peixin]

Fix clang-tidy warning.

[ftynse]

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

423

typo: workshwring

429

Nit: couldn't parse "it behaves that the THREADS"

429

typo: cluase

437

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

482

Nit: you don't need a ternary operator here, just do bool isDependSource = dependType == omp::ClauseDepend::dependsource.

491

Nit: please .reserve space in a vector before calling push_back in the loop.

504

Should this return failure() in presence of said directive?

506–508

It would be better to actually check bodyGenStatus after bodyGenCB is transitively called below.

[peixin]

@ftynse Thanks for your comments and addressed them.

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

423

Fixed.

429

Fixed.

429

The previous description is not correct. Replaced the statement of behaves that the THREADS clause is specfied with the statement of behaves as if the THREADS clause is specified or no clause is specified. There is no need to add the threads attribute in MLIR. The omp ordered and omp ordered threads directive in fortran code will be lowered to the following mlir:

omp.ordered {
  omp.terminator
} // nothing here

437

Fixed.

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

482

Fixed.

491

Fixed.

504

Yes, this is better. Fixed.

506–508

Good point. Fixed by return bodyGenStatus instead of success();

[kiranchandramohan]

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

446

Do we need both depend and depend_type_val? The presence of depend_type_val implies depend right?

451

For discussion:
The standalone ordered construct does not have a region. Should we split the ordered construct into two MLIR operations, something like the following?
omp.ordered_region
omp.ordered

[peixin]

@kiranchandramohan Thanks for the comments.

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

446

Considering that the MLIR operation will be split, the depend attribute will be deleted.

451

Yes, I agree. This makes more sense although IR generated will be the same. Let me do it.

[peixin]

Split the ordered construct into two MLIR operations, OrderedOp and OrderedRegionOp.

[peixin]

Delete depend UnitAttr in test cases.

[kiranchandramohan]

LGTM. Apologies for the delay. Please wait for @ftynse to approve.

Once you submit, you can cherry-pick these patches to fir-dev and then rebase the lowering of the ordered construct there.

[peixin]

@kiranchandramohan OK. Thanks for your review.

[shraiysh]

Not sure if this is feasible in MLIR, but can we verify that the ordered construct is within a worksharing-loop or simd construct, as specified in the standard?

[kiranchandramohan]

In D110015#3068247, @shraiysh wrote:

Not sure if this is feasible in MLIR, but can we verify that the ordered construct is within a worksharing-loop or simd construct, as specified in the standard?

Thanks @shraiysh for raising this.
You can get a parentofType as done in the verifyReductionOp.
https://github.com/llvm/llvm-project/blob/48ce523a26b7a5a3dc4cff616c93ed951244746b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp#L833

[peixin]

Add the verifier of MLIR and the corresponding test cases.

Thanks @shraiysh and @kiranchandramohan for noticing the missed verifier.

SIMD Op is not implemented yet. I left TODO for ordered simd.

[ftynse]

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1105

Nit: you can put the variable definition inside the if (auto container = op->getPraentOfType)

1106

Nit: I would put braces around the outer loop to avoid the potential dangling-else footgun.

[shraiysh]

Some attributes are expected in the attribute dictionary. This is different from the way it is done for other operations (nowait, default for ParallelOp and collapse, order, ordered clauses for WsLoopOp). I do not have a preference for either way, but it should probably be uniform across the operations. Maybe others can advise on which format to opt for.

[clementval]

In D110015#3070236, @shraiysh wrote:

Some attributes are expected in the attribute dictionary. This is different from the way it is done for other operations (nowait, default for ParallelOp and collapse, order, ordered clauses for WsLoopOp). I do not have a preference for either way, but it should probably be uniform across the operations. Maybe others can advise on which format to opt for.

+1 for uniformity between the ops in the same dialects.

[peixin]

Thanks @ftynse for the code format advice. Fixed.

Thanks @shraiysh @clementval for the operation uniformity advice. Add the depend_type and simd in assemblyFormat so that the operation keeps the similar format as others. I would rather leave num_loops_val as appendant. It is different as collapse and ordered in wsloop construct, which are clauses from fortran code. The num_loops_val does not exist in fortran code and it is helper to transform MLIR to LLVMIR. Take the following as one example:

!$omp depend(sink: i)

I think the MLIR format of omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) {num_loops_val = 1 : i64} looks more reasonable than omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) num_loops_val (1 : i64). Is this OK with you @shraiysh @clementval ?

[clementval]

Thanks @shraiysh @clementval for the operation uniformity advice. Add the depend_type and simd in assemblyFormat so that the operation keeps the similar format as others. I would rather leave num_loops_val as appendant. It is different as collapse and ordered in wsloop construct, which are clauses from fortran code. The num_loops_val does not exist in fortran code and it is helper to transform MLIR to LLVMIR. Take the following as one example:

!$omp depend(sink: i)

I think the MLIR format of omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) {num_loops_val = 1 : i64} looks more reasonable than omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) num_loops_val (1 : i64). Is this OK with you @shraiysh @clementval ?

I think this format omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) {num_loops_val = 1 : i64} is fine.

[shraiysh]

In D110015#3072110, @clementval wrote:

Thanks @shraiysh @clementval for the operation uniformity advice. Add the depend_type and simd in assemblyFormat so that the operation keeps the similar format as others. I would rather leave num_loops_val as appendant. It is different as collapse and ordered in wsloop construct, which are clauses from fortran code. The num_loops_val does not exist in fortran code and it is helper to transform MLIR to LLVMIR. Take the following as one example:

!$omp depend(sink: i)

I think the MLIR format of omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) {num_loops_val = 1 : i64} looks more reasonable than omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) num_loops_val (1 : i64). Is this OK with you @shraiysh @clementval ?

I think this format omp.ordered depend_type("dependsink") depend_vec(%arg0: i64) {num_loops_val = 1 : i64} is fine.

+1. I think this is fine.

[peixin]

Is it OK to land this patch now?

[shraiysh]

Thank you for updating the patch @peixin. I have a few comments.

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

442–446

The clauses are not order-independent at the moment (there was a discussion on the slack channel about this and they decided to support order-independence for clauses in OpenMP dialect). Another thing is that the values of "dependsink" and "dependsource" are expected to come with quotations marks. This is different from the way it is done for other clause values (proc_bind and default clauses expect their values like a keyword). I think you might have to add custom parser/printers for this operation for now.

There is an RFC to support order independence within assemblyFormat. Once that goes through, this might get simplified.

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1105

AFAIK ordered clause with region is also not allowed outside of a worksharing loop/simd construct. That is, like verifyOrderedOp a similar check for if(!container || ...) should be here. I am not sure about this restriction though, so please feel free to correct me if I am mistaken.

[peixin]

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

442–446

Keep the depend_type_val, depend_vec_vars, and num_loops_val in order is better since it is more like the fortran source code. This case is different from others since these three arguments are generated from one clause, and they are not indepentdent.

The depend_type_val is a little bit different from the default and proc_bind clauses, which are keyword of the clauses. The keyword of depend_type_val is not the string "dependsource" or "dependsink". Instead, it is depend_type, which has the similar format as default and proc_bind clauses. This depend clause is special since it has two keywords followed by one vector and multiple clauses can exist. These three arguments actully describe one clause. I think the current format is good enough to match the format of fortran code. What do you think?

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1105

You understand it correctly. The problem is that the current compiler cannot do interprocedural analysis. So for the following case, if (!container) should not be there.

subroutine sub1()
  !$omp ordered threads
  !$omp end ordered
end
subroutine sub2()
  !$omp do ordered
  ...
  call sub1()
  ...
  !$omp end do
end

[shraiysh]

LGTM.

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

442–446

Okay, thanks for the clarification about the ordering.

About the proc_bind clause, I meant that the syntax there is omp.parallel proc_bind(close) and not omp.parallel proc_bind("close"). But I think this is okay because we can use assemblyFormat if we allow the quotation marks. Writing custom parsers/printers for this alone is not worth it IMO.

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1105

Oh okay, sounds good. Should this check then be removed from the OrderedOp too?

[peixin]

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1105

No. The special case of OrderedOp ordered depend(source) doesn't know the number of loops, so there must be one wsloop in the same procedure. That is, the above code for ordered depend(source) cannot be lowered since the loop number info is missed. So we should give user one semantic error, which is also done by gfortran.

[shraiysh]

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1105

Okay, that makes sense. Thanks for the explanation.

[peixin]

Is it OK to land this patch now?

[peixin]

I will land this patch now, and cherry-pick this and the other two ordered construct related patches to fir-dev.

[mehdi_amini]

All the bots were broken, I reverted in cb11ddb96c47538545913de527906aa6f9cdc76f

[peixin]

Rebase this patch and delete the inclusive attribute to avoid CI fail.

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

let description = [{
     The barrier construct specifies an explicit barrier at the point at which
     the construct appears.
   }];
 
   let assemblyFormat = "attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
+// [5.1] 2.19.9 ordered Construct
+//===----------------------------------------------------------------------===//
+
+def ClauseDependSource : StrEnumAttrCase<"dependsource">;
+def ClauseDependSink : StrEnumAttrCase<"dependsink">;
+
+def ClauseDepend : StrEnumAttr<
+    "ClauseDepend",
+    "depend clause",
+    [ClauseDependSource, ClauseDependSink]> {
+  let cppNamespace = "::mlir::omp";
+}
+
+def OrderedOp : OpenMP_Op<"ordered"> {
+  let summary = "ordered construct without region";
+  let description = [{
+    The ordered construct without region is a stand-alone directive that
+    specifies cross-iteration dependences in a doacross loop nest.
+
+    The `depend_type_val` attribute refers to either the DEPEND(SOURCE) clause
+    or the DEPEND(SINK: vec) clause.
+
+    The `num_loops_val` attribute specifies the number of loops in the doacross
+    nest.
+
+    The `depend_vec_vars` is a variadic list of operands that specifies the index
+    of the loop iterator in the doacross nest for the DEPEND(SOURCE) clause or
+    the index of the element of "vec" for the DEPEND(SINK: vec) clause. It
+    contains the operands in multiple "vec" when multiple DEPEND(SINK: vec)
+    clauses exist in one ORDERED directive.
+  }];
+
+  let arguments = (ins OptionalAttr<ClauseDepend>:$depend_type_val,
+             Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
+             Variadic<AnyType>:$depend_vec_vars);
+
+  let assemblyFormat = [{
+    ( `depend_type` `(` $depend_type_val^ `)` )?
+    ( `depend_vec` `(` $depend_vec_vars^ `:` type($depend_vec_vars) `)` )?
+    attr-dict
+  }];
+
+  let verifier = "return ::verifyOrderedOp(*this);";
+}
+
+def OrderedRegionOp : OpenMP_Op<"ordered_region"> {
+  let summary = "ordered construct with region";
+  let description = [{
+    The ordered construct with region specifies a structured block in a
+    worksharing-loop, SIMD, or worksharing-loop SIMD region that is executed in
+    the order of the loop iterations.
+
+    The `simd` attribute corresponds to the SIMD clause specified. If it is not
+    present, it behaves as if the THREADS clause is specified or no clause is
+    specified.
+  }];
+
+  let arguments = (ins UnitAttr:$simd);
+
+  let regions = (region AnyRegion:$region);
+
+  let assemblyFormat = [{ ( `simd` $simd^ )? $region attr-dict}];
+
+  let verifier = "return ::verifyOrderedRegionOp(*this);";
+}
+
+//===----------------------------------------------------------------------===//
 // 2.17.5 taskwait Construct
 //===----------------------------------------------------------------------===//
 
 def TaskwaitOp : OpenMP_Op<"taskwait"> {
   let summary = "taskwait construct";
   let description = [{
     The taskwait construct specifies a wait on the completion of child tasks
     of the current task.

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

if (!decl) {
       return op.emitOpError() << "expected symbol reference " << symbolRef
                               << " to point to a critical declaration";
     }
   }
 
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// Verifier for ordered construct
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verifyOrderedOp(OrderedOp op) {
+  auto container = op->getParentOfType<WsLoopOp>();
+  if (!container || !container.ordered_valAttr() ||
+      container.ordered_valAttr().getInt() == 0)
+    return op.emitOpError() << "ordered depend directive must be closely "
+                            << "nested inside a worksharing-loop with ordered "
+                            << "clause with parameter present";
+
+  if (container.ordered_valAttr().getInt() !=
+      (int64_t)op.num_loops_val().getValue())
+    return op.emitOpError() << "number of variables in depend clause does not "
+                            << "match number of iteration variables in the "
+                            << "doacross loop";
+
+  return success();
+}
+
+static LogicalResult verifyOrderedRegionOp(OrderedRegionOp op) {
+  // TODO: The code generation for ordered simd directive is not supported yet.
+  if (op.simd())
+    return failure();
+
+  if (auto container = op->getParentOfType<WsLoopOp>()) {
+    if (!container.ordered_valAttr() ||
+        container.ordered_valAttr().getInt() != 0)
+      return op.emitOpError() << "ordered region must be closely nested inside "
+                              << "a worksharing-loop region with an ordered "
+                              << "clause without parameter present";
+  }
+
+  return success();
+}
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

OwningAtomicReductionGen atomicGen =
                                            moduleTranslation, &phis)))
           return llvm::OpenMPIRBuilder::InsertPointTy();
         assert(phis.empty());
         return builder.saveIP();
       };
   return atomicGen;
 }
 
+/// Converts an OpenMP 'ordered' operation into LLVM IR using OpenMPIRBuilder.
+static LogicalResult
+convertOmpOrdered(Operation &opInst, llvm::IRBuilderBase &builder,
+                  LLVM::ModuleTranslation &moduleTranslation) {
+  auto orderedOp = cast<omp::OrderedOp>(opInst);
+
+  omp::ClauseDepend dependType =
+      *omp::symbolizeClauseDepend(orderedOp.depend_type_valAttr().getValue());
+  bool isDependSource = dependType == omp::ClauseDepend::dependsource;
+  unsigned numLoops = orderedOp.num_loops_val().getValue();
+  SmallVector<llvm::Value *> vecValues =
+      moduleTranslation.lookupValues(orderedOp.depend_vec_vars());
+
+  llvm::OpenMPIRBuilder::LocationDescription ompLoc(
+      builder.saveIP(), builder.getCurrentDebugLocation());
+  size_t indexVecValues = 0;
+  while (indexVecValues < vecValues.size()) {
+    SmallVector<llvm::Value *> storeValues;
+    storeValues.reserve(numLoops);
+    for (unsigned i = 0; i < numLoops; i++) {
+      storeValues.push_back(vecValues[indexVecValues]);
+      indexVecValues++;
+    }
+    builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createOrderedDepend(
+        ompLoc, findAllocaInsertPoint(builder, moduleTranslation), numLoops,
+        storeValues, ".cnt.addr", isDependSource));
+  }
+  return success();
+}
+
+/// Converts an OpenMP 'ordered_region' operation into LLVM IR using
+/// OpenMPIRBuilder.
+static LogicalResult
+convertOmpOrderedRegion(Operation &opInst, llvm::IRBuilderBase &builder,
+                        LLVM::ModuleTranslation &moduleTranslation) {
+  using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
+  auto orderedRegionOp = cast<omp::OrderedRegionOp>(opInst);
+
+  // TODO: The code generation for ordered simd directive is not supported yet.
+  if (orderedRegionOp.simd())
+    return failure();
+
+  // TODO: support error propagation in OpenMPIRBuilder and use it instead of
+  // relying on captured variables.
+  LogicalResult bodyGenStatus = success();
+
+  auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
+                       llvm::BasicBlock &continuationBlock) {
+    // OrderedOp has only one region associated with it.
+    auto &region = cast<omp::OrderedRegionOp>(opInst).getRegion();
+    convertOmpOpRegions(region, "omp.ordered.region", *codeGenIP.getBlock(),
+                        continuationBlock, builder, moduleTranslation,
+                        bodyGenStatus);
+  };
+
+  // TODO: Perform finalization actions for variables. This has to be
+  // called for variables which have destructors/finalizers.
+  auto finiCB = [&](InsertPointTy codeGenIP) {};
+
+  llvm::OpenMPIRBuilder::LocationDescription ompLoc(
+      builder.saveIP(), builder.getCurrentDebugLocation());
+  builder.restoreIP(
+      moduleTranslation.getOpenMPBuilder()->createOrderedThreadsSimd(
+          ompLoc, bodyGenCB, finiCB, !orderedRegionOp.simd()));
+  return bodyGenStatus;
+}
+
 /// Converts an OpenMP workshare loop into LLVM IR using OpenMPIRBuilder.
 static LogicalResult
 convertOmpWsLoop(Operation &opInst, llvm::IRBuilderBase &builder,
                  LLVM::ModuleTranslation &moduleTranslation) {
   auto loop = cast<omp::WsLoopOp>(opInst);
   // TODO: this should be in the op verifier instead.
   if (loop.lowerBound().empty())
     return failure();
return llvm::TypeSwitch<Operation *, LogicalResult>(op)
         return convertOmpReductionOp(reductionOp, builder, moduleTranslation);
       })
       .Case([&](omp::MasterOp) {
         return convertOmpMaster(*op, builder, moduleTranslation);
       })
       .Case([&](omp::CriticalOp) {
         return convertOmpCritical(*op, builder, moduleTranslation);
       })
+      .Case([&](omp::OrderedRegionOp) {
+        return convertOmpOrderedRegion(*op, builder, moduleTranslation);
+      })
+      .Case([&](omp::OrderedOp) {
+        return convertOmpOrdered(*op, builder, moduleTranslation);
+      })
       .Case([&](omp::WsLoopOp) {
         return convertOmpWsLoop(*op, builder, moduleTranslation);
       })
       .Case<omp::YieldOp, omp::TerminatorOp, omp::ReductionDeclareOp,
             omp::CriticalDeclareOp>([](auto op) {
         // `yield` and `terminator` can be just omitted. The block structure
         // was created in the region that handles their parent operation.
         // `reduction.declare` will be used by reductions and is not

mlir/test/Dialect/OpenMP/invalid.mlir

 
 omp.critical.declare @mutex
 func @omp_critica() -> () {
   // expected-error @below {{invalid_hint is not a valid hint}}
   omp.critical(@mutex) hint(invalid_hint) {
     omp.terminator
   }
 }
+
+// -----
+
+func @omp_ordered1(%arg1 : i64, %arg2 : i64, %arg3 : i64) -> () {
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) ordered(1) inclusive {
+    // expected-error @below {{ordered region must be closely nested inside a worksharing-loop region with an ordered clause without parameter present}}
+    omp.ordered_region {
+      omp.terminator
+    }
+    omp.yield
+  }
+  return
+}
+
+// -----
+
+func @omp_ordered2(%arg1 : i64, %arg2 : i64, %arg3 : i64) -> () {
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) inclusive {
+    // expected-error @below {{ordered region must be closely nested inside a worksharing-loop region with an ordered clause without parameter present}}
+    omp.ordered_region {
+      omp.terminator
+    }
+    omp.yield
+  }
+  return
+}
+
+// -----
+
+func @omp_ordered3(%vec0 : i64) -> () {
+  // expected-error @below {{ordered depend directive must be closely nested inside a worksharing-loop with ordered clause with parameter present}}
+  omp.ordered depend_type("dependsink") depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+  return
+}
+
+// -----
+
+func @omp_ordered4(%arg1 : i64, %arg2 : i64, %arg3 : i64, %vec0 : i64) -> () {
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) ordered(0) inclusive {
+    // expected-error @below {{ordered depend directive must be closely nested inside a worksharing-loop with ordered clause with parameter present}}
+    omp.ordered depend_type("dependsink") depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+
+    omp.yield
+  }
+  return
+}
+
+// -----
+
+func @omp_ordered5(%arg1 : i64, %arg2 : i64, %arg3 : i64, %vec0 : i64, %vec1 : i64) -> () {
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) ordered(1) inclusive {
+    // expected-error @below {{number of variables in depend clause does not match number of iteration variables in the doacross loop}}
+    omp.ordered depend_type("dependsource") depend_vec(%vec0, %vec1 : i64, i64) {num_loops_val = 2 : i64}
+
+    omp.yield
+  }
+  return
+}

mlir/test/Dialect/OpenMP/ops.mlir

omp.critical(@mutex) hint(uncontended, speculative) {
     omp.terminator
   }
   // CHECK: omp.critical(@{{.*}}) hint(contended, speculative)
   omp.critical(@mutex) hint(speculative, contended) {
     omp.terminator
   }
   return
 }
+
+func @omp_ordered(%arg1 : i64, %arg2 : i64, %arg3 : i64,
+    %vec0 : i64, %vec1 : i64, %vec2 : i64, %vec3 : i64) -> () {
+  // CHECK: omp.ordered_region
+  omp.ordered_region {
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) ordered(0) inclusive {
+    omp.ordered_region {
+      omp.terminator
+    }
+    omp.yield
+  }
+
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) ordered(1) inclusive {
+    // Only one DEPEND(SINK: vec) clause
+    // CHECK: omp.ordered depend_type("dependsink") depend_vec(%{{.*}} : i64) {num_loops_val = 1 : i64}
+    omp.ordered depend_type("dependsink") depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+
+    // CHECK: omp.ordered depend_type("dependsource") depend_vec(%{{.*}} : i64) {num_loops_val = 1 : i64}
+    omp.ordered depend_type("dependsource") depend_vec(%vec0 : i64) {num_loops_val = 1 : i64}
+
+    omp.yield
+  }
+
+  omp.wsloop (%0) : i64 = (%arg1) to (%arg2) step (%arg3) ordered(2) inclusive {
+    // Multiple DEPEND(SINK: vec) clauses
+    // CHECK: omp.ordered depend_type("dependsink") depend_vec(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i64, i64, i64, i64) {num_loops_val = 2 : i64}
+    omp.ordered depend_type("dependsink") depend_vec(%vec0, %vec1, %vec2, %vec3 : i64, i64, i64, i64) {num_loops_val = 2 : i64}
+
+    // CHECK: omp.ordered depend_type("dependsource") depend_vec(%{{.*}}, %{{.*}} : i64, i64) {num_loops_val = 2 : i64}
+    omp.ordered depend_type("dependsource") depend_vec(%vec0, %vec1 : i64, i64) {num_loops_val = 2 : i64}
+
+    omp.yield
+  }
+
+  return
+}

mlir/test/Target/LLVMIR/openmp-llvm.mlir

omp.wsloop (%arg0, %arg1, %arg2) : i32 = (%0, %1, %2) to (%3, %4, %5) step (%6, %7, %8) collapse(3) {
       %34 = llvm.add %33, %arg2 : i32
       llvm.store %34, %20 : !llvm.ptr<i32>
       omp.yield
     }
     omp.terminator
   }
   llvm.return
 }
+
+llvm.func @omp_ordered(%arg0 : i64, %arg1 : i64, %arg2 : i64, %arg3 : i64,
+    %arg4: i64, %arg5: i64, %arg6: i64) -> () {
+  // CHECK: [[ADDR9:%.*]] = alloca [2 x i64], align 8
+  // CHECK: [[ADDR7:%.*]] = alloca [2 x i64], align 8
+  // CHECK: [[ADDR5:%.*]] = alloca [2 x i64], align 8
+  // CHECK: [[ADDR3:%.*]] = alloca [1 x i64], align 8
+  // CHECK: [[ADDR:%.*]] = alloca [1 x i64], align 8
+
+  // CHECK: [[OMP_THREAD:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB1:[0-9]+]])
+  // CHECK-NEXT:  call void @__kmpc_ordered(%struct.ident_t* @[[GLOB1]], i32 [[OMP_THREAD]])
+  omp.ordered_region {
+    omp.terminator
+  // CHECK: call void @__kmpc_end_ordered(%struct.ident_t* @[[GLOB1]], i32 [[OMP_THREAD]])
+  }
+
+  omp.wsloop (%arg7) : i64 = (%arg0) to (%arg1) step (%arg2) ordered(0) inclusive {
+    // CHECK: [[OMP_THREAD:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB1:[0-9]+]])
+    // CHECK-NEXT:  call void @__kmpc_ordered(%struct.ident_t* @[[GLOB1]], i32 [[OMP_THREAD]])
+    omp.ordered_region  {
+      omp.terminator
+    // CHECK: call void @__kmpc_end_ordered(%struct.ident_t* @[[GLOB1]], i32 [[OMP_THREAD]])
+    }
+    omp.yield
+  }
+
+  omp.wsloop (%arg7) : i64 = (%arg0) to (%arg1) step (%arg2) ordered(1) inclusive {
+    // CHECK: [[TMP:%.*]] = getelementptr inbounds [1 x i64], [1 x i64]* [[ADDR]], i64 0, i64 0
+    // CHECK: store i64 [[ARG0:%.*]], i64* [[TMP]], align 4
+    // CHECK: [[TMP2:%.*]] = getelementptr inbounds [1 x i64], [1 x i64]* [[ADDR]], i64 0, i64 0
+    // CHECK: [[OMP_THREAD2:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB3:[0-9]+]])
+    // CHECK: call void @__kmpc_doacross_wait(%struct.ident_t* @[[GLOB3]], i32 [[OMP_THREAD2]], i64* [[TMP2]])
+    omp.ordered depend_type("dependsink") depend_vec(%arg3 : i64) {num_loops_val = 1 : i64}
+
+    // CHECK: [[TMP3:%.*]] = getelementptr inbounds [1 x i64], [1 x i64]* [[ADDR3]], i64 0, i64 0
+    // CHECK: store i64 [[ARG0]], i64* [[TMP3]], align 4
+    // CHECK: [[TMP4:%.*]] = getelementptr inbounds [1 x i64], [1 x i64]* [[ADDR3]], i64 0, i64 0
+    // CHECK: [[OMP_THREAD4:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB5:[0-9]+]])
+    // CHECK: call void @__kmpc_doacross_post(%struct.ident_t* @[[GLOB5]], i32 [[OMP_THREAD4]], i64* [[TMP4]])
+    omp.ordered depend_type("dependsource") depend_vec(%arg3 : i64) {num_loops_val = 1 : i64}
+
+    omp.yield
+  }
+
+  omp.wsloop (%arg7) : i64 = (%arg0) to (%arg1) step (%arg2) ordered(2) inclusive {
+    // CHECK: [[TMP5:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR5]], i64 0, i64 0
+    // CHECK: store i64 [[ARG0]], i64* [[TMP5]], align 4
+    // CHECK: [[TMP6:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR5]], i64 0, i64 1
+    // CHECK: store i64 [[ARG1:%.*]], i64* [[TMP6]], align 4
+    // CHECK: [[TMP7:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR5]], i64 0, i64 0
+    // CHECK: [[OMP_THREAD6:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB7:[0-9]+]])
+    // CHECK: call void @__kmpc_doacross_wait(%struct.ident_t* @[[GLOB7]], i32 [[OMP_THREAD6]], i64* [[TMP7]])
+    // CHECK: [[TMP8:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR7]], i64 0, i64 0
+    // CHECK: store i64 [[ARG2:%.*]], i64* [[TMP8]], align 4
+    // CHECK: [[TMP9:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR7]], i64 0, i64 1
+    // CHECK: store i64 [[ARG3:%.*]], i64* [[TMP9]], align 4
+    // CHECK: [[TMP10:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR7]], i64 0, i64 0
+    // CHECK: [[OMP_THREAD8:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB7]])
+    // CHECK: call void @__kmpc_doacross_wait(%struct.ident_t* @[[GLOB7]], i32 [[OMP_THREAD8]], i64* [[TMP10]])
+    omp.ordered depend_type("dependsink") depend_vec(%arg3, %arg4, %arg5, %arg6 : i64, i64, i64, i64) {num_loops_val = 2 : i64}
+
+    // CHECK: [[TMP11:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR9]], i64 0, i64 0
+    // CHECK: store i64 [[ARG0]], i64* [[TMP11]], align 4
+    // CHECK: [[TMP12:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR9]], i64 0, i64 1
+    // CHECK: store i64 [[ARG1]], i64* [[TMP12]], align 4
+    // CHECK: [[TMP13:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[ADDR9]], i64 0, i64 0
+    // CHECK: [[OMP_THREAD10:%.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GLOB9:[0-9]+]])
+    // CHECK: call void @__kmpc_doacross_post(%struct.ident_t* @[[GLOB9]], i32 [[OMP_THREAD10]], i64* [[TMP13]])
+    omp.ordered depend_type("dependsource") depend_vec(%arg3, %arg4 : i64, i64) {num_loops_val = 2 : i64}
+
+    omp.yield
+  }
+
+  llvm.return
+}