[mlir] Support verification order (3/3)

[Chia-hungDuan]

Summary

In this CL, update the function name of verifier according to the
behavior. If a verifier needs to access the region then it'll be updated
to verifyRegions.

[rriddle]

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

67–68

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

1780

Some of the checks here are not related to regions. We should really keep the checks contained to where they should be checked (I would keep everything non-region in the main hasVerifier). hasRegionVerifier should really only contain region related verification code.

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

1039

Same comment here and throughout.

mlir/lib/IR/Operation.cpp

1090–1091

If it should be well formed (i.e. if you are guaranteed to be able to assume it), we should just remove the assert. It feels like a legacy assert at this point.

mlir/test/Dialect/Tensor/invalid.mlir

379

Missing newline here?

[Chia-hungDuan]

Address review comment and quickly went through the verifiers on Ops and updated some of them.

[Chia-hungDuan]

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

1780

Supported both hasVerifier and hasRegionVerifier and split the verifier based on if it touches the region

mlir/lib/IR/Operation.cpp

1090–1091

Ideally no one should just use this except the trait. Removed.

mlir/test/Dialect/Tensor/invalid.mlir

379

Not sure what happened here, upload a new one and see if this is still happening.

[Chia-hungDuan]

Fix verification label in linalg op interface

[jpienaar]

Nice thanks

mlir/include/mlir/IR/OpBase.td

2076–2077

This probably becomes more interesting with SameOperandsAndResultType moving to to interfaces (and I still need to do some work there to make it OpTraitList), A little bit of artifact of this file being a collection of all attributes.

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

2161

I'm a little bit hesitant to have this duplicated at every decl site.

mlir/test/Dialect/GPU/invalid.mlir

29

Ooc why this change?

mlir/test/Dialect/LLVMIR/global.mlir

175

Having the SSA id in the error message is unfortunate, especially as not guaranteed to be stable (so makes it easy to create a flaky test here, e.g., every run could have a different id returned)

mlir/test/Dialect/SCF/invalid.mlir

292

So here yield would fail first to verify parent relationship and change error else?

[rriddle]

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

2161

Yeah, can we just drop this? Feels like this should be gleaned from the ODS documentation (which I know right now is a mess).

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

4111

Can we signal this in the op definition? i.e. by removing the hasVerifier or by adding hasVerifier = ?(if the hasVerifier was set in a base class).

[Chia-hungDuan]

Address review comments and rebase

mlir/include/mlir/IR/OpBase.td

2076–2077

Yep, it may be a problem for describing dependency between these traits and interfaces. Not sure if we can do it in pure string rather than a tblgen def

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

2161

All removed.
Added more descriptions in the doc.

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

4111

disable them in the derived class by adding let hasVerifier = 0

mlir/test/Dialect/GPU/invalid.mlir

29

return expects its parent to be builtin.func so that we won't get the expected error. In fact, there are many cases like this, most of the ops are well-defined, i.e., they specify the restriction of terminator, the restriction of parent op, .etc. As a result, some tests case we may not be able to verify the fact they want without using ops from other dialects(like test dialect)

mlir/test/Dialect/LLVMIR/global.mlir

175

You're right. Removed the later of "block with no terminator"

mlir/test/Dialect/SCF/invalid.mlir

292

Yes, like the case above. yield has assigned its parent

[rriddle]

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

278

Can we remove this?

[Chia-hungDuan]

Address review comment

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

278

Sorry, a leftover.

