Skip to content

Commit b98dc03

Browse files
River707River707
committed
[mlir][NFC] Update MemRef/Tensor operations to use hasVerifier instead of verifier
The verifier field is deprecated, and slated for removal. Differential Revision: https://reviews.llvm.org/D118821
1 parent bdc7ce9 commit b98dc03

File tree

6 files changed

+325
-314
lines changed

6 files changed

+325
-314
lines changed

‎mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

Lines changed: 25 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,6 @@ def MemRefTypeAttr
2828
class MemRef_Op<string mnemonic, list<Trait> traits = []>
2929
: Op<MemRef_Dialect, mnemonic, traits> {
3030
let printer = [{ return ::print(p, *this); }];
31-
let verifier = [{ return ::verify(*this); }];
3231
let parser = [{ return ::parse$cppClass(parser, result); }];
3332
}
3433

@@ -93,6 +92,7 @@ class AllocLikeOp<string mnemonic,
9392
}];
9493

9594
let hasCanonicalizer = 1;
95+
let hasVerifier = 1;
9696
}
9797

9898
//===----------------------------------------------------------------------===//
@@ -115,6 +115,7 @@ def AssumeAlignmentOp : MemRef_Op<"assume_alignment"> {
115115
let results = (outs);
116116

117117
let assemblyFormat = "$memref `,` $alignment attr-dict `:` type($memref)";
118+
let hasVerifier = 1;
118119
}
119120

