mlir/test/IR/invalid.mlir

   1 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics
   2
   3 // See http://llvm.org/pr52045
   4 // UNSUPPORTED: asan
   5
   6 // Check different error cases.
   7 // -----
   8
   9 func @illegaltype(i) // expected-error {{expected non-function type}}
  10
  11 // -----
  12
  13 func @illegaltype() {
  14   %0 = arith.constant dense<0> : <vector 4 x f32> : vector<4 x f32> // expected-error {{expected non-function type}}
  15 }
  16
  17 // -----
  18
  19 func @nestedtensor(tensor<tensor<i8>>) -> () // expected-error {{invalid tensor element type}}
  20
  21 // -----
  22
  23 // expected-error@+1 {{invalid dimension}}
  24 #large_dim = tensor<9223372036854775808xf32>
  25
  26 // -----
  27
  28 func @illegalmemrefelementtype(memref<?xtensor<i8>>) -> () // expected-error {{invalid memref element type}}
  29
  30 // -----
  31
  32 func @illegalunrankedmemrefelementtype(memref<*xtensor<i8>>) -> () // expected-error {{invalid memref element type}}
  33
  34 // -----
  35 // Test no map in memref type.
  36 func @memrefs(memref<2x4xi8, >) // expected-error {{expected list element}}
  37
  38 // -----
  39 // Test non-existent map in memref type.
  40 func @memrefs(memref<2x4xi8, #map7>) // expected-error {{undefined symbol alias id 'map7'}}
  41
  42 // -----
  43 // Test unsupported memory space.
  44 func @memrefs(memref<2x4xi8, i8>) // expected-error {{unsupported memory space Attribute}}
  45
  46 // -----
  47 // Test non-existent map in map composition of memref type.
  48 #map0 = affine_map<(d0, d1) -> (d0, d1)>
  49
  50 func @memrefs(memref<2x4xi8, #map0, #map8>) // expected-error {{undefined symbol alias id 'map8'}}
  51
  52 // -----
  53 // Test multiple memory space error.
  54 #map0 = affine_map<(d0, d1) -> (d0, d1)>
  55 func @memrefs(memref<2x4xi8, #map0, 1, 2>) // expected-error {{multiple memory spaces specified in memref type}}
  56
  57 // -----
  58 // Test affine map after memory space.
  59 #map0 = affine_map<(d0, d1) -> (d0, d1)>
  60 #map1 = affine_map<(d0, d1) -> (d0, d1)>
  61
  62 func @memrefs(memref<2x4xi8, #map0, 1, #map1>) // expected-error {{expected memory space to be last in memref type}}
  63
  64 // -----
  65 // Test dimension mismatch between memref and layout map.
  66 // The error must be emitted even for the trivial identity layout maps that are
  67 // dropped in type creation.
  68 #map0 = affine_map<(d0, d1) -> (d0, d1)>
  69 func @memrefs(memref<42xi8, #map0>) // expected-error {{memref layout mismatch between rank and affine map: 1 != 2}}
  70
  71 // -----
  72
  73 func @memref_space_after_strides(memref<42x42xi8, 0, offset: ?, strides: [?, ?]>) // expected-error {{expected memory space to be last in memref type}}
  74
  75 // -----
  76
  77 func @memref_stride_missing_colon(memref<42x42xi8, offset ?, strides: [?, ?]>) // expected-error {{expected colon after `offset` keyword}}
  78
  79 // -----
  80
  81 func @memref_stride_invalid_offset(memref<42x42xi8, offset: [], strides: [?, ?]>) // expected-error {{invalid offset}}
  82
  83 // -----
  84
  85 func @memref_stride_missing_strides(memref<42x42xi8, offset: 0 [?, ?]>) // expected-error {{expected comma after offset value}}
  86
  87 // -----
  88
  89 func @memref_stride_missing_strides(memref<42x42xi8, offset: 0, [?, ?]>) // expected-error {{expected `strides` keyword after offset specification}}
  90
  91 // -----
  92
  93 func @memref_stride_missing_colon_2(memref<42x42xi8, offset: 0, strides [?, ?]>) // expected-error {{expected colon after `strides` keyword}}
  94
  95 // -----
  96
  97 // expected-error @+1 {{expected '['}}
  98 func @memref_stride_invalid_strides(memref<42x42xi8, offset: 0, strides: ()>)
  99
 100 // -----
 101
 102 func @memref_zero_stride(memref<42x42xi8, offset: ?, strides: [0, ?]>) // expected-error {{invalid memref stride}}
 103
 104 // -----
 105
 106 func @tensor_encoding_mismatch(%arg0: tensor<8xi32, "enc">) -> (tensor<8xi32>) { // expected-note {{prior use here}}
 107   return %arg0: tensor<8xi32> // expected-error {{use of value '%arg0' expects different type than prior uses: 'tensor<8xi32>' vs 'tensor<8xi32, "enc">'}}
 108 }
 109
 110 // -----
 111
 112 func @bad_branch() {
 113 ^bb12:
 114   br ^missing  // expected-error {{reference to an undefined block}}
 115 }
 116
 117 // -----
 118
 119 func @block_redef() {
 120 ^bb42:
 121   return
 122 ^bb42:        // expected-error {{redefinition of block '^bb42'}}
 123   return
 124 }
 125
 126 // -----
 127
 128 func @no_terminator() {   // expected-error {{empty block: expect at least a terminator}}
 129 ^bb40:
 130   return
 131 ^bb41:
 132 ^bb42:
 133   return
 134 }
 135
 136 // -----
 137
 138 func @block_no_rparen() {
 139 ^bb42 (%bb42 : i32: // expected-error {{expected ')' to end argument list}}
 140   return
 141 }
 142
 143 // -----
 144
 145 func @block_arg_no_ssaid() {
 146 ^bb42 (i32): // expected-error {{expected SSA operand}}
 147   return
 148 }
 149
 150 // -----
 151
 152 func @block_arg_no_type() {
 153 ^bb42 (%0): // expected-error {{expected ':' and type for SSA operand}}
 154   return
 155 }
 156
 157 // -----
 158
 159 func @block_arg_no_close_paren() {
 160 ^bb42:
 161   br ^bb2( // expected-error@+1 {{expected ':'}}
 162   return
 163 }
 164
 165 // -----
 166
 167 func @block_first_has_predecessor() {
 168 // expected-error@-1 {{entry block of region may not have predecessors}}
 169 ^bb42:
 170   br ^bb43
 171 ^bb43:
 172   br ^bb42
 173 }
 174
 175 // -----
 176
 177 func @no_return() {
 178   %x = arith.constant 0 : i32
 179   %y = arith.constant 1 : i32  // expected-error {{block with no terminator}}
 180 }
 181
 182 // -----
 183
 184 func @no_terminator() {
 185   br ^bb1
 186 ^bb1:
 187   %x = arith.constant 0 : i32
 188   %y = arith.constant 1 : i32  // expected-error {{block with no terminator}}
 189 }
 190
 191
 192 // -----
 193
 194 "       // expected-error {{expected}}
 195 "
 196
 197 // -----
 198
 199 "       // expected-error {{expected}}
 200
 201 // -----
 202
 203 func @bad_op_type() {
 204 ^bb40:
 205   "foo"() : i32  // expected-error {{expected function type}}
 206   return
 207 }
 208 // -----
 209
 210 func @no_terminator() {
 211 ^bb40:
 212   "foo"() : ()->()
 213   ""() : ()->()  // expected-error {{empty operation name is invalid}}
 214   return
 215 }
 216
 217 // -----
 218
 219 func @illegaltype(i21312312323120) // expected-error {{invalid integer width}}
 220
 221 // -----
 222
 223 func @malformed_for_percent() {
 224   affine.for i = 1 to 10 { // expected-error {{expected SSA operand}}
 225
 226 // -----
 227
 228 func @malformed_for_equal() {
 229   affine.for %i 1 to 10 { // expected-error {{expected '='}}
 230
 231 // -----
 232
 233 func @malformed_for_to() {
 234   affine.for %i = 1 too 10 { // expected-error {{expected 'to' between bounds}}
 235   }
 236 }
 237
 238 // -----
 239
 240 func @incomplete_for() {
 241   affine.for %i = 1 to 10 step 2
 242 }        // expected-error {{expected '{' to begin a region}}
 243
 244 // -----
 245
 246 #map0 = affine_map<(d0) -> (d0 floordiv 4)>
 247
 248 func @reference_to_iv_in_bound() {
 249   // expected-error@+2 {{region entry argument '%i0' is already in use}}
 250   // expected-note@+1 {{previously referenced here}}
 251   affine.for %i0 = #map0(%i0) to 10 {
 252   }
 253 }
 254
 255 // -----
 256
 257 func @nonconstant_step(%1 : i32) {
 258   affine.for %2 = 1 to 5 step %1 { // expected-error {{expected non-function type}}
 259
 260 // -----
 261
 262 func @for_negative_stride() {
 263   affine.for %i = 1 to 10 step -1
 264 }        // expected-error@-1 {{expected step to be representable as a positive signed integer}}
 265
 266 // -----
 267
 268 func @non_operation() {
 269   test.asd   // expected-error {{custom op 'test.asd' is unknown}}
 270 }
 271
 272 // -----
 273
 274 func @invalid_if_conditional2() {
 275   affine.for %i = 1 to 10 {
 276     affine.if affine_set<(i)[N] : (i >= )>  // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
 277   }
 278 }
 279
 280 // -----
 281
 282 func @invalid_if_conditional3() {
 283   affine.for %i = 1 to 10 {
 284     affine.if affine_set<(i)[N] : (i == 1)> // expected-error {{expected '0' after '=='}}
 285   }
 286 }
 287
 288 // -----
 289
 290 func @invalid_if_conditional4() {
 291   affine.for %i = 1 to 10 {
 292     affine.if affine_set<(i)[N] : (i >= 2)> // expected-error {{expected '0' after '>='}}
 293   }
 294 }
 295
 296 // -----
 297
 298 func @invalid_if_conditional5() {
 299   affine.for %i = 1 to 10 {
 300     affine.if affine_set<(i)[N] : (i <= 0)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
 301   }
 302 }
 303
 304 // -----
 305
 306 func @invalid_if_conditional6() {
 307   affine.for %i = 1 to 10 {
 308     affine.if affine_set<(i) : (i)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
 309   }
 310 }
 311
 312 // -----
 313 // TODO: support affine.if (1)?
 314 func @invalid_if_conditional7() {
 315   affine.for %i = 1 to 10 {
 316     affine.if affine_set<(i) : (1)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
 317   }
 318 }
 319
 320 // -----
 321
 322 #map = affine_map<(d0) -> (%  // expected-error {{invalid SSA name}}
 323
 324 // -----
 325
 326 func @test() {
 327 ^bb40:
 328   %1 = "foo"() : (i32)->i64 // expected-error {{expected 0 operand types but had 1}}
 329   return
 330 }
 331
 332 // -----
 333
 334 func @redef() {
 335 ^bb42:
 336   %x = "xxx"(){index = 0} : ()->i32 // expected-note {{previously defined here}}
 337   %x = "xxx"(){index = 0} : ()->i32 // expected-error {{redefinition of SSA value '%x'}}
 338   return
 339 }
 340
 341 // -----
 342
 343 func @undef() {
 344 ^bb42:
 345   %x = "xxx"(%y) : (i32)->i32   // expected-error {{use of undeclared SSA value}}
 346   return
 347 }
 348
 349 // -----
 350
 351 func @malformed_type(%a : intt) { // expected-error {{expected non-function type}}
 352 }
 353
 354 // -----
 355
 356 func @resulterror() -> i32 {
 357 ^bb42:
 358   return    // expected-error {{'std.return' op has 0 operands, but enclosing function (@resulterror) returns 1}}
 359 }
 360
 361 // -----
 362
 363 func @func_resulterror() -> i32 {
 364   return // expected-error {{'std.return' op has 0 operands, but enclosing function (@func_resulterror) returns 1}}
 365 }
 366
 367 // -----
 368
 369 func @argError() {
 370 ^bb1(%a: i64):  // expected-note {{previously defined here}}
 371   br ^bb2
 372 ^bb2(%a: i64):  // expected-error{{redefinition of SSA value '%a'}}
 373   return
 374 }
 375
 376 // -----
 377
 378 func @br_mismatch() {
 379 ^bb0:
 380   %0:2 = "foo"() : () -> (i1, i17)
 381   // expected-error @+1 {{branch has 2 operands for successor #0, but target block has 1}}
 382   br ^bb1(%0#1, %0#0 : i17, i1)
 383
 384 ^bb1(%x: i17):
 385   return
 386 }
 387
 388 // -----
 389
 390 func @succ_arg_type_mismatch() {
 391 ^bb0:
 392   %0 = "getBool"() : () -> i1
 393   // expected-error @+1 {{type mismatch for bb argument #0 of successor #0}}
 394   br ^bb1(%0 : i1)
 395
 396 ^bb1(%x: i32):
 397   return
 398 }
 399
 400
 401 // -----
 402
 403 // Test no nested vector.
 404 func @vectors(vector<1 x vector<1xi32>>, vector<2x4xf32>)
 405 // expected-error@-1 {{vector elements must be int/index/float type}}
 406
 407 // -----
 408
 409 func @condbr_notbool() {
 410 ^bb0:
 411   %a = "foo"() : () -> i32 // expected-note {{prior use here}}
 412   cond_br %a, ^bb0, ^bb0 // expected-error {{use of value '%a' expects different type than prior uses: 'i1' vs 'i32'}}
 413 }
 414
 415 // -----
 416
 417 func @condbr_badtype() {
 418 ^bb0:
 419   %c = "foo"() : () -> i1
 420   %a = "foo"() : () -> i32
 421   cond_br %c, ^bb0(%a, %a : i32, ^bb0) // expected-error {{expected non-function type}}
 422 }
 423
 424 // -----
 425
 426 func @condbr_a_bb_is_not_a_type() {
 427 ^bb0:
 428   %c = "foo"() : () -> i1
 429   %a = "foo"() : () -> i32
 430   cond_br %c, ^bb0(%a, %a : i32, i32), i32 // expected-error {{expected block name}}
 431 }
 432
 433 // -----
 434
 435 func @successors_in_non_terminator(%a : i32, %b : i32) {
 436   %c = "arith.addi"(%a, %b)[^bb1] : () -> () // expected-error {{successors in non-terminator}}
 437 ^bb1:
 438   return
 439 }
 440
 441 // -----
 442
 443 func @undef() {
 444 ^bb0:
 445   %x = "xxx"(%y) : (i32)->i32   // expected-error {{use of undeclared SSA value name}}
 446   return
 447 }
 448
 449 // -----
 450
 451 func @undef() {
 452   %x = "xxx"(%y) : (i32)->i32   // expected-error {{use of undeclared SSA value name}}
 453   return
 454 }
 455
 456 // -----
 457
 458 func @duplicate_induction_var() {
 459   affine.for %i = 1 to 10 {   // expected-note {{previously referenced here}}
 460     affine.for %i = 1 to 10 { // expected-error {{region entry argument '%i' is already in use}}
 461     }
 462   }
 463   return
 464 }
 465
 466 // -----
 467
 468 func @name_scope_failure() {
 469   affine.for %i = 1 to 10 {
 470   }
 471   "xxx"(%i) : (index)->()   // expected-error {{use of undeclared SSA value name}}
 472   return
 473 }
 474
 475 // -----
 476
 477 func @dominance_failure() {
 478 ^bb0:
 479   "foo"(%x) : (i32) -> ()    // expected-error {{operand #0 does not dominate this use}}
 480   br ^bb1
 481 ^bb1:
 482   %x = "bar"() : () -> i32    // expected-note {{operand defined here (op in the same region)}}
 483   return
 484 }
 485
 486 // -----
 487
 488 func @dominance_failure() {
 489 ^bb0:
 490   "foo"(%x) : (i32) -> ()    // expected-error {{operand #0 does not dominate this use}}
 491   %x = "bar"() : () -> i32    // expected-note {{operand defined here (op in the same block)}}
 492   br ^bb1
 493 ^bb1:
 494   return
 495 }
 496
 497 // -----
 498
 499 func @dominance_failure() {
 500   "foo"() ({
 501     "foo"(%x) : (i32) -> ()    // expected-error {{operand #0 does not dominate this use}}
 502   }) : () -> ()
 503   %x = "bar"() : () -> i32    // expected-note {{operand defined here (op in a parent region)}}
 504   return
 505 }
 506
 507 // -----
 508
 509 func @dominance_failure() {  //  expected-note {{operand defined as a block argument (block #1 in the same region)}}
 510 ^bb0:
 511   br ^bb1(%x : i32)    // expected-error {{operand #0 does not dominate this use}}
 512 ^bb1(%x : i32):
 513   return
 514 }
 515
 516 // -----
 517
 518 func @dominance_failure() {  //  expected-note {{operand defined as a block argument (block #1 in a parent region)}}
 519 ^bb0:
 520   %f = "foo"() ({
 521     "foo"(%x) : (i32) -> ()    // expected-error {{operand #0 does not dominate this use}}
 522   }) : () -> (i32)
 523   br ^bb1(%f : i32)
 524 ^bb1(%x : i32):
 525   return
 526 }
 527
 528 // -----
 529
 530 func @return_type_mismatch() -> i32 {
 531   %0 = "foo"() : ()->f32
 532   return %0 : f32  // expected-error {{type of return operand 0 ('f32') doesn't match function result type ('i32') in function @return_type_mismatch}}
 533 }
 534
 535 // -----
 536
 537 func @return_inside_loop() {
 538   affine.for %i = 1 to 100 {
 539     // expected-error@-1 {{op expects regions to end with 'affine.yield', found 'std.return'}}
 540     // expected-note@-2 {{in custom textual format, the absence of terminator implies}}
 541     return
 542   }
 543   return
 544 }
 545
 546 // -----
 547
 548 // expected-error@+1 {{expected three consecutive dots for an ellipsis}}
 549 func @malformed_ellipsis_one(.)
 550
 551 // -----
 552
 553 // expected-error@+1 {{expected three consecutive dots for an ellipsis}}
 554 func @malformed_ellipsis_two(..)
 555
 556 // -----
 557
 558 // expected-error@+1 {{expected non-function type}}
 559 func @func_variadic(...)
 560
 561 // -----
 562
 563 func @redef()  // expected-note {{see existing symbol definition here}}
 564 func @redef()  // expected-error {{redefinition of symbol named 'redef'}}
 565
 566 // -----
 567
 568 func @foo() {
 569 ^bb0:
 570   %x = constant @foo : (i32) -> ()  // expected-error {{reference to function with mismatched type}}
 571   return
 572 }
 573
 574 // -----
 575
 576 func @undefined_function() {
 577 ^bb0:
 578   %x = constant @qux : (i32) -> ()  // expected-error {{reference to undefined function 'qux'}}
 579   return
 580 }
 581
 582 // -----
 583
 584 #map1 = affine_map<(i)[j] -> (i+j)>
 585
 586 func @bound_symbol_mismatch(%N : index) {
 587   affine.for %i = #map1(%N) to 100 {
 588   // expected-error@-1 {{symbol operand count and affine map symbol count must match}}
 589   }
 590   return
 591 }
 592
 593 // -----
 594
 595 #map1 = affine_map<(i)[j] -> (i+j)>
 596
 597 func @bound_dim_mismatch(%N : index) {
 598   affine.for %i = #map1(%N, %N)[%N] to 100 {
 599   // expected-error@-1 {{dim operand count and affine map dim count must match}}
 600   }
 601   return
 602 }
 603
 604 // -----
 605
 606 func @large_bound() {
 607   affine.for %i = 1 to 9223372036854775810 {
 608   // expected-error@-1 {{integer constant out of range for attribute}}
 609   }
 610   return
 611 }
 612
 613 // -----
 614
 615 func @max_in_upper_bound(%N : index) {
 616   affine.for %i = 1 to max affine_map<(i)->(N, 100)> { //expected-error {{expected non-function type}}
 617   }
 618   return
 619 }
 620
 621 // -----
 622
 623 func @step_typo() {
 624   affine.for %i = 1 to 100 step -- 1 { //expected-error {{expected constant integer}}
 625   }
 626   return
 627 }
 628
 629 // -----
 630
 631 func @invalid_bound_map(%N : i32) {
 632   affine.for %i = 1 to affine_map<(i)->(j)>(%N) { //expected-error {{use of undeclared identifier}}
 633   }
 634   return
 635 }
 636
 637 // -----
 638
 639 // expected-error @+1 {{expected '(' in integer set constraint list}}
 640 #set0 = affine_set<(i)[N, M] : )i >= 0)>
 641
 642 // -----
 643 #set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 644
 645 func @invalid_if_operands1(%N : index) {
 646   affine.for %i = 1 to 10 {
 647     affine.if #set0(%i) {
 648     // expected-error@-1 {{symbol operand count and integer set symbol count must match}}
 649
 650 // -----
 651 #set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 652
 653 func @invalid_if_operands2(%N : index) {
 654   affine.for %i = 1 to 10 {
 655     affine.if #set0()[%N] {
 656     // expected-error@-1 {{dim operand count and integer set dim count must match}}
 657
 658 // -----
 659 #set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 660
 661 func @invalid_if_operands3(%N : index) {
 662   affine.for %i = 1 to 10 {
 663     affine.if #set0(%i)[%i] {
 664     // expected-error@-1 {{operand cannot be used as a symbol}}
 665     }
 666   }
 667   return
 668 }
 669
 670 // -----
 671 // expected-error@+1 {{expected '"' in string literal}}
 672 "J// -----
 673 func @calls(%arg0: i32) {
 674   // expected-error@+1 {{expected non-function type}}
 675   %z = "casdasda"(%x) : (ppop32) -> i32
 676 }
 677 // -----
 678 // expected-error@+2 {{expected SSA operand}}
 679 func@n(){^b(
 680 // -----
 681
 682 func @elementsattr_non_tensor_type() -> () {
 683 ^bb0:
 684   "foo"(){bar = dense<[4]> : i32} : () -> () // expected-error {{elements literal must be a ranked tensor or vector type}}
 685 }
 686
 687 // -----
 688
 689 func @elementsattr_non_ranked() -> () {
 690 ^bb0:
 691   "foo"(){bar = dense<[4]> : tensor<?xi32>} : () -> () // expected-error {{elements literal type must have static shape}}
 692 }
 693
 694 // -----
 695
 696 func @elementsattr_shape_mismatch() -> () {
 697 ^bb0:
 698   "foo"(){bar = dense<[4]> : tensor<5xi32>} : () -> () // expected-error {{inferred shape of elements literal ([1]) does not match type ([5])}}
 699 }
 700
 701 // -----
 702
 703 func @elementsattr_invalid() -> () {
 704 ^bb0:
 705   "foo"(){bar = dense<[4, [5]]> : tensor<2xi32>} : () -> () // expected-error {{tensor literal is invalid; ranks are not consistent between elements}}
 706 }
 707
 708 // -----
 709
 710 func @elementsattr_badtoken() -> () {
 711 ^bb0:
 712   "foo"(){bar = dense<[tf_opaque]> : tensor<1xi32>} : () -> () // expected-error {{expected element literal of primitive type}}
 713 }
 714
 715 // -----
 716
 717 func @elementsattr_floattype1() -> () {
 718 ^bb0:
 719   // expected-error@+1 {{expected integer elements, but parsed floating-point}}
 720   "foo"(){bar = dense<[4.0]> : tensor<1xi32>} : () -> ()
 721 }
 722
 723 // -----
 724
 725 func @elementsattr_floattype1() -> () {
 726 ^bb0:
 727   // expected-error@+1 {{expected integer elements, but parsed floating-point}}
 728   "foo"(){bar = dense<4.0> : tensor<i32>} : () -> ()
 729 }
 730
 731 // -----
 732
 733 func @elementsattr_floattype2() -> () {
 734 ^bb0:
 735   // expected-error@+1 {{expected floating-point elements, but parsed integer}}
 736   "foo"(){bar = dense<[4]> : tensor<1xf32>} : () -> ()
 737 }
 738
 739 // -----
 740
 741 func @elementsattr_toolarge1() -> () {
 742 ^bb0:
 743   "foo"(){bar = dense<[777]> : tensor<1xi8>} : () -> () // expected-error {{integer constant out of range}}
 744 }
 745
 746 // -----
 747
 748 // expected-error@+1 {{parsed zero elements, but type ('tensor<i64>') expected at least 1}}
 749 #attr = dense<> : tensor<i64>
 750
 751 // -----
 752
 753 func @elementsattr_toolarge2() -> () {
 754 ^bb0:
 755   "foo"(){bar = dense<[-777]> : tensor<1xi8>} : () -> () // expected-error {{integer constant out of range}}
 756 }
 757
 758 // -----
 759
 760 "foo"(){bar = dense<[()]> : tensor<complex<i64>>} : () -> () // expected-error {{expected element literal of primitive type}}
 761
 762 // -----
 763
 764 "foo"(){bar = dense<[(10)]> : tensor<complex<i64>>} : () -> () // expected-error {{expected ',' between complex elements}}
 765
 766 // -----
 767
 768 "foo"(){bar = dense<[(10,)]> : tensor<complex<i64>>} : () -> () // expected-error {{expected element literal of primitive type}}
 769
 770 // -----
 771
 772 "foo"(){bar = dense<[(10,10]> : tensor<complex<i64>>} : () -> () // expected-error {{expected ')' after complex elements}}
 773
 774 // -----
 775
 776 func @elementsattr_malformed_opaque() -> () {
 777 ^bb0:
 778   "foo"(){bar = opaque<10, "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected dialect namespace}}
 779 }
 780
 781 // -----
 782
 783 func @elementsattr_malformed_opaque1() -> () {
 784 ^bb0:
 785   "foo"(){bar = opaque<"_", "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
 786 }
 787
 788 // -----
 789
 790 func @elementsattr_malformed_opaque2() -> () {
 791 ^bb0:
 792   "foo"(){bar = opaque<"_", "00abc"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
 793 }
 794
 795 // -----
 796
 797 func @redundant_signature(%a : i32) -> () {
 798 ^bb0(%b : i32):  // expected-error {{invalid block name in region with named arguments}}
 799   return
 800 }
 801
 802 // -----
 803
 804 func @mixed_named_arguments(%a : i32,
 805                                f32) -> () {
 806     // expected-error @-1 {{expected SSA identifier}}
 807   return
 808 }
 809
 810 // -----
 811
 812 func @mixed_named_arguments(f32,
 813                                %a : i32) -> () { // expected-error {{expected type instead of SSA identifier}}
 814   return
 815 }
 816
 817 // -----
 818
 819 // This used to crash the parser, but should just error out by interpreting
 820 // `tensor` as operator rather than as a type.
 821 func @f(f32) {
 822 ^bb0(%a : f32):
 823   %18 = arith.cmpi slt, %idx, %idx : index
 824   tensor<42 x index  // expected-error {{custom op 'tensor' is unknown}}
 825   return
 826 }
 827
 828 // -----
 829
 830 func @f(%m : memref<?x?xf32>) {
 831   affine.for %i0 = 0 to 42 {
 832     // expected-note@+1 {{previously referenced here}}
 833     %x = memref.load %m[%i0, %i1] : memref<?x?xf32>
 834   }
 835   // expected-error@+1 {{region entry argument '%i1' is already in use}}
 836   affine.for %i1 = 0 to 42 {
 837   }
 838   return
 839 }
 840
 841 // -----
 842
 843 func @dialect_type_empty_namespace(!<"">) -> () { // expected-error {{invalid type identifier}}
 844   return
 845 }
 846
 847 // -----
 848
 849 func @dialect_type_no_string_type_data(!foo<>) -> () { // expected-error {{expected string literal data in dialect symbol}}
 850   return
 851 }
 852
 853 // -----
 854
 855 func @dialect_type_missing_greater(!foo<"") -> () { // expected-error {{expected '>' in dialect symbol}}
 856   return
 857 }
 858
 859 // -----
 860
 861 func @type_alias_unknown(!unknown_alias) -> () { // expected-error {{undefined symbol alias id 'unknown_alias'}}
 862   return
 863 }
 864
 865 // -----
 866
 867 // expected-error @+1 {{type names with a '.' are reserved for dialect-defined names}}
 868 !foo.bar = i32
 869
 870 // -----
 871
 872 !missing_eq_alias type i32 // expected-error {{expected '=' in type alias definition}}
 873
 874 // -----
 875
 876 !missing_kw_type_alias = i32 // expected-error {{expected 'type' in type alias definition}}
 877
 878 // -----
 879
 880 !missing_type_alias = type // expected-error@+2 {{expected non-function type}}
 881
 882 // -----
 883
 884 !redef_alias = type i32
 885 !redef_alias = type i32 // expected-error {{redefinition of type alias id 'redef_alias'}}
 886
 887 // -----
 888
 889 // Check ill-formed opaque tensor.
 890 func @complex_loops() {
 891   affine.for %i1 = 1 to 100 {
 892   // expected-error @+1 {{expected '"' in string literal}}
 893   "opaqueIntTensor"(){bar = opaque<"_", "0x686]> : tensor<2x1x4xi32>} : () -> ()
 894
 895 // -----
 896
 897 func @mi() {
 898   // expected-error @+1 {{expected element literal of primitive type}}
 899   "fooi64"(){bar = sparse<vector<1xi64>,[,[,1]
 900
 901 // -----
 902
 903 func @invalid_tensor_literal() {
 904   // expected-error @+1 {{expected 1-d tensor for sparse element values}}
 905   "foof16"(){bar = sparse<[[0, 0, 0]],  [[-2.0]]> : vector<1x1x1xf16>} : () -> ()
 906
 907 // -----
 908
 909 func @invalid_tensor_literal() {
 910   // expected-error @+1 {{expected element literal of primitive type}}
 911   "fooi16"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0,, [[0, 0, 0]], [-2.0]> : tensor<2x2x2xi16>} : () -> ()
 912
 913 // -----
 914
 915 func @invalid_tensor_literal() {
 916   // expected-error @+1 {{sparse index #0 is not contained within the value shape, with index=[1, 1], and type='tensor<1x1xi16>'}}
 917   "fooi16"(){bar = sparse<1, 10> : tensor<1x1xi16>} : () -> ()
 918
 919 // -----
 920
 921 func @invalid_affine_structure() {
 922   %c0 = arith.constant 0 : index
 923   %idx = affine.apply affine_map<(d0, d1)> (%c0, %c0) // expected-error {{expected '->' or ':'}}
 924   return
 925 }
 926
 927 // -----
 928
 929 func @missing_for_max(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
 930   // expected-error @+1 {{lower loop bound affine map with multiple results requires 'max' prefix}}
 931   affine.for %i0 = affine_map<()[s]->(0,s-1)>()[%arg0] to %arg1 {
 932   }
 933   return
 934 }
 935
 936 // -----
 937
 938 func @missing_for_min(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
 939   // expected-error @+1 {{upper loop bound affine map with multiple results requires 'min' prefix}}
 940   affine.for %i0 = %arg0 to affine_map<()[s]->(100,s+1)>()[%arg1] {
 941   }
 942   return
 943 }
 944
 945 // -----
 946
 947 // expected-error @+1 {{vector types must have positive constant sizes}}
 948 func @zero_vector_type() -> vector<0xi32>
 949
 950 // -----
 951
 952 // expected-error @+1 {{vector types must have positive constant sizes}}
 953 func @zero_in_vector_type() -> vector<1x0xi32>
 954
 955 // -----
 956
 957 // expected-error @+1 {{expected non-function type}}
 958 func @negative_vector_size() -> vector<-1xi32>
 959
 960 // -----
 961
 962 // expected-error @+1 {{expected non-function type}}
 963 func @negative_in_vector_size() -> vector<1x-1xi32>
 964
 965 // -----
 966
 967 // expected-error @+1 {{expected non-function type}}
 968 func @negative_memref_size() -> memref<-1xi32>
 969
 970 // -----
 971
 972 // expected-error @+1 {{expected non-function type}}
 973 func @negative_in_memref_size() -> memref<1x-1xi32>
 974
 975 // -----
 976
 977 // expected-error @+1 {{expected non-function type}}
 978 func @negative_tensor_size() -> tensor<-1xi32>
 979
 980 // -----
 981
 982 // expected-error @+1 {{expected non-function type}}
 983 func @negative_in_tensor_size() -> tensor<1x-1xi32>
 984
 985 // -----
 986
 987 func @invalid_nested_dominance() {
 988   "test.ssacfg_region"() ({
 989     // expected-error @+1 {{operand #0 does not dominate this use}}
 990     "foo.use" (%1) : (i32) -> ()
 991     br ^bb2
 992
 993   ^bb2:
 994     // expected-note @+1 {{operand defined here}}
 995     %1 = arith.constant 0 : i32
 996     "foo.yield" () : () -> ()
 997   }) : () -> ()
 998   return
 999 }
1000
1001 // -----
1002
1003 // expected-error @+1 {{unbalanced ']' character in pretty dialect name}}
1004 func @invalid_unknown_type_dialect_name() -> !invalid.dialect<!x@#]!@#>
1005
1006 // -----
1007
1008 // expected-error @+1 {{@ identifier expected to start with letter or '_'}}
1009 func @$invalid_function_name()
1010
1011 // -----
1012
1013 // expected-error @+1 {{arguments may only have dialect attributes}}
1014 func @invalid_func_arg_attr(i1 {non_dialect_attr = 10})
1015
1016 // -----
1017
1018 // expected-error @+1 {{results may only have dialect attributes}}
1019 func @invalid_func_result_attr() -> (i1 {non_dialect_attr = 10})
1020
1021 // -----
1022
1023 // expected-error @+1 {{expected '<' in tuple type}}
1024 func @invalid_tuple_missing_less(tuple i32>)
1025
1026 // -----
1027
1028 // expected-error @+1 {{expected '>' in tuple type}}
1029 func @invalid_tuple_missing_greater(tuple<i32)
1030
1031 // -----
1032
1033 // Should not crash because of deletion order here.
1034 func @invalid_region_dominance() {
1035   "foo.use" (%1) : (i32) -> ()
1036   "foo.region"() ({
1037     %1 = arith.constant 0 : i32  // This value is used outside of the region.
1038     "foo.yield" () : () -> ()
1039   }, {
1040     // expected-error @+1 {{expected operation name in quotes}}
1041     %2 = arith.constant 1 i32  // Syntax error causes region deletion.
1042   }) : () -> ()
1043   return
1044 }
1045
1046 // -----
1047
1048 // Should not crash because of deletion order here.
1049 func @invalid_region_block() {
1050   "foo.branch"()[^bb2] : () -> ()  // Attempt to jump into the region.
1051
1052 ^bb1:
1053   "foo.region"() ({
1054     ^bb2:
1055       "foo.yield"() : () -> ()
1056   }, {
1057     // expected-error @+1 {{expected operation name in quotes}}
1058     %2 = arith.constant 1 i32  // Syntax error causes region deletion.
1059   }) : () -> ()
1060 }
1061
1062 // -----
1063
1064 // Should not crash because of deletion order here.
1065 func @invalid_region_dominance() {
1066   "foo.use" (%1) : (i32) -> ()
1067   "foo.region"() ({
1068     "foo.region"() ({
1069       %1 = arith.constant 0 : i32  // This value is used outside of the region.
1070       "foo.yield" () : () -> ()
1071     }) : () -> ()
1072   }, {
1073     // expected-error @+1 {{expected operation name in quotes}}
1074     %2 = arith.constant 1 i32  // Syntax error causes region deletion.
1075   }) : () -> ()
1076   return
1077 }
1078
1079 // -----
1080
1081 func @unfinished_region_list() {
1082   // expected-error@+1 {{expected ')' to end region list}}
1083   "region"() ({},{},{} : () -> ()
1084 }
1085
1086 // -----
1087
1088 func @multi_result_missing_count() {
1089   // expected-error@+1 {{expected integer number of results}}
1090   %0: = "foo" () : () -> (i32, i32)
1091   return
1092 }
1093
1094 // -----
1095
1096 func @multi_result_zero_count() {
1097   // expected-error@+1 {{expected named operation to have atleast 1 result}}
1098   %0:0 = "foo" () : () -> (i32, i32)
1099   return
1100 }
1101
1102 // -----
1103
1104 func @multi_result_invalid_identifier() {
1105   // expected-error@+1 {{expected valid ssa identifier}}
1106   %0, = "foo" () : () -> (i32, i32)
1107   return
1108 }
1109
1110 // -----
1111
1112 func @multi_result_mismatch_count() {
1113   // expected-error@+1 {{operation defines 2 results but was provided 1 to bind}}
1114   %0:1 = "foo" () : () -> (i32, i32)
1115   return
1116 }
1117
1118 // -----
1119
1120 func @multi_result_mismatch_count() {
1121   // expected-error@+1 {{operation defines 2 results but was provided 3 to bind}}
1122   %0, %1, %3 = "foo" () : () -> (i32, i32)
1123   return
1124 }
1125
1126 // -----
1127
1128 func @no_result_with_name() {
1129   // expected-error@+1 {{cannot name an operation with no results}}
1130   %0 = "foo" () : () -> ()
1131   return
1132 }
1133
1134 // -----
1135
1136 func @conflicting_names() {
1137   // expected-note@+1 {{previously defined here}}
1138   %foo, %bar  = "foo" () : () -> (i32, i32)
1139
1140   // expected-error@+1 {{redefinition of SSA value '%bar'}}
1141   %bar, %baz  = "foo" () : () -> (i32, i32)
1142   return
1143 }
1144
1145 // -----
1146
1147 func @ssa_name_missing_eq() {
1148   // expected-error@+1 {{expected '=' after SSA name}}
1149   %0:2 "foo" () : () -> (i32, i32)
1150   return
1151 }
1152
1153 // -----
1154
1155 // expected-error @+1 {{invalid element type for complex}}
1156 func @bad_complex(complex<memref<2x4xi8>>)
1157
1158 // -----
1159
1160 // expected-error @+1 {{expected '<' in complex type}}
1161 func @bad_complex(complex memref<2x4xi8>>)
1162
1163 // -----
1164
1165 // expected-error @+1 {{expected '>' in complex type}}
1166 func @bad_complex(complex<i32)
1167
1168 // -----
1169
1170 // expected-error @+1 {{attribute names with a '.' are reserved for dialect-defined names}}
1171 #foo.attr = i32
1172
1173 // -----
1174
1175 func @invalid_region_dominance() {
1176   "test.ssacfg_region"() ({
1177     // expected-error @+1 {{operand #0 does not dominate this use}}
1178     "foo.use" (%def) : (i32) -> ()
1179     "foo.yield" () : () -> ()
1180   }, {
1181     // expected-note @+1 {{operand defined here}}
1182     %def = "foo.def" () : () -> i32
1183   }) : () -> ()
1184   return
1185 }
1186
1187 // -----
1188
1189 func @invalid_region_dominance() {
1190   // expected-note @+1 {{operand defined here}}
1191   %def = "test.ssacfg_region"() ({
1192     // expected-error @+1 {{operand #0 does not dominate this use}}
1193     "foo.use" (%def) : (i32) -> ()
1194     "foo.yield" () : () -> ()
1195   }) : () -> (i32)
1196   return
1197 }
1198
1199 // -----
1200
1201 func @hexadecimal_float_leading_minus() {
1202   // expected-error @+1 {{hexadecimal float literal should not have a leading minus}}
1203   "foo"() {value = -0x7fff : f16} : () -> ()
1204 }
1205
1206 // -----
1207
1208 func @hexadecimal_float_literal_overflow() {
1209   // expected-error @+1 {{hexadecimal float constant out of range for type}}
1210   "foo"() {value = 0xffffffff : f16} : () -> ()
1211 }
1212
1213 // -----
1214
1215 func @decimal_float_literal() {
1216   // expected-error @+2 {{unexpected decimal integer literal for a floating point value}}
1217   // expected-note @+1 {{add a trailing dot to make the literal a float}}
1218   "foo"() {value = 42 : f32} : () -> ()
1219 }
1220
1221 // -----
1222
1223 func @float_in_int_tensor() {
1224   // expected-error @+1 {{expected integer elements, but parsed floating-point}}
1225   "foo"() {bar = dense<[42.0, 42]> : tensor<2xi32>} : () -> ()
1226 }
1227
1228 // -----
1229
1230 func @float_in_bool_tensor() {
1231   // expected-error @+1 {{expected integer elements, but parsed floating-point}}
1232   "foo"() {bar = dense<[true, 42.0]> : tensor<2xi1>} : () -> ()
1233 }
1234
1235 // -----
1236
1237 func @decimal_int_in_float_tensor() {
1238   // expected-error @+1 {{expected floating-point elements, but parsed integer}}
1239   "foo"() {bar = dense<[42, 42.0]> : tensor<2xf32>} : () -> ()
1240 }
1241
1242 // -----
1243
1244 func @bool_in_float_tensor() {
1245   // expected-error @+1 {{expected floating-point elements, but parsed integer}}
1246   "foo"() {bar = dense<[42.0, true]> : tensor<2xf32>} : () -> ()
1247 }
1248
1249 // -----
1250
1251 func @hexadecimal_float_leading_minus_in_tensor() {
1252   // expected-error @+1 {{hexadecimal float literal should not have a leading minus}}
1253   "foo"() {bar = dense<-0x7FFFFFFF> : tensor<2xf32>} : () -> ()
1254 }
1255
1256 // -----
1257
1258 // Check that we report an error when a value could be parsed, but does not fit
1259 // into the specified type.
1260 func @hexadecimal_float_too_wide_for_type_in_tensor() {
1261   // expected-error @+1 {{hexadecimal float constant out of range for type}}
1262   "foo"() {bar = dense<0x7FF0000000000000> : tensor<2xf32>} : () -> ()
1263 }
1264
1265 // -----
1266
1267 // Check that we report an error when a value is too wide to be parsed.
1268 func @hexadecimal_float_too_wide_in_tensor() {
1269   // expected-error @+1 {{hexadecimal float constant out of range for type}}
1270   "foo"() {bar = dense<0x7FFFFFF0000000000000> : tensor<2xf32>} : () -> ()
1271 }
1272
1273 // -----
1274
1275 func @integer_too_wide_in_tensor() {
1276   // expected-error @+1 {{integer constant out of range for type}}
1277   "foo"() {bar = dense<0xFFFFFFFFFFFFFF> : tensor<2xi16>} : () -> ()
1278 }
1279
1280 // -----
1281
1282 func @bool_literal_in_non_bool_tensor() {
1283   // expected-error @+1 {{expected i1 type for 'true' or 'false' values}}
1284   "foo"() {bar = dense<true> : tensor<2xi16>} : () -> ()
1285 }
1286
1287 // -----
1288
1289 // expected-error @+1 {{unbalanced ')' character in pretty dialect name}}
1290 func @bad_arrow(%arg : !unreg.ptr<(i32)->)
1291
1292 // -----
1293
1294 func @negative_value_in_unsigned_int_attr() {
1295   // expected-error @+1 {{negative integer literal not valid for unsigned integer type}}
1296   "foo"() {bar = -5 : ui32} : () -> ()
1297 }
1298
1299 // -----
1300
1301 func @negative_value_in_unsigned_vector_attr() {
1302   // expected-error @+1 {{expected unsigned integer elements, but parsed negative value}}
1303   "foo"() {bar = dense<[5, -5]> : vector<2xui32>} : () -> ()
1304 }
1305
1306 // -----
1307
1308 func @large_bound() {
1309   "test.out_of_range_attribute"() {
1310     // expected-error @+1 {{integer constant out of range for attribute}}
1311     attr = -129 : i8
1312   } : () -> ()
1313   return
1314 }
1315
1316 // -----
1317
1318 func @large_bound() {
1319   "test.out_of_range_attribute"() {
1320     // expected-error @+1 {{integer constant out of range for attribute}}
1321     attr = 256 : i8
1322   } : () -> ()
1323   return
1324 }
1325
1326 // -----
1327
1328 func @large_bound() {
1329   "test.out_of_range_attribute"() {
1330     // expected-error @+1 {{integer constant out of range for attribute}}
1331     attr = -129 : si8
1332   } : () -> ()
1333   return
1334 }
1335
1336 // -----
1337
1338 func @large_bound() {
1339   "test.out_of_range_attribute"() {
1340     // expected-error @+1 {{integer constant out of range for attribute}}
1341     attr = 129 : si8
1342   } : () -> ()
1343   return
1344 }
1345
1346 // -----
1347
1348 func @large_bound() {
1349   "test.out_of_range_attribute"() {
1350     // expected-error @+1 {{negative integer literal not valid for unsigned integer type}}
1351     attr = -1 : ui8
1352   } : () -> ()
1353   return
1354 }
1355
1356 // -----
1357
1358 func @large_bound() {
1359   "test.out_of_range_attribute"() {
1360     // expected-error @+1 {{integer constant out of range for attribute}}
1361     attr = 256 : ui8
1362   } : () -> ()
1363   return
1364 }
1365
1366 // -----
1367
1368 func @large_bound() {
1369   "test.out_of_range_attribute"() {
1370     // expected-error @+1 {{integer constant out of range for attribute}}
1371     attr = -32769 : i16
1372   } : () -> ()
1373   return
1374 }
1375
1376 // -----
1377
1378 func @large_bound() {
1379   "test.out_of_range_attribute"() {
1380     // expected-error @+1 {{integer constant out of range for attribute}}
1381     attr = 65536 : i16
1382   } : () -> ()
1383   return
1384 }
1385
1386 // -----
1387
1388 func @large_bound() {
1389   "test.out_of_range_attribute"() {
1390     // expected-error @+1 {{integer constant out of range for attribute}}
1391     attr = -32769 : si16
1392   } : () -> ()
1393   return
1394 }
1395
1396 // -----
1397
1398 func @large_bound() {
1399   "test.out_of_range_attribute"() {
1400     // expected-error @+1 {{integer constant out of range for attribute}}
1401     attr = 32768 : si16
1402   } : () -> ()
1403   return
1404 }
1405
1406 // -----
1407
1408 func @large_bound() {
1409   "test.out_of_range_attribute"() {
1410     // expected-error @+1 {{negative integer literal not valid for unsigned integer type}}
1411     attr = -1 : ui16
1412   } : () -> ()
1413   return
1414 }
1415
1416 // -----
1417
1418 func @large_bound() {
1419   "test.out_of_range_attribute"() {
1420     // expected-error @+1 {{integer constant out of range for attribute}}
1421     attr = 65536: ui16
1422   } : () -> ()
1423   return
1424 }
1425
1426 // -----
1427
1428 func @large_bound() {
1429   "test.out_of_range_attribute"() {
1430     // expected-error @+1 {{integer constant out of range for attribute}}
1431     attr = -2147483649 : i32
1432   } : () -> ()
1433   return
1434 }
1435
1436 // -----
1437
1438 func @large_bound() {
1439   "test.out_of_range_attribute"() {
1440     // expected-error @+1 {{integer constant out of range for attribute}}
1441     attr = 4294967296 : i32
1442   } : () -> ()
1443   return
1444 }
1445
1446 // -----
1447
1448 func @large_bound() {
1449   "test.out_of_range_attribute"() {
1450     // expected-error @+1 {{integer constant out of range for attribute}}
1451     attr = -2147483649 : si32
1452   } : () -> ()
1453   return
1454 }
1455
1456 // -----
1457
1458 func @large_bound() {
1459   "test.out_of_range_attribute"() {
1460     // expected-error @+1 {{integer constant out of range for attribute}}
1461     attr = 2147483648 : si32
1462   } : () -> ()
1463   return
1464 }
1465
1466 // -----
1467
1468 func @large_bound() {
1469   "test.out_of_range_attribute"() {
1470     // expected-error @+1 {{negative integer literal not valid for unsigned integer type}}
1471     attr = -1 : ui32
1472   } : () -> ()
1473   return
1474 }
1475
1476 // -----
1477
1478 func @large_bound() {
1479   "test.out_of_range_attribute"() {
1480     // expected-error @+1 {{integer constant out of range for attribute}}
1481     attr = 4294967296 : ui32
1482   } : () -> ()
1483   return
1484 }
1485
1486 // -----
1487
1488 func @large_bound() {
1489   "test.out_of_range_attribute"() {
1490     // expected-error @+1 {{integer constant out of range for attribute}}
1491     attr = -9223372036854775809 : i64
1492   } : () -> ()
1493   return
1494 }
1495
1496 // -----
1497
1498 func @large_bound() {
1499   "test.out_of_range_attribute"() {
1500     // expected-error @+1 {{integer constant out of range for attribute}}
1501     attr = 18446744073709551616 : i64
1502   } : () -> ()
1503   return
1504 }
1505
1506 // -----
1507
1508 func @large_bound() {
1509   "test.out_of_range_attribute"() {
1510     // expected-error @+1 {{integer constant out of range for attribute}}
1511     attr = -9223372036854775809 : si64
1512   } : () -> ()
1513   return
1514 }
1515
1516 // -----
1517
1518 func @large_bound() {
1519   "test.out_of_range_attribute"() {
1520     // expected-error @+1 {{integer constant out of range for attribute}}
1521     attr = 9223372036854775808 : si64
1522   } : () -> ()
1523   return
1524 }
1525
1526 // -----
1527
1528 func @large_bound() {
1529   "test.out_of_range_attribute"() {
1530     // expected-error @+1 {{negative integer literal not valid for unsigned integer type}}
1531     attr = -1 : ui64
1532   } : () -> ()
1533   return
1534 }
1535
1536 // -----
1537
1538 func @large_bound() {
1539   "test.out_of_range_attribute"() {
1540     // expected-error @+1 {{integer constant out of range for attribute}}
1541     attr = 18446744073709551616 : ui64
1542   } : () -> ()
1543   return
1544 }
1545
1546 // -----
1547
1548 func @really_large_bound() {
1549   "test.out_of_range_attribute"() {
1550     // expected-error @+1 {{integer constant out of range for attribute}}
1551     attr = 79228162514264337593543950336 : ui96
1552   } : () -> ()
1553   return
1554 }
1555
1556 // -----
1557
1558 func @really_large_bound() {
1559   "test.out_of_range_attribute"() {
1560     // expected-error @+1 {{integer constant out of range for attribute}}
1561     attr = 79228162514264337593543950336 : i96
1562   } : () -> ()
1563   return
1564 }
1565
1566 // -----
1567
1568 func @really_large_bound() {
1569   "test.out_of_range_attribute"() {
1570     // expected-error @+1 {{integer constant out of range for attribute}}
1571     attr = 39614081257132168796771975168 : si96
1572   } : () -> ()
1573   return
1574 }
1575
1576 // -----
1577
1578 func @duplicate_dictionary_attr_key() {
1579   // expected-error @+1 {{duplicate key 'a' in dictionary attribute}}
1580   "foo.op"() {a, a} : () -> ()
1581 }
1582
1583 // -----
1584
1585 // expected-error @+1 {{attribute 'attr' occurs more than once in the attribute list}}
1586 test.format_symbol_name_attr_op @name { attr = "xx" }
1587
1588 // -----
1589
1590 func @forward_reference_type_check() -> (i8) {
1591   br ^bb2
1592
1593 ^bb1:
1594   // expected-note @+1 {{previously used here with type 'i8'}}
1595   return %1 : i8
1596
1597 ^bb2:
1598   // expected-error @+1 {{definition of SSA value '%1#0' has type 'f32'}}
1599   %1 = "bar"() : () -> (f32)
1600   br ^bb1
1601 }
1602
1603 // -----
1604
1605 func @dominance_error_in_unreachable_op() -> i1 {
1606   %c = arith.constant false
1607   return %c : i1
1608 ^bb0:
1609   "test.ssacfg_region" () ({ // unreachable
1610     ^bb1:
1611 // expected-error @+1 {{operand #0 does not dominate this use}}
1612       %2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
1613       br ^bb4
1614     ^bb2:
1615       br ^bb2
1616     ^bb4:
1617       %1 = "foo"() : ()->i64   // expected-note {{operand defined here}}
1618   }) : () -> ()
1619   return %c : i1
1620 }
1621
1622 // -----
1623
1624 func @invalid_region_dominance_with_dominance_free_regions() {
1625   test.graph_region {
1626     "foo.use" (%1) : (i32) -> ()
1627     "foo.region"() ({
1628       %1 = arith.constant 0 : i32  // This value is used outside of the region.
1629       "foo.yield" () : () -> ()
1630     }, {
1631       // expected-error @+1 {{expected operation name in quotes}}
1632       %2 = arith.constant 1 i32  // Syntax error causes region deletion.
1633     }) : () -> ()
1634   }
1635   return
1636 }
1637
1638 // -----
1639
1640 func @foo() {} // expected-error {{expected non-empty function body}}