[mlir] Remove successor operands from the Operation class

[rriddle]

Summary

This revision removes all of the functionality related to successor operands on the core Operation class. This greatly simplifies a lot of handling of operands, as well as successors. For example, DialectConversion no longer needs a special "matchAndRewrite" for branching terminator operations.(Note, the existing method was also broken for operations with variadic successors!!)

This also enables terminator operations to define their own relationships with successor arguments, instead of the hardcoded "pass-through" behavior that exists today.

Depends On D75317

[jpienaar]

Looks good thanks!

mlir/lib/Transforms/Utils/RegionUtils.cpp

286

Super nit: ++argI

[rriddle]

Resolve comments

[rriddle]

Rebase

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

[{
     build(builder, result, operands, attributes);
   }]>;
 
 // Base class for LLVM operations with zero results.
 class LLVM_ZeroResultOp<string mnemonic, list<OpTrait> traits = []> :
     LLVM_Op<mnemonic, traits>, Results<(outs)>,
     LLVM_TwoBuilders<LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder>;
 
+// Opaque builder used for terminator operations that contain successors.
+def LLVM_TerminatorPassthroughOpBuilder : OpBuilder<
+  "Builder *, OperationState &result, ValueRange operands, "
+  "SuccessorRange destinations, ArrayRef<NamedAttribute> attributes = {}",
+  [{
+    result.addOperands(operands);
+    result.addSuccessors(destinations);
+    result.addAttributes(attributes);
+  }]>;
+
 // Base class for LLVM terminator operations.  All terminator operations have
 // zero results and an optional list of successors.
 class LLVM_TerminatorOp<string mnemonic, list<OpTrait> traits = []> :
-    LLVM_Op<mnemonic, !listconcat(traits, [Terminator])> {
-  let builders = [
-    OpBuilder<
-      "Builder *, OperationState &result, "
-      "ValueRange properOperands, "
-      "ArrayRef<Block *> destinations, "
-      "ArrayRef<ValueRange> operands, "
-      "ArrayRef<NamedAttribute> attributes = {}",
-      [{
-        result.addOperands(properOperands);
-        for (auto kvp : llvm::zip(destinations, operands)) {
-          result.addSuccessor(std::get<0>(kvp), std::get<1>(kvp));
-        }
-        for (auto namedAttr : attributes) {
-          result.addAttribute(namedAttr.first, namedAttr.second);
-        }
-      }]
-    >,
-    OpBuilder<
-      "Builder *builder, OperationState &result, "
-      "ValueRange properOperands, "
-      "ArrayRef<Block *> destinations, "
-      "ArrayRef<NamedAttribute> attributes = {}",
-    [{
-        SmallVector<ValueRange, 2> operands(destinations.size(), {});
-        build(builder, result, properOperands,
-            destinations, operands, attributes);
-      }]
-    >,
-  ];
-}
+    LLVM_Op<mnemonic, !listconcat(traits, [Terminator])>;
 
 // Class for arithmetic binary operations.
 class LLVM_ArithmeticOp<string mnemonic, string builderFunc,
                         list<OpTrait> traits = []> :
     LLVM_OneResultOp<mnemonic,
            !listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
     Arguments<(ins LLVM_Type:$lhs, LLVM_Type:$rhs)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($lhs, $rhs);"> {

 def LLVM_UIToFPOp : LLVM_CastOp<"uitofp", "CreateUIToFP">;
 def LLVM_FPToSIOp : LLVM_CastOp<"fptosi", "CreateFPToSI">;
 def LLVM_FPToUIOp : LLVM_CastOp<"fptoui", "CreateFPToUI">;
 def LLVM_FPExtOp : LLVM_CastOp<"fpext", "CreateFPExt">;
 def LLVM_FPTruncOp : LLVM_CastOp<"fptrunc", "CreateFPTrunc">;
 
 // Call-related operations.
 def LLVM_InvokeOp : LLVM_Op<"invoke", [
-                      DeclareOpInterfaceMethods<BranchOpInterface>, Terminator
+                      AttrSizedOperandSegments,
+                      DeclareOpInterfaceMethods<BranchOpInterface>,
+                      Terminator
                     ]>,
                     Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