120121
//===----------------------------------------------------------------------===//
@@ -162,6 +163,7 @@ def MemRef_AllocOp : AllocLikeOp<"alloc", DefaultResource, []> {
162163
memref<8x64xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
163164
```
164165
}];
166+
let hasVerifier = 1;
165167
}
166168

167169
//===----------------------------------------------------------------------===//
@@ -205,6 +207,7 @@ def MemRef_AllocaOp : AllocLikeOp<"alloca", AutomaticAllocationScopeResource> {
205207
an alignment on any convenient boundary compatible with the type will be
206208
chosen.
207209
}];
210+
let hasVerifier = 1;
208211
}
209212

210213
//===----------------------------------------------------------------------===//
@@ -253,6 +256,7 @@ def MemRef_AllocaScopeOp : MemRef_Op<"alloca_scope",
253256

254257
let results = (outs Variadic<AnyType>:$results);
255258
let regions = (region SizedRegion<1>:$bodyRegion);
259+
let hasVerifier = 1;
256260
}
257261

258262
//===----------------------------------------------------------------------===//
@@ -279,11 +283,7 @@ def MemRef_AllocaScopeReturnOp : MemRef_Op<"alloca_scope.return",
279283
let arguments = (ins Variadic<AnyType>:$results);
280284
let builders = [OpBuilder<(ins), [{ /*nothing to do */ }]>];
281285

282-
let assemblyFormat =
283-
[{ attr-dict ($results^ `:` type($results))? }];
284-
285-
// No custom verification needed.
286-
let verifier = ?;
286+
let assemblyFormat = "attr-dict ($results^ `:` type($results))?";
287287
}
288288

289289
//===----------------------------------------------------------------------===//
@@ -355,7 +355,6 @@ def MemRef_CastOp : MemRef_Op<"cast", [
355355
let arguments = (ins AnyRankedOrUnrankedMemRef:$source);
356356
let results = (outs AnyRankedOrUnrankedMemRef:$dest);
357357
let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
358-
let verifier = "return impl::verifyCastOp(*this, areCastCompatible);";
359358
let builders = [
360359
OpBuilder<(ins "Value":$source, "Type":$destType), [{
361360
impl::buildCastOp($_builder, $_state, source, destType);
@@ -370,6 +369,7 @@ def MemRef_CastOp : MemRef_Op<"cast", [
370369
}];
371370

372371
let hasFolder = 1;
372+
let hasVerifier = 1;
373373
}
374374

375375
//===----------------------------------------------------------------------===//
@@ -408,7 +408,6 @@ def CopyOp : MemRef_Op<"copy",
408408

409409
let hasCanonicalizer = 1;
410410
let hasFolder = 1;
411-
let verifier = ?;
412411
}
413412

414413
//===----------------------------------------------------------------------===//
@@ -434,7 +433,6 @@ def MemRef_DeallocOp : MemRef_Op<"dealloc", [MemRefsNormalizable]> {
434433
let arguments = (ins Arg<AnyRankedOrUnrankedMemRef, "", [MemFree]>:$memref);
435434

436435
let hasFolder = 1;
437-
let verifier = ?;
438436
let assemblyFormat = "$memref attr-dict `:` type($memref)";
439437
}
440438

@@ -488,6 +486,7 @@ def MemRef_DimOp : MemRef_Op<"dim", [NoSideEffect, MemRefsNormalizable]> {
488486

489487
let hasCanonicalizer = 1;
490488
let hasFolder = 1;
489+
let hasVerifier = 1;
491490
}
492491

493492
//===----------------------------------------------------------------------===//
@@ -646,6 +645,7 @@ def MemRef_DmaStartOp : MemRef_Op<"dma_start"> {
646645
}
647646
}];
648647
let hasFolder = 1;
648+
let hasVerifier = 1;
649649
}
650650

651651
//===----------------------------------------------------------------------===//
@@ -697,6 +697,7 @@ def MemRef_DmaWaitOp : MemRef_Op<"dma_wait"> {
697697
Value getNumElements() { return numElements(); }
698698
}];
699699
let hasFolder = 1;
700+
let hasVerifier = 1;
700701
}
701702

702703
//===----------------------------------------------------------------------===//
@@ -757,6 +758,7 @@ def GenericAtomicRMWOp : MemRef_Op<"generic_atomic_rmw", [
757758
return memref().getType().cast<MemRefType>();
758759
}
759760
}];
761+
let hasVerifier = 1;
760762
}
761763

762764
def AtomicYieldOp : MemRef_Op<"atomic_yield", [
@@ -772,6 +774,7 @@ def AtomicYieldOp : MemRef_Op<"atomic_yield", [
772774

773775
let arguments = (ins AnyType:$result);
774776
let assemblyFormat = "$result attr-dict `:` type($result)";
777+
let hasVerifier = 1;
775778
}
776779

777780
//===----------------------------------------------------------------------===//
@@ -797,9 +800,6 @@ def MemRef_GetGlobalOp : MemRef_Op<"get_global",
797800
let arguments = (ins FlatSymbolRefAttr:$name);
798801
let results = (outs AnyStaticShapeMemRef:$result);
799802
let assemblyFormat = "$name `:` type($result) attr-dict";
800-
801-
// `GetGlobalOp` is fully verified by its traits.
802-
let verifier = ?;
803803
}
804804

805805
//===----------------------------------------------------------------------===//
@@ -866,6 +866,7 @@ def MemRef_GlobalOp : MemRef_Op<"global", [Symbol]> {
866866
return !isExternal() && initial_value().getValue().isa<UnitAttr>();
867867
}
868868
}];
869+
let hasVerifier = 1;
869870
}
870871

871872
//===----------------------------------------------------------------------===//
@@ -939,6 +940,7 @@ def LoadOp : MemRef_Op<"load",
939940
}];
940941

941942
let hasFolder = 1;
943+
let hasVerifier = 1;
942944

943945
let assemblyFormat = "$memref `[` $indices `]` attr-dict `:` type($memref)";
944946
}
@@ -982,6 +984,7 @@ def MemRef_PrefetchOp : MemRef_Op<"prefetch"> {
982984
}];
983985

984986
let hasFolder = 1;
987+
let hasVerifier = 1;
985988
}
986989

987990
//===----------------------------------------------------------------------===//
@@ -1034,6 +1037,7 @@ def MemRef_ReinterpretCastOp:
10341037

10351038
let parser = ?;
10361039
let printer = ?;
1040+
let hasVerifier = 1;
10371041

10381042
let builders = [
10391043
// Build a ReinterpretCastOp with mixed static and dynamic entries.
@@ -1096,7 +1100,6 @@ def MemRef_RankOp : MemRef_Op<"rank", [NoSideEffect]> {
10961100
let arguments = (ins AnyRankedOrUnrankedMemRef:$memref);
10971101
let results = (outs Index);
10981102

1099-
let verifier = ?;
11001103
let hasFolder = 1;
11011104
let assemblyFormat = "$memref attr-dict `:` type($memref)";
11021105
}
@@ -1161,6 +1164,7 @@ def MemRef_ReshapeOp: MemRef_Op<"reshape", [
11611164
let assemblyFormat = [{
11621165
$source `(` $shape `)` attr-dict `:` functional-type(operands, results)
11631166
}];
1167+
let hasVerifier = 1;
11641168
}
11651169

11661170
//===----------------------------------------------------------------------===//
@@ -1226,6 +1230,7 @@ class MemRef_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
12261230

12271231
let hasFolder = 1;
12281232
let hasCanonicalizer = 1;
1233+
let hasVerifier = 1;
12291234
let printer = [{ return ::print(p, *this); }];
12301235
let parser = [{ return ::parseReshapeLikeOp(parser, result); }];
12311236
}
@@ -1265,6 +1270,7 @@ def MemRef_ExpandShapeOp : MemRef_ReassociativeReshapeOp<"expand_shape"> {
12651270
```
12661271
}];
12671272
let extraClassDeclaration = commonExtraClassDeclaration;
1273+
let hasVerifier = 1;
12681274
}
12691275

