[mlir] Revamp `RegionBranchOpInterface` successor mechanism

[zero9178]

Summary

The RegionBranchOpInterface had a few fundamental issues caused by the API design of getSuccessorRegions.

It always required passing values for the operands parameter. This is problematic as the operands parameter actually changes meaning depending on which predecessor index is referring to. If coming from a region, you'd have to find a RegionBranchTerminatorOpInterface in that region, get its operand count, and then create a SmallVector of that size.
This is not only inconvenient, but also error-prone, which has lead to a bug in the implementation of a previously existing getSuccessorRegions overload.

Additionally, this made the method dual-use, trying to serve two different use-cases: 1) Trying to determine possible control flow edges between regions and 2) Trying to determine the region being branched to based on constant operands.

This patch fixes these issues by changing the interface methods and adding new ones:

• The operands argument of getSuccessorRegions has been removed. The method is now only responsible for returning possible control flow edges between regions.
• An optional getEntrySuccessorRegions method has been added. This is used to determine which regions are branched to from the parent op based on constant operands of the parent op. By default, it calls getSuccessorRegions. This is analogous to getSuccessorForOperands from BranchOpInterface.
• Add getSuccessorRegions to RegionBranchTerminatorOpInterface. This is used to get the possible successors of the terminator based on constant operands. By default, it calls the containing RegionBranchOpInterfaces getSuccessorRegions method.
• getSuccessorEntryOperands was renamed to getEntrySuccessorOperands for consistency.

[mehdi_amini]

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

256

Technical nit: a region terminator never directly "branch to" another region, the parent operation is driving the control flow.

267

Why do we pass this array instead of letting the implementation match as needed?

[zero9178]

Address review comments

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

256

I've changed from to after in the wording, with the intention that it does not imply the branching is done by the terminator.

267

The reason is very similar to why fold does it: This makes thes interface more useful as you can pass in constant values and "see what it does".
This is used by various DataFlowAnalysis passes for example. SCCP will pass in constants if it has so far optimistcally proven that a given value has only been a constant so far.
Combined with the region branch op interface, it enables more dead code analysis.

If you'd want to do this using matchPattern, a caller would have to first materialize n constant ops, change the operands of the op to the constant ops, call getSuccessorRegions, and then undo the transformation (as it was performed optimistically on purpose and could still end up being incorrect).

[zero9178]

Rebase

[mehdi_amini]

I'll let @Mogball maybe review with more details, but thanks for the fixes!

[Mogball]

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

180–181

Perfect. This API was definitely not ideal. The new method makes things abundantly clear.

271

style: prefer using the original namespace if explicitly spelled out

294

[awarzynski]

Sadly this breaks my local build as well as one of the bots:

• https://lab.llvm.org/buildbot/#/builders/61/builds/47367

Most likely missing CMake dependency, but it's a bit too large for me to identify it myself. I will revert it, but please let me know if you are unable to reproduce locally and need any help with this.

[zero9178]

In D157506#4575938, @awarzynski wrote:

Sadly this breaks my local build as well as one of the bots:

• https://lab.llvm.org/buildbot/#/builders/61/builds/47367

Most likely missing CMake dependency, but it's a bit too large for me to identify it myself. I will revert it, but please let me know if you are unable to reproduce locally and need any help with this.

Already fixed in https://github.com/llvm/llvm-project/commit/345acac85d382998e5721073cc077e47e799311f. Sorry for the inconvenience

[awarzynski]

In D157506#4575943, @zero9178 wrote:

In D157506#4575938, @awarzynski wrote:

Sadly this breaks my local build as well as one of the bots:

• https://lab.llvm.org/buildbot/#/builders/61/builds/47367

Most likely missing CMake dependency, but it's a bit too large for me to identify it myself. I will revert it, but please let me know if you are unable to reproduce locally and need any help with this.

Already fixed in https://github.com/llvm/llvm-project/commit/345acac85d382998e5721073cc077e47e799311f. Sorry for the inconvenience

No bother at all, thanks for the quick fix!

flang/include/flang/Optimizer/Dialect/FIROps.td