-                               Variadic<LLVM_Type>)>,
+                               Variadic<LLVM_Type>:$operands,
+                               Variadic<LLVM_Type>:$normalDestOperands,
+                               Variadic<LLVM_Type>:$unwindDestOperands)>,
                     Results<(outs Variadic<LLVM_Type>)> {
   let successors = (successor AnySuccessor:$normalDest,
                               AnySuccessor:$unwindDest);
 
   let builders = [OpBuilder<
     "Builder *b, OperationState &result, ArrayRef<Type> tys, "
+    "FlatSymbolRefAttr callee, ValueRange ops, Block* normal, "
+    "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
+    [{
+      result.addAttribute("callee", callee);
+      build(b, result, tys, ops, normal, normalOps, unwind, unwindOps);
+    }]>,
+    OpBuilder<
+    "Builder *b, OperationState &result, ArrayRef<Type> tys, "
     "ValueRange ops, Block* normal, "
     "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
     [{
-      result.addTypes(tys);
-      result.addOperands(ops);
-      result.addSuccessor(normal, normalOps);
-      result.addSuccessor(unwind, unwindOps);
+      build(b, result, tys, /*callee=*/FlatSymbolRefAttr(), ops, normalOps,
+            unwindOps, normal, unwind);
     }]>];
   let verifier = [{ return ::verify(*this);  }];
   let parser = [{ return parseInvokeOp(parser, result); }];
   let printer = [{ printInvokeOp(p, *this); }];
 }
 
 def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad">,
                         Arguments<(ins UnitAttr:$cleanup,
def LLVM_FreezeOp : LLVM_OneResultOp<"freeze", [SameOperandsAndResultType]>,
                     Arguments<(ins LLVM_Type:$val)> {
   let assemblyFormat = "$val attr-dict `:` type($val)";
   string llvmBuilder = "builder.CreateFreeze($val);";
 }
 
 // Terminators.
 def LLVM_BrOp : LLVM_TerminatorOp<"br",
     [DeclareOpInterfaceMethods<BranchOpInterface>]> {
+  let arguments = (ins Variadic<LLVM_Type>:$destOperands);
   let successors = (successor AnySuccessor:$dest);
-  let assemblyFormat = "$dest attr-dict";
+  let assemblyFormat = [{
+    $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict
+  }];
+  let builders = [LLVM_TerminatorPassthroughOpBuilder];
 }
 def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br",
-    [DeclareOpInterfaceMethods<BranchOpInterface>]> {
-  let arguments = (ins LLVMI1:$condition);
+    [AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>]> {
+  let arguments = (ins LLVMI1:$condition,
+                   Variadic<LLVM_Type>:$trueDestOperands,
+                   Variadic<LLVM_Type>:$falseDestOperands);
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
-  let assemblyFormat = "$condition `,` successors attr-dict";
+  let assemblyFormat = [{
+    $condition `,`
+    $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
+    $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
+    attr-dict
+  }];
+
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value condition,"
+    "Block *trueDest, ValueRange trueOperands,"
+    "Block *falseDest, ValueRange falseOperands", [{
+      build(builder, result, condition, trueOperands, falseOperands, trueDest,
+            falseDest);
+  }]>, OpBuilder<
+    "Builder *builder, OperationState &result, Value condition,"
+    "Block *trueDest, Block *falseDest, ValueRange falseOperands = {}", [{
+      build(builder, result, condition, trueDest, ValueRange(), falseDest,
+            falseOperands);
+  }]>, LLVM_TerminatorPassthroughOpBuilder];
 }
 def LLVM_ReturnOp : LLVM_TerminatorOp<"return", []>,
                     Arguments<(ins Variadic<LLVM_Type>:$args)> {
   string llvmBuilder = [{
     if ($_numOperands != 0)
       builder.CreateRet($args[0]);
     else
       builder.CreateRetVoid();

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

 #define SPIRV_CONTROLFLOW_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
 include "mlir/Analysis/CallInterfaces.td"
 include "mlir/Analysis/ControlFlowInterfaces.td"
 
 // -----
 
-def SPV_BranchOp : SPV_Op<"Branch",[
+def SPV_BranchOp : SPV_Op<"Branch", [
     DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope,
     Terminator]> {
   let summary = "Unconditional branch to target block.";
 
   let description = [{
     This instruction must be the last instruction in a block.
 
     ### Custom assembly form
 
     ```
     branch-op ::= `spv.Branch` successor
     successor ::= bb-id branch-use-list?
     branch-use-list ::= `(` ssa-use-list `:` type-list-no-parens `)`
     ```
 
     For example:
 
     ```
     spv.Branch ^target
     spv.Branch ^target(%0, %1: i32, f32)
     ```
   }];
 
-  let arguments = (ins);
+  let arguments = (ins Variadic<SPV_Type>:$targetOperands);
 
   let results = (outs);
 
   let successors = (successor AnySuccessor:$target);
 
   let verifier = [{ return success(); }];
 
   let builders = [
     OpBuilder<
       "Builder *, OperationState &state, "
       "Block *successor, ValueRange arguments = {}", [{
-        state.addSuccessor(successor, arguments);
+        state.addSuccessors(successor);
+        state.addOperands(arguments);
       }]
     >
   ];
 
   let skipDefaultBuilders = 1;
 
   let extraClassDeclaration = [{
     /// Returns the branch target block.
     Block *getTarget() { return target(); }
 
     /// Returns the block arguments.
     operand_range getBlockArguments() { return targetOperands(); }
   }];
 
   let autogenSerialization = 0;
 
-  let assemblyFormat = "successors attr-dict";
+  let assemblyFormat = [{
+    $target (`(` $targetOperands^ `:` type($targetOperands) `)`)? attr-dict
+  }];
 }
 
 // -----
 
 def SPV_BranchConditionalOp : SPV_Op<"BranchConditional", [
-    DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope,
-    Terminator]> {
+    AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
+    InFunctionScope, Terminator]> {
   let summary = [{
     If Condition is true, branch to true block, otherwise branch to false
     block.
   }];
 
   let description = [{
     Condition must be a Boolean type scalar.
 
let description = [{
     ```
     spv.BranchConditional %condition, ^true_branch, ^false_branch
     spv.BranchConditional %condition, ^true_branch(%0: i32), ^false_branch(%1: i32)
     ```
   }];
 
   let arguments = (ins
     SPV_Bool:$condition,
+    Variadic<SPV_Type>:$trueTargetOperands,
+    Variadic<SPV_Type>:$falseTargetOperands,
     OptionalAttr<I32ArrayAttr>:$branch_weights
   );
 
   let results = (outs);
 
   let successors = (successor AnySuccessor:$trueTarget,
-                               AnySuccessor:$falseTarget);
 
   let builders = [
     OpBuilder<
       "Builder *builder, OperationState &state, Value condition, "
       "Block *trueBlock, ValueRange trueArguments, "
       "Block *falseBlock, ValueRange falseArguments, "
       "Optional<std::pair<uint32_t, uint32_t>> weights = {}",
       [{
-        state.addOperands(condition);
-        state.addSuccessor(trueBlock, trueArguments);
-        state.addSuccessor(falseBlock, falseArguments);
+        ArrayAttr weightsAttr;
         if (weights) {
-          auto attr =
+          weightsAttr =
               builder->getI32ArrayAttr({static_cast<int32_t>(weights->first),
                                         static_cast<int32_t>(weights->second)});
-          state.addAttribute("branch_weights", attr);
         }
+        build(builder, state, condition, trueArguments, falseArguments,
+              weightsAttr, trueBlock, falseBlock);
       }]
     >
   ];
 
-  let skipDefaultBuilders = 1;
-
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
     /// Branch indices into the successor list.
     enum { kTrueIndex = 0, kFalseIndex = 1 };
 
     /// Returns the target block for the true branch.
     Block *getTrueBlock() { return getOperation()->getSuccessor(kTrueIndex); }
 
     /// Returns the target block for the false branch.
     Block *getFalseBlock() { return getOperation()->getSuccessor(kFalseIndex); }
 
     /// Returns the number of arguments to the true target block.
     unsigned getNumTrueBlockArguments() {
-      return getNumSuccessorOperands(kTrueIndex);
+      return trueTargetOperands().size();
     }
 
     /// Returns the number of arguments to the false target block.
     unsigned getNumFalseBlockArguments() {
-      return getNumSuccessorOperands(kFalseIndex);
+      return falseTargetOperands().size();
     }
 
     // Iterator and range support for true target block arguments.
-    operand_iterator true_block_argument_begin() {
-      return operand_begin() + getTrueBlockArgumentIndex();
-    }
-    operand_iterator true_block_argument_end() {
-      return true_block_argument_begin() + getNumTrueBlockArguments();
-    }
     operand_range getTrueBlockArguments() {
-      return {true_block_argument_begin(), true_block_argument_end()};
+      return trueTargetOperands();
     }
 
     // Iterator and range support for false target block arguments.
-    operand_iterator false_block_argument_begin() {
-      return true_block_argument_end();
-    }
-    operand_iterator false_block_argument_end() {
-      return false_block_argument_begin() + getNumFalseBlockArguments();
-    }
     operand_range getFalseBlockArguments() {
-      return {false_block_argument_begin(), false_block_argument_end()};
+      return falseTargetOperands();
     }
 
   private:
     /// Gets the index of the first true block argument in the operand list.
     unsigned getTrueBlockArgumentIndex() {
       return 1; // Omit the first argument, which is the condition.
     }
 

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

let description = [{
     the block successor. For example:
 
       ^bb2:
         %2 = call @someFn()
         br ^bb3(%2 : tensor<*xf32>)
       ^bb3(%3: tensor<*xf32>):
   }];
 
+  let arguments = (ins Variadic<AnyType>:$destOperands);
   let successors = (successor AnySuccessor:$dest);
 
-  let builders = [OpBuilder<"Builder *, OperationState &result, Block *dest", [{
-    result.addSuccessor(dest, llvm::None);
+  let builders = [OpBuilder<"Builder *, OperationState &result, Block *dest, "
+                            "ValueRange destOperands = {}", [{
+    result.addSuccessors(dest);
+    result.addOperands(destOperands);
   }]>];
 
   // BranchOp is fully verified by traits.
   let verifier = ?;
 
   let extraClassDeclaration = [{
     Block *getDest();
     void setDest(Block *block);
 
     /// Erase the operand at 'index' from the operand list.
     void eraseOperand(unsigned index);
   }];
 
   let hasCanonicalizer = 1;
-  let assemblyFormat = "$dest attr-dict";
+  let assemblyFormat = [{
+    $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict
+  }];
 }
 
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
 def CallOp : Std_Op<"call", [CallOpInterface]> {
   let summary = "call operation";
def CmpIOp : Std_Op<"cmpi",
   let assemblyFormat = "$predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs)";
 }
 
 //===----------------------------------------------------------------------===//
 // CondBranchOp
 //===----------------------------------------------------------------------===//
 
 def CondBranchOp : Std_Op<"cond_br",
-    [DeclareOpInterfaceMethods<BranchOpInterface>, Terminator]> {
+    [AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
+     Terminator]> {
   let summary = "conditional branch operation";
   let description = [{
     The "cond_br" operation represents a conditional branch operation in a
     function. The operation takes variable number of operands and produces
     no results. The operand number and types for each successor must match the
     arguments of the block successor. For example:
 
       ^bb0:
          %0 = extract_element %arg0[] : tensor<i1>
          cond_br %0, ^bb1, ^bb2
       ^bb1:
          ...
       ^bb2:
          ...
   }];
 
-  let arguments = (ins I1:$condition);
+  let arguments = (ins I1:$condition,
+                       Variadic<AnyType>:$trueDestOperands,
+                       Variadic<AnyType>:$falseDestOperands);
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
 
+  let builders = [OpBuilder<
+    "Builder *builder, OperationState &result, Value condition,"
+    "Block *trueDest, ValueRange trueOperands,"
+    "Block *falseDest, ValueRange falseOperands", [{
+      build(builder, result, condition, trueOperands, falseOperands, trueDest,
+            falseDest);
+  }]>, OpBuilder<
+    "Builder *builder, OperationState &result, Value condition,"
+    "Block *trueDest, Block *falseDest, ValueRange falseOperands = {}", [{
+      build(builder, result, condition, trueDest, ValueRange(), falseDest,
+            falseOperands);
+  }]>];
+
   // CondBranchOp is fully verified by traits.
   let verifier = ?;
 
   let extraClassDeclaration = [{
     // These are the indices into the dests list.
     enum { trueIndex = 0, falseIndex = 1 };
 
     // The condition operand is the first operand in the list.
Value getTrueOperand(unsigned idx) {
       return getOperand(getTrueDestOperandIndex() + idx);
     }
 
     void setTrueOperand(unsigned idx, Value value) {
       assert(idx < getNumTrueOperands());
       setOperand(getTrueDestOperandIndex() + idx, value);
     }
 
-    operand_iterator true_operand_begin() {
-      return operand_begin() + getTrueDestOperandIndex();
-    }
-    operand_iterator true_operand_end() {
-      return true_operand_begin() + getNumTrueOperands();
-    }
-    operand_range getTrueOperands() {
-      return {true_operand_begin(), true_operand_end()};
-    }
+    operand_range getTrueOperands() { return trueDestOperands(); }
 
-    unsigned getNumTrueOperands()  {
-      return getNumSuccessorOperands(trueIndex);
-    }
+    unsigned getNumTrueOperands()  { return getTrueOperands().size(); }
 
     /// Erase the operand at 'index' from the true operand list.
     void eraseTrueOperand(unsigned index)  {
-      getOperation()->eraseSuccessorOperand(trueIndex, index);
+      eraseSuccessorOperand(trueIndex, index);
     }
 
     // Accessors for operands to the 'false' destination.
     Value getFalseOperand(unsigned idx) {
       assert(idx < getNumFalseOperands());
       return getOperand(getFalseDestOperandIndex() + idx);
     }
     void setFalseOperand(unsigned idx, Value value) {
       assert(idx < getNumFalseOperands());
       setOperand(getFalseDestOperandIndex() + idx, value);
     }
 
-    operand_iterator false_operand_begin() { return true_operand_end(); }
-    operand_iterator false_operand_end() {
-      return false_operand_begin() + getNumFalseOperands();
-    }
-    operand_range getFalseOperands() {
-      return {false_operand_begin(), false_operand_end()};
-    }
+    operand_range getFalseOperands() { return falseDestOperands(); }
 
-    unsigned getNumFalseOperands() {
-      return getNumSuccessorOperands(falseIndex);
-    }
+    unsigned getNumFalseOperands() { return getFalseOperands().size(); }
 
     /// Erase the operand at 'index' from the false operand list.
     void eraseFalseOperand(unsigned index) {
-      getOperation()->eraseSuccessorOperand(falseIndex, index);
+      eraseSuccessorOperand(falseIndex, index);
     }
 
   private:
     /// Get the index of the first true destination operand.
     unsigned getTrueDestOperandIndex() { return 1; }
 
     /// Get the index of the first false destination operand.
     unsigned getFalseDestOperandIndex() {
       return getTrueDestOperandIndex() + getNumTrueOperands();
     }
   }];
 
   let hasCanonicalizer = 1;
-  let assemblyFormat = "$condition `,` successors attr-dict";
+  let assemblyFormat = [{
+    $condition `,`
+    $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
+    $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
+    attr-dict
+  }];
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 def ConstantOp : Std_Op<"constant",
     [NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {

mlir/include/mlir/IR/OpDefinition.h

 public:
   static AbstractOperation::OperationProperties getTraitProperties() {
     return static_cast<AbstractOperation::OperationProperties>(
         OperationProperty::Terminator);
   }
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyIsTerminator(op);
   }
-
-  unsigned getNumSuccessorOperands(unsigned index) {
-    return this->getOperation()->getNumSuccessorOperands(index);
-  }
 };
 
 /// This class provides verification for ops that are known to have zero
 /// successors.
 template <typename ConcreteType>
 class ZeroSuccessor : public TraitBase<ConcreteType, ZeroSuccessor> {
 public:
   static LogicalResult verifyTrait(Operation *op) {

mlir/include/mlir/IR/OpImplementation.h

public:
   }
   virtual void printType(Type type) = 0;
   virtual void printAttribute(Attribute attr) = 0;
 
   /// Print the given attribute without its type. The corresponding parser must
   /// provide a valid type for the attribute.
   virtual void printAttributeWithoutType(Attribute attr) = 0;
 
-  /// Print a successor, and use list, of a terminator operation given the
-  /// terminator and the successor index.
-  virtual void printSuccessorAndUseList(Operation *term, unsigned index) = 0;
+  /// Print the given successor.
+  virtual void printSuccessor(Block *successor) = 0;
+
+  /// Print the successor and its operands.
+  virtual void printSuccessorAndUseList(Block *successor,
+                                        ValueRange succOperands) = 0;
 
   /// If the specified operation has attributes, print out an attribute
   /// dictionary with their values.  elidedAttrs allows the client to ignore
   /// specific well known attributes, commonly used if the attribute value is
   /// printed some other way (like as a fixed operand).
   virtual void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                                      ArrayRef<StringRef> elidedAttrs = {}) = 0;
 
if (wrapped)
       os << '(';
     interleaveComma(types, *this);
     if (wrapped)
       os << ')';
   }
 
   /// Print the complete type of an operation in functional form.
   void printFunctionalType(Operation *op) {
-    printFunctionalType(op->getNonSuccessorOperands().getTypes(),
-                        op->getResultTypes());
+    printFunctionalType(op->getOperandTypes(), op->getResultTypes());
   }
   /// Print the two given type ranges in a functional form.
   template <typename InputRangeT, typename ResultRangeT>
   void printFunctionalType(InputRangeT &&inputs, ResultRangeT &&results) {
     auto &os = getStream();
     os << "(";
     interleaveComma(inputs, *this);
     os << ")";
inline OpAsmPrinter &operator<<(OpAsmPrinter &p, const T &other) {
   p.getStream() << other;
   return p;
 }
 
 inline OpAsmPrinter &operator<<(OpAsmPrinter &p, bool value) {
   return p << (value ? StringRef("true") : "false");
 }
 
+inline OpAsmPrinter &operator<<(OpAsmPrinter &p, Block *value) {
+  p.printSuccessor(value);
+  return p;
+}
+
 template <typename ValueRangeT>
 inline OpAsmPrinter &operator<<(OpAsmPrinter &p,
                                 const ValueTypeRange<ValueRangeT> &types) {
   interleaveComma(types, p);
   return p;
 }
 inline OpAsmPrinter &operator<<(OpAsmPrinter &p, ArrayRef<Type> types) {
   interleaveComma(types, p);
public:
 
   /// Parse a region argument if present.
   virtual ParseResult parseOptionalRegionArgument(OperandType &argument) = 0;
 
   //===--------------------------------------------------------------------===//
   // Successor Parsing
   //===--------------------------------------------------------------------===//
 
+  /// Parse a single operation successor.
+  virtual ParseResult parseSuccessor(Block *&dest) = 0;
+
+  /// Parse an optional operation successor.
+  virtual OptionalParseResult parseOptionalSuccessor(Block *&dest) = 0;
+
   /// Parse a single operation successor and its operand list.
   virtual ParseResult
   parseSuccessorAndUseList(Block *&dest, SmallVectorImpl<Value> &operands) = 0;
 
-  /// Parse an optional operation successor and its operand list.
-  virtual OptionalParseResult
-  parseOptionalSuccessorAndUseList(Block *&dest,
-                                   SmallVectorImpl<Value> &operands) = 0;
-
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   virtual ParseResult parseType(Type &result) = 0;
 
   /// Parse a type of a specific type.

mlir/include/mlir/IR/Operation.h

public:
 
   /// Returns the region held by this operation at position 'index'.
   Region &getRegion(unsigned index) {
     assert(index < numRegions && "invalid region index");
     return getRegions()[index];
   }
 
   //===--------------------------------------------------------------------===//
-  // Terminators
+  // Successors
   //===--------------------------------------------------------------------===//
 
   MutableArrayRef<BlockOperand> getBlockOperands() {
     return {getTrailingObjects<BlockOperand>(), numSuccs};
   }
 
   // Successor iteration.
   using succ_iterator = SuccessorRange::iterator;
   succ_iterator successor_begin() { return getSuccessors().begin(); }
   succ_iterator successor_end() { return getSuccessors().end(); }
   SuccessorRange getSuccessors() { return SuccessorRange(this); }
 
-  /// Return the operands of this operation that are *not* successor arguments.
-  operand_range getNonSuccessorOperands();
-
-  operand_range getSuccessorOperands(unsigned index);
-
-  Value getSuccessorOperand(unsigned succIndex, unsigned opIndex) {
-    assert(!isKnownNonTerminator() && "only terminators may have successors");
-    assert(opIndex < getNumSuccessorOperands(succIndex));
-    return getOperand(getSuccessorOperandIndex(succIndex) + opIndex);
-  }
-
   bool hasSuccessors() { return numSuccs != 0; }
   unsigned getNumSuccessors() { return numSuccs; }
-  unsigned getNumSuccessorOperands(unsigned index) {
-    assert(!isKnownNonTerminator() && "only terminators may have successors");
-    assert(index < getNumSuccessors());
-    return getBlockOperands()[index].numSuccessorOperands;
-  }
 
   Block *getSuccessor(unsigned index) {
     assert(index < getNumSuccessors());
     return getBlockOperands()[index].get();
   }
   void setSuccessor(Block *block, unsigned index);
 
-  /// Erase a specific operand from the operand list of the successor at
-  /// 'index'.
-  void eraseSuccessorOperand(unsigned succIndex, unsigned opIndex) {
-    assert(succIndex < getNumSuccessors());
-    assert(opIndex < getNumSuccessorOperands(succIndex));
-    getOperandStorage().eraseOperand(getSuccessorOperandIndex(succIndex) +
-                                     opIndex);
-    --getBlockOperands()[succIndex].numSuccessorOperands;
-  }
-
-  /// Get the index of the first operand of the successor at the provided
-  /// index.
-  unsigned getSuccessorOperandIndex(unsigned index);
-
-  /// Return a pair (successorIndex, successorArgIndex) containing the index
-  /// of the successor that `operandIndex` belongs to and the index of the
-  /// argument to that successor that `operandIndex` refers to.
-  ///
-  /// If `operandIndex` is not a successor operand, None is returned.
-  Optional<std::pair<unsigned, unsigned>>
-  decomposeSuccessorOperandIndex(unsigned operandIndex);
-
-  /// Returns the `BlockArgument` corresponding to operand `operandIndex` in
-  /// some successor, or None if `operandIndex` isn't a successor operand index.
-  Optional<BlockArgument> getSuccessorBlockArgument(unsigned operandIndex) {
-    auto decomposed = decomposeSuccessorOperandIndex(operandIndex);
-    if (!decomposed.hasValue())
-      return None;
-    return getSuccessor(decomposed->first)->getArgument(decomposed->second);
-  }
-
   //===--------------------------------------------------------------------===//
   // Accessors for various properties of operations
   //===--------------------------------------------------------------------===//
 
   /// Returns whether the operation is commutative.
   bool isCommutative() {
     if (auto *absOp = getAbstractOperation())
       return absOp->hasProperty(OperationProperty::Commutative);

mlir/include/mlir/IR/OperationSupport.h

 class OpAsmPrinter;
 class OperandRange;
 class OpFoldResult;
 class ParseResult;
 class Pattern;
 class Region;
 class ResultRange;
 class RewritePattern;
+class SuccessorRange;
 class Type;
 class Value;
 class ValueRange;
 template <typename ValueRangeT> class ValueTypeRange;
 
 /// This is an adaptor from a list of values to named operands of OpTy.  In a
 /// generic operation context, e.g., in dialect conversions, an ordered array of
 /// `Value`s is treated as operands of `OpTy`.  This adaptor takes a reference
void addAttribute(Identifier name, Attribute attr) {
     attributes.push_back({name, attr});
   }
 
   /// Add an array of named attributes.
   void addAttributes(ArrayRef<NamedAttribute> newAttributes) {
     attributes.append(newAttributes.begin(), newAttributes.end());
   }
 
-  void addSuccessor(Block *successor, ValueRange succOperands);
+  /// Add an array of successors.
+  void addSuccessors(ArrayRef<Block *> newSuccessors) {
+    successors.append(newSuccessors.begin(), newSuccessors.end());
+  }
+  void addSuccessors(Block *successor) { successors.push_back(successor); }
+  void addSuccessors(SuccessorRange newSuccessors);
 
   /// Create a region that should be attached to the operation.  These regions
   /// can be filled in immediately without waiting for Operation to be
   /// created.  When it is, the region bodies will be transferred.
   Region *addRegion();
 
   /// Take a region that should be attached to the Operation.  The body of the
   /// region will be transferred when the Operation is constructed.  If the

mlir/include/mlir/IR/UseDefLists.h

 public:
   using IROperand<BlockOperand, Block *>::IROperand;
 
   /// Provide the use list that is attached to the given block.
   static IRObjectWithUseList<BlockOperand> *getUseList(Block *value);
 
   /// Return which operand this is in the operand list of the User.
   unsigned getOperandNumber();
-
-private:
-  /// The number of OpOperands that correspond with this block operand.
-  unsigned numSuccessorOperands = 0;
-
-  /// Allow access to 'numSuccessorOperands'.
-  friend Operation;
 };
 
 //===----------------------------------------------------------------------===//
 // OpOperand
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// This class provides an opaque type erased wrapper around a `Value`.

mlir/include/mlir/Transforms/DialectConversion.h

public:
   /// canonical name of the first operation matched by the pattern.
   ConversionPattern(StringRef rootName, PatternBenefit benefit,
                     MLIRContext *ctx)
       : RewritePattern(rootName, benefit, ctx) {}
 
   /// Hook for derived classes to implement rewriting. `op` is the (first)
   /// operation matched by the pattern, `operands` is a list of rewritten values
   /// that are passed to this operation, `rewriter` can be used to emit the new
-  /// operations. This function must be reimplemented if the
-  /// ConversionPattern ever needs to replace an operation that does not
-  /// have successors. This function should not fail. If some specific cases of
+  /// operations. This function should not fail. If some specific cases of
   /// the operation are not supported, these cases should not be matched.
   virtual void rewrite(Operation *op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("unimplemented rewrite");
   }
 
-  /// Hook for derived classes to implement rewriting. `op` is the (first)
-  /// operation matched by the pattern, `properOperands` is a list of rewritten
-  /// values that are passed to the operation itself, `destinations` is a list
-  /// of (potentially rewritten) successor blocks, `operands` is a list of lists
-  /// of rewritten values passed to each of the successors, co-indexed with
-  /// `destinations`, `rewriter` can be used to emit the new operations. It must
-  /// be reimplemented if the ConversionPattern ever needs to replace a
-  /// terminator operation that has successors. This function should not fail
-  /// the pass. If some specific cases of the operation are not supported,
-  /// these cases should not be matched.
-  virtual void rewrite(Operation *op, ArrayRef<Value> properOperands,
-                       ArrayRef<Block *> destinations,
-                       ArrayRef<ArrayRef<Value>> operands,
-                       ConversionPatternRewriter &rewriter) const {
-    llvm_unreachable("unimplemented rewrite for terminators");
-  }
-
-  /// Hook for derived classes to implement combined matching and rewriting.
-  virtual PatternMatchResult
-  matchAndRewrite(Operation *op, ArrayRef<Value> properOperands,
-                  ArrayRef<Block *> destinations,
-                  ArrayRef<ArrayRef<Value>> operands,
-                  ConversionPatternRewriter &rewriter) const {
-    if (!match(op))
-      return matchFailure();
-    rewrite(op, properOperands, destinations, operands, rewriter);
-    return matchSuccess();
-  }
-
   /// Hook for derived classes to implement combined matching and rewriting.
   virtual PatternMatchResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (!match(op))
       return matchFailure();
     rewrite(op, operands, rewriter);
     return matchSuccess();
OpConversionPattern(MLIRContext *context, PatternBenefit benefit = 1)
       : ConversionPattern(SourceOp::getOperationName(), benefit, context) {}
 
   /// Wrappers around the ConversionPattern methods that pass the derived op
   /// type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
     rewrite(cast<SourceOp>(op), operands, rewriter);
   }
-  void rewrite(Operation *op, ArrayRef<Value> properOperands,
-               ArrayRef<Block *> destinations,
-               ArrayRef<ArrayRef<Value>> operands,
-               ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), properOperands, destinations, operands,
-            rewriter);
-  }
-  PatternMatchResult
-  matchAndRewrite(Operation *op, ArrayRef<Value> properOperands,
-                  ArrayRef<Block *> destinations,
-                  ArrayRef<ArrayRef<Value>> operands,
-                  ConversionPatternRewriter &rewriter) const final {
-    return matchAndRewrite(cast<SourceOp>(op), properOperands, destinations,
-                           operands, rewriter);
-  }
   PatternMatchResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     return matchAndRewrite(cast<SourceOp>(op), operands, rewriter);
   }
 
   // TODO(b/142763075): Use OperandAdaptor when it supports access to unnamed
   // operands.
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override matchAndRewrite or a rewrite method");
   }
 
-  virtual void rewrite(SourceOp op, ArrayRef<Value> properOperands,
-                       ArrayRef<Block *> destinations,
-                       ArrayRef<ArrayRef<Value>> operands,
-                       ConversionPatternRewriter &rewriter) const {
-    llvm_unreachable("unimplemented rewrite for terminators");
-  }
-
-  virtual PatternMatchResult
-  matchAndRewrite(SourceOp op, ArrayRef<Value> properOperands,
-                  ArrayRef<Block *> destinations,
-                  ArrayRef<ArrayRef<Value>> operands,
-                  ConversionPatternRewriter &rewriter) const {
-    if (!match(op))
-      return matchFailure();
-    rewrite(op, properOperands, destinations, operands, rewriter);
-    return matchSuccess();
-  }
-
   virtual PatternMatchResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (!match(op))
       return matchFailure();
     rewrite(op, operands, rewriter);
     return matchSuccess();
   }

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

return AccumulatorFactory([&](Location loc, Value lhs, Value rhs,
       BlockAndValueMapping mapping;
       mapping.map(body.front().getArgument(0), lhs);
       mapping.map(body.front().getArgument(1), rhs);
       rewriter.cloneRegionBefore(body, *split->getParent(),
                                  split->getIterator(), mapping);
 
       // Add branch before inserted body, into body.
       block = block->getNextNode();
-      rewriter.create<LLVM::BrOp>(loc, ArrayRef<Value>{},
-                                  llvm::makeArrayRef(block), ValueRange());
+      rewriter.create<LLVM::BrOp>(loc, ValueRange(), block);
 
       // Replace all gpu.yield ops with branch out of body.
       for (; block != split; block = block->getNextNode()) {
         Operation *terminator = block->getTerminator();
         if (!llvm::isa<gpu::YieldOp>(terminator))
           continue;
         rewriter.setInsertionPointToEnd(block);
         rewriter.replaceOpWithNewOp<LLVM::BrOp>(
-            terminator, ArrayRef<Value>{}, llvm::makeArrayRef(split),
-            ValueRange(terminator->getOperand(0)));
+            terminator, terminator->getOperand(0), split);
       }
 
       // Return accumulator result.
       rewriter.setInsertionPointToStart(split);
       return split->addArgument(lhs.getType());
     });
   }
 
void createIf(Location loc, ConversionPatternRewriter &rewriter,
     Block *currentBlock = rewriter.getInsertionBlock();
     auto currentPoint = rewriter.getInsertionPoint();
 
     Block *thenBlock = rewriter.splitBlock(currentBlock, currentPoint);
     Block *elseBlock = rewriter.splitBlock(thenBlock, thenBlock->begin());
     Block *continueBlock = rewriter.splitBlock(elseBlock, elseBlock->begin());
 
     rewriter.setInsertionPointToEnd(currentBlock);
-    rewriter.create<LLVM::CondBrOp>(loc, llvm::makeArrayRef(condition),
-                                    ArrayRef<Block *>{thenBlock, elseBlock});
+    rewriter.create<LLVM::CondBrOp>(loc, condition, thenBlock, elseBlock);
 
     auto addBranch = [&](ValueRange operands) {
-      rewriter.create<LLVM::BrOp>(loc, ArrayRef<Value>{},
-                                  llvm::makeArrayRef(continueBlock),
-                                  llvm::makeArrayRef(operands));
+      rewriter.create<LLVM::BrOp>(loc, operands, continueBlock);
     };
 
     rewriter.setInsertionPointToStart(thenBlock);
     auto thenOperands = thenOpsFactory();
     addBranch(thenOperands);
 
     rewriter.setInsertionPointToStart(elseBlock);
     auto elseOperands = elseOpsFactory();
struct GPUReturnOpLowering : public ConvertToLLVMPattern {
   GPUReturnOpLowering(LLVMTypeConverter &typeConverter)
       : ConvertToLLVMPattern(gpu::ReturnOp::getOperationName(),
                              typeConverter.getDialect()->getContext(),
                              typeConverter) {}
 
   PatternMatchResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands,
-                                                ArrayRef<Block *>());
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands);
     return matchSuccess();
   }
 };
 
 /// Import the GPU Ops to NVVM Patterns.
 #include "GPUToNVVM.cpp.inc"
 
 /// A pass that replaces all occurrences of GPU device operations with their

mlir/lib/Conversion/StandardToLLVM/ConvertStandardToLLVM.cpp

 // Base class for LLVM IR lowering terminator operations with successors.
 template <typename SourceOp, typename TargetOp>
 struct OneToOneLLVMTerminatorLowering
     : public LLVMLegalizationPattern<SourceOp> {
   using LLVMLegalizationPattern<SourceOp>::LLVMLegalizationPattern;
   using Super = OneToOneLLVMTerminatorLowering<SourceOp, TargetOp>;
 
   PatternMatchResult
-  matchAndRewrite(Operation *op, ArrayRef<Value> properOperands,
-                  ArrayRef<Block *> destinations,
-                  ArrayRef<ArrayRef<Value>> operands,
-                  ConversionPatternRewriter &rewriter) const override {
-    SmallVector<ValueRange, 2> operandRanges(operands.begin(), operands.end());
-    rewriter.replaceOpWithNewOp<TargetOp>(op, properOperands, destinations,
-                                          operandRanges, op->getAttrs());
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<TargetOp>(op, operands, op->getSuccessors(),
+                                          op->getAttrs());
     return this->matchSuccess();
   }
 };
 
 // Special lowering pattern for `ReturnOps`.  Unlike all other operations,
 // `ReturnOp` interacts with the function signature and must have as many
 // operands as the function has return values.  Because in LLVM IR, functions
 // can only return 0 or 1 value, we pack multiple values into a structure type.
 // Emit `UndefOp` followed by `InsertValueOp`s to create such structure if
 // necessary before returning it
 struct ReturnOpLowering : public LLVMLegalizationPattern<ReturnOp> {
   using LLVMLegalizationPattern<ReturnOp>::LLVMLegalizationPattern;
 
   PatternMatchResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     unsigned numArguments = op->getNumOperands();
 
     // If ReturnOp has 0 or 1 operand, create it and return immediately.
     if (numArguments == 0) {
       rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(
-          op, ArrayRef<Value>(), ArrayRef<Block *>(), op->getAttrs());
+          op, ArrayRef<Type>(), ArrayRef<Value>(), op->getAttrs());
       return matchSuccess();
     }
     if (numArguments == 1) {
       rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(
-          op, ArrayRef<Value>(operands.front()), ArrayRef<Block *>(),
-          op->getAttrs());
+          op, ArrayRef<Type>(), operands.front(), op->getAttrs());
       return matchSuccess();
     }
 
     // Otherwise, we need to pack the arguments into an LLVM struct type before
     // returning.
     auto packedType = typeConverter.packFunctionResults(
         llvm::to_vector<4>(op->getOperandTypes()));
 
     Value packed = rewriter.create<LLVM::UndefOp>(op->getLoc(), packedType);
     for (unsigned i = 0; i < numArguments; ++i) {
       packed = rewriter.create<LLVM::InsertValueOp>(
           op->getLoc(), packedType, packed, operands[i],
           rewriter.getI64ArrayAttr(i));
     }
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(
-        op, llvm::makeArrayRef(packed), ArrayRef<Block *>(), op->getAttrs());
+    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, ArrayRef<Type>(), packed,
+                                                op->getAttrs());
     return matchSuccess();
   }
 };
 
 // FIXME: this should be tablegen'ed as well.
 struct BranchOpLowering
     : public OneToOneLLVMTerminatorLowering<BranchOp, LLVM::BrOp> {
   using Super::Super;
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto loopPosition = rewriter.getInsertionPoint();
     auto *endBlock = rewriter.splitBlock(loopBlock, loopPosition);
 
     // Compute the loaded value and branch to the loop block.
     rewriter.setInsertionPointToEnd(initBlock);
     auto memRefType = atomicOp.getMemRefType();
     auto dataPtr = getDataPtr(loc, memRefType, adaptor.memref(),
                               adaptor.indices(), rewriter, getModule());
-    auto init = rewriter.create<LLVM::LoadOp>(loc, dataPtr);
-    std::array<Value, 1> brRegionOperands{init};
-    std::array<ValueRange, 1> brOperands{brRegionOperands};
-    rewriter.create<LLVM::BrOp>(loc, ArrayRef<Value>{}, loopBlock, brOperands);
+    Value init = rewriter.create<LLVM::LoadOp>(loc, dataPtr);
+    rewriter.create<LLVM::BrOp>(loc, init, loopBlock);
 
     // Prepare the body of the loop block.
     rewriter.setInsertionPointToStart(loopBlock);
     auto predicateI64 =
         rewriter.getI64IntegerAttr(static_cast<int64_t>(predicate));
     auto boolType = LLVM::LLVMType::getInt1Ty(&getDialect());
     auto lhs = loopArgument;
     auto rhs = adaptor.value();
     auto cmp =
         rewriter.create<LLVM::FCmpOp>(loc, boolType, predicateI64, lhs, rhs);
     auto select = rewriter.create<LLVM::SelectOp>(loc, cmp, lhs, rhs);
 
     // Prepare the epilog of the loop block.
     rewriter.setInsertionPointToEnd(loopBlock);
     // Append the cmpxchg op to the end of the loop block.
     auto successOrdering = LLVM::AtomicOrdering::acq_rel;
     auto failureOrdering = LLVM::AtomicOrdering::monotonic;
     auto pairType = LLVM::LLVMType::getStructTy(valueType, boolType);
     auto cmpxchg = rewriter.create<LLVM::AtomicCmpXchgOp>(
         loc, pairType, dataPtr, loopArgument, select, successOrdering,
         failureOrdering);
     // Extract the %new_loaded and %ok values from the pair.
-    auto newLoaded = rewriter.create<LLVM::ExtractValueOp>(
+    Value newLoaded = rewriter.create<LLVM::ExtractValueOp>(
         loc, valueType, cmpxchg, rewriter.getI64ArrayAttr({0}));
-    auto ok = rewriter.create<LLVM::ExtractValueOp>(
+    Value ok = rewriter.create<LLVM::ExtractValueOp>(
         loc, boolType, cmpxchg, rewriter.getI64ArrayAttr({1}));
 
     // Conditionally branch to the end or back to the loop depending on %ok.
-    std::array<Value, 1> condBrProperOperands{ok};
-    std::array<Block *, 2> condBrDestinations{endBlock, loopBlock};
-    std::array<Value, 1> condBrRegionOperands{newLoaded};
-    std::array<ValueRange, 2> condBrOperands{ArrayRef<Value>{},
-                                             condBrRegionOperands};
-    rewriter.create<LLVM::CondBrOp>(loc, condBrProperOperands,
-                                    condBrDestinations, condBrOperands);
+    rewriter.create<LLVM::CondBrOp>(loc, ok, endBlock, ArrayRef<Value>(),
+                                    loopBlock, newLoaded);
 
     // The 'result' of the atomic_rmw op is the newly loaded value.
     rewriter.replaceOp(op, {newLoaded});
 
     return matchSuccess();
   }
 };
 

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

static ParseResult parseStoreOp(OpAsmParser &parser, OperationState &result) {
 
   if (parser.resolveOperand(value, elemTy, result.operands) ||
       parser.resolveOperand(addr, type, result.operands))
     return failure();
 
   return success();
 }
 
-///===----------------------------------------------------------------------===//
+///===---------------------------------------------------------------------===//
 /// LLVM::InvokeOp
-///===----------------------------------------------------------------------===//
+///===---------------------------------------------------------------------===//
 
 Optional<OperandRange> InvokeOp::getSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
   return index == 0 ? normalDestOperands() : unwindDestOperands();
 }
 
 bool InvokeOp::canEraseSuccessorOperand() { return true; }
 