12701276
def MemRef_CollapseShapeOp : MemRef_ReassociativeReshapeOp<"collapse_shape"> {
@@ -1302,6 +1308,7 @@ def MemRef_CollapseShapeOp : MemRef_ReassociativeReshapeOp<"collapse_shape"> {
13021308
```
13031309
}];
13041310
let extraClassDeclaration = commonExtraClassDeclaration;
1311+
let hasVerifier = 1;
13051312
}
13061313

13071314
//===----------------------------------------------------------------------===//
@@ -1369,6 +1376,7 @@ def MemRef_StoreOp : MemRef_Op<"store",
13691376
}];
13701377

13711378
let hasFolder = 1;
1379+
let hasVerifier = 1;
13721380

13731381
let assemblyFormat = [{
13741382
$value `,` $memref `[` $indices `]` attr-dict `:` type($memref)
@@ -1617,6 +1625,7 @@ def SubViewOp : BaseOpWithOffsetSizesAndStrides<
16171625

16181626
let hasCanonicalizer = 1;
16191627
let hasFolder = 1;
1628+
let hasVerifier = 1;
16201629
}
16211630

16221631
//===----------------------------------------------------------------------===//
@@ -1645,8 +1654,6 @@ def TensorStoreOp : MemRef_Op<"tensor_store",
16451654

16461655
let arguments = (ins AnyTensor:$tensor, Arg<AnyRankedOrUnrankedMemRef,
16471656
"the reference to store to", [MemWrite]>:$memref);
1648-
// TensorStoreOp is fully verified by traits.
1649-
let verifier = ?;
16501657

16511658
let assemblyFormat = "$tensor `,` $memref attr-dict `:` type($memref)";
16521659
}
@@ -1681,6 +1688,7 @@ def MemRef_TransposeOp : MemRef_Op<"transpose", [NoSideEffect]>,
16811688
}];
16821689

16831690
let hasFolder = 1;
1691+
let hasVerifier = 1;
16841692
}
16851693

16861694
//===----------------------------------------------------------------------===//
@@ -1749,6 +1757,7 @@ def MemRef_ViewOp : MemRef_Op<"view", [
17491757
}];
17501758

17511759
let hasCanonicalizer = 1;
1760+
let hasVerifier = 1;
17521761
}
17531762

17541763
//===----------------------------------------------------------------------===//
@@ -1796,6 +1805,7 @@ def AtomicRMWOp : MemRef_Op<"atomic_rmw", [
17961805
}
17971806
}];
17981807
let hasFolder = 1;
1808+
let hasVerifier = 1;
17991809
}
18001810

18011811
#endif // MEMREF_OPS

‎mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,6 @@ include "mlir/Interfaces/SideEffectInterfaces.td"
2121
class SparseTensor_Op<string mnemonic, list<Trait> traits = []>
2222
: Op<SparseTensor_Dialect, mnemonic, traits> {
2323
let printer = [{ return ::print(p, *this); }];
24-
let verifier = [{ return ::verify(*this); }];
2524
let parser = [{ return ::parse$cppClass(parser, result); }];
2625
}
2726

@@ -50,6 +49,7 @@ def SparseTensor_NewOp : SparseTensor_Op<"new", [NoSideEffect]>,
5049
```
5150
}];
5251
let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
52+
let hasVerifier = 1;
5353
}
5454

