Revert "Remove cancel and cancellation point verifiers entirely"

This reverts commit da8639e.

Author: tblah

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

@@ -1655,6 +1655,8 @@ def CancelOp : OpenMP_Op<"cancel", clauses = [
   let builders = [
     OpBuilder<(ins CArg<"const CancelOperands &">:$clauses)>
   ];
+
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
@@ -1673,6 +1675,8 @@ def CancellationPointOp : OpenMP_Op<"cancellation_point", clauses = [
   let builders = [
     OpBuilder<(ins CArg<"const CancellationPointOperands &">:$clauses)>
   ];
+
+  let hasVerifier = 1;
 }
 
 def ScanOp : OpenMP_Op<"scan", [

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

@@ -3101,6 +3101,46 @@ void CancelOp::build(OpBuilder &builder, OperationState &state,
   CancelOp::build(builder, state, clauses.cancelDirective, clauses.ifExpr);
 }
 
+LogicalResult CancelOp::verify() {
+  ClauseCancellationConstructType cct = getCancelDirective();
+  Operation *thisOp = (*this).getOperation();
+
+  if ((cct == ClauseCancellationConstructType::Parallel) &&
+      !thisOp->getParentOfType<ParallelOp>()) {
+    return emitOpError() << "cancel parallel must appear "
+                         << "inside a parallel region";
+  }
+  if (cct == ClauseCancellationConstructType::Loop) {
+    auto wsloopOp = thisOp->getParentOfType<WsloopOp>();
+
+    if (!wsloopOp) {
+      return emitOpError()
+             << "cancel loop must appear inside a worksharing-loop region";
+    }
+    if (wsloopOp.getNowaitAttr()) {
+      return emitError() << "A worksharing construct that is canceled "
+                         << "must not have a nowait clause";
+    }
+    if (wsloopOp.getOrderedAttr()) {
+      return emitError() << "A worksharing construct that is canceled "
+                         << "must not have an ordered clause";
+    }
+
+  } else if (cct == ClauseCancellationConstructType::Sections) {
+    auto sectionsOp = thisOp->getParentOfType<SectionsOp>();
+    if (!sectionsOp) {
+      return emitOpError() << "cancel sections must appear "
+                           << "inside a sections region";
+    }
+    if (sectionsOp.getNowait()) {
+      return emitError() << "A sections construct that is canceled "
+                         << "must not have a nowait clause";
+    }
+  }
+  // TODO : Add more when we support taskgroup.
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // CancellationPointOp
 //===----------------------------------------------------------------------===//
@@ -3110,6 +3150,29 @@ void CancellationPointOp::build(OpBuilder &builder, OperationState &state,
   CancellationPointOp::build(builder, state, clauses.cancelDirective);
 }
 
+LogicalResult CancellationPointOp::verify() {
+  ClauseCancellationConstructType cct = getCancelDirective();
+  Operation *thisOp = (*this).getOperation();
+
+  if ((cct == ClauseCancellationConstructType::Parallel) &&
+      !thisOp->getParentOfType<ParallelOp>()) {
+    return emitOpError() << "cancellation point parallel must appear "
+                         << "inside a parallel region";
+  }
+  if ((cct == ClauseCancellationConstructType::Loop) &&
+      !thisOp->getParentOfType<WsloopOp>()) {
+    return emitOpError() << "cancellation point loop must appear "
+                         << "inside a worksharing-loop region";
+  }
+  if ((cct == ClauseCancellationConstructType::Sections) &&
+      !thisOp->getParentOfType<SectionsOp>()) {
+    return emitOpError() << "cancellation point sections must appear "
+                         << "inside a sections region";
+  }
+  // TODO : Add more when we support taskgroup.
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // MapBoundsOp
 //===----------------------------------------------------------------------===//

mlir/test/Dialect/OpenMP/invalid.mlir

@@ -1710,6 +1710,121 @@ func.func @omp_task(%mem: memref<1xf32>) {
 
 // -----
 
+func.func @omp_cancel() {
+  omp.sections {
+    // expected-error @below {{cancel parallel must appear inside a parallel region}}
+    omp.cancel cancellation_construct_type(parallel)
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancel1() {
+  omp.parallel {
+    // expected-error @below {{cancel sections must appear inside a sections region}}
+    omp.cancel cancellation_construct_type(sections)
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancel2() {
+  omp.sections {
+    // expected-error @below {{cancel loop must appear inside a worksharing-loop region}}
+    omp.cancel cancellation_construct_type(loop)
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancel3(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () {
+  omp.wsloop nowait {
+    omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
+      // expected-error @below {{A worksharing construct that is canceled must not have a nowait clause}}
+      omp.cancel cancellation_construct_type(loop)
+      // CHECK: omp.yield
+      omp.yield
+    }
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancel4(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () {
+  omp.wsloop ordered(1) {
+    omp.loop_nest (%0) : i32 = (%arg1) to (%arg2) step (%arg3) {
+      // expected-error @below {{A worksharing construct that is canceled must not have an ordered clause}}
+      omp.cancel cancellation_construct_type(loop)
+      // CHECK: omp.yield
+      omp.yield
+    }
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancel5() -> () {
+  omp.sections nowait {
+    omp.section {
+      // expected-error @below {{A sections construct that is canceled must not have a nowait clause}}
+      omp.cancel cancellation_construct_type(sections)
+      omp.terminator
+    }
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancellationpoint() {
+  omp.sections {
+    // expected-error @below {{cancellation point parallel must appear inside a parallel region}}
+    omp.cancellation_point cancellation_construct_type(parallel)
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancellationpoint1() {
+  omp.parallel {
+    // expected-error @below {{cancellation point sections must appear inside a sections region}}
+    omp.cancellation_point cancellation_construct_type(sections)
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
+func.func @omp_cancellationpoint2() {
+  omp.sections {
+    // expected-error @below {{cancellation point loop must appear inside a worksharing-loop region}}
+    omp.cancellation_point cancellation_construct_type(loop)
+    // CHECK: omp.terminator
+    omp.terminator
+  }
+  return
+}
+
+// -----
+
 omp.declare_reduction @add_f32 : f32
 init {
  ^bb0(%arg: f32):