394 lines · plain
1// RUN: mlir-opt %s -convert-vector-to-llvm -split-input-file | FileCheck %s2// RUN: mlir-opt %s -convert-vector-to-llvm='reassociate-fp-reductions' -split-input-file | FileCheck %s --check-prefix=REASSOC3 4// CHECK-LABEL: @reduce_add_f32(5// CHECK-SAME: %[[A:.*]]: vector<16xf32>)6// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f327// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])8// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<16xf32>) -> f329// CHECK: return %[[V]] : f3210//11// REASSOC-LABEL: @reduce_add_f32(12// REASSOC-SAME: %[[A:.*]]: vector<16xf32>)13// REASSOC: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f3214// REASSOC: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])15// REASSOC-SAME: <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<16xf32>) -> f3216// REASSOC: return %[[V]] : f3217//18func.func @reduce_add_f32(%arg0: vector<16xf32>) -> f32 {19 %0 = vector.reduction <add>, %arg0 : vector<16xf32> into f3220 return %0 : f3221}22 23// -----24 25// CHECK-LABEL: @reduce_add_f32_always_reassoc(26// CHECK-SAME: %[[A:.*]]: vector<16xf32>)27// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f3228// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])29/// Note: the reassoc flag remains even though the pass sets reassociate-fp-reduction to false.30/// Ponder whether this flag really is a property of the pass / pattern..31// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<16xf32>) -> f3232// CHECK: return %[[V]] : f3233//34// REASSOC-LABEL: @reduce_add_f32_always_reassoc(35// REASSOC-SAME: %[[A:.*]]: vector<16xf32>)36// REASSOC: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f3237// REASSOC: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])38// REASSOC-SAME: <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<16xf32>) -> f3239// REASSOC: return %[[V]] : f3240//41func.func @reduce_add_f32_always_reassoc(%arg0: vector<16xf32>) -> f32 {42 %0 = vector.reduction <add>, %arg0 fastmath<reassoc> : vector<16xf32> into f3243 return %0 : f3244}45 46// -----47 48// CHECK-LABEL: @reduce_mul_f32(49// CHECK-SAME: %[[A:.*]]: vector<16xf32>)50// CHECK: %[[C:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f3251// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fmul"(%[[C]], %[[A]])52// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<nnan, ninf>}> : (f32, vector<16xf32>) -> f3253// CHECK: return %[[V]] : f3254//55// REASSOC-LABEL: @reduce_mul_f32(56// REASSOC-SAME: %[[A:.*]]: vector<16xf32>)57// REASSOC: %[[C:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f3258// REASSOC: %[[V:.*]] = "llvm.intr.vector.reduce.fmul"(%[[C]], %[[A]])59// REASSOC-SAME: <{fastmathFlags = #llvm.fastmath<nnan, ninf, reassoc>}> : (f32, vector<16xf32>) -> f3260// REASSOC: return %[[V]] : f3261//62func.func @reduce_mul_f32(%arg0: vector<16xf32>) -> f32 {63 %0 = vector.reduction <mul>, %arg0 fastmath<nnan, ninf> : vector<16xf32> into f3264 return %0 : f3265}66 67// -----68 69func.func @masked_reduce_add_f32(%arg0: vector<16xf32>, %mask : vector<16xi1>) -> f32 {70 %0 = vector.mask %mask { vector.reduction <add>, %arg0 : vector<16xf32> into f32 } : vector<16xi1> -> f3271 return %0 : f3272}73 74// CHECK-LABEL: func.func @masked_reduce_add_f32(75// CHECK-SAME: %[[INPUT:.*]]: vector<16xf32>,76// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>) -> f32 {77// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f3278// CHECK: %[[VL:.*]] = llvm.mlir.constant(16 : i32) : i3279// CHECK: "llvm.intr.vp.reduce.fadd"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (f32, vector<16xf32>, vector<16xi1>, i32) -> f3280 81 82// -----83 84func.func @masked_reduce_add_f32_scalable(%arg0: vector<[16]xf32>, %mask : vector<[16]xi1>) -> f32 {85 %0 = vector.mask %mask { vector.reduction <add>, %arg0 : vector<[16]xf32> into f32 } : vector<[16]xi1> -> f3286 return %0 : f3287}88 89// CHECK-LABEL: func.func @masked_reduce_add_f32_scalable(90// CHECK-SAME: %[[INPUT:.*]]: vector<[16]xf32>,91// CHECK-SAME: %[[MASK:.*]]: vector<[16]xi1>) -> f32 {92// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f3293// CHECK: %[[VL_BASE:.*]] = llvm.mlir.constant(16 : i32) : i3294// CHECK: %[[VSCALE:.*]] = "llvm.intr.vscale"() : () -> i6495// CHECK: %[[CAST_IDX:.*]] = builtin.unrealized_conversion_cast %[[VSCALE]] : i64 to index96// CHECK: %[[CAST_I32:.*]] = arith.index_cast %[[CAST_IDX]] : index to i3297// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i3298// CHECK: "llvm.intr.vp.reduce.fadd"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (f32, vector<[16]xf32>, vector<[16]xi1>, i32) -> f3299 100 101// -----102 103func.func @masked_reduce_mul_f32(%arg0: vector<16xf32>, %mask : vector<16xi1>) -> f32 {104 %0 = vector.mask %mask { vector.reduction <mul>, %arg0 : vector<16xf32> into f32 } : vector<16xi1> -> f32105 return %0 : f32106}107 108// CHECK-LABEL: func.func @masked_reduce_mul_f32(109// CHECK-SAME: %[[INPUT:.*]]: vector<16xf32>,110// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>) -> f32 {111// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32112// CHECK: %[[VL:.*]] = llvm.mlir.constant(16 : i32) : i32113// CHECK: "llvm.intr.vp.reduce.fmul"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (f32, vector<16xf32>, vector<16xi1>, i32) -> f32114 115 116// -----117 118func.func @masked_reduce_minf_f32(%arg0: vector<16xf32>, %mask : vector<16xi1>) -> f32 {119 %0 = vector.mask %mask { vector.reduction <minnumf>, %arg0 : vector<16xf32> into f32 } : vector<16xi1> -> f32120 return %0 : f32121}122 123// CHECK-LABEL: func.func @masked_reduce_minf_f32(124// CHECK-SAME: %[[INPUT:.*]]: vector<16xf32>,125// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>) -> f32 {126// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0xFFC00000 : f32) : f32127// CHECK: %[[VL:.*]] = llvm.mlir.constant(16 : i32) : i32128// CHECK: "llvm.intr.vp.reduce.fmin"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (f32, vector<16xf32>, vector<16xi1>, i32) -> f32129 130// -----131 132func.func @masked_reduce_minf_f32_scalable(%arg0: vector<[16]xf32>, %mask : vector<[16]xi1>) -> f32 {133 %0 = vector.mask %mask { vector.reduction <minnumf>, %arg0 : vector<[16]xf32> into f32 } : vector<[16]xi1> -> f32134 return %0 : f32135}136 137// CHECK-LABEL: func.func @masked_reduce_minf_f32_scalable(138// CHECK-SAME: %[[INPUT:.*]]: vector<[16]xf32>,139// CHECK-SAME: %[[MASK:.*]]: vector<[16]xi1>) -> f32 {140// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0xFFC00000 : f32) : f32141// CHECK: %[[VL_BASE:.*]] = llvm.mlir.constant(16 : i32) : i32142// CHECK: %[[VSCALE:.*]] = "llvm.intr.vscale"() : () -> i64143// CHECK: %[[CAST_IDX:.*]] = builtin.unrealized_conversion_cast %[[VSCALE]] : i64 to index144// CHECK: %[[CAST_I32:.*]] = arith.index_cast %[[CAST_IDX]] : index to i32145// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i32146// CHECK: "llvm.intr.vp.reduce.fmin"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (f32, vector<[16]xf32>, vector<[16]xi1>, i32) -> f32147 148// -----149 150func.func @masked_reduce_maxf_f32(%arg0: vector<16xf32>, %mask : vector<16xi1>) -> f32 {151 %0 = vector.mask %mask { vector.reduction <maxnumf>, %arg0 : vector<16xf32> into f32 } : vector<16xi1> -> f32152 return %0 : f32153}154 155// CHECK-LABEL: func.func @masked_reduce_maxf_f32(156// CHECK-SAME: %[[INPUT:.*]]: vector<16xf32>,157// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>) -> f32 {158// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0x7FC00000 : f32) : f32159// CHECK: %[[VL:.*]] = llvm.mlir.constant(16 : i32) : i32160// CHECK: "llvm.intr.vp.reduce.fmax"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (f32, vector<16xf32>, vector<16xi1>, i32) -> f32161 162// -----163 164func.func @masked_reduce_maximumf_f32(%arg0: vector<16xf32>, %mask : vector<16xi1>) -> f32 {165 %0 = vector.mask %mask { vector.reduction <maximumf>, %arg0 : vector<16xf32> into f32 } : vector<16xi1> -> f32166 return %0 : f32167}168 169// CHECK-LABEL: func.func @masked_reduce_maximumf_f32(170// CHECK-SAME: %[[INPUT:.*]]: vector<16xf32>,171// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>) -> f32 {172// CHECK: %[[MASK_NEUTRAL:.*]] = llvm.mlir.constant(dense<-1.401300e-45> : vector<16xf32>) : vector<16xf32>173// CHECK: %[[MASKED:.*]] = llvm.select %[[MASK]], %[[INPUT]], %[[MASK_NEUTRAL]] : vector<16xi1>, vector<16xf32>174// CHECK: %[[RESULT:.*]] = llvm.intr.vector.reduce.fmaximum(%[[MASKED]]) : (vector<16xf32>) -> f32175// CHECK: return %[[RESULT]]176 177// -----178 179func.func @masked_reduce_minimumf_f32(%arg0: vector<16xf32>, %mask : vector<16xi1>) -> f32 {180 %0 = vector.mask %mask { vector.reduction <minimumf>, %arg0 : vector<16xf32> into f32 } : vector<16xi1> -> f32181 return %0 : f32182}183 184// CHECK-LABEL: func.func @masked_reduce_minimumf_f32(185// CHECK-SAME: %[[INPUT:.*]]: vector<16xf32>,186// CHECK-SAME: %[[MASK:.*]]: vector<16xi1>) -> f32 {187// CHECK: %[[MASK_NEUTRAL:.*]] = llvm.mlir.constant(dense<3.40282347E+38> : vector<16xf32>) : vector<16xf32>188// CHECK: %[[MASKED:.*]] = llvm.select %[[MASK]], %[[INPUT]], %[[MASK_NEUTRAL]] : vector<16xi1>, vector<16xf32>189// CHECK: %[[RESULT:.*]] = llvm.intr.vector.reduce.fminimum(%[[MASKED]]) : (vector<16xf32>) -> f32190// CHECK: return %[[RESULT]]191 192// -----193 194func.func @masked_reduce_add_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {195 %0 = vector.mask %mask { vector.reduction <add>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8196 return %0 : i8197}198 199// CHECK-LABEL: func.func @masked_reduce_add_i8(200// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,201// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {202// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0 : i8) : i8203// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32204// CHECK: "llvm.intr.vp.reduce.add"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8205 206 207// -----208 209func.func @masked_reduce_add_i8_scalable(%arg0: vector<[32]xi8>, %mask : vector<[32]xi1>) -> i8 {210 %0 = vector.mask %mask { vector.reduction <add>, %arg0 : vector<[32]xi8> into i8 } : vector<[32]xi1> -> i8211 return %0 : i8212}213 214// CHECK-LABEL: func.func @masked_reduce_add_i8_scalable(215// CHECK-SAME: %[[INPUT:.*]]: vector<[32]xi8>,216// CHECK-SAME: %[[MASK:.*]]: vector<[32]xi1>) -> i8 {217// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0 : i8) : i8218// CHECK: %[[VL_BASE:.*]] = llvm.mlir.constant(32 : i32) : i32219// CHECK: %[[VSCALE:.*]] = "llvm.intr.vscale"() : () -> i64220// CHECK: %[[CAST_IDX:.*]] = builtin.unrealized_conversion_cast %[[VSCALE]] : i64 to index221// CHECK: %[[CAST_I32:.*]] = arith.index_cast %[[CAST_IDX]] : index to i32222// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i32223// CHECK: "llvm.intr.vp.reduce.add"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (i8, vector<[32]xi8>, vector<[32]xi1>, i32) -> i8224 225 226// -----227 228func.func @masked_reduce_mul_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {229 %0 = vector.mask %mask { vector.reduction <mul>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8230 return %0 : i8231}232 233// CHECK-LABEL: func.func @masked_reduce_mul_i8(234// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,235// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {236// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(1 : i8) : i8237// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32238// CHECK: %[[VAL_4:.*]] = "llvm.intr.vp.reduce.mul"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8239 240// -----241 242func.func @masked_reduce_minui_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {243 %0 = vector.mask %mask { vector.reduction <minui>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8244 return %0 : i8245}246 247// CHECK-LABEL: func.func @masked_reduce_minui_i8(248// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,249// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {250// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(-1 : i8) : i8251// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32252// CHECK: "llvm.intr.vp.reduce.umin"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8253 254// -----255 256func.func @masked_reduce_minui_i8_scalable(%arg0: vector<[32]xi8>, %mask : vector<[32]xi1>) -> i8 {257 %0 = vector.mask %mask { vector.reduction <minui>, %arg0 : vector<[32]xi8> into i8 } : vector<[32]xi1> -> i8258 return %0 : i8259}260 261// CHECK-LABEL: func.func @masked_reduce_minui_i8_scalable(262// CHECK-SAME: %[[INPUT:.*]]: vector<[32]xi8>,263// CHECK-SAME: %[[MASK:.*]]: vector<[32]xi1>) -> i8 {264// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(-1 : i8) : i8265// CHECK: %[[VL_BASE:.*]] = llvm.mlir.constant(32 : i32) : i32266// CHECK: %[[VSCALE:.*]] = "llvm.intr.vscale"() : () -> i64267// CHECK: %[[CAST_IDX:.*]] = builtin.unrealized_conversion_cast %[[VSCALE]] : i64 to index268// CHECK: %[[CAST_I32:.*]] = arith.index_cast %[[CAST_IDX]] : index to i32269// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i32270// CHECK: "llvm.intr.vp.reduce.umin"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (i8, vector<[32]xi8>, vector<[32]xi1>, i32) -> i8271 272// -----273 274func.func @masked_reduce_maxui_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {275 %0 = vector.mask %mask { vector.reduction <maxui>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8276 return %0 : i8277}278 279// CHECK-LABEL: func.func @masked_reduce_maxui_i8(280// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,281// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {282// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0 : i8) : i8283// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32284// CHECK: "llvm.intr.vp.reduce.umax"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8285 286// -----287 288func.func @masked_reduce_minsi_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {289 %0 = vector.mask %mask { vector.reduction <minsi>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8290 return %0 : i8291}292 293// CHECK-LABEL: func.func @masked_reduce_minsi_i8(294// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,295// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {296// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(127 : i8) : i8297// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32298// CHECK: "llvm.intr.vp.reduce.smin"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8299 300// -----301 302func.func @masked_reduce_maxsi_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {303 %0 = vector.mask %mask { vector.reduction <maxsi>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8304 return %0 : i8305}306 307// CHECK-LABEL: func.func @masked_reduce_maxsi_i8(308// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,309// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {310// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(-128 : i8) : i8311// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32312// CHECK: "llvm.intr.vp.reduce.smax"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8313 314// -----315 316func.func @masked_reduce_maxsi_i8_scalable(%arg0: vector<[32]xi8>, %mask : vector<[32]xi1>) -> i8 {317 %0 = vector.mask %mask { vector.reduction <maxsi>, %arg0 : vector<[32]xi8> into i8 } : vector<[32]xi1> -> i8318 return %0 : i8319}320 321// CHECK-LABEL: func.func @masked_reduce_maxsi_i8_scalable(322// CHECK-SAME: %[[INPUT:.*]]: vector<[32]xi8>,323// CHECK-SAME: %[[MASK:.*]]: vector<[32]xi1>) -> i8 {324// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(-128 : i8) : i8325// CHECK: %[[VL_BASE:.*]] = llvm.mlir.constant(32 : i32) : i32326// CHECK: %[[VSCALE:.*]] = "llvm.intr.vscale"() : () -> i64327// CHECK: %[[CAST_IDX:.*]] = builtin.unrealized_conversion_cast %[[VSCALE]] : i64 to index328// CHECK: %[[CAST_I32:.*]] = arith.index_cast %[[CAST_IDX]] : index to i32329// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i32330// CHECK: "llvm.intr.vp.reduce.smax"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (i8, vector<[32]xi8>, vector<[32]xi1>, i32) -> i8331 332// -----333 334func.func @masked_reduce_or_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {335 %0 = vector.mask %mask { vector.reduction <or>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8336 return %0 : i8337}338 339// CHECK-LABEL: func.func @masked_reduce_or_i8(340// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,341// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {342// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0 : i8) : i8343// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32344// CHECK: "llvm.intr.vp.reduce.or"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8345 346 347// -----348 349func.func @masked_reduce_and_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {350 %0 = vector.mask %mask { vector.reduction <and>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8351 return %0 : i8352}353 354// CHECK-LABEL: func.func @masked_reduce_and_i8(355// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,356// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {357// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(-1 : i8) : i8358// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32359// CHECK: "llvm.intr.vp.reduce.and"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8360 361// -----362 363func.func @masked_reduce_xor_i8(%arg0: vector<32xi8>, %mask : vector<32xi1>) -> i8 {364 %0 = vector.mask %mask { vector.reduction <xor>, %arg0 : vector<32xi8> into i8 } : vector<32xi1> -> i8365 return %0 : i8366}367 368// CHECK-LABEL: func.func @masked_reduce_xor_i8(369// CHECK-SAME: %[[INPUT:.*]]: vector<32xi8>,370// CHECK-SAME: %[[MASK:.*]]: vector<32xi1>) -> i8 {371// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0 : i8) : i8372// CHECK: %[[VL:.*]] = llvm.mlir.constant(32 : i32) : i32373// CHECK: "llvm.intr.vp.reduce.xor"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL]]) : (i8, vector<32xi8>, vector<32xi1>, i32) -> i8374 375// -----376 377func.func @masked_reduce_xor_i8_scalable(%arg0: vector<[32]xi8>, %mask : vector<[32]xi1>) -> i8 {378 %0 = vector.mask %mask { vector.reduction <xor>, %arg0 : vector<[32]xi8> into i8 } : vector<[32]xi1> -> i8379 return %0 : i8380}381 382// CHECK-LABEL: func.func @masked_reduce_xor_i8_scalable(383// CHECK-SAME: %[[INPUT:.*]]: vector<[32]xi8>,384// CHECK-SAME: %[[MASK:.*]]: vector<[32]xi1>) -> i8 {385// CHECK: %[[NEUTRAL:.*]] = llvm.mlir.constant(0 : i8) : i8386// CHECK: %[[VL_BASE:.*]] = llvm.mlir.constant(32 : i32) : i32387// CHECK: %[[VSCALE:.*]] = "llvm.intr.vscale"() : () -> i64388// CHECK: %[[CAST_IDX:.*]] = builtin.unrealized_conversion_cast %[[VSCALE]] : i64 to index389// CHECK: %[[CAST_I32:.*]] = arith.index_cast %[[CAST_IDX]] : index to i32390// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i32391// CHECK: "llvm.intr.vp.reduce.xor"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (i8, vector<[32]xi8>, vector<[32]xi1>, i32) -> i8392 393 394