[mlir][scf] Add insideMutuallyExclusiveBranches helper

[springerm]

Summary

This helper function checks if two given ops are in mutually exclusive branches of the same scf::IfOp.

Depends On D111928

[springerm]

mlir/include/mlir/Dialect/SCF/SCF.h

54

I think RegionBranchOpInterface does not have the capability to support this atm. I can query the "successor" region of a region (or an op in general). But, in general, after executing a region, another region of the same op may execute. What we are asking here is "execute one region but not the other one".

[ftynse]

LGTM if naming is fixed.

mlir/include/mlir/Dialect/SCF/SCF.h

54

This sounds very specific to "conditional" ops so I suggest to keep it on individual ops for now.

55

s/Mutable/Mutually

Also in the commit description.

mlir/include/mlir/Dialect/SCF/SCF.h

 /// Returns the loop parent of an induction variable. If the provided value is
 /// not an induction variable, then return nullptr.
 ForOp getForInductionVarOwner(Value val);
 
 /// Returns the parallel loop parent of an induction variable. If the provided
 /// value is not an induction variable, then return nullptr.
 ParallelOp getParallelForInductionVarOwner(Value val);
 
+/// Return true if ops a and b (or their ancestors) are in mutually exclusive
+/// regions/blocks of an IfOp.
+// TODO: Consider moving this functionality to RegionBranchOpInterface.
+bool insideMutableExclusiveBranches(Operation *a, Operation *b);
+
 /// An owning vector of values, handy to return from functions.
 using ValueVector = std::vector<Value>;
 using LoopVector = std::vector<scf::ForOp>;
 struct LoopNest {
   ResultRange getResults() { return loops.front().getResults(); }
   LoopVector loops;
 };
 

mlir/lib/Dialect/SCF/SCF.cpp

void ForOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<ForOpIterArgsFolder, SimplifyTrivialLoops,
               LastTensorLoadCanonicalization, ForOpTensorCastFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
+bool mlir::scf::insideMutableExclusiveBranches(Operation *a, Operation *b) {
+  assert(a && "expected non-empty operation");
+  assert(b && "expected non-empty operation");
+
+  IfOp ifOp = a->getParentOfType<IfOp>();
+  while (ifOp) {
+    // Check if b is inside ifOp. (We already know that a is.)
+    if (ifOp->isProperAncestor(b))
+      // b is contained in ifOp. a and b are in mutually exclusive branches if
+      // they are in different blocks of ifOp.
+      return static_cast<bool>(ifOp.thenBlock()->findAncestorOpInBlock(*a)) !=
+             static_cast<bool>(ifOp.thenBlock()->findAncestorOpInBlock(*b));
+    // Check next enclosing IfOp.
+    ifOp = ifOp->getParentOfType<IfOp>();
+  }
+
+  // Could not find a common IfOp among a's and b's ancestors.
+  return false;
+}
+
 void IfOp::build(OpBuilder &builder, OperationState &result, Value cond,
                  bool withElseRegion) {
   build(builder, result, /*resultTypes=*/llvm::None, cond, withElseRegion);
 }
 
 void IfOp::build(OpBuilder &builder, OperationState &result,
                  TypeRange resultTypes, Value cond, bool withElseRegion) {
   auto addTerminator = [&](OpBuilder &nested, Location loc) {