let extraClassDeclaration = [{
     mlir::BlockArgument iterArgToBlockArg(mlir::Value iterArg);
     void resultToSourceOps(llvm::SmallVectorImpl<mlir::Value> &results,
                            unsigned resultNum);
     mlir::Value blockArgToSourceOp(unsigned blockArgNum);
   }];
 }
 
 def fir_IfOp : region_Op<"if", [DeclareOpInterfaceMethods<RegionBranchOpInterface, [
-    "getRegionInvocationBounds"]>, RecursiveMemoryEffects,
+    "getRegionInvocationBounds", "getEntrySuccessorRegions"]>, RecursiveMemoryEffects,
     NoRegionArguments]> {
   let summary = "if-then-else conditional operation";
   let description = [{
     Used to conditionally execute operations. This operation is the FIR
     dialect's version of `loop.if`.
 
     ```mlir
       %56 = ... : i1

flang/lib/Optimizer/Dialect/FIROps.cpp

void fir::IfOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
   mlir::Region *elseRegion = result.addRegion();
   if (withElseRegion) {
     elseRegion->push_back(new mlir::Block());
     if (resultTypes.empty())
       IfOp::ensureTerminator(*elseRegion, builder, result.location);
   }
 }
 
-// These 2 functions copied from scf.if implementation.
+// These 3 functions copied from scf.if implementation.
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
-/// during the flow of control. `operands` is a set of optional attributes that
-/// correspond to a constant value for each operand, or null if that operand is
-/// not a constant.
+/// during the flow of control.
 void fir::IfOp::getSuccessorRegions(
-    std::optional<unsigned> index, llvm::ArrayRef<mlir::Attribute> operands,
+    std::optional<unsigned> index,
     llvm::SmallVectorImpl<mlir::RegionSuccessor> &regions) {
   // The `then` and the `else` region branch back to the parent operation.
   if (index) {
     regions.push_back(mlir::RegionSuccessor(getResults()));
     return;
   }
 
   // Don't consider the else region if it is empty.
+  regions.push_back(mlir::RegionSuccessor(&getThenRegion()));
+
+  // Don't consider the else region if it is empty.
   mlir::Region *elseRegion = &this->getElseRegion();
   if (elseRegion->empty())
-    elseRegion = nullptr;
-
-  // Otherwise, the successor is dependent on the condition.
-  bool condition;
-  if (auto condAttr = operands.front().dyn_cast_or_null<mlir::IntegerAttr>()) {
-    condition = condAttr.getValue().isOne();
-  } else {
-    // If the condition isn't constant, both regions may be executed.
-    regions.push_back(mlir::RegionSuccessor(&getThenRegion()));
-    // If the else region does not exist, it is not a viable successor.
-    if (elseRegion)
-      regions.push_back(mlir::RegionSuccessor(elseRegion));
-    return;
-  }
+    regions.push_back(mlir::RegionSuccessor());
+  else
 
-  // Add the successor regions using the condition.
-  regions.push_back(
-      mlir::RegionSuccessor(condition ? &getThenRegion() : elseRegion));
+void fir::IfOp::getEntrySuccessorRegions(
+    llvm::ArrayRef<mlir::Attribute> operands,
+    llvm::SmallVectorImpl<mlir::RegionSuccessor> &regions) {
+  FoldAdaptor adaptor(operands);
+  auto boolAttr =
+      mlir::dyn_cast_or_null<mlir::BoolAttr>(adaptor.getCondition());
+  if (!boolAttr || boolAttr.getValue())
+    regions.emplace_back(&getThenRegion());
+
+  // If the else region is empty, execution continues after the parent op.
+  if (!boolAttr || !boolAttr.getValue()) {
+    if (!getElseRegion().empty())
+      regions.emplace_back(&getElseRegion());
+    else
+      regions.emplace_back(getResults());
+  }
 }
 
 void fir::IfOp::getRegionInvocationBounds(
     llvm::ArrayRef<mlir::Attribute> operands,
     llvm::SmallVectorImpl<mlir::InvocationBounds> &invocationBounds) {
   if (auto cond = operands[0].dyn_cast_or_null<mlir::BoolAttr>()) {
     // If the condition is known, then one region is known to be executed once
     // and the other zero times.

mlir/include/mlir/Analysis/DataFlow/DeadCodeAnalysis.h

 #include <optional>
 
 namespace mlir {
 
 class CallOpInterface;
 class CallableOpInterface;
 class BranchOpInterface;
 class RegionBranchOpInterface;
+class RegionBranchTerminatorOpInterface;
 
 namespace dataflow {
 
 //===----------------------------------------------------------------------===//
 // Executable
 //===----------------------------------------------------------------------===//
 
 /// This is a simple analysis state that represents whether the associated
private:
   /// Visit the given region branch operation, which defines regions, and
   /// compute any necessary lattice state. This also resolves the lattice state
   /// of both the operation results and any nested regions.
   void visitRegionBranchOperation(RegionBranchOpInterface branch);
 
   /// Visit the given terminator operation that exits a region under an
   /// operation with control-flow semantics. These are terminators with no CFG
   /// successors.
-  void visitRegionTerminator(Operation *op, RegionBranchOpInterface branch);
+  void visitRegionTerminator(RegionBranchTerminatorOpInterface op,
+                             RegionBranchOpInterface branch);
 
   /// Visit the given terminator operation that exits a callable region. These
   /// are terminators with no CFG successors.
   void visitCallableTerminator(Operation *op, CallableOpInterface callable);
 
   /// Mark the edge between `from` and `to` as executable.
   void markEdgeLive(Block *from, Block *to);
 

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

 }
 
 def AffineForOp : Affine_Op<"for",
     [AutomaticAllocationScope, ImplicitAffineTerminator, ConditionallySpeculatable,
      RecursiveMemoryEffects, DeclareOpInterfaceMethods<LoopLikeOpInterface,
      ["getSingleInductionVar", "getSingleLowerBound", "getSingleStep",
       "getSingleUpperBound"]>,
      DeclareOpInterfaceMethods<RegionBranchOpInterface,
-     ["getSuccessorEntryOperands"]>]> {
+     ["getEntrySuccessorOperands"]>]> {
   let summary = "for operation";
   let description = [{
     Syntax:
 
     ```
     operation   ::= `affine.for` ssa-id `=` lower-bound `to` upper-bound
                     (`step` integer-literal)? `{` op* `}`
 

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

 
 // Base class for the operation in this dialect
 class Async_Op<string mnemonic, list<Trait> traits = []> :
     Op<AsyncDialect, mnemonic, traits>;
 
 def Async_ExecuteOp :
   Async_Op<"execute", [SingleBlockImplicitTerminator<"YieldOp">,
                        DeclareOpInterfaceMethods<RegionBranchOpInterface,
-                                                 ["getSuccessorEntryOperands",
+                                                 ["getEntrySuccessorOperands",
                                                   "areTypesCompatible"]>,
                        AttrSizedOperandSegments,
                        AutomaticAllocationScope]> {
   let summary = "Asynchronous execute operation";
   let description = [{
     The `body` region attached to the `async.execute` operation semantically
     can be executed concurrently with the successor operation. In the followup
     example "compute0" can be executed concurrently with "compute1".
def Async_ReturnOp : Async_Op<"return",
   let builders = [OpBuilder<(ins), [{build($_builder, $_state, std::nullopt);}]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
   let hasVerifier = 1;
 }
 
 def Async_YieldOp :
     Async_Op<"yield", [
-      HasParent<"ExecuteOp">, Pure, Terminator,
-      DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>]> {
+      HasParent<"ExecuteOp">, Pure, Terminator, ReturnLike]> {
   let summary = "terminator for Async execute operation";
   let description = [{
     The `async.yield` is a special terminator operation for the block inside
     `async.execute` operation.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
   let assemblyFormat = "($operands^ `:` type($operands))? attr-dict";
-  let hasVerifier = 1;
 }
 
 def Async_AwaitOp : Async_Op<"await"> {
   let summary = "waits for the argument to become ready";
   let description = [{
     The `async.await` operation waits until the argument becomes ready, and for
     the `async.value` arguments it unwraps the underlying value
 

mlir/include/mlir/Dialect/SCF/IR/SCFOps.td

class SCF_Op<string mnemonic, list<Trait> traits = []> :
     Op<SCF_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // ConditionOp
 //===----------------------------------------------------------------------===//
 
 def ConditionOp : SCF_Op<"condition", [
   HasParent<"WhileOp">,
-  DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>,
+  DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface,
+    ["getSuccessorRegions"]>,
   Pure,
   Terminator
 ]> {
   let summary = "loop continuation condition";
   let description = [{
     This operation accepts the continuation (i.e., inverse of exit) condition
     of the `scf.while` construct. If its first argument is true, the "after"
     region of `scf.while` is executed, with the remaining arguments forwarded

 //===----------------------------------------------------------------------===//
 
 def ForOp : SCF_Op<"for",
       [AutomaticAllocationScope, DeclareOpInterfaceMethods<LoopLikeOpInterface,
        ["getSingleInductionVar", "getSingleLowerBound", "getSingleStep",
         "getSingleUpperBound", "promoteIfSingleIteration"]>,
        AllTypesMatch<["lowerBound", "upperBound", "step"]>,
        ConditionallySpeculatable,
-       DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+       DeclareOpInterfaceMethods<RegionBranchOpInterface,
+        ["getEntrySuccessorOperands"]>,
        SingleBlockImplicitTerminator<"scf::YieldOp">,
        RecursiveMemoryEffects]> {
   let summary = "for operation";
   let description = [{
     The `scf.for` operation represents a loop taking 3 SSA value as operands
     that represent the lower bound, upper bound and step respectively. The
     operation defines an SSA value for its induction variable. It has one
     region capturing the loop body. The induction variable is represented as an
let extraClassDeclaration = [{
     /// clients by hiding the operand / block argument mapping.
     OpOperand &getOpOperandForResult(OpResult opResult) {
       assert(opResult.getDefiningOp() == getOperation() &&
              "opResult does not belong to the scf::ForOp operation");
       return getOperation()->getOpOperand(
         getNumControlOperands() + opResult.getResultNumber());
     }
 
-    /// Return operands used when entering the region at 'index'. These operands
-    /// correspond to the loop iterator operands, i.e., those exclusing the
-    /// induction variable. LoopOp only has one region, so 0 is the only valid
-    /// value for `index`.
-    OperandRange getSuccessorEntryOperands(std::optional<unsigned> index);
-
     /// Returns the step as an `APInt` if it is constant.
     std::optional<APInt> getConstantStep();
 
     /// Interface method for ConditionallySpeculatable.
     Speculation::Speculatability getSpeculatability();
   }];
 
   let hasCanonicalizer = 1;
def InParallelOp : SCF_Op<"forall.in_parallel", [
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
 def IfOp : SCF_Op<"if", [DeclareOpInterfaceMethods<RegionBranchOpInterface, [
-    "getNumRegionInvocations", "getRegionInvocationBounds"]>,
+    "getNumRegionInvocations", "getRegionInvocationBounds",
+    "getEntrySuccessorRegions"]>,
     InferTypeOpAdaptor, SingleBlockImplicitTerminator<"scf::YieldOp">,
     RecursiveMemoryEffects, NoRegionArguments]> {
   let summary = "if-then-else operation";
   let description = [{
     The `scf.if` operation represents an if-then-else construct for
     conditionally executing two regions of code. The operand to an if operation
     is a boolean value. For example:
 
def ReduceReturnOp :
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // WhileOp
 //===----------------------------------------------------------------------===//
 
 def WhileOp : SCF_Op<"while",
-    [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
+    [DeclareOpInterfaceMethods<RegionBranchOpInterface,
+        ["getEntrySuccessorOperands"]>,
      RecursiveMemoryEffects]> {
   let summary = "a generic 'while' loop";
   let description = [{
     This operation represents a generic "while"/"do-while" loop that keeps
     iterating as long as a condition is satisfied. There is no restriction on
     the complexity of the condition. It consists of two regions (with single
     block each): "before" region and "after" region. The names of regions
     indicates whether they execute before or after the condition check.
OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$operands,
       "function_ref<void(OpBuilder &, Location, ValueRange)>":$beforeBuilder,
       "function_ref<void(OpBuilder &, Location, ValueRange)>":$afterBuilder)>
   ];
 
   let extraClassDeclaration = [{
     using BodyBuilderFn =
         function_ref<void(OpBuilder &, Location, ValueRange)>;
 
-    OperandRange getSuccessorEntryOperands(std::optional<unsigned> index);
     ConditionOp getConditionOp();
     YieldOp getYieldOp();
     Block::BlockArgListType getBeforeArguments();
     Block::BlockArgListType getAfterArguments();
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // IndexSwitchOp
 //===----------------------------------------------------------------------===//
 
 def IndexSwitchOp : SCF_Op<"index_switch", [RecursiveMemoryEffects,
     SingleBlockImplicitTerminator<"scf::YieldOp">,
     DeclareOpInterfaceMethods<RegionBranchOpInterface,
-                              ["getRegionInvocationBounds"]>]> {
+                              ["getRegionInvocationBounds",
+                               "getEntrySuccessorRegions"]>]> {
   let summary = "switch-case operation on an index argument";
   let description = [{
     The `scf.index_switch` is a control-flow operation that branches to one of
     the given regions based on the values of the argument and the cases. The
     argument is always of type `index`.
 
     The operation always has a "default" region and any number of case regions
     denoted by integer constants. Control-flow transfers to the case region

mlir/include/mlir/Dialect/Transform/IR/TransformOps.td

 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Dialect/Transform/IR/MatchInterfaces.td"
 include "mlir/Dialect/Transform/IR/TransformAttrs.td"
 include "mlir/Dialect/Transform/IR/TransformDialect.td"
 include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
 
 def AlternativesOp : TransformDialectOp<"alternatives",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface,
-        ["getSuccessorEntryOperands", "getSuccessorRegions",
+        ["getEntrySuccessorOperands", "getSuccessorRegions",
          "getRegionInvocationBounds"]>,
      DeclareOpInterfaceMethods<TransformOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      IsolatedFromAbove, PossibleTopLevelTransformOpTrait,
      SingleBlockImplicitTerminator<"::mlir::transform::YieldOp">]> {
   let summary = "Attempts sequences of transforms until one succeeds";
   let description = [{
     This op may have an arbitrary number of regions, each of which represents a
def ForeachMatchOp : TransformDialectOp<"foreach_match", [
 
   let hasVerifier = 1;
 }
 
 def ForeachOp : TransformDialectOp<"foreach",
     [DeclareOpInterfaceMethods<TransformOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      DeclareOpInterfaceMethods<RegionBranchOpInterface, [
-         "getSuccessorRegions", "getSuccessorEntryOperands"]>,
+         "getSuccessorRegions", "getEntrySuccessorOperands"]>,
      SingleBlockImplicitTerminator<"::mlir::transform::YieldOp">
     ]> {
   let summary = "Executes the body for each payload op";
   let description = [{
     This op has exactly one region with exactly one block ("body"). The body is
     executed for each payload op that is associated to the target operand in an
     unbatched fashion. I.e., the block argument ("iteration variable") is always
     mapped to exactly one payload op.
def SelectOp : TransformDialectOp<"select",
   let results = (outs TransformHandleTypeInterface:$result);
   let assemblyFormat = [{
     $op_name `in` $target attr-dict `:` functional-type(operands, results)
   }];
 }
 
 def SequenceOp : TransformDialectOp<"sequence",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface,
-        ["getSuccessorEntryOperands", "getSuccessorRegions",
+        ["getEntrySuccessorOperands", "getSuccessorRegions",
          "getRegionInvocationBounds"]>,
      MatchOpInterface,
      DeclareOpInterfaceMethods<TransformOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      OpAsmOpInterface, PossibleTopLevelTransformOpTrait,
      SingleBlockImplicitTerminator<"::mlir::transform::YieldOp">,
      AttrSizedOperandSegments]> {
   let summary = "Contains a sequence of other transform ops to apply";

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

let description = [{
     edges. By default, type equality is used.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<[{
         Returns the operands of this operation used as the entry arguments when
         entering the region at `index`, which was specified as a successor of
-        this operation by `getSuccessorRegions`, or the operands forwarded to
-        the operation's results when it branches back to itself. These operands
+        this operation by `getEntrySuccessorRegions`, or the operands forwarded
+        to the operation's results when it branches back to itself. These operands
         should correspond 1-1 with the successor inputs specified in
-        `getSuccessorRegions`.
+        `getEntrySuccessorRegions`.
       }],
-      "::mlir::OperandRange", "getSuccessorEntryOperands",
+      "::mlir::OperandRange", "getEntrySuccessorOperands",
       (ins "::std::optional<unsigned>":$index), [{}],
       /*defaultImplementation=*/[{
         auto operandEnd = this->getOperation()->operand_end();
         return ::mlir::OperandRange(operandEnd, operandEnd);
       }]
     >,
     InterfaceMethod<[{
+        Returns the viable region successors that are branched to when first
+        executing the op.
+        Unlike `getSuccessorRegions`, this method also passes along the
+        constant operands of this op. Based on these, different region
+        successors can be determined.
+        `operands` contains an entry for every operand of the implementing
+        op with a null attribute if the operand has no constant value or
+        the corresponding attribute if it is a constant.
+
+        By default, simply dispatches to `getSuccessorRegions`.
+      }],
+      "void", "getEntrySuccessorRegions",
+      (ins "::llvm::ArrayRef<::mlir::Attribute>":$operands,
+           "::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &":$regions),
+           [{}], [{
+        $_op.getSuccessorRegions(std::nullopt, regions);
+      }]
+    >,
+    InterfaceMethod<[{
         Returns the viable successors of a region at `index`, or the possible
         successors when branching from the parent op if `index` is None. These
-        are the regions that may be selected during the flow of control. If
-        `index` is None, `operands` is a set of optional attributes that
-        either correspond to a constant value for each operand of this
-        operation, or null if that operand is not a constant. If `index` is
-        valid, `operands` corresponds to the entry values of the region at
-        `index`. The parent operation, i.e. a null `index`, may specify itself
-        as successor, which indicates that the control flow may not enter any
-        region at all. This method allows for describing which
-        regions may be executed when entering an operation, and which regions
-        are executed after having executed another region of the parent op. The
-        successor region must be non-empty.
+        are the regions that may be selected during the flow of control. The
+        parent operation, i.e. a null `index`, may specify itself as successor,
+        which indicates that the control flow may not enter any region at all.
+        This method allows for describing which regions may be executed when
+        entering an operation, and which regions are executed after having
+        executed another region of the parent op. The successor region must be
+        non-empty.
       }],
       "void", "getSuccessorRegions",
       (ins "::std::optional<unsigned>":$index,
-           "::llvm::ArrayRef<::mlir::Attribute>":$operands,
            "::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &":$regions)
     >,
     InterfaceMethod<[{
         Populates `invocationBounds` with the minimum and maximum number of
         times this operation will invoke the attached regions (assuming the
         regions yield normally, i.e. do not abort or invoke an infinite loop).
         The minimum number of invocations is at least 0. If the maximum number
         of invocations cannot be statically determined, then it will not have a
         value (i.e., it is set to `std::nullopt`).
def RegionBranchOpInterface : OpInterface<"RegionBranchOpInterface"> {
   let verify = [{
     static_assert(!ConcreteOp::template hasTrait<OpTrait::ZeroRegions>(),
                   "expected operation to have non-zero regions");
     return detail::verifyTypesAlongControlFlowEdges($_op);
   }];
   let verifyWithRegions = 1;
 
   let extraClassDeclaration = [{
-    /// Convenience helper in case none of the operands is known.
-    void getSuccessorRegions(std::optional<unsigned> index,
-                             SmallVectorImpl<RegionSuccessor> &regions);
-
     /// Return `true` if control flow originating from the given region may
     /// eventually branch back to the same region. (Maybe after passing through
     /// other regions.)
     bool isRepetitiveRegion(unsigned index);
   }];
 }
 
 //===----------------------------------------------------------------------===//
InterfaceMethod<[{
         passing them to the region successor given by `index`.  If `index` is
         None, this function returns the operands that are passed as a result to
         the parent operation.
       }],
       "::mlir::MutableOperandRange", "getMutableSuccessorOperands",
       (ins "::std::optional<unsigned>":$index)
     >,
     InterfaceMethod<[{
-        Returns a range of operands that are semantically "returned" by passing
-        them to the region successor given by `index`.  If `index` is None, this
-        function returns the operands that are passed as a result to the parent
-        operation.
+        Returns the viable region successors that are branched to from this
+        terminator based on the given constant operands.
+
+        `operands` contains an entry for every operand of the
+        implementing op with a null attribute if the operand has no constant
+        value or the corresponding attribute if it is a constant.
+
+        Default implementation simply dispatches to the parent
+        `RegionBranchOpInterface`'s `getSuccessorRegions` implementation.
       }],
-      "::mlir::OperandRange", "getSuccessorOperands",
-      (ins "::std::optional<unsigned>":$index), [{}],
-      /*defaultImplementation=*/[{
-        return $_op.getMutableSuccessorOperands(index);
+      "void", "getSuccessorRegions",
+      (ins "::llvm::ArrayRef<::mlir::Attribute>":$operands,
+           "::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &":$regions), [{}],
+      [{
+        ::mlir::Operation *op = $_op;
+        ::mlir::cast<::mlir::RegionBranchOpInterface>(op->getParentOp())
+          .getSuccessorRegions(op->getParentRegion()->getRegionNumber(),
+            regions);
       }]
-    >
+    >,
   ];
 
   let verify = [{
     static_assert(ConcreteOp::template hasTrait<OpTrait::IsTerminator>(),
                   "expected operation to be a terminator");
     static_assert(ConcreteOp::template hasTrait<OpTrait::ZeroResults>(),
                   "expected operation to have zero results");
     static_assert(ConcreteOp::template hasTrait<OpTrait::ZeroSuccessors>(),
                   "expected operation to have zero successors");
     return success();
   }];
+
+  let extraClassDeclaration = [{
+    // Returns a range of operands that are semantically "returned" by passing
+    // them to the region successor given by `index`.  If `index` is None, this
+    // function returns the operands that are passed as a result to the parent
+    // operation.
+    ::mlir::OperandRange getSuccessorOperands(std::optional<unsigned> index) {
+        return getMutableSuccessorOperands(index);
+    }
+  }];
 }
 
 //===----------------------------------------------------------------------===//
 // ControlFlow Traits
 //===----------------------------------------------------------------------===//
 
 // Op is "return-like".
 def ReturnLike : TraitList<[

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

static void collectUnderlyingAddressValues(RegionBranchOpInterface branch,
   std::optional<unsigned> regionIndex;
   if (region) {
     // Determine the actual region number from the passed region.
     regionIndex = region->getRegionNumber();
   }
   if (std::optional<unsigned> operandIndex =
           getOperandIndexIfPred(/*predIndex=*/std::nullopt)) {
     collectUnderlyingAddressValues(
-        branch.getSuccessorEntryOperands(regionIndex)[*operandIndex], maxDepth,
+        branch.getEntrySuccessorOperands(regionIndex)[*operandIndex], maxDepth,
         visited, output);
   }
   // Check branches from each child region.
   Operation *op = branch.getOperation();
   for (int i = 0, e = op->getNumRegions(); i != e; ++i) {
     if (std::optional<unsigned> operandIndex = getOperandIndexIfPred(i)) {
       for (Block &block : op->getRegion(i)) {
         // Try to determine possible region-branch successor operands for the

mlir/lib/Analysis/DataFlow/DeadCodeAnalysis.cpp

if (op->getNumRegions()) {
     } else {
       markEntryBlocksLive(op);
     }
   }
 
   if (isRegionOrCallableReturn(op)) {
     if (auto branch = dyn_cast<RegionBranchOpInterface>(op->getParentOp())) {
       // Visit the exiting terminator of a region.
-      visitRegionTerminator(op, branch);
+      visitRegionTerminator(cast<RegionBranchTerminatorOpInterface>(op),
+                            branch);
     } else if (auto callable =
                    dyn_cast<CallableOpInterface>(op->getParentOp())) {
       // Visit the exiting terminator of a callable.
       visitCallableTerminator(op, callable);
     }
   }
   // Visit the successors.
   if (op->getNumSuccessors()) {

 void DeadCodeAnalysis::visitRegionBranchOperation(
     RegionBranchOpInterface branch) {
   // Try to deduce which regions are executable.
   std::optional<SmallVector<Attribute>> operands = getOperandValues(branch);
   if (!operands)
     return;
 
   SmallVector<RegionSuccessor> successors;
-  branch.getSuccessorRegions(/*index=*/{}, *operands, successors);
+  branch.getEntrySuccessorRegions(*operands, successors);
   for (const RegionSuccessor &successor : successors) {
     // The successor can be either an entry block or the parent operation.
     ProgramPoint point = successor.getSuccessor()
                              ? &successor.getSuccessor()->front()
                              : ProgramPoint(branch);
     // Mark the entry block as executable.
     auto *state = getOrCreate<Executable>(point);
     propagateIfChanged(state, state->setToLive());
     // Add the parent op as a predecessor.
     auto *predecessors = getOrCreate<PredecessorState>(point);
     propagateIfChanged(
         predecessors,
         predecessors->join(branch, successor.getSuccessorInputs()));
   }
 }
 
-void DeadCodeAnalysis::visitRegionTerminator(Operation *op,
-                                             RegionBranchOpInterface branch) {
+void DeadCodeAnalysis::visitRegionTerminator(
+    RegionBranchTerminatorOpInterface op, RegionBranchOpInterface branch) {
   std::optional<SmallVector<Attribute>> operands = getOperandValues(op);
   if (!operands)
     return;
 
   SmallVector<RegionSuccessor> successors;
-  branch.getSuccessorRegions(op->getParentRegion()->getRegionNumber(),
-                             *operands, successors);
+  op.getSuccessorRegions(*operands, successors);
 
   // Mark successor region entry blocks as executable and add this op to the
   // list of predecessors.
   for (const RegionSuccessor &successor : successors) {
     PredecessorState *predecessors;
     if (Region *region = successor.getSuccessor()) {
       auto *state = getOrCreate<Executable>(&region->front());
       propagateIfChanged(state, state->setToLive());

mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp

assert(predecessors->allPredecessorsKnown() &&
          "unexpected unresolved region successors");
 
   for (Operation *op : predecessors->getKnownPredecessors()) {
     // Get the incoming successor operands.
     std::optional<OperandRange> operands;
 
     // Check if the predecessor is the parent op.
     if (op == branch) {
-      operands = branch.getSuccessorEntryOperands(successorIndex);
+      operands = branch.getEntrySuccessorOperands(successorIndex);
       // Otherwise, try to deduce the operands from a region return-like op.
     } else if (auto regionTerminator =
                    dyn_cast<RegionBranchTerminatorOpInterface>(op)) {
       operands = regionTerminator.getSuccessorOperands(successorIndex);
     }
 
     if (!operands) {
       // We can't reason about the data-flow.

 }
 
 void AbstractSparseBackwardDataFlowAnalysis::visitRegionSuccessors(
     RegionBranchOpInterface branch,
     ArrayRef<AbstractSparseLattice *> operandLattices) {
   Operation *op = branch.getOperation();
   SmallVector<RegionSuccessor> successors;
   SmallVector<Attribute> operands(op->getNumOperands(), nullptr);
-  branch.getSuccessorRegions(/*index=*/{}, operands, successors);
+  branch.getEntrySuccessorRegions(operands, successors);
 
   // All operands not forwarded to any successor. This set can be non-contiguous
   // in the presence of multiple successors.
   BitVector unaccounted(op->getNumOperands(), true);
 
   for (RegionSuccessor &successor : successors) {
     Region *region = successor.getSuccessor();
     OperandRange operands =
-        region ? branch.getSuccessorEntryOperands(region->getRegionNumber())
-               : branch.getSuccessorEntryOperands({});
+        region ? branch.getEntrySuccessorOperands(region->getRegionNumber())
+               : branch.getEntrySuccessorOperands({});
     MutableArrayRef<OpOperand> opoperands = operandsToOpOperands(operands);
     ValueRange inputs = successor.getSuccessorInputs();
     for (auto [operand, input] : llvm::zip(opoperands, inputs)) {
       meet(getLatticeElement(operand.get()), *getLatticeElementFor(op, input));
       unaccounted.reset(operand.getOperandNumber());
     }
   }
   // All operands not forwarded to regions are typically parameters of the
void AbstractSparseBackwardDataFlowAnalysis::
   assert(isa<RegionBranchTerminatorOpInterface>(terminator) &&
          "expected a `RegionBranchTerminatorOpInterface` op");
   assert(terminator->getParentOp() == branch.getOperation() &&
          "expected `branch` to be the parent op of `terminator`");
 
   SmallVector<Attribute> operandAttributes(terminator->getNumOperands(),
                                            nullptr);
   SmallVector<RegionSuccessor> successors;
-  branch.getSuccessorRegions(terminator->getParentRegion()->getRegionNumber(),
-                             operandAttributes, successors);
+  terminator.getSuccessorRegions(operandAttributes, successors);
   // All operands not forwarded to any successor. This set can be
   // non-contiguous in the presence of multiple successors.
   BitVector unaccounted(terminator->getNumOperands(), true);
 
   for (const RegionSuccessor &successor : successors) {
     ValueRange inputs = successor.getSuccessorInputs();
     Region *region = successor.getSuccessor();
     OperandRange operands = terminator.getSuccessorOperands(

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

void AffineForOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<AffineForEmptyLoopFolder>(context);
 }
 
 /// Return operands used when entering the region at 'index'. These operands
 /// correspond to the loop iterator operands, i.e., those excluding the
 /// induction variable. AffineForOp only has one region, so zero is the only
 /// valid value for `index`.
 OperandRange
-AffineForOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
+AffineForOp::getEntrySuccessorOperands(std::optional<unsigned> index) {
   assert((!index || *index == 0) && "invalid region index");
 
   // The initial operands map to the loop arguments after the induction
   // variable or are forwarded to the results when the trip count is zero.
   return getIterOperands();
 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
 void AffineForOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   assert((!index.has_value() || index.value() == 0) && "expected loop region");
   // The loop may typically branch back to its body or to the parent operation.
   // If the predecessor is the parent op and the trip count is known to be at
   // least one, branch into the body using the iterator arguments. And in cases
   // we know the trip count is zero, it can only branch back to its parent.
   std::optional<uint64_t> tripCount = getTrivialConstantTripCount(*this);
   if (!index.has_value() && tripCount.has_value()) {
     if (tripCount.value() > 0) {
LogicalResult matchAndRewrite(AffineIfOp op,
     return success();
   }
 };
 } // namespace
 
 /// AffineIfOp has two regions -- `then` and `else`. The flow of data should be
 /// as follows: AffineIfOp -> `then`/`else` -> AffineIfOp
 void AffineIfOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   // If the predecessor is an AffineIfOp, then branching into both `then` and
   // `else` region is valid.
   if (!index.has_value()) {
     regions.reserve(2);
     regions.push_back(
         RegionSuccessor(&getThenRegion(), getThenRegion().getArguments()));
     // If the "else" region is empty, branch bach into parent.
     if (getElseRegion().empty()) {

mlir/lib/Dialect/Async/IR/Async.cpp

#include "mlir/Dialect/Async/IR/AsyncOps.cpp.inc"
       >();
   addTypes<
 #define GET_TYPEDEF_LIST
 #include "mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
-// YieldOp
-//===----------------------------------------------------------------------===//
-
-LogicalResult YieldOp::verify() {
-  // Get the underlying value types from async values returned from the
-  // parent `async.execute` operation.
-  auto executeOp = (*this)->getParentOfType<ExecuteOp>();
-  auto types =
-      llvm::map_range(executeOp.getBodyResults(), [](const OpResult &result) {
-        return llvm::cast<ValueType>(result.getType()).getValueType();
-      });
-
-  if (getOperandTypes() != types)
-    return emitOpError("operand types do not match the types returned from "
-                       "the parent ExecuteOp");
-
-  return success();
-}
-
-MutableOperandRange
-YieldOp::getMutableSuccessorOperands(std::optional<unsigned> index) {
-  return getOperandsMutable();
-}
-
-//===----------------------------------------------------------------------===//
 /// ExecuteOp
 //===----------------------------------------------------------------------===//
 
 constexpr char kOperandSegmentSizesAttr[] = "operand_segment_sizes";
 
 OperandRange
-ExecuteOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
+ExecuteOp::getEntrySuccessorOperands(std::optional<unsigned> index) {
   assert(index && *index == 0 && "invalid region index");
   return getBodyOperands();
 }
 
 bool ExecuteOp::areTypesCompatible(Type lhs, Type rhs) {
   const auto getValueOrTokenType = [](Type type) {
     if (auto value = llvm::dyn_cast<ValueType>(type))
       return value.getValueType();
     return type;
   };
   return getValueOrTokenType(lhs) == getValueOrTokenType(rhs);
 }
 
 void ExecuteOp::getSuccessorRegions(std::optional<unsigned> index,
-                                    ArrayRef<Attribute>,
                                     SmallVectorImpl<RegionSuccessor> &regions) {
   // The `body` region branch back to the parent operation.
   if (index) {
     assert(*index == 0 && "invalid region index");
     regions.push_back(RegionSuccessor(getBodyResults()));
     return;
   }
 

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

auto *it =
           return successorRegion.getSuccessor() == argRegion;
         });
     if (it == successorRegions.end())
       return success();
 
     // Determine the actual operand to introduce a clone for and rewire the
     // operand to point to the clone instead.
     auto operands =
-        regionInterface.getSuccessorEntryOperands(argRegion->getRegionNumber());
+        regionInterface.getEntrySuccessorOperands(argRegion->getRegionNumber());
     size_t operandIndex =
         llvm::find(it->getSuccessorInputs(), blockArg).getIndex() +
         operands.getBeginOperandIndex();
     Value operand = parentOp->getOperand(operandIndex);
     assert(operand ==
                operands[operandIndex - operands.getBeginOperandIndex()] &&
            "region interface operands don't match parentOp operands");
     auto clone = introduceCloneBuffers(operand, parentOp);

mlir/lib/Dialect/Bufferization/Transforms/BufferViewFlowAnalysis.cpp

if (auto regionInterface = dyn_cast<RegionBranchOpInterface>(op)) {
       // Extract all entry regions and wire all initial entry successor inputs.
       SmallVector<RegionSuccessor, 2> entrySuccessors;
       regionInterface.getSuccessorRegions(/*index=*/std::nullopt,
                                           entrySuccessors);
       for (RegionSuccessor &entrySuccessor : entrySuccessors) {
         // Wire the entry region's successor arguments with the initial
         // successor inputs.
         registerDependencies(
-            regionInterface.getSuccessorEntryOperands(
+            regionInterface.getEntrySuccessorOperands(
                 entrySuccessor.isParent()
                     ? std::optional<unsigned>()
                     : entrySuccessor.getSuccessor()->getRegionNumber()),
             entrySuccessor.getSuccessorInputs());
       }
 
       // Wire flow between regions and from region exits.
       for (Region &region : regionInterface->getRegions()) {

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

ParseResult AllocaScopeOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   return success();
 }
 
 void AllocaScopeOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   if (index) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
   regions.push_back(RegionSuccessor(&getBodyRegion()));
 }
 

mlir/lib/Dialect/SCF/IR/SCF.cpp

 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
 void ExecuteRegionOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   // If the predecessor is the ExecuteRegionOp, branch into the body.
   if (!index) {
     regions.push_back(RegionSuccessor(&getRegion()));
     return;
   }
 
   // Otherwise, the region branches back to the parent operation.
   regions.push_back(RegionSuccessor(getResults()));
 }
 
 //===----------------------------------------------------------------------===//
 // ConditionOp
 //===----------------------------------------------------------------------===//
 
 MutableOperandRange
 ConditionOp::getMutableSuccessorOperands(std::optional<unsigned> index) {
   // Pass all operands except the condition to the successor region.
   return getArgsMutable();
 }
 
+void ConditionOp::getSuccessorRegions(
+    ArrayRef<Attribute> operands, SmallVectorImpl<RegionSuccessor> &regions) {
+  FoldAdaptor adaptor(operands);
+
+  WhileOp whileOp = getParentOp();
+
+  // Condition can either lead to the after region or back to the parent op
+  // depending on whether the condition is true or not.
+  auto boolAttr = dyn_cast_or_null<BoolAttr>(adaptor.getCondition());
+  if (!boolAttr || boolAttr.getValue())
+    regions.emplace_back(&whileOp.getAfter(),
+                         whileOp.getAfter().getArguments());
+  if (!boolAttr || !boolAttr.getValue())
+    regions.emplace_back(whileOp.getResults());
+}
+
 //===----------------------------------------------------------------------===//
 // ForOp
 //===----------------------------------------------------------------------===//
 
 void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
                   Value ub, Value step, ValueRange iterArgs,
                   BodyBuilderFn bodyBuilder) {
   result.addOperands({lb, ub, step});
ForOp mlir::scf::getForInductionVarOwner(Value val) {
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingOp = ivArg.getOwner()->getParentOp();
   return dyn_cast_or_null<ForOp>(containingOp);
 }
 
 /// Return operands used when entering the region at 'index'. These operands
 /// correspond to the loop iterator operands, i.e., those excluding the
 /// induction variable.
-OperandRange ForOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
+OperandRange ForOp::getEntrySuccessorOperands(std::optional<unsigned> index) {
   return getInitArgs();
 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
 void ForOp::getSuccessorRegions(std::optional<unsigned> index,
-                                ArrayRef<Attribute> operands,
                                 SmallVectorImpl<RegionSuccessor> &regions) {
   // Both the operation itself and the region may be branching into the body or
   // back into the operation itself. It is possible for loop not to enter the
   // body.
   regions.push_back(RegionSuccessor(&getLoopBody(), getRegionIterArgs()));
   regions.push_back(RegionSuccessor(getResults()));
 }
 

 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
 void ForallOp::getSuccessorRegions(std::optional<unsigned> index,
-                                   ArrayRef<Attribute> operands,
                                    SmallVectorImpl<RegionSuccessor> &regions) {
   // Both the operation itself and the region may be branching into the body or
   // back into the operation itself. It is possible for loop not to enter the
   // body.
   regions.push_back(RegionSuccessor(&getRegion()));
   regions.push_back(RegionSuccessor());
 }
 

 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
 void IfOp::getSuccessorRegions(std::optional<unsigned> index,
-                               ArrayRef<Attribute> operands,
                                SmallVectorImpl<RegionSuccessor> &regions) {
   // The `then` and the `else` region branch back to the parent operation.
   if (index) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
+  regions.push_back(RegionSuccessor(&getThenRegion()));
+
   // Don't consider the else region if it is empty.
   Region *elseRegion = &this->getElseRegion();
   if (elseRegion->empty())
-    elseRegion = nullptr;
-
-  // Otherwise, the successor is dependent on the condition.
-  bool condition;
-  if (auto condAttr = llvm::dyn_cast_or_null<IntegerAttr>(operands.front())) {
-    condition = condAttr.getValue().isOne();
-  } else {
-    // If the condition isn't constant, both regions may be executed.
-    regions.push_back(RegionSuccessor(&getThenRegion()));
-    // If the else region does not exist, it is not a viable successor, so the
-    // control will go back to this operation instead.
-    if (elseRegion)
-      regions.push_back(RegionSuccessor(elseRegion));
-    else
-      regions.push_back(RegionSuccessor());
-    return;
-  }
+  else
+    regions.push_back(RegionSuccessor(elseRegion));
 
-  // Add the successor regions using the condition.
-  regions.push_back(RegionSuccessor(condition ? &getThenRegion() : elseRegion));
+void IfOp::getEntrySuccessorRegions(ArrayRef<Attribute> operands,
+                                    SmallVectorImpl<RegionSuccessor> &regions) {
+  FoldAdaptor adaptor(operands);
+  auto boolAttr = dyn_cast_or_null<BoolAttr>(adaptor.getCondition());
+  if (!boolAttr || boolAttr.getValue())
+    regions.emplace_back(&getThenRegion());
+
+  // If the else region is empty, execution continues after the parent op.
+  if (!boolAttr || !boolAttr.getValue()) {
+    if (!getElseRegion().empty())
+      regions.emplace_back(&getElseRegion());
+    else
+      regions.emplace_back(getResults());
+  }
 }
 
 LogicalResult IfOp::fold(FoldAdaptor adaptor,
                          SmallVectorImpl<OpFoldResult> &results) {
   // if (!c) then A() else B() -> if c then B() else A()
   if (getElseRegion().empty())
     return failure();
 

 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
 void ParallelOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   // Both the operation itself and the region may be branching into the body or
   // back into the operation itself. It is possible for loop not to enter the
   // body.
   regions.push_back(RegionSuccessor(&getRegion()));
   regions.push_back(RegionSuccessor());
 }
 
 //===----------------------------------------------------------------------===//
void WhileOp::build(::mlir::OpBuilder &odsBuilder,
   Region *afterRegion = odsState.addRegion();
   Block *afterBlock = odsBuilder.createBlock(afterRegion, /*insertPt=*/{},
                                              resultTypes, afterArgLocs);
 
   if (afterBuilder)
     afterBuilder(odsBuilder, odsState.location, afterBlock->getArguments());
 }
 
-OperandRange WhileOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
+OperandRange WhileOp::getEntrySuccessorOperands(std::optional<unsigned> index) {
   assert(index && *index == 0 &&
          "WhileOp is expected to branch only to the first region");
 
   return getInits();
 }
 
 ConditionOp WhileOp::getConditionOp() {
   return cast<ConditionOp>(getBefore().front().getTerminator());
 }
 
 YieldOp WhileOp::getYieldOp() {
   return cast<YieldOp>(getAfter().front().getTerminator());
 }
 
 Block::BlockArgListType WhileOp::getBeforeArguments() {
   return getBefore().front().getArguments();
 }
 
 Block::BlockArgListType WhileOp::getAfterArguments() {
   return getAfter().front().getArguments();
 }
 
 void WhileOp::getSuccessorRegions(std::optional<unsigned> index,
-                                  ArrayRef<Attribute> operands,
                                   SmallVectorImpl<RegionSuccessor> &regions) {
   // The parent op always branches to the condition region.
   if (!index) {
     regions.emplace_back(&getBefore(), getBefore().getArguments());
     return;
   }
 
   assert(*index < 2 && "there are only two regions in a WhileOp");
   // The body region always branches back to the condition region.
   if (*index == 1) {
     regions.emplace_back(&getBefore(), getBefore().getArguments());
     return;
   }
 
-  // Try to narrow the successor to the condition region.
-  assert(!operands.empty() && "expected at least one operand");
-  auto cond = llvm::dyn_cast_or_null<BoolAttr>(operands[0]);
-  if (!cond || !cond.getValue())
-    regions.emplace_back(getResults());
-  if (!cond || cond.getValue())
-    regions.emplace_back(&getAfter(), getAfter().getArguments());
 }
 
 /// Parses a `while` op.
 ///
 /// op ::= `scf.while` assignments `:` function-type region `do` region
 ///         `attributes` attribute-dict
 /// initializer ::= /* empty */ | `(` assignment-list `)`
 /// assignment-list ::= assignment | assignment `,` assignment-list

 }
 
 Block &scf::IndexSwitchOp::getCaseBlock(unsigned idx) {
   assert(idx < getNumCases() && "case index out-of-bounds");
   return getCaseRegions()[idx].front();
 }
 
 void IndexSwitchOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
+    std::optional<unsigned> index,
     SmallVectorImpl<RegionSuccessor> &successors) {
   // All regions branch back to the parent op.
   if (index) {
     successors.emplace_back(getResults());
     return;
   }
 
+  llvm::copy(getRegions(), std::back_inserter(successors));
+}
+
+void IndexSwitchOp::getEntrySuccessorRegions(
+    ArrayRef<Attribute> operands,
+    SmallVectorImpl<RegionSuccessor> &successors) {
+  FoldAdaptor adaptor(operands);
+
   // If a constant was not provided, all regions are possible successors.
-  auto operandValue = llvm::dyn_cast_or_null<IntegerAttr>(operands.front());
-  if (!operandValue) {
-    for (Region &caseRegion : getCaseRegions())
-      successors.emplace_back(&caseRegion);
-    successors.emplace_back(&getDefaultRegion());
+  auto arg = dyn_cast_or_null<IntegerAttr>(adaptor.getArg());
+  if (!arg) {
+    llvm::copy(getRegions(), std::back_inserter(successors));
     return;
   }
 
-  // Otherwise, try to find a case with a matching value. If not, the default
-  // region is the only successor.
+  // Otherwise, try to find a case with a matching value. If not, the
+  // default region is the only successor.
   for (auto [caseValue, caseRegion] : llvm::zip(getCases(), getCaseRegions())) {
-    if (caseValue == operandValue.getInt()) {
+    if (caseValue == arg.getInt()) {
       successors.emplace_back(&caseRegion);
       return;
     }
   }
   successors.emplace_back(&getDefaultRegion());
 }
 
 void IndexSwitchOp::getRegionInvocationBounds(

mlir/lib/Dialect/Shape/IR/Shape.cpp

 
 void AssumingOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                              MLIRContext *context) {
   patterns.add<AssumingOpRemoveUnusedResults, AssumingWithTrue>(context);
 }
 
 // See RegionBranchOpInterface in Interfaces/ControlFlowInterfaces.td
 void AssumingOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   // AssumingOp has unconditional control flow into the region and back to the
   // parent, so return the correct RegionSuccessor purely based on the index
   // being None or 0.
   if (index) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 

mlir/lib/Dialect/Transform/IR/TransformOps.cpp

 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Transform/IR/TransformOps.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // AlternativesOp
 //===----------------------------------------------------------------------===//
 
-OperandRange transform::AlternativesOp::getSuccessorEntryOperands(
+OperandRange transform::AlternativesOp::getEntrySuccessorOperands(
     std::optional<unsigned> index) {
   if (index && getOperation()->getNumOperands() == 1)
     return getOperation()->getOperands();
   return OperandRange(getOperation()->operand_end(),
                       getOperation()->operand_end());
 }
 
 void transform::AlternativesOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   for (Region &alternative : llvm::drop_begin(
            getAlternatives(), index.has_value() ? *index + 1 : 0)) {
     regions.emplace_back(&alternative, !getOperands().empty()
                                            ? alternative.getArguments()
                                            : Block::BlockArgListType());
   }
   if (index.has_value())
     regions.emplace_back(getOperation()->getResults());
if (any_of(getBody().front().without_terminator(), [&](Operation &op) {
     onlyReadsHandle(getTarget(), effects);
   }
 
   for (Value result : getResults())
     producesHandle(result, effects);
 }
 
 void transform::ForeachOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   Region *bodyRegion = &getBody();
   if (!index) {
     regions.emplace_back(bodyRegion, bodyRegion->getArguments());
     return;
   }
 
   // Branch back to the region or the parent.
   assert(*index == 0 && "unexpected region index");
   regions.emplace_back(bodyRegion, bodyRegion->getArguments());
   regions.emplace_back();
 }
 
 OperandRange
-transform::ForeachOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
+transform::ForeachOp::getEntrySuccessorOperands(std::optional<unsigned> index) {
   // The iteration variable op handle is mapped to a subset (one op to be
   // precise) of the payload ops of the ForeachOp operand.
   assert(index && *index == 0 && "unexpected region index");
   return getOperation()->getOperands();
 }
 
 transform::YieldOp transform::ForeachOp::getYieldOp() {
   return cast<transform::YieldOp>(getBody().front().getTerminator());
LogicalResult transform::SequenceOp::verify() {
   return success();
 }
 
 void transform::SequenceOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   getPotentialTopLevelEffects(effects);
 }
 
-OperandRange transform::SequenceOp::getSuccessorEntryOperands(
+OperandRange transform::SequenceOp::getEntrySuccessorOperands(
     std::optional<unsigned> index) {
   assert(index && *index == 0 && "unexpected region index");
   if (getOperation()->getNumOperands() > 0)
     return getOperation()->getOperands();
   return OperandRange(getOperation()->operand_end(),
                       getOperation()->operand_end());
 }
 
 void transform::SequenceOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   if (!index) {
     Region *bodyRegion = &getBody();
-    regions.emplace_back(bodyRegion, !operands.empty()
+    regions.emplace_back(bodyRegion, getNumOperands() != 0
                                          ? bodyRegion->getArguments()
                                          : Block::BlockArgListType());
     return;
   }
 
   assert(*index == 0 && "unexpected region index");
   regions.emplace_back(getOperation()->getResults());
 }

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

ParseResult WarpExecuteOnLane0Op::parse(OpAsmParser &parser,
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
   return success();
 }
 
 void WarpExecuteOnLane0Op::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   if (index) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
   // The warp region is always executed
   regions.push_back(RegionSuccessor(&getWarpRegion()));
 }

mlir/lib/Interfaces/ControlFlowInterfaces.cpp

 }
 
 /// Verify that types match along control flow edges described the given op.
 LogicalResult detail::verifyTypesAlongControlFlowEdges(Operation *op) {
   auto regionInterface = cast<RegionBranchOpInterface>(op);
 
   auto inputTypesFromParent =
       [&](std::optional<unsigned> regionNo) -> TypeRange {
-    return regionInterface.getSuccessorEntryOperands(regionNo).getTypes();
+    return regionInterface.getEntrySuccessorOperands(regionNo).getTypes();
   };
 
   // Verify types along control flow edges originating from the parent.
   if (failed(verifyTypesAlongAllEdges(op, std::nullopt, inputTypesFromParent)))
     return failure();
 
   auto areTypesCompatible = [&](TypeRange lhs, TypeRange rhs) {
     if (lhs.size() != rhs.size())
bool mlir::insideMutuallyExclusiveRegions(Operation *a, Operation *b) {
   return false;
 }
 
 bool RegionBranchOpInterface::isRepetitiveRegion(unsigned index) {
   Region *region = &getOperation()->getRegion(index);
   return isRegionReachable(region, region);
 }
 
-void RegionBranchOpInterface::getSuccessorRegions(
-    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
-  unsigned numInputs = 0;
-  if (index) {
-    // If the predecessor is a region, get the number of operands from an
-    // exiting terminator in the region.
-    for (Block &block : getOperation()->getRegion(*index)) {
-      Operation *terminator = block.getTerminator();
-      if (isa<RegionBranchTerminatorOpInterface>(terminator)) {
-        numInputs = terminator->getNumOperands();
-        break;
-      }
-    }
-  } else {
-    // Otherwise, use the number of parent operation operands.
-    numInputs = getOperation()->getNumOperands();
-  }
-  SmallVector<Attribute, 2> operands(numInputs, nullptr);
-  getSuccessorRegions(index, operands, regions);
-}
-
 Region *mlir::getEnclosingRepetitiveRegion(Operation *op) {
   while (Region *region = op->getParentRegion()) {
     op = region->getParentOp();
     if (auto branchOp = dyn_cast<RegionBranchOpInterface>(op))
       if (branchOp.isRepetitiveRegion(region->getRegionNumber()))
         return region;
   }
   return nullptr;

mlir/test/lib/Dialect/Test/TestDialect.cpp

if (parser.parseKeyword("then") || parser.parseRegion(*thenRegion, {}, {}) ||
       parser.parseKeyword("join") || parser.parseRegion(*joinRegion, {}, {}))
     return failure();
 
   return parser.resolveOperands(operandInfos, operandTypes,
                                 parser.getCurrentLocation(), result.operands);
 }
 
 OperandRange
-RegionIfOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
+RegionIfOp::getEntrySuccessorOperands(std::optional<unsigned> index) {
   assert(index && *index < 2 && "invalid region index");
   return getOperands();
 }
 
 void RegionIfOp::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   // We always branch to the join region.
   if (index.has_value()) {
     if (index.value() < 2)
       regions.push_back(RegionSuccessor(&getJoinRegion(), getJoinArgs()));
     else
       regions.push_back(RegionSuccessor(getResults()));
     return;
   }
void RegionIfOp::getRegionInvocationBounds(
   invocationBounds.assign(/*NumElts=*/3, /*Elt=*/{0, 1});
 }
 
 //===----------------------------------------------------------------------===//
 // AnyCondOp
 //===----------------------------------------------------------------------===//
 
 void AnyCondOp::getSuccessorRegions(std::optional<unsigned> index,
-                                    ArrayRef<Attribute> operands,
                                     SmallVectorImpl<RegionSuccessor> &regions) {
   // The parent op branches into the only region, and the region branches back
   // to the parent op.
   if (!index)
     regions.emplace_back(&getRegion());
   else
     regions.emplace_back(getResults());
 }
Operation::operand_range TestCallAndStoreOp::getArgOperands() {
   return getCalleeOperands();
 }
 
 MutableOperandRange TestCallAndStoreOp::getArgOperandsMutable() {
   return getCalleeOperandsMutable();
 }
 
 void TestStoreWithARegion::getSuccessorRegions(
-    std::optional<unsigned> index, ArrayRef<Attribute> operands,
-    SmallVectorImpl<RegionSuccessor> &regions) {
+    std::optional<unsigned> index, SmallVectorImpl<RegionSuccessor> &regions) {
   if (!index) {
     regions.emplace_back(&getBody(), getBody().front().getArguments());
   } else {
     regions.emplace_back();
   }
 }
 
-MutableOperandRange TestStoreWithARegionTerminator::getMutableSuccessorOperands(
-    std::optional<unsigned> index) {
-  return MutableOperandRange(getOperation());
-}
-
 LogicalResult
 TestVersionedOpA::readProperties(::mlir::DialectBytecodeReader &reader,
                                  ::mlir::OperationState &state) {
   auto &prop = state.getOrAddProperties<Properties>();
   if (::mlir::failed(reader.readAttribute(prop.dims)))
     return ::mlir::failure();
 
   // Check if we have a version. If not, assume we are parsing the current

mlir/test/lib/Dialect/Test/TestOps.td

def RegionIfYieldOp : TEST_Op<"region_if_yield",
   let arguments = (ins Variadic<AnyType>:$results);
   let assemblyFormat = [{
     $results `:` type($results) attr-dict
   }];
 }
 
 def RegionIfOp : TEST_Op<"region_if",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
-                                 ["getRegionInvocationBounds"]>,
+                                 ["getRegionInvocationBounds",
+                                  "getEntrySuccessorOperands"]>,
        SingleBlockImplicitTerminator<"RegionIfYieldOp">,
        RecursiveMemoryEffects]> {
   let description =[{
     Represents an abstract if-then-else-join pattern. In this context, the then
     and else regions jump to the join region, which finally returns to its
     parent op.
   }];
 
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$thenRegion,
                         AnyRegion:$elseRegion,
                         AnyRegion:$joinRegion);
   let extraClassDeclaration = [{
     ::mlir::Block::BlockArgListType getThenArgs() {
       return getBody(0)->getArguments();
     }
     ::mlir::Block::BlockArgListType getElseArgs() {
       return getBody(1)->getArguments();
     }
     ::mlir::Block::BlockArgListType getJoinArgs() {
       return getBody(2)->getArguments();
     }
-    ::mlir::OperandRange getSuccessorEntryOperands(
-        ::std::optional<unsigned> index);
   }];
   let hasCustomAssemblyFormat = 1;
 }
 
 def AnyCondOp : TEST_Op<"any_cond",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getRegionInvocationBounds"]>,
        RecursiveMemoryEffects]> {
let arguments = (ins
     BoolAttr:$store_before_region
   );
   let regions = (region AnyRegion:$body);
   let assemblyFormat =
     "$address attr-dict-with-keyword regions `:` type($address)";
 }
 
 def TestStoreWithARegionTerminator : TEST_Op<"store_with_a_region_terminator",
-    [DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>, Terminator, NoMemoryEffect]> {
+    [ReturnLike, Terminator, NoMemoryEffect]> {
   let assemblyFormat = "attr-dict";
 }
 
 #endif // TEST_OPS

mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp

struct MutuallyExclusiveRegionsOp
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() {
     return "cftest.mutually_exclusive_regions_op";
   }
 
   // Regions have no successors.
   void getSuccessorRegions(std::optional<unsigned> index,
-                           ArrayRef<Attribute> operands,
                            SmallVectorImpl<RegionSuccessor> &regions) {}
 };
 
 /// All regions of this op call each other in a large circle.
 struct LoopRegionsOp
     : public Op<LoopRegionsOp, RegionBranchOpInterface::Trait> {
   using Op::Op;
   static const unsigned kNumRegions = 3;
 
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() { return "cftest.loop_regions_op"; }
 
   void getSuccessorRegions(std::optional<unsigned> index,
-                           ArrayRef<Attribute> operands,
                            SmallVectorImpl<RegionSuccessor> &regions) {
     if (index) {
       if (*index == 1)
         // This region also branches back to the parent.
         regions.push_back(RegionSuccessor());
       regions.push_back(
           RegionSuccessor(&getOperation()->getRegion(*index % kNumRegions)));
     }
   }
 };
 
 /// Each region branches back it itself or the parent.
 struct DoubleLoopRegionsOp
     : public Op<DoubleLoopRegionsOp, RegionBranchOpInterface::Trait> {
   using Op::Op;
 
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() {
     return "cftest.double_loop_regions_op";
   }
 
   void getSuccessorRegions(std::optional<unsigned> index,
-                           ArrayRef<Attribute> operands,
                            SmallVectorImpl<RegionSuccessor> &regions) {
     if (index.has_value()) {
       regions.push_back(RegionSuccessor());
       regions.push_back(RegionSuccessor(&getOperation()->getRegion(*index)));
     }
   }
 };
 
 /// Regions are executed sequentially.
 struct SequentialRegionsOp
     : public Op<SequentialRegionsOp, RegionBranchOpInterface::Trait> {
   using Op::Op;
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() { return "cftest.sequential_regions_op"; }
 
   // Region 0 has Region 1 as a successor.
   void getSuccessorRegions(std::optional<unsigned> index,
-                           ArrayRef<Attribute> operands,
                            SmallVectorImpl<RegionSuccessor> &regions) {
     if (index == 0u) {
       Operation *thisOp = this->getOperation();
       regions.push_back(RegionSuccessor(&thisOp->getRegion(1)));
     }
   }
 };