[mlir][ODS] Add support for variadic regions.

[rriddle]

Summary

This revision adds support for marking the last region as variadic in the ODS region list with the VariadicRegion directive.

[mehdi_amini]

mlir/test/Dialect/LLVMIR/global.mlir

83

Is this a requirement because of the verifier change?

[rriddle]

mlir/test/Dialect/LLVMIR/global.mlir

83

Yes, the number of regions is verified earlier now.

mlir/docs/OpDefinitions.md

*   `ArrayMinCount<N>`: Specifying an array attribute to have at least `N`
     elements
 *   `IntArrayNthElemEq<I, N>`: Specifying an integer array attribute's `I`-th
     element to be equal to `N`
 *   `IntArrayNthElemMinValue<I, N>`: Specifying an integer array attribute's
     `I`-th element to be greater than or equal to `N`
 
 TODO: Design and implement more primitive constraints
 
+### Operation regions
+
+The regions of an operation are specified inside of the `dag`-typed `regions`,
+led by `region`:
+
+```tablegen
+let regions = (region
+  <region-constraint>:$<region-name>,
+  ...
+);
+```
+
+#### Variadic regions
+
+Similar to the `Variadic` class used for variadic operands and results,
+`VariadicRegion<...>` can be used for regions. Variadic regions can currently
+only be specified as the last region in the regions list.
+
 ### Operation results
 
 Similar to operands, results are specified inside the `dag`-typed `results`, led
 by `outs`:
 
 ```tablegen
 let results = (outs
   <type-constraint>:$<result-name>,

mlir/include/mlir/IR/OpBase.td

 // Any region.
 def AnyRegion : Region<CPred<"true">, "any region">;
 
 // A region with the given number of blocks.
 class SizedRegion<int numBlocks> : Region<
   CPred<"$_self.getBlocks().size() == " # numBlocks>,
   "region with " # numBlocks # " blocks">;
 
+// A variadic region constraint. It expands to zero or more of the base region.
+class VariadicRegion<Region region>
+  : Region<region.predicate, region.description>;
+
 //===----------------------------------------------------------------------===//
 // Successor definitions
 //===----------------------------------------------------------------------===//
 
 class Successor<Pred condition, string descr = ""> :
     SuccessorConstraint<condition, descr>;
 
 // Any successor.

mlir/include/mlir/IR/OpDefinition.h

 //===- OpDefinition.h - Classes for defining concrete Op types --*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

 namespace impl {
 LogicalResult verifyZeroOperands(Operation *op);
 LogicalResult verifyOneOperand(Operation *op);
 LogicalResult verifyNOperands(Operation *op, unsigned numOperands);
 LogicalResult verifyAtLeastNOperands(Operation *op, unsigned numOperands);
 LogicalResult verifyOperandsAreFloatLike(Operation *op);
 LogicalResult verifyOperandsAreSignlessIntegerLike(Operation *op);
 LogicalResult verifySameTypeOperands(Operation *op);
+LogicalResult verifyZeroRegion(Operation *op);
+LogicalResult verifyOneRegion(Operation *op);
+LogicalResult verifyNRegions(Operation *op, unsigned numRegions);
+LogicalResult verifyAtLeastNRegions(Operation *op, unsigned numRegions);
 LogicalResult verifyZeroResult(Operation *op);
 LogicalResult verifyOneResult(Operation *op);
 LogicalResult verifyNResults(Operation *op, unsigned numOperands);
 LogicalResult verifyAtLeastNResults(Operation *op, unsigned numOperands);
 LogicalResult verifySameOperandsShape(Operation *op);
 LogicalResult verifySameOperandsAndResultShape(Operation *op);
 LogicalResult verifySameOperandsElementType(Operation *op);
 LogicalResult verifySameOperandsAndResultElementType(Operation *op);

 
 /// This class provides the API for ops which have an unknown number of
 /// SSA operands.
 template <typename ConcreteType>
 class VariadicOperands
     : public detail::MultiOperandTraitBase<ConcreteType, VariadicOperands> {};
 
 //===----------------------------------------------------------------------===//
+// Region Traits
+
+/// This class provides verification for ops that are known to have zero
+/// regions.
+template <typename ConcreteType>
+class ZeroRegion : public TraitBase<ConcreteType, ZeroRegion> {
+public:
+  static LogicalResult verifyTrait(Operation *op) {
+    return impl::verifyZeroRegion(op);
+  }
+};
+
+namespace detail {
+/// Utility trait base that provides accessors for derived traits that have
+/// multiple regions.
+template <typename ConcreteType, template <typename> class TraitType>
+struct MultiRegionTraitBase : public TraitBase<ConcreteType, TraitType> {
+  using region_iterator = MutableArrayRef<Region>;
+  using region_range = RegionRange;
+
+  /// Return the number of regions.
+  unsigned getNumRegions() { return this->getOperation()->getNumRegions(); }
+
+  /// Return the region at `index`.
+  Region &getRegion(unsigned i) { return this->getOperation()->getRegion(i); }
+
+  /// Region iterator access.
+  region_iterator region_begin() {
+    return this->getOperation()->region_begin();
+  }
+  region_iterator region_end() { return this->getOperation()->region_end(); }
+  region_range getRegions() { return this->getOperation()->getRegions(); }
+};
+} // end namespace detail
+
+/// This class provides APIs for ops that are known to have a single region.
+template <typename ConcreteType>
+class OneRegion : public TraitBase<ConcreteType, OneRegion> {
+public:
+  Region &getRegion() { return this->getOperation()->getRegion(0); }
+
+  static LogicalResult verifyTrait(Operation *op) {
+    return impl::verifyOneRegion(op);
+  }
+};
+
+/// This class provides the API for ops that are known to have a specified
+/// number of regions.
+template <unsigned N> class NRegions {
+public:
+  static_assert(N > 1, "use ZeroRegion/OneRegion for N < 2");
+
+  template <typename ConcreteType>
+  class Impl
+      : public detail::MultiRegionTraitBase<ConcreteType, NRegions<N>::Impl> {
+  public:
+    static LogicalResult verifyTrait(Operation *op) {
+      return impl::verifyNRegions(op, N);
+    }
+  };
+};
+
+/// This class provides APIs for ops that are known to have at least a specified
+/// number of regions.
+template <unsigned N> class AtLeastNRegions {
+public:
+  template <typename ConcreteType>
+  class Impl : public detail::MultiRegionTraitBase<ConcreteType,
+                                                   AtLeastNRegions<N>::Impl> {
+  public:
+    static LogicalResult verifyTrait(Operation *op) {
+      return impl::verifyAtLeastNRegions(op, N);
+    }
+  };
+};
+
+/// This class provides the API for ops which have an unknown number of
+/// regions.
+template <typename ConcreteType>
+class VariadicRegions
+    : public detail::MultiRegionTraitBase<ConcreteType, VariadicRegions> {};
+
+//===----------------------------------------------------------------------===//
 // Result Traits
 
 /// This class provides return value APIs for ops that are known to have
 /// zero results.
 template <typename ConcreteType>
 class ZeroResult : public TraitBase<ConcreteType, ZeroResult> {
 public:
   static LogicalResult verifyTrait(Operation *op) {

mlir/include/mlir/TableGen/Operator.h

 //===- Operator.h - Operator class ------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
public:
   StringRef getArgName(int index) const;
   var_decorator_range getArgDecorators(int index) const;
 
   // Returns the trait wrapper for the given MLIR C++ `trait`.
   // TODO: We should add a C++ wrapper class for TableGen OpTrait instead of
   // requiring the raw MLIR trait here.
   const OpTrait *getTrait(llvm::StringRef trait) const;
 
+  // Regions.
+  using const_region_iterator = const NamedRegion *;
+  const_region_iterator region_begin() const;
+  const_region_iterator region_end() const;
+  llvm::iterator_range<const_region_iterator> getRegions() const;
+
   // Returns the number of regions.
   unsigned getNumRegions() const;
   // Returns the `index`-th region.
   const NamedRegion &getRegion(unsigned index) const;
 
+  // Returns the number of variadic regions in this operation.
+  unsigned getNumVariadicRegions() const;
+
   // Successors.
   using const_successor_iterator = const NamedSuccessor *;
   const_successor_iterator successor_begin() const;
   const_successor_iterator successor_end() const;
   llvm::iterator_range<const_successor_iterator> getSuccessors() const;
 
   // Returns the number of successors.
   unsigned getNumSuccessors() const;

mlir/include/mlir/TableGen/Region.h

 //===- TGRegion.h - TableGen region definitions -----------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_REGION_H_
 #define MLIR_TABLEGEN_REGION_H_
 
 #include "mlir/Support/LLVM.h"
 #include "mlir/TableGen/Constraint.h"
 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class providing helper methods for accessing Region defined in
 // TableGen.
 class Region : public Constraint {
 public:
   using Constraint::Constraint;
 
   static bool classof(const Constraint *c) { return c->getKind() == CK_Region; }
+
+  // Returns true if this region is variadic.
+  bool isVariadic() const;
 };
 
 // A struct bundling a region's constraint and its name.
 struct NamedRegion {
+  // Returns true if this region is variadic.
+  bool isVariadic() const { return constraint.isVariadic(); }
+
   StringRef name;
   Region constraint;
 };
 
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_REGION_H_

mlir/lib/IR/Operation.cpp

 //===- Operation.cpp - Operation support code -----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
LogicalResult OpTrait::impl::verifySameTypeOperands(Operation *op) {
 
   auto type = op->getOperand(0).getType();
   for (auto opType : llvm::drop_begin(op->getOperandTypes(), 1))
     if (opType != type)
       return op->emitOpError() << "requires all operands to have the same type";
   return success();
 }
 
+LogicalResult OpTrait::impl::verifyZeroRegion(Operation *op) {
+  if (op->getNumRegions() != 0)
+    return op->emitOpError() << "requires zero regions";
+  return success();
+}
+
+LogicalResult OpTrait::impl::verifyOneRegion(Operation *op) {
+  if (op->getNumRegions() != 1)
+    return op->emitOpError() << "requires one region";
+  return success();
+}
+
+LogicalResult OpTrait::impl::verifyNRegions(Operation *op,
+                                            unsigned numRegions) {
+  if (op->getNumRegions() != numRegions)
+    return op->emitOpError() << "expected " << numRegions << " regions";
+  return success();
+}
+
+LogicalResult OpTrait::impl::verifyAtLeastNRegions(Operation *op,
+                                                   unsigned numRegions) {
+  if (op->getNumRegions() < numRegions)
+    return op->emitOpError() << "expected " << numRegions << " or more regions";
+  return success();
+}
+
 LogicalResult OpTrait::impl::verifyZeroResult(Operation *op) {
   if (op->getNumResults() != 0)
     return op->emitOpError() << "requires zero results";
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyOneResult(Operation *op) {
   if (op->getNumResults() != 1)

mlir/lib/TableGen/CMakeLists.txt

 add_llvm_library(LLVMMLIRTableGen
   Argument.cpp
   Attribute.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Operator.cpp
   OpClass.cpp
   OpInterfaces.cpp
   OpTrait.cpp
   Pass.cpp
   Pattern.cpp
   Predicate.cpp
+  Region.cpp
   SideEffects.cpp
   Successor.cpp
   Type.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/TableGen
   )
 target_link_libraries(LLVMMLIRTableGen
   PUBLIC
   LLVMSupport
   LLVMTableGen)

mlir/lib/TableGen/Operator.cpp

 //===- Operator.cpp - Operator class --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
for (const auto &t : traits) {
     } else if (auto opTrait = dyn_cast<tblgen::InterfaceOpTrait>(&t)) {
       if (opTrait->getTrait() == trait)
         return opTrait;
     }
   }
   return nullptr;
 }
 
+auto tblgen::Operator::region_begin() const -> const_region_iterator {
+  return regions.begin();
+}
+auto tblgen::Operator::region_end() const -> const_region_iterator {
+  return regions.end();
+}
+auto tblgen::Operator::getRegions() const
+    -> llvm::iterator_range<const_region_iterator> {
+  return {region_begin(), region_end()};
+}
+
 unsigned tblgen::Operator::getNumRegions() const { return regions.size(); }
 
 const tblgen::NamedRegion &tblgen::Operator::getRegion(unsigned index) const {
   return regions[index];
 }
 
+unsigned tblgen::Operator::getNumVariadicRegions() const {
+  return llvm::count_if(regions,
+                        [](const NamedRegion &c) { return c.isVariadic(); });
+}
+
 auto tblgen::Operator::successor_begin() const -> const_successor_iterator {
   return successors.begin();
 }
 auto tblgen::Operator::successor_end() const -> const_successor_iterator {
   return successors.end();
 }
 auto tblgen::Operator::getSuccessors() const
     -> llvm::iterator_range<const_successor_iterator> {
void tblgen::Operator::populateOpStructure() {
 
   for (unsigned i = 0, e = regionsDag->getNumArgs(); i < e; ++i) {
     auto name = regionsDag->getArgNameStr(i);
     auto *regionInit = dyn_cast<DefInit>(regionsDag->getArg(i));
     if (!regionInit) {
       PrintFatalError(def.getLoc(),
                       Twine("undefined kind for region #") + Twine(i));
     }
-    regions.push_back({name, Region(regionInit->getDef())});
+    Region region(regionInit->getDef());
+    if (region.isVariadic()) {
+      // Only support variadic regions if it is the last one for now.
+      if (i != e - 1)
+        PrintFatalError(def.getLoc(), "only the last region can be variadic");
+      if (name.empty())
+        PrintFatalError(def.getLoc(), "variadic regions must be named");
+    }
+
+    regions.push_back({name, region});
   }
 
   LLVM_DEBUG(print(llvm::dbgs()));
 }
 
 ArrayRef<llvm::SMLoc> tblgen::Operator::getLoc() const { return def.getLoc(); }
 
 bool tblgen::Operator::hasDescription() const {

mlir/lib/TableGen/Region.cpp

+//===- Region.cpp - Region class ------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Region wrapper to simplify using TableGen Record defining a MLIR Region.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/TableGen/Region.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+// Returns true if this region is variadic.
+bool Region::isVariadic() const { return def->isSubClassOf("VariadicRegion"); }

mlir/test/Dialect/LLVMIR/func.mlir

module {
   // CHECK: llvm.func @external_func
   // GENERIC: linkage = 10
   llvm.func external @external_func()
 }
 
 // -----
 
 module {
-  // expected-error@+1 {{expects one region}}
+  // expected-error@+1 {{requires one region}}
   "llvm.func"() {sym_name = "no_region", type = !llvm<"void ()">} : () -> ()
 }
 
 // -----
 
 module {
   // expected-error@+1 {{requires a type attribute 'type'}}
   "llvm.func"() ({}) {sym_name = "missing_type"} : () -> ()

mlir/test/Dialect/LLVMIR/global.mlir

func @references() {
   %1 = llvm.mlir.addressof @".string" : !llvm<"[6 x i8]*">
 
   llvm.return
 }
 
 // -----
 
 // expected-error @+1 {{op requires string attribute 'sym_name'}}
-"llvm.mlir.global"() {type = !llvm.i64, constant, value = 42 : i64} : () -> ()
+"llvm.mlir.global"() ({}) {type = !llvm.i64, constant, value = 42 : i64} : () -> ()
 
 // -----
 
 // expected-error @+1 {{op requires attribute 'type'}}
-"llvm.mlir.global"() {sym_name = "foo", constant, value = 42 : i64} : () -> ()
+"llvm.mlir.global"() ({}) {sym_name = "foo", constant, value = 42 : i64} : () -> ()
 
 // -----
 
 // expected-error @+1 {{expects type to be a valid element type for an LLVM pointer}}
 llvm.mlir.global internal constant @constant(37.0) : !llvm<"label">
 
 // -----
 
 // expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
-"llvm.mlir.global"() {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = -1 : i32, linkage = 0} : () -> ()
+"llvm.mlir.global"() ({}) {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = -1 : i32, linkage = 0} : () -> ()
 
 // -----
 
 // expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
-"llvm.mlir.global"() {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = 1.0 : f32, linkage = 0} : () -> ()
+"llvm.mlir.global"() ({}) {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = 1.0 : f32, linkage = 0} : () -> ()
 
 // -----
 
 func @foo() {
   // expected-error @+1 {{must appear at the module level}}
   llvm.mlir.global internal @bar(42) : !llvm.i32
 }
 

mlir/test/Dialect/Loops/invalid.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics
 
 func @loop_for_lb(%arg0: f32, %arg1: index) {
   // expected-error@+1 {{operand #0 must be index}}
-  "loop.for"(%arg0, %arg1, %arg1) : (f32, index, index) -> ()
+  "loop.for"(%arg0, %arg1, %arg1) ({}) : (f32, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_for_ub(%arg0: f32, %arg1: index) {
   // expected-error@+1 {{operand #1 must be index}}
-  "loop.for"(%arg1, %arg0, %arg1) : (index, f32, index) -> ()
+  "loop.for"(%arg1, %arg0, %arg1) ({}) : (index, f32, index) -> ()
   return
 }
 
 // -----
 
 func @loop_for_step(%arg0: f32, %arg1: index) {
   // expected-error@+1 {{operand #2 must be index}}
-  "loop.for"(%arg1, %arg1, %arg0) : (index, index, f32) -> ()
+  "loop.for"(%arg1, %arg1, %arg0) ({}) : (index, index, f32) -> ()
   return
 }
 
 // -----
 
 func @loop_for_step_positive(%arg0: index) {
   // expected-error@+2 {{constant step operand must be positive}}
   %c0 = constant 0 : index
   "loop.for"(%arg0, %arg0, %c0) ({
     ^bb0(%arg1: index):
       loop.yield
   }) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_for_one_region(%arg0: index) {
-  // expected-error@+1 {{incorrect number of regions: expected 1 but found 2}}
+  // expected-error@+1 {{requires one region}}
   "loop.for"(%arg0, %arg0, %arg0) (
     {loop.yield},
     {loop.yield}
   ) : (index, index, index) -> ()
   return
 }
 
 // -----
func @loop_for_single_index_argument(%arg0: index) {
   ) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_if_not_i1(%arg0: index) {
   // expected-error@+1 {{operand #0 must be 1-bit signless integer}}
-  "loop.if"(%arg0) : (index) -> ()
+  "loop.if"(%arg0) ({}, {}) : (index) -> ()
   return
 }
 
 // -----
 
 func @loop_if_more_than_2_regions(%arg0: i1) {
-  // expected-error@+1 {{op has incorrect number of regions: expected 2}}
+  // expected-error@+1 {{expected 2 regions}}
   "loop.if"(%arg0) ({}, {}, {}): (i1) -> ()
   return
 }
 
 // -----
 
 func @loop_if_not_one_block_per_region(%arg0: i1) {
   // expected-error@+1 {{expects region #0 to have 0 or 1 blocks}}

mlir/test/IR/region.mlir

"test.two_region_op"()(
       {"work"() : () -> ()}
     ) : () -> ()
     return
 }
 
 // -----
 
 func @missing_regions() {
-    // expected-error@+1 {{op has incorrect number of regions: expected 2 but found 1}}
+    // expected-error@+1 {{expected 2 regions}}
     "test.two_region_op"()(
       {"work"() : () -> ()}
     ) : () -> ()
     return
 }
 
 // -----
 
 func @extra_regions() {
-    // expected-error@+1 {{op has incorrect number of regions: expected 2 but found 3}}
+    // expected-error@+1 {{expected 2 regions}}
     "test.two_region_op"()(
       {"work"() : () -> ()},
       {"work"() : () -> ()},
       {"work"() : () -> ()}
     ) : () -> ()
     return
 }
 

mlir/test/mlir-tblgen/op-decl.td

let arguments = (ins
     OptionalAttr<F32Attr>:$attr2
   );
 
   let results = (outs
     I32:$r,
     Variadic<F32>:$s
   );
 
-  let regions = (region AnyRegion:$someRegion);
+  let regions = (region
+    AnyRegion:$someRegion,
+    VariadicRegion<AnyRegion>:$someRegions
+  );
   let builders = [OpBuilder<"Value val">];
   let parser = [{ foo }];
   let printer = [{ bar }];
   let verifier = [{ baz }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 

 // CHECK:   AOpOperandAdaptor(ArrayRef<Value> values);
 // CHECK:   ArrayRef<Value> getODSOperands(unsigned index);
 // CHECK:   Value a();
 // CHECK:   ArrayRef<Value> b();
 // CHECK: private:
 // CHECK:   ArrayRef<Value> tblgen_operands;
 // CHECK: };
 
-// CHECK: class AOp : public Op<AOp, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::IsIsolatedFromAbove
+// CHECK: class AOp : public Op<AOp, OpTrait::AtLeastNRegions<1>::Impl, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::IsIsolatedFromAbove
 // CHECK-NOT: OpTrait::IsIsolatedFromAbove
 // CHECK: public:
 // CHECK:   using Op::Op;
 // CHECK:   using OperandAdaptor = AOpOperandAdaptor;
 // CHECK:   static StringRef getOperationName();
 // CHECK:   Operation::operand_range getODSOperands(unsigned index);
 // CHECK:   Value a();
 // CHECK:   Operation::operand_range b();
 // CHECK:   Operation::result_range getODSResults(unsigned index);
 // CHECK:   Value r();
 // CHECK:   Region &someRegion();
+// CHECK:   MutableArrayRef<Region> someRegions();
 // CHECK:   IntegerAttr attr1Attr()
 // CHECK:   APInt attr1();
 // CHECK:   FloatAttr attr2Attr()
 // CHECK:   Optional< APFloat > attr2();
 // CHECK:   static void build(Value val);
-// CHECK:   static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2)
-// CHECK:   static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2)
-// CHECK:   static void build(Builder *, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes)
+// CHECK:   static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
+// CHECK:   static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
+// CHECK:   static void build(Builder *, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes, unsigned numRegions)
 // CHECK:   static ParseResult parse(OpAsmParser &parser, OperationState &result);
 // CHECK:   void print(OpAsmPrinter &p);
 // CHECK:   LogicalResult verify();
 // CHECK:   static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);
 // CHECK:   LogicalResult fold(ArrayRef<Attribute> operands, SmallVectorImpl<OpFoldResult> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 //===- OpDefinitionsGen.cpp - MLIR op definitions generator ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
for (int i = 0; i != numResults; ++i) {
     }
   }
 }
 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
-    if (!region.name.empty()) {
-      auto &m = opClass.newMethod("Region &", region.name);
-      m.body() << formatv("  return this->getOperation()->getRegion({0});", i);
-    }
-  }
-}
+    if (region.name.empty())
+      continue;
+
+    // Generate the accessors for a varidiadic region.
+    if (region.isVariadic()) {
+      auto &m = opClass.newMethod("MutableArrayRef<Region>", region.name);
+      m.body() << formatv(
+          "  return this->getOperation()->getRegions().drop_front({0});", i);
+      continue;
+    }
+
 
 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;
 
if (op.getNumVariadicResults() != 0)
     return;
 
   int numResults = op.getNumResults();
 
   // Signature
   std::string params =
       std::string("Builder *odsBuilder, OperationState &") + builderOpState +
       ", ValueRange operands, ArrayRef<NamedAttribute> attributes";
+  if (op.getNumVariadicRegions())
+    params += ", unsigned numRegions";
   auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
   auto &body = m.body();
 
   // Operands
   body << "  " << builderOpState << ".addOperands(operands);\n\n";
 
   // Attributes
   body << "  " << builderOpState << ".addAttributes(attributes);\n";
 
   // Create the correct number of regions
   if (int numRegions = op.getNumRegions()) {
-    for (int i = 0; i < numRegions; ++i)
-      m.body() << "  (void)" << builderOpState << ".addRegion();\n";
+    body << llvm::formatv(
+        "  for (unsigned i = 0; i != {0}; ++i)\n",
+        (op.getNumVariadicRegions() ? "numRegions" : Twine(numRegions)));
+    body << "    (void)" << builderOpState << ".addRegion();\n";
   }
 
   // Result types
   SmallVector<std::string, 2> resultTypes(numResults, "operands[0].getType()");
   body << "  " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n\n";
 }
 
void OpEmitter::genCollectiveParamBuilder() {
   int numOperands = op.getNumOperands();
   int numVariadicOperands = op.getNumVariadicOperands();
   int numNonVariadicOperands = numOperands - numVariadicOperands;
   // Signature
   std::string params = std::string("Builder *, OperationState &") +
                        builderOpState +
                        ", ArrayRef<Type> resultTypes, ValueRange operands, "
                        "ArrayRef<NamedAttribute> attributes";
+  if (op.getNumVariadicRegions())
+    params += ", unsigned numRegions";
   auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
   auto &body = m.body();
 
   // Operands
   if (numVariadicOperands == 0 || numNonVariadicOperands != 0)
     body << "  assert(operands.size()"
          << (numVariadicOperands != 0 ? " >= " : " == ")
          << numNonVariadicOperands
          << "u && \"mismatched number of parameters\");\n";
   body << "  " << builderOpState << ".addOperands(operands);\n\n";
 
   // Attributes
   body << "  " << builderOpState << ".addAttributes(attributes);\n";
 
   // Create the correct number of regions
   if (int numRegions = op.getNumRegions()) {
-    for (int i = 0; i < numRegions; ++i)
-      m.body() << "  (void)" << builderOpState << ".addRegion();\n";
+    body << llvm::formatv(
+        "  for (unsigned i = 0; i != {0}; ++i)\n",
+        (op.getNumVariadicRegions() ? "numRegions" : Twine(numRegions)));
+    body << "    (void)" << builderOpState << ".addRegion();\n";
   }
 
   // Result types
   if (numVariadicResults == 0 || numNonVariadicResults != 0)
     body << "  assert(resultTypes.size()"
          << (numVariadicResults != 0 ? " >= " : " == ") << numNonVariadicResults
          << "u && \"mismatched number of return types\");\n";
   body << "  " << builderOpState << ".addTypes(resultTypes);\n";
if (argument.is<tblgen::NamedTypeConstraint *>()) {
         paramList.append(std::string(attr.getDefaultValue()));
         if (isString)
           paramList.append("\"");
       }
       ++numAttrs;
     }
   }
 
-  /// Insert parameters for the block and operands for each successor.
+  /// Insert parameters for each successor.
   for (const NamedSuccessor &succ : op.getSuccessors()) {
     paramList += (succ.isVariadic() ? ", ArrayRef<Block *> " : ", Block *");
     paramList += succ.name;
   }
+
+  /// Insert parameters for variadic regions.
+  for (const NamedRegion &region : op.getRegions()) {
+    if (region.isVariadic())
+      paramList += llvm::formatv(", unsigned {0}Count", region.name).str();
+  }
 }
 
 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)
          << ");\n";
if (!attr.isDerivedAttr()) {
       }
       if (emitNotNullCheck) {
         body << "  }\n";
       }
     }
   }
 
   // Create the correct number of regions.
-  if (int numRegions = op.getNumRegions()) {
-    for (int i = 0; i < numRegions; ++i)
-      body << "  (void)" << builderOpState << ".addRegion();\n";
+  for (const NamedRegion &region : op.getRegions()) {
+    if (region.isVariadic())
+      body << formatv("  for (unsigned i = 0; i < {0}Count; ++i)\n  ",
+                      region.name);
+
   }
 
   // Push all successors to the result.
   for (const NamedSuccessor &namedSuccessor : op.getSuccessors()) {
     body << formatv("  {0}.addSuccessors({1});\n", builderOpState,
                     namedSuccessor.name);
   }
 }
body << "      (void)v;\n"
          << "      ++index;\n"
          << "    }\n"; // for
   }
 
   body << "  }\n";
 }
 
 void OpEmitter::genRegionVerifier(OpMethodBody &body) {
+  // If we have no regions, there is nothing more to do.
   unsigned numRegions = op.getNumRegions();
+  if (numRegions == 0)
+    return;
 
-  // Verify this op has the correct number of regions
-  body << formatv(
-      "  if (this->getOperation()->getNumRegions() != {0}) {\n    "
-      "return emitOpError(\"has incorrect number of regions: expected {0} but "
-      "found \") << this->getOperation()->getNumRegions();\n  }\n",
-      numRegions);
+  body << "{\n";
+  body << "    unsigned index = 0; (void)index;\n";
 
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
+    if (region.constraint.getPredicate().isNull())
+      continue;
 
-    std::string name = std::string(formatv("#{0}", i));
-    if (!region.name.empty()) {
-      name += std::string(formatv(" ('{0}')", region.name));
-    }
-
-    auto getRegion = formatv("this->getOperation()->getRegion({0})", i).str();
+    body << "    for (Region &region : ";
+    body << formatv(
+        region.isVariadic()
+            ? "{0}()"
+            : "MutableArrayRef<Region>(this->getOperation()->getRegion({1}))",
+        region.name, i);
+    body << ") {\n";
     auto constraint = tgfmt(region.constraint.getConditionTemplate(),
-                            &verifyCtx.withSelf(getRegion))
+                            &verifyCtx.withSelf("region"))
                           .str();
 
-    body << formatv("  if (!({0})) {\n    "
-                    "return emitOpError(\"region {1} failed to verify "
-                    "constraint: {2}\");\n  }\n",
-                    constraint, name, region.constraint.getDescription());
+    body << formatv("      (void)region;\n"
+                    "      if (!({0})) {\n        "
+                    "return emitOpError(\"region #\") << index << \" {1}"
+                    "failed to "
+                    "verify constraint: {2}\";\n      }\n",
+                    constraint,
+                    region.name.empty() ? "" : "('" + region.name + "') ",
+                    region.constraint.getDescription())
+         << "      ++index;\n"
+         << "    }\n";
   }
+  body << "  }\n";
 }
 
 void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
   // If we have no successors, there is nothing more to do.
   unsigned numSuccessors = op.getNumSuccessors();
   if (numSuccessors == 0)
     return;
 
for (unsigned i = 0; i < numSuccessors; ++i) {
     body << formatv(successor.isVariadic() ? "{0}()"
                                            : "ArrayRef<Block *>({0}())",
                     successor.name);
     body << ") {\n";
     auto constraint = tgfmt(successor.constraint.getConditionTemplate(),
                             &verifyCtx.withSelf("successor"))
                           .str();
 
-    body << formatv(
-        "      (void)successor;\n"
+    body << formatv("      (void)successor;\n"
                     "      if (!({0})) {\n        "
-        "return emitOpError(\"successor #\") << index << \"('{2}') failed to "
-        "verify constraint: {3}\";\n      }\n",
-        constraint, i, successor.name, successor.constraint.getDescription());
-    body << "    }\n";
+                    "return emitOpError(\"successor #\") << index << \"('{1}') "
+                    "failed to "
+                    "verify constraint: {2}\";\n      }\n",
+                    constraint, successor.name,
+                    successor.constraint.getDescription())
+         << "      ++index;\n"
+         << "    }\n";
   }
   body << "  }\n";
 }
 
 /// Add a size count trait to the given operation class.
 static void addSizeCountTrait(OpClass &opClass, StringRef traitKind,
-                              int numNonVariadic, int numVariadic) {
+                              int numTotal, int numVariadic) {
   if (numVariadic != 0) {
-    if (numNonVariadic == numVariadic)
+    if (numTotal == numVariadic)
       opClass.addTrait("OpTrait::Variadic" + traitKind + "s");
     else
       opClass.addTrait("OpTrait::AtLeastN" + traitKind + "s<" +
-                       Twine(numNonVariadic - numVariadic) + ">::Impl");
+                       Twine(numTotal - numVariadic) + ">::Impl");
     return;
   }
-  switch (numNonVariadic) {
+  switch (numTotal) {
   case 0:
     opClass.addTrait("OpTrait::Zero" + traitKind);
     break;
   case 1:
     opClass.addTrait("OpTrait::One" + traitKind);
     break;
   default:
-    opClass.addTrait("OpTrait::N" + traitKind + "s<" + Twine(numNonVariadic) +
+    opClass.addTrait("OpTrait::N" + traitKind + "s<" + Twine(numTotal) +
                      ">::Impl");
     break;
   }
 }
 
 void OpEmitter::genTraits() {
+  // Add region size trait.
+  unsigned numRegions = op.getNumRegions();
+  unsigned numVariadicRegions = op.getNumVariadicRegions();
+  addSizeCountTrait(opClass, "Region", numRegions, numVariadicRegions);
+
+  // Add result size trait.
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariadicResults();
-
-  // Add return size trait.
   addSizeCountTrait(opClass, "Result", numResults, numVariadicResults);
 
   // Add successor size trait.
   unsigned numSuccessors = op.getNumSuccessors();
   unsigned numVariadicSuccessors = op.getNumVariadicSuccessors();
   addSizeCountTrait(opClass, "Successor", numSuccessors, numVariadicSuccessors);
 
   // Add variadic size trait and normal op traits.