[LLHD][TCM] Ignore processes with CFG loops within a TR

lib/Dialect/LLHD/Transforms/TemporalCodeMotionPass.cpp

@@ -123,7 +123,46 @@ void TemporalCodeMotionPass::runOnOperation() {
     (void)runOnProcess(proc); // Ignore processes that could not be lowered
 }
 
+static LogicalResult checkForCFGLoop(llhd::ProcessOp procOp) {
+  SmallVector<Block *> toCheck(
+      llvm::map_range(procOp.getOps<llhd::WaitOp>(), [](llhd::WaitOp waitOp) {
+        return waitOp.getSuccessor();
+      }));
+  toCheck.push_back(&procOp.getBody().front());
+
+  SmallVector<Block *> worklist;
+  DenseSet<Block *> visited;
+  for (auto *block : toCheck) {
+    worklist.clear();
+    visited.clear();
+    worklist.push_back(block);
+
+    while (!worklist.empty()) {
+      Block *curr = worklist.pop_back_val();
+      if (isa<llhd::WaitOp>(curr->getTerminator()))
+        continue;
+
+      visited.insert(curr);
+
+      for (auto *succ : curr->getSuccessors()) {
+        if (visited.contains(succ))
+          return failure();
+
+        worklist.push_back(succ);
+      }
+    }
+  }
+
+  return success();
+}
+
 LogicalResult TemporalCodeMotionPass::runOnProcess(llhd::ProcessOp procOp) {
+  // Make sure there are no CFG loops that don't contain a block with a wait
+  // terminator in the cycle because that's currently not supported by the
+  // temporal region analysis and this pass.
+  if (failed(checkForCFGLoop(procOp)))
+    return failure();
+
   llhd::TemporalRegionAnalysis trAnalysis =
       llhd::TemporalRegionAnalysis(procOp);
   unsigned numTRs = trAnalysis.getNumTemporalRegions();

lib/Dialect/LLHD/Transforms/TemporalRegions.cpp

@@ -91,6 +91,11 @@ void llhd::TemporalRegionAnalysis::recalculate(Operation *operation) {
       // If at least one predecessor has a wait terminator or at least one
       // predecessor has an unknown temporal region or not all predecessors have
       // the same TR, create a new TR
+      // FIXME: `!allPredecessorTRsKnown` is a problem when there are CFG loops
+      // in the process. If there is no wait op along any of the CFG edges of
+      // such a loop we don't want to assign a new temporal region. However, we
+      // also cannot just assume here that we can just assign the same TR, so
+      // this might require a bigger change to the algorithm.
     } else if (!allPredecessorTRsKnown(block, workDone) ||
                anyPredecessorHasWait(block) ||
                !(std::adjacent_find(block->pred_begin(), block->pred_end(),

test/Dialect/LLHD/Transforms/temporal-code-motion.mlir

@@ -205,3 +205,18 @@ hw.module @more_than_one_TR_wait_terminator(in %cond: i1) {
     cf.br ^bb1
   }
 }
+
+// CHECK-LABEL: @unsupportedLoop
+hw.module @unsupportedLoop() {
+  // CHECK-NEXT: llhd.process {
+  // CHECK-NEXT:   cf.br ^bb
+  // CHECK-NEXT: ^bb
+  // CHECK-NEXT:   llhd.wait ^bb
+  // CHECK-NEXT: }
+  llhd.process {
+    cf.br ^bb1
+  ^bb1:
+    llhd.wait ^bb1
+  }
+  hw.output
+}