static LogicalResult verify(InvokeOp op) {
   // In unwind destination, first operation must be LandingpadOp
   if (!isa<LandingpadOp>(unwindDest->front()))
     return op.emitError("first operation in unwind destination should be a "
                         "llvm.landingpad operation");
 
   return success();
 }
 
-static void printInvokeOp(OpAsmPrinter &p, InvokeOp &op) {
+static void printInvokeOp(OpAsmPrinter &p, InvokeOp op) {
   auto callee = op.callee();
   bool isDirect = callee.hasValue();
 
   p << op.getOperationName() << ' ';
 
   // Either function name or pointer
   if (isDirect)
     p.printSymbolName(callee.getValue());
   else
     p << op.getOperand(0);
 
   p << '(' << op.getOperands().drop_front(isDirect ? 0 : 1) << ')';
   p << " to ";
-  p.printSuccessorAndUseList(op.getOperation(), 0);
+  p.printSuccessorAndUseList(op.normalDest(), op.normalDestOperands());
   p << " unwind ";
-  p.printSuccessorAndUseList(op.getOperation(), 1);
-
-  p.printOptionalAttrDict(op.getAttrs(), {"callee"});
-
-  SmallVector<Type, 8> argTypes(
-      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
+  p.printSuccessorAndUseList(op.unwindDest(), op.unwindDestOperands());
 
-  p << " : "
-    << FunctionType::get(argTypes, op.getResultTypes(), op.getContext());
+  p.printOptionalAttrDict(op.getAttrs(),
+                          {InvokeOp::getOperandSegmentSizeAttr(), "callee"});
+  p << " : ";
+  p.printFunctionalType(
+      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1),
+      op.getResultTypes());
 }
 
 /// <operation> ::= `llvm.invoke` (function-id | ssa-use) `(` ssa-use-list `)`
 ///                  `to` bb-id (`[` ssa-use-and-type-list `]`)?
 ///                  `unwind` bb-id (`[` ssa-use-and-type-list `]`)?
 ///                  attribute-dict? `:` function-type
 static ParseResult parseInvokeOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> operands;
   FunctionType funcType;
   SymbolRefAttr funcAttr;
   llvm::SMLoc trailingTypeLoc;
   Block *normalDest, *unwindDest;
   SmallVector<Value, 4> normalOperands, unwindOperands;
+  Builder &builder = parser.getBuilder();
 
   // Parse an operand list that will, in practice, contain 0 or 1 operand.  In
   // case of an indirect call, there will be 1 operand before `(`.  In case of a
   // direct call, there will be no operands and the parser will stop at the
   // function identifier without complaining.
   if (parser.parseOperandList(operands))
     return failure();
   bool isDirect = operands.empty();
if (isDirect) {
     result.addTypes(funcType.getResults());
   } else {
     // Construct the LLVM IR Dialect function type that the first operand
     // should match.
     if (funcType.getNumResults() > 1)
       return parser.emitError(trailingTypeLoc,
                               "expected function with 0 or 1 result");
 
-    Builder &builder = parser.getBuilder();
     auto *llvmDialect =
         builder.getContext()->getRegisteredDialect<LLVM::LLVMDialect>();
     LLVM::LLVMType llvmResultType;
     if (funcType.getNumResults() == 0) {
       llvmResultType = LLVM::LLVMType::getVoidTy(llvmDialect);
     } else {
       llvmResultType = funcType.getResult(0).dyn_cast<LLVM::LLVMType>();
       if (!llvmResultType)
if (isDirect) {
     // match the types of the function arguments.
     if (parser.resolveOperand(operands[0], wrappedFuncType, result.operands) ||
         parser.resolveOperands(funcArguments, funcType.getInputs(),
                                parser.getNameLoc(), result.operands))
       return failure();
 
     result.addTypes(llvmResultType);
   }
-  result.addSuccessor(normalDest, normalOperands);
-  result.addSuccessor(unwindDest, unwindOperands);
+  result.addSuccessors({normalDest, unwindDest});
+  result.addOperands(normalOperands);
+  result.addOperands(unwindOperands);
+
+  result.addAttribute(
+      InvokeOp::getOperandSegmentSizeAttr(),
+      builder.getI32VectorAttr({static_cast<int32_t>(operands.size()),
+                                static_cast<int32_t>(normalOperands.size()),
+                                static_cast<int32_t>(unwindOperands.size())}));
   return success();
 }
 
 ///===----------------------------------------------------------------------===//
 /// Verifying/Printing/Parsing for LLVM::LandingpadOp.
 ///===----------------------------------------------------------------------===//
 
 static LogicalResult verify(LandingpadOp op) {

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 
 bool spirv::BranchConditionalOp::canEraseSuccessorOperand() { return true; }
 
 static ParseResult parseBranchConditionalOp(OpAsmParser &parser,
                                             OperationState &state) {
   auto &builder = parser.getBuilder();
   OpAsmParser::OperandType condInfo;
   Block *dest;
-  SmallVector<Value, 4> destOperands;
 
   // Parse the condition.
   Type boolTy = builder.getI1Type();
   if (parser.parseOperand(condInfo) ||
       parser.resolveOperand(condInfo, boolTy, state.operands))
     return failure();
 
   // Parse the optional branch weights.
   if (succeeded(parser.parseOptionalLSquare())) {
     IntegerAttr trueWeight, falseWeight;
     SmallVector<NamedAttribute, 2> weights;
 
     auto i32Type = builder.getIntegerType(32);
     if (parser.parseAttribute(trueWeight, i32Type, "weight", weights) ||
         parser.parseComma() ||
         parser.parseAttribute(falseWeight, i32Type, "weight", weights) ||
         parser.parseRSquare())
       return failure();
 
     state.addAttribute(kBranchWeightAttrName,
                        builder.getArrayAttr({trueWeight, falseWeight}));
   }
 
   // Parse the true branch.
+  SmallVector<Value, 4> trueOperands;
   if (parser.parseComma() ||
-      parser.parseSuccessorAndUseList(dest, destOperands))
+      parser.parseSuccessorAndUseList(dest, trueOperands))
     return failure();
-  state.addSuccessor(dest, destOperands);
+  state.addSuccessors(dest);
+  state.addOperands(trueOperands);
 
   // Parse the false branch.
-  destOperands.clear();
+  SmallVector<Value, 4> falseOperands;
   if (parser.parseComma() ||
-      parser.parseSuccessorAndUseList(dest, destOperands))
+      parser.parseSuccessorAndUseList(dest, falseOperands))
     return failure();
-  state.addSuccessor(dest, destOperands);
+  state.addSuccessors(dest);
+  state.addOperands(falseOperands);
+  state.addAttribute(
+      spirv::BranchConditionalOp::getOperandSegmentSizeAttr(),
+      builder.getI32VectorAttr({1, static_cast<int32_t>(trueOperands.size()),
+                                static_cast<int32_t>(falseOperands.size())}));
 
   return success();
 }
 
 static void print(spirv::BranchConditionalOp branchOp, OpAsmPrinter &printer) {
   printer << spirv::BranchConditionalOp::getOperationName() << ' '
           << branchOp.condition();
 
   if (auto weights = branchOp.branch_weights()) {
     printer << " [";
     interleaveComma(weights->getValue(), printer, [&](Attribute a) {
       printer << a.cast<IntegerAttr>().getInt();
     });
     printer << "]";
   }
 
   printer << ", ";
-  printer.printSuccessorAndUseList(branchOp.getOperation(),
-                                   spirv::BranchConditionalOp::kTrueIndex);
+  printer.printSuccessorAndUseList(branchOp.getTrueBlock(),
+                                   branchOp.getTrueBlockArguments());
   printer << ", ";
-  printer.printSuccessorAndUseList(branchOp.getOperation(),
-                                   spirv::BranchConditionalOp::kFalseIndex);
+  printer.printSuccessorAndUseList(branchOp.getFalseBlock(),
+                                   branchOp.getFalseBlockArguments());
 }
 
 static LogicalResult verify(spirv::BranchConditionalOp branchOp) {
   if (auto weights = branchOp.branch_weights()) {
     if (weights->getValue().size() != 2) {
       return branchOp.emitOpError("must have exactly two branch weights");
     }
     if (llvm::all_of(*weights, [](Attribute attr) {

mlir/lib/IR/AsmPrinter.cpp

public:
   }
   void printOptionalAttrDictWithKeyword(
       ArrayRef<NamedAttribute> attrs,
       ArrayRef<StringRef> elidedAttrs = {}) override {
     ModulePrinter::printOptionalAttrDict(attrs, elidedAttrs,
                                          /*withKeyword=*/true);
   }
 
+  /// Print the given successor.
+  void printSuccessor(Block *successor) override;
+
   /// Print an operation successor with the operands used for the block
   /// arguments.
-  void printSuccessorAndUseList(Operation *term, unsigned index) override;
+  void printSuccessorAndUseList(Block *successor,
+                                ValueRange succOperands) override;
 
   /// Print the given region.
   void printRegion(Region &region, bool printEntryBlockArgs,
                    bool printBlockTerminators) override;
 
   /// Renumber the arguments for the specified region to the same names as the
   /// SSA values in namesToUse. This may only be used for IsolatedFromAbove
   /// operations. If any entry in namesToUse is null, the corresponding
void OperationPrinter::printOperation(Operation *op) {
   // Otherwise print with the generic assembly form.
   printGenericOp(op);
 }
 
 void OperationPrinter::printGenericOp(Operation *op) {
   os << '"';
   printEscapedString(op->getName().getStringRef(), os);
   os << "\"(";
-
-  // Get the list of operands that are not successor operands.
-  unsigned totalNumSuccessorOperands = 0;
-  unsigned numSuccessors = op->getNumSuccessors();
-  for (unsigned i = 0; i < numSuccessors; ++i)
-    totalNumSuccessorOperands += op->getNumSuccessorOperands(i);
-  unsigned numProperOperands = op->getNumOperands() - totalNumSuccessorOperands;
-  interleaveComma(op->getOperands().take_front(numProperOperands),
-                  [&](Value value) { printValueID(value); });
-
+  interleaveComma(op->getOperands(), [&](Value value) { printValueID(value); });
   os << ')';
 
   // For terminators, print the list of successors and their operands.
-  if (numSuccessors != 0) {
+  if (op->getNumSuccessors() != 0) {
     os << '[';
-    interleaveComma(llvm::seq<unsigned>(0, numSuccessors),
-                    [&](unsigned i) { printSuccessorAndUseList(op, i); });
+    interleaveComma(op->getSuccessors(),
+                    [&](Block *successor) { printBlockName(successor); });
     os << ']';
   }
 
   // Print regions.
   if (op->getNumRegions() != 0) {
     os << " (";
     interleaveComma(op->getRegions(), [&](Region &region) {
       printRegion(region, /*printEntryBlockArgs=*/true,
void OperationPrinter::print(Block *block, bool printBlockArgs,
   }
   currentIndent -= indentWidth;
 }
 
 void OperationPrinter::printValueID(Value value, bool printResultNo) const {
   state->getSSANameState().printValueID(value, printResultNo, os);
 }
 
-void OperationPrinter::printSuccessorAndUseList(Operation *term,
-                                                unsigned index) {
-  printBlockName(term->getSuccessor(index));
+void OperationPrinter::printSuccessor(Block *successor) {
+  printBlockName(successor);
+}
 
-  auto succOperands = term->getSuccessorOperands(index);
-  if (succOperands.begin() == succOperands.end())
+void OperationPrinter::printSuccessorAndUseList(Block *successor,
+                                                ValueRange succOperands) {
+  printBlockName(successor);
+  if (succOperands.empty())
     return;
 
   os << '(';
   interleaveComma(succOperands,
                   [this](Value operand) { printValueID(operand); });
   os << " : ";
   interleaveComma(succOperands,
                   [this](Value operand) { printType(operand.getType()); });

mlir/lib/IR/Operation.cpp

 /// Overload of create that takes an existing NamedAttributeList to avoid
 /// unnecessarily uniquing a list of attributes.
 Operation *Operation::create(Location location, OperationName name,
                              ArrayRef<Type> resultTypes,
                              ArrayRef<Value> operands,
                              NamedAttributeList attributes,
                              ArrayRef<Block *> successors, unsigned numRegions,
                              bool resizableOperandList) {
-  unsigned numSuccessors = successors.size();
-
   // We only need to allocate additional memory for a subset of results.
   unsigned numTrailingResults = OpResult::getNumTrailing(resultTypes.size());
-
-  // Input operands are nullptr-separated for each successor, the null operands
-  // aren't actually stored.
-  unsigned numOperands = operands.size() - numSuccessors;
+  unsigned numSuccessors = successors.size();
+  unsigned numOperands = operands.size();
 
   // Compute the byte size for the operation and the operand storage.
   auto byteSize = totalSizeToAlloc<detail::TrailingOpResult, BlockOperand,
                                    Region, detail::OperandStorage>(
       numTrailingResults, numSuccessors, numRegions,
       /*detail::OperandStorage*/ 1);
   byteSize += llvm::alignTo(detail::OperandStorage::additionalAllocSize(
                                 numOperands, resizableOperandList),
if (LLVM_UNLIKELY(numTrailingResults > 0)) {
     for (unsigned i = 0; i != numTrailingResults; ++i, ++trailingResultIt)
       trailingResultIt->trailingResultNumber = i;
   }
 
   // Initialize the regions.
   for (unsigned i = 0; i != numRegions; ++i)
     new (&op->getRegion(i)) Region(op);
 
-  // Initialize the results and operands.
+  // Initialize the operands.
   new (&op->getOperandStorage())
       detail::OperandStorage(numOperands, resizableOperandList);
   auto opOperands = op->getOpOperands();
+  for (unsigned i = 0; i != numOperands; ++i)
+    new (&opOperands[i]) OpOperand(op, operands[i]);
 
-  // Initialize normal operands.
-  unsigned operandIt = 0, operandE = operands.size();
-  unsigned nextOperand = 0;
-  for (; operandIt != operandE; ++operandIt) {
-    // Null operands are used as sentinels between successor operand lists. If
-    // we encounter one here, break and handle the successor operands lists
-    // separately below.
-    if (!operands[operandIt])
-      break;
-    new (&opOperands[nextOperand++]) OpOperand(op, operands[operandIt]);
-  }
-
-  unsigned currentSuccNum = 0;
-  if (operandIt == operandE) {
-    // Verify that the amount of sentinel operands is equivalent to the number
-    // of successors.
-    assert(currentSuccNum == numSuccessors);
-    return op;
-  }
-
-  assert(!op->isKnownNonTerminator() &&
-         "Unexpected nullptr in operand list when creating non-terminator.");
-  auto instBlockOperands = op->getBlockOperands();
-  unsigned *succOperandCount = nullptr;
-
-  for (; operandIt != operandE; ++operandIt) {
-    // If we encounter a sentinel branch to the next operand update the count
-    // variable.
-    if (!operands[operandIt]) {
-      assert(currentSuccNum < numSuccessors);
-
-      new (&instBlockOperands[currentSuccNum])
-          BlockOperand(op, successors[currentSuccNum]);
-      succOperandCount =
-          &instBlockOperands[currentSuccNum].numSuccessorOperands;
-      ++currentSuccNum;
-      continue;
-    }
-    new (&opOperands[nextOperand++]) OpOperand(op, operands[operandIt]);
-    ++(*succOperandCount);
-  }
-
-  // Verify that the amount of sentinel operands is equivalent to the number of
-  // successors.
-  assert(currentSuccNum == numSuccessors);
+  // Initialize the successors.
+  auto blockOperands = op->getBlockOperands();
+  for (unsigned i = 0; i != numSuccessors; ++i)
+    new (&blockOperands[i]) BlockOperand(op, successors[i]);
 
   return op;
 }
 
 Operation::Operation(Location location, OperationName name,
                      ArrayRef<Type> resultTypes, unsigned numSuccessors,
                      unsigned numRegions, const NamedAttributeList &attributes)
     : location(location), numSuccs(numSuccessors), numRegions(numRegions),
auto Operation::getResultTypes() -> result_type_range {
   return resultType.cast<TupleType>().getTypes();
 }
 
 void Operation::setSuccessor(Block *block, unsigned index) {
   assert(index < getNumSuccessors());
   getBlockOperands()[index].set(block);
 }
 
-auto Operation::getNonSuccessorOperands() -> operand_range {
-  return getOperands().take_front(hasSuccessors() ? getSuccessorOperandIndex(0)
-                                                  : getNumOperands());
-}
-
-/// Get the index of the first operand of the successor at the provided
-/// index.
-unsigned Operation::getSuccessorOperandIndex(unsigned index) {
-  assert(!isKnownNonTerminator() && "only terminators may have successors");
-  assert(index < getNumSuccessors());
-
-  // Count the number of operands for each of the successors after, and
-  // including, the one at 'index'. This is based upon the assumption that all
-  // non successor operands are placed at the beginning of the operand list.
-  auto blockOperands = getBlockOperands().drop_front(index);
-  unsigned postSuccessorOpCount =
-      std::accumulate(blockOperands.begin(), blockOperands.end(), 0u,
-                      [](unsigned cur, const BlockOperand &operand) {
-                        return cur + operand.numSuccessorOperands;
-                      });
-  return getNumOperands() - postSuccessorOpCount;
-}
-
-Optional<std::pair<unsigned, unsigned>>
-Operation::decomposeSuccessorOperandIndex(unsigned operandIndex) {
-  assert(!isKnownNonTerminator() && "only terminators may have successors");
-  assert(operandIndex < getNumOperands());
-  unsigned currentOperandIndex = getNumOperands();
-  auto blockOperands = getBlockOperands();
-  for (unsigned i = 0, e = getNumSuccessors(); i < e; i++) {
-    unsigned successorIndex = e - i - 1;
-    currentOperandIndex -= blockOperands[successorIndex].numSuccessorOperands;
-    if (currentOperandIndex <= operandIndex)
-      return std::make_pair(successorIndex, operandIndex - currentOperandIndex);
-  }
-  return None;
-}
-
-auto Operation::getSuccessorOperands(unsigned index) -> operand_range {
-  unsigned succOperandIndex = getSuccessorOperandIndex(index);
-  return getOperands().slice(succOperandIndex, getNumSuccessorOperands(index));
-}
-
 /// Attempt to fold this operation using the Op's registered foldHook.
 LogicalResult Operation::fold(ArrayRef<Attribute> operands,
                               SmallVectorImpl<OpFoldResult> &results) {
   // If we have a registered operation definition matching this one, use it to
   // try to constant fold the operation.
   auto *abstractOp = getAbstractOperation();
   if (abstractOp && succeeded(abstractOp->foldHook(this, operands, results)))
     return success();

 
 /// Create a deep copy of this operation but keep the operation regions empty.
 /// Operands are remapped using `mapper` (if present), and `mapper` is updated
 /// to contain the results.
 Operation *Operation::cloneWithoutRegions(BlockAndValueMapping &mapper) {
   SmallVector<Value, 8> operands;
   SmallVector<Block *, 2> successors;
 
-  operands.reserve(getNumOperands() + getNumSuccessors());
-
-  if (getNumSuccessors() == 0) {
-    // Non-branching operations can just add all the operands.
-    for (auto opValue : getOperands())
-      operands.push_back(mapper.lookupOrDefault(opValue));
-  } else {
-    // We add the operands separated by nullptr's for each successor.
-    unsigned firstSuccOperand =
-        getNumSuccessors() ? getSuccessorOperandIndex(0) : getNumOperands();
-    auto opOperands = getOpOperands();
-
-    unsigned i = 0;
-    for (; i != firstSuccOperand; ++i)
-      operands.push_back(mapper.lookupOrDefault(opOperands[i].get()));
+  // Remap the operands.
+  operands.reserve(getNumOperands());
 
-    successors.reserve(getNumSuccessors());
-    for (unsigned succ = 0, e = getNumSuccessors(); succ != e; ++succ) {
-      successors.push_back(mapper.lookupOrDefault(getSuccessor(succ)));
-
-      // Add sentinel to delineate successor operands.
-      operands.push_back(nullptr);
-
-      // Remap the successors operands.
-      for (auto operand : getSuccessorOperands(succ))
-        operands.push_back(mapper.lookupOrDefault(operand));
-    }
-  }
+  // Remap the successors.
+  for (Block *successor : getSuccessors())
+    successors.push_back(mapper.lookupOrDefault(successor));
 
-  unsigned numRegions = getNumRegions();
-  auto *newOp =
-      Operation::create(getLoc(), getName(), getResultTypes(), operands, attrs,
-                        successors, numRegions, hasResizableOperandsList());
+  // Create the new operation.
+  auto *newOp = Operation::create(getLoc(), getName(), getResultTypes(),
+                                  operands, attrs, successors, getNumRegions(),
+                                  hasResizableOperandsList());
 
   // Remember the mapping of any results.
   for (unsigned i = 0, e = getNumResults(); i != e; ++i)
     mapper.map(getResult(i), newOp->getResult(i));
 
   return newOp;
 }
 

mlir/lib/IR/OperationSupport.cpp

: location(location), name(name, location->getContext()),
       types(types.begin(), types.end()),
       attributes(attributes.begin(), attributes.end()),
       successors(successors.begin(), successors.end()) {
   for (std::unique_ptr<Region> &r : regions)
     this->regions.push_back(std::move(r));
 }
 
 void OperationState::addOperands(ValueRange newOperands) {
-  assert(successors.empty() && "Non successor operands should be added first.");
   operands.append(newOperands.begin(), newOperands.end());
 }
 
-void OperationState::addSuccessor(Block *successor, ValueRange succOperands) {
-  successors.push_back(successor);
-  // Insert a sentinel operand to mark a barrier between successor operands.
-  operands.push_back(nullptr);
-  operands.append(succOperands.begin(), succOperands.end());
+void OperationState::addSuccessors(SuccessorRange newSuccessors) {
+  successors.append(newSuccessors.begin(), newSuccessors.end());
 }
 
 Region *OperationState::addRegion() {
   regions.emplace_back(new Region);
   return regions.back().get();
 }
 
 void OperationState::addRegion(std::unique_ptr<Region> &&region) {

mlir/lib/Parser/Parser.cpp

public:
 
   //===--------------------------------------------------------------------===//
   // Operation Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse an operation instance.
   ParseResult parseOperation();
 
-  /// Parse a single operation successor and its operand list.
-  ParseResult parseSuccessorAndUseList(Block *&dest,
-                                       SmallVectorImpl<Value> &operands);
+  /// Parse a single operation successor.
+  ParseResult parseSuccessor(Block *&dest);
 
   /// Parse a comma-separated list of operation successors in brackets.
-  ParseResult parseSuccessors(SmallVectorImpl<Block *> &destinations,
-                              SmallVectorImpl<SmallVector<Value, 4>> &operands);
+  ParseResult parseSuccessors(SmallVectorImpl<Block *> &destinations);
 
   /// Parse an operation instance that is in the generic form.
   Operation *parseGenericOperation();
 
   /// Parse an operation instance that is in the generic form and insert it at
   /// the provided insertion point.
   Operation *parseGenericOperation(Block *insertBlock,
                                    Block::iterator insertPt);
for (std::tuple<StringRef, unsigned, SMLoc> &resIt : resultIDs) {
           return failure();
       }
     }
   }
 
   return success();
 }
 
-/// Parse a single operation successor and its operand list.
+/// Parse a single operation successor.
 ///
-///   successor ::= block-id branch-use-list?
-///   branch-use-list ::= `(` ssa-use-list ':' type-list-no-parens `)`
+///   successor ::= block-id
 ///
-ParseResult
-OperationParser::parseSuccessorAndUseList(Block *&dest,
-                                          SmallVectorImpl<Value> &operands) {
+ParseResult OperationParser::parseSuccessor(Block *&dest) {
   // Verify branch is identifier and get the matching block.
   if (!getToken().is(Token::caret_identifier))
     return emitError("expected block name");
   dest = getBlockNamed(getTokenSpelling(), getToken().getLoc());
   consumeToken();
-
-  // Handle optional arguments.
-  if (consumeIf(Token::l_paren) &&
-      (parseOptionalSSAUseAndTypeList(operands) ||
-       parseToken(Token::r_paren, "expected ')' to close argument list"))) {
-    return failure();
-  }
-
   return success();
 }
 
 /// Parse a comma-separated list of operation successors in brackets.
 ///
 ///   successor-list ::= `[` successor (`,` successor )* `]`
 ///
-ParseResult OperationParser::parseSuccessors(
-    SmallVectorImpl<Block *> &destinations,
-    SmallVectorImpl<SmallVector<Value, 4>> &operands) {
+ParseResult
+OperationParser::parseSuccessors(SmallVectorImpl<Block *> &destinations) {
   if (parseToken(Token::l_square, "expected '['"))
     return failure();
 
-  auto parseElt = [this, &destinations, &operands]() {
+  auto parseElt = [this, &destinations] {
     Block *dest;
-    SmallVector<Value, 4> destOperands;
-    auto res = parseSuccessorAndUseList(dest, destOperands);
+    ParseResult res = parseSuccessor(dest);
     destinations.push_back(dest);
-    operands.push_back(destOperands);
     return res;
   };
   return parseCommaSeparatedListUntil(Token::r_square, parseElt,
                                       /*allowEmptyList=*/false);
 }
 
 namespace {
 // RAII-style guard for cleaning up the regions in the operation state before
Operation *OperationParser::parseGenericOperation() {
 
   OperationState result(srcLocation, name);
 
   // Generic operations have a resizable operation list.
   result.setOperandListToResizable();
 
   // Parse the operand list.
   SmallVector<SSAUseInfo, 8> operandInfos;
-
   if (parseToken(Token::l_paren, "expected '(' to start operand list") ||
       parseOptionalSSAUseList(operandInfos) ||
       parseToken(Token::r_paren, "expected ')' to end operand list")) {
     return nullptr;
   }
 
-  // Parse the successor list but don't add successors to the result yet to
-  // avoid messing up with the argument order.
-  SmallVector<Block *, 2> successors;
-  SmallVector<SmallVector<Value, 4>, 2> successorOperands;
+  // Parse the successor list.
   if (getToken().is(Token::l_square)) {
     // Check if the operation is a known terminator.
     const AbstractOperation *abstractOp = result.name.getAbstractOperation();
     if (abstractOp && !abstractOp->hasProperty(OperationProperty::Terminator))
       return emitError("successors in non-terminator"), nullptr;
-    if (parseSuccessors(successors, successorOperands))
+
+    SmallVector<Block *, 2> successors;
+    if (parseSuccessors(successors))
       return nullptr;
+    result.addSuccessors(successors);
   }
 
   // Parse the region list.
   CleanupOpStateRegions guard{result};
   if (consumeIf(Token::l_paren)) {
     do {
       // Create temporary regions with the top level region as parent.
       result.regions.emplace_back(new Region(moduleOp));
Operation *OperationParser::parseGenericOperation() {
 
   // Resolve all of the operands.
   for (unsigned i = 0, e = operandInfos.size(); i != e; ++i) {
     result.operands.push_back(resolveSSAUse(operandInfos[i], operandTypes[i]));
     if (!result.operands.back())
       return nullptr;
   }
 
-  // Add the successors, and their operands after the proper operands.
-  for (auto succ : llvm::zip(successors, successorOperands)) {
-    Block *successor = std::get<0>(succ);
-    const SmallVector<Value, 4> &operands = std::get<1>(succ);
-    result.addSuccessor(successor, operands);
-  }
-
   // Parse a location if one is present.
   if (parseOptionalTrailingLocation(result.location))
     return nullptr;
 
   return opBuilder.createOperation(result);
 }
 
 Operation *OperationParser::parseGenericOperation(Block *insertBlock,
parseRegionArgumentList(SmallVectorImpl<OperandType> &result,
     return parseOperandOrRegionArgList(result, /*isOperandList=*/false,
                                        requiredOperandCount, delimiter);
   }
 
   //===--------------------------------------------------------------------===//
   // Successor Parsing
   //===--------------------------------------------------------------------===//
 
-  /// Parse a single operation successor and its operand list.
-  ParseResult
-  parseSuccessorAndUseList(Block *&dest,
-                           SmallVectorImpl<Value> &operands) override {
-    return parser.parseSuccessorAndUseList(dest, operands);
+  /// Parse a single operation successor.
+  ParseResult parseSuccessor(Block *&dest) override {
+    return parser.parseSuccessor(dest);
   }
 
   /// Parse an optional operation successor and its operand list.
-  OptionalParseResult
-  parseOptionalSuccessorAndUseList(Block *&dest,
-                                   SmallVectorImpl<Value> &operands) override {
+  OptionalParseResult parseOptionalSuccessor(Block *&dest) override {
     if (parser.getToken().isNot(Token::caret_identifier))
       return llvm::None;
-    return parseSuccessorAndUseList(dest, operands);
+    return parseSuccessor(dest);
+  }
+
+  /// Parse a single operation successor and its operand list.
+  ParseResult
+  parseSuccessorAndUseList(Block *&dest,
+                           SmallVectorImpl<Value> &operands) override {
+    if (parseSuccessor(dest))
+      return failure();
+
+    // Handle optional arguments.
+    if (succeeded(parseOptionalLParen()) &&
+        (parser.parseOptionalSSAUseAndTypeList(operands) || parseRParen())) {
+      return failure();
+    }
+    return success();
   }
 
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   ParseResult parseType(Type &result) override {

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

v = b.create<ICmpOp>(
         loc, getICmpPredicate(cast<llvm::ICmpInst>(inst)->getPredicate()), lhs,
         rhs);
     return success();
   }
   case llvm::Instruction::Br: {
     auto *brInst = cast<llvm::BranchInst>(inst);
     OperationState state(loc,
                          brInst->isConditional() ? "llvm.cond_br" : "llvm.br");
-    SmallVector<Value, 4> ops;
     if (brInst->isConditional()) {
       Value condition = processValue(brInst->getCondition());
       if (!condition)
         return failure();
-      ops.push_back(condition);
+      state.addOperands(condition);
     }
-    state.addOperands(ops);
-    SmallVector<Block *, 4> succs;
-    for (auto *succ : llvm::reverse(brInst->successors())) {
+
+    std::array<int32_t, 3> operandSegmentSizes = {1, 0, 0};
+    for (int i : llvm::seq<int>(0, brInst->getNumSuccessors())) {
+      auto *succ = brInst->getSuccessor(i);
       SmallVector<Value, 4> blockArguments;
       if (failed(processBranchArgs(brInst, succ, blockArguments)))
         return failure();
-      state.addSuccessor(blocks[succ], blockArguments);
+      state.addSuccessors(blocks[succ]);
+      state.addOperands(blockArguments);
+      operandSegmentSizes[i + 1] = blockArguments.size();
     }
+
+    if (brInst->isConditional()) {
+      state.addAttribute(LLVM::CondBrOp::getOperandSegmentSizeAttr(),
+                         b.getI32VectorAttr(operandSegmentSizes));
+    }
+
     b.createOperation(state);
     return success();
   }
   case llvm::Instruction::PHI: {
     LLVMType type = processType(inst->getType());
     if (!type)
       return failure();
     v = b.getInsertionBlock()->addArgument(type);

mlir/lib/Transforms/DialectConversion.cpp

 
 /// Attempt to match and rewrite the IR root at the specified operation.
 PatternMatchResult
 ConversionPattern::matchAndRewrite(Operation *op,
                                    PatternRewriter &rewriter) const {
   SmallVector<Value, 4> operands;
   auto &dialectRewriter = static_cast<ConversionPatternRewriter &>(rewriter);
   dialectRewriter.getImpl().remapValues(op->getOperands(), operands);
-
-  // If this operation has no successors, invoke the rewrite directly.
-  if (op->getNumSuccessors() == 0)
-    return matchAndRewrite(op, operands, dialectRewriter);
-
-  // Otherwise, we need to remap the successors.
-  SmallVector<Block *, 2> destinations;
-  destinations.reserve(op->getNumSuccessors());
-
-  SmallVector<ArrayRef<Value>, 2> operandsPerDestination;
-  unsigned firstSuccessorOperand = op->getSuccessorOperandIndex(0);
-  for (unsigned i = 0, seen = 0, e = op->getNumSuccessors(); i < e; ++i) {
-    destinations.push_back(op->getSuccessor(i));
-
-    // Lookup the successors operands.
-    unsigned n = op->getNumSuccessorOperands(i);
-    operandsPerDestination.push_back(
-        llvm::makeArrayRef(operands.data() + firstSuccessorOperand + seen, n));
-    seen += n;
-  }
-
-  // Rewrite the operation.
-  return matchAndRewrite(
-      op,
-      llvm::makeArrayRef(operands.data(),
-                         operands.data() + firstSuccessorOperand),
-      destinations, operandsPerDestination, dialectRewriter);
 }
 
 //===----------------------------------------------------------------------===//
 // OperationLegalizer
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A set of rewrite patterns that can be used to legalize a given operation.

mlir/lib/Transforms/Utils/RegionUtils.cpp

 //===- RegionUtils.cpp - Region-related transformation utilities ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/RegionUtils.h"
+#include "mlir/Analysis/ControlFlowInterfaces.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/IR/Value.h"
 
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallSet.h"
static bool isUseSpeciallyKnownDead(OpOperand &use, LiveMap &liveMap) {
   // node based SSA IR, where each successor operand is really an operand to a
   // *separate* phi node, rather than all operands to the branch itself as with
   // the block argument representation that MLIR uses.
   //
   // And similarly, because each successor operand is really an operand to a phi
   // node, rather than to the terminator op itself, a terminator op can't e.g.
   // "print" the value of a successor operand.
   if (owner->isKnownTerminator()) {
-    if (auto arg = owner->getSuccessorBlockArgument(operandIndex))
+    if (BranchOpInterface branchInterface = dyn_cast<BranchOpInterface>(owner))
+      if (auto arg = branchInterface.getSuccessorBlockArgument(operandIndex))
         return !liveMap.wasProvenLive(*arg);
     return false;
   }
   return false;
 }
 
 static void processValue(Value value, LiveMap &liveMap) {
   bool provedLive = llvm::any_of(value.getUses(), [&](OpOperand &use) {
     if (isUseSpeciallyKnownDead(use, liveMap))
if (!op->isKnownNonTerminator())
     return true;
   // If the op has a side effect, we treat it as live.
   if (!op->hasNoSideEffect())
     return true;
   return false;
 }
 
 static void propagateLiveness(Region &region, LiveMap &liveMap);
+
+static void propagateTerminatorLiveness(Operation *op, LiveMap &liveMap) {
+  // Terminators are always live.
+  liveMap.setProvedLive(op);
+
+  // Check to see if we can reason about the successor operands and mutate them.
+  BranchOpInterface branchInterface = dyn_cast<BranchOpInterface>(op);
+  if (!branchInterface || !branchInterface.canEraseSuccessorOperand()) {
+    for (Block *successor : op->getSuccessors())
+      for (BlockArgument arg : successor->getArguments())
+        liveMap.setProvedLive(arg);
+    return;
+  }
+
+  // If we can't reason about the operands to a successor, conservatively mark
+  // all arguments as live.
+  for (unsigned i = 0, e = op->getNumSuccessors(); i != e; ++i) {
+    if (!branchInterface.getSuccessorOperands(i))
+      for (BlockArgument arg : op->getSuccessor(i)->getArguments())
+        liveMap.setProvedLive(arg);
+  }
+}
+
 static void propagateLiveness(Operation *op, LiveMap &liveMap) {
   // All Value's are either a block argument or an op result.
   // We call processValue on those cases.
 
   // Recurse on any regions the op has.
   for (Region &region : op->getRegions())
     propagateLiveness(region, liveMap);
 
+  // Process terminator operations.
+  if (op->isKnownTerminator())
+    return propagateTerminatorLiveness(op, liveMap);
+
   // Process the op itself.
   if (isOpIntrinsicallyLive(op)) {
     liveMap.setProvedLive(op);
     return;
   }
   for (Value value : op->getResults())
     processValue(value, liveMap);
   bool provedLive = llvm::any_of(op->getResults(), [&](Value value) {
for (Operation &op : llvm::reverse(block->getOperations()))
       propagateLiveness(&op, liveMap);
     for (Value value : block->getArguments())
       processValue(value, liveMap);
   }
 }
 
 static void eraseTerminatorSuccessorOperands(Operation *terminator,
                                              LiveMap &liveMap) {
+  BranchOpInterface branchOp = dyn_cast<BranchOpInterface>(terminator);
+  if (!branchOp)
+    return;
+
   for (unsigned succI = 0, succE = terminator->getNumSuccessors();
        succI < succE; succI++) {
     // Iterating successors in reverse is not strictly needed, since we
     // aren't erasing any successors. But it is slightly more efficient
     // since it will promote later operands of the terminator being erased
     // first, reducing the quadratic-ness.
     unsigned succ = succE - succI - 1;
-    for (unsigned argI = 0, argE = terminator->getNumSuccessorOperands(succ);
-         argI < argE; argI++) {
+    Optional<OperandRange> succOperands = branchOp.getSuccessorOperands(succ);
+    if (!succOperands)
+      continue;
+    Block *successor = terminator->getSuccessor(succ);
+
+    for (unsigned argI = 0, argE = succOperands->size(); argI < argE; ++argI) {
       // Iterating args in reverse is needed for correctness, to avoid
       // shifting later args when earlier args are erased.
       unsigned arg = argE - argI - 1;
-      Value value = terminator->getSuccessor(succ)->getArgument(arg);
-      if (!liveMap.wasProvenLive(value)) {
-        terminator->eraseSuccessorOperand(succ, arg);
-      }
+      if (!liveMap.wasProvenLive(successor->getArgument(arg)))
+        branchOp.eraseSuccessorOperand(succ, arg);
     }
   }
 }
 
 static LogicalResult deleteDeadness(MutableArrayRef<Region> regions,
                                     LiveMap &liveMap) {
   bool erasedAnything = false;
   for (Region &region : regions) {

mlir/test/Dialect/SPIRV/control-flow-ops.mlir

func @branch_argument() -> () {
   spv.Branch ^next(%zero, %zero: i32, i32)
 ^next(%arg0: i32, %arg1: i32):
   spv.Return
 }
 
 // -----
 
 func @missing_accessor() -> () {
-  // expected-error @+1 {{requires 1 successor but found 0}}
+  // expected-error @+2 {{expected block name}}
   spv.Branch
 }
 
 // -----
 
 func @wrong_accessor_count() -> () {
   %true = spv.constant true
   // expected-error @+1 {{requires 1 successor but found 2}}
^two:
   spv.Return
 }
 
 // -----
 
 func @wrong_accessor_count() -> () {
   %true = spv.constant true
   // expected-error @+1 {{requires 2 successors but found 1}}
-  "spv.BranchConditional"(%true)[^one] : (i1) -> ()
+  "spv.BranchConditional"(%true)[^one] {operand_segment_sizes = dense<[1, 0, 0]>: vector<3xi32>} : (i1) -> ()
 ^one:
   spv.Return
 ^two:
   spv.Return
 }
 
 // -----
 
 func @wrong_number_of_weights() -> () {
   %true = spv.constant true
   // expected-error @+1 {{must have exactly two branch weights}}
-  "spv.BranchConditional"(%true)[^one, ^two] {branch_weights = [1 : i32, 2 : i32, 3 : i32]} : (i1) -> ()
+  "spv.BranchConditional"(%true)[^one, ^two] {branch_weights = [1 : i32, 2 : i32, 3 : i32],
+                                              operand_segment_sizes = dense<[1, 0, 0]>: vector<3xi32>} : (i1) -> ()
 ^one:
   spv.Return
 ^two:
   spv.Return
 }
 
 // -----
 

mlir/test/IR/invalid.mlir

 ^bb42 (%0): // expected-error {{expected ':' and type for SSA operand}}
   return
 }
 
 // -----
 
 func @block_arg_no_close_paren() {
 ^bb42:
-  br ^bb2( // expected-error@+1 {{expected ')' to close argument list}}
+  br ^bb2( // expected-error@+1 {{expected ':'}}
   return
 }
 
 // -----
 
 func @block_first_has_predecessor() {
 // expected-error@-1 {{entry block of region may not have predecessors}}
 ^bb42:

mlir/test/IR/parser.mlir

^bb1(%x: i17, %y: i1):       // CHECK: ^bb1(%{{.*}}: i17, %{{.*}}: i1):
   %1:2 = "baz"(%x, %y, %0#1) : (i17, i1, i17) -> (i16, i8)
   return %1#0, %1#1 : i16, i8
 }
 
 // CHECK-LABEL: func @verbose_terminators() -> (i1, i17)
 func @verbose_terminators() -> (i1, i17) {
   %0:2 = "foo"() : () -> (i1, i17)
 // CHECK:  br ^bb1(%{{.*}}#0, %{{.*}}#1 : i1, i17)
-  "std.br"()[^bb1(%0#0, %0#1 : i1, i17)] : () -> ()
+  "std.br"(%0#0, %0#1)[^bb1] : (i1, i17) -> ()
 
 ^bb1(%x : i1, %y : i17):
 // CHECK:  cond_br %{{.*}}, ^bb2(%{{.*}} : i17), ^bb3(%{{.*}}, %{{.*}} : i1, i17)
-  "std.cond_br"(%x)[^bb2(%y : i17), ^bb3(%x, %y : i1, i17)] : (i1) -> ()
+  "std.cond_br"(%x, %y, %x, %y) [^bb2, ^bb3] {operand_segment_sizes = dense<[1, 1, 2]>: vector<3xi32>} : (i1, i17, i1, i17) -> ()
 
 ^bb2(%a : i17):
   %true = constant 1 : i1
 // CHECK:  return %{{.*}}, %{{.*}} : i1, i17
   "std.return"(%true, %a) : (i1, i17) -> ()
 
 ^bb3(%b : i1, %c : i17):
 // CHECK:  return %{{.*}}, %{{.*}} : i1, i17
func @terminator_with_regions() {
   // CHECK: }) : () -> ()
   "region"()[^bb2] ({}) : () -> ()
 ^bb2:
   return
 }
 
 // CHECK-LABEL: func @unregistered_term
 func @unregistered_term(%arg0 : i1) -> i1 {
-  // CHECK-NEXT: "unregistered_br"()[^bb1(%{{.*}} : i1)] : () -> ()
-  "unregistered_br"()[^bb1(%arg0 : i1)] : () -> ()
+  // CHECK-NEXT: "unregistered_br"(%{{.*}})[^bb1] : (i1) -> ()
+  "unregistered_br"(%arg0)[^bb1] : (i1) -> ()
 
 ^bb1(%arg1 : i1):
   return %arg1 : i1
 }
 
 // CHECK-LABEL: func @dialect_attrs
 func @dialect_attrs()
     // CHECK: attributes  {dialect.attr = 10

mlir/test/Transforms/canonicalize-dce.mlir

 // Test case: Simple case of deleting a block argument.
 
 // CHECK:      func @f(%arg0: f32)
 // CHECK-NEXT:   "test.br"()[^bb1]
 // CHECK-NEXT: ^bb1:
 // CHECK-NEXT:   return
 
 func @f(%arg0: f32) {
-  "test.br"()[^succ(%arg0: f32)] : () -> ()
+  "test.br"(%arg0)[^succ] : (f32) -> ()
 ^succ(%0: f32):
   return
 }
 
 // -----
 
 // Test case: Deleting recursively dead block arguments.
 
func @f(%arg0: f32) {
   return
 }
 
 // -----
 
 // Test case: Test the mechanics of deleting multiple block arguments.
 
 // CHECK:      func @f(%arg0: tensor<1xf32>, %arg1: tensor<2xf32>, %arg2: tensor<3xf32>, %arg3: tensor<4xf32>, %arg4: tensor<5xf32>)
-// CHECK-NEXT:   "test.br"()[^bb1(%arg1, %arg3 : tensor<2xf32>, tensor<4xf32>)
+// CHECK-NEXT:   "test.br"(%arg1, %arg3)[^bb1] : (tensor<2xf32>, tensor<4xf32>)
 // CHECK-NEXT: ^bb1([[VAL0:%.+]]: tensor<2xf32>, [[VAL1:%.+]]: tensor<4xf32>):
 // CHECK-NEXT:   "foo.print"([[VAL0]])
 // CHECK-NEXT:   "foo.print"([[VAL1]])
 // CHECK-NEXT:   return
 
 
 func @f(
   %arg0: tensor<1xf32>,
   %arg1: tensor<2xf32>,
   %arg2: tensor<3xf32>,
   %arg3: tensor<4xf32>,
   %arg4: tensor<5xf32>) {
-  "test.br"()[^succ(%arg0, %arg1, %arg2, %arg3, %arg4 : tensor<1xf32>, tensor<2xf32>, tensor<3xf32>, tensor<4xf32>, tensor<5xf32>)] : () -> ()
+  "test.br"(%arg0, %arg1, %arg2, %arg3, %arg4)[^succ] : (tensor<1xf32>, tensor<2xf32>, tensor<3xf32>, tensor<4xf32>, tensor<5xf32>) -> ()
 ^succ(%t1: tensor<1xf32>, %t2: tensor<2xf32>, %t3: tensor<3xf32>, %t4: tensor<4xf32>, %t5: tensor<5xf32>):
   "foo.print"(%t2) : (tensor<2xf32>) -> ()
   "foo.print"(%t4) : (tensor<4xf32>) -> ()
   return
 }

mlir/test/lib/TestDialect/TestOps.td

 def IsNotScalar : Constraint<CPred<"$0.getType().getRank() != 0">>;
 
 def UpdateAttr : Pat<(I32ElementsAttrOp $attr),
                      (I32ElementsAttrOp ConstantAttr<I32ElementsAttr, "0">),
                      [(IsNotScalar $attr)]>;
 
 def TestBranchOp : TEST_Op<"br",
     [DeclareOpInterfaceMethods<BranchOpInterface>, Terminator]> {
+  let arguments = (ins Variadic<AnyType>:$targetOperands);
   let successors = (successor AnySuccessor:$target);
 }
 
 def AttrSizedOperandOp : TEST_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,
     Variadic<I32>:$b,

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 
 void OpEmitter::genNamedSuccessorGetters() {
   unsigned numSuccessors = op.getNumSuccessors();
   for (unsigned i = 0; i < numSuccessors; ++i) {
     const NamedSuccessor &successor = op.getSuccessor(i);
     if (successor.name.empty())
       continue;
 
-    // Generate the accessors for a variadic successor.
+    // Generate the accessors for a variadic successor list.
     if (successor.isVariadic()) {
-      // Generate the getter.
       auto &m = opClass.newMethod("SuccessorRange", successor.name);
       m.body() << formatv(
           "  return {std::next(this->getOperation()->successor_begin(), {0}), "
           "this->getOperation()->successor_end()};",
           i);
       continue;
     }
 
-    // Generate the block getter.
     auto &m = opClass.newMethod("Block *", successor.name);
     m.body() << formatv("  return this->getOperation()->getSuccessor({0});", i);
-
-    // Generate the all-operands getter.
-    auto &operandsMethod = opClass.newMethod(
-        "Operation::operand_range", (successor.name + "Operands").str());
-    operandsMethod.body() << formatv(
-        " return this->getOperation()->getSuccessorOperands({0});", i);
-
-    // Generate the individual-operand getter.
-    auto &operandMethod = opClass.newMethod(
-        "Value", (successor.name + "Operand").str(), "unsigned index");
-    operandMethod.body() << formatv(
-        " return this->getOperation()->getSuccessorOperand({0}, index);", i);
   }
 }
 
 static bool canGenerateUnwrappedBuilder(Operator &op) {
   // If this op does not have native attributes at all, return directly to avoid
   // redefining builders.
   if (op.getNumNativeAttributes() == 0)
     return false;
if (argument.is<tblgen::NamedTypeConstraint *>()) {
         if (isString)
           paramList.append("\"");
       }
       ++numAttrs;
     }
   }
 
   /// Insert parameters for the block and operands for each successor.
-  const char *variadicSuccCode =
-      ", ArrayRef<Block *> {0}, ArrayRef<ValueRange> {0}Operands";
-  const char *succCode = ", Block *{0}, ValueRange {0}Operands";
-  for (const NamedSuccessor &namedSuccessor : op.getSuccessors()) {
-    if (namedSuccessor.isVariadic())
-      paramList += llvm::formatv(variadicSuccCode, namedSuccessor.name).str();
-    else
-      paramList += llvm::formatv(succCode, namedSuccessor.name).str();
+  for (const NamedSuccessor &succ : op.getSuccessors()) {
+    paramList += (succ.isVariadic() ? ", ArrayRef<Block *> " : ", Block *");
+    paramList += succ.name;
   }
 }
 
 void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
                                                        bool isRawValueAttr) {
   // Push all operands to the result.
   for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     body << "  " << builderOpState << ".addOperands(" << getArgumentName(op, i)
void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
   // Create the correct number of regions.
   if (int numRegions = op.getNumRegions()) {
     for (int i = 0; i < numRegions; ++i)
       body << "  (void)" << builderOpState << ".addRegion();\n";
   }
 
   // Push all successors to the result.
   for (const NamedSuccessor &namedSuccessor : op.getSuccessors()) {
-    if (namedSuccessor.isVariadic()) {
-      body << formatv("  for (int i = 0, e = {1}.size(); i != e; ++i)\n"
-                      "    {0}.addSuccessor({1}[i], {1}Operands[i]);\n",
-                      builderOpState, namedSuccessor.name);
-      continue;
-    }
-
-    body << formatv("  {0}.addSuccessor({1}, {1}Operands);\n", builderOpState,
+    body << formatv("  {0}.addSuccessors({1});\n", builderOpState,
                     namedSuccessor.name);
   }
 }
 
 void OpEmitter::genCanonicalizerDecls() {
   if (!def.getValueAsBit("hasCanonicalizer"))
     return;
 
else if (auto opTrait = dyn_cast<tblgen::InterfaceOpTrait>(&trait))
       opClass.addTrait(opTrait->getTrait());
   }
 
   // Add variadic size trait and normal op traits.
   int numOperands = op.getNumOperands();
   int numVariadicOperands = op.getNumVariadicOperands();
 
   // Add operand size trait.
-  // Note: Successor operands are also included in the operation's operand list,
-  // so we always need to use VariadicOperands in the presence of successors.
-  if (numVariadicOperands != 0 || op.getNumSuccessors()) {
+  if (numVariadicOperands != 0) {
     if (numOperands == numVariadicOperands)
       opClass.addTrait("OpTrait::VariadicOperands");
     else
       opClass.addTrait("OpTrait::AtLeastNOperands<" +
                        Twine(numOperands - numVariadicOperands) + ">::Impl");
   } else {
     switch (numOperands) {
     case 0:

mlir/tools/mlir-tblgen/OpFormatGen.cpp

const char *const functionalTypeParserCode = R"(
   {0}Types = {0}__{1}_functionType.getInputs();
   {1}Types = {0}__{1}_functionType.getResults();
 )";
 
 /// The code snippet used to generate a parser call for a successor list.
 ///
 /// {0}: The name for the successor list.
 const char *successorListParserCode = R"(
-  SmallVector<std::pair<Block *, SmallVector<Value, 4>>, 2> {0}Successors;
+  SmallVector<Block *, 2> {0}Successors;
   {
     Block *succ;
-    SmallVector<Value, 4> succOperands;
-    // Parse the first successor.
-    auto firstSucc = parser.parseOptionalSuccessorAndUseList(succ,
-                                                             succOperands);
+    auto firstSucc = parser.parseOptionalSuccessor(succ);
     if (firstSucc.hasValue()) {
       if (failed(*firstSucc))
         return failure();
-      {0}Successors.emplace_back(succ, succOperands);
+      {0}Successors.emplace_back(succ);
 
       // Parse any trailing successors.
       while (succeeded(parser.parseOptionalComma())) {
-        succOperands.clear();
-        if (parser.parseSuccessorAndUseList(succ, succOperands))
+        if (parser.parseSuccessor(succ))
           return failure();
-        {0}Successors.emplace_back(succ, succOperands);
+        {0}Successors.emplace_back(succ);
       }
     }
   }
 )";
 
 /// The code snippet used to generate a parser call for a successor.
 ///
 /// {0}: The name of the successor.
 const char *successorParserCode = R"(
   Block *{0}Successor = nullptr;
-  SmallVector<Value, 4> {0}Operands;
-  if (parser.parseSuccessorAndUseList({0}Successor, {0}Operands))
+  if (parser.parseSuccessor({0}Successor))
     return failure();
 )";
 
-/// The code snippet used to resolve a list of parsed successors.
-///
-/// {0}: The name of the successor list.
-const char *resolveSuccessorListParserCode = R"(
-  for (auto &succAndArgs : {0}Successors)
-    result.addSuccessor(succAndArgs.first, succAndArgs.second);
-)";
-
 /// Get the name used for the type list for the given type directive operand.
 /// 'isVariadic' is set to true if the operand has variadic types.
 static StringRef getTypeListName(Element *arg, bool &isVariadic) {
   if (auto *operand = dyn_cast<OperandVariable>(arg)) {
     isVariadic = operand->getVar()->isVariadic();
     return operand->getVar()->name;
   }
   if (auto *result = dyn_cast<ResultVariable>(arg)) {

 }
 
 void OperationFormat::genParserSuccessorResolution(Operator &op,
                                                    OpMethodBody &body) {
   // Check for the case where all successors were parsed.
   bool hasAllSuccessors = llvm::any_of(
       elements, [](auto &elt) { return isa<SuccessorsDirective>(elt.get()); });
   if (hasAllSuccessors) {
-    body << llvm::formatv(resolveSuccessorListParserCode, "full");
+    body << "  result.addSuccessors(fullSuccessors);\n";
     return;
   }
 
   // Otherwise, handle each successor individually.
   for (const NamedSuccessor &successor : op.getSuccessors()) {
-    if (successor.isVariadic()) {
-      body << llvm::formatv(resolveSuccessorListParserCode, successor.name);
-      continue;
-    }
-
-    body << llvm::formatv("  result.addSuccessor({0}Successor, {0}Operands);\n",
-                          successor.name);
+    if (successor.isVariadic())
+      body << "  result.addSuccessors(" << successor.name << "Successors);\n";
+    else
+      body << "  result.addSuccessors(" << successor.name << "Successor);\n";
   }
 }
 
 void OperationFormat::genParserVariadicSegmentResolution(Operator &op,
                                                          OpMethodBody &body) {
   if (!allOperands && op.getTrait("OpTrait::AttrSizedOperandSegments")) {
     body << "  result.addAttribute(\"operand_segment_sizes\", "
          << "builder.getI32VectorAttr({";
if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     if (attrType && attrType->getBuilderCall())
       body << "  p.printAttributeWithoutType(" << var->name << "Attr());\n";
     else
       body << "  p.printAttribute(" << var->name << "Attr());\n";
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     body << "  p << " << operand->getVar()->name << "();\n";
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     const NamedSuccessor *var = successor->getVar();
-    if (var->isVariadic()) {
-      body << "  {\n"
-           << "    auto succRange = " << var->name << "();\n"
-           << "    auto opSuccBegin = getOperation()->successor_begin();\n"
-           << "    int i = succRange.begin() - opSuccBegin;\n"
-           << "    int e = i + succRange.size();\n"
-           << "    interleaveComma(llvm::seq<int>(i, e), p, [&](int i) {\n"
-           << "      p.printSuccessorAndUseList(*this, i);\n"
-           << "    });\n"
-           << "  }\n";
-      return;
-    }
-
-    unsigned index = successor->getVar() - op.successor_begin();
-    body << "  p.printSuccessorAndUseList(*this, " << index << ");\n";
+    if (var->isVariadic())
+      body << "  interleaveComma(" << var->name << "(), p);\n";
+    else
+      body << "  p << " << var->name << "();\n";
   } else if (isa<OperandsDirective>(element)) {
     body << "  p << getOperation()->getOperands();\n";
   } else if (isa<SuccessorsDirective>(element)) {
-    body << "  interleaveComma(llvm::seq<int>(0, "
-            "getOperation()->getNumSuccessors()), p, [&](int i) {"
-         << "    p.printSuccessorAndUseList(*this, i);"
-         << "  });\n";
+    body << "  interleaveComma(getOperation()->getSuccessors(), p);\n";
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     body << "  p << ";
     genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     body << "  p.printFunctionalType(";
     genTypeOperandPrinter(dir->getInputs(), body) << ", ";
     genTypeOperandPrinter(dir->getResults(), body) << ");\n";
   } else {