1177 lines · plain
1// RUN: mlir-opt %s | mlir-opt | FileCheck %s2 3// CHECK-LABEL: func @vector_transfer_ops_0d(4func.func @vector_transfer_ops_0d(%arg0: tensor<f32>, %arg1: memref<f32>)5 -> tensor<f32> {6 %f0 = arith.constant 0.0 : f327 %0 = vector.transfer_read %arg0[], %f0 {permutation_map = affine_map<()->()>} :8 tensor<f32>, vector<f32>9 %1 = vector.transfer_write %0, %arg0[] {permutation_map = affine_map<()->()>} :10 vector<f32>, tensor<f32>11 %2 = vector.transfer_read %arg1[], %f0 {permutation_map = affine_map<()->()>} :12 memref<f32>, vector<f32>13 vector.transfer_write %2, %arg1[] {permutation_map = affine_map<()->()>} :14 vector<f32>, memref<f32>15 return %1: tensor<f32>16}17 18// CHECK-LABEL: func @vector_transfer_ops_0d_from_higher_d(19func.func @vector_transfer_ops_0d_from_higher_d(%arg0: tensor<?xf32>, %arg1: memref<?x?xf32>)20 -> tensor<?xf32> {21 %c0 = arith.constant 0 : index22 %f0 = arith.constant 0.0 : f3223 %0 = vector.transfer_read %arg0[%c0], %f0 {permutation_map = affine_map<(d0)->()>} :24 tensor<?xf32>, vector<f32>25 %1 = vector.transfer_write %0, %arg0[%c0] {permutation_map = affine_map<(d0)->()>} :26 vector<f32>, tensor<?xf32>27 %2 = vector.transfer_read %arg1[%c0, %c0], %f0 {permutation_map = affine_map<(d0, d1)->()>} :28 memref<?x?xf32>, vector<f32>29 vector.transfer_write %2, %arg1[%c0, %c0] {permutation_map = affine_map<(d0, d1)->()>} :30 vector<f32>, memref<?x?xf32>31 return %1: tensor<?xf32>32}33 34// CHECK-LABEL: func @vector_transfer_ops(35func.func @vector_transfer_ops(%arg0: memref<?x?xf32>,36 %arg1 : memref<?x?xvector<4x3xf32>>,37 %arg2 : memref<?x?xvector<4x3xi32>>,38 %arg3 : memref<?x?xvector<4x3xindex>>,39 %arg4 : memref<?x?x?xf32>) {40 // CHECK: %[[C3:.*]] = arith.constant 3 : index41 %c3 = arith.constant 3 : index42 %cst = arith.constant 3.0 : f3243 %f0 = arith.constant 0.0 : f3244 %c0 = arith.constant 0 : i3245 %i0 = arith.constant 0 : index46 %i1 = arith.constant 1 : i147 48 %vf0 = vector.broadcast %f0 : f32 to vector<4x3xf32>49 %v0 = vector.broadcast %c0 : i32 to vector<4x3xi32>50 %vi0 = vector.broadcast %i0 : index to vector<4x3xindex>51 %m = arith.constant dense<[0, 0, 1, 0, 1]> : vector<5xi1>52 %m2 = vector.broadcast %i1 : i1 to vector<4x5xi1>53 //54 // CHECK: vector.transfer_read55 %0 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d0)>} : memref<?x?xf32>, vector<128xf32>56 // CHECK: vector.transfer_read57 %1 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : memref<?x?xf32>, vector<3x7xf32>58 // CHECK: vector.transfer_read59 %2 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0)>} : memref<?x?xf32>, vector<128xf32>60 // CHECK: vector.transfer_read61 %3 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d1)>} : memref<?x?xf32>, vector<128xf32>62 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>63 %4 = vector.transfer_read %arg1[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>64 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} {in_bounds = [false, true]} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>65 %5 = vector.transfer_read %arg1[%c3, %c3], %vf0 {in_bounds = [false, true]} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>66 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : memref<?x?xvector<4x3xi32>>, vector<5x24xi8>67 %6 = vector.transfer_read %arg2[%c3, %c3], %v0 : memref<?x?xvector<4x3xi32>>, vector<5x24xi8>68 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : memref<?x?xvector<4x3xindex>>, vector<5x48xi8>69 %7 = vector.transfer_read %arg3[%c3, %c3], %vi0 : memref<?x?xvector<4x3xindex>>, vector<5x48xi8>70 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}}, %{{.*}} : memref<?x?xf32>, vector<5xf32>71 %8 = vector.transfer_read %arg0[%c3, %c3], %f0, %m : memref<?x?xf32>, vector<5xf32>72 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]], %[[C3]]], %{{.*}}, %{{.*}} : memref<?x?x?xf32>, vector<5x4x8xf32>73 %9 = vector.transfer_read %arg4[%c3, %c3, %c3], %f0, %m2 {permutation_map = affine_map<(d0, d1, d2)->(d1, d0, 0)>} : memref<?x?x?xf32>, vector<5x4x8xf32>74 75 // CHECK: vector.transfer_write76 vector.transfer_write %0, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0)>} : vector<128xf32>, memref<?x?xf32>77 // CHECK: vector.transfer_write78 vector.transfer_write %1, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : vector<3x7xf32>, memref<?x?xf32>79 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>80 vector.transfer_write %4, %arg1[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>81 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>82 vector.transfer_write %5, %arg1[%c3, %c3] {in_bounds = [false, false]} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>83 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<5x24xi8>, memref<?x?xvector<4x3xi32>>84 vector.transfer_write %6, %arg2[%c3, %c3] : vector<5x24xi8>, memref<?x?xvector<4x3xi32>>85 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<5x48xi8>, memref<?x?xvector<4x3xindex>>86 vector.transfer_write %7, %arg3[%c3, %c3] : vector<5x48xi8>, memref<?x?xvector<4x3xindex>>87 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : vector<5xf32>, memref<?x?xf32>88 vector.transfer_write %8, %arg0[%c3, %c3], %m : vector<5xf32>, memref<?x?xf32>89 90 return91}92 93 94// CHECK-LABEL: func @vector_transfer_ops_tensor(95func.func @vector_transfer_ops_tensor(%arg0: tensor<?x?xf32>,96 %arg1 : tensor<?x?xvector<4x3xf32>>,97 %arg2 : tensor<?x?xvector<4x3xi32>>,98 %arg3 : tensor<?x?xvector<4x3xindex>>) ->99 (tensor<?x?xf32>, tensor<?x?xf32>, tensor<?x?xvector<4x3xf32>>,100 tensor<?x?xvector<4x3xf32>>, tensor<?x?xvector<4x3xi32>>,101 tensor<?x?xvector<4x3xindex>>){102 // CHECK: %[[C3:.*]] = arith.constant 3 : index103 %c3 = arith.constant 3 : index104 %cst = arith.constant 3.0 : f32105 %f0 = arith.constant 0.0 : f32106 %c0 = arith.constant 0 : i32107 %i0 = arith.constant 0 : index108 109 %vf0 = vector.broadcast %f0 : f32 to vector<4x3xf32>110 %v0 = vector.broadcast %c0 : i32 to vector<4x3xi32>111 %vi0 = vector.broadcast %i0 : index to vector<4x3xindex>112 113 //114 // CHECK: vector.transfer_read115 %0 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d0)>} : tensor<?x?xf32>, vector<128xf32>116 // CHECK: vector.transfer_read117 %1 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : tensor<?x?xf32>, vector<3x7xf32>118 // CHECK: vector.transfer_read119 %2 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0)>} : tensor<?x?xf32>, vector<128xf32>120 // CHECK: vector.transfer_read121 %3 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d1)>} : tensor<?x?xf32>, vector<128xf32>122 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : tensor<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>123 %4 = vector.transfer_read %arg1[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : tensor<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>124 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} {in_bounds = [false, true]} : tensor<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>125 %5 = vector.transfer_read %arg1[%c3, %c3], %vf0 {in_bounds = [false, true]} : tensor<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>126 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : tensor<?x?xvector<4x3xi32>>, vector<5x24xi8>127 %6 = vector.transfer_read %arg2[%c3, %c3], %v0 : tensor<?x?xvector<4x3xi32>>, vector<5x24xi8>128 // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} : tensor<?x?xvector<4x3xindex>>, vector<5x48xi8>129 %7 = vector.transfer_read %arg3[%c3, %c3], %vi0 : tensor<?x?xvector<4x3xindex>>, vector<5x48xi8>130 131 132 // CHECK: vector.transfer_write133 %8 = vector.transfer_write %0, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0)>} : vector<128xf32>, tensor<?x?xf32>134 // CHECK: vector.transfer_write135 %9 = vector.transfer_write %1, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : vector<3x7xf32>, tensor<?x?xf32>136 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<1x1x4x3xf32>, tensor<?x?xvector<4x3xf32>>137 %10 = vector.transfer_write %4, %arg1[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : vector<1x1x4x3xf32>, tensor<?x?xvector<4x3xf32>>138 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<1x1x4x3xf32>, tensor<?x?xvector<4x3xf32>>139 %11 = vector.transfer_write %5, %arg1[%c3, %c3] {in_bounds = [false, false]} : vector<1x1x4x3xf32>, tensor<?x?xvector<4x3xf32>>140 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<5x24xi8>, tensor<?x?xvector<4x3xi32>>141 %12 = vector.transfer_write %6, %arg2[%c3, %c3] : vector<5x24xi8>, tensor<?x?xvector<4x3xi32>>142 // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] : vector<5x48xi8>, tensor<?x?xvector<4x3xindex>>143 %13 = vector.transfer_write %7, %arg3[%c3, %c3] : vector<5x48xi8>, tensor<?x?xvector<4x3xindex>>144 145 return %8, %9, %10, %11, %12, %13 :146 tensor<?x?xf32>, tensor<?x?xf32>, tensor<?x?xvector<4x3xf32>>,147 tensor<?x?xvector<4x3xf32>>, tensor<?x?xvector<4x3xi32>>,148 tensor<?x?xvector<4x3xindex>>149}150 151// CHECK-LABEL: @vector_broadcast152func.func @vector_broadcast(%a: f32, %b: vector<f32>, %c: vector<16xf32>, %d: vector<1x16xf32>, %e: vector<8x1xf32>, %f: vector<8x1x!llvm.ptr<1>>, %g: !llvm.ptr<1>) {153 // CHECK: vector.broadcast %{{.*}} : f32 to vector<f32>154 %0 = vector.broadcast %a : f32 to vector<f32>155 // CHECK: vector.broadcast %{{.*}} : vector<f32> to vector<4xf32>156 %1 = vector.broadcast %b : vector<f32> to vector<4xf32>157 // CHECK: vector.broadcast %{{.*}} : f32 to vector<16xf32>158 %2 = vector.broadcast %a : f32 to vector<16xf32>159 // CHECK-NEXT: vector.broadcast %{{.*}} : vector<16xf32> to vector<8x16xf32>160 %3 = vector.broadcast %c : vector<16xf32> to vector<8x16xf32>161 // CHECK-NEXT: vector.broadcast %{{.*}} : vector<1x16xf32> to vector<8x16xf32>162 %4 = vector.broadcast %d : vector<1x16xf32> to vector<8x16xf32>163 // CHECK-NEXT: vector.broadcast %{{.*}} : vector<8x1xf32> to vector<8x16xf32>164 %5 = vector.broadcast %e : vector<8x1xf32> to vector<8x16xf32>165 // CHECK-NEXT: vector.broadcast %{{.*}} : vector<8x1x!llvm.ptr<1>> to vector<8x16x!llvm.ptr<1>>166 %6 = vector.broadcast %f : vector<8x1x!llvm.ptr<1>> to vector<8x16x!llvm.ptr<1>>167 // CHECK-NEXT: vector.broadcast %{{.*}} : !llvm.ptr<1> to vector<8x16x!llvm.ptr<1>>168 %7 = vector.broadcast %g : !llvm.ptr<1> to vector<8x16x!llvm.ptr<1>>169 return170}171 172// CHECK-LABEL: @shuffle0D173func.func @shuffle0D(%a: vector<f32>) -> vector<3xf32> {174 // CHECK: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 0] : vector<f32>, vector<f32>175 %1 = vector.shuffle %a, %a[0, 1, 0] : vector<f32>, vector<f32>176 return %1 : vector<3xf32>177}178 179// CHECK-LABEL: @shuffle1D180func.func @shuffle1D(%a: vector<2xf32>, %b: vector<4xf32>) -> vector<2xf32> {181 // CHECK: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 2, 3] : vector<2xf32>, vector<2xf32>182 %1 = vector.shuffle %a, %a[0, 1, 2, 3] : vector<2xf32>, vector<2xf32>183 // CHECK-NEXT: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 2] : vector<4xf32>, vector<4xf32>184 %2 = vector.shuffle %1, %b[0, 1, 2] : vector<4xf32>, vector<4xf32>185 // CHECK-NEXT: vector.shuffle %{{.*}}, %{{.*}}[0, 6] : vector<3xf32>, vector<4xf32>186 %3 = vector.shuffle %2, %b[0, 6] : vector<3xf32>, vector<4xf32>187 return %3 : vector<2xf32>188}189 190// CHECK-LABEL: @shuffle2D191func.func @shuffle2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {192 // CHECK: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 2] : vector<1x4xf32>, vector<2x4xf32>193 %1 = vector.shuffle %a, %b[0, 1, 2] : vector<1x4xf32>, vector<2x4xf32>194 return %1 : vector<3x4xf32>195}196 197// CHECK-LABEL: @shuffle_poison_mask198func.func @shuffle_poison_mask(%a: vector<4xf32>, %b: vector<4xf32>) -> vector<4xf32> {199 // CHECK: vector.shuffle %{{.*}}, %{{.*}}[1, -1, 6, -1] : vector<4xf32>, vector<4xf32>200 %1 = vector.shuffle %a, %a[1, -1, 6, -1] : vector<4xf32>, vector<4xf32>201 return %1 : vector<4xf32>202}203 204// CHECK-LABEL: @extract_const_idx205func.func @extract_const_idx(%arg0: vector<4x8x16xf32>)206 -> (vector<4x8x16xf32>, vector<8x16xf32>, vector<16xf32>, f32) {207 // CHECK: vector.extract {{.*}}[] : vector<4x8x16xf32> from vector<4x8x16xf32>208 %0 = vector.extract %arg0[] : vector<4x8x16xf32> from vector<4x8x16xf32>209 // CHECK: vector.extract {{.*}}[3] : vector<8x16xf32> from vector<4x8x16xf32>210 %1 = vector.extract %arg0[3] : vector<8x16xf32> from vector<4x8x16xf32>211 // CHECK-NEXT: vector.extract {{.*}}[3, 3] : vector<16xf32> from vector<4x8x16xf32>212 %2 = vector.extract %arg0[3, 3] : vector<16xf32> from vector<4x8x16xf32>213 // CHECK-NEXT: vector.extract {{.*}}[3, 3, 3] : f32 from vector<4x8x16xf32>214 %3 = vector.extract %arg0[3, 3, 3] : f32 from vector<4x8x16xf32>215 return %0, %1, %2, %3 : vector<4x8x16xf32>, vector<8x16xf32>, vector<16xf32>, f32216}217 218// CHECK-LABEL: @extract_val_idx219// CHECK-SAME: %[[VEC:.+]]: vector<4x8x16xf32>, %[[IDX:.+]]: index220func.func @extract_val_idx(%arg0: vector<4x8x16xf32>, %idx: index)221 -> (vector<8x16xf32>, vector<16xf32>, f32) {222 // CHECK: vector.extract %[[VEC]][%[[IDX]]] : vector<8x16xf32> from vector<4x8x16xf32>223 %0 = vector.extract %arg0[%idx] : vector<8x16xf32> from vector<4x8x16xf32>224 // CHECK-NEXT: vector.extract %[[VEC]][%[[IDX]], %[[IDX]]] : vector<16xf32> from vector<4x8x16xf32>225 %1 = vector.extract %arg0[%idx, %idx] : vector<16xf32> from vector<4x8x16xf32>226 // CHECK-NEXT: vector.extract %[[VEC]][%[[IDX]], 5, %[[IDX]]] : f32 from vector<4x8x16xf32>227 %2 = vector.extract %arg0[%idx, 5, %idx] : f32 from vector<4x8x16xf32>228 return %0, %1, %2 : vector<8x16xf32>, vector<16xf32>, f32229}230 231// CHECK-LABEL: @extract_0d232func.func @extract_0d(%a: vector<f32>) -> f32 {233 // CHECK-NEXT: vector.extract %{{.*}}[] : f32 from vector<f32>234 %0 = vector.extract %a[] : f32 from vector<f32>235 return %0 : f32236}237 238// CHECK-LABEL: @extract_poison_idx239func.func @extract_poison_idx(%a: vector<4x5xf32>) -> f32 {240 // CHECK-NEXT: vector.extract %{{.*}}[-1, 0] : f32 from vector<4x5xf32>241 %0 = vector.extract %a[-1, 0] : f32 from vector<4x5xf32>242 return %0 : f32243}244 245// CHECK-LABEL: @insert_const_idx246func.func @insert_const_idx(%a: f32, %b: vector<16xf32>, %c: vector<8x16xf32>,247 %res: vector<4x8x16xf32>) -> vector<4x8x16xf32> {248 // CHECK: vector.insert %{{.*}}, %{{.*}}[3] : vector<8x16xf32> into vector<4x8x16xf32>249 %1 = vector.insert %c, %res[3] : vector<8x16xf32> into vector<4x8x16xf32>250 // CHECK: vector.insert %{{.*}}, %{{.*}}[3, 3] : vector<16xf32> into vector<4x8x16xf32>251 %2 = vector.insert %b, %res[3, 3] : vector<16xf32> into vector<4x8x16xf32>252 // CHECK: vector.insert %{{.*}}, %{{.*}}[3, 3, 3] : f32 into vector<4x8x16xf32>253 %3 = vector.insert %a, %res[3, 3, 3] : f32 into vector<4x8x16xf32>254 // CHECK: vector.insert %{{.*}}, %{{.*}}[] : vector<4x8x16xf32> into vector<4x8x16xf32>255 %4 = vector.insert %3, %3[] : vector<4x8x16xf32> into vector<4x8x16xf32>256 return %4 : vector<4x8x16xf32>257}258 259// CHECK-LABEL: @insert_val_idx260// CHECK-SAME: %[[A:.+]]: f32, %[[B:.+]]: vector<16xf32>, %[[C:.+]]: vector<8x16xf32>, %[[IDX:.+]]: index261func.func @insert_val_idx(%a: f32, %b: vector<16xf32>, %c: vector<8x16xf32>,262 %idx: index, %res: vector<4x8x16xf32>) -> vector<4x8x16xf32> {263 // CHECK: vector.insert %[[C]], %{{.*}}[%[[IDX]]] : vector<8x16xf32> into vector<4x8x16xf32>264 %0 = vector.insert %c, %res[%idx] : vector<8x16xf32> into vector<4x8x16xf32>265 // CHECK: vector.insert %[[B]], %{{.*}}[%[[IDX]], %[[IDX]]] : vector<16xf32> into vector<4x8x16xf32>266 %1 = vector.insert %b, %res[%idx, %idx] : vector<16xf32> into vector<4x8x16xf32>267 // CHECK: vector.insert %[[A]], %{{.*}}[%[[IDX]], 5, %[[IDX]]] : f32 into vector<4x8x16xf32>268 %2 = vector.insert %a, %res[%idx, 5, %idx] : f32 into vector<4x8x16xf32>269 return %2 : vector<4x8x16xf32>270}271 272// CHECK-LABEL: @insert_0d273func.func @insert_0d(%a: f32, %b: vector<f32>) -> vector<f32> {274 // CHECK-NEXT: vector.insert %{{.*}}, %{{.*}}[] : f32 into vector<f32>275 %1 = vector.insert %a, %b[] : f32 into vector<f32>276 return %1 : vector<f32>277}278 279// CHECK-LABEL: @insert_poison_idx280func.func @insert_poison_idx(%a: vector<4x5xf32>, %b: f32) {281 // CHECK-NEXT: vector.insert %{{.*}}, %{{.*}}[-1, 0] : f32 into vector<4x5xf32>282 vector.insert %b, %a[-1, 0] : f32 into vector<4x5xf32>283 return284}285 286// CHECK-LABEL: @outerproduct287func.func @outerproduct(%arg0: vector<4xf32>, %arg1: vector<8xf32>, %arg2: vector<4x8xf32>) -> vector<4x8xf32> {288 // CHECK: vector.outerproduct {{.*}} : vector<4xf32>, vector<8xf32>289 %0 = vector.outerproduct %arg0, %arg1 : vector<4xf32>, vector<8xf32>290 // CHECK: vector.outerproduct {{.*}}, {{.*}}, {{.*}} : vector<4xf32>, vector<8xf32>291 %1 = vector.outerproduct %arg0, %arg1, %arg2 : vector<4xf32>, vector<8xf32>292 return %1 : vector<4x8xf32>293}294 295// CHECK-LABEL: @outerproduct_scalable296func.func @outerproduct_scalable(%arg0 : vector<[4]xf32>, %arg1 : vector<[8]xf32>) {297 // CHECK: vector.outerproduct {{.*}} : vector<[4]xf32>, vector<[8]xf32>298 %0 = vector.outerproduct %arg0, %arg1 : vector<[4]xf32>, vector<[8]xf32>299 300 %cst = arith.constant 1.0 : f32301 // CHECK: vector.outerproduct {{.*}} : vector<[4]xf32>, f32302 %1 = vector.outerproduct %arg0, %cst : vector<[4]xf32>, f32303 return304}305 306// CHECK-LABEL: @insert_strided_slice307func.func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) {308 // CHECK: vector.insert_strided_slice %{{.*}}, %{{.*}} {offsets = [2, 2, 2], strides = [1, 1]} : vector<4x4xf32> into vector<4x8x16xf32>309 %1 = vector.insert_strided_slice %a, %b {offsets = [2, 2, 2], strides = [1, 1]} : vector<4x4xf32> into vector<4x8x16xf32>310 return311}312 313// CHECK-LABEL: @insert_strided_slice_scalable314func.func @insert_strided_slice_scalable(%a: vector<4x[16]xf32>, %b: vector<4x8x[16]xf32>) {315 // CHECK: vector.insert_strided_slice %{{.*}}, %{{.*}} {offsets = [2, 2, 0], strides = [1, 1]} : vector<4x[16]xf32> into vector<4x8x[16]xf32>316 %1 = vector.insert_strided_slice %a, %b {offsets = [2, 2, 0], strides = [1, 1]} : vector<4x[16]xf32> into vector<4x8x[16]xf32>317 return318}319 320// CHECK-LABEL: @extract_strided_slice321func.func @extract_strided_slice(%arg0: vector<4x8x16xf32>) -> vector<2x2x16xf32> {322 // CHECK: vector.extract_strided_slice %{{.*}} {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8x16xf32>323 %1 = vector.extract_strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8x16xf32> to vector<2x2x16xf32>324 return %1: vector<2x2x16xf32>325}326 327// CHECK-LABEL: @extract_strided_slice_scalable328func.func @extract_strided_slice_scalable(%arg0: vector<4x[8]x16xf32>) -> vector<2x[8]x16xf32> {329 // CHECK: vector.extract_strided_slice %{{.*}} {offsets = [2, 0], sizes = [2, 8], strides = [1, 1]} : vector<4x[8]x16xf32>330 %1 = vector.extract_strided_slice %arg0 {offsets = [2, 0], sizes = [2, 8], strides = [1, 1]} : vector<4x[8]x16xf32> to vector<2x[8]x16xf32>331 return %1: vector<2x[8]x16xf32>332}333 334#contraction_to_scalar_accesses = [335 affine_map<(i) -> (i)>,336 affine_map<(i) -> (i)>,337 affine_map<(i) -> ()>338]339#contraction_to_scalar_trait = {340 indexing_maps = #contraction_to_scalar_accesses,341 iterator_types = ["reduction"]342}343// CHECK-LABEL: @contraction_to_scalar344func.func @contraction_to_scalar(%arg0: vector<10xf32>, %arg1: vector<10xf32>) -> f32 {345 // CHECK: %[[C0:.*]] = arith.constant 0.000000e+00 : f32346 %f0 = arith.constant 0.0: f32347 // CHECK: %[[X:.*]] = vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["reduction"], kind = #vector.kind<add>} %{{.*}}, %{{.*}}, %[[C0]] : vector<10xf32>, vector<10xf32> into f32348 %0 = vector.contract #contraction_to_scalar_trait %arg0, %arg1, %f0349 : vector<10xf32>, vector<10xf32> into f32350 // CHECK: return %[[X]] : f32351 return %0 : f32352}353 354// CHECK-LABEL: @contraction_to_scalar_scalable355func.func @contraction_to_scalar_scalable(%arg0: vector<[10]xf32>, %arg1: vector<[10]xf32>) -> f32 {356 // CHECK: %[[C0:.*]] = arith.constant 0.000000e+00 : f32357 %f0 = arith.constant 0.0: f32358 // CHECK: %[[X:.*]] = vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["reduction"], kind = #vector.kind<add>} %{{.*}}, %{{.*}}, %[[C0]] : vector<[10]xf32>, vector<[10]xf32> into f32359 %0 = vector.contract #contraction_to_scalar_trait %arg0, %arg1, %f0360 : vector<[10]xf32>, vector<[10]xf32> into f32361 // CHECK: return %[[X]] : f32362 return %0 : f32363}364 365// CHECK-LABEL: @contraction_extra_attrs366func.func @contraction_extra_attrs(%arg0: vector<10xf32>, %arg1: vector<10xf32>) -> f32 {367 // CHECK: %[[C0:.*]] = arith.constant 0.000000e+00 : f32368 %f0 = arith.constant 0.0: f32369 // CHECK: %[[X:.*]] = vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["reduction"], kind = #vector.kind<add>} %{{.*}}, %{{.*}}, %[[C0]] {first_attr = 1 : i32, second_attr = "string"} : vector<10xf32>, vector<10xf32> into f32370 %0 = vector.contract #contraction_to_scalar_trait %arg0, %arg1, %f0371 {first_attr = 1 : i32, second_attr = "string"}372 : vector<10xf32>, vector<10xf32> into f32373 // CHECK: return %[[X]] : f32374 return %0 : f32375}376 377#contraction_to_scalar_max_accesses = [378 affine_map<(i) -> (i)>,379 affine_map<(i) -> (i)>,380 affine_map<(i) -> ()>381]382#contraction_to_scalar_max_trait = {383 indexing_maps = #contraction_to_scalar_max_accesses,384 iterator_types = ["reduction"],385 kind = #vector.kind<maxnumf>386}387// CHECK-LABEL: @contraction_to_scalar_with_max388func.func @contraction_to_scalar_with_max(%arg0: vector<10xf32>, %arg1: vector<10xf32>) -> f32 {389 // CHECK: %[[C0:.*]] = arith.constant 0.000000e+00 : f32390 %f0 = arith.constant 0.0: f32391 // CHECK: %[[X:.*]] = vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["reduction"], kind = #vector.kind<maxnumf>} %{{.*}}, %{{.*}}, %[[C0]] : vector<10xf32>, vector<10xf32> into f32392 %0 = vector.contract #contraction_to_scalar_max_trait %arg0, %arg1, %f0393 : vector<10xf32>, vector<10xf32> into f32394 // CHECK: return %[[X]] : f32395 return %0 : f32396}397 398#contraction_accesses0 = [399 affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,400 affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,401 affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>402]403#contraction_trait0 = {404 indexing_maps = #contraction_accesses0,405 iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]406}407#contraction_accesses1 = [ // 7, 8, 16, 15408 affine_map<(f0, f1, f2, f3, c0, c1) -> (c0, f0, c1, f2)>,409 // 8, 16, 7, 5410 affine_map<(f0, f1, f2, f3, c0, c1) -> (f1, c1, c0, f3)>,411 // 8, 8, 15, 5412 affine_map<(f0, f1, f2, f3, c0, c1) -> (f0, f1, f2, f3)>413]414#iterator_types1 = ["parallel", "parallel", "parallel", "parallel", "reduction",415 "reduction"]416#contraction_trait1 = {417 indexing_maps = #contraction_accesses1,418 iterator_types = #iterator_types1419}420#contraction_trait2 = {421 indexing_maps = #contraction_accesses1,422 iterator_types = #iterator_types1,423 kind = #vector.kind<maxnumf>424}425// CHECK-LABEL: @contraction426func.func @contraction(%arg0 : vector<7x8x16x15xf32>, %arg1 : vector<8x16x7x5xf32>,427 %arg2 : vector<8x15x5xf32>, %arg3 : vector<8x8x15x5xf32>,428 %arg4 : vector<7x8x16x15xf16>, %arg5 : vector<8x16x7x5xf16>) {429 // Test contraction with batch and contracting dims.430 // CHECK: vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"], kind = #vector.kind<add>} {{.*}}, {{.*}}, {{.*}} : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>431 %0 = vector.contract #contraction_trait0 %arg0, %arg1, %arg2432 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>433 // Test contraction with only contracting dims. In this case the lhs/rhs434 // dimension of size 8 will be considered a parallel dim for lhs/rhs and will435 // appear twice in the output.436 // CHECK: vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], kind = #vector.kind<add>} {{.*}}, {{.*}}, {{.*}} : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x8x15x5xf32>437 %1 = vector.contract #contraction_trait1 %arg0, %arg1, %arg3438 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x8x15x5xf32>439 // Test contraction with mixed type.440 // CHECK: vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], kind = #vector.kind<add>} {{.*}}, {{.*}}, {{.*}} : vector<7x8x16x15xf16>, vector<8x16x7x5xf16> into vector<8x8x15x5xf32>441 %3 = vector.contract #contraction_trait1 %arg4, %arg5, %arg3442 : vector<7x8x16x15xf16>, vector<8x16x7x5xf16> into vector<8x8x15x5xf32>443 // Test contraction with "max" instead of "add".444 // CHECK: vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction"], kind = #vector.kind<maxnumf>} {{.*}}, {{.*}}, {{.*}} : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x8x15x5xf32>445 %4 = vector.contract #contraction_trait2 %arg0, %arg1, %arg3446 : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x8x15x5xf32>447 return448}449 450#contraction_matmul_accesses = [451 affine_map<(d0, d1, d2) -> (d0, d2)>,452 affine_map<(d0, d1, d2) -> (d2, d1)>,453 affine_map<(d0, d1, d2) -> (d0, d1)>454]455#contraction_matmul_trait = {456 indexing_maps = #contraction_matmul_accesses,457 iterator_types = ["parallel", "parallel", "reduction"]458}459// CHECK-LABEL: @contraction_matmul_scalable460func.func @contraction_matmul_scalable(%A: vector<8x1xf32>, %B: vector<1x[32]xf32>, %C: vector<8x[32]xf32>) -> vector<8x[32]xf32> {461 // CHECK: %[[X:.*]] = vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "reduction"], kind = #vector.kind<add>} {{.*}}, {{.*}}, {{.*}} : vector<8x1xf32>, vector<1x[32]xf32> into vector<8x[32]xf32>462 %res = vector.contract #contraction_matmul_trait %A, %B, %C463 : vector<8x1xf32>, vector<1x[32]xf32> into vector<8x[32]xf32>464 // CHECK: return %[[X]] : vector<8x[32]xf32>465 return %res : vector<8x[32]xf32>466}467 468// CHECK-LABEL: @create_vector_mask469func.func @create_vector_mask() {470 // CHECK: %[[C2:.*]] = arith.constant 2 : index471 %c2 = arith.constant 2 : index472 // CHECK-NEXT: %[[C3:.*]] = arith.constant 3 : index473 %c3 = arith.constant 3 : index474 // CHECK-NEXT: vector.create_mask %[[C3]], %[[C2]] : vector<4x3xi1>475 %0 = vector.create_mask %c3, %c2 : vector<4x3xi1>476 477 return478}479 480// CHECK-LABEL: @constant_vector_mask_0d481func.func @constant_vector_mask_0d() {482 // CHECK: vector.constant_mask [0] : vector<i1>483 %0 = vector.constant_mask [0] : vector<i1>484 // CHECK: vector.constant_mask [1] : vector<i1>485 %1 = vector.constant_mask [1] : vector<i1>486 return487}488 489// CHECK-LABEL: @constant_vector_mask490func.func @constant_vector_mask() {491 // CHECK: vector.constant_mask [3, 2] : vector<4x3xi1>492 %0 = vector.constant_mask [3, 2] : vector<4x3xi1>493 // CHECK: vector.constant_mask [0] : vector<[4]xi1>494 %1 = vector.constant_mask [0] : vector<[4]xi1>495 // CHECK: vector.constant_mask [4] : vector<[4]xi1>496 %2 = vector.constant_mask [4] : vector<[4]xi1>497 // CHECK: vector.constant_mask [1, 4] : vector<2x[4]xi1>498 %3 = vector.constant_mask [1, 4] : vector<2x[4]xi1>499 return500}501 502// CHECK-LABEL: @vector_print_on_vector503func.func @vector_print_on_vector(%arg0: vector<8x4xf32>) {504 // CHECK: vector.print %{{.*}} : vector<8x4xf32>505 vector.print %arg0 : vector<8x4xf32>506 return507}508 509// CHECK-LABEL: @vector_print_on_scalar510func.func @vector_print_on_scalar(%arg0: i64) {511 // CHECK: vector.print %{{.*}} : i64512 vector.print %arg0 : i64513 return514}515 516// CHECK-LABEL: @shape_cast517func.func @shape_cast(%arg0 : vector<5x1x3x2xf32>,518 %arg1 : vector<8x1xf32>,519 %arg2 : vector<16x1x1xf32>)520 -> (vector<15x2xf32>, vector<8xf32>, vector<16xf32>, vector<16x1xf32>) {521 522 // CHECK: vector.shape_cast %{{.*}} : vector<5x1x3x2xf32> to vector<15x2xf32>523 %0 = vector.shape_cast %arg0 : vector<5x1x3x2xf32> to vector<15x2xf32>524 525 // CHECK-NEXT: vector.shape_cast %{{.*}} : vector<8x1xf32> to vector<8xf32>526 %1 = vector.shape_cast %arg1 : vector<8x1xf32> to vector<8xf32>527 528 // CHECK-NEXT: vector.shape_cast %{{.*}} : vector<16x1x1xf32> to vector<16xf32>529 %2 = vector.shape_cast %arg2 : vector<16x1x1xf32> to vector<16xf32>530 531 // CHECK-NEXT: vector.shape_cast %{{.*}} : vector<16x1x1xf32> to vector<16x1xf32>532 %3 = vector.shape_cast %arg2 : vector<16x1x1xf32> to vector<16x1xf32>533 534 return %0, %1, %2, %3 : vector<15x2xf32>, vector<8xf32>, vector<16xf32>, vector<16x1xf32>535}536 537// A vector.shape_cast can cast between any 2 shapes as long as the538// number of elements is preserved. For those familiar with the tensor539// dialect: this behaviour is like the tensor.reshape operation, i.e.540// less restrictive than tensor.collapse_shape and tensor.expand_shape541// CHECK-LABEL: @shape_cast_general_reshape542func.func @shape_cast_general_reshape(%arg0 : vector<2x3xf32>) -> (vector<3x1x2xf32>) {543 // CHECK: vector.shape_cast %{{.*}} : vector<2x3xf32> to vector<3x1x2xf32>544 %0 = vector.shape_cast %arg0 : vector<2x3xf32> to vector<3x1x2xf32>545 return %0 : vector<3x1x2xf32>546}547 548// CHECK-LABEL: @shape_cast_0d549func.func @shape_cast_0d(%arg0 : vector<1x1x1x1xf32>) -> (vector<1x1x1x1xf32>) {550 551 // CHECK: vector.shape_cast %{{.*}} : vector<1x1x1x1xf32> to vector<f32>552 %0 = vector.shape_cast %arg0 : vector<1x1x1x1xf32> to vector<f32>553 554 // CHECK: vector.shape_cast %{{.*}} : vector<f32> to vector<1x1x1x1xf32>555 %1 = vector.shape_cast %0 : vector<f32> to vector<1x1x1x1xf32>556 557 return %1 : vector<1x1x1x1xf32>558}559 560// CHECK-LABEL: @bitcast561func.func @bitcast(%arg0 : vector<5x1x3x2xf32>,562 %arg1 : vector<8x1xi32>,563 %arg2 : vector<16x1x8xi8>,564 %arg3 : vector<8x2x1xindex>,565 %arg4 : vector<f32>)566 -> (vector<5x1x3x4xf16>, vector<5x1x3x8xi8>, vector<8x4xi8>, vector<8x1xf32>, vector<16x1x2xi32>, vector<16x1x4xi16>, vector<16x1x1xindex>, vector<8x2x2xf32>, vector<i32>) {567 568 // CHECK: vector.bitcast %{{.*}} : vector<5x1x3x2xf32> to vector<5x1x3x4xf16>569 %0 = vector.bitcast %arg0 : vector<5x1x3x2xf32> to vector<5x1x3x4xf16>570 571 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<5x1x3x2xf32> to vector<5x1x3x8xi8>572 %1 = vector.bitcast %arg0 : vector<5x1x3x2xf32> to vector<5x1x3x8xi8>573 574 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<8x1xi32> to vector<8x4xi8>575 %2 = vector.bitcast %arg1 : vector<8x1xi32> to vector<8x4xi8>576 577 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<8x1xi32> to vector<8x1xf32>578 %3 = vector.bitcast %arg1 : vector<8x1xi32> to vector<8x1xf32>579 580 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<16x1x8xi8> to vector<16x1x2xi32>581 %4 = vector.bitcast %arg2 : vector<16x1x8xi8> to vector<16x1x2xi32>582 583 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<16x1x8xi8> to vector<16x1x4xi16>584 %5 = vector.bitcast %arg2 : vector<16x1x8xi8> to vector<16x1x4xi16>585 586 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<16x1x8xi8> to vector<16x1x1xindex>587 %6 = vector.bitcast %arg2 : vector<16x1x8xi8> to vector<16x1x1xindex>588 589 // CHECK-NEXT: vector.bitcast %{{.*}} : vector<8x2x1xindex> to vector<8x2x2xf32>590 %7 = vector.bitcast %arg3 : vector<8x2x1xindex> to vector<8x2x2xf32>591 592 // CHECK: vector.bitcast %{{.*}} : vector<f32> to vector<i32>593 %8 = vector.bitcast %arg4 : vector<f32> to vector<i32>594 595 return %0, %1, %2, %3, %4, %5, %6, %7, %8 : vector<5x1x3x4xf16>, vector<5x1x3x8xi8>, vector<8x4xi8>, vector<8x1xf32>, vector<16x1x2xi32>, vector<16x1x4xi16>, vector<16x1x1xindex>, vector<8x2x2xf32>, vector<i32>596}597 598// CHECK-LABEL: @vector_fma599func.func @vector_fma(%a: vector<8xf32>, %b: vector<8x4xf32>, %c: vector<f32>) {600 // CHECK: vector.fma %{{.*}} : vector<8xf32>601 vector.fma %a, %a, %a : vector<8xf32>602 // CHECK: vector.fma %{{.*}} : vector<8x4xf32>603 vector.fma %b, %b, %b : vector<8x4xf32>604 // CHECK: vector.fma %{{.*}} : vector<f32>605 vector.fma %c, %c, %c : vector<f32>606 return607}608 609// CHECK-LABEL: @reduce_fp610func.func @reduce_fp(%arg0: vector<16xf32>, %arg1: f32) -> f32 {611 // CHECK: vector.reduction <add>, %{{.*}} : vector<16xf32> into f32612 vector.reduction <add>, %arg0 : vector<16xf32> into f32613 // CHECK: vector.reduction <add>, %{{.*}}, %{{.*}} : vector<16xf32> into f32614 vector.reduction <add>, %arg0, %arg1 : vector<16xf32> into f32615 // CHECK: vector.reduction <mul>, %{{.*}} : vector<16xf32> into f32616 vector.reduction <mul>, %arg0 : vector<16xf32> into f32617 // CHECK: vector.reduction <mul>, %{{.*}}, %{{.*}} : vector<16xf32> into f32618 vector.reduction <mul>, %arg0, %arg1 : vector<16xf32> into f32619 // CHECK: vector.reduction <minnumf>, %{{.*}} : vector<16xf32> into f32620 vector.reduction <minnumf>, %arg0 : vector<16xf32> into f32621 // CHECK: %[[X0:.*]] = vector.reduction <maxnumf>, %{{.*}} : vector<16xf32> into f32622 %0 = vector.reduction <maxnumf>, %arg0 : vector<16xf32> into f32623 // CHECK: vector.reduction <minimumf>, %{{.*}} : vector<16xf32> into f32624 vector.reduction <minimumf>, %arg0 : vector<16xf32> into f32625 // CHECK: %[[X1:.*]] = vector.reduction <maximumf>, %{{.*}} : vector<16xf32> into f32626 %1 = vector.reduction <maximumf>, %arg0 : vector<16xf32> into f32627 // CHECK: return %[[X0]] : f32628 return %0 : f32629}630 631// CHECK-LABEL: @reduce_int632func.func @reduce_int(%arg0: vector<16xi32>) -> i32 {633 // CHECK: vector.reduction <add>, %{{.*}} : vector<16xi32> into i32634 vector.reduction <add>, %arg0 : vector<16xi32> into i32635 // CHECK: vector.reduction <mul>, %{{.*}} : vector<16xi32> into i32636 vector.reduction <mul>, %arg0 : vector<16xi32> into i32637 // CHECK: vector.reduction <minui>, %{{.*}} : vector<16xi32> into i32638 vector.reduction <minui>, %arg0 : vector<16xi32> into i32639 // CHECK: vector.reduction <minsi>, %{{.*}} : vector<16xi32> into i32640 vector.reduction <minsi>, %arg0 : vector<16xi32> into i32641 // CHECK: vector.reduction <maxui>, %{{.*}} : vector<16xi32> into i32642 vector.reduction <maxui>, %arg0 : vector<16xi32> into i32643 // CHECK: vector.reduction <maxsi>, %{{.*}} : vector<16xi32> into i32644 vector.reduction <maxsi>, %arg0 : vector<16xi32> into i32645 // CHECK: vector.reduction <and>, %{{.*}} : vector<16xi32> into i32646 vector.reduction <and>, %arg0 : vector<16xi32> into i32647 // CHECK: vector.reduction <or>, %{{.*}} : vector<16xi32> into i32648 vector.reduction <or>, %arg0 : vector<16xi32> into i32649 // CHECK: %[[X:.*]] = vector.reduction <xor>, %{{.*}} : vector<16xi32> into i32650 %0 = vector.reduction <xor>, %arg0 : vector<16xi32> into i32651 // CHECK: return %[[X]] : i32652 return %0 : i32653}654 655// CHECK-LABEL: @reduce_int656func.func @reduce_int_0d(%arg0: vector<i32>) -> i32 {657 // CHECK: vector.reduction <add>, %{{.*}} : vector<i32> into i32658 vector.reduction <add>, %arg0 : vector<i32> into i32659 // CHECK: vector.reduction <mul>, %{{.*}} : vector<i32> into i32660 vector.reduction <mul>, %arg0 : vector<i32> into i32661 // CHECK: vector.reduction <minui>, %{{.*}} : vector<i32> into i32662 vector.reduction <minui>, %arg0 : vector<i32> into i32663 // CHECK: vector.reduction <minsi>, %{{.*}} : vector<i32> into i32664 vector.reduction <minsi>, %arg0 : vector<i32> into i32665 // CHECK: vector.reduction <maxui>, %{{.*}} : vector<i32> into i32666 vector.reduction <maxui>, %arg0 : vector<i32> into i32667 // CHECK: vector.reduction <maxsi>, %{{.*}} : vector<i32> into i32668 vector.reduction <maxsi>, %arg0 : vector<i32> into i32669 // CHECK: vector.reduction <and>, %{{.*}} : vector<i32> into i32670 vector.reduction <and>, %arg0 : vector<i32> into i32671 // CHECK: vector.reduction <or>, %{{.*}} : vector<i32> into i32672 vector.reduction <or>, %arg0 : vector<i32> into i32673 // CHECK: %[[X:.*]] = vector.reduction <xor>, %{{.*}} : vector<i32> into i32674 %0 = vector.reduction <xor>, %arg0 : vector<i32> into i32675 // CHECK: return %[[X]] : i32676 return %0 : i32677}678 679// CHECK-LABEL: @transpose_fp680func.func @transpose_fp(%arg0: vector<3x7xf32>) -> vector<7x3xf32> {681 // CHECK: %[[X:.*]] = vector.transpose %{{.*}}, [1, 0] : vector<3x7xf32> to vector<7x3xf32>682 %0 = vector.transpose %arg0, [1, 0] : vector<3x7xf32> to vector<7x3xf32>683 // CHECK: return %[[X]] : vector<7x3xf32>684 return %0 : vector<7x3xf32>685}686 687// CHECK-LABEL: @transpose_int688func.func @transpose_int(%arg0: vector<11x7x3x2xi32>) -> vector<2x11x7x3xi32> {689 // CHECK: %[[X:.*]] = vector.transpose %{{.*}}, [3, 0, 1, 2] : vector<11x7x3x2xi32> to vector<2x11x7x3xi32>690 %0 = vector.transpose %arg0, [3, 0, 1, 2] : vector<11x7x3x2xi32> to vector<2x11x7x3xi32>691 // CHECK: return %[[X]] : vector<2x11x7x3xi32>692 return %0 : vector<2x11x7x3xi32>693}694 695// CHECK-LABEL: @transpose_fp_0d696func.func @transpose_fp_0d(%arg0: vector<f32>) -> vector<f32> {697 // CHECK: %[[X:.*]] = vector.transpose %{{.*}}, [] : vector<f32> to vector<f32>698 %0 = vector.transpose %arg0, [] : vector<f32> to vector<f32>699 // CHECK: return %[[X]] : vector<f32>700 return %0 : vector<f32>701}702 703// CHECK-LABEL: @transpose_int_0d704func.func @transpose_int_0d(%arg0: vector<i32>) -> vector<i32> {705 // CHECK: %[[X:.*]] = vector.transpose %{{.*}}, [] : vector<i32> to vector<i32>706 %0 = vector.transpose %arg0, [] : vector<i32> to vector<i32>707 // CHECK: return %[[X]] : vector<i32>708 return %0 : vector<i32>709}710 711// CHECK-LABEL: @vector_load_and_store_0d_scalar_memref712func.func @vector_load_and_store_0d_scalar_memref(%memref : memref<200x100xf32>,713 %i : index, %j : index) {714 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xf32>, vector<f32>715 %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<f32>716 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xf32>, vector<f32>717 vector.store %0, %memref[%i, %j] : memref<200x100xf32>, vector<f32>718 return719}720 721// CHECK-LABEL: @vector_load_and_store_0d_scalar_strided_memref722func.func @vector_load_and_store_0d_scalar_strided_memref(%memref : memref<200x100xf32, strided<[?, ?], offset: ?>>,723 %i : index, %j : index) {724 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<f32>725 %0 = vector.load %memref[%i, %j] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<f32>726 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<f32>727 vector.store %0, %memref[%i, %j] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<f32>728 return729}730 731// CHECK-LABEL: @vector_load_and_store_unit_vec_strided_memref732func.func @vector_load_and_store_unit_vec_strided_memref(%memref : memref<200x100xf32, strided<[?, ?], offset: ?>>,733 %i : index, %j : index) {734 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<1xf32>735 %0 = vector.load %memref[%i, %j] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<1xf32>736 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<1xf32>737 vector.store %0, %memref[%i, %j] : memref<200x100xf32, strided<[?, ?], offset: ?>>, vector<1xf32>738 return739}740 741// CHECK-LABEL: @vector_load_and_store_1d_scalar_memref742func.func @vector_load_and_store_1d_scalar_memref(%memref : memref<200x100xf32>,743 %i : index, %j : index) {744 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xf32>, vector<8xf32>745 %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<8xf32>746 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xf32>, vector<8xf32>747 vector.store %0, %memref[%i, %j] : memref<200x100xf32>, vector<8xf32>748 return749}750 751// CHECK-LABEL: @vector_load_and_store_1d_vector_memref752func.func @vector_load_and_store_1d_vector_memref(%memref : memref<200x100xvector<8xf32>>,753 %i : index, %j : index) {754 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xvector<8xf32>>, vector<8xf32>755 %0 = vector.load %memref[%i, %j] : memref<200x100xvector<8xf32>>, vector<8xf32>756 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xvector<8xf32>>, vector<8xf32>757 vector.store %0, %memref[%i, %j] : memref<200x100xvector<8xf32>>, vector<8xf32>758 return759}760 761// CHECK-LABEL: @vector_load_and_store_scalable_vector_memref762func.func @vector_load_and_store_scalable_vector_memref(%v: vector<[4]xi32>, %m: memref<?xi32>) -> vector<[4]xi32> {763 %c0 = arith.constant 0 : index764 // CHECK: vector.load {{.*}}: memref<?xi32>, vector<[4]xi32>765 %0 = vector.load %m[%c0] : memref<?xi32>, vector<[4]xi32>766 // CHECK: vector.store {{.*}}: memref<?xi32>, vector<[4]xi32>767 vector.store %v, %m[%c0] : memref<?xi32>, vector<[4]xi32>768 return %0 : vector<[4]xi32>769}770 771func.func @vector_load_and_store_1d_scalable_vector_memref(%memref : memref<200x100xvector<8xf32>>,772 %i : index, %j : index) {773 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xvector<8xf32>>, vector<8xf32>774 %0 = vector.load %memref[%i, %j] : memref<200x100xvector<8xf32>>, vector<8xf32>775 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xvector<8xf32>>, vector<8xf32>776 vector.store %0, %memref[%i, %j] : memref<200x100xvector<8xf32>>, vector<8xf32>777 return778}779 780// CHECK-LABEL: @vector_load_and_store_out_of_bounds781func.func @vector_load_and_store_out_of_bounds(%memref : memref<7xf32>) {782 %c0 = arith.constant 0 : index783 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<7xf32>, vector<8xf32>784 %0 = vector.load %memref[%c0] : memref<7xf32>, vector<8xf32>785 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<7xf32>, vector<8xf32>786 vector.store %0, %memref[%c0] : memref<7xf32>, vector<8xf32>787 return788}789 790// CHECK-LABEL: @vector_load_and_store_2d_scalar_memref791func.func @vector_load_and_store_2d_scalar_memref(%memref : memref<200x100xf32>,792 %i : index, %j : index) {793 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xf32>, vector<4x8xf32>794 %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<4x8xf32>795 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xf32>, vector<4x8xf32>796 vector.store %0, %memref[%i, %j] : memref<200x100xf32>, vector<4x8xf32>797 return798}799 800// CHECK-LABEL: @vector_load_and_store_2d_vector_memref801func.func @vector_load_and_store_2d_vector_memref(%memref : memref<200x100xvector<4x8xf32>>,802 %i : index, %j : index) {803 // CHECK: %[[ld:.*]] = vector.load %{{.*}}[%{{.*}}] : memref<200x100xvector<4x8xf32>>, vector<4x8xf32>804 %0 = vector.load %memref[%i, %j] : memref<200x100xvector<4x8xf32>>, vector<4x8xf32>805 // CHECK: vector.store %[[ld]], %{{.*}}[%{{.*}}] : memref<200x100xvector<4x8xf32>>, vector<4x8xf32>806 vector.store %0, %memref[%i, %j] : memref<200x100xvector<4x8xf32>>, vector<4x8xf32>807 return808}809 810// CHECK-LABEL: func @load_store_alignment811func.func @load_store_alignment(%memref: memref<4xi32>) {812 %c0 = arith.constant 0 : index813 // CHECK: vector.load {{.*}} {alignment = 16 : i64}814 %val = vector.load %memref[%c0] { alignment = 16 } : memref<4xi32>, vector<4xi32>815 // CHECK: vector.store {{.*}} {alignment = 16 : i64}816 vector.store %val, %memref[%c0] { alignment = 16 } : memref<4xi32>, vector<4xi32>817 return818}819 820// CHECK-LABEL: @masked_load_and_store821func.func @masked_load_and_store(%base: memref<?xf32>, %mask: vector<16xi1>, %passthru: vector<16xf32>) {822 %c0 = arith.constant 0 : index823 // CHECK: %[[X:.*]] = vector.maskedload %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}} : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>824 %0 = vector.maskedload %base[%c0], %mask, %passthru : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>825 // CHECK: vector.maskedstore %{{.*}}[%{{.*}}], %{{.*}}, %[[X]] : memref<?xf32>, vector<16xi1>, vector<16xf32>826 vector.maskedstore %base[%c0], %mask, %0 : memref<?xf32>, vector<16xi1>, vector<16xf32>827 return828}829 830// CHECK-LABEL: @masked_load_and_store2d831func.func @masked_load_and_store2d(%base: memref<?x?xf32>, %mask: vector<16xi1>, %passthru: vector<16xf32>) {832 %c0 = arith.constant 0 : index833 // CHECK: %[[X:.*]] = vector.maskedload %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}, %{{.*}} : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>834 %0 = vector.maskedload %base[%c0, %c0], %mask, %passthru : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>835 // CHECK: vector.maskedstore %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}, %[[X]] : memref<?x?xf32>, vector<16xi1>, vector<16xf32>836 vector.maskedstore %base[%c0, %c0], %mask, %0 : memref<?x?xf32>, vector<16xi1>, vector<16xf32>837 return838}839 840// CHECK-LABEL: @gather_and_scatter841func.func @gather_and_scatter(%base: memref<?xf32>, %v: vector<16xi32>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) {842 %c0 = arith.constant 0 : index843 // CHECK: %[[X:.*]] = vector.gather %{{.*}}[%{{.*}}] [%{{.*}}], %{{.*}}, %{{.*}} : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>844 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>845 // CHECK: vector.scatter %{{.*}}[%{{.*}}] [%{{.*}}], %{{.*}}, %[[X]] : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32>846 vector.scatter %base[%c0][%v], %mask, %0 : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32>847 return848}849 850// CHECK-LABEL: @gather_and_scatter2d851func.func @gather_and_scatter2d(%base: memref<?x?xf32>, %v: vector<16xi32>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) {852 %c0 = arith.constant 0 : index853 // CHECK: %[[X:.*]] = vector.gather %{{.*}}[%{{.*}}, %{{.*}}] [%{{.*}}], %{{.*}}, %{{.*}} : memref<?x?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>854 %0 = vector.gather %base[%c0, %c0][%v], %mask, %pass_thru : memref<?x?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>855 // CHECK: vector.scatter %{{.*}}[%{{.*}}] [%{{.*}}], %{{.*}}, %[[X]] : memref<?x?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32>856 vector.scatter %base[%c0, %c0][%v], %mask, %0 : memref<?x?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32>857 return858}859 860// CHECK-LABEL: @gather_and_scatter_multi_dims861func.func @gather_and_scatter_multi_dims(%base: memref<?xf32>, %v: vector<2x16xi32>, %mask: vector<2x16xi1>, %pass_thru: vector<2x16xf32>) -> vector<2x16xf32> {862 %c0 = arith.constant 0 : index863 // CHECK: %[[X:.*]] = vector.gather %{{.*}}[%{{.*}}] [%{{.*}}], %{{.*}}, %{{.*}} : memref<?xf32>, vector<2x16xi32>, vector<2x16xi1>, vector<2x16xf32> into vector<2x16xf32>864 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : memref<?xf32>, vector<2x16xi32>, vector<2x16xi1>, vector<2x16xf32> into vector<2x16xf32>865 // CHECK: vector.scatter %{{.*}}[%{{.*}}] [%{{.*}}], %{{.*}}, %[[X]] : memref<?xf32>, vector<2x16xi32>, vector<2x16xi1>, vector<2x16xf32>866 vector.scatter %base[%c0][%v], %mask, %0 : memref<?xf32>, vector<2x16xi32>, vector<2x16xi1>, vector<2x16xf32>867 return %0 : vector<2x16xf32>868}869 870// CHECK-LABEL: @gather_on_tensor871func.func @gather_on_tensor(%base: tensor<?xf32>, %v: vector<16xi32>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) -> vector<16xf32> {872 %c0 = arith.constant 0 : index873 // CHECK: vector.gather %{{.*}}[%{{.*}}] [%{{.*}}], %{{.*}}, %{{.*}} : tensor<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>874 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : tensor<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>875 return %0 : vector<16xf32>876}877 878// CHECK-LABEL: @expand_and_compress879func.func @expand_and_compress(%base: memref<?xf32>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) {880 %c0 = arith.constant 0 : index881 // CHECK: %[[X:.*]] = vector.expandload %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}} : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>882 %0 = vector.expandload %base[%c0], %mask, %pass_thru : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>883 // CHECK: vector.compressstore %{{.*}}[%{{.*}}], %{{.*}}, %[[X]] : memref<?xf32>, vector<16xi1>, vector<16xf32>884 vector.compressstore %base[%c0], %mask, %0 : memref<?xf32>, vector<16xi1>, vector<16xf32>885 return886}887 888// CHECK-LABEL: @expand_and_compress2d889func.func @expand_and_compress2d(%base: memref<?x?xf32>, %mask: vector<16xi1>, %pass_thru: vector<16xf32>) {890 %c0 = arith.constant 0 : index891 // CHECK: %[[X:.*]] = vector.expandload %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}, %{{.*}} : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>892 %0 = vector.expandload %base[%c0, %c0], %mask, %pass_thru : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>893 // CHECK: vector.compressstore %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}, %[[X]] : memref<?x?xf32>, vector<16xi1>, vector<16xf32>894 vector.compressstore %base[%c0, %c0], %mask, %0 : memref<?x?xf32>, vector<16xi1>, vector<16xf32>895 return896}897 898// CHECK-LABEL: @multi_reduction899func.func @multi_reduction(%0: vector<4x8x16x32xf32>, %acc0: vector<4x16xf32>,900 %acc1: f32) -> f32 {901 // CHECK: vector.multi_reduction <add>, %{{.*}}, %{{.*}} [1, 3] : vector<4x8x16x32xf32> to vector<4x16xf32>902 %1 = vector.multi_reduction <add>, %0, %acc0 [1, 3] :903 vector<4x8x16x32xf32> to vector<4x16xf32>904 // CHECK: vector.multi_reduction <add>, %{{.*}}, %{{.*}} [0, 1] : vector<4x16xf32> to f32905 %2 = vector.multi_reduction <add>, %1, %acc1 [0, 1] :906 vector<4x16xf32> to f32907 return %2 : f32908}909 910// CHECK-LABEL: @get_vector_scale911func.func @get_vector_scale() -> index {912 // CHECK: vector.vscale913 %0 = vector.vscale914 return %0 : index915}916 917// CHECK-LABEL: @vector_scan918func.func @vector_scan(%0: vector<4x8x16x32xf32>) -> vector<4x8x16x32xf32> {919 %1 = arith.constant dense<0.0> : vector<4x16x32xf32>920 %2:2 = vector.scan <add>, %0, %1 {reduction_dim = 1 : i64, inclusive = true} :921 vector<4x8x16x32xf32>, vector<4x16x32xf32>922 return %2#0 : vector<4x8x16x32xf32>923}924 925// CHECK-LABEL: func @vector_mask926func.func @vector_mask(%a: vector<8xi32>, %m0: vector<8xi1>) -> i32 {927// CHECK-NEXT: %{{.*}} = vector.mask %{{.*}} { vector.reduction <add>, %{{.*}} : vector<8xi32> into i32 } : vector<8xi1> -> i32928 %0 = vector.mask %m0 { vector.reduction <add>, %a : vector<8xi32> into i32 } : vector<8xi1> -> i32929 return %0 : i32930}931 932// CHECK-LABEL: func @vector_mask_passthru933func.func @vector_mask_passthru(%t0: tensor<?xf32>, %idx: index, %m0: vector<16xi1>, %pt0: vector<16xf32>) -> vector<16xf32> {934 %ft0 = arith.constant 0.0 : f32935// CHECK: %{{.*}} = vector.mask %{{.*}}, %{{.*}} { vector.transfer_read %{{.*}}[%{{.*}}], %{{.*}} : tensor<?xf32>, vector<16xf32> } : vector<16xi1> -> vector<16xf32>936 %0 = vector.mask %m0, %pt0 { vector.transfer_read %t0[%idx], %ft0 : tensor<?xf32>, vector<16xf32> } : vector<16xi1> -> vector<16xf32>937 return %0 : vector<16xf32>938}939 940// CHECK-LABEL: func @vector_mask_no_return941func.func @vector_mask_no_return(%val: vector<16xf32>, %t0: memref<?xf32>, %idx: index, %m0: vector<16xi1>) {942// CHECK-NEXT: vector.mask %{{.*}} { vector.transfer_write %{{.*}}, %{{.*}}[%{{.*}}] : vector<16xf32>, memref<?xf32> } : vector<16xi1>943 vector.mask %m0 { vector.transfer_write %val, %t0[%idx] : vector<16xf32>, memref<?xf32> } : vector<16xi1>944 return945}946 947// CHECK-LABEL: func @vector_mask_tensor_return948func.func @vector_mask_tensor_return(%val: vector<16xf32>, %t0: tensor<?xf32>, %idx: index, %m0: vector<16xi1>) {949// CHECK-NEXT: vector.mask %{{.*}} { vector.transfer_write %{{.*}}, %{{.*}}[%{{.*}}] : vector<16xf32>, tensor<?xf32> } : vector<16xi1> -> tensor<?xf32>950 vector.mask %m0 { vector.transfer_write %val, %t0[%idx] : vector<16xf32>, tensor<?xf32> } : vector<16xi1> -> tensor<?xf32>951 return952}953 954// CHECK-LABEL: func @vector_mask_empty955func.func @vector_mask_empty(%m0: vector<16xi1>) {956// CHECK: vector.mask %{{.*}} { vector.yield } : vector<16xi1>957 vector.mask %m0 { } : vector<16xi1>958 return959}960 961// CHECK-LABEL: func @vector_mask_empty_with_yield962func.func @vector_mask_empty_with_yield(%m0: vector<16xi1>) {963// CHECK: vector.mask %{{.*}} { vector.yield } : vector<16xi1>964 vector.mask %m0 { vector.yield } : vector<16xi1>965 return966}967 968// CHECK-LABEL: func @vector_mask_empty_return969func.func @vector_mask_empty_return(%m0: vector<16xi1>, %arg0: vector<16xf32>) -> vector<16xf32> {970// CHECK: vector.mask %{{.*}} { vector.yield {{.*}} : vector<16xf32> } : vector<16xi1> -> vector<16xf32>971 %0 = vector.mask %m0 { vector.yield %arg0 : vector<16xf32> } : vector<16xi1> -> vector<16xf32>972 return %0 : vector<16xf32>973}974 975// CHECK-LABEL: func @vector_mask_scalar_broadcast_transfer976func.func @vector_mask_scalar_broadcast_transfer(%arg0: tensor<2x4xi32>,977 %idx0: index, %idx1: index,978 %m0: vector<1xi1>) -> vector<1x1x4xi32> {979 %cst = arith.constant 0 : i32980 // CHECK: vector.mask %{{.*}} { vector.transfer_read {{.*}} } : vector<1xi1> -> vector<1x1x4xi32>981 %res = vector.mask %m0 {982 %0 = vector.transfer_read %arg0[%idx0, %idx1], %cst {permutation_map = affine_map<(d0, d1) -> (0, 0, 0)>}983 : tensor<2x4xi32>, vector<1x1x4xi32>984 vector.yield %0 : vector<1x1x4xi32>985 } : vector<1xi1> -> vector<1x1x4xi32>986 return %res : vector<1x1x4xi32>987}988 989// CHECK-LABEL: func @vector_scalable_insert(990// CHECK-SAME: %[[SUB0:.*]]: vector<4xi32>, %[[SUB1:.*]]: vector<8xi32>,991// CHECK-SAME: %[[SUB2:.*]]: vector<[4]xi32>, %[[SV:.*]]: vector<[8]xi32>992func.func @vector_scalable_insert(%sub0: vector<4xi32>, %sub1: vector<8xi32>,993 %sub2: vector<[4]xi32>, %sv: vector<[8]xi32>) {994 // CHECK-NEXT: vector.scalable.insert %[[SUB0]], %[[SV]][12] : vector<4xi32> into vector<[8]xi32>995 %0 = vector.scalable.insert %sub0, %sv[12] : vector<4xi32> into vector<[8]xi32>996 // CHECK-NEXT: vector.scalable.insert %[[SUB1]], %[[SV]][0] : vector<8xi32> into vector<[8]xi32>997 %1 = vector.scalable.insert %sub1, %sv[0] : vector<8xi32> into vector<[8]xi32>998 // CHECK-NEXT: vector.scalable.insert %[[SUB2]], %[[SV]][0] : vector<[4]xi32> into vector<[8]xi32>999 %2 = vector.scalable.insert %sub2, %sv[0] : vector<[4]xi32> into vector<[8]xi32>1000 return1001 }1002 1003// CHECK-LABEL: func @vector_scalable_extract(1004// CHECK-SAME: %[[SV:.*]]: vector<[8]xi32>1005func.func @vector_scalable_extract(%sv: vector<[8]xi32>) {1006 // CHECK-NEXT: vector.scalable.extract %[[SV]][0] : vector<16xi32> from vector<[8]xi32>1007 %0 = vector.scalable.extract %sv[0] : vector<16xi32> from vector<[8]xi32>1008 // CHECK-NEXT: vector.scalable.extract %[[SV]][0] : vector<[4]xi32> from vector<[8]xi32>1009 %1 = vector.scalable.extract %sv[0] : vector<[4]xi32> from vector<[8]xi32>1010 // CHECK-NEXT: vector.scalable.extract %[[SV]][4] : vector<4xi32> from vector<[8]xi32>1011 %2 = vector.scalable.extract %sv[4] : vector<4xi32> from vector<[8]xi32>1012 return1013 }1014 1015#matmat_accesses = [1016 affine_map<(i, j, k) -> (i, k)>,1017 affine_map<(i, j, k) -> (k, j)>,1018 affine_map<(i, j, k) -> (i, j)>1019]1020#matmat_trait = {1021 indexing_maps = #matmat_accesses,1022 iterator_types = ["parallel", "parallel", "reduction"]1023}1024// CHECK-LABEL: func.func @contraction_masked_scalable(1025// CHECK-SAME: %[[A:.*]]: vector<3x4xf32>,1026// CHECK-SAME: %[[B:.*]]: vector<4x[8]xf32>,1027// CHECK-SAME: %[[C:.*]]: vector<3x[8]xf32>,1028// CHECK-SAME: %[[M:.*]]: vector<3x[8]x4xi1>) -> vector<3x[8]xf32> {1029func.func @contraction_masked_scalable(%A: vector<3x4xf32>,1030 %B: vector<4x[8]xf32>,1031 %C: vector<3x[8]xf32>,1032 %M : vector<3x[8]x4xi1>) -> vector<3x[8]xf32> {1033 // CHECK: vector.mask %[[M]] { vector.contract {indexing_maps = [#{{.*}}, #{{.*}}, #{{.*}}], iterator_types = ["parallel", "parallel", "reduction"], kind = #vector.kind<add>} %[[A]], %[[B]], %[[C]] : vector<3x4xf32>, vector<4x[8]xf32> into vector<3x[8]xf32> } : vector<3x[8]x4xi1> -> vector<3x[8]xf32>1034 %0 = vector.mask %M { vector.contract #matmat_trait %A, %B, %C : vector<3x4xf32>, vector<4x[8]xf32> into vector<3x[8]xf32> }1035 : vector<3x[8]x4xi1> -> vector<3x[8]xf32>1036 return %0 : vector<3x[8]xf32>1037}1038 1039// CHECK-LABEL: func.func @fastmath(1040func.func @fastmath(%x: vector<42xf32>) -> f32 {1041 // CHECK: vector.reduction <minnumf>, %{{.*}} fastmath<reassoc,nnan,ninf>1042 %min = vector.reduction <minnumf>, %x fastmath<reassoc,nnan,ninf> : vector<42xf32> into f321043 return %min: f321044}1045 1046// CHECK-LABEL: @interleave_0d1047func.func @interleave_0d(%a: vector<f32>, %b: vector<f32>) -> vector<2xf32> {1048 // CHECK: vector.interleave %{{.*}}, %{{.*}} : vector<f32> -> vector<2xf32>1049 %0 = vector.interleave %a, %b : vector<f32> -> vector<2xf32>1050 return %0 : vector<2xf32>1051}1052 1053// CHECK-LABEL: @interleave_1d1054func.func @interleave_1d(%a: vector<4xf32>, %b: vector<4xf32>) -> vector<8xf32> {1055 // CHECK: vector.interleave %{{.*}}, %{{.*}} : vector<4xf32>1056 %0 = vector.interleave %a, %b : vector<4xf32> -> vector<8xf32>1057 return %0 : vector<8xf32>1058}1059 1060// CHECK-LABEL: @interleave_1d_scalable1061func.func @interleave_1d_scalable(%a: vector<[8]xi16>, %b: vector<[8]xi16>) -> vector<[16]xi16> {1062 // CHECK: vector.interleave %{{.*}}, %{{.*}} : vector<[8]xi16>1063 %0 = vector.interleave %a, %b : vector<[8]xi16> -> vector<[16]xi16>1064 return %0 : vector<[16]xi16>1065}1066 1067// CHECK-LABEL: @interleave_2d1068func.func @interleave_2d(%a: vector<2x8xf32>, %b: vector<2x8xf32>) -> vector<2x16xf32> {1069 // CHECK: vector.interleave %{{.*}}, %{{.*}} : vector<2x8xf32>1070 %0 = vector.interleave %a, %b : vector<2x8xf32> -> vector<2x16xf32>1071 return %0 : vector<2x16xf32>1072}1073 1074// CHECK-LABEL: @interleave_2d_scalable1075func.func @interleave_2d_scalable(%a: vector<2x[2]xf64>, %b: vector<2x[2]xf64>) -> vector<2x[4]xf64> {1076 // CHECK: vector.interleave %{{.*}}, %{{.*}} : vector<2x[2]xf64>1077 %0 = vector.interleave %a, %b : vector<2x[2]xf64> -> vector<2x[4]xf64>1078 return %0 : vector<2x[4]xf64>1079}1080 1081// CHECK-LABEL: @deinterleave_1d1082func.func @deinterleave_1d(%arg: vector<4xf32>) -> (vector<2xf32>, vector<2xf32>) {1083 // CHECK: vector.deinterleave %{{.*}} : vector<4xf32> -> vector<2xf32>1084 %0, %1 = vector.deinterleave %arg : vector<4xf32> -> vector<2xf32>1085 return %0, %1 : vector<2xf32>, vector<2xf32>1086}1087 1088// CHECK-LABEL: @deinterleave_1d_scalable1089func.func @deinterleave_1d_scalable(%arg: vector<[4]xf32>) -> (vector<[2]xf32>, vector<[2]xf32>) {1090 // CHECK: vector.deinterleave %{{.*}} : vector<[4]xf32> -> vector<[2]xf32>1091 %0, %1 = vector.deinterleave %arg : vector<[4]xf32> -> vector<[2]xf32>1092 return %0, %1 : vector<[2]xf32>, vector<[2]xf32>1093}1094 1095// CHECK-LABEL: @deinterleave_2d1096func.func @deinterleave_2d(%arg: vector<3x4xf32>) -> (vector<3x2xf32>, vector<3x2xf32>) {1097 // CHECK: vector.deinterleave %{{.*}} : vector<3x4xf32> -> vector<3x2xf32>1098 %0, %1 = vector.deinterleave %arg : vector<3x4xf32> -> vector<3x2xf32>1099 return %0, %1 : vector<3x2xf32>, vector<3x2xf32>1100}1101 1102// CHECK-LABEL: @deinterleave_2d_scalable1103func.func @deinterleave_2d_scalable(%arg: vector<3x[4]xf32>) -> (vector<3x[2]xf32>, vector<3x[2]xf32>) {1104 // CHECK: vector.deinterleave %{{.*}} : vector<3x[4]xf32> -> vector<3x[2]xf32>1105 %0, %1 = vector.deinterleave %arg : vector<3x[4]xf32> -> vector<3x[2]xf32>1106 return %0, %1 : vector<3x[2]xf32>, vector<3x[2]xf32>1107}1108 1109// CHECK-LABEL: @deinterleave_nd1110func.func @deinterleave_nd(%arg: vector<2x3x4x6xf32>) -> (vector<2x3x4x3xf32>, vector<2x3x4x3xf32>) {1111 // CHECK: vector.deinterleave %{{.*}} : vector<2x3x4x6xf32> -> vector<2x3x4x3xf32>1112 %0, %1 = vector.deinterleave %arg : vector<2x3x4x6xf32> -> vector<2x3x4x3xf32>1113 return %0, %1 : vector<2x3x4x3xf32>, vector<2x3x4x3xf32>1114}1115 1116// CHECK-LABEL: @deinterleave_nd_scalable1117func.func @deinterleave_nd_scalable(%arg:vector<2x3x4x[6]xf32>) -> (vector<2x3x4x[3]xf32>, vector<2x3x4x[3]xf32>) {1118 // CHECK: vector.deinterleave %{{.*}} : vector<2x3x4x[6]xf32> -> vector<2x3x4x[3]xf32>1119 %0, %1 = vector.deinterleave %arg : vector<2x3x4x[6]xf32> -> vector<2x3x4x[3]xf32>1120 return %0, %1 : vector<2x3x4x[3]xf32>, vector<2x3x4x[3]xf32>1121}1122 1123// CHECK-LABEL: func @to_elements(1124// CHECK-SAME: %[[A_VEC:.*]]: vector<f32>, %[[B_VEC:.*]]: vector<1xf32>,1125// CHECK-SAME: %[[C_VEC:.*]]: vector<1x2xf32>, %[[D_VEC:.*]]: vector<2x2xf32>)1126func.func @to_elements(%a_vec : vector<f32>, %b_vec : vector<1xf32>,1127 %c_vec : vector<1x2xf32>, %d_vec : vector<2x2xf32>)1128 -> (f32, f32, f32, f32, f32, f32, f32, f32) {1129 // CHECK: %[[A_ELEMS:.*]] = vector.to_elements %[[A_VEC]] : vector<f32>1130 %0 = vector.to_elements %a_vec : vector<f32>1131 // CHECK: %[[B_ELEMS:.*]] = vector.to_elements %[[B_VEC]] : vector<1xf32>1132 %1 = vector.to_elements %b_vec : vector<1xf32>1133 // CHECK: %[[C_ELEMS:.*]]:2 = vector.to_elements %[[C_VEC]] : vector<1x2xf32>1134 %2:2 = vector.to_elements %c_vec : vector<1x2xf32>1135 // CHECK: %[[D_ELEMS:.*]]:4 = vector.to_elements %[[D_VEC]] : vector<2x2xf32>1136 %3:4 = vector.to_elements %d_vec : vector<2x2xf32>1137 // CHECK: return %[[A_ELEMS]], %[[B_ELEMS]], %[[C_ELEMS]]#0, %[[C_ELEMS]]#1, %[[D_ELEMS]]#0, %[[D_ELEMS]]#1, %[[D_ELEMS]]#2, %[[D_ELEMS]]#31138 return %0, %1, %2#0, %2#1, %3#0, %3#1, %3#2, %3#3: f32, f32, f32, f32, f32, f32, f32, f321139}1140 1141// CHECK-LABEL: func @from_elements(1142// CHECK-SAME: %[[a:.*]]: f32, %[[b:.*]]: f32)1143func.func @from_elements(%a: f32, %b: f32) -> (vector<f32>, vector<1xf32>, vector<1x2xf32>, vector<2x2xf32>) {1144 // CHECK: vector.from_elements %[[a]] : vector<f32>1145 %0 = vector.from_elements %a : vector<f32>1146 // CHECK: vector.from_elements %[[a]] : vector<1xf32>1147 %1 = vector.from_elements %a : vector<1xf32>1148 // CHECK: vector.from_elements %[[a]], %[[b]] : vector<1x2xf32>1149 %2 = vector.from_elements %a, %b : vector<1x2xf32>1150 // CHECK: vector.from_elements %[[b]], %[[b]], %[[a]], %[[a]] : vector<2x2xf32>1151 %3 = vector.from_elements %b, %b, %a, %a : vector<2x2xf32>1152 return %0, %1, %2, %3 : vector<f32>, vector<1xf32>, vector<1x2xf32>, vector<2x2xf32>1153}1154 1155// CHECK-LABEL: @step1156func.func @step() {1157 // CHECK: vector.step : vector<2xindex>1158 %0 = vector.step : vector<2xindex>1159 // CHECK: vector.step : vector<[4]xindex>1160 %1 = vector.step : vector<[4]xindex>1161 return1162}1163 1164// CHECK-LABEL: func @scatter_tensor(1165// CHECK-SAME: %[[BASE:.*]]: tensor<16x16xf32>, %[[V:.*]]: vector<16xi32>,1166// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>, %[[VALUE:.*]]: vector<16xf32>) -> tensor<16x16xf32>1167func.func @scatter_tensor(%base: tensor<16x16xf32>, %v: vector<16xi32>, 1168 %mask: vector<16xi1>, %value: vector<16xf32>) -> tensor<16x16xf32> {1169 // CHECK: %[[C0:.*]] = arith.constant 0 : index1170 %c0 = arith.constant 0 : index1171 // CHECK: %[[RESULT:.*]] = vector.scatter %[[BASE]][%[[C0]], %[[C0]]] [%[[V]]], %[[MASK]], %[[VALUE]]1172 %0 = vector.scatter %base[%c0, %c0] [%v], %mask, %value1173 : tensor<16x16xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> -> tensor<16x16xf32>1174 // CHECK: return %[[RESULT]] : tensor<16x16xf32>1175 return %0 : tensor<16x16xf32>1176}1177