clang/test/CodeGen/X86/avx512vlbw-reduceIntrin.c

   1 // RUN: %clang_cc1 -ffreestanding %s -O0 -triple=x86_64 -target-feature +avx512bw -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
   2 // RUN: %clang_cc1 -ffreestanding %s -O0 -triple=i386 -target-feature +avx512bw -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
   3
   4 #include <immintrin.h>
   5
   6 short test_mm_reduce_add_epi16(__m128i __W){
   7 // CHECK-LABEL: @test_mm_reduce_add_epi16(
   8 // CHECK: call i16 @llvm.vector.reduce.add.v8i16(<8 x i16> %{{.*}})
   9   return _mm_reduce_add_epi16(__W);
  10 }
  11
  12 short test_mm_reduce_mul_epi16(__m128i __W){
  13 // CHECK-LABEL: @test_mm_reduce_mul_epi16(
  14 // CHECK:    call i16 @llvm.vector.reduce.mul.v8i16(<8 x i16> %{{.*}})
  15   return _mm_reduce_mul_epi16(__W);
  16 }
  17
  18 short test_mm_reduce_or_epi16(__m128i __W){
  19 // CHECK-LABEL: @test_mm_reduce_or_epi16(
  20 // CHECK:    call i16 @llvm.vector.reduce.or.v8i16(<8 x i16> %{{.*}})
  21   return _mm_reduce_or_epi16(__W);
  22 }
  23
  24 short test_mm_reduce_and_epi16(__m128i __W){
  25 // CHECK-LABEL: @test_mm_reduce_and_epi16(
  26 // CHECK:    call i16 @llvm.vector.reduce.and.v8i16(<8 x i16> %{{.*}})
  27   return _mm_reduce_and_epi16(__W);
  28 }
  29
  30 short test_mm_mask_reduce_add_epi16(__mmask8 __M, __m128i __W){
  31 // CHECK-LABEL: @test_mm_mask_reduce_add_epi16(
  32 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
  33 // CHECK:    call i16 @llvm.vector.reduce.add.v8i16(<8 x i16> %{{.*}})
  34   return _mm_mask_reduce_add_epi16(__M, __W);
  35 }
  36
  37 short test_mm_mask_reduce_mul_epi16(__mmask8 __M, __m128i __W){
  38 // CHECK-LABEL: @test_mm_mask_reduce_mul_epi16(
  39 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
  40 // CHECK:    call i16 @llvm.vector.reduce.mul.v8i16(<8 x i16> %{{.*}})
  41   return _mm_mask_reduce_mul_epi16(__M, __W);
  42 }
  43
  44 short test_mm_mask_reduce_and_epi16(__mmask8 __M, __m128i __W){
  45 // CHECK-LABEL: @test_mm_mask_reduce_and_epi16(
  46 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
  47 // CHECK:    call i16 @llvm.vector.reduce.and.v8i16(<8 x i16> %{{.*}}
  48   return _mm_mask_reduce_and_epi16(__M, __W);
  49 }
  50
  51 short test_mm_mask_reduce_or_epi16(__mmask8 __M, __m128i __W){
  52 // CHECK-LABEL: @test_mm_mask_reduce_or_epi16(
  53 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
  54 // CHECK:    call i16 @llvm.vector.reduce.or.v8i16(<8 x i16> %{{.*}})
  55   return _mm_mask_reduce_or_epi16(__M, __W);
  56 }
  57
  58 short test_mm256_reduce_add_epi16(__m256i __W){
  59 // CHECK-LABEL: @test_mm256_reduce_add_epi16(
  60 // CHECK:    call i16 @llvm.vector.reduce.add.v16i16(<16 x i16> %{{.*}})
  61   return _mm256_reduce_add_epi16(__W);
  62 }
  63
  64 short test_mm256_reduce_mul_epi16(__m256i __W){
  65 // CHECK-LABEL: @test_mm256_reduce_mul_epi16(
  66 // CHECK:    call i16 @llvm.vector.reduce.mul.v16i16(<16 x i16> %{{.*}})
  67   return _mm256_reduce_mul_epi16(__W);
  68 }
  69
  70 short test_mm256_reduce_or_epi16(__m256i __W){
  71 // CHECK-LABEL: @test_mm256_reduce_or_epi16(
  72 // CHECK:    call i16 @llvm.vector.reduce.or.v16i16(<16 x i16> %{{.*}})
  73   return _mm256_reduce_or_epi16(__W);
  74 }
  75
  76 short test_mm256_reduce_and_epi16(__m256i __W){
  77 // CHECK-LABEL: @test_mm256_reduce_and_epi16(
  78 // CHECK:    call i16 @llvm.vector.reduce.and.v16i16(<16 x i16> %{{.*}})
  79   return _mm256_reduce_and_epi16(__W);
  80 }
  81
  82 short test_mm256_mask_reduce_add_epi16(__mmask16 __M, __m256i __W){
  83 // CHECK-LABEL: @test_mm256_mask_reduce_add_epi16(
  84 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
  85 // CHECK:    call i16 @llvm.vector.reduce.add.v16i16(<16 x i16> %{{.*}})
  86   return _mm256_mask_reduce_add_epi16(__M, __W);
  87 }
  88
  89 short test_mm256_mask_reduce_mul_epi16(__mmask16 __M, __m256i __W){
  90 // CHECK-LABEL: @test_mm256_mask_reduce_mul_epi16(
  91 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
  92 // CHECK:    call i16 @llvm.vector.reduce.mul.v16i16(<16 x i16> %{{.*}})
  93   return _mm256_mask_reduce_mul_epi16(__M, __W);
  94 }
  95
  96 short test_mm256_mask_reduce_and_epi16(__mmask16 __M, __m256i __W){
  97 // CHECK-LABEL: @test_mm256_mask_reduce_and_epi16(
  98 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
  99 // CHECK:    call i16 @llvm.vector.reduce.and.v16i16(<16 x i16> %{{.*}})
 100   return _mm256_mask_reduce_and_epi16(__M, __W);
 101 }
 102
 103 short test_mm256_mask_reduce_or_epi16(__mmask16 __M, __m256i __W){
 104 // CHECK-LABEL: @test_mm256_mask_reduce_or_epi16(
 105 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
 106 // CHECK:    call i16 @llvm.vector.reduce.or.v16i16(<16 x i16> %{{.*}})
 107   return _mm256_mask_reduce_or_epi16(__M, __W);
 108 }
 109
 110 signed char test_mm_reduce_add_epi8(__m128i __W){
 111 // CHECK-LABEL: @test_mm_reduce_add_epi8(
 112 // CHECK:    call i8 @llvm.vector.reduce.add.v16i8(<16 x i8> %{{.*}})
 113   return _mm_reduce_add_epi8(__W);
 114 }
 115
 116 signed char test_mm_reduce_mul_epi8(__m128i __W){
 117 // CHECK-LABEL: @test_mm_reduce_mul_epi8(
 118 // CHECK:    call i8 @llvm.vector.reduce.mul.v16i8(<16 x i8> %{{.*}})
 119   return _mm_reduce_mul_epi8(__W);
 120 }
 121
 122 signed char test_mm_reduce_and_epi8(__m128i __W){
 123 // CHECK-LABEL: @test_mm_reduce_and_epi8(
 124 // CHECK:    call i8 @llvm.vector.reduce.and.v16i8(<16 x i8> %{{.*}})
 125   return _mm_reduce_and_epi8(__W);
 126 }
 127
 128 signed char test_mm_reduce_or_epi8(__m128i __W){
 129 // CHECK-LABEL: @test_mm_reduce_or_epi8(
 130 // CHECK:    call i8 @llvm.vector.reduce.or.v16i8(<16 x i8> %{{.*}})
 131   return _mm_reduce_or_epi8(__W);
 132 }
 133
 134 signed char test_mm_mask_reduce_add_epi8(__mmask16 __M, __m128i __W){
 135 // CHECK-LABEL: @test_mm_mask_reduce_add_epi8(
 136 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 137 // CHECK:    call i8 @llvm.vector.reduce.add.v16i8(<16 x i8> %{{.*}})
 138   return _mm_mask_reduce_add_epi8(__M, __W);
 139 }
 140
 141 signed char test_mm_mask_reduce_mul_epi8(__mmask16 __M, __m128i __W){
 142 // CHECK-LABEL: @test_mm_mask_reduce_mul_epi8(
 143 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 144 // CHECK:    call i8 @llvm.vector.reduce.mul.v16i8(<16 x i8> %{{.*}})
 145   return _mm_mask_reduce_mul_epi8(__M, __W);
 146 }
 147
 148 signed char test_mm_mask_reduce_and_epi8(__mmask16 __M, __m128i __W){
 149 // CHECK-LABEL: @test_mm_mask_reduce_and_epi8(
 150 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 151 // CHECK:    call i8 @llvm.vector.reduce.and.v16i8(<16 x i8> %{{.*}})
 152   return _mm_mask_reduce_and_epi8(__M, __W);
 153 }
 154
 155 signed char test_mm_mask_reduce_or_epi8(__mmask16 __M, __m128i __W){
 156 // CHECK-LABEL: @test_mm_mask_reduce_or_epi8(
 157 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 158 // CHECK:    call i8 @llvm.vector.reduce.or.v16i8(<16 x i8> %{{.*}})
 159   return _mm_mask_reduce_or_epi8(__M, __W);
 160 }
 161
 162 signed char test_mm256_reduce_add_epi8(__m256i __W){
 163 // CHECK-LABEL: @test_mm256_reduce_add_epi8(
 164 // CHECK:    call i8 @llvm.vector.reduce.add.v32i8(<32 x i8> %{{.*}})
 165   return _mm256_reduce_add_epi8(__W);
 166 }
 167
 168 signed char test_mm256_reduce_mul_epi8(__m256i __W){
 169 // CHECK-LABEL: @test_mm256_reduce_mul_epi8(
 170 // CHECK:    call i8 @llvm.vector.reduce.mul.v32i8(<32 x i8> %{{.*}})
 171   return _mm256_reduce_mul_epi8(__W);
 172 }
 173
 174 signed char test_mm256_reduce_and_epi8(__m256i __W){
 175 // CHECK-LABEL: @test_mm256_reduce_and_epi8(
 176 // CHECK:    call i8 @llvm.vector.reduce.and.v32i8(<32 x i8> %{{.*}})
 177   return _mm256_reduce_and_epi8(__W);
 178 }
 179
 180 signed char test_mm256_reduce_or_epi8(__m256i __W){
 181 // CHECK-LABEL: @test_mm256_reduce_or_epi8(
 182 // CHECK:    call i8 @llvm.vector.reduce.or.v32i8(<32 x i8> %{{.*}})
 183   return _mm256_reduce_or_epi8(__W);
 184 }
 185
 186 signed char test_mm256_mask_reduce_add_epi8(__mmask32 __M, __m256i __W){
 187 // CHECK-LABEL: @test_mm256_mask_reduce_add_epi8(
 188 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 189 // CHECK:    call i8 @llvm.vector.reduce.add.v32i8(<32 x i8> %{{.*}})
 190   return _mm256_mask_reduce_add_epi8(__M, __W);
 191 }
 192
 193 signed char test_mm256_mask_reduce_mul_epi8(__mmask32 __M, __m256i __W){
 194 // CHECK-LABEL: @test_mm256_mask_reduce_mul_epi8(
 195 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 196 // CHECK:    call i8 @llvm.vector.reduce.mul.v32i8(<32 x i8> %{{.*}})
 197   return _mm256_mask_reduce_mul_epi8(__M, __W);
 198 }
 199
 200 signed char test_mm256_mask_reduce_and_epi8(__mmask32 __M, __m256i __W){
 201 // CHECK-LABEL: @test_mm256_mask_reduce_and_epi8(
 202 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 203 // CHECK:    call i8 @llvm.vector.reduce.and.v32i8(<32 x i8> %{{.*}})
 204   return _mm256_mask_reduce_and_epi8(__M, __W);
 205 }
 206
 207 signed char test_mm256_mask_reduce_or_epi8(__mmask32 __M, __m256i __W){
 208 // CHECK-LABEL: @test_mm256_mask_reduce_or_epi8(
 209 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 210 // CHECK:    call i8 @llvm.vector.reduce.or.v32i8(<32 x i8> %{{.*}})
 211   return _mm256_mask_reduce_or_epi8(__M, __W);
 212 }
 213
 214 short test_mm_reduce_max_epi16(__m128i __W){
 215 // CHECK-LABEL: test_mm_reduce_max_epi16
 216 // CHECK:    call i16 @llvm.vector.reduce.smax.v8i16(<8 x i16> %{{.*}})
 217   return _mm_reduce_max_epi16(__W);
 218 }
 219
 220 short test_mm_reduce_min_epi16(__m128i __W){
 221 // CHECK-LABEL: test_mm_reduce_min_epi16
 222 // CHECK:    call i16 @llvm.vector.reduce.smin.v8i16(<8 x i16> %{{.*}})
 223   return _mm_reduce_min_epi16(__W);
 224 }
 225
 226 unsigned short test_mm_reduce_max_epu16(__m128i __W){
 227 // CHECK-LABEL: test_mm_reduce_max_epu16
 228 // CHECK:    call i16 @llvm.vector.reduce.umax.v8i16(<8 x i16> %{{.*}})
 229   return _mm_reduce_max_epu16(__W);
 230 }
 231
 232 unsigned short test_mm_reduce_min_epu16(__m128i __W){
 233 // CHECK-LABEL: test_mm_reduce_min_epu16
 234 // CHECK:    call i16 @llvm.vector.reduce.umin.v8i16(<8 x i16> %{{.*}})
 235   return _mm_reduce_min_epu16(__W);
 236 }
 237
 238 short test_mm_mask_reduce_max_epi16(__mmask8 __M, __m128i __W){
 239 // CHECK-LABEL: test_mm_mask_reduce_max_epi16
 240 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
 241 // CHECK:    call i16 @llvm.vector.reduce.smax.v8i16(<8 x i16> %{{.*}})
 242   return _mm_mask_reduce_max_epi16(__M, __W);
 243 }
 244
 245 short test_mm_mask_reduce_min_epi16(__mmask8 __M, __m128i __W){
 246 // CHECK-LABEL: test_mm_mask_reduce_min_epi16
 247 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
 248 // CHECK:    call i16 @llvm.vector.reduce.smin.v8i16(<8 x i16> %{{.*}})
 249   return _mm_mask_reduce_min_epi16(__M, __W);
 250 }
 251
 252 unsigned short test_mm_mask_reduce_max_epu16(__mmask8 __M, __m128i __W){
 253 // CHECK-LABEL: test_mm_mask_reduce_max_epu16
 254 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
 255 // CHECK:    call i16 @llvm.vector.reduce.umax.v8i16(<8 x i16> %{{.*}})
 256   return _mm_mask_reduce_max_epu16(__M, __W);
 257 }
 258
 259 unsigned short test_mm_mask_reduce_min_epu16(__mmask8 __M, __m128i __W){
 260 // CHECK-LABEL: test_mm_mask_reduce_min_epu16
 261 // CHECK:    select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
 262 // CHECK:    call i16 @llvm.vector.reduce.umin.v8i16(<8 x i16> %{{.*}})
 263   return _mm_mask_reduce_min_epu16(__M, __W);
 264 }
 265
 266 short test_mm256_reduce_max_epi16(__m256i __W){
 267 // CHECK-LABEL: test_mm256_reduce_max_epi16
 268 // CHECK:    call i16 @llvm.vector.reduce.smax.v16i16(<16 x i16> %{{.*}})
 269   return _mm256_reduce_max_epi16(__W);
 270 }
 271
 272 short test_mm256_reduce_min_epi16(__m256i __W){
 273 // CHECK-LABEL: test_mm256_reduce_min_epi16
 274 // CHECK:    call i16 @llvm.vector.reduce.smin.v16i16(<16 x i16> %{{.*}})
 275   return _mm256_reduce_min_epi16(__W);
 276 }
 277
 278 unsigned short test_mm256_reduce_max_epu16(__m256i __W){
 279 // CHECK-LABEL: test_mm256_reduce_max_epu16
 280 // CHECK:    call i16 @llvm.vector.reduce.umax.v16i16(<16 x i16> %{{.*}})
 281   return _mm256_reduce_max_epu16(__W);
 282 }
 283
 284 unsigned short test_mm256_reduce_min_epu16(__m256i __W){
 285 // CHECK-LABEL: test_mm256_reduce_min_epu16
 286 // CHECK:    call i16 @llvm.vector.reduce.umin.v16i16(<16 x i16> %{{.*}})
 287   return _mm256_reduce_min_epu16(__W);
 288 }
 289
 290 short test_mm256_mask_reduce_max_epi16(__mmask16 __M, __m256i __W){
 291 // CHECK-LABEL: test_mm256_mask_reduce_max_epi16
 292 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
 293 // CHECK:    call i16 @llvm.vector.reduce.smax.v16i16(<16 x i16> %{{.*}})
 294   return _mm256_mask_reduce_max_epi16(__M, __W);
 295 }
 296
 297 short test_mm256_mask_reduce_min_epi16(__mmask16 __M, __m256i __W){
 298 // CHECK-LABEL: test_mm256_mask_reduce_min_epi16
 299 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
 300 // CHECK:    call i16 @llvm.vector.reduce.smin.v16i16(<16 x i16> %{{.*}})
 301   return _mm256_mask_reduce_min_epi16(__M, __W);
 302 }
 303
 304 unsigned short test_mm256_mask_reduce_max_epu16(__mmask16 __M, __m256i __W){
 305 // CHECK-LABEL: test_mm256_mask_reduce_max_epu16
 306 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
 307 // CHECK:    call i16 @llvm.vector.reduce.umax.v16i16(<16 x i16> %{{.*}})
 308   return _mm256_mask_reduce_max_epu16(__M, __W);
 309 }
 310
 311 unsigned short test_mm256_mask_reduce_min_epu16(__mmask16 __M, __m256i __W){
 312 // CHECK-LABEL: test_mm256_mask_reduce_min_epu16
 313 // CHECK:    select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
 314 // CHECK:    call i16 @llvm.vector.reduce.umin.v16i16(<16 x i16> %{{.*}})
 315   return _mm256_mask_reduce_min_epu16(__M, __W);
 316 }
 317
 318 signed char test_mm_reduce_max_epi8(__m128i __W){
 319 // CHECK-LABEL: test_mm_reduce_max_epi8
 320 // CHECK:    call i8 @llvm.vector.reduce.smax.v16i8(<16 x i8> %{{.*}})
 321   return _mm_reduce_max_epi8(__W);
 322 }
 323
 324 signed char test_mm_reduce_min_epi8(__m128i __W){
 325 // CHECK-LABEL: test_mm_reduce_min_epi8
 326 // CHECK:    call i8 @llvm.vector.reduce.smin.v16i8(<16 x i8> %{{.*}})
 327   return _mm_reduce_min_epi8(__W);
 328 }
 329
 330 unsigned char test_mm_reduce_max_epu8(__m128i __W){
 331 // CHECK-LABEL: test_mm_reduce_max_epu8
 332 // CHECK:    call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %{{.*}})
 333   return _mm_reduce_max_epu8(__W);
 334 }
 335
 336 unsigned char test_mm_reduce_min_epu8(__m128i __W){
 337 // CHECK-LABEL: test_mm_reduce_min_epu8
 338 // CHECK:    call i8 @llvm.vector.reduce.umin.v16i8(<16 x i8> %{{.*}})
 339   return _mm_reduce_min_epu8(__W);
 340 }
 341
 342 signed char test_mm_mask_reduce_max_epi8(__mmask16 __M, __m128i __W){
 343 // CHECK-LABEL: test_mm_mask_reduce_max_epi8
 344 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 345 // CHECK:    call i8 @llvm.vector.reduce.smax.v16i8(<16 x i8> %{{.*}})
 346   return _mm_mask_reduce_max_epi8(__M, __W);
 347 }
 348
 349 signed char test_mm_mask_reduce_min_epi8(__mmask16 __M, __m128i __W){
 350 // CHECK-LABEL: test_mm_mask_reduce_min_epi8
 351 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 352 // CHECK:    call i8 @llvm.vector.reduce.smin.v16i8(<16 x i8> %{{.*}})
 353   return _mm_mask_reduce_min_epi8(__M, __W);
 354 }
 355
 356 unsigned char test_mm_mask_reduce_max_epu8(__mmask16 __M, __m128i __W){
 357 // CHECK-LABEL: test_mm_mask_reduce_max_epu8
 358 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 359 // CHECK:    call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %{{.*}})
 360   return _mm_mask_reduce_max_epu8(__M, __W);
 361 }
 362
 363 unsigned char test_mm_mask_reduce_min_epu8(__mmask16 __M, __m128i __W){
 364 // CHECK-LABEL: test_mm_mask_reduce_min_epu8
 365 // CHECK:    select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}}
 366 // CHECK:    call i8 @llvm.vector.reduce.umin.v16i8(<16 x i8> %{{.*}})
 367   return _mm_mask_reduce_min_epu8(__M, __W);
 368 }
 369
 370 signed char test_mm256_reduce_max_epi8(__m256i __W){
 371 // CHECK-LABEL: test_mm256_reduce_max_epi8
 372 // CHECK:    call i8 @llvm.vector.reduce.smax.v32i8(<32 x i8> %{{.*}})
 373   return _mm256_reduce_max_epi8(__W);
 374 }
 375
 376 signed char test_mm256_reduce_min_epi8(__m256i __W){
 377 // CHECK-LABEL: test_mm256_reduce_min_epi8
 378 // CHECK:    call i8 @llvm.vector.reduce.smin.v32i8(<32 x i8> %{{.*}})
 379   return _mm256_reduce_min_epi8(__W);
 380 }
 381
 382 unsigned char test_mm256_reduce_max_epu8(__m256i __W){
 383 // CHECK-LABEL: test_mm256_reduce_max_epu8
 384 // CHECK:    call i8 @llvm.vector.reduce.umax.v32i8(<32 x i8> %{{.*}})
 385   return _mm256_reduce_max_epu8(__W);
 386 }
 387
 388 unsigned char test_mm256_reduce_min_epu8(__m256i __W){
 389 // CHECK-LABEL: test_mm256_reduce_min_epu8
 390 // CHECK:    call i8 @llvm.vector.reduce.umin.v32i8(<32 x i8> %{{.*}})
 391   return _mm256_reduce_min_epu8(__W);
 392 }
 393
 394 signed char test_mm256_mask_reduce_max_epi8(__mmask32 __M, __m256i __W){
 395 // CHECK-LABEL: test_mm256_mask_reduce_max_epi8
 396 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 397 // CHECK:    call i8 @llvm.vector.reduce.smax.v32i8(<32 x i8> %{{.*}})
 398   return _mm256_mask_reduce_max_epi8(__M, __W);
 399 }
 400
 401 signed char test_mm256_mask_reduce_min_epi8(__mmask32 __M, __m256i __W){
 402 // CHECK-LABEL: test_mm256_mask_reduce_min_epi8
 403 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 404 // CHECK:    call i8 @llvm.vector.reduce.smin.v32i8(<32 x i8> %{{.*}})
 405   return _mm256_mask_reduce_min_epi8(__M, __W);
 406 }
 407
 408 unsigned char test_mm256_mask_reduce_max_epu8(__mmask32 __M, __m256i __W){
 409 // CHECK-LABEL: test_mm256_mask_reduce_max_epu8
 410 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 411 // CHECK:    call i8 @llvm.vector.reduce.umax.v32i8(<32 x i8> %{{.*}})
 412   return _mm256_mask_reduce_max_epu8(__M, __W);
 413 }
 414
 415 unsigned char test_mm256_mask_reduce_min_epu8(__mmask32 __M, __m256i __W){
 416 // CHECK-LABEL: test_mm256_mask_reduce_min_epu8
 417 // CHECK:    select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
 418 // CHECK:    call i8 @llvm.vector.reduce.umin.v32i8(<32 x i8> %{{.*}})
 419   return _mm256_mask_reduce_min_epu8(__M, __W);
 420 }