1// RUN: mlir-opt %s -split-input-file -verify-diagnostics 2 3// ----- 4 5func @broadcast_to_scalar(%arg0: f32) -> f32 { 6 // expected-error@+1 {{'vector.broadcast' op result #0 must be vector of any type values, but got 'f32'}} 7 %0 = vector.broadcast %arg0 : f32 to f32 8} 9 10// ----- 11 12func @broadcast_rank_too_high(%arg0: vector<4x4xf32>) { 13 // expected-error@+1 {{'vector.broadcast' op source rank higher than destination rank}} 14 %1 = vector.broadcast %arg0 : vector<4x4xf32> to vector<4xf32> 15} 16 17// ----- 18 19func @broadcast_dim1_mismatch(%arg0: vector<7xf32>) { 20 // expected-error@+1 {{'vector.broadcast' op dimension mismatch (7 vs. 3)}} 21 %1 = vector.broadcast %arg0 : vector<7xf32> to vector<3xf32> 22} 23 24// ----- 25 26func @broadcast_dim2_mismatch(%arg0: vector<4x8xf32>) { 27 // expected-error@+1 {{'vector.broadcast' op dimension mismatch (4 vs. 1)}} 28 %1 = vector.broadcast %arg0 : vector<4x8xf32> to vector<1x8xf32> 29} 30 31// ----- 32 33func @shuffle_elt_type_mismatch(%arg0: vector<2xf32>, %arg1: vector<2xi32>) { 34 // expected-error@+1 {{'vector.shuffle' op failed to verify that second operand v2 and result have same element type}} 35 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xi32> 36} 37 38// ----- 39 40func @shuffle_rank_mismatch(%arg0: vector<2xf32>, %arg1: vector<4x2xf32>) { 41 // expected-error@+1 {{'vector.shuffle' op rank mismatch}} 42 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<4x2xf32> 43} 44 45// ----- 46 47func @shuffle_trailing_dim_size_mismatch(%arg0: vector<2x2xf32>, %arg1: vector<2x4xf32>) { 48 // expected-error@+1 {{'vector.shuffle' op dimension mismatch}} 49 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2x2xf32>, vector<2x4xf32> 50} 51 52// ----- 53 54func @shuffle_index_out_of_range(%arg0: vector<2xf32>, %arg1: vector<2xf32>) { 55 // expected-error@+1 {{'vector.shuffle' op mask index #2 out of range}} 56 %1 = vector.shuffle %arg0, %arg1 [0, 4] : vector<2xf32>, vector<2xf32> 57} 58 59// ----- 60 61func @shuffle_empty_mask(%arg0: vector<2xf32>, %arg1: vector<2xf32>) { 62 // expected-error@+1 {{'vector.shuffle' invalid mask length}} 63 %1 = vector.shuffle %arg0, %arg1 [] : vector<2xf32>, vector<2xf32> 64} 65 66// ----- 67 68func @extract_element(%arg0: vector<4x4xf32>) { 69 %c = constant 3 : i32 70 // expected-error@+1 {{'vector.extractelement' op expected 1-D vector}} 71 %1 = vector.extractelement %arg0[%c : i32] : vector<4x4xf32> 72} 73 74// ----- 75 76func @extract_vector_type(%arg0: index) { 77 // expected-error@+1 {{expected vector type}} 78 %1 = vector.extract %arg0[] : index 79} 80 81// ----- 82 83func @extract_position_empty(%arg0: vector<4x8x16xf32>) { 84 // expected-error@+1 {{expected non-empty position attribute}} 85 %1 = vector.extract %arg0[] : vector<4x8x16xf32> 86} 87 88// ----- 89 90func @extract_position_rank_overflow(%arg0: vector<4x8x16xf32>) { 91 // expected-error@+1 {{expected position attribute of rank smaller than vector}} 92 %1 = vector.extract %arg0[0, 0, 0, 0] : vector<4x8x16xf32> 93} 94 95// ----- 96 97func @extract_position_rank_overflow_generic(%arg0: vector<4x8x16xf32>) { 98 // expected-error@+1 {{expected position attribute of rank smaller than vector}} 99 %1 = "vector.extract" (%arg0) { position = [0, 0, 0, 0] } : (vector<4x8x16xf32>) -> (vector<16xf32>) 100} 101 102// ----- 103 104func @extract_position_overflow(%arg0: vector<4x8x16xf32>) { 105 // expected-error@+1 {{expected position attribute #2 to be a non-negative integer smaller than the corresponding vector dimension}} 106 %1 = vector.extract %arg0[0, 43, 0] : vector<4x8x16xf32> 107} 108 109// ----- 110 111func @extract_precise_position_overflow(%arg0: vector<4x8x16xf32>) { 112 // expected-error@+1 {{expected position attribute #3 to be a non-negative integer smaller than the corresponding vector dimension}} 113 %1 = vector.extract %arg0[3, 7, 16] : vector<4x8x16xf32> 114} 115 116// ----- 117 118func @extract_position_overflow(%arg0: vector<4x8x16xf32>) { 119 // expected-error@+1 {{expected position attribute #3 to be a non-negative integer smaller than the corresponding vector dimension}} 120 %1 = vector.extract %arg0[0, 0, -1] : vector<4x8x16xf32> 121} 122 123// ----- 124 125func @insert_element(%arg0: f32, %arg1: vector<4x4xf32>) { 126 %c = constant 3 : i32 127 // expected-error@+1 {{'vector.insertelement' op expected 1-D vector}} 128 %0 = vector.insertelement %arg0, %arg1[%c : i32] : vector<4x4xf32> 129} 130 131// ----- 132 133func @insert_element_wrong_type(%arg0: i32, %arg1: vector<4xf32>) { 134 %c = constant 3 : i32 135 // expected-error@+1 {{'vector.insertelement' op failed to verify that source operand type matches element type of result}} 136 %0 = "vector.insertelement" (%arg0, %arg1, %c) : (i32, vector<4xf32>, i32) -> (vector<4xf32>) 137} 138 139// ----- 140 141func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) { 142 // expected-error@+1 {{expected non-empty position attribute}} 143 %1 = vector.insert %a, %b[] : f32 into vector<4x8x16xf32> 144} 145 146// ----- 147 148func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) { 149 // expected-error@+1 {{expected position attribute of rank smaller than dest vector rank}} 150 %1 = vector.insert %a, %b[3, 3, 3, 3, 3, 3] : f32 into vector<4x8x16xf32> 151} 152 153// ----- 154 155func @insert_vector_type(%a: vector<4xf32>, %b: vector<4x8x16xf32>) { 156 // expected-error@+1 {{expected position attribute rank + source rank to match dest vector rank}} 157 %1 = vector.insert %a, %b[3] : vector<4xf32> into vector<4x8x16xf32> 158} 159 160// ----- 161 162func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) { 163 // expected-error@+1 {{expected position attribute rank to match the dest vector rank}} 164 %1 = vector.insert %a, %b[3, 3] : f32 into vector<4x8x16xf32> 165} 166 167// ----- 168 169func @insert_position_overflow(%a: f32, %b: vector<4x8x16xf32>) { 170 // expected-error@+1 {{expected position attribute #3 to be a non-negative integer smaller than the corresponding dest vector dimension}} 171 %1 = vector.insert %a, %b[0, 0, -1] : f32 into vector<4x8x16xf32> 172} 173 174// ----- 175 176func @insert_precise_position_overflow(%a: f32, %b: vector<4x8x16xf32>) { 177 // expected-error@+1 {{expected position attribute #1 to be a non-negative integer smaller than the corresponding dest vector dimension}} 178 %1 = vector.insert %a, %b[4, 7, 15] : f32 into vector<4x8x16xf32> 179} 180 181// ----- 182 183func @outerproduct_num_operands(%arg0: f32) { 184 // expected-error@+1 {{expected at least 2 operands}} 185 %1 = vector.outerproduct %arg0 : f32, f32 186} 187// ----- 188 189func @outerproduct_non_vector_operand(%arg0: f32) { 190 // expected-error@+1 {{expected vector type for operand #1}} 191 %1 = vector.outerproduct %arg0, %arg0 : f32, f32 192} 193 194// ----- 195 196func @outerproduct_operand_1(%arg0: vector<4xf32>, %arg1: vector<4x8xf32>) { 197 // expected-error@+1 {{expected 1-d vector for operand #1}} 198 %1 = vector.outerproduct %arg1, %arg1 : vector<4x8xf32>, vector<4x8xf32> 199} 200 201// ----- 202 203func @outerproduct_operand_2(%arg0: vector<4xf32>, %arg1: vector<4x8xf32>) { 204 // expected-error@+1 {{expected 1-d vector for operand #2}} 205 %1 = vector.outerproduct %arg0, %arg1 : vector<4xf32>, vector<4x8xf32> 206} 207 208// ----- 209 210func @outerproduct_result_generic(%arg0: vector<4xf32>, %arg1: vector<8xf32>) { 211 // expected-error@+1 {{expected 2-d vector result}} 212 %1 = "vector.outerproduct" (%arg0, %arg1) : (vector<4xf32>, vector<8xf32>) -> (vector<8xf32>) 213} 214 215// ----- 216 217func @outerproduct_operand_1_dim_generic(%arg0: vector<4xf32>, %arg1: vector<8xf32>) { 218 // expected-error@+1 {{expected #1 operand dim to match result dim #1}} 219 %1 = "vector.outerproduct" (%arg0, %arg1) : (vector<4xf32>, vector<8xf32>) -> (vector<8x16xf32>) 220} 221 222// ----- 223 224func @outerproduct_operand_2_dim_generic(%arg0: vector<4xf32>, %arg1: vector<8xf32>) { 225 // expected-error@+1 {{expected #2 operand dim to match result dim #2}} 226 %1 = "vector.outerproduct" (%arg0, %arg1) : (vector<4xf32>, vector<8xf32>) -> (vector<4x16xf32>) 227} 228 229// ----- 230 231func @outerproduct_axpy_operand(%arg0: vector<4x8xf32>, %arg1: f32) { 232 // expected-error@+1 {{expected 1-d vector for operand #1}} 233 %1 = vector.outerproduct %arg0, %arg1 : vector<4x8xf32>, f32 234} 235 236// ----- 237 238func @outerproduct_axpy_result_generic(%arg0: vector<4xf32>, %arg1: f32) { 239 // expected-error@+1 {{expected 1-d vector result}} 240 %1 = "vector.outerproduct" (%arg0, %arg1) : (vector<4xf32>, f32) -> (vector<4x8xf32>) 241} 242 243// ----- 244 245func @outerproduct_axpy_operand_dim_generic(%arg0: vector<8xf32>, %arg1: f32) { 246 // expected-error@+1 {{expected #1 operand dim to match result dim #1}} 247 %1 = "vector.outerproduct" (%arg0, %arg1) : (vector<8xf32>, f32) -> (vector<16xf32>) 248} 249 250// ----- 251 252func @outerproduct_operand_3_result_type_generic(%arg0: vector<4xf32>, %arg1: vector<8xf32>, %arg2: vector<4x16xf32>) { 253 // expected-error@+1 {{expected operand #3 of same type as result type}} 254 %1 = "vector.outerproduct" (%arg0, %arg1, %arg2) : (vector<4xf32>, vector<8xf32>, vector<4x16xf32>) -> (vector<4x8xf32>) 255} 256 257// ----- 258 259func @test_vector.transfer_read(%arg0: memref<?x?xf32>) { 260 %c3 = constant 3 : index 261 %cst = constant 3.0 : f32 262 // expected-error@+1 {{requires two types}} 263 %0 = vector.transfer_read %arg0[%c3, %c3], %cst { permutation_map = affine_map<()->(0)> } : memref<?x?xf32> 264} 265 266// ----- 267 268func @test_vector.transfer_read(%arg0: vector<4x3xf32>) { 269 %c3 = constant 3 : index 270 %f0 = constant 0.0 : f32 271 %vf0 = splat %f0 : vector<4x3xf32> 272 // expected-error@+1 {{ requires memref or ranked tensor type}} 273 %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 : vector<4x3xf32>, vector<1x1x2x3xf32> 274} 275 276// ----- 277 278func @test_vector.transfer_read(%arg0: memref<4x3xf32>) { 279 %c3 = constant 3 : index 280 %f0 = constant 0.0 : f32 281 %vf0 = splat %f0 : vector<4x3xf32> 282 // expected-error@+1 {{ requires vector type}} 283 %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 : memref<4x3xf32>, f32 284} 285 286// ----- 287 288func @test_vector.transfer_read(%arg0: memref<?x?xf32>) { 289 %c3 = constant 3 : index 290 %cst = constant 3.0 : f32 291 // expected-error@+1 {{requires 2 indices}} 292 %0 = vector.transfer_read %arg0[%c3, %c3, %c3], %cst { permutation_map = affine_map<()->(0)> } : memref<?x?xf32>, vector<128xf32> 293} 294 295// ----- 296 297func @test_vector.transfer_read(%arg0: memref<?x?xf32>) { 298 %c3 = constant 3 : index 299 %cst = constant 3.0 : f32 300 // expected-error@+1 {{requires a permutation_map with input dims of the same rank as the source type}} 301 %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0)->(d0)>} : memref<?x?xf32>, vector<128xf32> 302} 303 304// ----- 305 306func @test_vector.transfer_read(%arg0: memref<?x?xf32>) { 307 %c3 = constant 3 : index 308 %cst = constant 3.0 : f32 309 // expected-error@+1 {{requires a permutation_map with result dims of the same rank as the vector type}} 310 %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xf32>, vector<128xf32> 311} 312 313// ----- 314 315func @test_vector.transfer_read(%arg0: memref<?x?xf32>) { 316 %c3 = constant 3 : index 317 %cst = constant 3.0 : f32 318 // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}} 319 %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0 + d1)>} : memref<?x?xf32>, vector<128xf32> 320} 321 322// ----- 323 324func @test_vector.transfer_read(%arg0: memref<?x?xf32>) { 325 %c3 = constant 3 : index 326 %cst = constant 3.0 : f32 327 // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}} 328 %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0 + 1)>} : memref<?x?xf32>, vector<128xf32> 329} 330 331// ----- 332 333func @test_vector.transfer_read(%arg0: memref<?x?x?xf32>) { 334 %c3 = constant 3 : index 335 %cst = constant 3.0 : f32 336 // expected-error@+1 {{requires a permutation_map that is a permutation (found one dim used more than once)}} 337 %0 = vector.transfer_read %arg0[%c3, %c3, %c3], %cst {permutation_map = affine_map<(d0, d1, d2)->(d0, d0)>} : memref<?x?x?xf32>, vector<3x7xf32> 338} 339 340// ----- 341 342func @test_vector.transfer_read(%arg0: memref<?x?xvector<4x3xf32>>) { 343 %c3 = constant 3 : index 344 %f0 = constant 0.0 : f32 345 %vf0 = splat %f0 : vector<4x3xf32> 346 // expected-error@+1 {{requires source vector element and vector result ranks to match}} 347 %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<3xf32> 348} 349 350// ----- 351 352func @test_vector.transfer_read(%arg0: memref<?x?xvector<6xf32>>) { 353 %c3 = constant 3 : index 354 %f0 = constant 0.0 : f32 355 %vf0 = splat %f0 : vector<6xf32> 356 // expected-error@+1 {{requires the bitwidth of the minor 1-D vector to be an integral multiple of the bitwidth of the minor 1-D vector of the source}} 357 %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 : memref<?x?xvector<6xf32>>, vector<3xf32> 358} 359 360// ----- 361 362func @test_vector.transfer_read(%arg0: memref<?x?xvector<2x3xf32>>) { 363 %c3 = constant 3 : index 364 %f0 = constant 0.0 : f32 365 %vf0 = splat %f0 : vector<2x3xf32> 366 // expected-error@+1 {{ expects the optional in_bounds attr of same rank as permutation_map results: affine_map<(d0, d1) -> (d0, d1)>}} 367 %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {in_bounds = [true], permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<2x3xf32>>, vector<1x1x2x3xf32> 368} 369 370// ----- 371 372func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 373 %c3 = constant 3 : index 374 %cst = constant 3.0 : f32 375 // expected-error@+1 {{requires two types}} 376 vector.transfer_write %arg0, %arg0[%c3, %c3] : memref<?x?xf32> 377} 378 379// ----- 380 381func @test_vector.transfer_write(%arg0: memref<vector<4x3xf32>>) { 382 %c3 = constant 3 : index 383 %f0 = constant 0.0 : f32 384 %vf0 = splat %f0 : vector<4x3xf32> 385 // expected-error@+1 {{ requires vector type}} 386 vector.transfer_write %arg0, %arg0[%c3, %c3] : memref<vector<4x3xf32>>, vector<4x3xf32> 387} 388 389// ----- 390 391func @test_vector.transfer_write(%arg0: vector<4x3xf32>) { 392 %c3 = constant 3 : index 393 %f0 = constant 0.0 : f32 394 %vf0 = splat %f0 : vector<4x3xf32> 395 // expected-error@+1 {{ requires memref or ranked tensor type}} 396 vector.transfer_write %arg0, %arg0[%c3, %c3] : vector<4x3xf32>, f32 397} 398 399// ----- 400 401func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 402 %c3 = constant 3 : index 403 %cst = constant dense<3.0> : vector<128 x f32> 404 // expected-error@+1 {{expected 5 operand types but had 4}} 405 %0 = "vector.transfer_write"(%cst, %arg0, %c3, %c3, %c3) {permutation_map = affine_map<()->(0)>} : (vector<128xf32>, memref<?x?xf32>, index, index) -> () 406} 407 408// ----- 409 410func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 411 %c3 = constant 3 : index 412 %cst = constant dense<3.0> : vector<128 x f32> 413 // expected-error@+1 {{requires 2 indices}} 414 vector.transfer_write %cst, %arg0[%c3, %c3, %c3] {permutation_map = affine_map<()->(0)>} : vector<128xf32>, memref<?x?xf32> 415} 416 417// ----- 418 419func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 420 %c3 = constant 3 : index 421 %cst = constant dense<3.0> : vector<128 x f32> 422 // expected-error@+1 {{requires a permutation_map with input dims of the same rank as the source type}} 423 vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0)->(d0)>} : vector<128xf32>, memref<?x?xf32> 424} 425 426// ----- 427 428func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 429 %c3 = constant 3 : index 430 %cst = constant dense<3.0> : vector<128 x f32> 431 // expected-error@+1 {{requires a permutation_map with result dims of the same rank as the vector type}} 432 vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : vector<128xf32>, memref<?x?xf32> 433} 434 435// ----- 436 437func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 438 %c3 = constant 3 : index 439 %cst = constant dense<3.0> : vector<128 x f32> 440 // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}} 441 vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0 + d1)>} : vector<128xf32>, memref<?x?xf32> 442} 443 444// ----- 445 446func @test_vector.transfer_write(%arg0: memref<?x?xf32>) { 447 %c3 = constant 3 : index 448 %cst = constant dense<3.0> : vector<128 x f32> 449 // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}} 450 vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0 + 1)>} : vector<128xf32>, memref<?x?xf32> 451} 452 453// ----- 454 455func @test_vector.transfer_write(%arg0: memref<?x?x?xf32>) { 456 %c3 = constant 3 : index 457 %cst = constant dense<3.0> : vector<3 x 7 x f32> 458 // expected-error@+1 {{requires a permutation_map that is a permutation (found one dim used more than once)}} 459 vector.transfer_write %cst, %arg0[%c3, %c3, %c3] {permutation_map = affine_map<(d0, d1, d2)->(d0, d0)>} : vector<3x7xf32>, memref<?x?x?xf32> 460} 461 462// ----- 463 464func @test_vector.transfer_write(%arg0: memref<?xf32>, %arg1: vector<7xf32>) { 465 %c3 = constant 3 : index 466 %cst = constant 3.0 : f32 467 // expected-error@+1 {{should not have broadcast dimensions}} 468 vector.transfer_write %arg1, %arg0[%c3] 469 {permutation_map = affine_map<(d0) -> (0)>} 470 : vector<7xf32>, memref<?xf32> 471} 472 473// ----- 474 475func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) { 476 // expected-error@+1 {{expected offsets of same size as destination vector rank}} 477 %1 = vector.insert_strided_slice %a, %b {offsets = [100], strides = [1, 1]} : vector<4x4xf32> into vector<4x8x16xf32> 478} 479 480// ----- 481 482func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) { 483 // expected-error@+1 {{expected strides of same size as source vector rank}} 484 %1 = vector.insert_strided_slice %a, %b {offsets = [2, 2, 2], strides = [1]} : vector<4x4xf32> into vector<4x8x16xf32> 485} 486 487// ----- 488 489func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) { 490 // expected-error@+1 {{expected source rank to be smaller than destination rank}} 491 %1 = vector.insert_strided_slice %b, %a {offsets = [2, 2], strides = [1, 1, 1]} : vector<4x8x16xf32> into vector<4x4xf32> 492} 493 494// ----- 495 496func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) { 497 // expected-error@+1 {{op expected offsets dimension 0 to be confined to [0, 4)}} 498 %1 = vector.insert_strided_slice %a, %b {offsets = [100,100,100], strides = [1, 1]} : vector<4x4xf32> into vector<4x8x16xf32> 499} 500 501// ----- 502 503func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) { 504 // expected-error@+1 {{op expected strides to be confined to [1, 2)}} 505 %1 = vector.insert_strided_slice %a, %b {offsets = [2, 2, 2], strides = [100, 100]} : vector<4x4xf32> into vector<4x8x16xf32> 506} 507 508// ----- 509 510func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) { 511 // expected-error@+1 {{op expected sum(offsets, source vector shape) dimension 1 to be confined to [1, 9)}} 512 %1 = vector.insert_strided_slice %a, %b {offsets = [2, 7, 2], strides = [1, 1]} : vector<4x4xf32> into vector<4x8x16xf32> 513} 514 515// ----- 516 517func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 518 // expected-error@+1 {{expected offsets, sizes and strides attributes of same size}} 519 %1 = vector.extract_strided_slice %arg0 {offsets = [100], sizes = [2, 2], strides = [1, 1]} : vector<4x8x16xf32> to vector<2x2x16xf32> 520} 521 522// ----- 523 524func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 525 // expected-error@+1 {{expected offsets attribute of rank smaller than vector rank}} 526 %1 = vector.extract_strided_slice %arg0 {offsets = [2, 2, 2, 2], sizes = [2, 2, 2, 2], strides = [1, 1, 1, 1]} : vector<4x8x16xf32> to vector<2x2x16xf32> 527} 528 529// ----- 530 531func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 532 // expected-error@+1 {{expected offsets attribute of rank smaller than vector rank}} 533 %1 = vector.extract_strided_slice %arg0 {offsets = [2, 2, 2, 2], sizes = [2, 2, 2, 2], strides = [1, 1, 1, 1]} : vector<4x8x16xf32> to vector<2x2x16xf32> 534} 535 536// ----- 537 538func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 539 // expected-error@+1 {{op expected offsets dimension 0 to be confined to [0, 4)}} 540 %1 = vector.extract_strided_slice %arg0 {offsets = [100], sizes = [100], strides = [100]} : vector<4x8x16xf32> to vector<100x8x16xf32> 541} 542 543// ----- 544 545func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 546 // expected-error@+1 {{op expected sizes dimension 0 to be confined to [1, 5)}} 547 %1 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [100], strides = [100]} : vector<4x8x16xf32> to vector<100x8x16xf32> 548} 549 550// ----- 551 552func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 553 // expected-error@+1 {{op expected strides to be confined to [1, 2)}} 554 %1 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [1], strides = [100]} : vector<4x8x16xf32> to vector<1x8x16xf32> 555} 556 557// ----- 558 559func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 560 // expected-error@+1 {{op expected strides to be confined to [1, 2)}} 561 %1 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [1], strides = [100]} : vector<4x8x16xf32> to vector<1x8x16xf32> 562} 563 564// ----- 565 566func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 567 // expected-error@+1 {{op expected sum(offsets, sizes) dimension 0 to be confined to [1, 5)}} 568 %1 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [3], strides = [1]} : vector<4x8x16xf32> to vector<3x8x16xf32> 569} 570 571// ----- 572 573func @extract_strided_slice(%arg0: vector<4x8x16xf32>) { 574 // expected-error@+1 {{op expected result type to be 'vector<2x8x16xf32>'}} 575 %1 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8x16xf32> to vector<3x1xf32> 576} 577 578// ----- 579 580#contraction_accesses = [ 581 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 582 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>, 583 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>, 584 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 585] 586#contraction_trait = { 587 indexing_maps = #contraction_accesses, 588 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 589} 590func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 591 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 592 %arg4 : index) { 593 // expected-error@+1 {{expected an indexing map for each vector operand}} 594 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 595 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 596} 597 598// ----- 599 600#contraction_accesses = [ 601 affine_map<(b0, f0, f1, c0, c1) -> (c0, c0, c1, f0)>, 602 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>, 603 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 604] 605#contraction_trait = { 606 indexing_maps = #contraction_accesses, 607 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 608} 609func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 610 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 611 %arg4 : index) { 612 // expected-error@+1 {{expected indexing map 0 to be a projected permutation of its inputs}} 613 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 614 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 615} 616 617// ----- 618 619#contraction_accesses = [ 620 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 621 affine_map<(b0, f0, f1, c0, c1)[s0] -> (b0, s0, c0, f1)>, 622 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 623] 624#contraction_trait = { 625 indexing_maps = #contraction_accesses, 626 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 627} 628func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 629 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 630 %arg4 : index) { 631 // expected-error@+1 {{op expected indexing map 1 to have no symbols}} 632 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 633 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 634} 635 636// ----- 637 638#contraction_accesses = [ 639 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 640 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>, 641 affine_map<(b0, f0, f1, c1) -> (b0, f0, f1)> 642] 643#contraction_trait = { 644 indexing_maps = #contraction_accesses, 645 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 646} 647func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 648 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 649 %arg4 : index) { 650 // expected-error@+1 {{expected indexing map 2 to have 5 number of inputs}} 651 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 652 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 653} 654 655// ----- 656 657#contraction_accesses = [ 658 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 659 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, f1)>, 660 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 661] 662#contraction_trait = { 663 indexing_maps = #contraction_accesses, 664 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 665} 666func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 667 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 668 %arg4 : index) { 669 // expected-error@+1 {{expected indexing map 1 to have 4 number of outputs}} 670 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 671 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 672} 673 674// ----- 675 676#contraction_accesses = [ 677 affine_map<(b0, f0, f1, b1, b2) -> (b1, b0, b2, f0)>, 678 affine_map<(b0, f0, f1, b1, b2) -> (b0, b2, b1, f1)>, 679 affine_map<(b0, f0, f1, b1, b2) -> (b0, f0, f1)> 680] 681#contraction_trait = { 682 indexing_maps = #contraction_accesses, 683 iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"] 684} 685func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 686 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 687 %arg4 : index) { 688 // expected-error@+1 {{op expected at least one contracting dimension pair}} 689 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 690 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 691} 692 693// ----- 694 695#contraction_accesses = [ 696 affine_map<(b0, f0, f1, c0, c1) -> (c1, b0, c0, f0)>, 697 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>, 698 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 699] 700#contraction_trait = { 701 indexing_maps = #contraction_accesses, 702 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 703} 704func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 705 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 706 %arg4 : index) { 707 // expected-error@+1 {{invalid contracting dimension map}} 708 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 709 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 710} 711 712// ----- 713 714#contraction_accesses = [ 715 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 716 affine_map<(b0, f0, f1, c0, c1) -> (f1, c1, c0, b0)>, 717 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 718] 719#contraction_trait = { 720 indexing_maps = #contraction_accesses, 721 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 722} 723func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 724 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 725 %arg4 : index) { 726 // expected-error@+1 {{invalid batch dimension map}} 727 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 728 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 729} 730 731// ----- 732 733#contraction_accesses = [ 734 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 735 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>, 736 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 737] 738#contraction_trait = { 739 indexing_maps = #contraction_accesses, 740 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 741} 742func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 743 %arg2: vector<88x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 744 %arg4 : index) { 745 // expected-error@+1 {{invalid accumulator/result vector shape}} 746 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 747 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<88x15x5xf32> 748} 749 750// ----- 751 752#contraction_accesses = [ 753 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>, 754 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>, 755 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)> 756] 757#contraction_trait = { 758 indexing_maps = #contraction_accesses, 759 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"] 760} 761func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>, 762 %arg2: vector<8x15x5xf32>, %arg3 : vector<8x15x8x5xf32>, 763 %arg4 : index) { 764 %lhs_mask = vector.constant_mask [7, 8, 16, 15] : vector<7x8x16x15xi1> 765 %rhs_mask = vector.constant_mask [8, 16, 7, 5] : vector<8x16x7x5xi1> 766 // expected-error@+1 {{expected zero or exactly 2 vector mask operands}} 767 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2, %lhs_mask 768 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32> 769} 770 771// ----- 772 773#contraction_accesses = [ 774 affine_map<(i, j, k) -> (i, k)>, 775 affine_map<(i, j, k) -> (k, j)>, 776 affine_map<(i, j, k) -> (i, j)> 777 ] 778#contraction_trait = { 779 indexing_maps = #contraction_accesses, 780 iterator_types = ["parallel", "parallel", "reduction"] 781 } 782func @contraction(%arg0: vector<4x3xi32>, 783 %arg1: vector<3x7xf32>, 784 %arg2: vector<4x7xf32>) -> vector<4x7xf32> { 785 // expected-error@+1 {{'vector.contract' op failed to verify that lhs and rhs have same element type}} 786 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 787 : vector<4x3xi32>, vector<3x7xf32> into vector<4x7xf32> 788} 789 790// ----- 791 792#contraction_accesses = [ 793 affine_map<(m, n, k) -> (m, k)>, 794 affine_map<(m, n, k) -> (k, n)>, 795 affine_map<(m, n, k) -> (n, m)> 796] 797#contraction_trait = { 798 indexing_maps = #contraction_accesses, 799 iterator_types = ["parallel", "parallel", "reduction"] 800} 801func @contraction(%arg0: vector<2x1xf32>, %arg1: vector<1x3xf32>, %arg2: vector<2x3xf32>) 802-> vector<3x2xf32> 803{ 804// expected-error@+1 {{invalid accumulator/result vector shape, expected: 'vector<3x2xf32>'}} 805 %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2 806 : vector<2x1xf32>, vector<1x3xf32> into vector<2x3xf32> 807 return %0 : vector<2x3xf32> 808} 809 810// ----- 811 812func @create_mask() { 813 %c2 = constant 2 : index 814 %c3 = constant 3 : index 815 // expected-error@+1 {{must specify an operand for each result vector dimension}} 816 %0 = vector.create_mask %c3, %c2 : vector<4x3x7xi1> 817} 818 819 820// ----- 821 822func @constant_mask() { 823 // expected-error@+1 {{must specify array attr of size equal vector result rank}} 824 %0 = vector.constant_mask [3, 2, 7] : vector<4x3xi1> 825} 826 827// ----- 828 829func @constant_mask_out_of_bounds() { 830 // expected-error@+1 {{array attr of size out of bounds of vector result dimension size}} 831 %0 = vector.constant_mask [-1, 2] : vector<4x3xi1> 832} 833 834// ----- 835 836func @constant_mask_out_of_bounds() { 837 // expected-error@+1 {{array attr of size out of bounds of vector result dimension size}} 838 %0 = vector.constant_mask [3, 4] : vector<4x3xi1> 839} 840 841// ----- 842 843func @constant_mask_with_zero_mask_dim_size() { 844 // expected-error@+1 {{expected all mask dim sizes to be zeros, as a result of conjunction with zero mask dim}} 845 %0 = vector.constant_mask [0, 2] : vector<4x3xi1> 846} 847 848 849// ----- 850 851func @extract_slices_non_unit_strides(%arg0 : vector<4x2xf32>) { 852 // expected-error@+1 {{requires unit strides}} 853 %0 = vector.extract_slices %arg0, [2, 2], [1, 3] 854 : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>> 855} 856 857// ----- 858 859func @extract_slices_tuple_element_wrong_rank(%arg0 : vector<4x2xf32>) { 860 // expected-error@+1 {{requires vector tuple elements of rank 2}} 861 %0 = vector.extract_slices %arg0, [2, 2], [1, 1] 862 : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2x3xf32>> 863} 864 865// ----- 866 867func @extract_slices_sizes_strides_wrong_rank(%arg0 : vector<4x2xf32>) { 868 // expected-error@+1 {{requires sizes and strides of rank}} 869 %0 = vector.extract_slices %arg0, [2, 2], [1, 1, 1] 870 : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>> 871} 872 873// ----- 874 875func @extract_slices_invalid_tuple_element_type(%arg0 : vector<4x2xf32>) { 876 // expected-error@+1 {{invalid tuple element type}} 877 %0 = vector.extract_slices %arg0, [2, 2], [1, 1] 878 : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<4x2xf32>> 879} 880 881// ----- 882 883func @tuple_of_non_vectors(%arg0 : vector<4x2xf32>) { 884 %c0 = constant 0 : index 885 // expected-error@+1 {{must be vector of any type values}} 886 %0 = vector.tuple %arg0, %c0 : vector<4x2xf32>, index 887} 888 889// ----- 890 891func @tuple_get_of_non_vectors(%arg0 : tuple<vector<4x2xf32>, index>) { 892 // expected-error@+1 {{vector of any type values}} 893 %0 = vector.tuple_get %arg0, 0 : tuple<vector<4x2xf32>, index> 894} 895 896// ----- 897 898func @insert_slices_non_unit_strides(%arg0 : tuple<vector<2x2xf32>, vector<2x2xf32>>) { 899 // expected-error@+1 {{requires unit strides}} 900 %0 = vector.insert_slices %arg0, [2, 2], [1, 3] 901 : tuple<vector<2x2xf32>, vector<2x2xf32>> into vector<4x2xf32> 902} 903 904// ----- 905 906func @insert_slices_tuple_element_wrong_rank(%arg0 : tuple<vector<2x2xf32>, vector<2x2x3xf32>>) { 907 // expected-error@+1 {{requires vector tuple elements of rank 2}} 908 %0 = vector.insert_slices %arg0, [2, 2], [1, 1] 909 : tuple<vector<2x2xf32>, vector<2x2x3xf32>> into vector<4x2xf32> 910} 911 912// ----- 913 914func @insert_slices_sizes_strides_wrong_rank(%arg0 : tuple<vector<2x2xf32>, vector<2x2xf32>>) { 915 // expected-error@+1 {{requires sizes and strides of rank}} 916 %0 = vector.insert_slices %arg0, [2, 2], [1, 1, 1] 917 : tuple<vector<2x2xf32>, vector<2x2xf32>> into vector<4x2xf32> 918} 919 920// ----- 921 922func @insert_slices_invalid_tuple_element_type(%arg0 : tuple<vector<2x2xf32>, vector<4x2xf32>>) { 923 // expected-error@+1 {{invalid tuple element type}} 924 %0 = vector.insert_slices %arg0, [2, 2], [1, 1] 925 : tuple<vector<2x2xf32>, vector<4x2xf32>> into vector<4x2xf32> 926} 927 928// ----- 929 930func @print_no_result(%arg0 : f32) -> i32 { 931 // expected-error@+1 {{cannot name an operation with no results}} 932 %0 = vector.print %arg0 : f32 933} 934 935// ----- 936 937func @reshape_bad_input_shape(%arg0 : vector<3x2x4xf32>) { 938 %c2 = constant 2 : index 939 %c3 = constant 3 : index 940 %c6 = constant 6 : index 941 %c9 = constant 9 : index 942 // expected-error@+1 {{invalid input shape for vector type}} 943 %1 = vector.reshape %arg0, [%c3, %c6, %c3], [%c2, %c9], [4] 944 : vector<3x2x4xf32> to vector<2x3x4xf32> 945} 946 947// ----- 948 949func @reshape_bad_output_shape(%arg0 : vector<3x2x4xf32>) { 950 %c2 = constant 2 : index 951 %c3 = constant 3 : index 952 %c6 = constant 6 : index 953 %c9 = constant 9 : index 954 // expected-error@+1 {{invalid output shape for vector type}} 955 %1 = vector.reshape %arg0, [%c3, %c6], [%c2, %c9, %c3], [4] 956 : vector<3x2x4xf32> to vector<2x3x4xf32> 957} 958 959// ----- 960 961func @reshape_bad_input_output_shape_product(%arg0 : vector<3x2x4xf32>) { 962 %c2 = constant 2 : index 963 %c3 = constant 3 : index 964 %c6 = constant 6 : index 965 %c9 = constant 9 : index 966 // expected-error@+1 {{product of input and output shape sizes must match}} 967 %1 = vector.reshape %arg0, [%c3, %c6], [%c2, %c6], [4] 968 : vector<3x2x4xf32> to vector<2x3x4xf32> 969} 970 971// ----- 972 973func @reshape_bad_input_fixed_size(%arg0 : vector<3x2x5xf32>) { 974 %c2 = constant 2 : index 975 %c3 = constant 3 : index 976 %c6 = constant 6 : index 977 %c9 = constant 9 : index 978 // expected-error@+1 {{fixed vector size must match input vector for dim 0}} 979 %1 = vector.reshape %arg0, [%c3, %c6], [%c2, %c9], [4] 980 : vector<3x2x5xf32> to vector<2x3x4xf32> 981} 982 983// ----- 984 985func @reshape_bad_output_fixed_size(%arg0 : vector<3x2x4xf32>) { 986 %c2 = constant 2 : index 987 %c3 = constant 3 : index 988 %c6 = constant 6 : index 989 %c9 = constant 9 : index 990 // expected-error@+1 {{fixed vector size must match output vector for dim 0}} 991 %1 = vector.reshape %arg0, [%c3, %c6], [%c2, %c9], [4] 992 : vector<3x2x4xf32> to vector<2x3x5xf32> 993} 994 995// ----- 996 997func @shape_cast_wrong_element_type(%arg0 : vector<5x1x3x2xf32>) { 998 // expected-error@+1 {{op source/result vectors must have same element type}} 999 %0 = vector.shape_cast %arg0 : vector<5x1x3x2xf32> to vector<15x2xi32> 1000} 1001 1002// ----- 1003 1004func @shape_cast_wrong_element_type_tuple(%arg0 : tuple<vector<5x4x2xf32>, 1005 vector<3x4x2xf32>>) { 1006 // expected-error@+1 {{op source/result vectors must have same element type}} 1007 %0 = vector.shape_cast %arg0 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>> to 1008 tuple<vector<20x2xi32>, vector<12x2xi32>> 1009} 1010 1011// ----- 1012 1013func @shape_cast_wrong_num_elements(%arg0 : vector<5x1x3x2xf32>) { 1014 // expected-error@+1 {{op source/result number of elements must match}} 1015 %0 = vector.shape_cast %arg0 : vector<5x1x3x2xf32> to vector<10x2xf32> 1016} 1017 1018// ----- 1019 1020func @shape_cast_wrong_num_elements_tuple(%arg0 : tuple<vector<5x4x2xf32>, 1021 vector<3x4x2xf32>>) { 1022 // expected-error@+1 {{op source/result number of elements must match}} 1023 %0 = vector.shape_cast %arg0 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>> to 1024 tuple<vector<21x2xf32>, vector<13x2xf32>> 1025} 1026 1027// ----- 1028 1029func @shape_cast_invalid_rank_reduction(%arg0 : vector<5x1x3x2xf32>) { 1030 // expected-error@+1 {{invalid shape cast}} 1031 %0 = vector.shape_cast %arg0 : vector<5x1x3x2xf32> to vector<2x15xf32> 1032} 1033 1034// ----- 1035 1036func @shape_cast_invalid_rank_reduction_tuple(%arg0 1037 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>>) { 1038 // expected-error@+1 {{invalid shape cast}} 1039 %0 = vector.shape_cast %arg0: tuple<vector<5x4x2xf32>, vector<3x4x2xf32>> to 1040 tuple<vector<10x4xf32>, vector<6x4xf32>> 1041} 1042 1043// ----- 1044 1045func @shape_cast_invalid_rank_expansion(%arg0 : vector<15x2xf32>) { 1046 // expected-error@+1 {{invalid shape cast}} 1047 %0 = vector.shape_cast %arg0 : vector<15x2xf32> to vector<5x2x3x1xf32> 1048} 1049 1050// ----- 1051 1052func @shape_cast_invalid_rank_expansion_tuple(%arg0 : tuple<vector<20x2xf32>, 1053 vector<12x2xf32>>) { 1054 // expected-error@+1 {{invalid shape cast}} 1055 %0 = vector.shape_cast %arg0 : tuple<vector<20x2xf32>, vector<12x2xf32>> to 1056 tuple<vector<5x2x4xf32>, vector<4x3x2xf32>> 1057} 1058 1059// ----- 1060 1061func @shape_cast_source_result_different_types( 1062 %arg1 : tuple<vector<20x2xf32>, vector<12x2xf32>>) { 1063 // expected-error@+1 {{source/result must be of same type}} 1064 %1 = vector.shape_cast %arg1 : tuple<vector<20x2xf32>, vector<12x2xf32>> to 1065 vector<5x2x4xf32> 1066} 1067 1068// ----- 1069 1070func @shape_cast_different_tuple_sizes( 1071 %arg1 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>>) { 1072 // expected-error@+1 {{op source/result tuples must be the same size}} 1073 %1 = vector.shape_cast %arg1 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>> to 1074 tuple<vector<20x2xf32>> 1075} 1076 1077// ----- 1078 1079func @bitcast_not_vector(%arg0 : vector<5x1x3x2xf32>) { 1080 // expected-error@+1 {{must be vector of any type values}} 1081 %0 = vector.bitcast %arg0 : vector<5x1x3x2xf32> to f32 1082} 1083 1084// ----- 1085 1086func @bitcast_rank_mismatch(%arg0 : vector<5x1x3x2xf32>) { 1087 // expected-error@+1 {{op failed to verify that all of {source, result} have same rank}} 1088 %0 = vector.bitcast %arg0 : vector<5x1x3x2xf32> to vector<5x3x2xf32> 1089} 1090 1091// ----- 1092 1093func @bitcast_shape_mismatch(%arg0 : vector<5x1x3x2xf32>) { 1094 // expected-error@+1 {{op dimension size mismatch}} 1095 %0 = vector.bitcast %arg0 : vector<5x1x3x2xf32> to vector<5x2x3x2xf32> 1096} 1097 1098// ----- 1099 1100func @bitcast_sizemismatch(%arg0 : vector<5x1x3x2xf32>) { 1101 // expected-error@+1 {{op source/result bitwidth of the minor 1-D vectors must be equal}} 1102 %0 = vector.bitcast %arg0 : vector<5x1x3x2xf32> to vector<5x1x3x3xf16> 1103} 1104 1105// ----- 1106 1107func @reduce_unknown_kind(%arg0: vector<16xf32>) -> f32 { 1108 // expected-error@+1 {{'vector.reduction' op unknown reduction kind: joho}} 1109 %0 = vector.reduction "joho", %arg0 : vector<16xf32> into f32 1110} 1111 1112// ----- 1113 1114func @reduce_elt_type_mismatch(%arg0: vector<16xf32>) -> i32 { 1115 // expected-error@+1 {{'vector.reduction' op failed to verify that source operand and result have same element type}} 1116 %0 = vector.reduction "add", %arg0 : vector<16xf32> into i32 1117} 1118 1119// ----- 1120 1121func @reduce_unsupported_attr(%arg0: vector<16xf32>) -> i32 { 1122 // expected-error@+1 {{attribute 'kind' failed to satisfy constraint: string attribute}} 1123 %0 = vector.reduction 1234, %arg0 : vector<16xf32> into i32 1124} 1125 1126// ----- 1127 1128func @reduce_unsupported_third_argument(%arg0: vector<16xf32>, %arg1: f32) -> f32 { 1129 // expected-error@+1 {{'vector.reduction' unsupported number of operands}} 1130 %0 = vector.reduction "add", %arg0, %arg1, %arg1 : vector<16xf32> into f32 1131} 1132 1133// ----- 1134 1135func @reduce_unsupported_accumulator_kind(%arg0: vector<16xf32>, %arg1: f32) -> f32 { 1136 // expected-error@+1 {{'vector.reduction' op no accumulator for reduction kind: min}} 1137 %0 = vector.reduction "min", %arg0, %arg1 : vector<16xf32> into f32 1138} 1139 1140// ----- 1141 1142func @reduce_unsupported_accumulator_type(%arg0: vector<16xi32>, %arg1: i32) -> i32 { 1143 // expected-error@+1 {{'vector.reduction' op no accumulator for type: 'i32'}} 1144 %0 = vector.reduction "add", %arg0, %arg1 : vector<16xi32> into i32 1145} 1146 1147// ----- 1148 1149func @reduce_unsupported_type(%arg0: vector<16xf32>) -> f32 { 1150 // expected-error@+1 {{'vector.reduction' op unsupported reduction type}} 1151 %0 = vector.reduction "xor", %arg0 : vector<16xf32> into f32 1152} 1153 1154// ----- 1155 1156func @reduce_unsupported_rank(%arg0: vector<4x16xf32>) -> f32 { 1157 // expected-error@+1 {{'vector.reduction' op unsupported reduction rank: 2}} 1158 %0 = vector.reduction "add", %arg0 : vector<4x16xf32> into f32 1159} 1160 1161// ----- 1162 1163func @transpose_rank_mismatch(%arg0: vector<4x16x11xf32>) { 1164 // expected-error@+1 {{'vector.transpose' op vector result rank mismatch: 1}} 1165 %0 = vector.transpose %arg0, [2, 1, 0] : vector<4x16x11xf32> to vector<100xf32> 1166} 1167 1168// ----- 1169 1170func @transpose_length_mismatch(%arg0: vector<4x4xf32>) { 1171 // expected-error@+1 {{'vector.transpose' op transposition length mismatch: 3}} 1172 %0 = vector.transpose %arg0, [2, 0, 1] : vector<4x4xf32> to vector<4x4xf32> 1173} 1174 1175// ----- 1176 1177func @transpose_index_oob(%arg0: vector<4x4xf32>) { 1178 // expected-error@+1 {{'vector.transpose' op transposition index out of range: 2}} 1179 %0 = vector.transpose %arg0, [2, 0] : vector<4x4xf32> to vector<4x4xf32> 1180} 1181 1182// ----- 1183 1184func @transpose_index_dup(%arg0: vector<4x4xf32>) { 1185 // expected-error@+1 {{'vector.transpose' op duplicate position index: 0}} 1186 %0 = vector.transpose %arg0, [0, 0] : vector<4x4xf32> to vector<4x4xf32> 1187} 1188 1189// ----- 1190 1191func @transpose_dim_size_mismatch(%arg0: vector<11x7x3x2xi32>) { 1192 // expected-error@+1 {{'vector.transpose' op dimension size mismatch at: 0}} 1193 %0 = vector.transpose %arg0, [3, 0, 1, 2] : vector<11x7x3x2xi32> to vector<2x3x7x11xi32> 1194} 1195 1196// ----- 1197 1198func @flat_transpose_type_mismatch(%arg0: vector<16xf32>) { 1199 // expected-error@+1 {{'vector.flat_transpose' op failed to verify that source operand and result have same element type}} 1200 %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 } : vector<16xf32> -> vector<16xf64> 1201} 1202 1203// ----- 1204 1205func @type_cast_layout(%arg0: memref<4x3xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + s2)>>) { 1206 // expected-error@+1 {{expects operand to be a memref with no layout}} 1207 %0 = vector.type_cast %arg0: memref<4x3xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + s2)>> to memref<vector<4x3xf32>> 1208} 1209 1210// ----- 1211 1212func @store_unsupported_layout(%memref : memref<200x100xf32, affine_map<(d0, d1) -> (d1, d0)>>, 1213 %i : index, %j : index, %value : vector<8xf32>) { 1214 // expected-error@+1 {{'vector.store' op base memref should have a default identity layout}} 1215 vector.store %value, %memref[%i, %j] : memref<200x100xf32, affine_map<(d0, d1) -> (d1, d0)>>, 1216 vector<8xf32> 1217} 1218 1219// ----- 1220 1221func @vector_memref_mismatch(%memref : memref<200x100xvector<4xf32>>, %i : index, 1222 %j : index, %value : vector<8xf32>) { 1223 // expected-error@+1 {{'vector.store' op base memref and valueToStore vector types should match}} 1224 vector.store %value, %memref[%i, %j] : memref<200x100xvector<4xf32>>, vector<8xf32> 1225} 1226 1227// ----- 1228 1229func @store_base_type_mismatch(%base : memref<?xf64>, %value : vector<16xf32>) { 1230 %c0 = constant 0 : index 1231 // expected-error@+1 {{'vector.store' op base and valueToStore element type should match}} 1232 vector.store %value, %base[%c0] : memref<?xf64>, vector<16xf32> 1233} 1234 1235// ----- 1236 1237func @store_memref_index_mismatch(%base : memref<?xf32>, %value : vector<16xf32>) { 1238 // expected-error@+1 {{'vector.store' op requires 1 indices}} 1239 vector.store %value, %base[] : memref<?xf32>, vector<16xf32> 1240} 1241 1242// ----- 1243 1244func @maskedload_base_type_mismatch(%base: memref<?xf64>, %mask: vector<16xi1>, %pass: vector<16xf32>) { 1245 %c0 = constant 0 : index 1246 // expected-error@+1 {{'vector.maskedload' op base and result element type should match}} 1247 %0 = vector.maskedload %base[%c0], %mask, %pass : memref<?xf64>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1248} 1249 1250// ----- 1251 1252func @maskedload_dim_mask_mismatch(%base: memref<?xf32>, %mask: vector<15xi1>, %pass: vector<16xf32>) { 1253 %c0 = constant 0 : index 1254 // expected-error@+1 {{'vector.maskedload' op expected result dim to match mask dim}} 1255 %0 = vector.maskedload %base[%c0], %mask, %pass : memref<?xf32>, vector<15xi1>, vector<16xf32> into vector<16xf32> 1256} 1257 1258// ----- 1259 1260func @maskedload_pass_thru_type_mask_mismatch(%base: memref<?xf32>, %mask: vector<16xi1>, %pass: vector<16xi32>) { 1261 %c0 = constant 0 : index 1262 // expected-error@+1 {{'vector.maskedload' op expected pass_thru of same type as result type}} 1263 %0 = vector.maskedload %base[%c0], %mask, %pass : memref<?xf32>, vector<16xi1>, vector<16xi32> into vector<16xf32> 1264} 1265 1266// ----- 1267 1268func @maskedload_memref_mismatch(%base: memref<?xf32>, %mask: vector<16xi1>, %pass: vector<16xf32>) { 1269 // expected-error@+1 {{'vector.maskedload' op requires 1 indices}} 1270 %0 = vector.maskedload %base[], %mask, %pass : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1271} 1272 1273// ----- 1274 1275func @maskedstore_base_type_mismatch(%base: memref<?xf64>, %mask: vector<16xi1>, %value: vector<16xf32>) { 1276 %c0 = constant 0 : index 1277 // expected-error@+1 {{'vector.maskedstore' op base and valueToStore element type should match}} 1278 vector.maskedstore %base[%c0], %mask, %value : memref<?xf64>, vector<16xi1>, vector<16xf32> 1279} 1280 1281// ----- 1282 1283func @maskedstore_dim_mask_mismatch(%base: memref<?xf32>, %mask: vector<15xi1>, %value: vector<16xf32>) { 1284 %c0 = constant 0 : index 1285 // expected-error@+1 {{'vector.maskedstore' op expected valueToStore dim to match mask dim}} 1286 vector.maskedstore %base[%c0], %mask, %value : memref<?xf32>, vector<15xi1>, vector<16xf32> 1287} 1288 1289// ----- 1290 1291func @maskedstore_memref_mismatch(%base: memref<?xf32>, %mask: vector<16xi1>, %value: vector<16xf32>) { 1292 %c0 = constant 0 : index 1293 // expected-error@+1 {{'vector.maskedstore' op requires 1 indices}} 1294 vector.maskedstore %base[%c0, %c0], %mask, %value : memref<?xf32>, vector<16xi1>, vector<16xf32> 1295} 1296 1297// ----- 1298 1299func @gather_base_type_mismatch(%base: memref<?xf64>, %indices: vector<16xi32>, 1300 %mask: vector<16xi1>, %pass_thru: vector<16xf32>) { 1301 %c0 = constant 0 : index 1302 // expected-error@+1 {{'vector.gather' op base and result element type should match}} 1303 %0 = vector.gather %base[%c0][%indices], %mask, %pass_thru 1304 : memref<?xf64>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1305} 1306 1307// ----- 1308 1309func @gather_memref_mismatch(%base: memref<?x?xf64>, %indices: vector<16xi32>, 1310 %mask: vector<16xi1>, %pass_thru: vector<16xf64>) { 1311 %c0 = constant 0 : index 1312 // expected-error@+1 {{'vector.gather' op requires 2 indices}} 1313 %0 = vector.gather %base[%c0][%indices], %mask, %pass_thru 1314 : memref<?x?xf64>, vector<16xi32>, vector<16xi1>, vector<16xf64> into vector<16xf64> 1315} 1316 1317// ----- 1318 1319func @gather_rank_mismatch(%base: memref<?xf32>, %indices: vector<16xi32>, 1320 %mask: vector<16xi1>, %pass_thru: vector<16xf32>) { 1321 %c0 = constant 0 : index 1322 // expected-error@+1 {{'vector.gather' op result #0 must be of ranks 1, but got 'vector<2x16xf32>'}} 1323 %0 = vector.gather %base[%c0][%indices], %mask, %pass_thru 1324 : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<2x16xf32> 1325} 1326 1327// ----- 1328 1329func @gather_dim_indices_mismatch(%base: memref<?xf32>, %indices: vector<17xi32>, 1330 %mask: vector<16xi1>, %pass_thru: vector<16xf32>) { 1331 %c0 = constant 0 : index 1332 // expected-error@+1 {{'vector.gather' op expected result dim to match indices dim}} 1333 %0 = vector.gather %base[%c0][%indices], %mask, %pass_thru 1334 : memref<?xf32>, vector<17xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1335} 1336 1337// ----- 1338 1339func @gather_dim_mask_mismatch(%base: memref<?xf32>, %indices: vector<16xi32>, 1340 %mask: vector<17xi1>, %pass_thru: vector<16xf32>) { 1341 %c0 = constant 0 : index 1342 // expected-error@+1 {{'vector.gather' op expected result dim to match mask dim}} 1343 %0 = vector.gather %base[%c0][%indices], %mask, %pass_thru 1344 : memref<?xf32>, vector<16xi32>, vector<17xi1>, vector<16xf32> into vector<16xf32> 1345} 1346 1347// ----- 1348 1349func @gather_pass_thru_type_mismatch(%base: memref<?xf32>, %indices: vector<16xi32>, 1350 %mask: vector<16xi1>, %pass_thru: vector<16xf64>) { 1351 %c0 = constant 0 : index 1352 // expected-error@+1 {{'vector.gather' op expected pass_thru of same type as result type}} 1353 %0 = vector.gather %base[%c0][%indices], %mask, %pass_thru 1354 : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf64> into vector<16xf32> 1355} 1356 1357// ----- 1358 1359func @scatter_base_type_mismatch(%base: memref<?xf64>, %indices: vector<16xi32>, 1360 %mask: vector<16xi1>, %value: vector<16xf32>) { 1361 %c0 = constant 0 : index 1362 // expected-error@+1 {{'vector.scatter' op base and valueToStore element type should match}} 1363 vector.scatter %base[%c0][%indices], %mask, %value 1364 : memref<?xf64>, vector<16xi32>, vector<16xi1>, vector<16xf32> 1365} 1366 1367// ----- 1368 1369func @scatter_memref_mismatch(%base: memref<?x?xf64>, %indices: vector<16xi32>, 1370 %mask: vector<16xi1>, %value: vector<16xf64>) { 1371 %c0 = constant 0 : index 1372 // expected-error@+1 {{'vector.scatter' op requires 2 indices}} 1373 vector.scatter %base[%c0][%indices], %mask, %value 1374 : memref<?x?xf64>, vector<16xi32>, vector<16xi1>, vector<16xf64> 1375} 1376 1377// ----- 1378 1379func @scatter_rank_mismatch(%base: memref<?xf32>, %indices: vector<16xi32>, 1380 %mask: vector<16xi1>, %value: vector<2x16xf32>) { 1381 %c0 = constant 0 : index 1382 // expected-error@+1 {{'vector.scatter' op operand #4 must be of ranks 1, but got 'vector<2x16xf32>'}} 1383 vector.scatter %base[%c0][%indices], %mask, %value 1384 : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<2x16xf32> 1385} 1386 1387// ----- 1388 1389func @scatter_dim_indices_mismatch(%base: memref<?xf32>, %indices: vector<17xi32>, 1390 %mask: vector<16xi1>, %value: vector<16xf32>) { 1391 %c0 = constant 0 : index 1392 // expected-error@+1 {{'vector.scatter' op expected valueToStore dim to match indices dim}} 1393 vector.scatter %base[%c0][%indices], %mask, %value 1394 : memref<?xf32>, vector<17xi32>, vector<16xi1>, vector<16xf32> 1395} 1396 1397// ----- 1398 1399func @scatter_dim_mask_mismatch(%base: memref<?xf32>, %indices: vector<16xi32>, 1400 %mask: vector<17xi1>, %value: vector<16xf32>) { 1401 %c0 = constant 0 : index 1402 // expected-error@+1 {{'vector.scatter' op expected valueToStore dim to match mask dim}} 1403 vector.scatter %base[%c0][%indices], %mask, %value 1404 : memref<?xf32>, vector<16xi32>, vector<17xi1>, vector<16xf32> 1405} 1406 1407// ----- 1408 1409func @expand_base_type_mismatch(%base: memref<?xf64>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) { 1410 %c0 = constant 0 : index 1411 // expected-error@+1 {{'vector.expandload' op base and result element type should match}} 1412 %0 = vector.expandload %base[%c0], %mask, %pass_thru : memref<?xf64>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1413} 1414 1415// ----- 1416 1417func @expand_dim_mask_mismatch(%base: memref<?xf32>, %mask: vector<17xi1>, %pass_thru: vector<16xf32>) { 1418 %c0 = constant 0 : index 1419 // expected-error@+1 {{'vector.expandload' op expected result dim to match mask dim}} 1420 %0 = vector.expandload %base[%c0], %mask, %pass_thru : memref<?xf32>, vector<17xi1>, vector<16xf32> into vector<16xf32> 1421} 1422 1423// ----- 1424 1425func @expand_pass_thru_mismatch(%base: memref<?xf32>, %mask: vector<16xi1>, %pass_thru: vector<17xf32>) { 1426 %c0 = constant 0 : index 1427 // expected-error@+1 {{'vector.expandload' op expected pass_thru of same type as result type}} 1428 %0 = vector.expandload %base[%c0], %mask, %pass_thru : memref<?xf32>, vector<16xi1>, vector<17xf32> into vector<16xf32> 1429} 1430 1431// ----- 1432 1433func @expand_memref_mismatch(%base: memref<?x?xf32>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) { 1434 %c0 = constant 0 : index 1435 // expected-error@+1 {{'vector.expandload' op requires 2 indices}} 1436 %0 = vector.expandload %base[%c0], %mask, %pass_thru : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1437} 1438 1439// ----- 1440 1441func @compress_base_type_mismatch(%base: memref<?xf64>, %mask: vector<16xi1>, %value: vector<16xf32>) { 1442 %c0 = constant 0 : index 1443 // expected-error@+1 {{'vector.compressstore' op base and valueToStore element type should match}} 1444 vector.compressstore %base[%c0], %mask, %value : memref<?xf64>, vector<16xi1>, vector<16xf32> 1445} 1446 1447// ----- 1448 1449func @compress_dim_mask_mismatch(%base: memref<?xf32>, %mask: vector<17xi1>, %value: vector<16xf32>) { 1450 %c0 = constant 0 : index 1451 // expected-error@+1 {{'vector.compressstore' op expected valueToStore dim to match mask dim}} 1452 vector.compressstore %base[%c0], %mask, %value : memref<?xf32>, vector<17xi1>, vector<16xf32> 1453} 1454 1455// ----- 1456 1457func @compress_memref_mismatch(%base: memref<?x?xf32>, %mask: vector<16xi1>, %value: vector<16xf32>) { 1458 %c0 = constant 0 : index 1459 // expected-error@+1 {{'vector.compressstore' op requires 2 indices}} 1460 vector.compressstore %base[%c0, %c0, %c0], %mask, %value : memref<?x?xf32>, vector<16xi1>, vector<16xf32> 1461} 1462 1463// ----- 1464 1465func @extract_map_rank(%v: vector<32xf32>, %id : index) { 1466 // expected-error@+1 {{'vector.extract_map' op expected source and destination vectors of same rank}} 1467 %0 = vector.extract_map %v[%id] : vector<32xf32> to vector<2x1xf32> 1468} 1469 1470// ----- 1471 1472func @extract_map_size(%v: vector<63xf32>, %id : index) { 1473 // expected-error@+1 {{'vector.extract_map' op source vector dimensions must be a multiple of destination vector dimensions}} 1474 %0 = vector.extract_map %v[%id] : vector<63xf32> to vector<2xf32> 1475} 1476 1477// ----- 1478 1479func @extract_map_id(%v: vector<2x32xf32>, %id : index) { 1480 // expected-error@+1 {{'vector.extract_map' op expected number of ids must match the number of dimensions distributed}} 1481 %0 = vector.extract_map %v[%id] : vector<2x32xf32> to vector<1x1xf32> 1482} 1483 1484// ----- 1485 1486func @insert_map_rank(%v: vector<2x1xf32>, %v1: vector<32xf32>, %id : index) { 1487 // expected-error@+1 {{'vector.insert_map' op expected source and destination vectors of same rank}} 1488 %0 = vector.insert_map %v, %v1[%id] : vector<2x1xf32> into vector<32xf32> 1489} 1490 1491// ----- 1492 1493func @insert_map_size(%v: vector<3xf32>, %v1: vector<64xf32>, %id : index) { 1494 // expected-error@+1 {{'vector.insert_map' op destination vector size must be a multiple of source vector size}} 1495 %0 = vector.insert_map %v, %v1[%id] : vector<3xf32> into vector<64xf32> 1496} 1497 1498// ----- 1499 1500func @insert_map_id(%v: vector<2x1xf32>, %v1: vector<4x32xf32>, %id : index) { 1501 // expected-error@+1 {{'vector.insert_map' op expected number of ids must match the number of dimensions distributed}} 1502 %0 = vector.insert_map %v, %v1[%id] : vector<2x1xf32> into vector<4x32xf32> 1503} 1504