292 lines · plain
1// RUN: mlir-opt %s --test-vector-gather-lowering | FileCheck %s2// RUN: mlir-opt %s --test-vector-gather-lowering --canonicalize | FileCheck %s --check-prefix=CANON3 4// CHECK-LABEL: @gather_memref_1d5// CHECK-SAME: ([[BASE:%.+]]: memref<?xf32>, [[IDXVEC:%.+]]: vector<2xindex>, [[MASK:%.+]]: vector<2xi1>, [[PASS:%.+]]: vector<2xf32>)6// CHECK-DAG: [[M0:%.+]] = vector.extract [[MASK]][0] : i1 from vector<2xi1>7// CHECK-DAG: %[[IDX0:.+]] = vector.extract [[IDXVEC]][0] : index from vector<2xindex>8// CHECK-NEXT: [[RES0:%.+]] = scf.if [[M0]] -> (vector<2xf32>)9// CHECK-NEXT: [[LD0:%.+]] = vector.load [[BASE]][%[[IDX0]]] : memref<?xf32>, vector<1xf32>10// CHECK-NEXT: [[ELEM0:%.+]] = vector.extract [[LD0]][0] : f32 from vector<1xf32>11// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[ELEM0]], [[PASS]] [0] : f32 into vector<2xf32>12// CHECK-NEXT: scf.yield [[INS0]] : vector<2xf32>13// CHECK-NEXT: else14// CHECK-NEXT: scf.yield [[PASS]] : vector<2xf32>15// CHECK-DAG: [[M1:%.+]] = vector.extract [[MASK]][1] : i1 from vector<2xi1>16// CHECK-DAG: %[[IDX1:.+]] = vector.extract [[IDXVEC]][1] : index from vector<2xindex>17// CHECK-NEXT: [[RES1:%.+]] = scf.if [[M1]] -> (vector<2xf32>)18// CHECK-NEXT: [[LD1:%.+]] = vector.load [[BASE]][%[[IDX1]]] : memref<?xf32>, vector<1xf32>19// CHECK-NEXT: [[ELEM1:%.+]] = vector.extract [[LD1]][0] : f32 from vector<1xf32>20// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[ELEM1]], [[RES0]] [1] : f32 into vector<2xf32>21// CHECK-NEXT: scf.yield [[INS1]] : vector<2xf32>22// CHECK-NEXT: else23// CHECK-NEXT: scf.yield [[RES0]] : vector<2xf32>24// CHECK: return [[RES1]] : vector<2xf32>25func.func @gather_memref_1d(%base: memref<?xf32>, %v: vector<2xindex>, %mask: vector<2xi1>, %pass_thru: vector<2xf32>) -> vector<2xf32> {26 %c0 = arith.constant 0 : index27 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : memref<?xf32>, vector<2xindex>, vector<2xi1>, vector<2xf32> into vector<2xf32>28 return %0 : vector<2xf32>29}30 31// CHECK-LABEL: @gather_memref_1d_i32_index32// CHECK-SAME: ([[BASE:%.+]]: memref<?xf32>, [[IDXVEC:%.+]]: vector<2xi32>, [[MASK:%.+]]: vector<2xi1>, [[PASS:%.+]]: vector<2xf32>)33// CHECK-DAG: [[C42:%.+]] = arith.constant 42 : index34// CHECK-DAG: [[IDXS:%.+]] = arith.index_cast [[IDXVEC]] : vector<2xi32> to vector<2xindex>35// CHECK-DAG: [[IDX0:%.+]] = vector.extract [[IDXS]][0] : index from vector<2xindex>36// CHECK-NEXT: %[[OFF0:.+]] = arith.addi [[IDX0]], [[C42]] : index37// CHECK-NEXT: [[RES0:%.+]] = scf.if38// CHECK-NEXT: [[LD0:%.+]] = vector.load [[BASE]][%[[OFF0]]] : memref<?xf32>, vector<1xf32>39// CHECK: else40// CHECK: [[IDX1:%.+]] = vector.extract [[IDXS]][1] : index from vector<2xindex>41// CHECK: %[[OFF1:.+]] = arith.addi [[IDX1]], [[C42]] : index42// CHECK: [[RES1:%.+]] = scf.if43// CHECK-NEXT: [[LD1:%.+]] = vector.load [[BASE]][%[[OFF1]]] : memref<?xf32>, vector<1xf32>44// CHECK: else45// CHECK: return [[RES1]] : vector<2xf32>46func.func @gather_memref_1d_i32_index(%base: memref<?xf32>, %v: vector<2xi32>, %mask: vector<2xi1>, %pass_thru: vector<2xf32>) -> vector<2xf32> {47 %c0 = arith.constant 42 : index48 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : memref<?xf32>, vector<2xi32>, vector<2xi1>, vector<2xf32> into vector<2xf32>49 return %0 : vector<2xf32>50}51 52// CHECK-LABEL: @gather_memref_2d53// CHECK-SAME: ([[BASE:%.+]]: memref<?x?xf32>, [[IDXVEC:%.+]]: vector<2x3xindex>, [[MASK:%.+]]: vector<2x3xi1>, [[PASS:%.+]]: vector<2x3xf32>)54// CHECK-DAG: %[[C0:.+]] = arith.constant 0 : index55// CHECK-DAG: %[[C1:.+]] = arith.constant 1 : index56// CHECK-DAG: [[PTV0:%.+]] = vector.extract [[PASS]][0] : vector<3xf32> from vector<2x3xf32>57// CHECK-DAG: [[M0:%.+]] = vector.extract [[MASK]][0, 0] : i1 from vector<2x3xi1>58// CHECK-DAG: [[IDX0:%.+]] = vector.extract [[IDXVEC]][0, 0] : index from vector<2x3xindex>59// CHECK-NEXT: %[[OFF0:.+]] = arith.addi [[IDX0]], %[[C1]] : index60// CHECK-NEXT: [[RES0:%.+]] = scf.if [[M0]] -> (vector<3xf32>)61// CHECK-NEXT: [[LD0:%.+]] = vector.load [[BASE]][%[[C0]], %[[OFF0]]] : memref<?x?xf32>, vector<1xf32>62// CHECK-NEXT: [[ELEM0:%.+]] = vector.extract [[LD0]][0] : f32 from vector<1xf32>63// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[ELEM0]], [[PTV0]] [0] : f32 into vector<3xf32>64// CHECK-NEXT: scf.yield [[INS0]] : vector<3xf32>65// CHECK-NEXT: else66// CHECK-NEXT: scf.yield [[PTV0]] : vector<3xf32>67// CHECK-COUNT-5: scf.if68// CHECK: [[FINAL:%.+]] = vector.insert %{{.+}}, %{{.+}} [1] : vector<3xf32> into vector<2x3xf32>69// CHECK-NEXT: return [[FINAL]] : vector<2x3xf32>70 func.func @gather_memref_2d(%base: memref<?x?xf32>, %v: vector<2x3xindex>, %mask: vector<2x3xi1>, %pass_thru: vector<2x3xf32>) -> vector<2x3xf32> {71 %c0 = arith.constant 0 : index72 %c1 = arith.constant 1 : index73 %0 = vector.gather %base[%c0, %c1][%v], %mask, %pass_thru : memref<?x?xf32>, vector<2x3xindex>, vector<2x3xi1>, vector<2x3xf32> into vector<2x3xf32>74 return %0 : vector<2x3xf32>75 }76 77// CHECK-LABEL: @scalable_gather_memref_2d78// CHECK-SAME: %[[BASE:.*]]: memref<?x?xf32>,79// CHECK-SAME: %[[IDXVEC:.*]]: vector<2x[3]xindex>,80// CHECK-SAME: %[[MASK:.*]]: vector<2x[3]xi1>,81// CHECK-SAME: %[[PASS:.*]]: vector<2x[3]xf32>82// CHECK: %[[C0:.*]] = arith.constant 0 : index83// CHECK: %[[C1:.*]] = arith.constant 1 : index84// CHECK: %[[INIT:.*]] = ub.poison : vector<2x[3]xf32>85// CHECK: %[[IDXVEC0:.*]] = vector.extract %[[IDXVEC]][0] : vector<[3]xindex> from vector<2x[3]xindex>86// CHECK: %[[MASK0:.*]] = vector.extract %[[MASK]][0] : vector<[3]xi1> from vector<2x[3]xi1>87// CHECK: %[[PASS0:.*]] = vector.extract %[[PASS]][0] : vector<[3]xf32> from vector<2x[3]xf32>88// CHECK: %[[GATHER0:.*]] = vector.gather %[[BASE]]{{\[}}%[[C0]], %[[C1]]] {{\[}}%[[IDXVEC0]]], %[[MASK0]], %[[PASS0]] : memref<?x?xf32>, vector<[3]xindex>, vector<[3]xi1>, vector<[3]xf32> into vector<[3]xf32>89// CHECK: %[[INS0:.*]] = vector.insert %[[GATHER0]], %[[INIT]] [0] : vector<[3]xf32> into vector<2x[3]xf32>90// CHECK: %[[IDXVEC1:.*]] = vector.extract %[[IDXVEC]][1] : vector<[3]xindex> from vector<2x[3]xindex>91// CHECK: %[[MASK1:.*]] = vector.extract %[[MASK]][1] : vector<[3]xi1> from vector<2x[3]xi1>92// CHECK: %[[PASS1:.*]] = vector.extract %[[PASS]][1] : vector<[3]xf32> from vector<2x[3]xf32>93// CHECK: %[[GATHER1:.*]] = vector.gather %[[BASE]]{{\[}}%[[C0]], %[[C1]]] {{\[}}%[[IDXVEC1]]], %[[MASK1]], %[[PASS1]] : memref<?x?xf32>, vector<[3]xindex>, vector<[3]xi1>, vector<[3]xf32> into vector<[3]xf32>94// CHECK: %[[INS1:.*]] = vector.insert %[[GATHER1]], %[[INS0]] [1] : vector<[3]xf32> into vector<2x[3]xf32>95// CHECK-NEXT: return %[[INS1]] : vector<2x[3]xf32>96func.func @scalable_gather_memref_2d(%base: memref<?x?xf32>, %v: vector<2x[3]xindex>, %mask: vector<2x[3]xi1>, %pass_thru: vector<2x[3]xf32>) -> vector<2x[3]xf32> {97 %c0 = arith.constant 0 : index98 %c1 = arith.constant 1 : index99 %0 = vector.gather %base[%c0, %c1][%v], %mask, %pass_thru : memref<?x?xf32>, vector<2x[3]xindex>, vector<2x[3]xi1>, vector<2x[3]xf32> into vector<2x[3]xf32>100 return %0 : vector<2x[3]xf32>101}102 103// CHECK-LABEL: @scalable_gather_memref_2d_with_alignment104// CHECK: vector.gather105// CHECK-SAME: {alignment = 8 : i64}106// CHECK: vector.gather107// CHECK-SAME: {alignment = 8 : i64}108func.func @scalable_gather_memref_2d_with_alignment(%base: memref<?x?xf32>, %v: vector<2x[3]xindex>, %mask: vector<2x[3]xi1>, %pass_thru: vector<2x[3]xf32>) -> vector<2x[3]xf32> {109 %c0 = arith.constant 0 : index110 %c1 = arith.constant 1 : index111 %0 = vector.gather %base[%c0, %c1][%v], %mask, %pass_thru {alignment = 8} : memref<?x?xf32>, vector<2x[3]xindex>, vector<2x[3]xi1>, vector<2x[3]xf32> into vector<2x[3]xf32>112 return %0 : vector<2x[3]xf32>113}114 115// CHECK-LABEL: @scalable_gather_cant_unroll116// CHECK-NOT: extract117// CHECK: vector.gather118// CHECK-NOT: extract119func.func @scalable_gather_cant_unroll(%base: memref<?x?xf32>, %v: vector<[4]x8xindex>, %mask: vector<[4]x8xi1>, %pass_thru: vector<[4]x8xf32>) -> vector<[4]x8xf32> {120 %c0 = arith.constant 0 : index121 %c1 = arith.constant 1 : index122 %0 = vector.gather %base[%c0, %c1][%v], %mask, %pass_thru : memref<?x?xf32>, vector<[4]x8xindex>, vector<[4]x8xi1>, vector<[4]x8xf32> into vector<[4]x8xf32>123 return %0 : vector<[4]x8xf32>124}125 126// CHECK-LABEL: @gather_tensor_1d127// CHECK-SAME: ([[BASE:%.+]]: tensor<?xf32>, [[IDXVEC:%.+]]: vector<2xindex>, [[MASK:%.+]]: vector<2xi1>, [[PASS:%.+]]: vector<2xf32>)128// CHECK-DAG: [[M0:%.+]] = vector.extract [[MASK]][0] : i1 from vector<2xi1>129// CHECK-DAG: %[[IDX0:.+]] = vector.extract [[IDXVEC]][0] : index from vector<2xindex>130// CHECK-NEXT: [[RES0:%.+]] = scf.if [[M0]] -> (vector<2xf32>)131// CHECK-NEXT: [[ELEM0:%.+]] = tensor.extract [[BASE]][%[[IDX0]]] : tensor<?xf32>132// CHECK-NEXT: [[INS0:%.+]] = vector.insert [[ELEM0]], [[PASS]] [0] : f32 into vector<2xf32>133// CHECK-NEXT: scf.yield [[INS0]] : vector<2xf32>134// CHECK-NEXT: else135// CHECK-NEXT: scf.yield [[PASS]] : vector<2xf32>136// CHECK-DAG: [[M1:%.+]] = vector.extract [[MASK]][1] : i1 from vector<2xi1>137// CHECK-DAG: %[[IDX1:.+]] = vector.extract [[IDXVEC]][1] : index from vector<2xindex>138// CHECK-NEXT: [[RES1:%.+]] = scf.if [[M1]] -> (vector<2xf32>)139// CHECK-NEXT: [[ELEM1:%.+]] = tensor.extract [[BASE]][%[[IDX1]]] : tensor<?xf32>140// CHECK-NEXT: [[INS1:%.+]] = vector.insert [[ELEM1]], [[RES0]] [1] : f32 into vector<2xf32>141// CHECK-NEXT: scf.yield [[INS1]] : vector<2xf32>142// CHECK-NEXT: else143// CHECK-NEXT: scf.yield [[RES0]] : vector<2xf32>144// CHECK: return [[RES1]] : vector<2xf32>145func.func @gather_tensor_1d(%base: tensor<?xf32>, %v: vector<2xindex>, %mask: vector<2xi1>, %pass_thru: vector<2xf32>) -> vector<2xf32> {146 %c0 = arith.constant 0 : index147 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : tensor<?xf32>, vector<2xindex>, vector<2xi1>, vector<2xf32> into vector<2xf32>148 return %0 : vector<2xf32>149}150 151// CHECK-LABEL: @gather_memref_non_unit_stride_read_1_element152// CHECK: %[[MASK:.*]] = vector.extract %arg2[0] : i1 from vector<1xi1>153// CHECK: %[[IDX:.*]] = vector.extract %arg1[0] : index from vector<1xindex>154// CHECK: %[[RET:.*]] = scf.if %[[MASK]] -> (vector<1xf32>) {155// CHECK: %[[VEC:.*]] = vector.load %arg0[%[[IDX]]] : memref<4xf32, strided<[2]>>, vector<1xf32>156// CHECK: %[[VAL:.*]] = vector.extract %[[VEC]][0] : f32 from vector<1xf32>157// CHECK: %[[RES:.*]] = vector.insert %[[VAL]], %arg3 [0] : f32 into vector<1xf32>158// CHECK: scf.yield %[[RES]] : vector<1xf32>159// CHECK: } else {160// CHECK: scf.yield %arg3 : vector<1xf32>161// CHECK: }162// CHECK: return %[[RET]] : vector<1xf32>163func.func @gather_memref_non_unit_stride_read_1_element(%base: memref<4xf32, strided<[2]>>, %v: vector<1xindex>, %mask: vector<1xi1>, %pass_thru: vector<1xf32>) -> vector<1xf32> {164 %c0 = arith.constant 0 : index165 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : memref<4xf32, strided<[2]>>, vector<1xindex>, vector<1xi1>, vector<1xf32> into vector<1xf32>166 return %0 : vector<1xf32>167}168 169// CHECK-LABEL: @gather_memref_non_unit_stride_read_more_than_1_element170// CHECK: %[[CONST:.*]] = arith.constant 0 : index171// CHECK: %[[RET:.*]] = vector.gather %arg0[%[[CONST]]] [%arg1], %arg2, %arg3 : memref<4xf32, strided<[2]>>, vector<2xindex>, vector<2xi1>, vector<2xf32> into vector<2xf32>172// CHECK: return %[[RET]] : vector<2xf32>173func.func @gather_memref_non_unit_stride_read_more_than_1_element(%base: memref<4xf32, strided<[2]>>, %v: vector<2xindex>, %mask: vector<2xi1>, %pass_thru: vector<2xf32>) -> vector<2xf32> {174 %c0 = arith.constant 0 : index175 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : memref<4xf32, strided<[2]>>, vector<2xindex>, vector<2xi1>, vector<2xf32> into vector<2xf32>176 return %0 : vector<2xf32>177}178 179// CHECK-LABEL: @gather_tensor_2d180// CHECK: scf.if181// CHECK: tensor.extract182// CHECK: else183// CHECK: scf.if184// CHECK: tensor.extract185// CHECK: else186// CHECK: scf.if187// CHECK: tensor.extract188// CHECK: else189// CHECK: scf.if190// CHECK: tensor.extract191// CHECK: else192// CHECK: scf.if193// CHECK: tensor.extract194// CHECK: else195// CHECK: scf.if196// CHECK: tensor.extract197// CHECK: else198// CHECK: [[FINAL:%.+]] = vector.insert %{{.+}}, %{{.+}} [1] : vector<3xf32> into vector<2x3xf32>199// CHECK-NEXT: return [[FINAL]] : vector<2x3xf32>200 func.func @gather_tensor_2d(%base: tensor<?x?xf32>, %v: vector<2x3xindex>, %mask: vector<2x3xi1>, %pass_thru: vector<2x3xf32>) -> vector<2x3xf32> {201 %c0 = arith.constant 0 : index202 %c1 = arith.constant 1 : index203 %0 = vector.gather %base[%c0, %c1][%v], %mask, %pass_thru : tensor<?x?xf32>, vector<2x3xindex>, vector<2x3xi1>, vector<2x3xf32> into vector<2x3xf32>204 return %0 : vector<2x3xf32>205 }206 207// Check that all-set and no-set maskes get optimized out after canonicalization.208 209// CANON-LABEL: @gather_tensor_1d_all_set210// CANON-NOT: scf.if211// CANON: tensor.extract212// CANON: tensor.extract213// CANON: [[FINAL:%.+]] = vector.from_elements %{{.+}}, %{{.+}} : vector<2xf32>214// CANON-NEXT: return [[FINAL]] : vector<2xf32>215func.func @gather_tensor_1d_all_set(%base: tensor<?xf32>, %v: vector<2xindex>, %pass_thru: vector<2xf32>) -> vector<2xf32> {216 %mask = arith.constant dense <true> : vector<2xi1>217 %c0 = arith.constant 0 : index218 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : tensor<?xf32>, vector<2xindex>, vector<2xi1>, vector<2xf32> into vector<2xf32>219 return %0 : vector<2xf32>220}221 222// CANON-LABEL: @gather_tensor_1d_none_set223// CANON-SAME: ([[BASE:%.+]]: tensor<?xf32>, [[IDXVEC:%.+]]: vector<2xindex>, [[PASS:%.+]]: vector<2xf32>)224// CANON-NEXT: return [[PASS]] : vector<2xf32>225func.func @gather_tensor_1d_none_set(%base: tensor<?xf32>, %v: vector<2xindex>, %pass_thru: vector<2xf32>) -> vector<2xf32> {226 %mask = arith.constant dense <false> : vector<2xi1>227 %c0 = arith.constant 0 : index228 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : tensor<?xf32>, vector<2xindex>, vector<2xi1>, vector<2xf32> into vector<2xf32>229 return %0 : vector<2xf32>230}231 232// Check that vector.gather of a strided memref is replaced with a233// vector.gather with indices encoding the original strides. Note that multiple234// patterns are run for this example, e.g.:235 // 1. "remove stride from gather source"236 // 2. "flatten gather"237// However, the main goal is to the test Pattern 1 above.238#map = affine_map<()[s0] -> (s0 * 4096)>239func.func @strided_gather(%base : memref<100x3xf32>,240 %idxs : vector<4xindex>,241 %x : index, %y : index) -> vector<4xf32> {242 %c0 = arith.constant 0 : index243 %x_1 = affine.apply #map()[%x]244 // Strided MemRef245 %subview = memref.subview %base[0, 0] [100, 1] [1, 1] : memref<100x3xf32> to memref<100xf32, strided<[3]>>246 %mask = arith.constant dense<true> : vector<4xi1>247 %pass_thru = arith.constant dense<0.000000e+00> : vector<4xf32>248 // Gather of a strided MemRef249 %res = vector.gather %subview[%c0] [%idxs], %mask, %pass_thru {alignment = 8} : memref<100xf32, strided<[3]>>, vector<4xindex>, vector<4xi1>, vector<4xf32> into vector<4xf32>250 return %res : vector<4xf32>251}252// CHECK-LABEL: func.func @strided_gather(253// CHECK-SAME: %[[base:.*]]: memref<100x3xf32>,254// CHECK-SAME: %[[IDXS:.*]]: vector<4xindex>,255// CHECK-SAME: %[[VAL_4:.*]]: index,256// CHECK-SAME: %[[VAL_5:.*]]: index) -> vector<4xf32> {257// CHECK: %[[TRUE:.*]] = arith.constant true258// CHECK: %[[CST_3:.*]] = arith.constant dense<3> : vector<4xindex>259 260// CHECK: %[[COLLAPSED:.*]] = memref.collapse_shape %[[base]] {{\[\[}}0, 1]] : memref<100x3xf32> into memref<300xf32>261// CHECK: %[[NEW_IDXS:.*]] = arith.muli %[[IDXS]], %[[CST_3]] : vector<4xindex>262 263// CHECK: %[[IDX_0:.*]] = vector.extract %[[NEW_IDXS]][0] : index from vector<4xindex>264// CHECK: scf.if %[[TRUE]] -> (vector<4xf32>)265// CHECK: %[[M_0:.*]] = vector.load %[[COLLAPSED]][%[[IDX_0]]] {alignment = 8 : i64} : memref<300xf32>, vector<1xf32>266// CHECK: %[[V_0:.*]] = vector.extract %[[M_0]][0] : f32 from vector<1xf32>267 268// CHECK: %[[IDX_1:.*]] = vector.extract %[[NEW_IDXS]][1] : index from vector<4xindex>269// CHECK: scf.if %[[TRUE]] -> (vector<4xf32>)270// CHECK: %[[M_1:.*]] = vector.load %[[COLLAPSED]][%[[IDX_1]]] {alignment = 8 : i64} : memref<300xf32>, vector<1xf32>271// CHECK: %[[V_1:.*]] = vector.extract %[[M_1]][0] : f32 from vector<1xf32>272 273// CHECK: %[[IDX_2:.*]] = vector.extract %[[NEW_IDXS]][2] : index from vector<4xindex>274// CHECK: scf.if %[[TRUE]] -> (vector<4xf32>)275// CHECK: %[[M_2:.*]] = vector.load %[[COLLAPSED]][%[[IDX_2]]] {alignment = 8 : i64} : memref<300xf32>, vector<1xf32>276// CHECK: %[[V_2:.*]] = vector.extract %[[M_2]][0] : f32 from vector<1xf32>277 278// CHECK: %[[IDX_3:.*]] = vector.extract %[[NEW_IDXS]][3] : index from vector<4xindex>279// CHECK: scf.if %[[TRUE]] -> (vector<4xf32>)280// CHECK: %[[M_3:.*]] = vector.load %[[COLLAPSED]][%[[IDX_3]]] {alignment = 8 : i64} : memref<300xf32>, vector<1xf32>281// CHECK: %[[V_3:.*]] = vector.extract %[[M_3]][0] : f32 from vector<1xf32>282 283// CHECK-LABEL: @scalable_gather_1d284// CHECK-NOT: extract285// CHECK: vector.gather286// CHECK-NOT: extract287func.func @scalable_gather_1d(%base: tensor<?xf32>, %v: vector<[2]xindex>, %mask: vector<[2]xi1>, %pass_thru: vector<[2]xf32>) -> vector<[2]xf32> {288 %c0 = arith.constant 0 : index289 %0 = vector.gather %base[%c0][%v], %mask, %pass_thru : tensor<?xf32>, vector<[2]xindex>, vector<[2]xi1>, vector<[2]xf32> into vector<[2]xf32>290 return %0 : vector<[2]xf32>291}292