mlir/docs/OpDefinitions.md

 ### Custom verifier code
 
 Verification code will be automatically generated for
 [constraints](#constraints) specified on various entities of the op. To perform
 _additional_ verification, you can use
 
 ```tablegen
 let hasVerifier = 1;
-```
-
-or
-
-```tablegen
 let hasRegionVerifier = 1;
 ```
 
-This will generate either `LogicalResult verify()` or
-`LogicalResult verifyRegions()` method declaration on the op class
-that can be defined with any additional verification constraints. These method
-will be invoked on its verification order.
+This will generate `LogicalResult verify()`/`LogicalResult verifyRegions()`
+method declarations on the op class that can be defined with any additional
+verification constraints. For verificaiton which needs to access the nested
+operations, you should use `hasRegionVerifier` to ensure that it won't access
+any ill-formed operation. Except that, The other verifications can be
+implemented with `hasVerifier`. Check the next section for the execution order
+of these verification methods.
 
 #### Verification Ordering
 
 The verification of an operation involves several steps,
 
 1. StructuralOpTrait will be verified first, they can be run independently.
 1. `verifyInvariants` which is constructed by ODS, it verifies the type,
    attributes, .etc.

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

let extraClassDeclaration = [{
     /// Returns true if both the lower and upper bound have the same operand
     /// lists (same operands in the same order).
     bool matchingBoundOperandList();
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def AffineIfOp : Affine_Op<"if",
                            [ImplicitAffineTerminator, RecursiveSideEffects,
                             NoRegionArguments]> {
   let summary = "if-then-else operation";
   let description = [{
     Syntax:

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

let arguments = (ins Variadic<Async_TokenType>:$dependencies,
                        Variadic<Async_AnyValueOrTokenType>:$operands);
 
   let results = (outs Async_TokenType:$token,
                       Variadic<Async_ValueType>:$results);
   let regions = (region SizedRegion<1>:$body);
 
   let hasCustomAssemblyFormat = 1;
   let skipDefaultBuilders = 1;
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
   let builders = [
     OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$dependencies,
       "ValueRange":$operands,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>",
            "nullptr">:$bodyBuilder)>,
   ];
 
   let extraClassDeclaration = [{

mlir/include/mlir/Dialect/GPU/GPUOps.td

let extraClassDeclaration = [{
 
     /// The number of region attributes containing the launch configuration,
     /// placed in the leading positions of the argument list.
     static constexpr unsigned kNumConfigRegionAttributes = 12;
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def GPU_PrintfOp : GPU_Op<"printf", [MemoryEffects<[MemWrite]>]>,
   Arguments<(ins StrAttr:$format,
                 Variadic<AnyTypeOf<[AnyInteger, Index, AnyFloat]>>:$args)> {
   let summary = "Device-side printf, as in CUDA or OpenCL, for debugging";
   let description = [{
     `gpu.printf` takes a literal format string `format` and an arbitrary number of
let description = [{
     `add`, `and`, `max`, `min`, `mul`, `or`, `xor`.
 
     Either none or all work items of a workgroup need to execute this op
     in convergence.
   }];
   let regions = (region AnyRegion:$body);
   let assemblyFormat = [{ custom<AllReduceOperation>($op) $value $body attr-dict
                           `:` functional-type(operands, results) }];
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def GPU_ShuffleOpXor  : I32EnumAttrCase<"XOR",  0, "xor">;
 def GPU_ShuffleOpDown : I32EnumAttrCase<"DOWN", 1, "down">;
 def GPU_ShuffleOpUp   : I32EnumAttrCase<"UP",   2, "up">;
 def GPU_ShuffleOpIdx  : I32EnumAttrCase<"IDX",  3, "idx">;
 
 def GPU_ShuffleMode : I32EnumAttr<"ShuffleMode",

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

let extraClassDeclaration = [{
     Block *getInitializerBlock() {
       return getInitializerRegion().empty() ?
         nullptr : &getInitializerRegion().front();
     }
   }];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def LLVM_GlobalCtorsOp : LLVM_Op<"mlir.global_ctors", [
                            DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
   let arguments = (ins FlatSymbolRefArrayAttr
                    : $ctors, I32ArrayAttr
                    : $priorities);
   let summary = "LLVM dialect global_ctors.";
let extraClassDeclaration = [{
     /// Hook for FunctionOpInterface, called after verifying that the 'type'
     /// attribute is present.  This can check for preconditions of the
     /// getNumArguments hook not failing.
     LogicalResult verifyType();
   }];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def LLVM_NullOp
     : LLVM_Op<"mlir.null", [NoSideEffect]>,
       LLVM_Builder<"$res = llvm::ConstantPointerNull::get("
                    "    cast<llvm::PointerType>($_resultType));"> {
   let summary = "Defines a value containing a null pointer to LLVM type.";
   let description = [{

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

def LinalgContractionOpInterface : OpInterface<"ContractionOpInterface"> {
    As a consequence, when vectorization of such an op occurs, the only special
    behavior is that the (unique) MulOpType is vectorized into a
    `vector.contract`. All other ops are handled in a generic fashion.
    In the future, we may wish to allow more input arguments and elementwise and
    constant operations that do not involve the reduction dimension(s).
   }];
   let cppNamespace = "::mlir::linalg";
   let verify = [{ return detail::verifyContractionInterface($_op); }];
+  let verifyWithRegions = 1;
   let methods = [
     InterfaceMethod<
     /*desc=*/"Returns the left-hand side operand.",
     /*retTy=*/"Value",
     /*methodName=*/"lhs",
     /*args=*/(ins),
     /*methodBody=*/[{
       return $_op.getOperation()->getOperand(0);
void setOperandSegmentAt(unsigned idx, unsigned val) {
       unsigned i = 0;
       auto newAttr = attr.mapValues(IntegerType::get(getContext(), 32),
         [&](const APInt &v) { return (i++ == idx) ? APInt(32, val) : v; });
       getOperation()->setAttr("operand_segment_sizes", newAttr);
     }
   }];
 
   let verify = [{ return detail::verifyStructuredOpInterface($_op); }];
+  let verifyWithRegions = 1;
 }
 
 #endif // LINALG_IR_LINALGINTERFACES

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

oilist( `reduction` `(`
                 $allocate_vars, type($allocate_vars),
                 $allocators_vars, type($allocators_vars)
               ) `)`
           | `nowait`
     ) $region attr-dict
   }];
 
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.9.2 Workshare Loop Construct
 //===----------------------------------------------------------------------===//
 
 def WsLoopOp : OpenMP_Op<"wsloop", [AttrSizedOperandSegments,
                          AllTypesMatch<["lowerBound", "upperBound", "step"]>,
def CriticalDeclareOp : OpenMP_Op<"critical.declare", [Symbol]> {
   let assemblyFormat = [{
     $sym_name oilist(`hint` `(` custom<SynchronizationHint>($hint_val) `)`)
     attr-dict
   }];
   let hasVerifier = 1;
 }
 
 
-def CriticalOp : OpenMP_Op<"critical"> {
+def CriticalOp : OpenMP_Op<"critical",
+    [DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
   let summary = "critical construct";
   let description = [{
     The critical construct imposes a restriction on the associated structured
     block (region) to be executed by only a single thread at a time.
   }];
 
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$name);
 
   let regions = (region AnyRegion:$region);
 
   let assemblyFormat = [{
     (`(` $name^ `)`)? $region attr-dict
   }];
-  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.17.2 barrier Construct
 //===----------------------------------------------------------------------===//
 
 def BarrierOp : OpenMP_Op<"barrier"> {
   let summary = "barrier construct";
let arguments = (ins OpenMP_PointerLikeType:$x,
                        OptionalAttr<MemoryOrderKindAttr>:$memory_order_val);
   let regions = (region SizedRegion<1>:$region);
   let assemblyFormat = [{
     oilist( `memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`
           | `hint` `(` custom<SynchronizationHint>($hint_val) `)`)
     $x `:` type($x) $region attr-dict
   }];
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def AtomicCaptureOp : OpenMP_Op<"atomic.capture",
     [SingleBlockImplicitTerminator<"TerminatorOp">]> {
   let summary = "performs an atomic capture";
   let description = [{
     This operation performs an atomic capture.
 
def AtomicCaptureOp : OpenMP_Op<"atomic.capture",
   let arguments = (ins DefaultValuedAttr<I64Attr, "0">:$hint_val,
                        OptionalAttr<MemoryOrderKindAttr>:$memory_order_val);
   let regions = (region SizedRegion<1>:$region);
   let assemblyFormat = [{
     oilist(`memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`
           |`hint` `(` custom<SynchronizationHint>($hint_val) `)`)
     $region attr-dict
   }];
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.19.5.7 declare reduction Directive
 //===----------------------------------------------------------------------===//
 
 def ReductionDeclareOp : OpenMP_Op<"reduction.declare", [Symbol]> {
   let summary = "declares a reduction kind";
def ReductionDeclareOp : OpenMP_Op<"reduction.declare", [Symbol]> {
   let extraClassDeclaration = [{
     PointerLikeType getAccumulatorType() {
       if (atomicReductionRegion().empty())
         return {};
 
       return atomicReductionRegion().front().getArgument(0).getType();
     }
   }];
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.19.5.4 reduction clause
 //===----------------------------------------------------------------------===//
 
 def ReductionOp : OpenMP_Op<"reduction", [
     TypesMatchWith<"value types matches accumulator element type",

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
 
     /// A PatternOp may optionally define a symbol.
     bool isOptionalSymbol() { return true; }
 
     /// Returns the rewrite operation of this pattern.
     RewriteOp getRewriter();
   }];
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ReplaceOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ReplaceOp : PDL_Op<"replace", [
     AttrSizedOperandSegments, HasParent<"pdl::RewriteOp">
let arguments = (ins Optional<PDL_Operation>:$root,
                        OptionalAttr<ArrayAttr>:$externalConstParams);
   let regions = (region AnyRegion:$body);
   let assemblyFormat = [{
     ($root^)? (`with` $name^ ($externalConstParams^)?
                              (`(` $externalArgs^ `:` type($externalArgs) `)`)?)?
               ($body^)?
     attr-dict-with-keyword
   }];
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 def PDL_TypeOp : PDL_Op<"type"> {
   let summary = "Define a type handle within a pattern";

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

let extraClassDeclaration = [{
     /// induction variable. LoopOp only has one region, so 0 is the only valid
     /// value for `index`.
     OperandRange getSuccessorEntryOperands(unsigned index);
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def IfOp : SCF_Op<"if",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getNumRegionInvocations",
                                   "getRegionInvocationBounds"]>,
        SingleBlockImplicitTerminator<"scf::YieldOp">, RecursiveSideEffects,
        NoRegionArguments]> {
let builders = [
     OpBuilder<(ins "Value":$operand,
       CArg<"function_ref<void (OpBuilder &, Location, Value, Value)>",
            "nullptr">:$bodyBuilderFn)>
   ];
 
   let arguments = (ins AnyType:$operand);
   let hasCustomAssemblyFormat = 1;
   let regions = (region SizedRegion<1>:$reductionOperator);
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def ReduceReturnOp :
     SCF_Op<"reduce.return", [HasParent<"ReduceOp">, NoSideEffect,
                               Terminator]> {
   let summary = "terminator for reduce operation";
   let description = [{
     "scf.reduce.return" is a special terminator operation for the block inside
let extraClassDeclaration = [{
     ConditionOp getConditionOp();
     YieldOp getYieldOp();
     Block::BlockArgListType getBeforeArguments();
     Block::BlockArgListType getAfterArguments();
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
-  let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 def YieldOp : SCF_Op<"yield", [NoSideEffect, ReturnLike, Terminator,
                                ParentOneOf<["ExecuteRegionOp, ForOp",
                                             "IfOp, ParallelOp, WhileOp"]>]> {
   let summary = "loop yield and termination operation";
   let description = [{
     "scf.yield" yields an SSA value from the SCF dialect op region and

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

let extraClassDeclaration = [{
     // Adds an empty entry block and loop merge block containing one
     // spv.mlir.merge op.
     void addEntryAndMergeBlock();
   }];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
+
+  let hasVerifier = 0;
+  let hasRegionVerifier = 1;
 }
 
 // -----
 
 def SPV_MergeOp : SPV_Op<"mlir.merge", [NoSideEffect, Terminator]> {
   let summary = "A special terminator for merging a structured selection/loop.";
 
   let description = [{
static SelectionOp createIfThen(
         OpBuilder &builder);
   }];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let hasCanonicalizer = 1;
+
+  let hasVerifier = 0;
+  let hasRegionVerifier = 1;
 }
 
 #endif // MLIR_DIALECT_SPIRV_IR_CONTROLFLOW_OPS

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

def SPV_ModuleOp : SPV_Op<"module",
   let extraClassDeclaration = [{
 
     bool isOptionalSymbol() { return true; }
 
     Optional<StringRef> getName() { return sym_name(); }
 
     static StringRef getVCETripleAttrName() { return "vce_triple"; }
   }];
+
+  let hasVerifier = 0;
+  let hasRegionVerifier = 1;
 }
 
 // -----
 
 def SPV_ReferenceOfOp : SPV_Op<"mlir.referenceof", [NoSideEffect]> {
   let summary = "Reference a specialization constant.";
 
   let description = [{
def SPV_SpecConstantOperationOp : SPV_Op<"SpecConstantOperation", [
 
   let results = (outs AnyType:$result);
 
   let regions = (region SizedRegion<1>:$body);
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
+
+  let hasVerifier = 0;
+  let hasRegionVerifier = 1;
 }
 
 // -----
 
 def SPV_YieldOp : SPV_Op<"mlir.yield", [
     HasParent<"SpecConstantOperationOp">, NoSideEffect, Terminator]> {
   let summary = [{
     Yields the result computed in `spv.SpecConstantOperation`'s

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

def Tensor_GenerateOp : Tensor_Op<"generate",
   let builders = [
     // Build op and populate its body per callback function.
     OpBuilder<(ins "Type":$resultTy, "ValueRange":$dynamicExtents,
       "function_ref<void(OpBuilder &, Location, ValueRange)>")>,
   ];
 
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_InsertOp : Tensor_Op<"insert",
     [NoSideEffect,
OpBuilder<(ins "Type":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
       CArg<"bool", "false">:$nofold,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
+  let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_SplatOp : Tensor_Op<"splat", [
     NoSideEffect,

mlir/include/mlir/IR/OpBase.td

 def AutomaticAllocationScope :
   NativeOpTrait<"AutomaticAllocationScope">;
 // Op supports operand broadcast behavior.
 def ResultsBroadcastableShape :
   NativeOpTrait<"ResultsBroadcastableShape">;
 // X op Y == Y op X
 def Commutative  : NativeOpTrait<"IsCommutative">;
 // op op X == op X (unary) / X op X == X (binary)
-def Idempotent  : NativeOpTrait<"IsIdempotent">;
+// FIXME: Idempotent should depend on SameOperandsAndResultType
+def Idempotent : NativeOpTrait<"IsIdempotent">;
 // op op X == X
-def Involution  : NativeOpTrait<"IsInvolution">;
+// FIXME: Involution should depend on SameOperandsAndResultType
+def Involution : NativeOpTrait<"IsInvolution">;
 // Op behaves like a constant.
 def ConstantLike : NativeOpTrait<"ConstantLike">;
 // Op is isolated from above.
 def IsolatedFromAbove : NativeOpTrait<"IsIsolatedFromAbove">;
 // Op results are float or vectors/tensors thereof.
 def ResultsAreFloatLike : NativeOpTrait<"ResultsAreFloatLike">;
 // Op has the same operand type.
 def SameTypeOperands : NativeOpTrait<"SameTypeOperands">;

 // Op is a terminator.
 def Terminator : NativeOpTrait<"IsTerminator">;
 // Op can be safely normalized in the presence of MemRefs with
 // non-identity maps.
 def MemRefsNormalizable : NativeOpTrait<"MemRefsNormalizable">;
 // Op is elementwise on tensor/vector operands and results.
 def Elementwise : NativeOpTrait<"Elementwise">;
 // Elementwise op can be applied to scalars instead tensor/vector operands.
-def Scalarizable : NativeOpTrait<"Scalarizable">;
+def Scalarizable : NativeOpTrait<"Scalarizable", [Elementwise]>;
 // Elementwise op can be applied to all-vector operands.
-def Vectorizable : NativeOpTrait<"Vectorizable">;
+def Vectorizable : NativeOpTrait<"Vectorizable", [Elementwise]>;
 // Elementwise op can be applied to all-tensor operands.
-def Tensorizable : NativeOpTrait<"Tensorizable">;
+def Tensorizable : NativeOpTrait<"Tensorizable", [Elementwise]>;
 
 // Group together `Elementwise`, `Scalarizable`, `Vectorizable`, and
 // `Tensorizable` for convenience.
 def ElementwiseMappable : TraitList<[
     Elementwise,
     Scalarizable,
     Vectorizable,
     Tensorizable,
class Op<Dialect dialect, string mnemonic, list<Trait> props = []> {
   ///   * ParseResult parse(OpAsmParser &parser, OperationState &result)
   ///   * void print(OpAsmPrinter &p)
   bit hasCustomAssemblyFormat = 0;
 
   // A bit indicating if the operation has additional invariants that need to
   // verified (aside from those verified by other ODS constructs). If set to `1`,
   // an additional `LogicalResult verify()` declaration will be generated on the
   // operation class. The operation should implement this method and verify the
-  // additional necessary invariants.
+  // additional necessary invariants. This verifier shouldn't access any nested
+  // operations because those operations may ill-formed. Use the
+  // `hasRegionVerifier` below instead.
   bit hasVerifier = 0;
 
   // A bit indicating if the operation has additional invariants that need to
   // verified and which associate with regions (aside from those verified by the
   // traits). If set to `1`, an additional `LogicalResult verifyRegions()`
   // declaration will be generated on the operation class. The operation should
   // implement this method and verify the additional necessary invariants
   // associated with regions. Note that this method is invoked after all the

mlir/include/mlir/IR/OpDefinition.h

static Operation *buildTerminator(OpBuilder &builder, Location loc) {
       TerminatorOpType::build(builder, state);
       return Operation::create(state);
     }
 
   public:
     /// The type of the operation used as the implicit terminator type.
     using ImplicitTerminatorOpT = TerminatorOpType;
 
-    static LogicalResult verifyTrait(Operation *op) {
+    static LogicalResult verifyRegionTrait(Operation *op) {
       if (failed(Base::verifyTrait(op)))
         return failure();
       for (unsigned i = 0, e = op->getNumRegions(); i < e; ++i) {
         Region &region = op->getRegion(i);
         // Empty regions are fine.
         if (region.empty())
           continue;
         Operation &terminator = region.front().back();

 };
 
 /// This class provides the API for ops that are known to be isolated from
 /// above.
 template <typename ConcreteType>
 class IsIsolatedFromAbove
     : public TraitBase<ConcreteType, IsIsolatedFromAbove> {
 public:
-  static LogicalResult verifyTrait(Operation *op) {
+  static LogicalResult verifyRegionTrait(Operation *op) {
     return impl::verifyIsIsolatedFromAbove(op);
   }
 };
 
 /// A trait of region holding operations that defines a new scope for polyhedral
 /// optimization purposes. Any SSA values of 'index' type that either dominate
 /// such an operation or are used at the top-level of such an operation
 /// automatically become valid symbols for the polyhedral scope defined by that

 /// This class provides a verifier for ops that are expecting their parent
 /// to be one of the given parent ops
 template <typename... ParentOpTypes>
 struct HasParent {
   template <typename ConcreteType>
   class Impl : public TraitBase<ConcreteType, Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
-      if (llvm::isa<ParentOpTypes...>(op->getParentOp()))
+      if (llvm::isa_and_nonnull<ParentOpTypes...>(op->getParentOp()))
         return success();
 
       return op->emitOpError()
              << "expects parent op "
              << (sizeof...(ParentOpTypes) != 1 ? "to be one of '" : "'")
              << llvm::makeArrayRef({ParentOpTypes::getOperationName()...})
              << "'";
     }

mlir/include/mlir/IR/SymbolTable.h

 /// that are directly within the region, i.e not including those within child
 /// regions, that contain a 'SymbolTable::getSymbolAttrName()' StringAttr will
 /// be verified to ensure that the names are uniqued. These operations must also
 /// adhere to the constraints defined by the `Symbol` trait, even if they do not
 /// inherit from it.
 template <typename ConcreteType>
 class SymbolTable : public TraitBase<ConcreteType, SymbolTable> {
 public:
-  static LogicalResult verifyTrait(Operation *op) {
+  static LogicalResult verifyRegionTrait(Operation *op) {
     return ::mlir::detail::verifySymbolTable(op);
   }
 
   /// Look up a symbol with the specified name, returning null if no such
   /// name exists. Symbol names never include the @ on them. Note: This
   /// performs a linear scan of held symbols.
   Operation *lookupSymbol(StringAttr name) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), name);

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

StaticInterfaceMethod<
       /*defaultImplementation=*/[{
         /// Returns whether two arrays are equal as strongest check for
         /// compatibility by default.
         return lhs == rhs;
       }]
     >,
   ];
 
+  // Inferring result types may need to access the region operations.
+  let verifyWithRegions = 1;
   let verify = [{
     return detail::verifyInferredResultTypes($_op);
   }];
 }
 
 def InferShapedTypeOpInterface : OpInterface<"InferShapedTypeOpInterface"> {
   let description = [{
     Interface to infer the components of a ShapedType returned by an operation

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

void AffineForOp::build(OpBuilder &builder, OperationState &result, int64_t lb,
                         int64_t ub, int64_t step, ValueRange iterArgs,
                         BodyBuilderFn bodyBuilder) {
   auto lbMap = AffineMap::getConstantMap(lb, builder.getContext());
   auto ubMap = AffineMap::getConstantMap(ub, builder.getContext());
   return build(builder, result, {}, lbMap, {}, ubMap, step, iterArgs,
                bodyBuilder);
 }
 
-LogicalResult AffineForOp::verify() {
+LogicalResult AffineForOp::verifyRegions() {
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = getBody();
   if (body->getNumArguments() == 0 || !body->getArgument(0).getType().isIndex())
     return emitOpError("expected body to have a single index argument for the "
                        "induction variable");
 
   // Verify that the bound operands are valid dimension/symbols.

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

if (parser.parseRegion(*body, /*arguments=*/{unwrappedArgs},
                          /*argTypes=*/{unwrappedTypes},
                          /*argLocations=*/{},
                          /*enableNameShadowing=*/false))
     return failure();
 
   return success();
 }
 
-LogicalResult ExecuteOp::verify() {
+LogicalResult ExecuteOp::verifyRegions() {
   // Unwrap async.execute value operands types.
   auto unwrappedTypes = llvm::map_range(operands(), [](Value operand) {
     return operand.getType().cast<ValueType>().getValueType();
   });
 
   // Verify that unwrapped argument types matches the body region arguments.
   if (body().getArgumentTypes() != unwrappedTypes)
     return emitOpError("async body region argument types do not match the "

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

auto walkResult = module.walk([&module](LaunchFuncOp launchOp) -> WalkResult {
     }
 
     return success();
   });
 
   return walkResult.wasInterrupted() ? failure() : success();
 }
 
-LogicalResult gpu::AllReduceOp::verify() {
+/// Verify the invariants that related to the regions. This will be invoked
+/// after the verification of regions' ops.
+LogicalResult gpu::AllReduceOp::verifyRegions() {
   if (body().empty() != op().hasValue())
     return emitError("expected either an op attribute or a non-empty body");
   if (!body().empty()) {
     if (body().getNumArguments() != 2)
       return emitError("expected two region arguments");
     for (auto argument : body().getArguments()) {
       if (argument.getType() != getType())
         return emitError("incorrect region argument type");

 KernelDim3 LaunchOp::getGridSizeOperandValues() {
   return KernelDim3{getOperand(0), getOperand(1), getOperand(2)};
 }
 
 KernelDim3 LaunchOp::getBlockSizeOperandValues() {
   return KernelDim3{getOperand(3), getOperand(4), getOperand(5)};
 }
 
-LogicalResult LaunchOp::verify() {
+LogicalResult LaunchOp::verifyRegions() {
   // Kernel launch takes kNumConfigOperands leading operands for grid/block
   // sizes and transforms them into kNumConfigRegionAttributes region arguments
   // for block/thread identifiers and grid/block sizes.
   if (!body().empty()) {
     if (body().getNumArguments() != LaunchOp::kNumConfigOperands +
                                         getNumOperands() -
                                         (dynamicSharedMemorySize() ? 1 : 0))
       return emitOpError("unexpected number of region arguments");

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

if (auto splatValue = value.dyn_cast<SplatElementsAttr>())
     return isZeroAttribute(splatValue.getSplatValue<Attribute>());
   if (auto elementsValue = value.dyn_cast<ElementsAttr>())
     return llvm::all_of(elementsValue.getValues<Attribute>(), isZeroAttribute);
   if (auto arrayValue = value.dyn_cast<ArrayAttr>())
     return llvm::all_of(arrayValue.getValue(), isZeroAttribute);
   return false;
 }
 
 LogicalResult GlobalOp::verify() {
   if (!LLVMPointerType::isValidElementType(getType()))
     return emitOpError(
         "expects type to be a valid element type for an LLVM pointer");
   if ((*this)->getParentOp() && !satisfiesLLVMModule((*this)->getParentOp()))
     return emitOpError("must appear at the module level");
 
   if (auto strAttr = getValueOrNull().dyn_cast_or_null<StringAttr>()) {
     auto type = getType().dyn_cast<LLVMArrayType>();
     IntegerType elementType =
         type ? type.getElementType().dyn_cast<IntegerType>() : nullptr;
     if (!elementType || elementType.getWidth() != 8 ||
         type.getNumElements() != strAttr.getValue().size())
       return emitOpError(
           "requires an i8 array type of the length equal to that of the string "
           "attribute");
   }
 
-  if (Block *b = getInitializerBlock()) {
-    ReturnOp ret = cast<ReturnOp>(b->getTerminator());
-    if (ret.operand_type_begin() == ret.operand_type_end())
-      return emitOpError("initializer region cannot return void");
-    if (*ret.operand_type_begin() != getType())
-      return emitOpError("initializer region type ")
-             << *ret.operand_type_begin() << " does not match global type "
-             << getType();
-
-    for (Operation &op : *b) {
-      auto iface = dyn_cast<MemoryEffectOpInterface>(op);
-      if (!iface || !iface.hasNoEffect())
-        return op.emitError()
-               << "ops with side effects not allowed in global initializers";
-    }
-
-    if (getValueOrNull())
-      return emitOpError("cannot have both initializer value and region");
-  }
-
   if (getLinkage() == Linkage::Common) {
     if (Attribute value = getValueOrNull()) {
       if (!isZeroAttribute(value)) {
         return emitOpError()
                << "expected zero value for '"
                << stringifyLinkage(Linkage::Common) << "' linkage";
       }
     }
if (alignAttr.hasValue()) {
     uint64_t value = alignAttr.getValue();
     if (!llvm::isPowerOf2_64(value))
       return emitError() << "alignment attribute is not a power of 2";
   }
 
   return success();
 }
 
+LogicalResult GlobalOp::verifyRegions() {
+  if (Block *b = getInitializerBlock()) {
+    ReturnOp ret = cast<ReturnOp>(b->getTerminator());
+    if (ret.operand_type_begin() == ret.operand_type_end())
+      return emitOpError("initializer region cannot return void");
+    if (*ret.operand_type_begin() != getType())
+      return emitOpError("initializer region type ")
+             << *ret.operand_type_begin() << " does not match global type "
+             << getType();
+
+    for (Operation &op : *b) {
+      auto iface = dyn_cast<MemoryEffectOpInterface>(op);
+      if (!iface || !iface.hasNoEffect())
+        return op.emitError()
+               << "ops with side effects not allowed in global initializers";
+    }
+
+    if (getValueOrNull())
+      return emitOpError("cannot have both initializer value and region");
+  }
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // LLVM::GlobalCtorsOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 GlobalCtorsOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   for (Attribute ctor : getCtors()) {
     if (failed(verifySymbolAttrUse(ctor.cast<FlatSymbolRefAttr>(), *this,
LogicalResult LLVMFuncOp::verifyType() {
 
   return success();
 }
 
 // Verifies LLVM- and implementation-specific properties of the LLVM func Op:
 // - functions don't have 'common' linkage
 // - external functions have 'external' or 'extern_weak' linkage;
 // - vararg is (currently) only supported for external functions;
-// - entry block arguments are of LLVM types and match the function signature.
 LogicalResult LLVMFuncOp::verify() {
   if (getLinkage() == LLVM::Linkage::Common)
     return emitOpError() << "functions cannot have '"
                          << stringifyLinkage(LLVM::Linkage::Common)
                          << "' linkage";
 
   // Check to see if this function has a void return with a result attribute to
   // it. It isn't clear what semantics we would assign to that.
if (getLinkage() != LLVM::Linkage::External &&
                            << stringifyLinkage(LLVM::Linkage::ExternWeak)
                            << "' linkage";
     return success();
   }
 
   if (isVarArg())
     return emitOpError("only external functions can be variadic");
 
+  return success();
+}
+
+/// Verifies LLVM- and implementation-specific properties of the LLVM func Op:
+/// - entry block arguments are of LLVM types and match the function signature.
+LogicalResult LLVMFuncOp::verifyRegions() {
+  if (isExternal())
+    return success();
+
   unsigned numArguments = getType().getNumParams();
   Block &entryBlock = front();
   for (unsigned i = 0; i < numArguments; ++i) {
     Type argType = entryBlock.getArgument(i).getType();
     if (!isCompatibleType(argType))
       return emitOpError("entry block argument #")
              << i << " is not of LLVM type";
     if (getType().getParamType(i) != argType)

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 }
 
 LogicalResult linalg::YieldOp::verify() {
   auto *parentOp = (*this)->getParentOp();
   if (parentOp->getNumRegions() != 1 || parentOp->getRegion(0).empty())
     return emitOpError("expected single non-empty parent region");
 
   if (auto linalgOp = dyn_cast<LinalgOp>(parentOp))
-    return verifyYield(*this, cast<LinalgOp>(parentOp));
+    return verifyYield(*this, linalgOp);
 
   return emitOpError("expected parent op with LinalgOp interface");
 }
 
 //===----------------------------------------------------------------------===//
 // IndexOp
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

if (!reductions || reductions->size() != reductionVars.size())
              << "expected as many reduction symbol references "
                 "as reduction variables";
   } else {
     if (reductions)
       return op->emitOpError() << "unexpected reduction symbol references";
     return success();
   }
 
+  // TODO: The followings should be done in
+  // SymbolUserOpInterface::verifySymbolUses.
   DenseSet<Value> accumulators;
   for (auto args : llvm::zip(reductionVars, *reductions)) {
     Value accum = std::get<0>(args);
 
     if (!accumulators.insert(accum).second)
       return op->emitOpError() << "accumulator variable used more than once";
 
     Type varType = accum.getType().cast<PointerLikeType>();

 // Verifier for SectionsOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SectionsOp::verify() {
   if (allocate_vars().size() != allocators_vars().size())
     return emitError(
         "expected equal sizes for allocate and allocator variables");
 
+  return verifyReductionVarList(*this, reductions(), reduction_vars());
+}
+
+LogicalResult SectionsOp::verifyRegions() {
   for (auto &inst : *region().begin()) {
     if (!(isa<SectionOp>(inst) || isa<TerminatorOp>(inst))) {
       return emitOpError()
              << "expected omp.section op or terminator op inside region";
     }
   }
 
-  return verifyReductionVarList(*this, reductions(), reduction_vars());
+  return success();
 }
 
 /// Parses an OpenMP Workshare Loop operation
 ///
 /// wsloop ::= `omp.wsloop` loop-control clause-list
 /// loop-control ::= `(` ssa-id-list `)` `:` type `=`  loop-bounds
 /// loop-bounds := `(` ssa-id-list `)` to `(` ssa-id-list `)` inclusive? steps
 /// steps := `step` `(`ssa-id-list`)`

 static void printAtomicReductionRegion(OpAsmPrinter &printer,
                                        ReductionDeclareOp op, Region &region) {
   if (region.empty())
     return;
   printer << "atomic ";
   printer.printRegion(region);
 }
 
-LogicalResult ReductionDeclareOp::verify() {
+LogicalResult ReductionDeclareOp::verifyRegions() {
   if (initializerRegion().empty())
     return emitOpError() << "expects non-empty initializer region";
   Block &initializerEntryBlock = initializerRegion().front();
   if (initializerEntryBlock.getNumArguments() != 1 ||
       initializerEntryBlock.getArgument(0).getType() != type()) {
     return emitOpError() << "expects initializer region with one argument "
                             "of the reduction type";
   }

 //===----------------------------------------------------------------------===//
 // Verifier for critical construct (2.17.1)
 //===----------------------------------------------------------------------===//
 
 LogicalResult CriticalDeclareOp::verify() {
   return verifySynchronizationHint(*this, hint_val());
 }
 
-LogicalResult CriticalOp::verify() {
+LogicalResult
+CriticalOp::verifySymbolUses(SymbolTableCollection &symbol_table) {
   if (nameAttr()) {
     SymbolRefAttr symbolRef = nameAttr();
-    auto decl = SymbolTable::lookupNearestSymbolFrom<CriticalDeclareOp>(
+    auto decl = symbol_table.lookupNearestSymbolFrom<CriticalDeclareOp>(
         *this, symbolRef);
     if (!decl) {
       return emitOpError() << "expected symbol reference " << symbolRef
                            << " to point to a critical declaration";
     }
   }
 
   return success();
LogicalResult AtomicWriteOp::verify() {
   }
   return verifySynchronizationHint(*this, hint_val());
 }
 
 //===----------------------------------------------------------------------===//
 // Verifier for AtomicUpdateOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult AtomicUpdateOp::verify() {
   if (auto mo = memory_order_val()) {
     if (*mo == ClauseMemoryOrderKind::Acq_rel ||
         *mo == ClauseMemoryOrderKind::Acquire) {
       return emitError(
           "memory-order must not be acq_rel or acquire for atomic updates");
     }
   }
 
-  if (region().getNumArguments() != 1)
-    return emitError("the region must accept exactly one argument");
-
   if (x().getType().cast<PointerLikeType>().getElementType() !=
       region().getArgument(0).getType()) {
     return emitError("the type of the operand must be a pointer type whose "
                      "element type is the same as that of the region argument");
   }
 
+  return success();
+}
+
+LogicalResult AtomicUpdateOp::verifyRegions() {
+  if (region().getNumArguments() != 1)
+    return emitError("the region must accept exactly one argument");
+
   YieldOp yieldOp = *region().getOps<YieldOp>().begin();
 
   if (yieldOp.results().size() != 1)
     return emitError("only updated value must be returned");
   if (yieldOp.results().front().getType() != region().getArgument(0).getType())
     return emitError("input and yielded value must have the same type");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Verifier for AtomicCaptureOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult AtomicCaptureOp::verify() {
+LogicalResult AtomicCaptureOp::verifyRegions() {
   Block::OpListType &ops = region().front().getOperations();
   if (ops.size() != 3)
     return emitError()
            << "expected three operations in omp.atomic.capture region (one "
               "terminator, and two atomic ops)";
   auto &firstOp = ops.front();
   auto &secondOp = *ops.getNextNode(firstOp);
   auto firstReadStmt = dyn_cast<AtomicReadOp>(firstOp);

mlir/lib/Dialect/PDL/IR/PDL.cpp

if (auto rInfo = RegisteredOperationName::lookup(*opName, getContext()))
     return rInfo->hasInterface<InferTypeOpInterface>();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult PatternOp::verify() {
+LogicalResult PatternOp::verifyRegions() {
   Region &body = getBodyRegion();
   Operation *term = body.front().getTerminator();
   auto rewriteOp = dyn_cast<RewriteOp>(term);
   if (!rewriteOp) {
     return emitOpError("expected body to terminate with `pdl.rewrite`")
         .attachNote(term->getLoc())
         .append("see terminator defined here");
   }
LogicalResult ResultsOp::verify() {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult RewriteOp::verify() {
+LogicalResult RewriteOp::verifyRegions() {
   Region &rewriteRegion = body();
 
   // Handle the case where the rewrite is external.
   if (name()) {
     if (!rewriteRegion.empty()) {
       return emitOpError()
              << "expected rewrite region to be empty when rewrite is external";
     }

mlir/lib/Dialect/SCF/SCF.cpp

void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
   }
 }
 
 LogicalResult ForOp::verify() {
   if (auto cst = getStep().getDefiningOp<arith::ConstantIndexOp>())
     if (cst.value() <= 0)
       return emitOpError("constant step operand must be positive");
 
+  auto opNumResults = getNumResults();
+  if (opNumResults == 0)
+    return success();
+  // If ForOp defines values, check that the number and types of
+  // the defined values match ForOp initial iter operands and backedge
+  // basic block arguments.
+  if (getNumIterOperands() != opNumResults)
+    return emitOpError(
+        "mismatch in number of loop-carried values and defined values");
+  return success();
+}
+
+LogicalResult ForOp::verifyRegions() {
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = getBody();
   if (!body->getArgument(0).getType().isIndex())
     return emitOpError(
         "expected body first argument to be an index argument for "
         "the induction variable");
 
   auto opNumResults = getNumResults();
   if (opNumResults == 0)
     return success();
-  // If ForOp defines values, check that the number and types of
-  // the defined values match ForOp initial iter operands and backedge
-  // basic block arguments.
-  if (getNumIterOperands() != opNumResults)
-    return emitOpError(
-        "mismatch in number of loop-carried values and defined values");
+
   if (getNumRegionIterArgs() != opNumResults)
     return emitOpError(
         "mismatch in number of basic block args and defined values");
+
   auto iterOperands = getIterOperands();
   auto iterArgs = getRegionIterArgs();
   auto opResults = getResults();
   unsigned i = 0;
   for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
     if (std::get<0>(e).getType() != std::get<2>(e).getType())
       return emitOpError() << "types mismatch between " << i
                            << "th iter operand and defined value";
void ReduceOp::build(
   Region *bodyRegion = result.addRegion();
   Block *body = builder.createBlock(bodyRegion, {}, ArrayRef<Type>{type, type},
                                     {result.location, result.location});
   if (bodyBuilderFn)
     bodyBuilderFn(builder, result.location, body->getArgument(0),
                   body->getArgument(1));
 }
 
-LogicalResult ReduceOp::verify() {
+LogicalResult ReduceOp::verifyRegions() {
   // The region of a ReduceOp has two arguments of the same type as its operand.
   auto type = getOperand().getType();
   Block &block = getReductionOperator().front();
   if (block.empty())
     return emitOpError("the block inside reduce should not be empty");
   if (block.getNumArguments() != 2 ||
       llvm::any_of(block.getArguments(), [&](const BlockArgument &arg) {
         return arg.getType() != type;
if (auto yield = dyn_cast_or_null<TerminatorTy>(terminatorOperation))
     return yield;
 
   auto diag = op.emitOpError(errorMessage);
   if (terminatorOperation)
     diag.attachNote(terminatorOperation->getLoc()) << "terminator here";
   return nullptr;
 }
 
-LogicalResult scf::WhileOp::verify() {
+LogicalResult scf::WhileOp::verifyRegions() {
   auto beforeTerminator = verifyAndGetTerminator<scf::ConditionOp>(
       *this, getBefore(),
       "expects the 'before' region to terminate with 'scf.condition'");
   if (!beforeTerminator)
     return failure();
 
   auto afterTerminator = verifyAndGetTerminator<scf::YieldOp>(
       *this, getAfter(),

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

static inline bool hasOneBranchOpTo(Block &srcBlock, Block &dstBlock) {
   // Check that there is only one op in the `srcBlock`.
   if (!llvm::hasSingleElement(srcBlock))
     return false;
 
   auto branchOp = dyn_cast<spirv::BranchOp>(srcBlock.back());
   return branchOp && branchOp.getSuccessor() == &dstBlock;
 }
 
-LogicalResult spirv::LoopOp::verify() {
+LogicalResult spirv::LoopOp::verifyRegions() {
   auto *op = getOperation();
 
   // We need to verify that the blocks follow the following layout:
   //
   //                     +-------------+
   //                     | entry block |
   //                     +-------------+
   //                            |

 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MergeOp::verify() {
   auto *parentOp = (*this)->getParentOp();
   if (!parentOp || !isa<spirv::SelectionOp, spirv::LoopOp>(parentOp))
     return emitOpError(
         "expected parent op to be 'spv.mlir.selection' or 'spv.mlir.loop'");
 
+  // TODO: This check should be done in `verifyRegions` of parent op.
   Block &parentLastBlock = (*this)->getParentRegion()->back();
   if (getOperation() != parentLastBlock.getTerminator())
     return emitOpError("can only be used in the last block of "
                        "'spv.mlir.selection' or 'spv.mlir.loop'");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
if (Optional<spirv::VerCapExtAttr> triple = vce_triple()) {
     elidedAttrs.push_back(spirv::ModuleOp::getVCETripleAttrName());
   }
 
   printer.printOptionalAttrDictWithKeyword((*this)->getAttrs(), elidedAttrs);
   printer << ' ';
   printer.printRegion(getRegion());
 }
 
-LogicalResult spirv::ModuleOp::verify() {
+LogicalResult spirv::ModuleOp::verifyRegions() {
   Dialect *dialect = (*this)->getDialect();
   DenseMap<std::pair<spirv::FuncOp, spirv::ExecutionModel>, spirv::EntryPointOp>
       entryPoints;
   mlir::SymbolTable table(*this);
 
   for (auto &op : *getBody()) {
     if (op.getDialect() != dialect)
       return op.emitError("'spv.module' can only contain spv.* ops");
void spirv::SelectionOp::print(OpAsmPrinter &printer) {
   auto control = selection_control();
   if (control != spirv::SelectionControl::None)
     printer << " control(" << spirv::stringifySelectionControl(control) << ")";
   printer << ' ';
   printer.printRegion(getRegion(), /*printEntryBlockArgs=*/false,
                       /*printBlockTerminators=*/true);
 }
 
-LogicalResult spirv::SelectionOp::verify() {
+LogicalResult spirv::SelectionOp::verifyRegions() {
   auto *op = getOperation();
 
   // We need to verify that the blocks follow the following layout:
   //
   //                     +--------------+
   //                     | header block |
   //                     +--------------+
   //                          / | \
ParseResult spirv::SpecConstantOperationOp::parse(OpAsmParser &parser,
   return success();
 }
 
 void spirv::SpecConstantOperationOp::print(OpAsmPrinter &printer) {
   printer << " wraps ";
   printer.printGenericOp(&body().front().front());
 }
 
-LogicalResult spirv::SpecConstantOperationOp::verify() {
+LogicalResult spirv::SpecConstantOperationOp::verifyRegions() {
   Block &block = getRegion().getBlocks().front();
 
   if (block.getOperations().size() != 2)
     return emitOpError("expected exactly 2 nested ops");
 
   Operation &enclosedOp = block.getOperations().front();
 
   if (!enclosedOp.hasTrait<OpTrait::spirv::UsableInSpecConstantOp>())
     return emitOpError("invalid enclosed op");

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 LogicalResult GenerateOp::verify() {
   // Ensure that the tensor type has as many dynamic dimensions as are specified
   // by the operands.
   RankedTensorType resultTy = getType().cast<RankedTensorType>();
   if (getNumOperands() != resultTy.getNumDynamicDims())
     return emitError("must have as many index operands as dynamic extents "
                      "in the result type");
 
+  return success();
+}
+
+LogicalResult GenerateOp::verifyRegions() {
+  RankedTensorType resultTy = getType().cast<RankedTensorType>();
   // Ensure that region arguments span the index space.
   if (!llvm::all_of(body().getArgumentTypes(),
                     [](Type ty) { return ty.isIndex(); }))
     return emitError("all body arguments must be index");
   if (body().getNumArguments() != resultTy.getRank())
     return emitError("must have one body argument per input dimension");
 
   // Ensure that the region yields an element of the right type.
if (resultType.getDimSize(i) == expectedType.getDimSize(i))
       continue;
     if (expectedType.isDynamicDim(i))
       continue;
     return emitError("specified type ")
            << resultType << " does not match the inferred type "
            << expectedType;
   }
 
+  return success();
+}
+
+LogicalResult PadOp::verifyRegions() {
   auto &region = getRegion();
-  unsigned rank = resultType.getRank();
+  unsigned rank = result().getType().cast<RankedTensorType>().getRank();
   Block &block = region.front();
   if (block.getNumArguments() != rank)
     return emitError("expected the block to have ") << rank << " arguments";
 
   // Note: the number and type of yield values are checked in the YieldOp.
   for (const auto &en : llvm::enumerate(block.getArgumentTypes())) {
     if (!en.value().isIndex())
       return emitOpError("expected block argument ")

mlir/lib/IR/Operation.cpp

LogicalResult OpTrait::impl::verifyIsIsolatedFromAbove(Operation *isolatedOp) {
   // Therefore, use a simple vector and push/pop back the current region.
   SmallVector<Region *, 8> pendingRegions;
   for (auto &region : isolatedOp->getRegions()) {
     pendingRegions.push_back(&region);
 
     // Traverse all operations in the region.
     while (!pendingRegions.empty()) {
       for (Operation &op : pendingRegions.pop_back_val()->getOps()) {
         for (Value operand : op.getOperands()) {
-          // operand should be non-null here if the IR is well-formed. But
-          // we don't assert here as this function is called from the verifier
-          // and so could be called on invalid IR.
-          if (!operand)
-            return op.emitOpError("operation's operand is null");
-
           // Check that any value that is used by an operation is defined in the
           // same region as either an operation result.
           auto *operandRegion = operand.getParentRegion();
           if (!operandRegion)
             return op.emitError("operation's operand is unlinked");
           if (!region.isAncestor(operandRegion)) {
             return op.emitOpError("using value defined outside the region")
                        .attachNote(isolatedOp->getLoc())
                    << "required by region isolation constraints";

mlir/test/Dialect/GPU/invalid.mlir

 
 // -----
 
 func @no_region_attrs(%sz : index) {
   // expected-error@+1 {{unexpected number of region arguments}}
  "gpu.launch"(%sz, %sz, %sz, %sz, %sz, %sz) ({
   ^bb1(%bx: index, %by: index, %bz: index,
        %tx: index, %ty: index, %tz: index):
-    gpu.return
+    gpu.terminator
   }) : (index, index, index, index, index, index) -> ()
   return
 }
 
 // -----
 
 func @launch_requires_gpu_return(%sz : index) {
   // @expected-note@+1 {{in 'gpu.launch' body region}}
   gpu.launch blocks(%bx, %by, %bz) in (%sbx = %sz, %sby = %sz, %sbz = %sz)
              threads(%tx, %ty, %tz) in (%stx = %sz, %sty = %sz, %stz = %sz) {
-    // @expected-error@+1 {{expected 'gpu.terminator' or a terminator with successors}}
-    return
+    // @expected-error@+2 {{expected 'gpu.terminator' or a terminator with successors}}
+    %one = arith.constant 1 : i32
+    "gpu.yield"(%one) : (i32) -> ()
   }
   return
 }
 
 // -----
 
 func @launch_func_too_few_operands(%sz : index) {
   // expected-error@+1 {{expected 6 or more operands}}

 }
 
 // -----
 
 func @reduce_incorrect_yield(%arg0 : f32) {
   // expected-error@+1 {{expected gpu.yield op in region}}
   %res = gpu.all_reduce %arg0 {
   ^bb(%lhs : f32, %rhs : f32):
-    return
+    "test.finish" () : () -> ()
   } : (f32) -> (f32)
   return
 }
 
 // -----
 
 func @shuffle_mismatching_type(%arg0 : f32, %arg1 : i32, %arg2 : i32) {
   // expected-error@+1 {{op failed to verify that all of {value, result} have same type}}

mlir/test/Dialect/LLVMIR/global.mlir

 
 llvm.func @bar() {
   // expected-error @+1 {{the type must be a pointer to the type of the referenced function}}
   llvm.mlir.addressof @foo : !llvm.ptr<i8>
 }
 
 // -----
 
-// expected-error @+2 {{'llvm.mlir.global' op expects regions to end with 'llvm.return', found 'llvm.mlir.constant'}}
-// expected-note @+1 {{in custom textual format, the absence of terminator implies 'llvm.return'}}
+// expected-error @+2 {{block with no terminator}}
 llvm.mlir.global internal @g() : i64 {
   %c = llvm.mlir.constant(42 : i64) : i64
 }
 
 // -----
 
 // expected-error @+1 {{'llvm.mlir.global' op initializer region type 'i64' does not match global type 'i32'}}
 llvm.mlir.global internal @g() : i32 {

mlir/test/Dialect/Linalg/invalid.mlir

linalg.generic {
     ins(%arg0 : memref<f32>)
    outs(%arg0 : memref<f32>) {
   }
 }
 
 // -----
 
 func @generic_mismatched_num_arguments(%arg0: memref<f32>) {
-  // expected-error @+1 {{expected as many non-induction variable region arguments as the number of input/output operands}}
+  // expected-error @+6 {{'linalg.yield' op expected number of yield values (2) to match the number of operands of the enclosing LinalgOp (1)}}
   linalg.generic {
       indexing_maps =  [ affine_map<() -> ()>, affine_map<() -> ()> ],
       iterator_types = []}
       outs(%arg0, %arg0 : memref<f32>, memref<f32>) {
     ^bb(%f: f32):
       linalg.yield %f: f32
   }
 }
 
 // -----
 
 func @generic_shaped_operand_block_arg_type(%arg0: memref<f32>) {
-  // expected-error @+1 {{expected type of bb argument #0 ('i1') to match element or self type of the corresponding operand ('f32')}}
+  // expected-error @+6 {{'linalg.yield' op type of yield operand 1 ('i1') doesn't match the element type of the enclosing linalg.generic op ('f32')}}
   linalg.generic {
     indexing_maps =  [ affine_map<() -> ()> ],
     iterator_types = []}
       outs(%arg0 : memref<f32>) {
     ^bb(%i: i1):
     linalg.yield %i : i1
   }
 }
 
 // -----
 
 func @generic_scalar_operand_block_arg_type(%arg0: tensor<f32>) {
-  // expected-error @+1 {{expected type of bb argument #0 ('i1') to match element or self type of the corresponding operand ('f32')}}
+  // expected-error @+6 {{'linalg.yield' op type of yield operand 1 ('i1') doesn't match the element type of the enclosing linalg.generic op ('f32')}}
   linalg.generic {
     indexing_maps =  [ affine_map<() -> ()> ],
     iterator_types = []}
       outs(%arg0 : tensor<f32>) {
     ^bb(%i: i1):
     linalg.yield %i : i1
   } -> tensor<f32>
 }
iterator_types = ["reduction"]}
       outs(%arg1 : tensor<?xf32>) {
     ^bb(%i: f32, %j: f32):
       linalg.yield %i: f32
   } -> tensor<?xf32>
 }
 
 // -----
 
-func @generic(%arg0: memref<?x?xi4>) {
-  // expected-error @+2 {{op expects regions to end with 'linalg.yield', found 'arith.addf'}}
-  // expected-note @+1 {{in custom textual format, the absence of terminator implies 'linalg.yield'}}
+func @generic(%arg0: memref<?x?xf32>) {
+  // expected-error @+6 {{block with no terminator, has %0 = "arith.addf"(%arg1, %arg1) : (f32, f32) -> f32}}
   linalg.generic  {
     indexing_maps = [ affine_map<(i, j) -> (i, j)> ],
     iterator_types = ["parallel", "parallel"]}
-      outs(%arg0 : memref<?x?xi4>) {
-    ^bb(%0: i4) :
-      %1 = arith.addf %0, %0: i4
+      outs(%arg0 : memref<?x?xf32>) {
+    ^bb(%0: f32) :
+      %1 = arith.addf %0, %0: f32
   }
   return
 }
 
 // -----
 
 // This test is currently disabled: subject to verifier ordering issues.
 // Instead, when the ranks are not greater than 2, an assertion will be triggered

mlir/test/Dialect/PDL/invalid.mlir

 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 // expected-error@below {{expected body to terminate with `pdl.rewrite`}}
 pdl.pattern : benefit(1) {
   // expected-note@below {{see terminator defined here}}
-  return
+  "test.finish" () : () -> ()
 }
 
 // -----
 
 // expected-error@below {{the pattern must contain at least one `pdl.operation`}}
 pdl.pattern : benefit(1) {
   rewrite with "foo"
 }

mlir/test/Dialect/SCF/invalid.mlir

 }
 
 // -----
 
 func @reduce_empty_block(%arg0 : index, %arg1 : f32) {
   %zero = arith.constant 0.0 : f32
   %res = scf.parallel (%i0) = (%arg0) to (%arg0)
                                        step (%arg0) init (%zero) -> f32 {
-    // expected-error@+1 {{the block inside reduce should not be empty}}
+    // expected-error@+1 {{empty block: expect at least a terminator}}
     scf.reduce(%arg1) : f32 {
       ^bb0(%lhs : f32, %rhs : f32):
     }
   }
   return
 }
 
 // -----

 
 func @reduce_wrong_terminator(%arg0 : index, %arg1 : f32) {
   %zero = arith.constant 0.0 : f32
   %res = scf.parallel (%i0) = (%arg0) to (%arg0)
                                        step (%arg0) init (%zero) -> f32 {
     // expected-error@+1 {{the block inside reduce should be terminated with a 'scf.reduce.return' op}}
     scf.reduce(%arg1) : f32 {
       ^bb0(%lhs : f32, %rhs : f32):
-        scf.yield
+        "test.finish" () : () -> ()
     }
   }
   return
 }
 
 // -----
 
 func @reduceReturn_wrong_type(%arg0 : index, %arg1: f32) {

mlir/test/Dialect/Tensor/invalid.mlir

func @tensor.generate(%m : index, %n : index)
   } : tensor<?x3x?xf32>
   return %tnsr : tensor<?x3x?xf32>
 }
 
 // -----
 
 func @tensor.generate(%m : index, %n : index)
     -> tensor<?x3x?xf32> {
-  // expected-error @+2 {{op expects regions to end with 'tensor.yield', found 'func.return'}}
-  // expected-note @+1 {{in custom textual format, the absence of terminator implies 'tensor.yield'}}
+  // expected-error @+4 {{'func.return' op expects parent op 'builtin.func'}}
   %tnsr = tensor.generate %m, %n {
     ^bb0(%i : index, %j : index, %k : index):
       %elem = arith.constant 8.0 : f32
       return %elem : f32
   } : tensor<?x3x?xf32>
   return %tnsr : tensor<?x3x?xf32>
 }
 

 }
 
 // -----
 
 func @invalid_splat(%v : vector<8xf32>) {
   // expected-error@+1 {{must be integer/index/float type}}
   %w = tensor.splat %v : tensor<8xvector<8xf32>>
   return
-}
+}
 

mlir/test/IR/invalid.mlir

func @return_type_mismatch() -> i32 {
   %0 = "foo"() : ()->f32
   return %0 : f32  // expected-error {{type of return operand 0 ('f32') doesn't match function result type ('i32') in function @return_type_mismatch}}
 }
 
 // -----
 
 func @return_inside_loop() {
   affine.for %i = 1 to 100 {
-    // expected-error@-1 {{op expects regions to end with 'affine.yield', found 'func.return'}}
-    // expected-note@-2 {{in custom textual format, the absence of terminator implies}}
+    // expected-error@+1 {{'func.return' op expects parent op 'builtin.func'}}
     return
   }
   return
 }
 
 // -----
 
 // expected-error@+1 {{expected three consecutive dots for an ellipsis}}

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 void OpEmitter::genCustomVerifier() {
   auto *valueInit = def.getValueInit("verifier");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   bool hasCustomVerifyCodeBlock = stringInit && !stringInit->getValue().empty();
 
   if (def.getValueAsBit("hasVerifier")) {
     auto *method = opClass.declareMethod("::mlir::LogicalResult", "verify");
     ERROR_IF_PRUNED(method, "verify", op);
-  } else if (def.getValueAsBit("hasRegionVerifier")) {
-    auto *method =
-        opClass.declareMethod("::mlir::LogicalResult", "verifyRegions");
-    ERROR_IF_PRUNED(method, "verifyRegions", op);
   } else if (hasCustomVerifyCodeBlock) {
     auto *method = opClass.addMethod("::mlir::LogicalResult", "verify");
     ERROR_IF_PRUNED(method, "verify", op);
     auto &body = method->body();
 
     FmtContext fctx;
     fctx.addSubst("cppClass", opClass.getClassName());
     auto printer = stringInit->getValue().ltrim().rtrim(" \t\v\f\r");
     body << "  " << tgfmt(printer, &fctx);
   }
+
+  if (def.getValueAsBit("hasRegionVerifier")) {
+    auto *method =
+        opClass.declareMethod("::mlir::LogicalResult", "verifyRegions");
+    ERROR_IF_PRUNED(method, "verifyRegions", op);
+  }
 }
 
 void OpEmitter::genOperandResultVerifier(MethodBody &body,
                                          Operator::const_value_range values,
                                          StringRef valueKind) {
   // Check that an optional value is at most 1 element.
   //
   // {0}: Value index.