Correct /simplify

The gang/worker/vector check was insufficient based on review, so this
fixes it.  It also moves the check for the ParallelismFlag and
gang/worker/vector check to LoopOp so that it can be used elsewhere. We
also can simplify the Clang version here for the same reasons.

Author: erichkeane

clang/lib/CIR/CodeGen/CIRGenStmtOpenACCLoop.cpp

@@ -27,56 +27,29 @@ void CIRGenFunction::updateLoopOpParallelism(mlir::acc::LoopOp &op,
                                              OpenACCDirectiveKind dk) {
   // Check that at least one of auto, independent, or seq is present
   // for the device-independent default clauses.
-  auto hasDeviceNone = [](mlir::acc::DeviceTypeAttr attr) -> bool {
-    return attr.getValue() == mlir::acc::DeviceType::None;
-  };
-  bool hasDefaultSeq =
-      op.getSeqAttr()
-          ? llvm::any_of(
-                op.getSeqAttr().getAsRange<mlir::acc::DeviceTypeAttr>(),
-                hasDeviceNone)
-          : false;
-  bool hasDefaultIndependent =
-      op.getIndependentAttr()
-          ? llvm::any_of(
-                op.getIndependentAttr().getAsRange<mlir::acc::DeviceTypeAttr>(),
-                hasDeviceNone)
-          : false;
-  bool hasDefaultAuto =
-      op.getAuto_Attr()
-          ? llvm::any_of(
-                op.getAuto_Attr().getAsRange<mlir::acc::DeviceTypeAttr>(),
-                hasDeviceNone)
-          : false;
-
-  if (hasDefaultSeq || hasDefaultIndependent || hasDefaultAuto)
+  if (op.hasParallelismFlag(mlir::acc::DeviceType::None))
     return;
 
-  // Orphan or parallel results in 'independent'.
-  if (isOrphan || dk == OpenACCDirectiveKind::Parallel ||
-      dk == OpenACCDirectiveKind::ParallelLoop) {
+  switch (dk) {
+  default:
+    llvm_unreachable("Invalid parent directive kind");
+  case OpenACCDirectiveKind::Invalid:
+  case OpenACCDirectiveKind::Parallel:
+  case OpenACCDirectiveKind::ParallelLoop:
     op.addIndependent(builder.getContext(), {});
     return;
-  }
-
-  // Kernels always results in 'auto'.
-  if (dk == OpenACCDirectiveKind::Kernels ||
-      dk == OpenACCDirectiveKind::KernelsLoop) {
+  case OpenACCDirectiveKind::Kernels:
+  case OpenACCDirectiveKind::KernelsLoop:
     op.addAuto(builder.getContext(), {});
     return;
-  }
-
-  // Serial should use 'seq' unless there is a gang, worker, or vector clause,
-  // in which case, it should use 'auto'.
-  assert(dk == OpenACCDirectiveKind::Serial ||
-         dk == OpenACCDirectiveKind::SerialLoop);
-
-  if (op.getWorkerAttr() || op.getVectorAttr() || op.getGangAttr()) {
-    op.addAuto(builder.getContext(), {});
+  case OpenACCDirectiveKind::Serial:
+  case OpenACCDirectiveKind::SerialLoop:
+    if (op.hasDefaultGangWorkerVector())
+      op.addAuto(builder.getContext(), {});
+    else
+      op.addSeq(builder.getContext(), {});
     return;
-  }
-
-  op.addSeq(builder.getContext(), {});
+  };
 }
 
 mlir::LogicalResult

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

@@ -2246,6 +2246,14 @@ def OpenACC_LoopOp : OpenACC_Op<"loop",
     // device_types. This is for the case where there is no expression specified
     // in a 'gang'.
     void addEmptyGang(MLIRContext *, llvm::ArrayRef<DeviceType>);
+
+    // Return whether this LoopOp has an auto, seq, or independent for the
+    // specified device-type.
+    bool hasParallelismFlag(DeviceType);
+
+    // Return whether this LoopOp has a gang, worker, or vector applying to the
+    // 'default'/None device-type.
+    bool hasDefaultGangWorkerVector();
   }];
 
   let hasCustomAssemblyFormat = 1;

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

@@ -2839,6 +2839,30 @@ void acc::LoopOp::addEmptyGang(
                                                  effectiveDeviceTypes));
 }
 
+bool acc::LoopOp::hasParallelismFlag(DeviceType dt) {
+  auto hasDevice = [=](DeviceTypeAttr attr) -> bool {
+    return attr.getValue() == dt;
+  };
+  auto testFromArr = [=](ArrayAttr arr) -> bool {
+    return llvm::any_of(arr.getAsRange<DeviceTypeAttr>(), hasDevice);
+  };
+
+  if (ArrayAttr arr = getSeqAttr(); arr && testFromArr(arr))
+    return true;
+  if (ArrayAttr arr = getIndependentAttr(); arr && testFromArr(arr))
+    return true;
+  if (ArrayAttr arr = getAuto_Attr(); arr && testFromArr(arr))
+    return true;
+
+  return false;
+}
+
+bool acc::LoopOp::hasDefaultGangWorkerVector() {
+  return hasVector() || getVectorValue() || hasWorker() || getWorkerValue() ||
+         hasGang() || getGangValue(GangArgType::Num) ||
+         getGangValue(GangArgType::Dim) || getGangValue(GangArgType::Static);
+}
+
 void acc::LoopOp::addGangOperands(
     MLIRContext *context, llvm::ArrayRef<DeviceType> effectiveDeviceTypes,
     llvm::ArrayRef<GangArgType> argTypes, mlir::ValueRange values) {