1// RUN: mlir-opt %s -split-input-file -verify-diagnostics 2 3//===----------------------------------------------------------------------===// 4// arm_sme.get_tile 5//===----------------------------------------------------------------------===// 6 7// ----- 8 9func.func @arm_sme_get_tile__bad_vector_type_rank_1() -> vector<[16]xi8> { 10 // expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[16]xi8>'}} 11 %0 = arm_sme.get_tile : vector<[16]xi8> 12 return %0 : vector<[16]xi8> 13} 14 15// ----- 16 17func.func @arm_sme_get_tile__bad_vector_type_i4() -> vector<[16]x[16]xi4> { 18 // expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[16]x[16]xi4>'}} 19 %0 = arm_sme.get_tile : vector<[16]x[16]xi4> 20 return %0 : vector<[16]x[16]xi4> 21} 22 23// ----- 24 25func.func @arm_sme_get_tile__bad_vector_type_non_scalable_dim_0() -> vector<16x[16]xi8> { 26 // expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<16x[16]xi8>'}} 27 %0 = arm_sme.get_tile : vector<16x[16]xi8> 28 return %0 : vector<16x[16]xi8> 29} 30 31// ----- 32 33func.func @arm_sme_get_tile__bad_vector_type_non_scalable_dim_1() -> vector<[16]x16xi8> { 34 // expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[16]x16xi8>'}} 35 %0 = arm_sme.get_tile : vector<[16]x16xi8> 36 return %0 : vector<[16]x16xi8> 37} 38 39// ----- 40 41func.func @arm_sme_get_tile__bad_shape(%tile_id : i8) -> vector<[4]x[16]xi8> { 42 // expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[4]x[16]xi8>'}} 43 %0 = arm_sme.get_tile : vector<[4]x[16]xi8> 44 return %0 : vector<[4]x[16]xi8> 45} 46 47//===----------------------------------------------------------------------===// 48// arm_sme.insert_tile_slice 49//===----------------------------------------------------------------------===// 50 51// ----- 52 53func.func @arm_sme_insert_tile_slice_i8__bad_vector_type(%vector : vector<[8]xi8>, %tile : vector<[16]x[16]xi8>, %tile_slice_index : index) -> vector<[16]x[16]xi8> { 54 %c0 = arith.constant 0 : index 55 // expected-error@+1 {{op failed to verify that type of 'vector' matches type of 'tile' slice}} 56 %0 = arm_sme.insert_tile_slice %vector, %tile[%tile_slice_index] : vector<[8]xi8> into vector<[16]x[16]xi8> 57 return %0 : vector<[16]x[16]xi8> 58} 59 60// ----- 61 62func.func @arm_sme_insert_tile_slice_f32__bad_vector_type(%vector : vector<[8]xf32>, %tile : vector<[4]x[4]xf32>, %tile_slice_index : index) -> vector<[4]x[4]xf32> { 63 %c0 = arith.constant 0 : index 64 // expected-error@+1 {{op failed to verify that type of 'vector' matches type of 'tile' slice}} 65 %0 = arm_sme.insert_tile_slice %vector, %tile[%tile_slice_index] : vector<[8]xf32> into vector<[4]x[4]xf32> 66 return %0 : vector<[4]x[4]xf32> 67} 68 69//===----------------------------------------------------------------------===// 70// arm_sme.extract_tile_slice 71//===----------------------------------------------------------------------===// 72 73// ----- 74 75func.func @arm_sme_extract_tile_slice__bad_result_type(%tile : vector<[4]x[4]xf32>, %tile_slice_index : index) -> vector<[2]xf64> { 76 // expected-error@+1 {{op failed to verify that type of 'result' matches type of 'tile' slice}} 77 %0 = arm_sme.extract_tile_slice %tile[%tile_slice_index] : vector<[2]xf64> from vector<[4]x[4]xf32> 78 return %0 : vector<[2]xf64> 79} 80 81//===----------------------------------------------------------------------===// 82// arm_sme.tile_load 83//===----------------------------------------------------------------------===// 84 85// ----- 86 87func.func @arm_sme_tile_load__bad_padding_type(%src : memref<?x?xf64>, %pad : f32, %mask : vector<[2]x[2]xi1>) { 88 %c0 = arith.constant 0 : index 89 // expected-note@-2 {{prior use here}} 90 // expected-error@+1 {{use of value '%pad' expects different type than prior uses: 'f64' vs 'f32'}} 91 %tile = arm_sme.tile_load %src[%c0, %c0], %pad, %mask : memref<?x?xf64>, vector<[2]x[2]xf64> 92 return 93} 94 95// ----- 96 97func.func @arm_sme_tile_load__bad_mask_type(%src : memref<?x?xf64>, %pad : f64, %mask : vector<[4]x[4]xi1>) { 98 %c0 = arith.constant 0 : index 99 // expected-note@-2 {{prior use here}} 100 // expected-error@+1 {{use of value '%mask' expects different type than prior uses: 'vector<[2]x[2]xi1>' vs 'vector<[4]x[4]xi1>}} 101 %tile = arm_sme.tile_load %src[%c0, %c0], %pad, %mask : memref<?x?xf64>, vector<[2]x[2]xf64> 102 return 103} 104 105// ----- 106 107func.func @arm_sme_tile_load__pad_but_no_mask(%src : memref<?x?xf64>, %pad : f64) { 108 %c0 = arith.constant 0 : index 109 // expected-error@+1 {{op failed to verify that both `padding` and `mask` should be provided or neither}} 110 %tile = arm_sme.tile_load %src[%c0, %c0], %pad, : memref<?x?xf64>, vector<[2]x[2]xf64> 111 return 112} 113 114//===----------------------------------------------------------------------===// 115// arm_sme.load_tile_slice 116//===----------------------------------------------------------------------===// 117 118// ----- 119 120func.func @arm_sme_load_tile_slice__bad_mask_type(%src : memref<?x?xi8>, %mask : vector<[2]xi1>, %tile : vector<[16]x[16]xi8>, %tile_slice_index : index) { 121 %c0 = arith.constant 0 : index 122 // expected-error@+1 {{op failed to verify that `mask` has i1 element type and the shape is a slice of `result`}} 123 %tile_update = arm_sme.load_tile_slice %src[%c0], %mask, %tile, %tile_slice_index : memref<?x?xi8>, vector<[2]xi1>, vector<[16]x[16]xi8> 124 return 125} 126 127//===----------------------------------------------------------------------===// 128// arm_sme.tile_store 129//===----------------------------------------------------------------------===// 130 131// ----- 132 133func.func @arm_sme_tile_store__bad_mask_type(%tile : vector<[16]x[16]xi8>, %mask : vector<[1]x[1]xi1>, %dest : memref<?x?xi8>) { 134 %c0 = arith.constant 0 : index 135 // expected-note@-2 {{prior use here}} 136 // expected-error@+1 {{use of value '%mask' expects different type than prior uses: 'vector<[16]x[16]xi1>' vs 'vector<[1]x[1]xi1>}} 137 arm_sme.tile_store %tile, %dest[%c0, %c0], %mask : memref<?x?xi8>, vector<[16]x[16]xi8> 138 return 139} 140 141//===----------------------------------------------------------------------===// 142// arm_sme.store_tile_slice 143//===----------------------------------------------------------------------===// 144 145 146// ----- 147 148func.func @arm_sme_store_tile_slice__bad_mask_type(%tile : vector<[16]x[16]xi8>, %tile_slice_index : index, %mask : vector<[8]xi1>, %dest : memref<?x?xi8>) -> () { 149 %c0 = arith.constant 0 : index 150 // expected-error@+1 {{op failed to verify that `mask` has i1 element type and the shape is a slice of `tile`}} 151 arm_sme.store_tile_slice %tile, %tile_slice_index, %mask, %dest[%c0] : memref<?x?xi8>, vector<[8]xi1>, vector<[16]x[16]xi8> 152 return 153} 154 155//===----------------------------------------------------------------------===// 156// arm_sme.outerproduct 157//===----------------------------------------------------------------------===// 158 159// ----- 160 161func.func @arm_sme_outerproduct__bad_result_type(%vecA: vector<[2]xi16>, %vecB: vector<[2]xi16>) -> vector<[2]x[2]xi16> 162{ 163 // expected-error@+1 {{op result #0 must be a vector type that fits into a SME tile, but got 'vector<[2]x[2]xi16>'}} 164 %0 = arm_sme.outerproduct %vecA, %vecB : vector<[2]xi16>, vector<[2]xi16> 165 return %0 : vector<[2]x[2]xi16> 166} 167 168// ----- 169 170func.func @arm_sme_outerproduct__bad_vector_type(%vecA: vector<[4]xf32>, %vecB: vector<[8]xf32>) -> vector<[4]x[4]xf32> 171{ 172 // expected-error@+1 {{op failed to verify that all of {lhs, rhs} have same type}} 173 %0 = arm_sme.outerproduct %vecA, %vecB : vector<[4]xf32>, vector<[8]xf32> 174 return %0 : vector<[4]x[4]xf32> 175} 176 177//===----------------------------------------------------------------------===// 178// arm_sme.fmopa_2way 179//===----------------------------------------------------------------------===// 180 181// ----- 182 183func.func @arm_sme_fmopa_2way__bad_rhs_vector_type(%vecA: vector<[8]xf16>, %vecB: vector<[4]xf32>) -> vector<[4]x[4]xf32> 184{ 185 // expected-error@+1 {{op failed to verify that all of {lhs, rhs} have same type}} 186 %0 = arm_sme.fmopa_2way %vecA, %vecB : vector<[8]xf16>, vector<[4]xf32> into vector<[4]x[4]xf32> 187 return %0 : vector<[4]x[4]xf32> 188} 189 190// ----- 191 192func.func @arm_sme_fmopa_2way__bad_lhs_mask_type(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>, %maskA : vector<[4]xi1>, %maskB : vector<[8]xi1>) -> vector<[4]x[4]xf32> 193{ 194 // expected-note@-2 {{prior use here}} 195 // expected-error@+1 {{use of value '%maskA' expects different type than prior uses: 'vector<[8]xi1>' vs 'vector<[4]xi1>}} 196 %0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA, %maskB) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32> 197 return %0 : vector<[4]x[4]xf32> 198} 199 200// ----- 201 202func.func @arm_sme_fmopa_2way__bad_rhs_mask_type(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>, %maskA : vector<[8]xi1>, %maskB : vector<[4]xi1>) -> vector<[4]x[4]xf32> 203{ 204 // expected-note@-2 {{prior use here}} 205 // expected-error@+1 {{use of value '%maskB' expects different type than prior uses: 'vector<[8]xi1>' vs 'vector<[4]xi1>}} 206 %0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA, %maskB) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32> 207 return %0 : vector<[4]x[4]xf32> 208} 209 210// ----- 211 212func.func @arm_sme_fmopa_2way__no_rhs_mask(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>, %maskA : vector<[8]xi1>) -> vector<[4]x[4]xf32> 213{ 214 // expected-error@+1 {{op failed to verify that both `lhsMask` and `rhsMask` should be provided or neither}} 215 %0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA,) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32> 216 return %0 : vector<[4]x[4]xf32> 217} 218 219// ----- 220 221func.func @arm_sme_fmopa_2way__bad_acc_type(%vecA: vector<[8]xf16>, %vecB: vector<[8]xf16>) -> vector<[4]x[4]xf32> 222{ 223 %acc = arm_sme.zero : vector<[2]x[2]xi64> 224 // expected-note@-1 {{prior use here}} 225 // expected-error@+1 {{use of value '%acc' expects different type than prior uses: 'vector<[4]x[4]xf32>' vs 'vector<[2]x[2]xi64>'}} 226 %0 = arm_sme.fmopa_2way %vecA, %vecB masks(%maskA, %maskB) acc(%acc) : vector<[8]xf16>, vector<[8]xf16> into vector<[4]x[4]xf32> 227 return %0 : vector<[4]x[4]xf32> 228} 229 230//===----------------------------------------------------------------------===// 231// arm_sme.smopa_4way 232//===----------------------------------------------------------------------===// 233 234// ----- 235 236func.func @arm_sme_smopa_4way__bad_tile_type(%vecA: vector<[8]xi16>, %vecB: vector<[8]xi16>) -> vector<[4]x[4]xi32> 237{ 238 // expected-error@+1 {{op failed to verify that tile element size equals input element size * 4}} 239 %0 = arm_sme.smopa_4way %vecA, %vecB : vector<[8]xi16>, vector<[8]xi16> into vector<[4]x[4]xi32> 240 return %0 : vector<[4]x[4]xi32> 241} 242