mlir/test/Dialect/IRDL/testd.mlir

   1 // RUN: mlir-opt %s --irdl-file=%S/testd.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // Type or attribute constraint
   5 //===----------------------------------------------------------------------===//
   6
   7 func.func @typeFitsType() {
   8   // CHECK: "testd.any"() : () -> !testd.parametric<i32>
   9   "testd.any"() : () -> !testd.parametric<i32>
  10   return
  11 }
  12
  13 // -----
  14
  15 func.func @attrDoesntFitType() {
  16   "testd.any"() : () -> !testd.parametric<"foo">
  17   return
  18 }
  19
  20 // -----
  21
  22 func.func @attrFitsAttr() {
  23   // CHECK: "testd.any"() : () -> !testd.attr_in_type_out<"foo">
  24   "testd.any"() : () -> !testd.attr_in_type_out<"foo">
  25   return
  26 }
  27
  28 // -----
  29
  30 func.func @typeFitsAttr() {
  31   // CHECK: "testd.any"() : () -> !testd.attr_in_type_out<i32>
  32   "testd.any"() : () -> !testd.attr_in_type_out<i32>
  33   return
  34 }
  35
  36 // -----
  37
  38 //===----------------------------------------------------------------------===//
  39 // Equality constraint
  40 //===----------------------------------------------------------------------===//
  41
  42 func.func @succeededEqConstraint() {
  43   // CHECK: "testd.eq"() : () -> i32
  44   "testd.eq"() : () -> i32
  45   return
  46 }
  47
  48 // -----
  49
  50 func.func @failedEqConstraint() {
  51   // expected-error@+1 {{expected 'i32' but got 'i64'}}
  52   "testd.eq"() : () -> i64
  53   return
  54 }
  55
  56 // -----
  57
  58 //===----------------------------------------------------------------------===//
  59 // AnyOf constraint
  60 //===----------------------------------------------------------------------===//
  61
  62 func.func @succeededAnyOfConstraint() {
  63   // CHECK: "testd.anyof"() : () -> i32
  64   "testd.anyof"() : () -> i32
  65   // CHECK: "testd.anyof"() : () -> i64
  66   "testd.anyof"() : () -> i64
  67   return
  68 }
  69
  70 // -----
  71
  72 func.func @failedAnyOfConstraint() {
  73   // expected-error@+1 {{'i1' does not satisfy the constraint}}
  74   "testd.anyof"() : () -> i1
  75   return
  76 }
  77
  78 // -----
  79
  80 //===----------------------------------------------------------------------===//
  81 // AllOf constraint
  82 //===----------------------------------------------------------------------===//
  83
  84 func.func @succeededAllOfConstraint() {
  85   // CHECK: "testd.all_of"() : () -> i64
  86   "testd.all_of"() : () -> i64
  87   return
  88 }
  89
  90 // -----
  91
  92 func.func @failedAllOfConstraint1() {
  93   // expected-error@+1 {{'i1' does not satisfy the constraint}}
  94   "testd.all_of"() : () -> i1
  95   return
  96 }
  97
  98 // -----
  99
 100 func.func @failedAllOfConstraint2() {
 101   // expected-error@+1 {{expected 'i64' but got 'i32'}}
 102   "testd.all_of"() : () -> i32
 103   return
 104 }
 105
 106 // -----
 107
 108 //===----------------------------------------------------------------------===//
 109 // Any constraint
 110 //===----------------------------------------------------------------------===//
 111
 112 func.func @succeededAnyConstraint() {
 113   // CHECK: "testd.any"() : () -> i32
 114   "testd.any"() : () -> i32
 115   // CHECK: "testd.any"() : () -> i64
 116   "testd.any"() : () -> i64
 117   return
 118 }
 119
 120 // -----
 121
 122 //===----------------------------------------------------------------------===//
 123 // Base constraints
 124 //===----------------------------------------------------------------------===//
 125
 126 func.func @succeededDynBaseConstraint() {
 127   // CHECK: "testd.dyn_type_base"() : () -> !testd.parametric<i32>
 128   "testd.dyn_type_base"() : () -> !testd.parametric<i32>
 129   // CHECK: "testd.dyn_type_base"() : () -> !testd.parametric<i64>
 130   "testd.dyn_type_base"() : () -> !testd.parametric<i64>
 131   // CHECK: "testd.dyn_type_base"() : () -> !testd.parametric<!testd.parametric<i64>>
 132   "testd.dyn_type_base"() : () -> !testd.parametric<!testd.parametric<i64>>
 133   // CHECK: "testd.dyn_attr_base"() {attr1 = #testd.parametric_attr<i32>} : () -> ()
 134   "testd.dyn_attr_base"() {attr1 = #testd.parametric_attr<i32>} : () -> ()
 135   // CHECK: "testd.dyn_attr_base"() {attr1 = #testd.parametric_attr<i64>} : () -> ()
 136   "testd.dyn_attr_base"() {attr1 = #testd.parametric_attr<i64>} : () -> ()
 137   return
 138 }
 139
 140 // -----
 141
 142 func.func @failedDynTypeBaseConstraint() {
 143   // expected-error@+1 {{expected base type 'testd.parametric' but got 'builtin.integer'}}
 144   "testd.dyn_type_base"() : () -> i32
 145   return
 146 }
 147
 148 // -----
 149
 150 func.func @failedDynAttrBaseConstraintNotType() {
 151   // expected-error@+1 {{expected base attribute 'testd.parametric_attr' but got 'builtin.type'}}
 152   "testd.dyn_attr_base"() {attr1 = i32}: () -> ()
 153   return
 154 }
 155
 156 // -----
 157
 158
 159 func.func @succeededNamedBaseConstraint() {
 160   // CHECK: "testd.named_type_base"() : () -> i32
 161   "testd.named_type_base"() : () -> i32
 162   // CHECK: "testd.named_type_base"() : () -> i64
 163   "testd.named_type_base"() : () -> i64
 164   // CHECK: "testd.named_attr_base"() {attr1 = 0 : i32} : () -> ()
 165   "testd.named_attr_base"() {attr1 = 0 : i32} : () -> ()
 166   // CHECK: "testd.named_attr_base"() {attr1 = 0 : i64} : () -> ()
 167   "testd.named_attr_base"() {attr1 = 0 : i64} : () -> ()
 168   return
 169 }
 170
 171 // -----
 172
 173 func.func @failedNamedTypeBaseConstraint() {
 174   // expected-error@+1 {{expected base type 'builtin.integer' but got 'builtin.vector'}}
 175   "testd.named_type_base"() : () -> vector<i32>
 176   return
 177 }
 178
 179 // -----
 180
 181 func.func @failedDynAttrBaseConstraintNotType() {
 182   // expected-error@+1 {{expected base attribute 'builtin.integer' but got 'builtin.type'}}
 183   "testd.named_attr_base"() {attr1 = i32}: () -> ()
 184   return
 185 }
 186
 187 // -----
 188
 189 //===----------------------------------------------------------------------===//
 190 // Dynamic parameters constraint
 191 //===----------------------------------------------------------------------===//
 192
 193 func.func @succeededDynParamsConstraint() {
 194   // CHECK: "testd.dynparams"() : () -> !testd.parametric<i32>
 195   "testd.dynparams"() : () -> !testd.parametric<i32>
 196   // CHECK: "testd.dynparams"() : () -> !testd.parametric<i64>
 197   "testd.dynparams"() : () -> !testd.parametric<i64>
 198   return
 199 }
 200
 201 // -----
 202
 203 func.func @failedDynParamsConstraintBase() {
 204   // expected-error@+1 {{expected base type 'testd.parametric' but got 'i32'}}
 205   "testd.dynparams"() : () -> i32
 206   return
 207 }
 208
 209 // -----
 210
 211 func.func @failedDynParamsConstraintParam() {
 212   // expected-error@+1 {{'i1' does not satisfy the constraint}}
 213   "testd.dynparams"() : () -> !testd.parametric<i1>
 214   return
 215 }
 216
 217 // -----
 218
 219 //===----------------------------------------------------------------------===//
 220 // Constraint variables
 221 //===----------------------------------------------------------------------===//
 222
 223 func.func @succeededConstraintVars() {
 224   // CHECK: "testd.constraint_vars"() : () -> (i32, i32)
 225   "testd.constraint_vars"() : () -> (i32, i32)
 226   return
 227 }
 228
 229 // -----
 230
 231 func.func @succeededConstraintVars2() {
 232   // CHECK: "testd.constraint_vars"() : () -> (i64, i64)
 233   "testd.constraint_vars"() : () -> (i64, i64)
 234   return
 235 }
 236
 237 // -----
 238
 239 func.func @failedConstraintVars() {
 240   // expected-error@+1 {{expected 'i64' but got 'i32'}}
 241   "testd.constraint_vars"() : () -> (i64, i32)
 242   return
 243 }
 244
 245 // -----
 246
 247 //===----------------------------------------------------------------------===//
 248 // Constraint attributes
 249 //===----------------------------------------------------------------------===//
 250
 251 func.func @succeededAttrs() {
 252   // CHECK: "testd.attrs"() {attr1 = i32, attr2 = i64} : () -> ()
 253   "testd.attrs"() {attr1 = i32, attr2 = i64} : () -> ()
 254   return
 255 }
 256
 257 // -----
 258
 259 func.func @failedAttrsMissingAttr() {
 260   // expected-error@+1 {{attribute "attr2" is expected but not provided}}
 261   "testd.attrs"() {attr1 = i32} : () -> ()
 262   return
 263 }
 264
 265 // -----
 266
 267 func.func @failedAttrsConstraint() {
 268   // expected-error@+1 {{expected 'i32' but got 'i64'}}
 269   "testd.attrs"() {attr1 = i64, attr2 = i64} : () -> ()
 270   return
 271 }
 272
 273 // -----
 274
 275 func.func @failedAttrsConstraint2() {
 276   // expected-error@+1 {{expected 'i64' but got 'i32'}}
 277   "testd.attrs"() {attr1 = i32, attr2 = i32} : () -> ()
 278   return
 279 }
 280
 281 // -----
 282
 283 //===----------------------------------------------------------------------===//
 284 // Regions
 285 //===----------------------------------------------------------------------===//
 286
 287 // CHECK: func.func @succeededRegions
 288 func.func @succeededRegions() {
 289   "testd.regions"() (
 290   {
 291     ^bb1:
 292       llvm.unreachable
 293   },
 294   {
 295     ^bb1(%arg0: i32, %arg1: i64):
 296       llvm.unreachable
 297   },
 298   {
 299     ^bb1:
 300       cf.br ^bb3
 301     ^bb2:
 302       cf.br ^bb3
 303     ^bb3:
 304       llvm.unreachable
 305   },
 306   {
 307     ^bb1:
 308       llvm.unreachable
 309   }) : () -> ()
 310
 311   return
 312 }
 313 // -----
 314
 315 // CHECK: func.func @succeededRegionWithNoConstraints
 316 func.func @succeededRegionWithNoConstraints() {
 317   "testd.regions"() (
 318   {
 319     ^bb1(%arg0: i32, %arg1: i64, %arg2 : f64):
 320       llvm.unreachable
 321     ^bb2(%arg3: i32, %arg4: i64, %arg5 : f64):
 322       llvm.unreachable
 323     ^bb3(%arg6: i32, %arg7: i64, %arg8 : f64):
 324       llvm.unreachable
 325     ^bb4(%arg9: i32, %arg10: i64, %arg11 : f64):
 326       llvm.unreachable
 327     ^bb5(%arg12: i32, %arg13: i64, %arg14 : f64):
 328       llvm.unreachable
 329   },
 330   {
 331     ^bb1(%arg0: i32, %arg1: i64):
 332       llvm.unreachable
 333   },
 334   {
 335     ^bb1:
 336       cf.br ^bb3
 337     ^bb2:
 338       cf.br ^bb3
 339     ^bb3:
 340       llvm.unreachable
 341   },
 342   {
 343     ^bb1:
 344       llvm.unreachable
 345   }) : () -> ()
 346
 347   return
 348 }
 349
 350 // -----
 351
 352 func.func @failedRegionArgsLessThanNeeded() {
 353   // expected-note@+1 {{see the operation}}
 354   "testd.regions"() (
 355   {
 356     ^bb1:
 357       llvm.unreachable
 358   },
 359   {
 360     // expected-error@+1 {{expected region 1 to have 2 arguments but got 1}}
 361     ^bb1(%arg0: i32):
 362       llvm.unreachable
 363   },
 364   {
 365     ^bb1:
 366       cf.br ^bb3
 367     ^bb2:
 368       cf.br ^bb3
 369     ^bb3:
 370       llvm.unreachable
 371   },
 372   {
 373     ^bb1:
 374       llvm.unreachable
 375   }) : () -> ()
 376
 377   return
 378 }
 379
 380 // -----
 381
 382 func.func @failedRegionArgsMoreThanNeeded() {
 383   // expected-note@+1 {{see the operation}}
 384   "testd.regions"() (
 385   {
 386     ^bb1:
 387       llvm.unreachable
 388   },
 389   {
 390     // expected-error@+1 {{expected region 1 to have 2 arguments but got 3}}
 391     ^bb1(%arg0: i32, %arg1: i64, %arg2 : f64):
 392       llvm.unreachable
 393   },
 394   {
 395     ^bb1:
 396       cf.br ^bb3
 397     ^bb2:
 398       cf.br ^bb3
 399     ^bb3:
 400       llvm.unreachable
 401   },
 402   {
 403     ^bb1:
 404       llvm.unreachable
 405   }) : () -> ()
 406
 407   return
 408 }
 409
 410 // -----
 411
 412 func.func @failedRegionArgsEmptyButRequired() {
 413   // expected-error@+1 {{expected region 1 to have 2 arguments but got 0}}
 414   "testd.regions"() (
 415   {
 416     ^bb1:
 417       llvm.unreachable
 418   },
 419   {
 420     ^bb1():
 421       llvm.unreachable
 422   },
 423   {
 424     ^bb1:
 425       cf.br ^bb3
 426     ^bb2:
 427       cf.br ^bb3
 428     ^bb3:
 429       llvm.unreachable
 430   },
 431   {
 432     ^bb1:
 433       llvm.unreachable
 434   }) : () -> ()
 435
 436   return
 437 }
 438
 439 // -----
 440
 441 func.func @faIledRegionArgsConstraint() {
 442   // expected-note@+1 {{see the operation}}
 443   "testd.regions"() (
 444   {
 445     ^bb1:
 446       llvm.unreachable
 447   },
 448   {
 449     // expected-error@+1 {{expected 'i64' but got 'f64'}}
 450     ^bb1(%arg0: i32, %arg1: f64):
 451       llvm.unreachable
 452   },
 453   {
 454     ^bb1:
 455       cf.br ^bb3
 456     ^bb2:
 457       cf.br ^bb3
 458     ^bb3:
 459       llvm.unreachable
 460   },
 461   {
 462     ^bb1:
 463       llvm.unreachable
 464   }) : () -> ()
 465
 466   return
 467 }
 468
 469 // -----
 470
 471 func.func @failedRegionBlocksCountLessThanNeeded() {
 472   // expected-error@+1 {{expected region 2 to have 3 block(s) but got 2}}
 473   "testd.regions"() (
 474   {
 475     ^bb1:
 476       llvm.unreachable
 477   },
 478   {
 479     ^bb1(%arg0: i32, %arg1: i64):
 480       llvm.unreachable
 481   },
 482   {
 483     ^bb1:
 484       cf.br ^bb3
 485     ^bb3:
 486       llvm.unreachable
 487   },
 488   {
 489     ^bb1:
 490       llvm.unreachable
 491   }) : () -> ()
 492
 493   return
 494 }
 495
 496 // -----
 497
 498 func.func @failedRegionBlocksCountMoreThanNeeded() {
 499   // expected-error@+1 {{expected region 2 to have 3 block(s) but got 4}}
 500   "testd.regions"() (
 501   {
 502     ^bb1:
 503       llvm.unreachable
 504   },
 505   {
 506     ^bb1(%arg0: i32, %arg1: i64):
 507       llvm.unreachable
 508   },
 509   {
 510     ^bb1:
 511       cf.br ^bb3
 512     ^bb2:
 513       cf.br ^bb3
 514     ^bb4:
 515       cf.br ^bb3
 516     ^bb3:
 517       llvm.unreachable
 518   },
 519   {
 520     ^bb1:
 521       llvm.unreachable
 522   }) : () -> ()
 523
 524   return
 525 }
 526
 527 // -----
 528
 529 func.func @failedRegionWithEmptyArgs() {
 530   // expected-note@+1 {{see the operation}}
 531   "testd.regions"() (
 532   {
 533     ^bb1:
 534       llvm.unreachable
 535   },
 536   {
 537     ^bb1(%arg0: i32, %arg1: i64):
 538       llvm.unreachable
 539   },
 540   {
 541     ^bb1:
 542       cf.br ^bb3
 543     ^bb2:
 544       cf.br ^bb3
 545     ^bb3:
 546       llvm.unreachable
 547   },
 548   {
 549     // expected-error@+1 {{expected region 3 to have 0 arguments but got 2}}
 550     ^bb1(%arg0: i32, %arg1: i64):
 551       llvm.unreachable
 552   }) : () -> ()
 553
 554   return
 555 }
 556
 557 // -----
 558
 559 func.func @failedRegionWithLessBlocksThanNeeded() {
 560   // expected-error@+1 {{'testd.regions' op unexpected number of regions: expected 4 but got 3}}
 561   "testd.regions"() (
 562   {
 563     ^bb1:
 564       llvm.unreachable
 565   },
 566   {
 567     ^bb1:
 568       cf.br ^bb3
 569     ^bb2:
 570       cf.br ^bb3
 571     ^bb3:
 572       llvm.unreachable
 573   },
 574   {
 575     ^bb1:
 576       llvm.unreachable
 577   }) : () -> ()
 578
 579   return
 580 }
 581
 582 // -----
 583
 584 func.func @failedRegionWithMoreBlocksThanNeeded() {
 585   // expected-error@+1 {{'testd.regions' op unexpected number of regions: expected 4 but got 5}}
 586   "testd.regions"() (
 587   {
 588     ^bb1:
 589       llvm.unreachable
 590   },
 591   {
 592     ^bb1(%arg0: i32, %arg1: i64):
 593       llvm.unreachable
 594   },
 595   {
 596     ^bb1:
 597       cf.br ^bb3
 598     ^bb2:
 599       cf.br ^bb3
 600     ^bb3:
 601       llvm.unreachable
 602   },
 603   {
 604     ^bb1(%arg0: i32, %arg1: i64):
 605       llvm.unreachable
 606   },
 607   {
 608     ^bb1(%arg0: i32, %arg1: i64):
 609       llvm.unreachable
 610   }) : () -> ()
 611
 612   return
 613 }
 614
 615 // -----
 616
 617 func.func @successReuseConstraintBetweenRegionAndOperand() {
 618   %0 = arith.constant 42 : i32
 619   "testd.region_and_operand"(%0) ({
 620     ^bb(%1: i32):
 621       llvm.unreachable
 622   }) : (i32) -> ()
 623
 624   return
 625 }
 626
 627 // -----
 628
 629 func.func @failedReuseConstraintBetweenRegionAndOperand() {
 630   %0 = arith.constant 42 : i32
 631   // expected-note@+1 {{see the operation}}
 632   "testd.region_and_operand"(%0) ({
 633     // expected-error@+1 {{expected 'i32' but got 'i64'}}
 634     ^bb(%1: i64):
 635       llvm.unreachable
 636   }) : (i32) -> ()
 637
 638   return
 639 }