brintos / llvm-project-archived public Read only

1// RUN: mlir-opt --convert-to-llvm="filter-dialects=vector" --split-input-file %s | FileCheck %s2// RUN: mlir-opt --convert-to-llvm="filter-dialects=vector allow-pattern-rollback=0" --split-input-file %s | FileCheck %s3// RUN: mlir-opt %s -convert-vector-to-llvm -split-input-file | FileCheck %s4 5//===========================================================================//6// Basic tests for Vector-to-LLVM conversion7//8// These examples are meant to be convertible to LLVM with:9//  * `populateVectorToLLVMConversionPatterns`,10// i.e. no other patterns should be required.11//===========================================================================//12 13//===----------------------------------------------------------------------===//14// vector.bitcast15//===----------------------------------------------------------------------===//16 17func.func @bitcast_f32_to_i32_vector_0d(%arg0: vector<f32>) -> vector<i32> {18  %0 = vector.bitcast %arg0 : vector<f32> to vector<i32>19  return %0 : vector<i32>20}21 22// CHECK-LABEL: @bitcast_f32_to_i32_vector_0d23// CHECK-SAME:  %[[ARG_0:.*]]: vector<f32>24// CHECK:       %[[VEC_F32_1D:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : vector<f32> to vector<1xf32>25// CHECK:       %[[VEC_I32_1D:.*]] = llvm.bitcast %[[VEC_F32_1D]] : vector<1xf32> to vector<1xi32>26// CHECK:       %[[VEC_I32_0D:.*]] = builtin.unrealized_conversion_cast %[[VEC_I32_1D]] : vector<1xi32> to vector<i32>27// CHECK:       return %[[VEC_I32_0D]] : vector<i32>28 29// -----30 31func.func @bitcast_f32_to_i32_vector(%arg0: vector<16xf32>) -> vector<16xi32> {32  %0 = vector.bitcast %arg0 : vector<16xf32> to vector<16xi32>33  return %0 : vector<16xi32>34}35 36 37// CHECK-LABEL: @bitcast_f32_to_i32_vector38// CHECK-SAME:  %[[ARG_0:.*]]: vector<16xf32>39// CHECK:       llvm.bitcast %[[ARG_0]] : vector<16xf32> to vector<16xi32>40 41// -----42 43func.func @bitcast_f32_to_i32_vector_scalable(%arg0: vector<[16]xf32>) -> vector<[16]xi32> {44  %0 = vector.bitcast %arg0 : vector<[16]xf32> to vector<[16]xi32>45  return %0 : vector<[16]xi32>46}47 48// CHECK-LABEL: @bitcast_f32_to_i32_vector_scalable49// CHECK-SAME:  %[[ARG_0:.*]]: vector<[16]xf32>50// CHECK:       llvm.bitcast %[[ARG_0]] : vector<[16]xf32> to vector<[16]xi32>51 52// -----53 54func.func @bitcast_i8_to_f32_vector(%arg0: vector<64xi8>) -> vector<16xf32> {55  %0 = vector.bitcast %arg0 : vector<64xi8> to vector<16xf32>56  return %0 : vector<16xf32>57}58 59// CHECK-LABEL: @bitcast_i8_to_f32_vector60// CHECK-SAME:  %[[ARG_0:.*]]: vector<64xi8>61// CHECK:       llvm.bitcast %[[ARG_0]] : vector<64xi8> to vector<16xf32>62 63// -----64 65func.func @bitcast_i8_to_f32_vector_scalable(%arg0: vector<[64]xi8>) -> vector<[16]xf32> {66  %0 = vector.bitcast %arg0 : vector<[64]xi8> to vector<[16]xf32>67  return %0 : vector<[16]xf32>68}69 70// CHECK-LABEL: @bitcast_i8_to_f32_vector_scalable71// CHECK-SAME:  %[[ARG_0:.*]]: vector<[64]xi8>72// CHECK:       llvm.bitcast %[[ARG_0]] : vector<[64]xi8> to vector<[16]xf32>73 74// -----75 76func.func @bitcast_index_to_i8_vector(%arg0: vector<16xindex>) -> vector<128xi8> {77  %0 = vector.bitcast %arg0 : vector<16xindex> to vector<128xi8>78  return %0 : vector<128xi8>79}80 81// CHECK-LABEL: @bitcast_index_to_i8_vector82// CHECK-SAME:  %[[ARG_0:.*]]: vector<16xindex>83// CHECK:       %[[T0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : vector<16xindex> to vector<16xi64>84// CHECK:       llvm.bitcast %[[T0]] : vector<16xi64> to vector<128xi8>85 86// -----87 88func.func @bitcast_index_to_i8_vector_scalable(%arg0: vector<[16]xindex>) -> vector<[128]xi8> {89  %0 = vector.bitcast %arg0 : vector<[16]xindex> to vector<[128]xi8>90  return %0 : vector<[128]xi8>91}92 93// CHECK-LABEL: @bitcast_index_to_i8_vector_scalable94// CHECK-SAME:  %[[ARG_0:.*]]: vector<[16]xindex>95// CHECK:       %[[T0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : vector<[16]xindex> to vector<[16]xi64>96// CHECK:       llvm.bitcast %[[T0]] : vector<[16]xi64> to vector<[128]xi8>97 98// -----99 100//===----------------------------------------------------------------------===//101// vector.broadcast102//===----------------------------------------------------------------------===//103 104func.func @broadcast_vec0d_from_vec0d(%arg0: vector<f32>) -> vector<f32> {105  %0 = vector.broadcast %arg0 : vector<f32> to vector<f32>106  return %0 : vector<f32>107}108// CHECK-LABEL: @broadcast_vec0d_from_vec0d(109// CHECK-SAME:  %[[A:.*]]: vector<f32>)110// CHECK:       return %[[A]] : vector<f32>111 112// -----113 114func.func @broadcast_vec1d_from_vec1d(%arg0: vector<2xf32>) -> vector<2xf32> {115  %0 = vector.broadcast %arg0 : vector<2xf32> to vector<2xf32>116  return %0 : vector<2xf32>117}118// CHECK-LABEL: @broadcast_vec1d_from_vec1d(119// CHECK-SAME:  %[[A:.*]]: vector<2xf32>)120// CHECK:       return %[[A]] : vector<2xf32>121 122// -----123 124func.func @broadcast_vec1d_from_vec1d_scalable(%arg0: vector<[2]xf32>) -> vector<[2]xf32> {125  %0 = vector.broadcast %arg0 : vector<[2]xf32> to vector<[2]xf32>126  return %0 : vector<[2]xf32>127}128// CHECK-LABEL: @broadcast_vec1d_from_vec1d_scalable(129// CHECK-SAME:  %[[A:.*]]: vector<[2]xf32>)130// CHECK:       return %[[A]] : vector<[2]xf32>131 132// -----133 134// CHECK-LABEL: @broadcast_vec0d_from_scalar135// CHECK-SAME: %[[ELT:.*]]: f32136func.func @broadcast_vec0d_from_scalar(%elt: f32) -> vector<f32> {137  %v = vector.broadcast %elt : f32 to vector<f32>138  return %v : vector<f32>139}140// CHECK-NEXT: %[[UNDEF:[0-9]+]] = llvm.mlir.poison : vector<1xf32>141// CHECK-NEXT: %[[ZERO:[0-9]+]] = llvm.mlir.constant(0 : i32) : i32142// CHECK-NEXT: %[[V:[0-9]+]] = llvm.insertelement %[[ELT]], %[[UNDEF]][%[[ZERO]] : i32] : vector<1xf32>143// CHECK-NEXT: %[[VCAST:[0-9]+]] = builtin.unrealized_conversion_cast %[[V]] : vector<1xf32> to vector<f32>144// CHECK-NEXT: return %[[VCAST]] : vector<f32>145 146// -----147 148// CHECK-LABEL: @broadcast_vec1d_from_scalar149// CHECK-SAME: %[[VEC:[0-9a-zA-Z]+]]: vector<4xf32>150// CHECK-SAME: %[[ELT:[0-9a-zA-Z]+]]: f32151func.func @broadcast_vec1d_from_scalar(%vec: vector<4xf32>, %elt: f32) -> vector<4xf32> {152  %vb = vector.broadcast %elt : f32 to vector<4xf32>153  return %vb : vector<4xf32>154}155// CHECK-NEXT: %[[UNDEF:[0-9]+]] = llvm.mlir.poison : vector<4xf32>156// CHECK-NEXT: %[[ZERO:[0-9]+]] = llvm.mlir.constant(0 : i32) : i32157// CHECK-NEXT: %[[V:[0-9]+]] = llvm.insertelement %[[ELT]], %[[UNDEF]][%[[ZERO]] : i32] : vector<4xf32>158// CHECK-NEXT: %[[SPLAT:[0-9]+]] = llvm.shufflevector %[[V]], %[[UNDEF]] [0, 0, 0, 0]159// CHECK-NEXT: return %[[SPLAT]] : vector<4xf32>160 161// -----162 163// CHECK-LABEL: @broadcast_scalable_vec1d_from_scalar164// CHECK-SAME: %[[VEC:[0-9a-zA-Z]+]]: vector<[4]xf32>165// CHECK-SAME: %[[ELT:[0-9a-zA-Z]+]]: f32166func.func @broadcast_scalable_vec1d_from_scalar(%vec: vector<[4]xf32>, %elt: f32) -> vector<[4]xf32> {167  %vb = vector.broadcast %elt : f32 to vector<[4]xf32>168  return %vb : vector<[4]xf32>169}170// CHECK-NEXT: %[[UNDEF:[0-9]+]] = llvm.mlir.poison : vector<[4]xf32>171// CHECK-NEXT: %[[ZERO:[0-9]+]] = llvm.mlir.constant(0 : i32) : i32172// CHECK-NEXT: %[[V:[0-9]+]] = llvm.insertelement %[[ELT]], %[[UNDEF]][%[[ZERO]] : i32] : vector<[4]xf32>173// CHECK-NEXT: %[[SPLAT:[0-9]+]] = llvm.shufflevector %[[V]], %[[UNDEF]] [0, 0, 0, 0]174// CHECK-NEXT: return %[[SPLAT]] : vector<[4]xf32>175 176//===----------------------------------------------------------------------===//177// vector.shuffle178//===----------------------------------------------------------------------===//179 180func.func @shuffle_0D_direct(%arg0: vector<f32>) -> vector<3xf32> {181  %1 = vector.shuffle %arg0, %arg0 [0, 1, 0] : vector<f32>, vector<f32>182  return %1 : vector<3xf32>183}184// CHECK-LABEL: @shuffle_0D_direct(185//  CHECK-SAME:     %[[A:.*]]: vector<f32>186//       CHECK:   %[[s:.*]] = llvm.shufflevector %{{.*}}, %{{.*}} [0, 1, 0] : vector<1xf32>187//       CHECK:   return %[[s]] : vector<3xf32>188 189// -----190 191func.func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> {192  %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32>193  return %1 : vector<2xf32>194}195// CHECK-LABEL: @shuffle_1D_direct(196// CHECK-SAME: %[[A:.*]]: vector<2xf32>,197// CHECK-SAME: %[[B:.*]]: vector<2xf32>)198//       CHECK:   return %[[A:.*]]: vector<2xf32>199 200// -----201 202func.func @shuffle_1D_index_direct(%arg0: vector<2xindex>, %arg1: vector<2xindex>) -> vector<2xindex> {203  %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xindex>, vector<2xindex>204  return %1 : vector<2xindex>205}206// CHECK-LABEL: @shuffle_1D_index_direct(207// CHECK-SAME: %[[A:.*]]: vector<2xindex>,208// CHECK-SAME: %[[B:.*]]: vector<2xindex>)209//       CHECK:   return  %[[A:.*]]: vector<2xindex>210 211// -----212 213func.func @shuffle_poison_mask(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<4xf32> {214  %1 = vector.shuffle %arg0, %arg1 [0, -1, 3, -1] : vector<2xf32>, vector<2xf32>215  return %1 : vector<4xf32>216}217// CHECK-LABEL: @shuffle_poison_mask(218//  CHECK-SAME:   %[[A:.*]]: vector<2xf32>, %[[B:.*]]: vector<2xf32>)219//       CHECK:     %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, -1, 3, -1] : vector<2xf32>220 221// -----222 223func.func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> {224  %1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32>225  return %1 : vector<5xf32>226}227// CHECK-LABEL: @shuffle_1D(228// CHECK-SAME: %[[A:.*]]: vector<2xf32>,229// CHECK-SAME: %[[B:.*]]: vector<3xf32>)230//       CHECK:   %[[U0:.*]] = llvm.mlir.poison : vector<5xf32>231//       CHECK:   %[[C2:.*]] = llvm.mlir.constant(2 : index) : i64232//       CHECK:   %[[E1:.*]] = llvm.extractelement %[[B]][%[[C2]] : i64] : vector<3xf32>233//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64234//       CHECK:   %[[I1:.*]] = llvm.insertelement %[[E1]], %[[U0]][%[[C0]] : i64] : vector<5xf32>235//       CHECK:   %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64236//       CHECK:   %[[E2:.*]] = llvm.extractelement %[[B]][%[[C1]] : i64] : vector<3xf32>237//       CHECK:   %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64238//       CHECK:   %[[I2:.*]] = llvm.insertelement %[[E2]], %[[I1]][%[[C1]] : i64] : vector<5xf32>239//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64240//       CHECK:   %[[E3:.*]] = llvm.extractelement %[[B]][%[[C0]] : i64] : vector<3xf32>241//       CHECK:   %[[C2:.*]] = llvm.mlir.constant(2 : index) : i64242//       CHECK:   %[[I3:.*]] = llvm.insertelement %[[E3]], %[[I2]][%[[C2]] : i64] : vector<5xf32>243//       CHECK:   %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64244//       CHECK:   %[[E4:.*]] = llvm.extractelement %[[A]][%[[C1]] : i64] : vector<2xf32>245//       CHECK:   %[[C3:.*]] = llvm.mlir.constant(3 : index) : i64246//       CHECK:   %[[I4:.*]] = llvm.insertelement %[[E4]], %[[I3]][%[[C3]] : i64] : vector<5xf32>247//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64248//       CHECK:   %[[E5:.*]] = llvm.extractelement %[[A]][%[[C0]] : i64] : vector<2xf32>249//       CHECK:   %[[C4:.*]] = llvm.mlir.constant(4 : index) : i64250//       CHECK:   %[[I5:.*]] = llvm.insertelement %[[E5]], %[[I4]][%[[C4]] : i64] : vector<5xf32>251//       CHECK:   return %[[I5]] : vector<5xf32>252 253// -----254 255func.func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {256  %1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32>257  return %1 : vector<3x4xf32>258}259// CHECK-LABEL: @shuffle_2D(260// CHECK-SAME: %[[A:.*]]: vector<1x4xf32>,261// CHECK-SAME: %[[B:.*]]: vector<2x4xf32>)262//       CHECK-DAG:   %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>>263//       CHECK-DAG:   %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>>264//       CHECK:   %[[U0:.*]] = llvm.mlir.poison : !llvm.array<3 x vector<4xf32>>265//       CHECK:   %[[E1:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<4xf32>>266//       CHECK:   %[[I1:.*]] = llvm.insertvalue %[[E1]], %[[U0]][0] : !llvm.array<3 x vector<4xf32>>267//       CHECK:   %[[E2:.*]] = llvm.extractvalue %[[VAL_0]][0] : !llvm.array<1 x vector<4xf32>>268//       CHECK:   %[[I2:.*]] = llvm.insertvalue %[[E2]], %[[I1]][1] : !llvm.array<3 x vector<4xf32>>269//       CHECK:   %[[E3:.*]] = llvm.extractvalue %[[VAL_1]][1] : !llvm.array<2 x vector<4xf32>>270//       CHECK:   %[[I3:.*]] = llvm.insertvalue %[[E3]], %[[I2]][2] : !llvm.array<3 x vector<4xf32>>271//       CHECK:   %[[VAL_3:.*]] = builtin.unrealized_conversion_cast %[[I3]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32>272//       CHECK:   return %[[VAL_3]] : vector<3x4xf32>273 274// -----275 276//===----------------------------------------------------------------------===//277// vector.extract278//===----------------------------------------------------------------------===//279 280func.func @extract_scalar_from_vec_1d_f32(%arg0: vector<16xf32>) -> f32 {281  %0 = vector.extract %arg0[15]: f32 from vector<16xf32>282  return %0 : f32283}284// CHECK-LABEL: @extract_scalar_from_vec_1d_f32285//       CHECK:   llvm.mlir.constant(15 : i64) : i64286//       CHECK:   llvm.extractelement {{.*}}[{{.*}} : i64] : vector<16xf32>287//       CHECK:   return {{.*}} : f32288 289 290// -----291 292func.func @extract_scalar_from_vec_1d_f32_scalable(%arg0: vector<[16]xf32>) -> f32 {293  %0 = vector.extract %arg0[15]: f32 from vector<[16]xf32>294  return %0 : f32295}296// CHECK-LABEL: @extract_scalar_from_vec_1d_f32_scalable297//       CHECK:   llvm.mlir.constant(15 : i64) : i64298//       CHECK:   llvm.extractelement {{.*}}[{{.*}} : i64] : vector<[16]xf32>299//       CHECK:   return {{.*}} : f32300 301// -----302 303func.func @extract_vec_1e_from_vec_1d_f32(%arg0: vector<16xf32>) -> vector<1xf32> {304  %0 = vector.extract %arg0[15]: vector<1xf32> from vector<16xf32>305  return %0 : vector<1xf32>306}307// CHECK-LABEL: @extract_vec_1e_from_vec_1d_f32(308//  CHECK-SAME:   %[[A:.*]]: vector<16xf32>)309//       CHECK:   %[[T0:.*]] = llvm.mlir.constant(15 : i64) : i64310//       CHECK:   %[[T1:.*]] = llvm.extractelement %[[A]][%[[T0]] : i64] : vector<16xf32>311//       CHECK:   %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : f32 to vector<1xf32>312//       CHECK:   return %[[T2]] : vector<1xf32>313 314// -----315 316func.func @extract_vec_1e_from_vec_1d_f32_scalable(%arg0: vector<[16]xf32>) -> vector<1xf32> {317  %0 = vector.extract %arg0[15]: vector<1xf32> from vector<[16]xf32>318  return %0 : vector<1xf32>319}320// CHECK-LABEL: @extract_vec_1e_from_vec_1d_f32_scalable(321//  CHECK-SAME:   %[[A:.*]]: vector<[16]xf32>)322//       CHECK:   %[[T0:.*]] = llvm.mlir.constant(15 : i64) : i64323//       CHECK:   %[[T1:.*]] = llvm.extractelement %[[A]][%[[T0]] : i64] : vector<[16]xf32>324//       CHECK:   %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : f32 to vector<1xf32>325//       CHECK:   return %[[T2]] : vector<1xf32>326 327// -----328 329func.func @extract_scalar_from_vec_1d_index(%arg0: vector<16xindex>) -> index {330  %0 = vector.extract %arg0[15]: index from vector<16xindex>331  return %0 : index332}333// CHECK-LABEL: @extract_scalar_from_vec_1d_index(334//  CHECK-SAME:   %[[A:.*]]: vector<16xindex>)335//       CHECK:   %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64>336//       CHECK:   %[[T1:.*]] = llvm.mlir.constant(15 : i64) : i64337//       CHECK:   %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<16xi64>338//       CHECK:   %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : i64 to index339//       CHECK:   return %[[T3]] : index340 341// -----342 343func.func @extract_scalar_from_vec_1d_index_scalable(%arg0: vector<[16]xindex>) -> index {344  %0 = vector.extract %arg0[15]: index from vector<[16]xindex>345  return %0 : index346}347// CHECK-LABEL: @extract_scalar_from_vec_1d_index_scalable(348//  CHECK-SAME:   %[[A:.*]]: vector<[16]xindex>)349//       CHECK:   %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<[16]xindex> to vector<[16]xi64>350//       CHECK:   %[[T1:.*]] = llvm.mlir.constant(15 : i64) : i64351//       CHECK:   %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<[16]xi64>352//       CHECK:   %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : i64 to index353//       CHECK:   return %[[T3]] : index354 355// -----356 357func.func @extract_vec_2d_from_vec_3d_f32(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> {358  %0 = vector.extract %arg0[0]: vector<3x16xf32> from vector<4x3x16xf32>359  return %0 : vector<3x16xf32>360}361// CHECK-LABEL: @extract_vec_2d_from_vec_3d_f32362//       CHECK:   llvm.extractvalue {{.*}}[0] : !llvm.array<4 x array<3 x vector<16xf32>>>363//       CHECK:   return {{.*}} : vector<3x16xf32>364 365 366// -----367 368func.func @extract_vec_2d_from_vec_3d_f32_scalable(%arg0: vector<4x3x[16]xf32>) -> vector<3x[16]xf32> {369  %0 = vector.extract %arg0[0]: vector<3x[16]xf32> from vector<4x3x[16]xf32>370  return %0 : vector<3x[16]xf32>371}372// CHECK-LABEL: @extract_vec_2d_from_vec_3d_f32_scalable373//       CHECK:   llvm.extractvalue {{.*}}[0] : !llvm.array<4 x array<3 x vector<[16]xf32>>>374//       CHECK:   return {{.*}} : vector<3x[16]xf32>375 376// -----377 378func.func @extract_vec_1d_from_vec_3d_f32(%arg0: vector<4x3x16xf32>) -> vector<16xf32> {379  %0 = vector.extract %arg0[0, 0]: vector<16xf32> from vector<4x3x16xf32>380  return %0 : vector<16xf32>381}382// CHECK-LABEL: @extract_vec_1d_from_vec_3d_f32383//       CHECK:   llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<16xf32>>>384//       CHECK:   return {{.*}} : vector<16xf32>385 386// -----387 388func.func @extract_vec_1d_from_vec_3d_f32_scalable(%arg0: vector<4x3x[16]xf32>) -> vector<[16]xf32> {389  %0 = vector.extract %arg0[0, 0]: vector<[16]xf32> from vector<4x3x[16]xf32>390  return %0 : vector<[16]xf32>391}392// CHECK-LABEL: @extract_vec_1d_from_vec_3d_f32_scalable393//       CHECK:   llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<[16]xf32>>>394//       CHECK:   return {{.*}} : vector<[16]xf32>395 396// -----397 398func.func @extract_scalar_from_vec_3d_f32(%arg0: vector<4x3x16xf32>) -> f32 {399  %0 = vector.extract %arg0[0, 0, 0]: f32 from vector<4x3x16xf32>400  return %0 : f32401}402// CHECK-LABEL: @extract_scalar_from_vec_3d_f32403//       CHECK:   llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<16xf32>>>404//       CHECK:   llvm.mlir.constant(0 : i64) : i64405//       CHECK:   llvm.extractelement {{.*}}[{{.*}} : i64] : vector<16xf32>406//       CHECK:   return {{.*}} : f32407 408// -----409 410func.func @extract_scalar_from_vec_3d_f32_scalable(%arg0: vector<4x3x[16]xf32>) -> f32 {411  %0 = vector.extract %arg0[0, 0, 0]: f32 from vector<4x3x[16]xf32>412  return %0 : f32413}414// CHECK-LABEL: @extract_scalar_from_vec_3d_f32_scalable415//       CHECK:   llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<[16]xf32>>>416//       CHECK:   llvm.mlir.constant(0 : i64) : i64417//       CHECK:   llvm.extractelement {{.*}}[{{.*}} : i64] : vector<[16]xf32>418//       CHECK:   return {{.*}} : f32419 420// -----421 422func.func @extract_scalar_from_vec_1d_f32_dynamic_idx(%arg0: vector<16xf32>, %arg1: index) -> f32 {423  %0 = vector.extract %arg0[%arg1]: f32 from vector<16xf32>424  return %0 : f32425}426// CHECK-LABEL: @extract_scalar_from_vec_1d_f32_dynamic_idx427//  CHECK-SAME:   %[[VEC:.+]]: vector<16xf32>, %[[INDEX:.+]]: index428//       CHECK:   %[[UC:.+]] = builtin.unrealized_conversion_cast %[[INDEX]] : index to i64429//       CHECK:   llvm.extractelement %[[VEC]][%[[UC]] : i64] : vector<16xf32>430 431// -----432 433func.func @extract_scalar_from_vec_1d_f32_dynamic_idx_scalable(%arg0: vector<[16]xf32>, %arg1: index) -> f32 {434  %0 = vector.extract %arg0[%arg1]: f32 from vector<[16]xf32>435  return %0 : f32436}437// CHECK-LABEL: @extract_scalar_from_vec_1d_f32_dynamic_idx_scalable438//  CHECK-SAME:   %[[VEC:.+]]: vector<[16]xf32>, %[[INDEX:.+]]: index439//       CHECK:   %[[UC:.+]] = builtin.unrealized_conversion_cast %[[INDEX]] : index to i64440//       CHECK:   llvm.extractelement %[[VEC]][%[[UC]] : i64] : vector<[16]xf32>441 442// -----443 444func.func @extract_scalar_from_vec_2d_f32_inner_dynamic_idx(%arg0: vector<1x16xf32>, %arg1: index) -> f32 {445  %0 = vector.extract %arg0[0, %arg1]: f32 from vector<1x16xf32>446  return %0 : f32447}448 449// Lowering supports extracting from multi-dim vectors with dynamic indices450// provided that only the trailing index is dynamic.451 452// CHECK-LABEL: @extract_scalar_from_vec_2d_f32_inner_dynamic_idx(453//       CHECK:   llvm.extractvalue454//       CHECK:   llvm.extractelement455 456func.func @extract_scalar_from_vec_2d_f32_inner_dynamic_idx_scalable(%arg0: vector<1x[16]xf32>, %arg1: index) -> f32 {457  %0 = vector.extract %arg0[0, %arg1]: f32 from vector<1x[16]xf32>458  return %0 : f32459}460 461// Lowering supports extracting from multi-dim vectors with dynamic indices462// provided that only the trailing index is dynamic.463 464// CHECK-LABEL: @extract_scalar_from_vec_2d_f32_inner_dynamic_idx_scalable(465//       CHECK:   llvm.extractvalue466//       CHECK:   llvm.extractelement467 468// -----469 470func.func @extract_scalar_from_vec_2d_f32_outer_dynamic_idx(%arg0: vector<1x16xf32>, %arg1: index) -> f32 {471  %0 = vector.extract %arg0[%arg1, 0]: f32 from vector<1x16xf32>472  return %0 : f32473}474 475// Lowering supports extracting from multi-dim vectors with dynamic indices476// provided that only the trailing index is dynamic.477 478// CHECK-LABEL: @extract_scalar_from_vec_2d_f32_outer_dynamic_idx(479//       CHECK:   vector.extract480 481func.func @extract_scalar_from_vec_2d_f32_outer_dynamic_idx_scalable(%arg0: vector<1x[16]xf32>, %arg1: index) -> f32 {482  %0 = vector.extract %arg0[%arg1, 0]: f32 from vector<1x[16]xf32>483  return %0 : f32484}485 486// Lowering does not support extracting from multi-dim vectors with non trailing487// dynamic index, but it shouldn't crash.488 489// CHECK-LABEL: @extract_scalar_from_vec_2d_f32_outer_dynamic_idx_scalable(490//       CHECK:   vector.extract491 492// -----493 494func.func @extract_scalar_from_vec_0d_index(%arg0: vector<index>) -> index {495  %0 = vector.extract %arg0[]: index from vector<index>496  return %0 : index497}498// CHECK-LABEL: @extract_scalar_from_vec_0d_index(499//  CHECK-SAME:   %[[A:.*]]: vector<index>)500//       CHECK:   %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<index> to vector<1xi64>501//       CHECK:   %[[T1:.*]] = llvm.mlir.constant(0 : i64) : i64502//       CHECK:   %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<1xi64>503//       CHECK:   %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : i64 to index504//       CHECK:   return %[[T3]] : index505 506// -----507 508func.func @extract_scalar_from_vec_2d_f32_dynamic_idxs_compile_time_const(%arg : vector<32x1xf32>) -> f32 {509  %0 = arith.constant 0 : index510  %1 = vector.extract %arg[%0, %0] : f32 from vector<32x1xf32>511  return %1 : f32512}513 514// At compile time, since the indices of extractOp are constants,515// they will be collapsed and folded away; therefore, the lowering works.516 517// CHECK-LABEL: @extract_scalar_from_vec_2d_f32_dynamic_idxs_compile_time_const518//  CHECK-SAME:   %[[ARG:.*]]: vector<32x1xf32>) -> f32 {519//       CHECK:   %[[CAST:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<32x1xf32> to !llvm.array<32 x vector<1xf32>>520//       CHECK:   %[[VEC_0:.*]] = llvm.extractvalue %[[CAST]][0] : !llvm.array<32 x vector<1xf32>>521//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64522//       CHECK:   %[[RES:.*]] = llvm.extractelement %[[VEC_0]]{{\[}}%[[C0]] : i64] : vector<1xf32>523//       CHECK:   return %[[RES]] : f32524 525// -----526 527//===----------------------------------------------------------------------===//528// vector.insert529//===----------------------------------------------------------------------===//530 531func.func @insert_scalar_into_vec_0d(%src: f32, %dst: vector<f32>) -> vector<f32> {532  %0 = vector.insert %src, %dst[] : f32 into vector<f32>533  return %0 : vector<f32>534}535 536// CHECK-LABEL: @insert_scalar_into_vec_0d537//       CHECK: llvm.insertelement {{.*}} : vector<1xf32>538 539// -----540 541func.func @insert_scalar_into_vec_1d_f32(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {542  %0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32>543  return %0 : vector<4xf32>544}545// CHECK-LABEL: @insert_scalar_into_vec_1d_f32546//       CHECK:   llvm.mlir.constant(3 : i64) : i64547//       CHECK:   llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32>548//       CHECK:   return {{.*}} : vector<4xf32>549 550// -----551 552func.func @insert_scalar_into_vec_1d_f32_scalable(%arg0: f32, %arg1: vector<[4]xf32>) -> vector<[4]xf32> {553  %0 = vector.insert %arg0, %arg1[3] : f32 into vector<[4]xf32>554  return %0 : vector<[4]xf32>555}556// CHECK-LABEL: @insert_scalar_into_vec_1d_f32_scalable557//       CHECK:   llvm.mlir.constant(3 : i64) : i64558//       CHECK:   llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<[4]xf32>559//       CHECK:   return {{.*}} : vector<[4]xf32>560 561// -----562 563func.func @insert_scalar_into_vec_1d_index(%arg0: index, %arg1: vector<4xindex>) -> vector<4xindex> {564  %0 = vector.insert %arg0, %arg1[3] : index into vector<4xindex>565  return %0 : vector<4xindex>566}567// CHECK-LABEL: @insert_scalar_into_vec_1d_index(568//  CHECK-SAME:   %[[A:.*]]: index,569//  CHECK-SAME:   %[[B:.*]]: vector<4xindex>)570//   CHECK-DAG:   %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64571//   CHECK-DAG:   %[[T1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<4xindex> to vector<4xi64>572//       CHECK:   %[[T3:.*]] = llvm.mlir.constant(3 : i64) : i64573//       CHECK:   %[[T4:.*]] = llvm.insertelement %[[T0]], %[[T1]][%[[T3]] : i64] : vector<4xi64>574//       CHECK:   %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : vector<4xi64> to vector<4xindex>575//       CHECK:   return %[[T5]] : vector<4xindex>576 577// -----578 579func.func @insert_scalar_into_vec_1d_index_scalable(%arg0: index, %arg1: vector<[4]xindex>) -> vector<[4]xindex> {580  %0 = vector.insert %arg0, %arg1[3] : index into vector<[4]xindex>581  return %0 : vector<[4]xindex>582}583// CHECK-LABEL: @insert_scalar_into_vec_1d_index_scalable(584//  CHECK-SAME:   %[[A:.*]]: index,585//  CHECK-SAME:   %[[B:.*]]: vector<[4]xindex>)586//   CHECK-DAG:   %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64587//   CHECK-DAG:   %[[T1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<[4]xindex> to vector<[4]xi64>588//       CHECK:   %[[T3:.*]] = llvm.mlir.constant(3 : i64) : i64589//       CHECK:   %[[T4:.*]] = llvm.insertelement %[[T0]], %[[T1]][%[[T3]] : i64] : vector<[4]xi64>590//       CHECK:   %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : vector<[4]xi64> to vector<[4]xindex>591//       CHECK:   return %[[T5]] : vector<[4]xindex>592 593// -----594 595func.func @insert_vec_2d_into_vec_3d_f32(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {596  %0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32>597  return %0 : vector<4x8x16xf32>598}599// CHECK-LABEL: @insert_vec_2d_into_vec_3d_f32600//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x array<8 x vector<16xf32>>>601//       CHECK:   return {{.*}} : vector<4x8x16xf32>602 603// -----604 605func.func @insert_vec_2d_into_vec_3d_f32_scalable(%arg0: vector<8x[16]xf32>, %arg1: vector<4x8x[16]xf32>) -> vector<4x8x[16]xf32> {606  %0 = vector.insert %arg0, %arg1[3] : vector<8x[16]xf32> into vector<4x8x[16]xf32>607  return %0 : vector<4x8x[16]xf32>608}609// CHECK-LABEL: @insert_vec_2d_into_vec_3d_f32_scalable610//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x array<8 x vector<[16]xf32>>>611//       CHECK:   return {{.*}} : vector<4x8x[16]xf32>612 613// -----614 615func.func @insert_vec_1d_into_vec_3d_f32(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {616  %0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32>617  return %0 : vector<4x8x16xf32>618}619// CHECK-LABEL: @insert_vec_1d_into_vec_3d_f32620//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>>621//       CHECK:   return {{.*}} : vector<4x8x16xf32>622 623// -----624 625func.func @insert_vec_1d_into_vec_3d_f32_scalable(%arg0: vector<[16]xf32>, %arg1: vector<4x8x[16]xf32>) -> vector<4x8x[16]xf32> {626  %0 = vector.insert %arg0, %arg1[3, 7] : vector<[16]xf32> into vector<4x8x[16]xf32>627  return %0 : vector<4x8x[16]xf32>628}629// CHECK-LABEL: @insert_vec_1d_into_vec_3d_f32_scalable630//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<[16]xf32>>>631//       CHECK:   return {{.*}} : vector<4x8x[16]xf32>632 633// -----634 635func.func @insert_scalar_into_vec_3d_f32(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {636  %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32>637  return %0 : vector<4x8x16xf32>638}639// CHECK-LABEL: @insert_scalar_into_vec_3d_f32640//       CHECK:   llvm.extractvalue {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>>641//       CHECK:   llvm.mlir.constant(15 : i64) : i64642//       CHECK:   llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<16xf32>643//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>>644//       CHECK:   return {{.*}} : vector<4x8x16xf32>645 646// -----647 648func.func @insert_scalar_into_vec_3d_f32_scalable(%arg0: f32, %arg1: vector<4x8x[16]xf32>) -> vector<4x8x[16]xf32> {649  %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x[16]xf32>650  return %0 : vector<4x8x[16]xf32>651}652// CHECK-LABEL: @insert_scalar_into_vec_3d_f32_scalable653//       CHECK:   llvm.extractvalue {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<[16]xf32>>>654//       CHECK:   llvm.mlir.constant(15 : i64) : i64655//       CHECK:   llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<[16]xf32>656//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<[16]xf32>>>657//       CHECK:   return {{.*}} : vector<4x8x[16]xf32>658 659// -----660 661func.func @insert_scalar_into_vec_1d_f32_dynamic_idx(%arg0: vector<16xf32>, %arg1: f32, %arg2: index)662                                      -> vector<16xf32> {663  %0 = vector.insert %arg1, %arg0[%arg2]: f32 into vector<16xf32>664  return %0 : vector<16xf32>665}666 667// CHECK-LABEL: @insert_scalar_into_vec_1d_f32_dynamic_idx668//  CHECK-SAME:   %[[DST:.+]]: vector<16xf32>, %[[SRC:.+]]: f32, %[[INDEX:.+]]: index669//       CHECK:   %[[UC:.+]] = builtin.unrealized_conversion_cast %[[INDEX]] : index to i64670//       CHECK:   llvm.insertelement %[[SRC]], %[[DST]][%[[UC]] : i64] : vector<16xf32>671 672// -----673 674func.func @insert_scalar_into_vec_1d_f32_dynamic_idx_scalable(%arg0: vector<[16]xf32>, %arg1: f32, %arg2: index)675                                      -> vector<[16]xf32> {676  %0 = vector.insert %arg1, %arg0[%arg2]: f32 into vector<[16]xf32>677  return %0 : vector<[16]xf32>678}679 680// CHECK-LABEL: @insert_scalar_into_vec_1d_f32_dynamic_idx_scalable681//  CHECK-SAME:   %[[DST:.+]]: vector<[16]xf32>, %[[SRC:.+]]: f32, %[[INDEX:.+]]: index682//       CHECK:   %[[UC:.+]] = builtin.unrealized_conversion_cast %[[INDEX]] : index to i64683//       CHECK:   llvm.insertelement %[[SRC]], %[[DST]][%[[UC]] : i64] : vector<[16]xf32>684 685// -----686 687func.func @insert_scalar_into_vec_2d_f32_dynamic_idx(%arg0: vector<1x16xf32>, %arg1: f32, %idx: index)688                                        -> vector<1x16xf32> {689  %0 = vector.insert %arg1, %arg0[0, %idx]: f32 into vector<1x16xf32>690  return %0 : vector<1x16xf32>691}692 693// CHECK-LABEL: @insert_scalar_into_vec_2d_f32_dynamic_idx(694//       CHECK:   llvm.extractvalue {{.*}} : !llvm.array<1 x vector<16xf32>>695//       CHECK:   llvm.insertelement {{.*}} : vector<16xf32>696//       CHECK:   llvm.insertvalue {{.*}} : !llvm.array<1 x vector<16xf32>>697 698// -----699 700func.func @insert_scalar_into_vec_2d_f32_dynamic_idx_scalable(%arg0: vector<1x[16]xf32>, %arg1: f32, %idx: index)701                                        -> vector<1x[16]xf32> {702  %0 = vector.insert %arg1, %arg0[0, %idx]: f32 into vector<1x[16]xf32>703  return %0 : vector<1x[16]xf32>704}705 706// CHECK-LABEL: @insert_scalar_into_vec_2d_f32_dynamic_idx_scalable(707//       CHECK:   llvm.extractvalue {{.*}} : !llvm.array<1 x vector<[16]xf32>>708//       CHECK:   llvm.insertelement {{.*}} : vector<[16]xf32>709//       CHECK:   llvm.insertvalue {{.*}} : !llvm.array<1 x vector<[16]xf32>>710 711 712// -----713 714func.func @insert_scalar_into_vec_2d_f32_dynamic_idx_fail(%arg0: vector<2x16xf32>, %arg1: f32, %idx: index)715                                        -> vector<2x16xf32> {716  %0 = vector.insert %arg1, %arg0[%idx, 0]: f32 into vector<2x16xf32>717  return %0 : vector<2x16xf32>718}719 720// Currently fails to convert because of the dynamic index in non-innermost721// dimension that converts to a llvm.array, as llvm.extractvalue does not722// support dynamic dimensions723 724// CHECK-LABEL: @insert_scalar_into_vec_2d_f32_dynamic_idx_fail725//       CHECK: vector.insert726 727// -----728 729func.func @insert_scalar_from_vec_2d_f32_dynamic_idxs_compile_time_const(%arg : vector<4x1xf32>) -> vector<4x1xf32> {730  %0 = arith.constant 0 : index731  %1 = arith.constant 1.0 : f32732  %res = vector.insert %1, %arg[%0, %0] : f32 into vector<4x1xf32>733  return %res : vector<4x1xf32>734}735 736// At compile time, since the indices of insertOp are constants,737// they will be collapsed and folded away; therefore, the lowering works.738 739// CHECK-LABEL: @insert_scalar_from_vec_2d_f32_dynamic_idxs_compile_time_const740//  CHECK-SAME:   %[[ARG:.*]]: vector<4x1xf32>) -> vector<4x1xf32> {741//       CHECK:   %[[CAST:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>>742//       CHECK:   %[[C1:.*]] = arith.constant 1.000000e+00 : f32743//       CHECK:   %[[VEC_0:.*]] = llvm.extractvalue %[[CAST]][0] : !llvm.array<4 x vector<1xf32>>744//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64745//       CHECK:   %[[VEC_1:.*]] = llvm.insertelement %[[C1]], %[[VEC_0]]{{\[}}%[[C0]] : i64] : vector<1xf32>746//       CHECK:   %[[VEC_2:.*]] = llvm.insertvalue %[[VEC_1]], %[[CAST]][0] : !llvm.array<4 x vector<1xf32>>747//       CHECK:   %[[RES:.*]] = builtin.unrealized_conversion_cast %[[VEC_2]] : !llvm.array<4 x vector<1xf32>> to vector<4x1xf32>748//       CHECK:   return %[[RES]] : vector<4x1xf32>749 750// -----751 752//===----------------------------------------------------------------------===//753// vector.type_cast754//755// TODO: Add tests for for vector.type_cast that would cover scalable vectors756//===----------------------------------------------------------------------===//757 758func.func @type_cast_f32(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {759  %0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>>760  return %0 : memref<vector<8x8x8xf32>>761}762// CHECK-LABEL: @type_cast_f32763//       CHECK:   llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)>764//       CHECK:   %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>765//       CHECK:   llvm.insertvalue %[[allocated]], {{.*}}[0] : !llvm.struct<(ptr, ptr, i64)>766//       CHECK:   %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>767//       CHECK:   llvm.insertvalue %[[aligned]], {{.*}}[1] : !llvm.struct<(ptr, ptr, i64)>768//       CHECK:   llvm.mlir.constant(0 : index769//       CHECK:   llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr, ptr, i64)>770 771// NOTE: No test for scalable vectors - the input memref is fixed size.772 773// -----774 775func.func @type_cast_index(%arg0: memref<8x8x8xindex>) -> memref<vector<8x8x8xindex>> {776  %0 = vector.type_cast %arg0: memref<8x8x8xindex> to memref<vector<8x8x8xindex>>777  return %0 : memref<vector<8x8x8xindex>>778}779// CHECK-LABEL: @type_cast_index(780// CHECK-SAME: %[[A:.*]]: memref<8x8x8xindex>)781//       CHECK:   %{{.*}} = builtin.unrealized_conversion_cast %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>782 783//       CHECK:   %{{.*}} = builtin.unrealized_conversion_cast %{{.*}} : !llvm.struct<(ptr, ptr, i64)> to memref<vector<8x8x8xindex>>784 785// NOTE: No test for scalable vectors - the input memref is fixed size.786 787// -----788 789func.func @type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> memref<vector<8x8x8xf32>, 3> {790  %0 = vector.type_cast %arg0: memref<8x8x8xf32, 3> to memref<vector<8x8x8xf32>, 3>791  return %0 : memref<vector<8x8x8xf32>, 3>792}793// CHECK-LABEL: @type_cast_non_zero_addrspace794//       CHECK:   llvm.mlir.poison : !llvm.struct<(ptr<3>, ptr<3>, i64)>795//       CHECK:   %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr<3>, ptr<3>, i64, array<3 x i64>, array<3 x i64>)>796//       CHECK:   llvm.insertvalue %[[allocated]], {{.*}}[0] : !llvm.struct<(ptr<3>, ptr<3>, i64)>797//       CHECK:   %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.struct<(ptr<3>, ptr<3>, i64, array<3 x i64>, array<3 x i64>)>798//       CHECK:   llvm.insertvalue %[[aligned]], {{.*}}[1] : !llvm.struct<(ptr<3>, ptr<3>, i64)>799//       CHECK:   llvm.mlir.constant(0 : index800//       CHECK:   llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<3>, ptr<3>, i64)>801 802// NOTE: No test for scalable vectors - the input memref is fixed size.803 804// -----805 806//===----------------------------------------------------------------------===//807// vector.print808//===----------------------------------------------------------------------===//809 810func.func @print_scalar_i64(%arg0: i64) {811  vector.print %arg0 : i64812  return813}814// CHECK-LABEL: @print_scalar_i64(815// CHECK-SAME: %[[A:.*]]: i64)816//       CHECK:    llvm.call @printI64(%[[A]]) : (i64) -> ()817//       CHECK:    llvm.call @printNewline() : () -> ()818 819// -----820 821func.func @print_scalar_ui64(%arg0: ui64) {822  vector.print %arg0 : ui64823  return824}825// CHECK-LABEL: @print_scalar_ui64(826// CHECK-SAME: %[[A:.*]]: ui64)827//       CHECK:    %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui64 to i64828//       CHECK:    llvm.call @printU64(%[[C]]) : (i64) -> ()829//       CHECK:    llvm.call @printNewline() : () -> ()830 831// -----832 833func.func @print_scalar_index(%arg0: index) {834  vector.print %arg0 : index835  return836}837// CHECK-LABEL: @print_scalar_index(838// CHECK-SAME: %[[A:.*]]: index)839//       CHECK:    %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64840//       CHECK:    llvm.call @printU64(%[[C]]) : (i64) -> ()841//       CHECK:    llvm.call @printNewline() : () -> ()842 843// -----844 845func.func @print_scalar_f32(%arg0: f32) {846  vector.print %arg0 : f32847  return848}849// CHECK-LABEL: @print_scalar_f32(850// CHECK-SAME: %[[A:.*]]: f32)851//       CHECK:    llvm.call @printF32(%[[A]]) : (f32) -> ()852//       CHECK:    llvm.call @printNewline() : () -> ()853 854// -----855 856func.func @print_scalar_f64(%arg0: f64) {857  vector.print %arg0 : f64858  return859}860// CHECK-LABEL: @print_scalar_f64(861// CHECK-SAME: %[[A:.*]]: f64)862//       CHECK:    llvm.call @printF64(%[[A]]) : (f64) -> ()863//       CHECK:    llvm.call @printNewline() : () -> ()864 865// -----866 867// CHECK-LABEL: module {868// CHECK: llvm.func @printString(!llvm.ptr)869// CHECK: llvm.mlir.global private constant @[[GLOBAL_STR:.*]]({{.*}})870// CHECK: @print_string871//       CHECK-NEXT: %[[GLOBAL_ADDR:.*]] = llvm.mlir.addressof @[[GLOBAL_STR]] : !llvm.ptr872//       CHECK-NEXT: %[[STR_PTR:.*]] = llvm.getelementptr %[[GLOBAL_ADDR]][0] : (!llvm.ptr) -> !llvm.ptr873//       CHECK-NEXT: llvm.call @printString(%[[STR_PTR]]) : (!llvm.ptr) -> ()874func.func @print_string() {875  vector.print str "Hello, World!"876  return877}878 879// -----880 881//===----------------------------------------------------------------------===//882// vector.reduction883//===----------------------------------------------------------------------===//884 885func.func @reduce_0d_f32(%arg0: vector<f32>) -> f32 {886  %0 = vector.reduction <add>, %arg0 : vector<f32> into f32887  return %0 : f32888}889// CHECK-LABEL: @reduce_0d_f32(890// CHECK-SAME: %[[A:.*]]: vector<f32>)891//      CHECK: %[[CA:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<f32> to vector<1xf32>892//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32893//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[CA]])894// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<1xf32>) -> f32895//      CHECK: return %[[V]] : f32896 897// -----898 899func.func @reduce_f16(%arg0: vector<16xf16>) -> f16 {900  %0 = vector.reduction <add>, %arg0 : vector<16xf16> into f16901  return %0 : f16902}903// CHECK-LABEL: @reduce_f16(904// CHECK-SAME: %[[A:.*]]: vector<16xf16>)905//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16906//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])907// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<16xf16>) -> f16908//      CHECK: return %[[V]] : f16909 910// -----911 912func.func @reduce_f16_scalable(%arg0: vector<[16]xf16>) -> f16 {913  %0 = vector.reduction <add>, %arg0 : vector<[16]xf16> into f16914  return %0 : f16915}916// CHECK-LABEL: @reduce_f16_scalable(917// CHECK-SAME: %[[A:.*]]: vector<[16]xf16>)918//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16919//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])920// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<[16]xf16>) -> f16921//      CHECK: return %[[V]] : f16922 923// -----924 925func.func @reduce_f32(%arg0: vector<16xf32>) -> f32 {926  %0 = vector.reduction <add>, %arg0 : vector<16xf32> into f32927  return %0 : f32928}929// CHECK-LABEL: @reduce_f32(930// CHECK-SAME: %[[A:.*]]: vector<16xf32>)931//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32932//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])933// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<16xf32>) -> f32934//      CHECK: return %[[V]] : f32935 936// -----937 938func.func @reduce_f32_scalable(%arg0: vector<[16]xf32>) -> f32 {939  %0 = vector.reduction <add>, %arg0 : vector<[16]xf32> into f32940  return %0 : f32941}942// CHECK-LABEL: @reduce_f32_scalable(943// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>)944//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32945//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])946// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<[16]xf32>) -> f32947//      CHECK: return %[[V]] : f32948 949// -----950 951func.func @reduce_f64(%arg0: vector<16xf64>) -> f64 {952  %0 = vector.reduction <add>, %arg0 : vector<16xf64> into f64953  return %0 : f64954}955// CHECK-LABEL: @reduce_f64(956// CHECK-SAME: %[[A:.*]]: vector<16xf64>)957//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64958//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])959// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<16xf64>) -> f64960//      CHECK: return %[[V]] : f64961 962// -----963 964func.func @reduce_f64_scalable(%arg0: vector<[16]xf64>) -> f64 {965  %0 = vector.reduction <add>, %arg0 : vector<[16]xf64> into f64966  return %0 : f64967}968// CHECK-LABEL: @reduce_f64_scalable(969// CHECK-SAME: %[[A:.*]]: vector<[16]xf64>)970//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64971//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])972// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<[16]xf64>) -> f64973//      CHECK: return %[[V]] : f64974 975// -----976 977func.func @reduce_i8(%arg0: vector<16xi8>) -> i8 {978  %0 = vector.reduction <add>, %arg0 : vector<16xi8> into i8979  return %0 : i8980}981// CHECK-LABEL: @reduce_i8(982// CHECK-SAME: %[[A:.*]]: vector<16xi8>)983//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])984//      CHECK: return %[[V]] : i8985 986// -----987 988func.func @reduce_i8_scalable(%arg0: vector<[16]xi8>) -> i8 {989  %0 = vector.reduction <add>, %arg0 : vector<[16]xi8> into i8990  return %0 : i8991}992// CHECK-LABEL: @reduce_i8_scalable(993// CHECK-SAME: %[[A:.*]]: vector<[16]xi8>)994//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])995//      CHECK: return %[[V]] : i8996 997// -----998 999func.func @reduce_i32(%arg0: vector<16xi32>) -> i32 {1000  %0 = vector.reduction <add>, %arg0 : vector<16xi32> into i321001  return %0 : i321002}1003// CHECK-LABEL: @reduce_i32(1004// CHECK-SAME: %[[A:.*]]: vector<16xi32>)1005//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])1006//      CHECK: return %[[V]] : i321007 1008// -----1009 1010func.func @reduce_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1011  %0 = vector.reduction <add>, %arg0 : vector<[16]xi32> into i321012  return %0 : i321013}1014// CHECK-LABEL: @reduce_i32_scalable(1015// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1016//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])1017//      CHECK: return %[[V]] : i321018 1019// -----1020 1021func.func @reduce_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1022  %0 = vector.reduction <add>, %arg0, %arg1 : vector<16xi32> into i321023  return %0 : i321024}1025// CHECK-LABEL: @reduce_acc_i32(1026//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1027//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])1028//       CHECK: %[[V:.*]] = llvm.add %[[ACC]], %[[R]]1029//       CHECK: return %[[V]] : i321030 1031// -----1032 1033func.func @reduce_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1034  %0 = vector.reduction <add>, %arg0, %arg1 : vector<[16]xi32> into i321035  return %0 : i321036}1037// CHECK-LABEL: @reduce_acc_i32_scalable(1038//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1039//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])1040//       CHECK: %[[V:.*]] = llvm.add %[[ACC]], %[[R]]1041//       CHECK: return %[[V]] : i321042 1043// -----1044 1045func.func @reduce_mul_i32(%arg0: vector<16xi32>) -> i32 {1046  %0 = vector.reduction <mul>, %arg0 : vector<16xi32> into i321047  return %0 : i321048}1049// CHECK-LABEL: @reduce_mul_i32(1050//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1051//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])1052//       CHECK: return %[[V]] : i321053 1054// -----1055 1056func.func @reduce_mul_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1057  %0 = vector.reduction <mul>, %arg0 : vector<[16]xi32> into i321058  return %0 : i321059}1060// CHECK-LABEL: @reduce_mul_i32_scalable(1061//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1062//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])1063//       CHECK: return %[[V]] : i321064 1065// -----1066 1067func.func @reduce_mul_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1068  %0 = vector.reduction <mul>, %arg0, %arg1 : vector<16xi32> into i321069  return %0 : i321070}1071// CHECK-LABEL: @reduce_mul_acc_i32(1072//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1073//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])1074//       CHECK: %[[V:.*]] = llvm.mul %[[ACC]], %[[R]]1075//       CHECK: return %[[V]] : i321076 1077// -----1078 1079func.func @reduce_mul_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1080  %0 = vector.reduction <mul>, %arg0, %arg1 : vector<[16]xi32> into i321081  return %0 : i321082}1083// CHECK-LABEL: @reduce_mul_acc_i32_scalable(1084//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1085//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])1086//       CHECK: %[[V:.*]] = llvm.mul %[[ACC]], %[[R]]1087//       CHECK: return %[[V]] : i321088 1089// -----1090 1091func.func @reduce_fmaximum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {1092  %0 = vector.reduction <maximumf>, %arg0, %arg1 : vector<16xf32> into f321093  return %0 : f321094}1095// CHECK-LABEL: @reduce_fmaximum_f32(1096// CHECK-SAME: %[[A:.*]]: vector<16xf32>, %[[B:.*]]: f32)1097//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmaximum(%[[A]]) : (vector<16xf32>) -> f321098//      CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f321099//      CHECK: return %[[R]] : f321100 1101// -----1102 1103func.func @reduce_fmaximum_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {1104  %0 = vector.reduction <maximumf>, %arg0, %arg1 : vector<[16]xf32> into f321105  return %0 : f321106}1107// CHECK-LABEL: @reduce_fmaximum_f32_scalable(1108// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)1109//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmaximum(%[[A]]) : (vector<[16]xf32>) -> f321110//      CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f321111//      CHECK: return %[[R]] : f321112 1113// -----1114 1115func.func @reduce_fminimum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {1116  %0 = vector.reduction <minimumf>, %arg0, %arg1 : vector<16xf32> into f321117  return %0 : f321118}1119// CHECK-LABEL: @reduce_fminimum_f32(1120// CHECK-SAME: %[[A:.*]]: vector<16xf32>, %[[B:.*]]: f32)1121//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fminimum(%[[A]]) : (vector<16xf32>) -> f321122//      CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f321123//      CHECK: return %[[R]] : f321124 1125// -----1126 1127func.func @reduce_fminimum_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {1128  %0 = vector.reduction <minimumf>, %arg0, %arg1 : vector<[16]xf32> into f321129  return %0 : f321130}1131// CHECK-LABEL: @reduce_fminimum_f32_scalable(1132// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)1133//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fminimum(%[[A]]) : (vector<[16]xf32>) -> f321134//      CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f321135//      CHECK: return %[[R]] : f321136 1137// -----1138 1139func.func @reduce_fmax_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {1140  %0 = vector.reduction <maxnumf>, %arg0, %arg1 : vector<16xf32> into f321141  return %0 : f321142}1143// CHECK-LABEL: @reduce_fmax_f32(1144// CHECK-SAME: %[[A:.*]]: vector<16xf32>, %[[B:.*]]: f32)1145//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmax(%[[A]]) : (vector<16xf32>) -> f321146//      CHECK: %[[R:.*]] = llvm.intr.maxnum(%[[V]], %[[B]]) : (f32, f32) -> f321147//      CHECK: return %[[R]] : f321148 1149// -----1150 1151func.func @reduce_fmax_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {1152  %0 = vector.reduction <maxnumf>, %arg0, %arg1 : vector<[16]xf32> into f321153  return %0 : f321154}1155// CHECK-LABEL: @reduce_fmax_f32_scalable(1156// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)1157//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmax(%[[A]]) : (vector<[16]xf32>) -> f321158//      CHECK: %[[R:.*]] = llvm.intr.maxnum(%[[V]], %[[B]]) : (f32, f32) -> f321159//      CHECK: return %[[R]] : f321160 1161// -----1162 1163func.func @reduce_fmin_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {1164  %0 = vector.reduction <minnumf>, %arg0, %arg1 : vector<16xf32> into f321165  return %0 : f321166}1167// CHECK-LABEL: @reduce_fmin_f32(1168// CHECK-SAME: %[[A:.*]]: vector<16xf32>, %[[B:.*]]: f32)1169//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmin(%[[A]]) : (vector<16xf32>) -> f321170//      CHECK: %[[R:.*]] = llvm.intr.minnum(%[[V]], %[[B]]) : (f32, f32) -> f321171//      CHECK: return %[[R]] : f321172 1173// -----1174 1175func.func @reduce_fmin_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {1176  %0 = vector.reduction <minnumf>, %arg0, %arg1 : vector<[16]xf32> into f321177  return %0 : f321178}1179// CHECK-LABEL: @reduce_fmin_f32_scalable(1180// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)1181//      CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmin(%[[A]]) : (vector<[16]xf32>) -> f321182//      CHECK: %[[R:.*]] = llvm.intr.minnum(%[[V]], %[[B]]) : (f32, f32) -> f321183//      CHECK: return %[[R]] : f321184 1185// -----1186 1187func.func @reduce_minui_i32(%arg0: vector<16xi32>) -> i32 {1188  %0 = vector.reduction <minui>, %arg0 : vector<16xi32> into i321189  return %0 : i321190}1191// CHECK-LABEL: @reduce_minui_i32(1192//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1193//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])1194//       CHECK: return %[[V]] : i321195 1196// -----1197 1198func.func @reduce_minui_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1199  %0 = vector.reduction <minui>, %arg0 : vector<[16]xi32> into i321200  return %0 : i321201}1202// CHECK-LABEL: @reduce_minui_i32_scalable(1203//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1204//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])1205//       CHECK: return %[[V]] : i321206 1207// -----1208 1209func.func @reduce_minui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1210  %0 = vector.reduction <minui>, %arg0, %arg1 : vector<16xi32> into i321211  return %0 : i321212}1213// CHECK-LABEL: @reduce_minui_acc_i32(1214//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1215//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])1216//       CHECK: %[[S:.*]] = llvm.icmp "ule" %[[ACC]], %[[R]]1217//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1218//       CHECK: return %[[V]] : i321219 1220// -----1221 1222func.func @reduce_minui_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1223  %0 = vector.reduction <minui>, %arg0, %arg1 : vector<[16]xi32> into i321224  return %0 : i321225}1226// CHECK-LABEL: @reduce_minui_acc_i32_scalable(1227//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1228//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])1229//       CHECK: %[[S:.*]] = llvm.icmp "ule" %[[ACC]], %[[R]]1230//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1231//       CHECK: return %[[V]] : i321232 1233// -----1234 1235func.func @reduce_maxui_i32(%arg0: vector<16xi32>) -> i32 {1236  %0 = vector.reduction <maxui>, %arg0 : vector<16xi32> into i321237  return %0 : i321238}1239// CHECK-LABEL: @reduce_maxui_i32(1240//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1241//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])1242//       CHECK: return %[[V]] : i321243 1244// -----1245 1246func.func @reduce_maxui_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1247  %0 = vector.reduction <maxui>, %arg0 : vector<[16]xi32> into i321248  return %0 : i321249}1250// CHECK-LABEL: @reduce_maxui_i32_scalable(1251//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1252//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])1253//       CHECK: return %[[V]] : i321254 1255// -----1256 1257func.func @reduce_maxui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1258  %0 = vector.reduction <maxui>, %arg0, %arg1 : vector<16xi32> into i321259  return %0 : i321260}1261// CHECK-LABEL: @reduce_maxui_acc_i32(1262//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1263//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])1264//       CHECK: %[[S:.*]] = llvm.icmp "uge" %[[ACC]], %[[R]]1265//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1266//       CHECK: return %[[V]] : i321267 1268// -----1269 1270func.func @reduce_maxui_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1271  %0 = vector.reduction <maxui>, %arg0, %arg1 : vector<[16]xi32> into i321272  return %0 : i321273}1274// CHECK-LABEL: @reduce_maxui_acc_i32_scalable(1275//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1276//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])1277//       CHECK: %[[S:.*]] = llvm.icmp "uge" %[[ACC]], %[[R]]1278//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1279//       CHECK: return %[[V]] : i321280 1281// -----1282 1283func.func @reduce_minsi_i32(%arg0: vector<16xi32>) -> i32 {1284  %0 = vector.reduction <minsi>, %arg0 : vector<16xi32> into i321285  return %0 : i321286}1287// CHECK-LABEL: @reduce_minsi_i32(1288//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1289//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])1290//       CHECK: return %[[V]] : i321291 1292// -----1293 1294func.func @reduce_minsi_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1295  %0 = vector.reduction <minsi>, %arg0 : vector<[16]xi32> into i321296  return %0 : i321297}1298// CHECK-LABEL: @reduce_minsi_i32_scalable(1299//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1300//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])1301//       CHECK: return %[[V]] : i321302 1303// -----1304 1305func.func @reduce_minsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1306  %0 = vector.reduction <minsi>, %arg0, %arg1 : vector<16xi32> into i321307  return %0 : i321308}1309// CHECK-LABEL: @reduce_minsi_acc_i32(1310//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1311//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])1312//       CHECK: %[[S:.*]] = llvm.icmp "sle" %[[ACC]], %[[R]]1313//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1314//       CHECK: return %[[V]] : i321315 1316// -----1317 1318func.func @reduce_minsi_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1319  %0 = vector.reduction <minsi>, %arg0, %arg1 : vector<[16]xi32> into i321320  return %0 : i321321}1322// CHECK-LABEL: @reduce_minsi_acc_i32_scalable(1323//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1324//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])1325//       CHECK: %[[S:.*]] = llvm.icmp "sle" %[[ACC]], %[[R]]1326//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1327//       CHECK: return %[[V]] : i321328 1329// -----1330 1331func.func @reduce_maxsi_i32(%arg0: vector<16xi32>) -> i32 {1332  %0 = vector.reduction <maxsi>, %arg0 : vector<16xi32> into i321333  return %0 : i321334}1335// CHECK-LABEL: @reduce_maxsi_i32(1336//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1337//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])1338//       CHECK: return %[[V]] : i321339 1340// -----1341 1342func.func @reduce_maxsi_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1343  %0 = vector.reduction <maxsi>, %arg0 : vector<[16]xi32> into i321344  return %0 : i321345}1346// CHECK-LABEL: @reduce_maxsi_i32_scalable(1347//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1348//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])1349//       CHECK: return %[[V]] : i321350 1351// -----1352 1353func.func @reduce_maxsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1354  %0 = vector.reduction <maxsi>, %arg0, %arg1 : vector<16xi32> into i321355  return %0 : i321356}1357// CHECK-LABEL: @reduce_maxsi_acc_i32(1358//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1359//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])1360//       CHECK: %[[S:.*]] = llvm.icmp "sge" %[[ACC]], %[[R]]1361//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1362//       CHECK: return %[[V]] : i321363 1364// -----1365 1366func.func @reduce_maxsi_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1367  %0 = vector.reduction <maxsi>, %arg0, %arg1 : vector<[16]xi32> into i321368  return %0 : i321369}1370// CHECK-LABEL: @reduce_maxsi_acc_i32_scalable(1371//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1372//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])1373//       CHECK: %[[S:.*]] = llvm.icmp "sge" %[[ACC]], %[[R]]1374//       CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]1375//       CHECK: return %[[V]] : i321376 1377// -----1378 1379func.func @reduce_and_i32(%arg0: vector<16xi32>) -> i32 {1380  %0 = vector.reduction <and>, %arg0 : vector<16xi32> into i321381  return %0 : i321382}1383// CHECK-LABEL: @reduce_and_i32(1384//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1385//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])1386//       CHECK: return %[[V]] : i321387 1388// -----1389 1390func.func @reduce_and_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1391  %0 = vector.reduction <and>, %arg0 : vector<[16]xi32> into i321392  return %0 : i321393}1394// CHECK-LABEL: @reduce_and_i32_scalable(1395//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1396//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])1397//       CHECK: return %[[V]] : i321398 1399// -----1400 1401func.func @reduce_and_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1402  %0 = vector.reduction <and>, %arg0, %arg1 : vector<16xi32> into i321403  return %0 : i321404}1405// CHECK-LABEL: @reduce_and_acc_i32(1406//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1407//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])1408//       CHECK: %[[V:.*]] = llvm.and %[[ACC]], %[[R]]1409//       CHECK: return %[[V]] : i321410 1411// -----1412 1413func.func @reduce_and_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1414  %0 = vector.reduction <and>, %arg0, %arg1 : vector<[16]xi32> into i321415  return %0 : i321416}1417// CHECK-LABEL: @reduce_and_acc_i32_scalable(1418//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1419//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])1420//       CHECK: %[[V:.*]] = llvm.and %[[ACC]], %[[R]]1421//       CHECK: return %[[V]] : i321422 1423// -----1424 1425func.func @reduce_or_i32(%arg0: vector<16xi32>) -> i32 {1426  %0 = vector.reduction <or>, %arg0 : vector<16xi32> into i321427  return %0 : i321428}1429// CHECK-LABEL: @reduce_or_i32(1430//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1431//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])1432//       CHECK: return %[[V]] : i321433 1434// -----1435 1436func.func @reduce_or_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1437  %0 = vector.reduction <or>, %arg0 : vector<[16]xi32> into i321438  return %0 : i321439}1440// CHECK-LABEL: @reduce_or_i32_scalable(1441//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1442//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])1443//       CHECK: return %[[V]] : i321444 1445// -----1446 1447func.func @reduce_or_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1448  %0 = vector.reduction <or>, %arg0, %arg1 : vector<16xi32> into i321449  return %0 : i321450}1451// CHECK-LABEL: @reduce_or_acc_i32(1452//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1453//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])1454//       CHECK: %[[V:.*]] = llvm.or %[[ACC]], %[[R]]1455//       CHECK: return %[[V]] : i321456 1457// -----1458 1459func.func @reduce_or_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1460  %0 = vector.reduction <or>, %arg0, %arg1 : vector<[16]xi32> into i321461  return %0 : i321462}1463// CHECK-LABEL: @reduce_or_acc_i32_scalable(1464//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1465//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])1466//       CHECK: %[[V:.*]] = llvm.or %[[ACC]], %[[R]]1467//       CHECK: return %[[V]] : i321468 1469// -----1470 1471func.func @reduce_xor_i32(%arg0: vector<16xi32>) -> i32 {1472  %0 = vector.reduction <xor>, %arg0 : vector<16xi32> into i321473  return %0 : i321474}1475// CHECK-LABEL: @reduce_xor_i32(1476//  CHECK-SAME: %[[A:.*]]: vector<16xi32>)1477//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])1478//       CHECK: return %[[V]] : i321479 1480// -----1481 1482func.func @reduce_xor_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {1483  %0 = vector.reduction <xor>, %arg0 : vector<[16]xi32> into i321484  return %0 : i321485}1486// CHECK-LABEL: @reduce_xor_i32_scalable(1487//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)1488//       CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])1489//       CHECK: return %[[V]] : i321490 1491// -----1492 1493func.func @reduce_xor_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {1494  %0 = vector.reduction <xor>, %arg0, %arg1 : vector<16xi32> into i321495  return %0 : i321496}1497// CHECK-LABEL: @reduce_xor_acc_i32(1498//  CHECK-SAME: %[[A:.*]]: vector<16xi32>, %[[ACC:.*]]: i32)1499//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])1500//       CHECK: %[[V:.*]] = llvm.xor %[[ACC]], %[[R]]1501//       CHECK: return %[[V]] : i321502 1503// -----1504 1505func.func @reduce_xor_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {1506  %0 = vector.reduction <xor>, %arg0, %arg1 : vector<[16]xi32> into i321507  return %0 : i321508}1509// CHECK-LABEL: @reduce_xor_acc_i32_scalable(1510//  CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)1511//       CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])1512//       CHECK: %[[V:.*]] = llvm.xor %[[ACC]], %[[R]]1513//       CHECK: return %[[V]] : i321514 1515// -----1516 1517func.func @reduce_i64(%arg0: vector<16xi64>) -> i64 {1518  %0 = vector.reduction <add>, %arg0 : vector<16xi64> into i641519  return %0 : i641520}1521// CHECK-LABEL: @reduce_i64(1522// CHECK-SAME: %[[A:.*]]: vector<16xi64>)1523//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])1524//      CHECK: return %[[V]] : i641525 1526// -----1527 1528func.func @reduce_i64_scalable(%arg0: vector<[16]xi64>) -> i64 {1529  %0 = vector.reduction <add>, %arg0 : vector<[16]xi64> into i641530  return %0 : i641531}1532// CHECK-LABEL: @reduce_i64_scalable(1533// CHECK-SAME: %[[A:.*]]: vector<[16]xi64>)1534//      CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])1535//      CHECK: return %[[V]] : i641536 1537// -----1538 1539func.func @reduce_index(%arg0: vector<16xindex>) -> index {1540  %0 = vector.reduction <add>, %arg0 : vector<16xindex> into index1541  return %0 : index1542}1543// CHECK-LABEL: @reduce_index(1544// CHECK-SAME: %[[A:.*]]: vector<16xindex>)1545//      CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64>1546//      CHECK: %[[T1:.*]] = "llvm.intr.vector.reduce.add"(%[[T0]])1547//      CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : i64 to index1548//      CHECK: return %[[T2]] : index1549 1550// -----1551 1552func.func @reduce_index_scalable(%arg0: vector<[16]xindex>) -> index {1553  %0 = vector.reduction <add>, %arg0 : vector<[16]xindex> into index1554  return %0 : index1555}1556// CHECK-LABEL: @reduce_index_scalable(1557// CHECK-SAME: %[[A:.*]]: vector<[16]xindex>)1558//      CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<[16]xindex> to vector<[16]xi64>1559//      CHECK: %[[T1:.*]] = "llvm.intr.vector.reduce.add"(%[[T0]])1560//      CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : i64 to index1561//      CHECK: return %[[T2]] : index1562 1563// -----1564 1565//===----------------------------------------------------------------------===//1566// vector.transpose1567//===----------------------------------------------------------------------===//1568 1569func.func @transpose_0d(%arg0: vector<f32>) -> vector<f32> {1570  %0 = vector.transpose %arg0, [] : vector<f32> to vector<f32>1571  return %0 : vector<f32>1572}1573 1574// CHECK-LABEL: func @transpose_0d1575// CHECK-SAME:  %[[A:.*]]: vector<f32>1576// CHECK:       return %[[A]] : vector<f32>1577 1578// -----1579 1580//===----------------------------------------------------------------------===//1581// vector.load1582//===----------------------------------------------------------------------===//1583 1584func.func @load(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<8xf32> {1585  %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<8xf32>1586  return %0 : vector<8xf32>1587}1588 1589// CHECK-LABEL: func @load1590// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641591// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641592// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641593// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321594// CHECK: llvm.load %[[GEP]] {alignment = 4 : i64} : !llvm.ptr -> vector<8xf32>1595 1596// -----1597 1598func.func @load_scalable(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<[8]xf32> {1599  %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<[8]xf32>1600  return %0 : vector<[8]xf32>1601}1602 1603// CHECK-LABEL: func @load_scalable1604// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641605// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641606// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641607// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321608// CHECK: llvm.load %[[GEP]] {alignment = 4 : i64} : !llvm.ptr -> vector<[8]xf32>1609 1610// -----1611 1612func.func @load_nontemporal(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<8xf32> {1613  %0 = vector.load %memref[%i, %j] {nontemporal = true} : memref<200x100xf32>, vector<8xf32>1614  return %0 : vector<8xf32>1615}1616 1617// CHECK-LABEL: func @load_nontemporal1618// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641619// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641620// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641621// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321622// CHECK: llvm.load %[[GEP]] {alignment = 4 : i64, nontemporal} : !llvm.ptr -> vector<8xf32>1623 1624// -----1625 1626func.func @load_nontemporal_scalable(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<[8]xf32> {1627  %0 = vector.load %memref[%i, %j] {nontemporal = true} : memref<200x100xf32>, vector<[8]xf32>1628  return %0 : vector<[8]xf32>1629}1630 1631// CHECK-LABEL: func @load_nontemporal_scalable1632// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641633// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641634// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641635// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321636// CHECK: llvm.load %[[GEP]] {alignment = 4 : i64, nontemporal} : !llvm.ptr -> vector<[8]xf32>1637 1638// -----1639 1640func.func @load_index(%memref : memref<200x100xindex>, %i : index, %j : index) -> vector<8xindex> {1641  %0 = vector.load %memref[%i, %j] : memref<200x100xindex>, vector<8xindex>1642  return %0 : vector<8xindex>1643}1644// CHECK-LABEL: func @load_index1645// CHECK: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<8xi64>1646// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<8xi64> to vector<8xindex>1647// CHECK: return %[[T1]] : vector<8xindex>1648 1649// -----1650 1651func.func @load_index_scalable(%memref : memref<200x100xindex>, %i : index, %j : index) -> vector<[8]xindex> {1652  %0 = vector.load %memref[%i, %j] : memref<200x100xindex>, vector<[8]xindex>1653  return %0 : vector<[8]xindex>1654}1655// CHECK-LABEL: func @load_index_scalable1656// CHECK: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<[8]xi64>1657// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<[8]xi64> to vector<[8]xindex>1658// CHECK: return %[[T1]] : vector<[8]xindex>1659 1660// -----1661 1662func.func @load_0d(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<f32> {1663  %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<f32>1664  return %0 : vector<f32>1665}1666 1667// CHECK-LABEL: func @load_0d1668// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %{{.*}} : index to i641669// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %{{.*}} : index to i641670// CHECK: %[[CAST_MEMREF:.*]] = builtin.unrealized_conversion_cast %{{.*}} : memref<200x100xf32> to !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>1671// CHECK: %[[REF:.*]] = llvm.extractvalue %[[CAST_MEMREF]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>1672// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641673// CHECK: %[[MUL:.*]] = llvm.mul %[[I]], %[[C100]] : i641674// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %[[J]] : i641675// CHECK: %[[ADDR:.*]] = llvm.getelementptr %[[REF]][%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321676// CHECK: %[[LOAD:.*]] = llvm.load %[[ADDR]] {alignment = 4 : i64} : !llvm.ptr -> vector<1xf32>1677// CHECK: %[[RES:.*]] = builtin.unrealized_conversion_cast %[[LOAD]] : vector<1xf32> to vector<f32>1678// CHECK: return %[[RES]] : vector<f32>1679 1680// -----1681 1682func.func @load_with_alignment(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<8xf32> {1683  %0 = vector.load %memref[%i, %j] { alignment = 8 } : memref<200x100xf32>, vector<8xf32>1684  return %0 : vector<8xf32>1685}1686 1687// CHECK-LABEL: func @load_with_alignment1688// CHECK: llvm.load {{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<8xf32>1689 1690// -----1691 1692//===----------------------------------------------------------------------===//1693// vector.store1694//===----------------------------------------------------------------------===//1695 1696func.func @store(%memref : memref<200x100xf32>, %i : index, %j : index) {1697  %val = arith.constant dense<11.0> : vector<4xf32>1698  vector.store %val, %memref[%i, %j] : memref<200x100xf32>, vector<4xf32>1699  return1700}1701 1702// CHECK-LABEL: func @store1703// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641704// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641705// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641706// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321707// CHECK: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64} :  vector<4xf32>, !llvm.ptr1708 1709// -----1710 1711func.func @store_scalable(%memref : memref<200x100xf32>, %i : index, %j : index) {1712  %val = arith.constant dense<11.0> : vector<[4]xf32>1713  vector.store %val, %memref[%i, %j] : memref<200x100xf32>, vector<[4]xf32>1714  return1715}1716 1717// CHECK-LABEL: func @store_scalable1718// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641719// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641720// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641721// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321722// CHECK: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64} :  vector<[4]xf32>, !llvm.ptr1723 1724// -----1725 1726func.func @store_nontemporal(%memref : memref<200x100xf32>, %i : index, %j : index) {1727  %val = arith.constant dense<11.0> : vector<4xf32>1728  vector.store %val, %memref[%i, %j] {nontemporal = true} : memref<200x100xf32>, vector<4xf32>1729  return1730}1731 1732// CHECK-LABEL: func @store_nontemporal1733// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641734// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641735// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641736// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321737// CHECK: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64, nontemporal} :  vector<4xf32>, !llvm.ptr1738 1739// -----1740 1741func.func @store_nontemporal_scalable(%memref : memref<200x100xf32>, %i : index, %j : index) {1742  %val = arith.constant dense<11.0> : vector<[4]xf32>1743  vector.store %val, %memref[%i, %j] {nontemporal = true} : memref<200x100xf32>, vector<[4]xf32>1744  return1745}1746 1747// CHECK-LABEL: func @store_nontemporal_scalable1748// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641749// CHECK: %[[MUL:.*]] = llvm.mul %{{.*}}, %[[C100]]  : i641750// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}  : i641751// CHECK: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321752// CHECK: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64, nontemporal} :  vector<[4]xf32>, !llvm.ptr1753 1754// -----1755 1756func.func @store_index(%memref : memref<200x100xindex>, %i : index, %j : index) {1757  %val = arith.constant dense<11> : vector<4xindex>1758  vector.store %val, %memref[%i, %j] : memref<200x100xindex>, vector<4xindex>1759  return1760}1761// CHECK-LABEL: func @store_index1762// CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : vector<4xi64>, !llvm.ptr1763 1764// -----1765 1766func.func @store_index_scalable(%memref : memref<200x100xindex>, %i : index, %j : index) {1767  %val = arith.constant dense<11> : vector<[4]xindex>1768  vector.store %val, %memref[%i, %j] : memref<200x100xindex>, vector<[4]xindex>1769  return1770}1771// CHECK-LABEL: func @store_index_scalable1772// CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : vector<[4]xi64>, !llvm.ptr1773 1774// -----1775 1776func.func @store_0d(%memref : memref<200x100xf32>, %i : index, %j : index) {1777  %val = arith.constant dense<11.0> : vector<f32>1778  vector.store %val, %memref[%i, %j] : memref<200x100xf32>, vector<f32>1779  return1780}1781 1782// CHECK-LABEL: func @store_0d1783// CHECK: %[[J:.*]] = builtin.unrealized_conversion_cast %{{.*}} : index to i641784// CHECK: %[[I:.*]] = builtin.unrealized_conversion_cast %{{.*}} : index to i641785// CHECK: %[[CAST_MEMREF:.*]] = builtin.unrealized_conversion_cast %{{.*}} : memref<200x100xf32> to !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>1786// CHECK: %[[CST:.*]] = arith.constant dense<1.100000e+01> : vector<f32>1787// CHECK: %[[VAL:.*]] = builtin.unrealized_conversion_cast %[[CST]] : vector<f32> to vector<1xf32>1788// CHECK: %[[REF:.*]] = llvm.extractvalue %[[CAST_MEMREF]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>1789// CHECK: %[[C100:.*]] = llvm.mlir.constant(100 : index) : i641790// CHECK: %[[MUL:.*]] = llvm.mul %[[I]], %[[C100]] : i641791// CHECK: %[[ADD:.*]] = llvm.add %[[MUL]], %[[J]] : i641792// CHECK: %[[ADDR:.*]] = llvm.getelementptr %[[REF]][%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321793// CHECK: llvm.store %[[VAL]], %[[ADDR]] {alignment = 4 : i64} : vector<1xf32>, !llvm.ptr1794// CHECK: return1795 1796// -----1797 1798func.func @store_with_alignment(%memref : memref<200x100xf32>, %i : index, %j : index, %val : vector<4xf32>) {1799  vector.store %val, %memref[%i, %j] {alignment = 8} : memref<200x100xf32>, vector<4xf32>1800  return1801}1802 1803// CHECK-LABEL: func @store_with_alignment1804// CHECK: llvm.store %{{.*}} {alignment = 8 : i64} :  vector<4xf32>, !llvm.ptr1805 1806// -----1807 1808//===----------------------------------------------------------------------===//1809// vector.maskedload1810//===----------------------------------------------------------------------===//1811 1812func.func @masked_load(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>) -> vector<16xf32> {1813  %c0 = arith.constant 0: index1814  %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>1815  return %0 : vector<16xf32>1816}1817 1818// CHECK-LABEL: func @masked_load1819// CHECK: %[[CO:.*]] = arith.constant 0 : index1820// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i641821// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321822// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>1823// CHECK: return %[[L]] : vector<16xf32>1824 1825// -----1826 1827func.func @masked_load_scalable(%arg0: memref<?xf32>, %arg1: vector<[16]xi1>, %arg2: vector<[16]xf32>) -> vector<[16]xf32> {1828  %c0 = arith.constant 0: index1829  %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<[16]xi1>, vector<[16]xf32> into vector<[16]xf32>1830  return %0 : vector<[16]xf32>1831}1832 1833// CHECK-LABEL: func @masked_load_scalable1834// CHECK: %[[CO:.*]] = arith.constant 0 : index1835// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i641836// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321837// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr, vector<[16]xi1>, vector<[16]xf32>) -> vector<[16]xf32>1838// CHECK: return %[[L]] : vector<[16]xf32>1839 1840// -----1841 1842func.func @masked_load_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2: vector<16xindex>) -> vector<16xindex> {1843  %c0 = arith.constant 0: index1844  %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<16xi1>, vector<16xindex> into vector<16xindex>1845  return %0 : vector<16xindex>1846}1847// CHECK-LABEL: func @masked_load_index1848// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xi64>) -> vector<16xi64>1849 1850// -----1851 1852func.func @masked_load_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[16]xi1>, %arg2: vector<[16]xindex>) -> vector<[16]xindex> {1853  %c0 = arith.constant 0: index1854  %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<[16]xi1>, vector<[16]xindex> into vector<[16]xindex>1855  return %0 : vector<[16]xindex>1856}1857// CHECK-LABEL: func @masked_load_index_scalable1858// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr, vector<[16]xi1>, vector<[16]xi64>) -> vector<[16]xi64>1859 1860// -----1861 1862func.func @masked_load_with_alignment(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>, %arg3: index) -> vector<16xf32> {1863  %0 = vector.maskedload %arg0[%arg3], %arg1, %arg2 { alignment = 2 } : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>1864  return %0 : vector<16xf32>1865}1866 1867// CHECK-LABEL: func @masked_load_with_alignment1868// CHECK: llvm.intr.masked.load %{{.*}} {alignment = 2 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>1869 1870// -----1871 1872//===----------------------------------------------------------------------===//1873// vector.maskedstore1874//===----------------------------------------------------------------------===//1875 1876func.func @masked_store(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>) {1877  %c0 = arith.constant 0: index1878  vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<16xi1>, vector<16xf32>1879  return1880}1881 1882// CHECK-LABEL: func @masked_store1883// CHECK: %[[CO:.*]] = arith.constant 0 : index1884// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i641885// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321886// CHECK: llvm.intr.masked.store %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr1887 1888// -----1889 1890func.func @masked_store_scalable(%arg0: memref<?xf32>, %arg1: vector<[16]xi1>, %arg2: vector<[16]xf32>) {1891  %c0 = arith.constant 0: index1892  vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<[16]xi1>, vector<[16]xf32>1893  return1894}1895 1896// CHECK-LABEL: func @masked_store_scalable1897// CHECK: %[[CO:.*]] = arith.constant 0 : index1898// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i641899// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f321900// CHECK: llvm.intr.masked.store %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<[16]xf32>, vector<[16]xi1> into !llvm.ptr1901 1902// -----1903 1904func.func @masked_store_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2: vector<16xindex>) {1905  %c0 = arith.constant 0: index1906  vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<16xi1>, vector<16xindex>1907  return1908}1909// CHECK-LABEL: func @masked_store_index1910// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<16xi64>, vector<16xi1> into !llvm.ptr1911 1912// -----1913 1914func.func @masked_store_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[16]xi1>, %arg2: vector<[16]xindex>) {1915  %c0 = arith.constant 0: index1916  vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<[16]xi1>, vector<[16]xindex>1917  return1918}1919// CHECK-LABEL: func @masked_store_index_scalable1920// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<[16]xi64>, vector<[16]xi1> into !llvm.ptr1921 1922// -----1923 1924func.func @masked_store_with_alignment(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>, %arg3: index) {1925  vector.maskedstore %arg0[%arg3], %arg1, %arg2 { alignment = 2 } : memref<?xf32>, vector<16xi1>, vector<16xf32>1926  return1927}1928 1929// CHECK-LABEL: func @masked_store_with_alignment1930// CHECK: llvm.intr.masked.store %{{.*}} {alignment = 2 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr1931 1932// -----1933 1934//===----------------------------------------------------------------------===//1935// vector.gather1936//===----------------------------------------------------------------------===//1937 1938func.func @gather(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) -> vector<3xf32> {1939  %0 = arith.constant 0: index1940  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32> into vector<3xf32>1941  return %1 : vector<3xf32>1942}1943 1944// CHECK-LABEL: func @gather1945// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi32>) -> vector<3x!llvm.ptr>, f321946// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>1947// CHECK: return %[[G]] : vector<3xf32>1948 1949// -----1950 1951func.func @gather_scalable(%arg0: memref<?xf32>, %arg1: vector<[3]xi32>, %arg2: vector<[3]xi1>, %arg3: vector<[3]xf32>) -> vector<[3]xf32> {1952  %0 = arith.constant 0: index1953  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<[3]xi32>, vector<[3]xi1>, vector<[3]xf32> into vector<[3]xf32>1954  return %1 : vector<[3]xf32>1955}1956 1957// CHECK-LABEL: func @gather_scalable1958// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi32>) -> vector<[3]x!llvm.ptr>, f321959// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>1960// CHECK: return %[[G]] : vector<[3]xf32>1961 1962// -----1963 1964func.func @gather_global_memory(%arg0: memref<?xf32, 1>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) -> vector<3xf32> {1965  %0 = arith.constant 0: index1966  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32, 1>, vector<3xi32>, vector<3xi1>, vector<3xf32> into vector<3xf32>1967  return %1 : vector<3xf32>1968}1969 1970// CHECK-LABEL: func @gather_global_memory1971// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<1>, vector<3xi32>) -> vector<3x!llvm.ptr<1>>, f321972// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr<1>>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>1973// CHECK: return %[[G]] : vector<3xf32>1974 1975// -----1976 1977func.func @gather_global_memory_scalable(%arg0: memref<?xf32, 1>, %arg1: vector<[3]xi32>, %arg2: vector<[3]xi1>, %arg3: vector<[3]xf32>) -> vector<[3]xf32> {1978  %0 = arith.constant 0: index1979  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32, 1>, vector<[3]xi32>, vector<[3]xi1>, vector<[3]xf32> into vector<[3]xf32>1980  return %1 : vector<[3]xf32>1981}1982 1983// CHECK-LABEL: func @gather_global_memory_scalable1984// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<1>, vector<[3]xi32>) -> vector<[3]x!llvm.ptr<1>>, f321985// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[3]x!llvm.ptr<1>>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>1986// CHECK: return %[[G]] : vector<[3]xf32>1987 1988// -----1989 1990 1991func.func @gather_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: vector<3xi1>, %arg3: vector<3xindex>) -> vector<3xindex> {1992  %0 = arith.constant 0: index1993  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<3xindex>, vector<3xi1>, vector<3xindex> into vector<3xindex>1994  return %1 : vector<3xindex>1995}1996 1997// CHECK-LABEL: func @gather_index1998// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi64>) -> vector<3x!llvm.ptr>, i641999// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xi64>) -> vector<3xi64>2000// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[G]] : vector<3xi64> to vector<3xindex>2001 2002// -----2003 2004func.func @gather_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[3]xindex>, %arg2: vector<[3]xi1>, %arg3: vector<[3]xindex>) -> vector<[3]xindex> {2005  %0 = arith.constant 0: index2006  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<[3]xindex>, vector<[3]xi1>, vector<[3]xindex> into vector<[3]xindex>2007  return %1 : vector<[3]xindex>2008}2009 2010// CHECK-LABEL: func @gather_index_scalable2011// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi64>) -> vector<[3]x!llvm.ptr>, i642012// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xi64>) -> vector<[3]xi64>2013// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[G]] : vector<[3]xi64> to vector<[3]xindex>2014 2015// -----2016 2017func.func @gather_1d_from_2d(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2: vector<4xi1>, %arg3: vector<4xf32>) -> vector<4xf32> {2018  %0 = arith.constant 3 : index2019  %1 = vector.gather %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x4xf32>, vector<4xi32>, vector<4xi1>, vector<4xf32> into vector<4xf32>2020  return %1 : vector<4xf32>2021}2022 2023// CHECK-LABEL: func @gather_1d_from_2d2024// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f322025// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<4xi32>) -> vector<4x!llvm.ptr>, f322026// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<4x!llvm.ptr>, vector<4xi1>, vector<4xf32>) -> vector<4xf32>2027// CHECK: return %[[G]] : vector<4xf32>2028 2029// -----2030 2031func.func @gather_1d_from_2d_scalable(%arg0: memref<4x?xf32>, %arg1: vector<[4]xi32>, %arg2: vector<[4]xi1>, %arg3: vector<[4]xf32>) -> vector<[4]xf32> {2032  %0 = arith.constant 3 : index2033  %1 = vector.gather %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x?xf32>, vector<[4]xi32>, vector<[4]xi1>, vector<[4]xf32> into vector<[4]xf32>2034  return %1 : vector<[4]xf32>2035}2036 2037// CHECK-LABEL: func @gather_1d_from_2d_scalable2038// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f322039// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<[4]xi32>) -> vector<[4]x!llvm.ptr>, f322040// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[4]x!llvm.ptr>, vector<[4]xi1>, vector<[4]xf32>) -> vector<[4]xf32>2041// CHECK: return %[[G]] : vector<[4]xf32>2042 2043// -----2044 2045func.func @gather_with_alignment(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>, %0: index) -> vector<3xf32> {2046  %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 {alignment = 8} : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32> into vector<3xf32>2047  return %1 : vector<3xf32>2048}2049 2050// CHECK-LABEL: func @gather_with_alignment2051// CHECK: llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>2052 2053// -----2054 2055//===----------------------------------------------------------------------===//2056// vector.scatter2057//===----------------------------------------------------------------------===//2058 2059func.func @scatter(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) {2060  %0 = arith.constant 0: index2061  vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32>2062  return2063}2064 2065// CHECK-LABEL: func @scatter2066// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi32>) -> vector<3x!llvm.ptr>, f322067// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>2068 2069// -----2070 2071func.func @scatter_scalable(%arg0: memref<?xf32>, %arg1: vector<[3]xi32>, %arg2: vector<[3]xi1>, %arg3: vector<[3]xf32>) {2072  %0 = arith.constant 0: index2073  vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<[3]xi32>, vector<[3]xi1>, vector<[3]xf32>2074  return2075}2076 2077// CHECK-LABEL: func @scatter_scalable2078// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi32>) -> vector<[3]x!llvm.ptr>, f322079// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<[3]xf32>, vector<[3]xi1> into vector<[3]x!llvm.ptr>2080 2081// -----2082 2083func.func @scatter_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: vector<3xi1>, %arg3: vector<3xindex>) {2084  %0 = arith.constant 0: index2085  vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<3xindex>, vector<3xi1>, vector<3xindex>2086  return2087}2088 2089// CHECK-LABEL: func @scatter_index2090// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi64>) -> vector<3x!llvm.ptr>, i642091// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 8 : i32} : vector<3xi64>, vector<3xi1> into vector<3x!llvm.ptr>2092 2093// -----2094 2095func.func @scatter_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[3]xindex>, %arg2: vector<[3]xi1>, %arg3: vector<[3]xindex>) {2096  %0 = arith.constant 0: index2097  vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<[3]xindex>, vector<[3]xi1>, vector<[3]xindex>2098  return2099}2100 2101// CHECK-LABEL: func @scatter_index_scalable2102// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi64>) -> vector<[3]x!llvm.ptr>, i642103// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 8 : i32} : vector<[3]xi64>, vector<[3]xi1> into vector<[3]x!llvm.ptr>2104 2105// -----2106 2107func.func @scatter_1d_into_2d(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2: vector<4xi1>, %arg3: vector<4xf32>) {2108  %0 = arith.constant 3 : index2109  vector.scatter %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x4xf32>, vector<4xi32>, vector<4xi1>, vector<4xf32>2110  return2111}2112 2113// CHECK-LABEL: func @scatter_1d_into_2d2114// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f322115// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<4xi32>) -> vector<4x!llvm.ptr>, f322116// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<4xf32>, vector<4xi1> into vector<4x!llvm.ptr>2117 2118// -----2119 2120func.func @scatter_1d_into_2d_scalable(%arg0: memref<4x?xf32>, %arg1: vector<[4]xi32>, %arg2: vector<[4]xi1>, %arg3: vector<[4]xf32>) {2121  %0 = arith.constant 3 : index2122  vector.scatter %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x?xf32>, vector<[4]xi32>, vector<[4]xi1>, vector<[4]xf32>2123  return2124}2125 2126// CHECK-LABEL: func @scatter_1d_into_2d_scalable2127// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f322128// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<[4]xi32>) -> vector<[4]x!llvm.ptr>, f322129// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<[4]xf32>, vector<[4]xi1> into vector<[4]x!llvm.ptr>2130 2131// -----2132 2133func.func @scatter_with_alignment(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>, %0: index) {2134  vector.scatter %arg0[%0][%arg1], %arg2, %arg3 { alignment = 8 } : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32>2135  return2136}2137 2138// CHECK-LABEL: func @scatter_with_alignment2139// CHECK: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>2140 2141 2142// -----2143 2144//===----------------------------------------------------------------------===//2145// vector.expandload2146//===----------------------------------------------------------------------===//2147 2148func.func @expand_load_op(%arg0: memref<?xf32>, %arg1: vector<11xi1>, %arg2: vector<11xf32>) -> vector<11xf32> {2149  %c0 = arith.constant 0: index2150  %0 = vector.expandload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<11xi1>, vector<11xf32> into vector<11xf32>2151  return %0 : vector<11xf32>2152}2153 2154// CHECK-LABEL: func @expand_load_op2155// CHECK: %[[CO:.*]] = arith.constant 0 : index2156// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i642157// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f322158// CHECK: %[[E:.*]] = "llvm.intr.masked.expandload"(%[[P]], %{{.*}}, %{{.*}}) : (!llvm.ptr, vector<11xi1>, vector<11xf32>) -> vector<11xf32>2159// CHECK: return %[[E]] : vector<11xf32>2160 2161// -----2162 2163func.func @expand_load_op_index(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>) -> vector<11xindex> {2164  %c0 = arith.constant 0: index2165  %0 = vector.expandload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<11xi1>, vector<11xindex> into vector<11xindex>2166  return %0 : vector<11xindex>2167}2168// CHECK-LABEL: func @expand_load_op_index2169// CHECK: %{{.*}} = "llvm.intr.masked.expandload"(%{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, vector<11xi1>, vector<11xi64>) -> vector<11xi64>2170 2171// -----2172 2173func.func @expand_load_op_with_alignment(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>, %c0: index) -> vector<11xindex> {2174  %0 = vector.expandload %arg0[%c0], %arg1, %arg2 { alignment = 8 } : memref<?xindex>, vector<11xi1>, vector<11xindex> into vector<11xindex>2175  return %0 : vector<11xindex>2176}2177// CHECK-LABEL: func @expand_load_op_with_alignment2178// CHECK: %{{.*}} = "llvm.intr.masked.expandload"(%{{.*}}, %{{.*}}, %{{.*}}) <{arg_attrs = [{llvm.align = 8 : i64}, {}, {}]}> : (!llvm.ptr, vector<11xi1>, vector<11xi64>) -> vector<11xi64>2179 2180// -----2181 2182//===----------------------------------------------------------------------===//2183// vector.compressstore2184//===----------------------------------------------------------------------===//2185 2186func.func @compress_store_op(%arg0: memref<?xf32>, %arg1: vector<11xi1>, %arg2: vector<11xf32>) {2187  %c0 = arith.constant 0: index2188  vector.compressstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<11xi1>, vector<11xf32>2189  return2190}2191 2192// CHECK-LABEL: func @compress_store_op2193// CHECK: %[[CO:.*]] = arith.constant 0 : index2194// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i642195// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f322196// CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %[[P]], %{{.*}}) : (vector<11xf32>, !llvm.ptr, vector<11xi1>) -> ()2197 2198// -----2199 2200func.func @compress_store_op_index(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>) {2201  %c0 = arith.constant 0: index2202  vector.compressstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<11xi1>, vector<11xindex>2203  return2204}2205// CHECK-LABEL: func @compress_store_op_index2206// CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<11xi64>, !llvm.ptr, vector<11xi1>) -> ()2207 2208// -----2209 2210func.func @compress_store_op_with_alignment(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>, %c0: index) {2211  vector.compressstore %arg0[%c0], %arg1, %arg2 { alignment = 8 } : memref<?xindex>, vector<11xi1>, vector<11xindex>2212  return2213}2214// CHECK-LABEL: func @compress_store_op_with_alignment2215// CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %{{.*}}, %{{.*}}) <{arg_attrs = [{}, {llvm.align = 8 : i64}, {}]}> : (vector<11xi64>, !llvm.ptr, vector<11xi1>) -> ()2216 2217// -----2218 2219//===----------------------------------------------------------------------===//2220// vector.scalable_insert2221//===----------------------------------------------------------------------===//2222 2223// CHECK-LABEL: @scalable_insert2224// CHECK-SAME: %[[SUB:.*]]: vector<4xf32>, %[[SV:.*]]: vector<[4]xf32>2225func.func @scalable_insert(%sub: vector<4xf32>, %dsv: vector<[4]xf32>) -> vector<[4]xf32> {2226  // CHECK-NEXT: %[[TMP:.*]] = llvm.intr.vector.insert %[[SUB]], %[[SV]][0] : vector<4xf32> into vector<[4]xf32>2227  %0 = vector.scalable.insert %sub, %dsv[0] : vector<4xf32> into vector<[4]xf32>2228  // CHECK-NEXT: llvm.intr.vector.insert %[[SUB]], %[[TMP]][4] : vector<4xf32> into vector<[4]xf32>2229  %1 = vector.scalable.insert %sub, %0[4] : vector<4xf32> into vector<[4]xf32>2230  return %1 : vector<[4]xf32>2231}2232 2233// -----2234 2235//===----------------------------------------------------------------------===//2236// vector.scalable_extract2237//===----------------------------------------------------------------------===//2238 2239// CHECK-LABEL: @scalable_extract2240// CHECK-SAME: %[[VEC:.*]]: vector<[4]xf32>2241func.func @scalable_extract(%vec: vector<[4]xf32>) -> vector<8xf32> {2242  // CHECK-NEXT: %{{.*}} = llvm.intr.vector.extract %[[VEC]][0] : vector<8xf32> from vector<[4]xf32>2243  %0 = vector.scalable.extract %vec[0] : vector<8xf32> from vector<[4]xf32>2244  return %0 : vector<8xf32>2245}2246 2247// -----2248 2249//===----------------------------------------------------------------------===//2250// vector.interleave2251//===----------------------------------------------------------------------===//2252 2253// CHECK-LABEL: @interleave_0d2254//  CHECK-SAME:     %[[LHS:.*]]: vector<i8>, %[[RHS:.*]]: vector<i8>)2255func.func @interleave_0d(%a: vector<i8>, %b: vector<i8>) -> vector<2xi8> {2256  // CHECK-DAG: %[[LHS_RANK1:.*]] = builtin.unrealized_conversion_cast %[[LHS]] : vector<i8> to vector<1xi8>2257  // CHECK-DAG: %[[RHS_RANK1:.*]] = builtin.unrealized_conversion_cast %[[RHS]] : vector<i8> to vector<1xi8>2258  // CHECK: %[[ZIP:.*]] = llvm.shufflevector %[[LHS_RANK1]], %[[RHS_RANK1]] [0, 1] : vector<1xi8>2259  // CHECK: return %[[ZIP]]2260  %0 = vector.interleave %a, %b : vector<i8> -> vector<2xi8>2261  return %0 : vector<2xi8>2262}2263 2264// -----2265 2266// CHECK-LABEL: @interleave_1d2267//  CHECK-SAME:     %[[LHS:.*]]: vector<8xf32>, %[[RHS:.*]]: vector<8xf32>)2268func.func @interleave_1d(%a: vector<8xf32>, %b: vector<8xf32>) -> vector<16xf32> {2269  // CHECK: %[[ZIP:.*]] = llvm.shufflevector %[[LHS]], %[[RHS]] [0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15] : vector<8xf32>2270  // CHECK: return %[[ZIP]]2271  %0 = vector.interleave %a, %b : vector<8xf32> -> vector<16xf32>2272  return %0 : vector<16xf32>2273}2274 2275// -----2276 2277// CHECK-LABEL: @interleave_1d_scalable2278//  CHECK-SAME:     %[[LHS:.*]]: vector<[4]xi32>, %[[RHS:.*]]: vector<[4]xi32>)2279func.func @interleave_1d_scalable(%a: vector<[4]xi32>, %b: vector<[4]xi32>) -> vector<[8]xi32> {2280  // CHECK: %[[ZIP:.*]] = "llvm.intr.vector.interleave2"(%[[LHS]], %[[RHS]]) : (vector<[4]xi32>, vector<[4]xi32>) -> vector<[8]xi32>2281  // CHECK: return %[[ZIP]]2282  %0 = vector.interleave %a, %b : vector<[4]xi32> -> vector<[8]xi32>2283  return %0 : vector<[8]xi32>2284}2285 2286// -----2287 2288//===----------------------------------------------------------------------===//2289// vector.deinterleave2290//===----------------------------------------------------------------------===//2291 2292// CHECK-LABEL: @deinterleave_1d2293// CHECK-SAME:  (%[[ARG:.*]]: vector<4xi32>) -> (vector<2xi32>, vector<2xi32>)2294func.func @deinterleave_1d(%arg: vector<4xi32>) -> (vector<2xi32>, vector<2xi32>) {2295  // CHECK: %[[POISON:.*]] = llvm.mlir.poison : vector<4xi32>2296  // CHECK: llvm.shufflevector %[[ARG]], %[[POISON]] [0, 2] : vector<4xi32>2297  // CHECK: llvm.shufflevector %[[ARG]], %[[POISON]] [1, 3] : vector<4xi32>2298  %0, %1 = vector.deinterleave %arg : vector<4xi32> -> vector<2xi32>2299  return %0, %1 : vector<2xi32>, vector<2xi32>2300}2301 2302// -----2303 2304// CHECK-LABEL: @deinterleave_1d_scalable2305// CHECK-SAME:  %[[ARG:.*]]: vector<[4]xi32>) -> (vector<[2]xi32>, vector<[2]xi32>)2306func.func @deinterleave_1d_scalable(%arg: vector<[4]xi32>) -> (vector<[2]xi32>, vector<[2]xi32>) {2307    // CHECK: %[[RES:.*]] = "llvm.intr.vector.deinterleave2"(%[[ARG]]) : (vector<[4]xi32>) -> !llvm.struct<(vector<[2]xi32>, vector<[2]xi32>)>2308    // CHECK: llvm.extractvalue %[[RES]][0] : !llvm.struct<(vector<[2]xi32>, vector<[2]xi32>)>2309    // CHECK: llvm.extractvalue %[[RES]][1] : !llvm.struct<(vector<[2]xi32>, vector<[2]xi32>)>2310    %0, %1 = vector.deinterleave %arg : vector<[4]xi32> -> vector<[2]xi32>2311    return %0, %1 : vector<[2]xi32>, vector<[2]xi32>2312}2313 2314// -----2315 2316//===----------------------------------------------------------------------===//2317// vector.from_elements2318//===----------------------------------------------------------------------===//2319 2320// CHECK-LABEL: func.func @from_elements_1d(2321//  CHECK-SAME:     %[[ARG_0:.*]]: f32, %[[ARG_1:.*]]: f32)2322//       CHECK:   %[[UNDEF:.*]] = llvm.mlir.poison : vector<3xf32>2323//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i642324//       CHECK:   %[[INSERT0:.*]] = llvm.insertelement %[[ARG_0]], %[[UNDEF]][%[[C0]] : i64] : vector<3xf32>2325//       CHECK:   %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i642326//       CHECK:   %[[INSERT1:.*]] = llvm.insertelement %[[ARG_1]], %[[INSERT0]][%[[C1]] : i64] : vector<3xf32>2327//       CHECK:   %[[C2:.*]] = llvm.mlir.constant(2 : i64) : i642328//       CHECK:   %[[INSERT2:.*]] = llvm.insertelement %[[ARG_0]], %[[INSERT1]][%[[C2]] : i64] : vector<3xf32>2329//       CHECK:   return %[[INSERT2]]2330func.func @from_elements_1d(%arg0: f32, %arg1: f32) -> vector<3xf32> {2331  %0 = vector.from_elements %arg0, %arg1, %arg0 : vector<3xf32>2332  return %0 : vector<3xf32>2333}2334 2335// -----2336 2337// CHECK-LABEL: func.func @from_elements_0d(2338//  CHECK-SAME:     %[[ARG_0:.*]]: f32)2339//       CHECK:   %[[UNDEF:.*]] = llvm.mlir.poison : vector<1xf32>2340//       CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i642341//       CHECK:   %[[INSERT0:.*]] = llvm.insertelement %[[ARG_0]], %[[UNDEF]][%[[C0]] : i64] : vector<1xf32>2342//       CHECK:   %[[CAST:.*]] = builtin.unrealized_conversion_cast %[[INSERT0]] : vector<1xf32> to vector<f32>2343//       CHECK:   return %[[CAST]]2344func.func @from_elements_0d(%arg0: f32) -> vector<f32> {2345  %0 = vector.from_elements %arg0 : vector<f32>2346  return %0 : vector<f32>2347}2348 2349// -----2350 2351//===----------------------------------------------------------------------===//2352// vector.to_elements2353//===----------------------------------------------------------------------===//2354 2355// CHECK-LABEL: func.func @to_elements_no_dead_elements2356 // CHECK-SAME:     %[[A:.*]]: vector<4xf32>)2357 //      CHECK:   %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i642358 //      CHECK:   %[[ELEM0:.*]] = llvm.extractelement %[[A]][%[[C0]] : i64] : vector<4xf32>2359 //      CHECK:   %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i642360 //      CHECK:   %[[ELEM1:.*]] = llvm.extractelement %[[A]][%[[C1]] : i64] : vector<4xf32>2361 //      CHECK:   %[[C2:.*]] = llvm.mlir.constant(2 : i64) : i642362 //      CHECK:   %[[ELEM2:.*]] = llvm.extractelement %[[A]][%[[C2]] : i64] : vector<4xf32>2363 //      CHECK:   %[[C3:.*]] = llvm.mlir.constant(3 : i64) : i642364 //      CHECK:   %[[ELEM3:.*]] = llvm.extractelement %[[A]][%[[C3]] : i64] : vector<4xf32>2365 //      CHECK:   return %[[ELEM0]], %[[ELEM1]], %[[ELEM2]], %[[ELEM3]] : f32, f32, f32, f322366func.func @to_elements_no_dead_elements(%a: vector<4xf32>) -> (f32, f32, f32, f32) {2367  %0:4 = vector.to_elements %a : vector<4xf32>2368  return %0#0, %0#1, %0#2, %0#3 : f32, f32, f32, f322369}2370 2371// -----2372 2373// CHECK-LABEL: func.func @to_elements_dead_elements2374 // CHECK-SAME:     %[[A:.*]]: vector<4xf32>)2375 //  CHECK-NOT:   llvm.mlir.constant(0 : i64) : i642376 //      CHECK:   %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i642377 //      CHECK:   %[[ELEM1:.*]] = llvm.extractelement %[[A]][%[[C1]] : i64] : vector<4xf32>2378 //  CHECK-NOT:   llvm.mlir.constant(2 : i64) : i642379 //      CHECK:   %[[C3:.*]] = llvm.mlir.constant(3 : i64) : i642380 //      CHECK:   %[[ELEM3:.*]] = llvm.extractelement %[[A]][%[[C3]] : i64] : vector<4xf32>2381 //      CHECK:   return %[[ELEM1]], %[[ELEM3]] : f32, f322382func.func @to_elements_dead_elements(%a: vector<4xf32>) -> (f32, f32) {2383  %0:4 = vector.to_elements %a : vector<4xf32>2384  return %0#1, %0#3 : f32, f322385}2386 2387// -----2388 2389//===----------------------------------------------------------------------===//2390// vector.step2391//===----------------------------------------------------------------------===//2392 2393// CHECK-LABEL: @step_scalable2394// CHECK: %[[STEPVECTOR:.*]] = llvm.intr.stepvector : vector<[4]xi64>2395// CHECK: %[[CAST:.*]] = builtin.unrealized_conversion_cast %[[STEPVECTOR]] : vector<[4]xi64> to vector<[4]xindex>2396// CHECK: return %[[CAST]] : vector<[4]xindex>2397func.func @step_scalable() -> vector<[4]xindex> {2398  %0 = vector.step : vector<[4]xindex>2399  return %0 : vector<[4]xindex>2400}2401