5555
def SparseTensor_InitOp : SparseTensor_Op<"init", [NoSideEffect]>,
@@ -72,6 +72,7 @@ def SparseTensor_InitOp : SparseTensor_Op<"init", [NoSideEffect]>,
7272
```
7373
}];
7474
let assemblyFormat = "`[` $sizes `]` attr-dict `:` type($result)";
75+
let hasVerifier = 1;
7576
}
7677

7778
def SparseTensor_ConvertOp : SparseTensor_Op<"convert",
@@ -113,6 +114,7 @@ def SparseTensor_ConvertOp : SparseTensor_Op<"convert",
113114
}];
114115
let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
115116
let hasFolder = 1;
117+
let hasVerifier = 1;
116118
}
117119

118120
def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
@@ -137,6 +139,7 @@ def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
137139
}];
138140
let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
139141
" `to` type($result)";
142+
let hasVerifier = 1;
140143
}
141144

142145
def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
@@ -161,6 +164,7 @@ def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
161164
}];
162165
let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
163166
" `to` type($result)";
167+
let hasVerifier = 1;
164168
}
165169

166170
def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
@@ -183,6 +187,7 @@ def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
183187
```
184188
}];
185189
let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
190+
let hasVerifier = 1;
186191
}
187192

188193
//===----------------------------------------------------------------------===//
@@ -217,6 +222,7 @@ def SparseTensor_LexInsertOp : SparseTensor_Op<"lex_insert", []>,
217222
}];
218223
let assemblyFormat = "$tensor `,` $indices `,` $value attr-dict `:`"
219224
" type($tensor) `,` type($indices) `,` type($value)";
225+
let hasVerifier = 1;
220226
}
221227

222228
def SparseTensor_ExpandOp : SparseTensor_Op<"expand", []>,
@@ -258,6 +264,7 @@ def SparseTensor_ExpandOp : SparseTensor_Op<"expand", []>,
258264
}];
259265
let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($values)"
260266
" `,` type($filled) `,` type($added) `,` type($count)";
267+
let hasVerifier = 1;
261268
}
262269

263270
def SparseTensor_CompressOp : SparseTensor_Op<"compress", []>,
@@ -292,6 +299,7 @@ def SparseTensor_CompressOp : SparseTensor_Op<"compress", []>,
292299
" $added `,` $count attr-dict `:` type($tensor) `,`"
293300
" type($indices) `,` type($values) `,` type($filled) `,`"
294301
" type($added) `,` type($count)";
302+
let hasVerifier = 1;
295303
}
296304

297305
def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
@@ -324,6 +332,7 @@ def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
324332
```
325333
}];
326334
let assemblyFormat = "$tensor (`hasInserts` $hasInserts^)? attr-dict `:` type($tensor)";
335+
let hasVerifier = 1;
327336
}
328337

329338
def SparseTensor_ReleaseOp : SparseTensor_Op<"release", []>,
@@ -349,6 +358,7 @@ def SparseTensor_ReleaseOp : SparseTensor_Op<"release", []>,
349358
```
350359
}];
351360
let assemblyFormat = "$tensor attr-dict `:` type($tensor)";
361+
let hasVerifier = 1;
352362
}
353363

354364
def SparseTensor_OutOp : SparseTensor_Op<"out", []>,
@@ -369,6 +379,7 @@ def SparseTensor_OutOp : SparseTensor_Op<"out", []>,
369379
```
370380
}];
371381
let assemblyFormat = "$tensor `,` $dest attr-dict `:` type($tensor) `,` type($dest)";
382+
let hasVerifier = 1;
372383
}
373384

374385
#endif // SPARSETENSOR_OPS

0 commit comments

Comments
 (0)