```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
let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1;
let hasFolder = 1;
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def AffineIfOp : Affine_Op<"if",
let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1;
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
let builders = [
OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$dependencies,
"ValueRange":$operands,
let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1;
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def GPU_PrintfOp : GPU_Op<"printf", [MemoryEffects<[MemWrite]>]>,
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">;
let hasCustomAssemblyFormat = 1;
let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def LLVM_GlobalCtorsOp : LLVM_Op<"mlir.global_ctors", [
let hasCustomAssemblyFormat = 1;
let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def LLVM_NullOp
}];
let cppNamespace = "::mlir::linalg";
let verify = [{ return detail::verifyContractionInterface($_op); }];
+ let verifyWithRegions = 1;
let methods = [
InterfaceMethod<
/*desc=*/"Returns the left-hand side operand.",
}];
let verify = [{ return detail::verifyStructuredOpInterface($_op); }];
+ let verifyWithRegions = 1;
}
#endif // LINALG_IR_LINALGINTERFACES
}];
let hasVerifier = 1;
+ let hasRegionVerifier = 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
let assemblyFormat = [{
(`(` $name^ `)`)? $region attr-dict
}];
- let hasVerifier = 1;
}
//===----------------------------------------------------------------------===//
$x `:` type($x) $region attr-dict
}];
let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def AtomicCaptureOp : OpenMP_Op<"atomic.capture",
|`hint` `(` custom<SynchronizationHint>($hint_val) `)`)
$region attr-dict
}];
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
//===----------------------------------------------------------------------===//
return atomicReductionRegion().front().getArgument(0).getType();
}
}];
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
//===----------------------------------------------------------------------===//
/// Returns the rewrite operation of this pattern.
RewriteOp getRewriter();
}];
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
//===----------------------------------------------------------------------===//
($body^)?
attr-dict-with-keyword
}];
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
//===----------------------------------------------------------------------===//
let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1;
let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def IfOp : SCF_Op<"if",
let arguments = (ins AnyType:$operand);
let hasCustomAssemblyFormat = 1;
let regions = (region SizedRegion<1>:$reductionOperator);
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def ReduceReturnOp :
let hasCanonicalizer = 1;
let hasCustomAssemblyFormat = 1;
- let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
def YieldOp : SCF_Op<"yield", [NoSideEffect, ReturnLike, Terminator,
let hasOpcode = 0;
let autogenSerialization = 0;
+
+ let hasVerifier = 0;
+ let hasRegionVerifier = 1;
}
// -----
let autogenSerialization = 0;
let hasCanonicalizer = 1;
+
+ let hasVerifier = 0;
+ let hasRegionVerifier = 1;
}
#endif // MLIR_DIALECT_SPIRV_IR_CONTROLFLOW_OPS
static StringRef getVCETripleAttrName() { return "vce_triple"; }
}];
+
+ let hasVerifier = 0;
+ let hasRegionVerifier = 1;
}
// -----
let hasOpcode = 0;
let autogenSerialization = 0;
+
+ let hasVerifier = 0;
+ let hasRegionVerifier = 1;
}
// -----
let hasCanonicalizer = 1;
let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
//===----------------------------------------------------------------------===//
let hasCanonicalizer = 1;
let hasFolder = 1;
let hasVerifier = 1;
+ let hasRegionVerifier = 1;
}
//===----------------------------------------------------------------------===//
// 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.
// 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.
// 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
/// 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) {
class IsIsolatedFromAbove
: public TraitBase<ConcreteType, IsIsolatedFromAbove> {
public:
- static LogicalResult verifyTrait(Operation *op) {
+ static LogicalResult verifyRegionTrait(Operation *op) {
return impl::verifyIsIsolatedFromAbove(op);
}
};
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()
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);
}
>,
];
+ // Inferring result types may need to access the region operations.
+ let verifyWithRegions = 1;
let verify = [{
return detail::verifyInferredResultTypes($_op);
}];
bodyBuilder);
}
-LogicalResult AffineForOp::verify() {
+LogicalResult AffineForOp::verifyRegions() {
// Check that the body defines as single block argument for the induction
// variable.
auto *body = getBody();
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();
return walkResult.wasInterrupted() ? failure() : success();
}
-LogicalResult gpu::AllReduceOp::verify() {
+LogicalResult gpu::AllReduceOp::verifyRegions() {
if (body().empty() != op().hasValue())
return emitError("expected either an op attribute or a non-empty body");
if (!body().empty()) {
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.
"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 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
//===----------------------------------------------------------------------===//
// - 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 '"
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) {
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");
}
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);
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()
}
}
- return verifyReductionVarList(*this, reductions(), reduction_vars());
+ return success();
}
/// Parses an OpenMP Workshare Loop operation
printer.printRegion(region);
}
-LogicalResult ReductionDeclareOp::verify() {
+LogicalResult ReductionDeclareOp::verifyRegions() {
if (initializerRegion().empty())
return emitOpError() << "expects non-empty initializer region";
Block &initializerEntryBlock = initializerRegion().front();
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
}
}
- 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");
+
if (region().front().getOperations().size() < 2)
return emitError() << "the update region must have at least two operations "
"(binop and terminator)";
// Verifier for AtomicCaptureOp
//===----------------------------------------------------------------------===//
-LogicalResult AtomicCaptureOp::verify() {
+LogicalResult AtomicCaptureOp::verifyRegions() {
Block::OpListType &ops = region().front().getOperations();
if (ops.size() != 3)
return emitError()
// pdl::PatternOp
//===----------------------------------------------------------------------===//
-LogicalResult PatternOp::verify() {
+LogicalResult PatternOp::verifyRegions() {
Region &body = getBodyRegion();
Operation *term = body.front().getTerminator();
auto rewriteOp = dyn_cast<RewriteOp>(term);
// pdl::RewriteOp
//===----------------------------------------------------------------------===//
-LogicalResult RewriteOp::verify() {
+LogicalResult RewriteOp::verifyRegions() {
Region &rewriteRegion = body();
// Handle the case where the rewrite is external.
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();
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();
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();
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'");
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:
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 "
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;
/*printBlockTerminators=*/true);
}
-LogicalResult spirv::SelectionOp::verify() {
+LogicalResult spirv::SelectionOp::verifyRegions() {
auto *op = getOperation();
// We need to verify that the blocks follow the following layout:
printer.printGenericOp(&body().front().front());
}
-LogicalResult spirv::SpecConstantOperationOp::verify() {
+LogicalResult spirv::SpecConstantOperationOp::verifyRegions() {
Block &block = getRegion().getBlocks().front();
if (block.getOperations().size() != 2)
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(); }))
<< expectedType;
}
+ return success();
+}
+
+LogicalResult PadOp::verifyRegions() {
auto ®ion = 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";
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();
"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
}
// @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
}
// 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
}
// -----
-// 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
}
// -----
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 = []}
// -----
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 = []}
// -----
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 = []}
// -----
-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
}
// expected-error@below {{expected body to terminate with `pdl.rewrite`}}
pdl.pattern : benefit(1) {
// expected-note@below {{see terminator defined here}}
- return
+ "test.finish" () : () -> ()
}
// -----
%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):
}
// 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 @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
// expected-error@+1 {{must be integer/index/float type}}
%w = tensor.splat %v : tensor<8xvector<8xf32>>
return
-}
\ No newline at end of file
+}
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
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 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,
projects / platform / upstream / llvm.git / commitdiff