[MLIR][OpenMP] Fixed the missing inclusive clause in omp.wsloop and fix order clause

[shraiysh]

Summary

This patch adds the inclusive clause (which was missed in previous
reorganization - https://reviews.llvm.org/D110903) in omp.wsloop operation.
Added a test for validating it.

Also fixes the order clause, which was not accepting any values. It now accepts
"concurrent" as a value, as specified in the standard.

[shraiysh]

@peixin @kiranchandramohan does this look okay? Please review it as this handles failing test cases in CI.

[shraiysh]

Rebase with main as the commit with failing tests was reverted.

[clementval]

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

917

That would be nice to be able to generate this kind of list from the OMP.td file so this kind of problem would not occur.

[shraiysh]

I will land this patch now.

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

917

Hmm, that is true. I will try to look into this sometime later.

[peixin]

Please double check any other clauses are not missed in test cases.

[peixin]

It seems that order clause test is also missed in ops.mlir. It would be better to add the test cases for each clause wsloop and parallel directive since your previous PR made changes to this part.

[clementval]

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

917

Sure it's not smth urgent right now but good to keep it on the omp todo list.

[kiranchandramohan]

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

917

inclusive is not a clause from the OpenMP standard. It is a property of the DO loop associated with the OpenMP worksharing loop. Just like we do not have upper_bound, lower_bound and step as clauses here, I think we should not list inclusive also as a clause and deal with it like upper_bound, lower_bound and step.

BTW, the test for inclusive was in generic syntax that is why we did not catch missing this. As @peixin says it will be good to go through all the clauses and see whether there is a test for the pretty syntax.

[shraiysh]

Thanks @kiranchandramohan @peixin and @clementval for the review.

Moved inclusive out of clauses. Added tests for other clauses. Please let me know if you see any missing test-cases. I have not added failing test cases for the clauses which are allowed by the standard but not supported by the operations right now.
Handled order clause, the constraint was not accepting the concurrent value and the default value could not be provided by the user. So, essentially it was absent. Added test for the same.

[shraiysh]

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

917

Done!

[shraiysh]

Handle build failure

[kiranchandramohan]

mlir/test/Dialect/OpenMP/invalid.mlir

150

Is this an error because inclusive is not placed after ub?

158

Why is this an error?

mlir/test/Dialect/OpenMP/ops.mlir

146

Nit: Is this a formatting character?

[shraiysh]

Address comments

[shraiysh]

Thanks for the comments @kiranchandramohan. I have addressed them.

mlir/test/Dialect/OpenMP/invalid.mlir

150

Yes, as you suggested, inclusive is not a clause and so, it is expected outside the clause-list. I placed it right after the upper bound because it only affects the upper bound.

158

This is an error because order(default) is not allowed to be specified by the user according to the standard. Order can either be present with the concurrent value, or it should not be there.

mlir/test/Dialect/OpenMP/ops.mlir

146

I don't think it is a formatting character, I have tried to remove it and add spaces and upload the diff, but it is staying. I believe this is just a new-line diff.

[shraiysh]

Update to restart build

[shraiysh]

Rebase with main

[shraiysh]

The builds have passed now. This patch is ready for review.

[peixin]

Thanks @shraiysh for providing those previous missed test cases.

mlir/test/Dialect/OpenMP/invalid.mlir

158

It seems that order clause can only be present with the concurrent value. Where does the OMP_ORDER_default in OMP.td come from? I don't see this in OpenMP 5.0 Spec.

[shraiysh]

mlir/test/Dialect/OpenMP/invalid.mlir

158

Yes, that is correct. It is not in the OpenMP Spec, but as far as I understand, every Clause in OMP.td is supposed to have a default value (which signifies no value, I believe). I faced a similar issue when dealing with the memory_order clause. There was no default memory clause in the standard, and not adding a default value was leading to some errors in either one of llvm/clang/flang (I don't exactly remember which one). @clementval please correct me if I have missed something.

[peixin]

LGTM.

mlir/test/Dialect/OpenMP/invalid.mlir

158

Thanks for the explanation. This is fine with me.

[kiranchandramohan]

I have a couple of questions.

mlir/test/Dialect/OpenMP/invalid.mlir

150

Since we have not documented the difference between regular OpenMP clauses and OpenMP dialect attributes/operands, it might be confusing to get this error. Would it be possible to give the error regarding the placement?

158

I think ClauseVal is currently only used for generating string attributes for some clauses in the OpenMP MLIR dialect. This change will list default as a possible option but the verifier will not permit it which I believe is not an ideal situation.
https://mlir.llvm.org/docs/Dialects/OpenMPDialect/#attributes-4

Can we do something else here?

1. Since only one value is allowed can this be changed to a unit attribute?
2. Check whether the requirement for default can be relaxed? Where did you see this error?

[shraiysh]

Thanks for the questions @kiranchandramohan ! I have tried to address them. Please let me know what you think.

mlir/test/Dialect/OpenMP/invalid.mlir

150

We can change this error message for invalid clauses in general, but changing it specifically for "inclusive" might not be simple with the current implementation. AFAIU, we have two choices -

• Make inclusive a clause and change the syntax back to original, just for OpenMP Dialect (might be useful for other loop-related pragmas too).
• Change the error message to include something like "attribute might be placed wrongly".

158

This error is not seen in the latest rebase. So we can use it without the default value now.

[shraiysh]

mlir/test/Dialect/OpenMP/invalid.mlir

158

I am sorry, there is an error in the latest rebase too. I do not know why procbind is getting affected by the presence/absence of default value for OMPC_Order. Looking into it.

$ ninja check-mlir
undefined reference to `llvm::omp::getProcBindKind(llvm::StringRef)'

[kiranchandramohan]

Thanks. LGTM.

mlir/test/Dialect/OpenMP/invalid.mlir

150

OK. No need to change now. We can later handle this appropriately as an attribute in general syntax, using open-closed interval syntax etc.

158

There is an error before that which leads to the OMP*.inc files not being generated and possibly the first missing function is getProcBindKind which causes an undefined reference.

[3/41] Building OMP.inc...
error: At least one val in Clause order must be defined as default.

Looking at this again I think this is OK, we do not generate documentation for the OrderKind values. And default does not seem to be in OrderKind.

def OrderKindconcurrent : StrEnumAttrCase<"concurrent">;
def OrderKind: StrEnumAttr<
  "ClauseOrderKind",
  "OrderKind Clause",
  [OrderKindconcurrent]> {
    let cppNamespace = "::mlir::omp";
}

BTW, proc_bind uses the unknown value for this purpose. Would it be better to reuse this value (unknown) instead of default?
def OMP_PROC_BIND_unknown : ClauseVal<"unknown",7,0> { let isDefault = true; }

[shraiysh]

Changed default to "unknown"

mlir/test/Dialect/OpenMP/invalid.mlir

150

Okay.

158

Hi, thanks for looking into this. I will change it to unknown.

llvm/include/llvm/Frontend/OpenMP/OMP.td

def OMPC_Allocate : Clause<"allocate"> {
   let flangClass = "OmpAllocateClause";
 }
 def OMPC_NonTemporal : Clause<"nontemporal"> {
   let clangClass = "OMPNontemporalClause";
   let flangClass = "Name";
   let isValueList = true; 
 }
 
-def OMP_ORDER_concurrent : ClauseVal<"default",2,0> { let isDefault = 1; }
+def OMP_ORDER_concurrent : ClauseVal<"concurrent",1,1> {}
+def OMP_ORDER_unknown : ClauseVal<"unknown",2,0> { let isDefault = 1; }
 def OMPC_Order : Clause<"order"> {
   let clangClass = "OMPOrderClause";
   let enumClauseValue = "OrderKind";
   let allowedClauseValues = [
+    OMP_ORDER_unknown,
     OMP_ORDER_concurrent
   ];
 }
 def OMPC_Init : Clause<"init"> {
   let clangClass = "OMPInitClause";
 }
 def OMPC_Use : Clause<"use"> {
   let clangClass = "OMPUseClause";

llvm/unittests/Frontend/OpenMPParsingTest.cpp

TEST(OpenMPParsingTest, isAllowedClauseForDirective) {
 
   EXPECT_FALSE(isAllowedClauseForDirective(OMPD_for, OMPC_order, 30));
   EXPECT_FALSE(isAllowedClauseForDirective(OMPD_for, OMPC_order, 45));
   EXPECT_TRUE(isAllowedClauseForDirective(OMPD_for, OMPC_order, 50));
   EXPECT_TRUE(isAllowedClauseForDirective(OMPD_for, OMPC_order, 51));
 }
 
 TEST(OpenMPParsingTest, getOrderKind) {
-  EXPECT_EQ(getOrderKind("foobar"), OMP_ORDER_concurrent);
-  EXPECT_EQ(getOrderKind("default"), OMP_ORDER_concurrent);
+  EXPECT_EQ(getOrderKind("foobar"), OMP_ORDER_unknown);
+  EXPECT_EQ(getOrderKind("unknown"), OMP_ORDER_unknown);
+  EXPECT_EQ(getOrderKind("concurrent"), OMP_ORDER_concurrent);
 }
 
 TEST(OpenMPParsingTest, getProcBindKind) {
   EXPECT_EQ(getProcBindKind("foobar"), OMP_PROC_BIND_unknown);
 
   EXPECT_EQ(getProcBindKind("master"), OMP_PROC_BIND_master);
   EXPECT_EQ(getProcBindKind("close"), OMP_PROC_BIND_close);
   EXPECT_EQ(getProcBindKind("spread"), OMP_PROC_BIND_spread);

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

enum ClauseType {
   procBindClause,
   reductionClause,
   nowaitClause,
   linearClause,
   scheduleClause,
   collapseClause,
   orderClause,
   orderedClause,
-  inclusiveClause,
   memoryOrderClause,
   hintClause,
   COUNT
 };
 
 //===----------------------------------------------------------------------===//
 // Parser for Clause List
 //===----------------------------------------------------------------------===//
static ParseResult parseClauses(OpAsmParser &parser, OperationState &result,
   // Compute the position of clauses in operand segments
   int currPos = 0;
   for (ClauseType clause : clauses) {
 
     // Skip the following clauses - they do not take any position in operand
     // segments
     if (clause == defaultClause || clause == procBindClause ||
         clause == nowaitClause || clause == collapseClause ||
-        clause == orderClause || clause == orderedClause ||
-        clause == inclusiveClause)
+        clause == orderClause || clause == orderedClause)
       continue;
 
     pos[clause] = currPos++;
 
     // For the following clauses, two positions are reserved in the operand
     // segments
     if (clause == allocateClause || clause == linearClause)
       currPos++;
   }
 
   SmallVector<int> clauseSegments(currPos);
 
   // Helper function to check if a clause is allowed/repeated or not
   auto checkAllowed = [&](ClauseType clause,
                           bool allowRepeat = false) -> ParseResult {
     if (!llvm::is_contained(clauses, clause))
       return parser.emitError(parser.getCurrentLocation())
-             << clauseKeyword << "is not a valid clause for the " << opName
+             << clauseKeyword << " is not a valid clause for the " << opName
              << " operation";
     if (done[clause] && !allowRepeat)
       return parser.emitError(parser.getCurrentLocation())
              << "at most one " << clauseKeyword << " clause can appear on the "
              << opName << " operation";
     done[clause] = true;
     return success();
   };
if (clauseKeyword == "if") {
       }
       result.addAttribute("ordered_val", attr);
     } else if (clauseKeyword == "order") {
       StringRef order;
       if (checkAllowed(orderClause) || parser.parseLParen() ||
           parser.parseKeyword(&order) || parser.parseRParen())
         return failure();
       auto attr = parser.getBuilder().getStringAttr(order);
-      result.addAttribute("order", attr);
-    } else if (clauseKeyword == "inclusive") {
-      if (checkAllowed(inclusiveClause))
-        return failure();
-      auto attr = UnitAttr::get(parser.getBuilder().getContext());
-      result.addAttribute("inclusive", attr);
+      result.addAttribute("order_val", attr);
     } else if (clauseKeyword == "memory_order") {
       StringRef memoryOrder;
       if (checkAllowed(memoryOrderClause) || parser.parseLParen() ||
           parser.parseKeyword(&memoryOrder) || parser.parseRParen())
         return failure();
       result.addAttribute("memory_order",
                           parser.getBuilder().getStringAttr(memoryOrder));
     } else if (clauseKeyword == "hint") {
if (parser.parseRegion(*body, regionArgs, regionArgTypes))
     return failure();
   return success();
 }
 
 /// Parses an OpenMP Workshare Loop operation
 ///
 /// wsloop ::= `omp.wsloop` loop-control clause-list
 /// loop-control ::= `(` ssa-id-list `)` `:` type `=`  loop-bounds
-/// loop-bounds := `(` ssa-id-list `)` to `(` ssa-id-list `)` steps
+/// loop-bounds := `(` ssa-id-list `)` to `(` ssa-id-list `)` inclusive? steps
 /// steps := `step` `(`ssa-id-list`)`
 /// clause-list ::= clause clause-list | empty
 /// clause ::= private | firstprivate | lastprivate | linear | schedule |
-//             collapse | nowait | ordered | order | inclusive | reduction
+//             collapse | nowait | ordered | order | reduction
 static ParseResult parseWsLoopOp(OpAsmParser &parser, OperationState &result) {
 
   // Parse an opening `(` followed by induction variables followed by `)`
   SmallVector<OpAsmParser::OperandType> ivs;
   if (parser.parseRegionArgumentList(ivs, /*requiredOperandCount=*/-1,
                                      OpAsmParser::Delimiter::Paren))
     return failure();
 
if (parser.parseEqual() ||
     return failure();
 
   SmallVector<OpAsmParser::OperandType> upper;
   if (parser.parseKeyword("to") ||
       parser.parseOperandList(upper, numIVs, OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(upper, loopVarType, result.operands))
     return failure();
 
+  if (succeeded(parser.parseOptionalKeyword("inclusive"))) {
+    auto attr = UnitAttr::get(parser.getBuilder().getContext());
+    result.addAttribute("inclusive", attr);
+  }
+
   // Parse step values.
   SmallVector<OpAsmParser::OperandType> steps;
   if (parser.parseKeyword("step") ||
       parser.parseOperandList(steps, numIVs, OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(steps, loopVarType, result.operands))
     return failure();
 
   SmallVector<ClauseType> clauses = {
       privateClause,   firstprivateClause, lastprivateClause, linearClause,
       reductionClause, collapseClause,     orderClause,       orderedClause,
       nowaitClause,    scheduleClause};
   SmallVector<int> segments{numIVs, numIVs, numIVs};
   if (failed(parseClauses(parser, result, clauses, segments)))
     return failure();
 
   result.addAttribute("operand_segment_sizes",
                       parser.getBuilder().getI32VectorAttr(segments));
 
   // Now parse the body.
   Region *body = result.addRegion();
   SmallVector<Type> ivTypes(numIVs, loopVarType);
   SmallVector<OpAsmParser::OperandType> blockArgs(ivs);
   if (parser.parseRegion(*body, blockArgs, ivTypes))
     return failure();
   return success();
 }
 
 static void printWsLoopOp(OpAsmPrinter &p, WsLoopOp op) {
   auto args = op.getRegion().front().getArguments();
   p << " (" << args << ") : " << args[0].getType() << " = (" << op.lowerBound()
-    << ") to (" << op.upperBound() << ") step (" << op.step() << ") ";
+    << ") to (" << op.upperBound() << ") ";
+  if (op.inclusive()) {
+    p << "inclusive ";
+  }
+  p << "step (" << op.step() << ") ";
 
   printDataVars(p, op.private_vars(), "private");
   printDataVars(p, op.firstprivate_vars(), "firstprivate");
   printDataVars(p, op.lastprivate_vars(), "lastprivate");
 
   if (op.linear_vars().size()) {
     p << "linear";
     printLinearClause(p, op.linear_vars(), op.linear_step_vars());
if (auto collapse = op.collapse_val())
     p << "collapse(" << collapse << ") ";
 
   if (op.nowait())
     p << "nowait ";
 
   if (auto ordered = op.ordered_val())
     p << "ordered(" << ordered << ") ";
 
+  if (auto order = op.order_val())
+    p << "order(" << order << ") ";
+
   if (!op.reduction_vars().empty()) {
     p << "reduction(";
     printReductionVarList(p, op.reductions(), op.reduction_vars());
   }
 
-  if (op.inclusive()) {
-    p << "inclusive ";
-  }
-
   p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // ReductionOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseAtomicReductionRegion(OpAsmParser &parser,

mlir/test/Dialect/OpenMP/invalid.mlir

func @copyin_once(%n : memref<i32>) {
   // expected-error@+1 {{at most one copyin clause can appear on the omp.parallel operation}}
   omp.parallel copyin(%n : memref<i32>) copyin(%n : memref<i32>) {
   }
 
   return
 }
 
 // -----
- 
+func @lastprivate_not_allowed(%n : memref<i32>) {
+  // expected-error@+1 {{lastprivate is not a valid clause for the omp.parallel operation}}
+  omp.parallel lastprivate(%n : memref<i32>) {}
+  return
+}
+
+// -----
+
+func @nowait_not_allowed(%n : memref<i32>) {
+  // expected-error@+1 {{nowait is not a valid clause for the omp.parallel operation}}
+  omp.parallel nowait {}
+  return
+}
+
+// -----
+
+func @linear_not_allowed(%data_var : memref<i32>, %linear_var : i32) {
+  // expected-error@+1 {{linear is not a valid clause for the omp.parallel operation}}
+  omp.parallel linear(%data_var = %linear_var : memref<i32>)  {}
+  return
+}
+
+// -----
+
+func @schedule_not_allowed() {
+  // expected-error@+1 {{schedule is not a valid clause for the omp.parallel operation}}
+  omp.parallel schedule(static) {}
+  return
+}
+
+// -----
+
+func @collapse_not_allowed() {
+  // expected-error@+1 {{collapse is not a valid clause for the omp.parallel operation}}
+  omp.parallel collapse(3) {}
+  return
+}
+
+// -----
+
+func @order_not_allowed() {
+  // expected-error@+1 {{order is not a valid clause for the omp.parallel operation}}
+  omp.parallel order(concurrent) {}
+  return
+}
+
+// -----
+
+func @ordered_not_allowed() {
+  // expected-error@+1 {{ordered is not a valid clause for the omp.parallel operation}}
+  omp.parallel ordered(2) {}
+}
+
+// -----
+
 func @default_once() {
   // expected-error@+1 {{at most one default clause can appear on the omp.parallel operation}}
   omp.parallel default(private) default(firstprivate) {
   }
 
   return
 }
 
 // -----
 
 func @proc_bind_once() {
   // expected-error@+1 {{at most one proc_bind clause can appear on the omp.parallel operation}}
   omp.parallel proc_bind(close) proc_bind(spread) {
   }
 
   return
 }
 
 // -----
 
+func @inclusive_not_a_clause(%lb : index, %ub : index, %step : index) {
+  // expected-error @below {{inclusive is not a valid clause}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) nowait inclusive {
+    omp.yield
+  }
+}
+
+// -----
+
+func @order_value(%lb : index, %ub : index, %step : index) {
+  // expected-error @below {{attribute 'order_val' failed to satisfy constraint: OrderKind Clause}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) order(default) {
+    omp.yield
+  }
+}
+
+// -----
+
+func @shared_not_allowed(%lb : index, %ub : index, %step : index, %var : memref<i32>) {
+  // expected-error @below {{shared is not a valid clause for the omp.wsloop operation}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) shared(%var) {
+    omp.yield
+  }
+}
+
+// -----
+
+func @copyin(%lb : index, %ub : index, %step : index, %var : memref<i32>) {
+  // expected-error @below {{copyin is not a valid clause for the omp.wsloop operation}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) copyin(%var) {
+    omp.yield
+  }
+}
+
+// -----
+
+func @if_not_allowed(%lb : index, %ub : index, %step : index, %bool_var : i1) {
+  // expected-error @below {{if is not a valid clause for the omp.wsloop operation}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) if(%bool_var: i1) {
+    omp.yield
+  }
+}
+
+// -----
+
+func @num_threads_not_allowed(%lb : index, %ub : index, %step : index, %int_var : i32) {
+  // expected-error @below {{num_threads is not a valid clause for the omp.wsloop operation}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) num_threads(%int_var: i32) {
+    omp.yield
+  }
+}
+
+// -----
+
+func @default_not_allowed(%lb : index, %ub : index, %step : index) {
+  // expected-error @below {{default is not a valid clause for the omp.wsloop operation}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) default(private) {
+    omp.yield
+  }
+}
+
+// -----
+
+func @proc_bind_not_allowed(%lb : index, %ub : index, %step : index) {
+  // expected-error @below {{proc_bind is not a valid clause for the omp.wsloop operation}}
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) proc_bind(close) {
+    omp.yield
+  }
+}
+
+// -----
+
 // expected-error @below {{op expects initializer region with one argument of the reduction type}}
 omp.reduction.declare @add_f32 : f64
 init {
 ^bb0(%arg: f32):
   %0 = arith.constant 0.0 : f32
   omp.yield (%0 : f32)
 }
 combiner {

mlir/test/Dialect/OpenMP/ops.mlir

  }
 
  // CHECK omp.parallel if(%{{.*}}) num_threads(%{{.*}} : si32) private(%{{.*}} : memref<i32>) proc_bind(close)
  omp.parallel num_threads(%num_threads : si32) if(%if_cond: i1)
               private(%data_var : memref<i32>) proc_bind(close) {
    omp.terminator
  }
 
+  // CHECK: omp.parallel default(private)
+  omp.parallel default(private) {
+    omp.terminator
+  }
+
+  // CHECK: omp.parallel default(firstprivate)
+  omp.parallel default(firstprivate) {
+    omp.terminator
+  }
+
+  // CHECK: omp.parallel default(shared)
+  omp.parallel default(shared) {
+    omp.terminator
+  }
+
+  // CHECK: omp.parallel default(none)
+  omp.parallel default(none) {
+    omp.terminator
+  }
+
   return
 }
 
 // CHECK-LABEL: omp_wsloop
 func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memref<i32>, %linear_var : i32, %chunk_var : i32) -> () {
 
   // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) private(%{{.*}} : memref<i32>, %{{.*}} : memref<i32>) collapse(2) ordered(1)
   "omp.wsloop" (%lb, %ub, %step, %data_var, %data_var) ({
     ^bb0(%iv: index):
omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) ordered(2) private(%data_var : memref<i32>)
     omp.yield
   }
 
   // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) private({{.*}} : memref<i32>)
   omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) private(%data_var : memref<i32>) {
     omp.yield
   }
 
+  // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) inclusive step (%{{.*}})
+  omp.wsloop (%iv) : index = (%lb) to (%ub) inclusive step (%step) {
+    omp.yield
+  }
+
+  // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) nowait
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) nowait {
+    omp.yield
+  }
+
+  // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) nowait order(concurrent)
+  omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) order(concurrent) nowait {
+    omp.yield
+  }
+
   return
 }
 
 // CHECK-LABEL: omp_wsloop_pretty_multi_block
 func @omp_wsloop_pretty_multi_block(%lb : index, %ub : index, %step : index, %data1 : memref<?xi32>, %data2 : memref<?xi32>) -> () {
 
   // CHECK: omp.wsloop (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) {