clang/test/CodeGen/X86/avx10_2ni-builtins.c

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64 -target-feature +avx10.2-256 -emit-llvm -o - | FileCheck %s
   2 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=i686 -target-feature +avx10.2-256 -emit-llvm -o - | FileCheck %s
   3
   4 #include <immintrin.h>
   5
   6 // VNNI FP16
   7 __m128 test_mm_dpph_ps(__m128 __W, __m128h __A, __m128h __B) {
   8 // CHECK-LABEL: @test_mm_dpph_ps(
   9 // CHECK: call <4 x float> @llvm.x86.avx10.vdpphps.128
  10   return _mm_dpph_ps(__W, __A, __B);
  11 }
  12
  13 __m128 test_mm_mask_dpph_ps(__m128 __W, __mmask8 __U, __m128h __A, __m128h __B) {
  14 // CHECK-LABEL: @test_mm_mask_dpph_ps(
  15 // CHECK: call <4 x float> @llvm.x86.avx10.vdpphps.128
  16 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
  17   return _mm_mask_dpph_ps(__W, __U, __A, __B);
  18 }
  19
  20 __m128 test_mm_maskz_dpph_ps(__mmask8 __U, __m128 __W, __m128h __A, __m128h __B) {
  21 // CHECK-LABEL: @test_mm_maskz_dpph_ps(
  22 // CHECK: call <4 x float> @llvm.x86.avx10.vdpphps.128
  23 // CHECK: zeroinitializer
  24 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
  25   return _mm_maskz_dpph_ps(__U, __W, __A, __B);
  26 }
  27
  28 __m256 test_mm256_dpph_ps(__m256 __W, __m256h __A, __m256h __B) {
  29 // CHECK-LABEL: @test_mm256_dpph_ps(
  30 // CHECK: call <8 x float> @llvm.x86.avx10.vdpphps.256
  31   return _mm256_dpph_ps(__W, __A, __B);
  32 }
  33
  34 __m256 test_mm256_mask_dpph_ps(__m256 __W, __mmask8 __U, __m256h __A, __m256h __B) {
  35 // CHECK-LABEL: @test_mm256_mask_dpph_ps(
  36 // CHECK: call <8 x float> @llvm.x86.avx10.vdpphps.256
  37 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
  38   return _mm256_mask_dpph_ps(__W, __U,  __A, __B);
  39 }
  40
  41 __m256 test_mm256_maskz_dpph_ps(__mmask8 __U, __m256 __W, __m256h __A, __m256h __B) {
  42 // CHECK-LABEL: @test_mm256_maskz_dpph_ps(
  43 // CHECK: call <8 x float> @llvm.x86.avx10.vdpphps.256
  44 // CHECK: zeroinitializer
  45 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
  46   return _mm256_maskz_dpph_ps(__U, __W, __A, __B);
  47 }
  48
  49 // VMPSADBW
  50 __m128i test_mm_mpsadbw_epu8(__m128i __A, __m128i __B) {
  51 // CHECK-LABEL: @test_mm_mpsadbw_epu8
  52 // CHECK: @llvm.x86.sse41.mpsadbw
  53   return _mm_mpsadbw_epu8(__A, __B, 170);
  54 }
  55
  56 __m128i test_mm_mask_mpsadbw_epu8(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
  57 // CHECK-LABEL: @test_mm_mask_mpsadbw_epu8
  58 // CHECK: @llvm.x86.sse41.mpsadbw
  59 // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
  60   return _mm_mask_mpsadbw_epu8(__W, __U, __A, __B, 170);
  61 }
  62
  63 __m128i test_mm_maskz_mpsadbw_epu8(__mmask8 __U, __m128i __A, __m128i __B) {
  64 // CHECK-LABEL: @test_mm_maskz_mpsadbw_epu8
  65 // CHECK: @llvm.x86.sse41.mpsadbw
  66 // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}}
  67   return _mm_maskz_mpsadbw_epu8(__U, __A, __B, 170);
  68 }
  69
  70 __m256i test_mm256_mpsadbw_epu8(__m256i __A, __m256i __B) {
  71 // CHECK-LABEL: @test_mm256_mpsadbw_epu8
  72 // CHECK: @llvm.x86.avx2.mpsadbw
  73   return _mm256_mpsadbw_epu8(__A, __B, 170);
  74 }
  75
  76 __m256i test_mm256_mask_mpsadbw_epu8(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
  77 // CHECK-LABEL: @test_mm256_mask_mpsadbw_epu8
  78 // CHECK: @llvm.x86.avx2.mpsadbw
  79 // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
  80   return _mm256_mask_mpsadbw_epu8(__W, __U, __A, __B, 170);
  81 }
  82
  83 __m256i test_mm256_maskz_mpsadbw_epu8(__mmask16 __U, __m256i __A, __m256i __B) {
  84 // CHECK-LABEL: @test_mm256_maskz_mpsadbw_epu8
  85 // CHECK: @llvm.x86.avx2.mpsadbw
  86 // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}}
  87   return _mm256_maskz_mpsadbw_epu8(__U, __A, __B, 170);
  88 }
  89
  90 // VNNI INT8
  91 __m128i test_mm_mask_dpbssd_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
  92 // CHECK-LABEL: @test_mm_mask_dpbssd_epi32
  93 // CHECK: @llvm.x86.avx2.vpdpbssd.128
  94 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
  95   return _mm_mask_dpbssd_epi32(__W, __U, __A, __B);
  96 }
  97
  98 __m128i test_mm_maskz_dpbssd_epi32(__mmask8 __U, __m128i __W, __m128i __A, __m128i __B) {
  99 // CHECK-LABEL: @test_mm_maskz_dpbssd_epi32
 100 // CHECK: @llvm.x86.avx2.vpdpbssd.128
 101 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 102   return _mm_maskz_dpbssd_epi32(__U, __W, __A, __B);
 103 }
 104
 105 __m128i test_mm_mask_dpbssds_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
 106 // CHECK-LABEL: @test_mm_mask_dpbssds_epi32
 107 // CHECK: @llvm.x86.avx2.vpdpbssds.128
 108 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 109   return _mm_mask_dpbssds_epi32(__W, __U, __A, __B);
 110 }
 111
 112 __m128i test_mm_maskz_dpbssds_epi32(__mmask8 __U, __m128i __W, __m128i __A, __m128i __B) {
 113 // CHECK-LABEL: @test_mm_maskz_dpbssds_epi32
 114 // CHECK: @llvm.x86.avx2.vpdpbssds.128
 115 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 116   return _mm_maskz_dpbssds_epi32(__U, __W, __A, __B);
 117 }
 118
 119 __m128i test_mm_mask_dpbsud_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
 120 // CHECK-LABEL: @test_mm_mask_dpbsud_epi32
 121 // CHECK: @llvm.x86.avx2.vpdpbsud.128
 122 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 123   return _mm_mask_dpbsud_epi32(__W, __U, __A, __B);
 124 }
 125
 126 __m128i test_mm_maskz_dpbsud_epi32(__mmask8 __U, __m128i __W, __m128i __A, __m128i __B) {
 127 // CHECK-LABEL: @test_mm_maskz_dpbsud_epi32
 128 // CHECK: @llvm.x86.avx2.vpdpbsud.128
 129 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 130   return _mm_maskz_dpbsud_epi32(__U, __W, __A, __B);
 131 }
 132
 133 __m128i test_mm_mask_dpbsuds_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
 134 // CHECK-LABEL: @test_mm_mask_dpbsuds_epi32
 135 // CHECK: @llvm.x86.avx2.vpdpbsuds.128
 136 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 137   return _mm_mask_dpbsuds_epi32(__W, __U, __A, __B);
 138 }
 139
 140 __m128i test_mm_maskz_dpbsuds_epi32(__mmask8 __U, __m128i __W, __m128i __A, __m128i __B) {
 141 // CHECK-LABEL: @test_mm_maskz_dpbsuds_epi32
 142 // CHECK: @llvm.x86.avx2.vpdpbsuds.128
 143 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 144   return _mm_maskz_dpbsuds_epi32(__U, __W, __A, __B);
 145 }
 146
 147 __m128i test_mm_mask_dpbuud_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
 148 // CHECK-LABEL: @test_mm_mask_dpbuud_epi32
 149 // CHECK: @llvm.x86.avx2.vpdpbuud.128
 150 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 151   return _mm_mask_dpbuud_epi32(__W, __U, __A, __B);
 152 }
 153
 154 __m128i test_mm_maskz_dpbuud_epi32(__mmask8 __U, __m128i __W, __m128i __A, __m128i __B) {
 155 // CHECK-LABEL: @test_mm_maskz_dpbuud_epi32
 156 // CHECK: @llvm.x86.avx2.vpdpbuud.128
 157 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 158   return _mm_maskz_dpbuud_epi32(__U, __W, __A, __B);
 159 }
 160
 161 __m128i test_mm_mask_dpbuuds_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
 162 // CHECK-LABEL: @test_mm_mask_dpbuuds_epi32
 163 // CHECK: @llvm.x86.avx2.vpdpbuuds.128
 164 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 165   return _mm_mask_dpbuuds_epi32(__W, __U, __A, __B);
 166 }
 167
 168 __m128i test_mm_maskz_dpbuuds_epi32(__mmask8 __U, __m128i __W, __m128i __A, __m128i __B) {
 169 // CHECK-LABEL: @test_mm_maskz_dpbuuds_epi32
 170 // CHECK: @llvm.x86.avx2.vpdpbuuds.128
 171 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 172   return _mm_maskz_dpbuuds_epi32(__U, __W, __A, __B);
 173 }
 174
 175 __m256i test_mm256_mask_dpbssd_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
 176 // CHECK-LABEL: @test_mm256_mask_dpbssd_epi32
 177 // CHECK: @llvm.x86.avx2.vpdpbssd.256
 178 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 179   return _mm256_mask_dpbssd_epi32(__W, __U, __A, __B);
 180 }
 181
 182 __m256i test_mm256_maskz_dpbssd_epi32(__mmask8 __U, __m256i __W, __m256i __A, __m256i __B) {
 183 // CHECK-LABEL: @test_mm256_maskz_dpbssd_epi32
 184 // CHECK: @llvm.x86.avx2.vpdpbssd.256
 185 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 186   return _mm256_maskz_dpbssd_epi32(__U, __W, __A, __B);
 187 }
 188
 189 __m256i test_mm256_mask_dpbssds_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
 190 // CHECK-LABEL: @test_mm256_mask_dpbssds_epi32
 191 // CHECK: @llvm.x86.avx2.vpdpbssds.256
 192 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 193   return _mm256_mask_dpbssds_epi32(__W, __U, __A, __B);
 194 }
 195
 196 __m256i test_mm256_maskz_dpbssds_epi32(__mmask8 __U, __m256i __W, __m256i __A, __m256i __B) {
 197 // CHECK-LABEL: @test_mm256_maskz_dpbssds_epi32
 198 // CHECK: @llvm.x86.avx2.vpdpbssds.256
 199 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 200   return _mm256_maskz_dpbssds_epi32(__U, __W, __A, __B);
 201 }
 202
 203 __m256i test_mm256_mask_dpbsud_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
 204 // CHECK-LABEL: @test_mm256_mask_dpbsud_epi32
 205 // CHECK: @llvm.x86.avx2.vpdpbsud.256
 206 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 207   return _mm256_mask_dpbsud_epi32(__W, __U, __A, __B);
 208 }
 209
 210 __m256i test_mm256_maskz_dpbsud_epi32(__mmask8 __U, __m256i __W, __m256i __A, __m256i __B) {
 211 // CHECK-LABEL: @test_mm256_maskz_dpbsud_epi32
 212 // CHECK: @llvm.x86.avx2.vpdpbsud.256
 213 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 214   return _mm256_maskz_dpbsud_epi32(__U, __W, __A, __B);
 215 }
 216
 217 __m256i test_mm256_mask_dpbsuds_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
 218 // CHECK-LABEL: @test_mm256_mask_dpbsuds_epi32
 219 // CHECK: @llvm.x86.avx2.vpdpbsuds.256
 220 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 221   return _mm256_mask_dpbsuds_epi32(__W, __U, __A, __B);
 222 }
 223
 224 __m256i test_mm256_maskz_dpbsuds_epi32(__mmask8 __U, __m256i __W, __m256i __A, __m256i __B) {
 225 // CHECK-LABEL: @test_mm256_maskz_dpbsuds_epi32
 226 // CHECK: @llvm.x86.avx2.vpdpbsuds.256
 227 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 228   return _mm256_maskz_dpbsuds_epi32(__U, __W, __A, __B);
 229 }
 230
 231 __m256i test_mm256_mask_dpbuud_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
 232 // CHECK-LABEL: @test_mm256_mask_dpbuud_epi32
 233 // CHECK: @llvm.x86.avx2.vpdpbuud.256
 234 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 235   return _mm256_mask_dpbuud_epi32(__W, __U, __A, __B);
 236 }
 237
 238 __m256i test_mm256_maskz_dpbuud_epi32(__mmask8 __U, __m256i __W, __m256i __A, __m256i __B) {
 239 // CHECK-LABEL: @test_mm256_maskz_dpbuud_epi32
 240 // CHECK: @llvm.x86.avx2.vpdpbuud.256
 241 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 242   return _mm256_maskz_dpbuud_epi32(__U, __W, __A, __B);
 243 }
 244
 245 __m256i test_mm256_mask_dpbuuds_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
 246 // CHECK-LABEL: @test_mm256_mask_dpbuuds_epi32
 247 // CHECK: @llvm.x86.avx2.vpdpbuuds.256
 248 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 249   return _mm256_mask_dpbuuds_epi32(__W, __U, __A, __B);
 250 }
 251
 252 __m256i test_mm256_maskz_dpbuuds_epi32(__mmask8 __U, __m256i __W, __m256i __A, __m256i __B) {
 253 // CHECK-LABEL: @test_mm256_maskz_dpbuuds_epi32
 254 // CHECK: @llvm.x86.avx2.vpdpbuuds.256
 255 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 256   return _mm256_maskz_dpbuuds_epi32(__U, __W, __A, __B);
 257 }
 258
 259 // VNNI INT16
 260 __m128i test_mm_mask_dpwsud_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 261 // CHECK-LABEL: @test_mm_mask_dpwsud_epi32(
 262 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwsud.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 263 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 264   return _mm_mask_dpwsud_epi32(__A, __B, __C, __D);
 265 }
 266
 267 __m128i test_mm_maskz_dpwsud_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 268 // CHECK-LABEL: @test_mm_maskz_dpwsud_epi32(
 269 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwsud.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 270 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 271   return _mm_maskz_dpwsud_epi32(__A, __B, __C, __D);
 272 }
 273
 274 __m256i test_mm256_mask_dpwsud_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 275 // CHECK-LABEL: @test_mm256_mask_dpwsud_epi32(
 276 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwsud.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 277 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 278   return _mm256_mask_dpwsud_epi32(__A, __B, __C, __D);
 279 }
 280
 281 __m256i test_mm256_maskz_dpwsud_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 282 // CHECK-LABEL: @test_mm256_maskz_dpwsud_epi32(
 283 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwsud.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 284 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 285   return _mm256_maskz_dpwsud_epi32(__A, __B, __C, __D);
 286 }
 287
 288 __m128i test_mm_mask_dpwsuds_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 289 // CHECK-LABEL: @test_mm_mask_dpwsuds_epi32(
 290 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwsuds.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 291 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 292   return _mm_mask_dpwsuds_epi32(__A, __B, __C, __D);
 293 }
 294
 295 __m128i test_mm_maskz_dpwsuds_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 296 // CHECK-LABEL: @test_mm_maskz_dpwsuds_epi32(
 297 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwsuds.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 298 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 299   return _mm_maskz_dpwsuds_epi32(__A, __B, __C, __D);
 300 }
 301
 302 __m256i test_mm256_mask_dpwsuds_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 303 // CHECK-LABEL: @test_mm256_mask_dpwsuds_epi32(
 304 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwsuds.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 305 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 306   return _mm256_mask_dpwsuds_epi32(__A, __B, __C, __D);
 307 }
 308
 309 __m256i test_mm256_maskz_dpwsuds_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 310 // CHECK-LABEL: @test_mm256_maskz_dpwsuds_epi32(
 311 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwsuds.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 312 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 313   return _mm256_maskz_dpwsuds_epi32(__A, __B, __C, __D);
 314 }
 315
 316 __m128i test_mm_mask_dpwusd_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 317 // CHECK-LABEL: @test_mm_mask_dpwusd_epi32(
 318 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwusd.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 319 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 320   return _mm_mask_dpwusd_epi32(__A, __B, __C, __D);
 321 }
 322
 323 __m128i test_mm_maskz_dpwusd_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 324 // CHECK-LABEL: @test_mm_maskz_dpwusd_epi32(
 325 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwusd.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 326 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 327   return _mm_maskz_dpwusd_epi32(__A, __B, __C, __D);
 328 }
 329
 330 __m256i test_mm256_mask_dpwusd_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 331 // CHECK-LABEL: @test_mm256_mask_dpwusd_epi32(
 332 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwusd.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 333 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 334   return _mm256_mask_dpwusd_epi32(__A, __B, __C, __D);
 335 }
 336
 337 __m256i test_mm256_maskz_dpwusd_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 338 // CHECK-LABEL: @test_mm256_maskz_dpwusd_epi32(
 339 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwusd.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 340 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 341   return _mm256_maskz_dpwusd_epi32(__A, __B, __C, __D);
 342 }
 343
 344 __m128i test_mm_mask_dpwusds_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 345 // CHECK-LABEL: @test_mm_mask_dpwusds_epi32(
 346 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwusds.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 347 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 348   return _mm_mask_dpwusds_epi32(__A, __B, __C, __D);
 349 }
 350
 351 __m128i test_mm_maskz_dpwusds_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 352 // CHECK-LABEL: @test_mm_maskz_dpwusds_epi32(
 353 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwusds.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 354 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 355   return _mm_maskz_dpwusds_epi32(__A, __B, __C, __D);
 356 }
 357
 358 __m256i test_mm256_mask_dpwusds_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 359 // CHECK-LABEL: @test_mm256_mask_dpwusds_epi32(
 360 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwusds.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 361 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 362   return _mm256_mask_dpwusds_epi32(__A, __B, __C, __D);
 363 }
 364
 365 __m256i test_mm256_maskz_dpwusds_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 366 // CHECK-LABEL: @test_mm256_maskz_dpwusds_epi32(
 367 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwusds.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 368 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 369   return _mm256_maskz_dpwusds_epi32(__A, __B, __C, __D);
 370 }
 371
 372 __m128i test_mm_mask_dpwuud_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 373 // CHECK-LABEL: @test_mm_mask_dpwuud_epi32(
 374 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwuud.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 375 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 376   return _mm_mask_dpwuud_epi32(__A, __B, __C, __D);
 377 }
 378
 379 __m128i test_mm_maskz_dpwuud_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 380 // CHECK-LABEL: @test_mm_maskz_dpwuud_epi32(
 381 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwuud.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 382 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 383   return _mm_maskz_dpwuud_epi32(__A, __B, __C, __D);
 384 }
 385
 386 __m256i test_mm256_mask_dpwuud_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 387 // CHECK-LABEL: @test_mm256_mask_dpwuud_epi32(
 388 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwuud.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 389 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 390   return _mm256_mask_dpwuud_epi32(__A, __B, __C, __D);
 391 }
 392
 393 __m256i test_mm256_maskz_dpwuud_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 394 // CHECK-LABEL: @test_mm256_maskz_dpwuud_epi32(
 395 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwuud.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 396 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 397   return _mm256_maskz_dpwuud_epi32(__A, __B, __C, __D);
 398 }
 399
 400 __m128i test_mm_mask_dpwuuds_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 401 // CHECK-LABEL: @test_mm_mask_dpwuuds_epi32(
 402 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwuuds.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 403 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 404   return _mm_mask_dpwuuds_epi32(__A, __B, __C, __D);
 405 }
 406
 407 __m128i test_mm_maskz_dpwuuds_epi32(__m128i __A, __mmask8 __B, __m128i __C, __m128i __D) {
 408 // CHECK-LABEL: @test_mm_maskz_dpwuuds_epi32(
 409 // CHECK: call <4 x i32> @llvm.x86.avx2.vpdpwuuds.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 410 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 411   return _mm_maskz_dpwuuds_epi32(__A, __B, __C, __D);
 412 }
 413
 414 __m256i test_mm256_mask_dpwuuds_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 415 // CHECK-LABEL: @test_mm256_mask_dpwuuds_epi32(
 416 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwuuds.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 417 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 418   return _mm256_mask_dpwuuds_epi32(__A, __B, __C, __D);
 419 }
 420
 421 __m256i test_mm256_maskz_dpwuuds_epi32(__m256i __A, __mmask8 __B, __m256i __C, __m256i __D) {
 422 // CHECK-LABEL: @test_mm256_maskz_dpwuuds_epi32(
 423 // CHECK: call <8 x i32> @llvm.x86.avx2.vpdpwuuds.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 424 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 425   return _mm256_maskz_dpwuuds_epi32(__A, __B, __C, __D);
 426 }
 427
 428 // YMM Rounding
 429 __m256d test_mm256_add_round_pd(__m256d __A, __m256d __B) {
 430 // CHECK-LABEL: @test_mm256_add_round_pd
 431 // CHECK: @llvm.x86.avx10.vaddpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 11)
 432   return _mm256_add_round_pd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 433 }
 434
 435 __m256d test_mm256_mask_add_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
 436 // CHECK-LABEL: @test_mm256_mask_add_round_pd
 437 // CHECK: @llvm.x86.avx10.vaddpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 10)
 438 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 439   return _mm256_mask_add_round_pd(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
 440 }
 441
 442 __m256d test_mm256_maskz_add_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
 443 // CHECK-LABEL: @test_mm256_maskz_add_round_pd
 444 // CHECK: @llvm.x86.avx10.vaddpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 9)
 445 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 446   return _mm256_maskz_add_round_pd(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
 447 }
 448
 449 __m256h test_mm256_add_round_ph(__m256h __A, __m256h __B) {
 450 // CHECK-LABEL: @test_mm256_add_round_ph
 451 // CHECK: @llvm.x86.avx10.vaddph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 11)
 452   return _mm256_add_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 453 }
 454
 455 __m256h test_mm256_mask_add_round_ph(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
 456 // CHECK-LABEL: @test_mm256_mask_add_round_ph
 457 // CHECK: @llvm.x86.avx10.vaddph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 10)
 458 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
 459   return _mm256_mask_add_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
 460 }
 461
 462 __m256h test_mm256_maskz_add_round_ph(__mmask8 __U, __m256h __A, __m256h __B) {
 463 // CHECK-LABEL: @test_mm256_maskz_add_round_ph
 464 // CHECK: @llvm.x86.avx10.vaddph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 9)
 465 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
 466   return _mm256_maskz_add_round_ph(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
 467 }
 468
 469 __m256 test_mm256_add_round_ps(__m256 __A, __m256 __B) {
 470 // CHECK-LABEL: @test_mm256_add_round_ps
 471 // CHECK: @llvm.x86.avx10.vaddps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 11)
 472   return _mm256_add_round_ps(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 473 }
 474
 475 __m256 test_mm256_mask_add_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
 476 // CHECK-LABEL: @test_mm256_mask_add_round_ps
 477 // CHECK: @llvm.x86.avx10.vaddps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 10)
 478 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 479   return _mm256_mask_add_round_ps(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
 480 }
 481
 482 __m256 test_mm256_maskz_add_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
 483 // CHECK-LABEL: @test_mm256_maskz_add_round_ps
 484 // CHECK: @llvm.x86.avx10.vaddps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 9)
 485 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 486   return _mm256_maskz_add_round_ps(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
 487 }
 488
 489 __mmask8 test_mm256_cmp_round_pd_mask(__m256d a, __m256d b) {
 490 // CHECK-LABEL: @test_mm256_cmp_round_pd_mask
 491 // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
 492   return _mm256_cmp_round_pd_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 493 }
 494
 495 __mmask8 test_mm256_mask_cmp_round_pd_mask(__mmask8 m, __m256d a, __m256d b) {
 496 // CHECK-LABEL: @test_mm256_mask_cmp_round_pd_mask
 497 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x double> %{{.*}}, %{{.*}}
 498 // CHECK: and <4 x i1> [[CMP]], {{.*}}
 499   return _mm256_mask_cmp_round_pd_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 500 }
 501
 502 __mmask16 test_mm256_cmp_round_ph_mask(__m256h a, __m256h b) {
 503 // CHECK-LABEL: @test_mm256_cmp_round_ph_mask
 504 // CHECK: fcmp oeq <16 x half> %{{.*}}, %{{.*}}
 505   return _mm256_cmp_round_ph_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 506 }
 507
 508 __mmask16 test_mm256_mask_cmp_round_ph_mask(__mmask16 m, __m256h a, __m256h b) {
 509 // CHECK-LABEL: @test_mm256_mask_cmp_round_ph_mask
 510 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x half> %{{.*}}, %{{.*}}
 511 // CHECK: and <16 x i1> [[CMP]], {{.*}}
 512   return _mm256_mask_cmp_round_ph_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 513 }
 514
 515 __mmask8 test_mm256_cmp_round_ps_mask(__m256 a, __m256 b) {
 516 // CHECK-LABEL: @test_mm256_cmp_round_ps_mask
 517 // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
 518   return _mm256_cmp_round_ps_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 519 }
 520
 521 __mmask8 test_mm256_mask_cmp_round_ps_mask(__mmask8 m, __m256 a, __m256 b) {
 522 // CHECK-LABEL: @test_mm256_mask_cmp_round_ps_mask
 523 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x float> %{{.*}}, %{{.*}}
 524 // CHECK: and <8 x i1> [[CMP]], {{.*}}
 525   return _mm256_mask_cmp_round_ps_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 526 }
 527
 528 __m128h test_mm256_cvt_roundepi32_ph(__m256i A) {
 529 // CHECK-LABEL: test_mm256_cvt_roundepi32_ph
 530 // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v8i32(<8 x i32> %{{.*}}, i32 11)
 531   return _mm256_cvt_roundepi32_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 532 }
 533
 534 __m128h test_mm256_mask_cvt_roundepi32_ph(__m128h A, __mmask8 B, __m256i C) {
 535 // CHECK-LABEL: test_mm256_mask_cvt_roundepi32_ph
 536 // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v8i32(<8 x i32> %{{.*}}, i32 10)
 537 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
 538   return _mm256_mask_cvt_roundepi32_ph(A, B, C, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
 539 }
 540
 541 __m128h test_mm256_maskz_cvt_roundepi32_ph(__mmask8 A, __m256i B) {
 542 // CHECK-LABEL: test_mm256_maskz_cvt_roundepi32_ph
 543 // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v8i32(<8 x i32> %{{.*}}, i32 9)
 544 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
 545   return _mm256_maskz_cvt_roundepi32_ph(A, B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
 546 }
 547
 548 __m256 test_mm256_cvt_roundepi32_ps(__m256i __A)
 549 {
 550 // CHECK-LABEL: @test_mm256_cvt_roundepi32_ps
 551 // CHECK: @llvm.x86.avx512.sitofp.round.v8f32.v8i32
 552   return _mm256_cvt_roundepi32_ps(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 553 }
 554
 555 __m256 test_mm256_mask_cvt_roundepi32_ps(__m256 __W, __mmask8 __U, __m256i __A)
 556 {
 557 // CHECK-LABEL: @test_mm256_mask_cvt_roundepi32_ps
 558 // CHECK: @llvm.x86.avx512.sitofp.round.v8f32.v8i32
 559 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 560   return _mm256_mask_cvt_roundepi32_ps(__W, __U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 561 }
 562
 563 __m256 test_mm256_maskz_cvt_roundepi32_ps(__mmask8 __U, __m256i __A)
 564 {
 565 // CHECK-LABEL: @test_mm256_maskz_cvt_roundepi32_ps
 566 // CHECK: @llvm.x86.avx512.sitofp.round.v8f32.v8i32
 567 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 568   return _mm256_maskz_cvt_roundepi32_ps(__U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 569 }
 570
 571 __m128i test_mm256_cvt_roundpd_epi32(__m256d A)
 572 {
 573 // CHECK-LABEL: @test_mm256_cvt_roundpd_epi32
 574 // CHECK: @llvm.x86.avx10.mask.vcvtpd2dq256
 575   return _mm256_cvt_roundpd_epi32(A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 576 }
 577
 578 __m128i test_mm256_mask_cvt_roundpd_epi32(__m128i W,__mmask8 U,__m256d A)
 579 {
 580 // CHECK-LABEL: @test_mm256_mask_cvt_roundpd_epi32
 581 // CHECK: @llvm.x86.avx10.mask.vcvtpd2dq256
 582   return _mm256_mask_cvt_roundpd_epi32(W, U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 583 }
 584
 585 __m128i test_mm256_maskz_cvt_roundpd_epi32(__mmask8 U, __m256d A)
 586 {
 587 // CHECK-LABEL: @test_mm256_maskz_cvt_roundpd_epi32
 588 // CHECK: @llvm.x86.avx10.mask.vcvtpd2dq256
 589   return _mm256_maskz_cvt_roundpd_epi32(U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 590 }
 591
 592 __m128h test_mm256_cvt_roundpd_ph(__m256d A) {
 593 // CHECK-LABEL: test_mm256_cvt_roundpd_ph
 594 // CHECK: @llvm.x86.avx10.mask.vcvtpd2ph256
 595   return _mm256_cvt_roundpd_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 596 }
 597
 598 __m128h test_mm256_mask_cvt_roundpd_ph(__m128h A, __mmask8 B, __m256d C) {
 599 // CHECK-LABEL: test_mm256_mask_cvt_roundpd_ph
 600 // CHECK: @llvm.x86.avx10.mask.vcvtpd2ph256
 601   return _mm256_mask_cvt_roundpd_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 602 }
 603
 604 __m128h test_mm256_maskz_cvt_roundpd_ph(__mmask8 A, __m256d B) {
 605 // CHECK-LABEL: test_mm256_maskz_cvt_roundpd_ph
 606 // CHECK: @llvm.x86.avx10.mask.vcvtpd2ph256
 607   return _mm256_maskz_cvt_roundpd_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 608 }
 609
 610 __m128 test_mm256_cvt_roundpd_ps(__m256d A)
 611 {
 612 // CHECK-LABEL: @test_mm256_cvt_roundpd_ps
 613 // CHECK: @llvm.x86.avx10.mask.vcvtpd2ps256
 614   return _mm256_cvt_roundpd_ps(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 615 }
 616
 617 __m128 test_mm256_mask_cvt_roundpd_ps(__m128 W, __mmask8 U,__m256d A)
 618 {
 619 // CHECK-LABEL: @test_mm256_mask_cvt_roundpd_ps
 620 // CHECK: @llvm.x86.avx10.mask.vcvtpd2ps256
 621   return _mm256_mask_cvt_roundpd_ps(W, U, A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 622 }
 623
 624 __m128 test_mm256_maskz_cvt_roundpd_ps(__mmask8 U, __m256d A)
 625 {
 626 // CHECK-LABEL: @test_mm256_maskz_cvt_roundpd_ps
 627 // CHECK: @llvm.x86.avx10.mask.vcvtpd2ps256
 628   return _mm256_maskz_cvt_roundpd_ps(U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 629 }
 630
 631 __m256i test_mm256_cvt_roundpd_epi64(__m256d __A) {
 632 // CHECK-LABEL: @test_mm256_cvt_roundpd_epi64
 633 // CHECK: @llvm.x86.avx10.mask.vcvtpd2qq256
 634   return _mm256_cvt_roundpd_epi64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 635 }
 636
 637 __m256i test_mm256_mask_cvt_roundpd_epi64(__m256i __W, __mmask8 __U, __m256d __A) {
 638 // CHECK-LABEL: @test_mm256_mask_cvt_roundpd_epi64
 639 // CHECK: @llvm.x86.avx10.mask.vcvtpd2qq256
 640   return _mm256_mask_cvt_roundpd_epi64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 641 }
 642
 643 __m256i test_mm256_maskz_cvt_roundpd_epi64(__mmask8 __U, __m256d __A) {
 644 // CHECK-LABEL: @test_mm256_maskz_cvt_roundpd_epi64
 645 // CHECK: @llvm.x86.avx10.mask.vcvtpd2qq256
 646   return _mm256_maskz_cvt_roundpd_epi64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 647 }
 648
 649 __m128i test_mm256_cvt_roundpd_epu32(__m256d A)
 650 {
 651 // CHECK-LABEL: @test_mm256_cvt_roundpd_epu32
 652 // CHECK: @llvm.x86.avx10.mask.vcvtpd2udq256
 653   return _mm256_cvt_roundpd_epu32(A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 654 }
 655
 656 __m128i test_mm256_mask_cvt_roundpd_epu32(__m128i W,__mmask8 U,__m256d A)
 657 {
 658 // CHECK-LABEL: @test_mm256_mask_cvt_roundpd_epu32
 659 // CHECK: @llvm.x86.avx10.mask.vcvtpd2udq256
 660   return _mm256_mask_cvt_roundpd_epu32(W, U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 661 }
 662
 663 __m128i test_mm256_maskz_cvt_roundpd_epu32(__mmask8 U, __m256d A)
 664 {
 665 // CHECK-LABEL: @test_mm256_maskz_cvt_roundpd_epu32
 666 // CHECK: @llvm.x86.avx10.mask.vcvtpd2udq256
 667   return _mm256_maskz_cvt_roundpd_epu32(U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 668 }
 669
 670 __m256i test_mm256_cvt_roundpd_epu64(__m256d __A) {
 671 // CHECK-LABEL: @test_mm256_cvt_roundpd_epu64
 672 // CHECK: @llvm.x86.avx10.mask.vcvtpd2uqq256
 673   return _mm256_cvt_roundpd_epu64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 674 }
 675
 676 __m256i test_mm256_mask_cvt_roundpd_epu64(__m256i __W, __mmask8 __U, __m256d __A) {
 677 // CHECK-LABEL: @test_mm256_mask_cvt_roundpd_epu64
 678 // CHECK: @llvm.x86.avx10.mask.vcvtpd2uqq256
 679   return _mm256_mask_cvt_roundpd_epu64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 680 }
 681
 682 __m256i test_mm256_maskz_cvt_roundpd_epu64(__mmask8 __U, __m256d __A) {
 683 // CHECK-LABEL: @test_mm256_maskz_cvt_roundpd_epu64
 684 // CHECK: @llvm.x86.avx10.mask.vcvtpd2uqq256
 685   return _mm256_maskz_cvt_roundpd_epu64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 686 }
 687
 688 __m256i test_mm256_cvt_roundph_epi32(__m128h A) {
 689 // CHECK-LABEL: test_mm256_cvt_roundph_epi32
 690 // CHECK: @llvm.x86.avx10.mask.vcvtph2dq256
 691   return _mm256_cvt_roundph_epi32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 692 }
 693
 694 __m256i test_mm256_mask_cvt_roundph_epi32(__m256i A, __mmask16 B, __m128h C) {
 695 // CHECK-LABEL: test_mm256_mask_cvt_roundph_epi32
 696 // CHECK: @llvm.x86.avx10.mask.vcvtph2dq256
 697   return _mm256_mask_cvt_roundph_epi32(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 698 }
 699
 700 __m256i test_mm256_maskz_cvt_roundph_epi32(__mmask16 A, __m128h B) {
 701 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_epi32
 702 // CHECK: @llvm.x86.avx10.mask.vcvtph2dq256
 703   return _mm256_maskz_cvt_roundph_epi32(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 704 }
 705
 706 __m256d test_mm256_cvt_roundph_pd(__m128h A) {
 707 // CHECK-LABEL: test_mm256_cvt_roundph_pd
 708 // CHECK: @llvm.x86.avx10.mask.vcvtph2pd256
 709   return _mm256_cvt_roundph_pd(A, _MM_FROUND_NO_EXC);
 710 }
 711
 712 __m256d test_mm256_mask_cvt_roundph_pd(__m256d A, __mmask8 B, __m128h C) {
 713 // CHECK-LABEL: test_mm256_mask_cvt_roundph_pd
 714 // CHECK: @llvm.x86.avx10.mask.vcvtph2pd256
 715   return _mm256_mask_cvt_roundph_pd(A, B, C, _MM_FROUND_NO_EXC);
 716 }
 717
 718 __m256d test_mm256_maskz_cvt_roundph_pd(__mmask8 A, __m128h B) {
 719 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_pd
 720 // CHECK: @llvm.x86.avx10.mask.vcvtph2pd256
 721   return _mm256_maskz_cvt_roundph_pd(A, B, _MM_FROUND_NO_EXC);
 722 }
 723
 724 __m256 test_mm256_cvtx_roundph_ps(__m128h A) {
 725 // CHECK-LABEL: test_mm256_cvtx_roundph_ps
 726 // CHECK: @llvm.x86.avx10.mask.vcvtph2psx256
 727   return _mm256_cvtx_roundph_ps(A, _MM_FROUND_NO_EXC);
 728 }
 729
 730 __m256 test_mm256_mask_cvtx_roundph_ps(__m256 A, __mmask16 B, __m128h C) {
 731 // CHECK-LABEL: test_mm256_mask_cvtx_roundph_ps
 732 // CHECK: @llvm.x86.avx10.mask.vcvtph2psx256
 733   return _mm256_mask_cvtx_roundph_ps(A, B, C, _MM_FROUND_NO_EXC);
 734 }
 735
 736 __m256 test_mm256_maskz_cvtx_roundph_ps(__mmask16 A, __m128h B) {
 737 // CHECK-LABEL: test_mm256_maskz_cvtx_roundph_ps
 738 // CHECK: @llvm.x86.avx10.mask.vcvtph2psx256
 739   return _mm256_maskz_cvtx_roundph_ps(A, B, _MM_FROUND_NO_EXC);
 740 }
 741
 742 __m256i test_mm256_cvt_roundph_epi64(__m128h A) {
 743 // CHECK-LABEL: test_mm256_cvt_roundph_epi64
 744 // CHECK: @llvm.x86.avx10.mask.vcvtph2qq256
 745   return _mm256_cvt_roundph_epi64(A, _MM_FROUND_NO_EXC);
 746 }
 747
 748 __m256i test_mm256_mask_cvt_roundph_epi64(__m256i A, __mmask8 B, __m128h C) {
 749 // CHECK-LABEL: test_mm256_mask_cvt_roundph_epi64
 750 // CHECK: @llvm.x86.avx10.mask.vcvtph2qq256
 751   return _mm256_mask_cvt_roundph_epi64(A, B, C, _MM_FROUND_NO_EXC);
 752 }
 753
 754 __m256i test_mm256_maskz_cvt_roundph_epi64(__mmask8 A, __m128h B) {
 755 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_epi64
 756 // CHECK: @llvm.x86.avx10.mask.vcvtph2qq256
 757   return _mm256_maskz_cvt_roundph_epi64(A, B, _MM_FROUND_NO_EXC);
 758 }
 759
 760 __m256i test_mm256_cvt_roundph_epu32(__m128h A) {
 761 // CHECK-LABEL: test_mm256_cvt_roundph_epu32
 762 // CHECK: @llvm.x86.avx10.mask.vcvtph2udq256
 763   return _mm256_cvt_roundph_epu32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 764 }
 765
 766 __m256i test_mm256_mask_cvt_roundph_epu32(__m256i A, __mmask16 B, __m128h C) {
 767 // CHECK-LABEL: test_mm256_mask_cvt_roundph_epu32
 768 // CHECK: @llvm.x86.avx10.mask.vcvtph2udq256
 769   return _mm256_mask_cvt_roundph_epu32(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 770 }
 771
 772 __m256i test_mm256_maskz_cvt_roundph_epu32(__mmask16 A, __m128h B) {
 773 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_epu32
 774 // CHECK: @llvm.x86.avx10.mask.vcvtph2udq256
 775   return _mm256_maskz_cvt_roundph_epu32(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 776 }
 777
 778 __m256i test_mm256_cvt_roundph_epu64(__m128h A) {
 779 // CHECK-LABEL: test_mm256_cvt_roundph_epu64
 780 // CHECK: @llvm.x86.avx10.mask.vcvtph2uqq256
 781   return _mm256_cvt_roundph_epu64(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 782 }
 783
 784 __m256i test_mm256_mask_cvt_roundph_epu64(__m256i A, __mmask8 B, __m128h C) {
 785 // CHECK-LABEL: test_mm256_mask_cvt_roundph_epu64
 786 // CHECK: @llvm.x86.avx10.mask.vcvtph2uqq256
 787   return _mm256_mask_cvt_roundph_epu64(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 788 }
 789
 790 __m256i test_mm256_maskz_cvt_roundph_epu64(__mmask8 A, __m128h B) {
 791 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_epu64
 792 // CHECK: @llvm.x86.avx10.mask.vcvtph2uqq256
 793   return _mm256_maskz_cvt_roundph_epu64(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 794 }
 795
 796 __m256i test_mm256_cvt_roundph_epu16(__m256h A) {
 797 // CHECK-LABEL: test_mm256_cvt_roundph_epu16
 798 // CHECK: @llvm.x86.avx10.mask.vcvtph2uw256
 799   return _mm256_cvt_roundph_epu16(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 800 }
 801
 802 __m256i test_mm256_mask_cvt_roundph_epu16(__m256i A, __mmask32 B, __m256h C) {
 803 // CHECK-LABEL: test_mm256_mask_cvt_roundph_epu16
 804 // CHECK: @llvm.x86.avx10.mask.vcvtph2uw256
 805   return _mm256_mask_cvt_roundph_epu16(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 806 }
 807
 808 __m256i test_mm256_maskz_cvt_roundph_epu16(__mmask32 A, __m256h B) {
 809 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_epu16
 810 // CHECK: @llvm.x86.avx10.mask.vcvtph2uw256
 811   return _mm256_maskz_cvt_roundph_epu16(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 812 }
 813
 814 __m256i test_mm256_cvt_roundph_epi16(__m256h A) {
 815 // CHECK-LABEL: test_mm256_cvt_roundph_epi16
 816 // CHECK: @llvm.x86.avx10.mask.vcvtph2w256
 817   return _mm256_cvt_roundph_epi16(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 818 }
 819
 820 __m256i test_mm256_mask_cvt_roundph_epi16(__m256i A, __mmask32 B, __m256h C) {
 821 // CHECK-LABEL: test_mm256_mask_cvt_roundph_epi16
 822 // CHECK: @llvm.x86.avx10.mask.vcvtph2w256
 823   return _mm256_mask_cvt_roundph_epi16(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 824 }
 825
 826 __m256i test_mm256_maskz_cvt_roundph_epi16(__mmask32 A, __m256h B) {
 827 // CHECK-LABEL: test_mm256_maskz_cvt_roundph_epi16
 828 // CHECK: @llvm.x86.avx10.mask.vcvtph2w256
 829   return _mm256_maskz_cvt_roundph_epi16(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 830 }
 831
 832 __m256i test_mm256_cvt_roundps_epi32(__m256 __A)
 833 {
 834 // CHECK-LABEL: @test_mm256_cvt_roundps_epi32
 835 // CHECK: @llvm.x86.avx10.mask.vcvtps2dq256
 836   return _mm256_cvt_roundps_epi32(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 837 }
 838
 839 __m256i test_mm256_mask_cvt_roundps_epi32(__m256i __W,__mmask16 __U,__m256 __A)
 840 {
 841 // CHECK-LABEL: @test_mm256_mask_cvt_roundps_epi32
 842 // CHECK: @llvm.x86.avx10.mask.vcvtps2dq256
 843   return _mm256_mask_cvt_roundps_epi32(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 844 }
 845
 846 __m256i test_mm256_maskz_cvt_roundps_epi32(__mmask16 __U, __m256 __A)
 847 {
 848 // CHECK-LABEL: @test_mm256_maskz_cvt_roundps_epi32
 849 // CHECK: @llvm.x86.avx10.mask.vcvtps2dq256
 850   return _mm256_maskz_cvt_roundps_epi32(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 851 }
 852
 853 __m256d test_mm256_cvt_roundps_pd(__m128 __A) {
 854 // CHECK-LABEL: @test_mm256_cvt_roundps_pd
 855 // CHECK: @llvm.x86.avx10.mask.vcvtps2pd256
 856   return _mm256_cvt_roundps_pd(__A, _MM_FROUND_NO_EXC);
 857 }
 858
 859 __m256d test_mm256_mask_cvt_roundps_pd(__m256d __W, __mmask8 __U, __m128 __A) {
 860 // CHECK-LABEL: @test_mm256_mask_cvt_roundps_pd
 861 // CHECK: @llvm.x86.avx10.mask.vcvtps2pd256
 862   return _mm256_mask_cvt_roundps_pd(__W, __U, __A, _MM_FROUND_NO_EXC);
 863 }
 864
 865 __m256d test_mm256_maskz_cvt_roundps_pd(__mmask8 __U, __m128 __A) {
 866 // CHECK-LABEL: @test_mm256_maskz_cvt_roundps_pd
 867 // CHECK: @llvm.x86.avx10.mask.vcvtps2pd256
 868   return _mm256_maskz_cvt_roundps_pd(__U, __A, _MM_FROUND_NO_EXC);
 869 }
 870
 871 // FIXME: We may change to @llvm.x86.avx10.mask.vcvtps2ph256 in future.
 872 __m128i test_mm256_cvt_roundps_ph(__m256  __A)
 873 {
 874   // CHECK-LABEL: @test_mm256_cvt_roundps_ph
 875   // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.256
 876     return _mm256_cvt_roundps_ph(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 877 }
 878
 879 __m128i test_mm256_mask_cvt_roundps_ph(__m128i __W , __mmask16 __U, __m256  __A)
 880 {
 881   // CHECK-LABEL: @test_mm256_mask_cvt_roundps_ph
 882   // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.256
 883     return _mm256_mask_cvt_roundps_ph(__W, __U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 884 }
 885
 886 __m128i test_mm256_maskz_cvt_roundps_ph(__mmask16 __U, __m256  __A)
 887 {
 888   // CHECK-LABEL: @test_mm256_maskz_cvt_roundps_ph
 889   // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.256
 890     return _mm256_maskz_cvt_roundps_ph(__U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 891 }
 892
 893 __m128h test_mm256_cvtx_roundps_ph(__m256 A) {
 894 // CHECK-LABEL: test_mm256_cvtx_roundps_ph
 895 // CHECK: @llvm.x86.avx10.mask.vcvtps2phx256
 896   return _mm256_cvtx_roundps_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 897 }
 898
 899 __m128h test_mm256_mask_cvtx_roundps_ph(__m128h A, __mmask16 B, __m256 C) {
 900 // CHECK-LABEL: test_mm256_mask_cvtx_roundps_ph
 901 // CHECK: @llvm.x86.avx10.mask.vcvtps2phx256
 902   return _mm256_mask_cvtx_roundps_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 903 }
 904
 905 __m128h test_mm256_maskz_cvtx_roundps_ph(__mmask16 A, __m256 B) {
 906 // CHECK-LABEL: test_mm256_maskz_cvtx_roundps_ph
 907 // CHECK: @llvm.x86.avx10.mask.vcvtps2phx256
 908   return _mm256_maskz_cvtx_roundps_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 909 }
 910
 911 __m256i test_mm256_cvt_roundps_epi64(__m128 __A) {
 912 // CHECK-LABEL: @test_mm256_cvt_roundps_epi64
 913 // CHECK: @llvm.x86.avx10.mask.vcvtps2qq256
 914   return _mm256_cvt_roundps_epi64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 915 }
 916
 917 __m256i test_mm256_mask_cvt_roundps_epi64(__m256i __W, __mmask8 __U, __m128 __A) {
 918 // CHECK-LABEL: @test_mm256_mask_cvt_roundps_epi64
 919 // CHECK: @llvm.x86.avx10.mask.vcvtps2qq256
 920   return _mm256_mask_cvt_roundps_epi64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 921 }
 922
 923 __m256i test_mm256_maskz_cvt_roundps_epi64(__mmask8 __U, __m128 __A) {
 924 // CHECK-LABEL: @test_mm256_maskz_cvt_roundps_epi64
 925 // CHECK: @llvm.x86.avx10.mask.vcvtps2qq256
 926   return _mm256_maskz_cvt_roundps_epi64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 927 }
 928
 929 __m256i test_mm256_cvt_roundps_epu32(__m256 __A)
 930 {
 931 // CHECK-LABEL: @test_mm256_cvt_roundps_epu32
 932 // CHECK: @llvm.x86.avx10.mask.vcvtps2udq256
 933   return _mm256_cvt_roundps_epu32(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 934 }
 935
 936 __m256i test_mm256_mask_cvt_roundps_epu32(__m256i __W,__mmask16 __U,__m256 __A)
 937 {
 938 // CHECK-LABEL: @test_mm256_mask_cvt_roundps_epu32
 939 // CHECK: @llvm.x86.avx10.mask.vcvtps2udq256
 940   return _mm256_mask_cvt_roundps_epu32(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 941 }
 942
 943 __m256i test_mm256_maskz_cvt_roundps_epu32(__mmask16 __U,__m256 __A)
 944 {
 945 // CHECK-LABEL: @test_mm256_maskz_cvt_roundps_epu32
 946 // CHECK: @llvm.x86.avx10.mask.vcvtps2udq256
 947   return _mm256_maskz_cvt_roundps_epu32(__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 948 }
 949
 950 __m256i test_mm256_cvt_roundps_epu64(__m128 __A) {
 951 // CHECK-LABEL: @test_mm256_cvt_roundps_epu64
 952 // CHECK: @llvm.x86.avx10.mask.vcvtps2uqq256
 953   return _mm256_cvt_roundps_epu64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 954 }
 955
 956 __m256i test_mm256_mask_cvt_roundps_epu64(__m256i __W, __mmask8 __U, __m128 __A) {
 957 // CHECK-LABEL: @test_mm256_mask_cvt_roundps_epu64
 958 // CHECK: @llvm.x86.avx10.mask.vcvtps2uqq256
 959   return _mm256_mask_cvt_roundps_epu64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 960 }
 961
 962 __m256i test_mm256_maskz_cvt_roundps_epu64(__mmask8 __U, __m128 __A) {
 963 // CHECK-LABEL: @test_mm256_maskz_cvt_roundps_epu64
 964 // CHECK: @llvm.x86.avx10.mask.vcvtps2uqq256
 965   return _mm256_maskz_cvt_roundps_epu64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 966 }
 967
 968 __m256d test__mm256_cvt_roundepi64_pd(__m256i __A) {
 969 // CHECK-LABEL: @test__mm256_cvt_roundepi64_pd
 970 // CHECK: @llvm.x86.avx512.sitofp.round.v4f64.v4i64
 971   return _mm256_cvt_roundepi64_pd(__A, _MM_FROUND_NO_EXC);
 972 }
 973
 974 __m256d test__mm256_mask_cvt_roundepi64_pd(__m256d __W, __mmask8 __U, __m256i __A) {
 975 // CHECK-LABEL: @test__mm256_mask_cvt_roundepi64_pd
 976 // CHECK: @llvm.x86.avx512.sitofp.round.v4f64.v4i64
 977   return _mm256_mask_cvt_roundepi64_pd(__W, __U, __A, _MM_FROUND_NO_EXC);
 978 }
 979
 980 __m256d test__mm256_maskz_cvt_roundepi64_pd(__mmask8 __U, __m256i __A) {
 981 // CHECK-LABEL: @test__mm256_maskz_cvt_roundepi64_pd
 982 // CHECK: @llvm.x86.avx512.sitofp.round.v4f64.v4i64
 983   return _mm256_maskz_cvt_roundepi64_pd(__U, __A, _MM_FROUND_NO_EXC);
 984 }
 985
 986 // FIXME: We may change to @llvm.x86.avx10.mask.vcvtqq2ph256 in future.
 987 __m128h test_mm256_cvt_roundepi64_ph(__m256i A) {
 988 // CHECK-LABEL: test_mm256_cvt_roundepi64_ph
 989 // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v4i64
 990   return _mm256_cvt_roundepi64_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 991 }
 992
 993 __m128h test_mm256_mask_cvt_roundepi64_ph(__m128h A, __mmask8 B, __m256i C) {
 994 // CHECK-LABEL: test_mm256_mask_cvt_roundepi64_ph
 995 // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v4i64
 996   return _mm256_mask_cvt_roundepi64_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 997 }
 998
 999 __m128h test_mm256_maskz_cvt_roundepi64_ph(__mmask8 A, __m256i B) {
1000 // CHECK-LABEL: test_mm256_maskz_cvt_roundepi64_ph
1001 // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v4i64
1002   return _mm256_maskz_cvt_roundepi64_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1003 }
1004
1005 __m128 test_mm256_cvt_roundepi64_ps(__m256i __A) {
1006 // CHECK-LABEL: @test_mm256_cvt_roundepi64_ps
1007 // CHECK: @llvm.x86.avx512.sitofp.round.v4f32.v4i64
1008   return _mm256_cvt_roundepi64_ps(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1009 }
1010
1011 __m128 test_mm256_mask_cvt_roundepi64_ps(__m128 __W, __mmask8 __U, __m256i __A) {
1012 // CHECK-LABEL: @test_mm256_mask_cvt_roundepi64_ps
1013 // CHECK: @llvm.x86.avx512.sitofp.round.v4f32.v4i64
1014 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
1015   return _mm256_mask_cvt_roundepi64_ps(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1016 }
1017
1018 __m128 test_mm256_maskz_cvt_roundepi64_ps(__mmask8 __U, __m256i __A) {
1019 // CHECK-LABEL: @test_mm256_maskz_cvt_roundepi64_ps
1020 // CHECK: @llvm.x86.avx512.sitofp.round.v4f32.v4i64
1021 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
1022   return _mm256_maskz_cvt_roundepi64_ps(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1023 }
1024
1025 __m128i test_mm256_cvtt_roundpd_epi32(__m256d A)
1026 {
1027 // CHECK-LABEL: @test_mm256_cvtt_roundpd_epi32
1028 // CHECK: @llvm.x86.avx10.mask.vcvttpd2dq256
1029   return _mm256_cvtt_roundpd_epi32(A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1030 }
1031
1032 __m128i test_mm256_mask_cvtt_roundpd_epi32(__m128i W,__mmask8 U,__m256d A)
1033 {
1034 // CHECK-LABEL: @test_mm256_mask_cvtt_roundpd_epi32
1035 // CHECK: @llvm.x86.avx10.mask.vcvttpd2dq256
1036   return _mm256_mask_cvtt_roundpd_epi32(W, U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1037 }
1038
1039 __m128i test_mm256_maskz_cvtt_roundpd_epi32(__mmask8 U, __m256d A)
1040 {
1041 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundpd_epi32
1042 // CHECK: @llvm.x86.avx10.mask.vcvttpd2dq256
1043   return _mm256_maskz_cvtt_roundpd_epi32(U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1044 }
1045
1046 __m256i test_mm256_cvtt_roundpd_epi64(__m256d __A) {
1047 // CHECK-LABEL: @test_mm256_cvtt_roundpd_epi64
1048 // CHECK: @llvm.x86.avx10.mask.vcvttpd2qq256
1049   return _mm256_cvtt_roundpd_epi64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1050 }
1051
1052 __m256i test_mm256_mask_cvtt_roundpd_epi64(__m256i __W, __mmask8 __U, __m256d __A) {
1053 // CHECK-LABEL: @test_mm256_mask_cvtt_roundpd_epi64
1054 // CHECK: @llvm.x86.avx10.mask.vcvttpd2qq256
1055   return _mm256_mask_cvtt_roundpd_epi64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1056 }
1057
1058 __m256i test_mm256_maskz_cvtt_roundpd_epi64(__mmask8 __U, __m256d __A) {
1059 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundpd_epi64
1060 // CHECK: @llvm.x86.avx10.mask.vcvttpd2qq256
1061   return _mm256_maskz_cvtt_roundpd_epi64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1062 }
1063
1064 __m128i test_mm256_cvtt_roundpd_epu32(__m256d A)
1065 {
1066 // CHECK-LABEL: @test_mm256_cvtt_roundpd_epu32
1067 // CHECK: @llvm.x86.avx10.mask.vcvttpd2udq256
1068   return _mm256_cvtt_roundpd_epu32(A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1069 }
1070
1071 __m128i test_mm256_mask_cvtt_roundpd_epu32(__m128i W,__mmask8 U,__m256d A)
1072 {
1073 // CHECK-LABEL: @test_mm256_mask_cvtt_roundpd_epu32
1074 // CHECK: @llvm.x86.avx10.mask.vcvttpd2udq256
1075   return _mm256_mask_cvtt_roundpd_epu32(W, U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1076 }
1077
1078 __m128i test_mm256_maskz_cvtt_roundpd_epu32(__mmask8 U, __m256d A)
1079 {
1080 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundpd_epu32
1081 // CHECK: @llvm.x86.avx10.mask.vcvttpd2udq256
1082   return _mm256_maskz_cvtt_roundpd_epu32(U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1083 }
1084
1085 __m256i test_mm256_cvtt_roundpd_epu64(__m256d __A) {
1086 // CHECK-LABEL: @test_mm256_cvtt_roundpd_epu64
1087 // CHECK: @llvm.x86.avx10.mask.vcvttpd2uqq256
1088   return _mm256_cvtt_roundpd_epu64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1089 }
1090
1091 __m256i test_mm256_mask_cvtt_roundpd_epu64(__m256i __W, __mmask8 __U, __m256d __A) {
1092 // CHECK-LABEL: @test_mm256_mask_cvtt_roundpd_epu64
1093 // CHECK: @llvm.x86.avx10.mask.vcvttpd2uqq256
1094   return _mm256_mask_cvtt_roundpd_epu64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1095 }
1096
1097 __m256i test_mm256_maskz_cvtt_roundpd_epu64(__mmask8 __U, __m256d __A) {
1098 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundpd_epu64
1099 // CHECK: @llvm.x86.avx10.mask.vcvttpd2uqq256
1100   return _mm256_maskz_cvtt_roundpd_epu64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1101 }
1102
1103 __m256i test_mm256_cvtt_roundph_epi32(__m128h A) {
1104 // CHECK-LABEL: test_mm256_cvtt_roundph_epi32
1105 // CHECK: @llvm.x86.avx10.mask.vcvttph2dq256
1106   return _mm256_cvtt_roundph_epi32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1107 }
1108
1109 __m256i test_mm256_mask_cvtt_roundph_epi32(__m256i A, __mmask16 B, __m128h C) {
1110 // CHECK-LABEL: test_mm256_mask_cvtt_roundph_epi32
1111 // CHECK: @llvm.x86.avx10.mask.vcvttph2dq256
1112   return _mm256_mask_cvtt_roundph_epi32(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1113 }
1114
1115 __m256i test_mm256_maskz_cvtt_roundph_epi32(__mmask16 A, __m128h B) {
1116 // CHECK-LABEL: test_mm256_maskz_cvtt_roundph_epi32
1117 // CHECK: @llvm.x86.avx10.mask.vcvttph2dq256
1118   return _mm256_maskz_cvtt_roundph_epi32(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1119 }
1120
1121 __m256i test_mm256_cvtt_roundph_epi64(__m128h A) {
1122 // CHECK-LABEL: test_mm256_cvtt_roundph_epi64
1123 // CHECK: @llvm.x86.avx10.mask.vcvttph2qq256
1124   return _mm256_cvtt_roundph_epi64(A, _MM_FROUND_NO_EXC);
1125 }
1126
1127 __m256i test_mm256_mask_cvtt_roundph_epi64(__m256i A, __mmask8 B, __m128h C) {
1128 // CHECK-LABEL: test_mm256_mask_cvtt_roundph_epi64
1129 // CHECK: @llvm.x86.avx10.mask.vcvttph2qq256
1130   return _mm256_mask_cvtt_roundph_epi64(A, B, C, _MM_FROUND_NO_EXC);
1131 }
1132
1133 __m256i test_mm256_maskz_cvtt_roundph_epi64(__mmask8 A, __m128h B) {
1134 // CHECK-LABEL: test_mm256_maskz_cvtt_roundph_epi64
1135 // CHECK: @llvm.x86.avx10.mask.vcvttph2qq256
1136   return _mm256_maskz_cvtt_roundph_epi64(A, B, _MM_FROUND_NO_EXC);
1137 }
1138
1139 __m256i test_mm256_cvtt_roundph_epu32(__m128h A) {
1140 // CHECK-LABEL: test_mm256_cvtt_roundph_epu32
1141 // CHECK: @llvm.x86.avx10.mask.vcvttph2udq256
1142   return _mm256_cvtt_roundph_epu32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1143 }
1144
1145 __m256i test_mm256_mask_cvtt_roundph_epu32(__m256i A, __mmask16 B, __m128h C) {
1146 // CHECK-LABEL: test_mm256_mask_cvtt_roundph_epu32
1147 // CHECK: @llvm.x86.avx10.mask.vcvttph2udq256
1148   return _mm256_mask_cvtt_roundph_epu32(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1149 }
1150
1151 __m256i test_mm256_maskz_cvtt_roundph_epu32(__mmask16 A, __m128h B) {
1152 // CHECK-LABEL: test_mm256_maskz_cvtt_roundph_epu32
1153 // CHECK: @llvm.x86.avx10.mask.vcvttph2udq256
1154   return _mm256_maskz_cvtt_roundph_epu32(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1155 }
1156
1157 __m256i test_mm256_cvtt_roundph_epu64(__m128h A) {
1158 // CHECK-LABEL: test_mm256_cvtt_roundph_epu64
1159 // CHECK: @llvm.x86.avx10.mask.vcvttph2uqq256
1160   return _mm256_cvtt_roundph_epu64(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1161 }
1162
1163 __m256i test_mm256_mask_cvtt_roundph_epu64(__m256i A, __mmask8 B, __m128h C) {
1164 // CHECK-LABEL: test_mm256_mask_cvtt_roundph_epu64
1165 // CHECK: @llvm.x86.avx10.mask.vcvttph2uqq256
1166   return _mm256_mask_cvtt_roundph_epu64(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1167 }
1168
1169 __m256i test_mm256_maskz_cvtt_roundph_epu64(__mmask8 A, __m128h B) {
1170 // CHECK-LABEL: test_mm256_maskz_cvtt_roundph_epu64
1171 // CHECK: @llvm.x86.avx10.mask.vcvttph2uqq256
1172   return _mm256_maskz_cvtt_roundph_epu64(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1173 }
1174
1175 __m256i test_mm256_cvtt_roundph_epu16(__m256h A) {
1176 // CHECK-LABEL: test_mm256_cvtt_roundph_epu16
1177 // CHECK: @llvm.x86.avx10.mask.vcvttph2uw256
1178   return _mm256_cvtt_roundph_epu16(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1179 }
1180
1181 __m256i test_mm256_mask_cvtt_roundph_epu16(__m256i A, __mmask32 B, __m256h C) {
1182 // CHECK-LABEL: test_mm256_mask_cvtt_roundph_epu16
1183 // CHECK: @llvm.x86.avx10.mask.vcvttph2uw256
1184   return _mm256_mask_cvtt_roundph_epu16(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1185 }
1186
1187 __m256i test_mm256_maskz_cvtt_roundph_epu16(__mmask32 A, __m256h B) {
1188 // CHECK-LABEL: test_mm256_maskz_cvtt_roundph_epu16
1189 // CHECK: @llvm.x86.avx10.mask.vcvttph2uw256
1190   return _mm256_maskz_cvtt_roundph_epu16(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1191 }
1192
1193 __m256i test_mm256_cvtt_roundph_epi16(__m256h A) {
1194 // CHECK-LABEL: test_mm256_cvtt_roundph_epi16
1195 // CHECK: @llvm.x86.avx10.mask.vcvttph2w256
1196   return _mm256_cvtt_roundph_epi16(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1197 }
1198
1199 __m256i test_mm256_mask_cvtt_roundph_epi16(__m256i A, __mmask32 B, __m256h C) {
1200 // CHECK-LABEL: test_mm256_mask_cvtt_roundph_epi16
1201 // CHECK: @llvm.x86.avx10.mask.vcvttph2w256
1202   return _mm256_mask_cvtt_roundph_epi16(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1203 }
1204
1205 __m256i test_mm256_maskz_cvtt_roundph_epi16(__mmask32 A, __m256h B) {
1206 // CHECK-LABEL: test_mm256_maskz_cvtt_roundph_epi16
1207 // CHECK: @llvm.x86.avx10.mask.vcvttph2w256
1208   return _mm256_maskz_cvtt_roundph_epi16(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1209 }
1210
1211 __m256i test_mm256_cvtt_roundps_epi32(__m256 __A)
1212 {
1213 // CHECK-LABEL: @test_mm256_cvtt_roundps_epi32
1214 // CHECK: @llvm.x86.avx10.mask.vcvttps2dq256
1215   return _mm256_cvtt_roundps_epi32(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1216 }
1217
1218 __m256i test_mm256_mask_cvtt_roundps_epi32(__m256i __W,__mmask16 __U,__m256 __A)
1219 {
1220 // CHECK-LABEL: @test_mm256_mask_cvtt_roundps_epi32
1221 // CHECK: @llvm.x86.avx10.mask.vcvttps2dq256
1222   return _mm256_mask_cvtt_roundps_epi32(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1223 }
1224
1225 __m256i test_mm256_maskz_cvtt_roundps_epi32(__mmask16 __U, __m256 __A)
1226 {
1227 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundps_epi32
1228 // CHECK: @llvm.x86.avx10.mask.vcvttps2dq256
1229   return _mm256_maskz_cvtt_roundps_epi32(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1230 }
1231
1232 __m256i test_mm256_cvtt_roundps_epi64(__m128 __A) {
1233 // CHECK-LABEL: @test_mm256_cvtt_roundps_epi64
1234 // CHECK: @llvm.x86.avx10.mask.vcvttps2qq256
1235   return _mm256_cvtt_roundps_epi64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1236 }
1237
1238 __m256i test_mm256_mask_cvtt_roundps_epi64(__m256i __W, __mmask8 __U, __m128 __A) {
1239 // CHECK-LABEL: @test_mm256_mask_cvtt_roundps_epi64
1240 // CHECK: @llvm.x86.avx10.mask.vcvttps2qq256
1241   return _mm256_mask_cvtt_roundps_epi64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1242 }
1243
1244 __m256i test_mm256_maskz_cvtt_roundps_epi64(__mmask8 __U, __m128 __A) {
1245 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundps_epi64
1246 // CHECK: @llvm.x86.avx10.mask.vcvttps2qq256
1247   return _mm256_maskz_cvtt_roundps_epi64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1248 }
1249
1250 __m256i test_mm256_cvtt_roundps_epu32(__m256 __A)
1251 {
1252 // CHECK-LABEL: @test_mm256_cvtt_roundps_epu32
1253 // CHECK: @llvm.x86.avx10.mask.vcvttps2udq256
1254   return _mm256_cvtt_roundps_epu32(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1255 }
1256
1257 __m256i test_mm256_mask_cvtt_roundps_epu32(__m256i __W,__mmask16 __U,__m256 __A)
1258 {
1259 // CHECK-LABEL: @test_mm256_mask_cvtt_roundps_epu32
1260 // CHECK: @llvm.x86.avx10.mask.vcvttps2udq256
1261   return _mm256_mask_cvtt_roundps_epu32(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1262 }
1263
1264 __m256i test_mm256_maskz_cvtt_roundps_epu32(__mmask16 __U,__m256 __A)
1265 {
1266 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundps_epu32
1267 // CHECK: @llvm.x86.avx10.mask.vcvttps2udq256
1268   return _mm256_maskz_cvtt_roundps_epu32(__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1269 }
1270
1271 __m256i test_mm256_cvtt_roundps_epu64(__m128 __A) {
1272 // CHECK-LABEL: @test_mm256_cvtt_roundps_epu64
1273 // CHECK: @llvm.x86.avx10.mask.vcvttps2uqq256
1274   return _mm256_cvtt_roundps_epu64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1275 }
1276
1277 __m256i test_mm256_mask_cvtt_roundps_epu64(__m256i __W, __mmask8 __U, __m128 __A) {
1278 // CHECK-LABEL: @test_mm256_mask_cvtt_roundps_epu64
1279 // CHECK: @llvm.x86.avx10.mask.vcvttps2uqq256
1280   return _mm256_mask_cvtt_roundps_epu64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1281 }
1282
1283 __m256i test_mm256_maskz_cvtt_roundps_epu64(__mmask8 __U, __m128 __A) {
1284 // CHECK-LABEL: @test_mm256_maskz_cvtt_roundps_epu64
1285 // CHECK: @llvm.x86.avx10.mask.vcvttps2uqq256
1286   return _mm256_maskz_cvtt_roundps_epu64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1287 }
1288
1289 __m128h test_mm256_cvt_roundepu32_ph(__m256i A) {
1290 // CHECK-LABEL: test_mm256_cvt_roundepu32_ph
1291 // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v8i32(<8 x i32> %{{.*}}, i32 11)
1292   return _mm256_cvt_roundepu32_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1293 }
1294
1295 __m128h test_mm256_mask_cvt_roundepu32_ph(__m128h A, __mmask8 B, __m256i C) {
1296 // CHECK-LABEL: test_mm256_mask_cvt_roundepu32_ph
1297 // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v8i32(<8 x i32> %{{.*}}, i32 10)
1298 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
1299   return _mm256_mask_cvt_roundepu32_ph(A, B, C, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
1300 }
1301
1302 __m128h test_mm256_maskz_cvt_roundepu32_ph(__mmask8 A, __m256i B) {
1303 // CHECK-LABEL: test_mm256_maskz_cvt_roundepu32_ph
1304 // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v8i32(<8 x i32> %{{.*}}, i32 9)
1305 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
1306   return _mm256_maskz_cvt_roundepu32_ph(A, B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
1307 }
1308
1309 __m256 test_mm256_cvt_roundepu32_ps(__m256i __A)
1310 {
1311 // CHECK-LABEL: @test_mm256_cvt_roundepu32_ps
1312 // CHECK: @llvm.x86.avx512.uitofp.round.v8f32.v8i32
1313   return _mm256_cvt_roundepu32_ps(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1314 }
1315
1316 __m256 test_mm256_mask_cvt_roundepu32_ps(__m256 __W, __mmask8 __U, __m256i __A)
1317 {
1318 // CHECK-LABEL: @test_mm256_mask_cvt_roundepu32_ps
1319 // CHECK: @llvm.x86.avx512.uitofp.round.v8f32.v8i32
1320 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1321   return _mm256_mask_cvt_roundepu32_ps(__W, __U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1322 }
1323
1324 __m256 test_mm256_maskz_cvt_roundepu32_ps(__mmask8 __U, __m256i __A)
1325 {
1326 // CHECK-LABEL: @test_mm256_maskz_cvt_roundepu32_ps
1327 // CHECK: @llvm.x86.avx512.uitofp.round.v8f32.v8i32
1328 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1329   return _mm256_maskz_cvt_roundepu32_ps(__U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1330 }
1331
1332 __m256d test__mm256_cvt_roundepu64_pd(__m256i __A) {
1333 // CHECK-LABEL: @test__mm256_cvt_roundepu64_pd
1334 // CHECK: @llvm.x86.avx512.uitofp.round.v4f64.v4i64
1335   return _mm256_cvt_roundepu64_pd(__A, _MM_FROUND_NO_EXC);
1336 }
1337
1338 __m256d test__mm256_mask_cvt_roundepu64_pd(__m256d __W, __mmask8 __U, __m256i __A) {
1339 // CHECK-LABEL: @test__mm256_mask_cvt_roundepu64_pd
1340 // CHECK: @llvm.x86.avx512.uitofp.round.v4f64.v4i64
1341   return _mm256_mask_cvt_roundepu64_pd(__W, __U, __A, _MM_FROUND_NO_EXC);
1342 }
1343
1344 __m256d test__mm256_maskz_cvt_roundepu64_pd(__mmask8 __U, __m256i __A) {
1345 // CHECK-LABEL: @test__mm256_maskz_cvt_roundepu64_pd
1346 // CHECK: @llvm.x86.avx512.uitofp.round.v4f64.v4i64
1347   return _mm256_maskz_cvt_roundepu64_pd(__U, __A, _MM_FROUND_NO_EXC);
1348 }
1349
1350 // FIXME: We may change to @llvm.x86.avx10.mask.vcvtuqq2ph256 in future.
1351 __m128h test_mm256_cvt_roundepu64_ph(__m256i A) {
1352 // CHECK-LABEL: test_mm256_cvt_roundepu64_ph
1353 // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v4i64
1354   return _mm256_cvt_roundepu64_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1355 }
1356
1357 __m128h test_mm256_mask_cvt_roundepu64_ph(__m128h A, __mmask8 B, __m256i C) {
1358 // CHECK-LABEL: test_mm256_mask_cvt_roundepu64_ph
1359 // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v4i64
1360   return _mm256_mask_cvt_roundepu64_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1361 }
1362
1363 __m128h test_mm256_maskz_cvt_roundepu64_ph(__mmask8 A, __m256i B) {
1364 // CHECK-LABEL: test_mm256_maskz_cvt_roundepu64_ph
1365 // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v4i64
1366   return _mm256_maskz_cvt_roundepu64_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1367 }
1368
1369 __m128 test_mm256_cvt_roundepu64_ps(__m256i __A) {
1370 // CHECK-LABEL: @test_mm256_cvt_roundepu64_ps
1371 // CHECK: @llvm.x86.avx512.uitofp.round.v4f32.v4i64
1372   return _mm256_cvt_roundepu64_ps(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1373 }
1374
1375 __m128 test_mm256_mask_cvt_roundepu64_ps(__m128 __W, __mmask8 __U, __m256i __A) {
1376 // CHECK-LABEL: @test_mm256_mask_cvt_roundepu64_ps
1377 // CHECK: @llvm.x86.avx512.uitofp.round.v4f32.v4i64
1378 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
1379   return _mm256_mask_cvt_roundepu64_ps(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1380 }
1381
1382 __m128 test_mm256_maskz_cvt_roundepu64_ps(__mmask8 __U, __m256i __A) {
1383 // CHECK-LABEL: @test_mm256_maskz_cvt_roundepu64_ps
1384 // CHECK: @llvm.x86.avx512.uitofp.round.v4f32.v4i64
1385 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
1386   return _mm256_maskz_cvt_roundepu64_ps(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
1387 }
1388
1389 __m256h test_mm256_cvt_roundepi16_ph(__m256i A) {
1390 // CHECK-LABEL: test_mm256_cvt_roundepi16_ph
1391 // CHECK:   @llvm.x86.avx512.sitofp.round.v16f16.v16i16
1392   return _mm256_cvt_roundepi16_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1393 }
1394
1395 __m256h test_mm256_mask_cvt_roundepi16_ph(__m256h A, __mmask16 B, __m256i C) {
1396 // CHECK-LABEL: test_mm256_mask_cvt_roundepi16_ph
1397 // CHECK: @llvm.x86.avx512.sitofp.round.v16f16.v16i16
1398   return _mm256_mask_cvt_roundepi16_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1399 }
1400
1401 __m256h test_mm256_maskz_cvt_roundepi16_ph(__mmask16 A, __m256i B) {
1402 // CHECK-LABEL: test_mm256_maskz_cvt_roundepi16_ph
1403 // CHECK: @llvm.x86.avx512.sitofp.round.v16f16.v16i16
1404   return _mm256_maskz_cvt_roundepi16_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1405 }
1406
1407 __m256h test_mm256_cvt_roundepu16_ph(__m256i A) {
1408 // CHECK-LABEL: test_mm256_cvt_roundepu16_ph
1409 // CHECK: @llvm.x86.avx512.uitofp.round.v16f16.v16i16
1410   return _mm256_cvt_roundepu16_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1411 }
1412
1413 __m256h test_mm256_mask_cvt_roundepu16_ph(__m256h A, __mmask16 B, __m256i C) {
1414 // CHECK-LABEL: test_mm256_mask_cvt_roundepu16_ph
1415 // CHECK: @llvm.x86.avx512.uitofp.round.v16f16.v16i16
1416   return _mm256_mask_cvt_roundepu16_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1417 }
1418
1419 __m256h test_mm256_maskz_cvt_roundepu16_ph(__mmask16 A, __m256i B) {
1420 // CHECK-LABEL: test_mm256_maskz_cvt_roundepu16_ph
1421 // CHECK: @llvm.x86.avx512.uitofp.round.v16f16.v16i16
1422   return _mm256_maskz_cvt_roundepu16_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1423 }
1424
1425 __m256d test_mm256_div_round_pd(__m256d __A, __m256d __B) {
1426 // CHECK-LABEL: @test_mm256_div_round_pd
1427 // CHECK: @llvm.x86.avx10.vdivpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 11)
1428   return _mm256_div_round_pd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1429 }
1430
1431 __m256d test_mm256_mask_div_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
1432 // CHECK-LABEL: @test_mm256_mask_div_round_pd
1433 // CHECK: @llvm.x86.avx10.vdivpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 10)
1434 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1435   return _mm256_mask_div_round_pd(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
1436 }
1437
1438 __m256d test_mm256_maskz_div_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
1439 // CHECK-LABEL: @test_mm256_maskz_div_round_pd
1440 // CHECK: @llvm.x86.avx10.vdivpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 9)
1441 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1442   return _mm256_maskz_div_round_pd(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
1443 }
1444
1445 __m256h test_mm256_div_round_ph(__m256h __A, __m256h __B) {
1446 // CHECK-LABEL: @test_mm256_div_round_ph
1447 // CHECK: @llvm.x86.avx10.vdivph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 11)
1448   return _mm256_div_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1449 }
1450
1451 __m256h test_mm256_mask_div_round_ph(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
1452 // CHECK-LABEL: @test_mm256_mask_div_round_ph
1453 // CHECK: @llvm.x86.avx10.vdivph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 10)
1454 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1455   return _mm256_mask_div_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
1456 }
1457
1458 __m256h test_mm256_maskz_div_round_ph(__mmask8 __U, __m256h __A, __m256h __B) {
1459 // CHECK-LABEL: @test_mm256_maskz_div_round_ph
1460 // CHECK: @llvm.x86.avx10.vdivph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 9)
1461 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1462   return _mm256_maskz_div_round_ph(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
1463 }
1464
1465 __m256 test_mm256_div_round_ps(__m256 __A, __m256 __B) {
1466 // CHECK-LABEL: @test_mm256_div_round_ps
1467 // CHECK: @llvm.x86.avx10.vdivps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 11)
1468   return _mm256_div_round_ps(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1469 }
1470
1471 __m256 test_mm256_mask_div_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
1472 // CHECK-LABEL: @test_mm256_mask_div_round_ps
1473 // CHECK: @llvm.x86.avx10.vdivps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 10)
1474 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1475   return _mm256_mask_div_round_ps(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
1476 }
1477
1478 __m256 test_mm256_maskz_div_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
1479 // CHECK-LABEL: @test_mm256_maskz_div_round_ps
1480 // CHECK: @llvm.x86.avx10.vdivps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 9)
1481 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1482   return _mm256_maskz_div_round_ps(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
1483 }
1484
1485 __m256h test_mm256_fcmadd_round_pch(__m256h __A, __m256h __B, __m256h __C) {
1486 // CHECK-LABEL: @test_mm256_fcmadd_round_pch
1487 // CHECK: @llvm.x86.avx10.mask.vfcmaddcph256
1488   return _mm256_fcmadd_round_pch(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1489 }
1490
1491 __m256h test_mm256_mask_fcmadd_round_pch(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
1492 // CHECK-LABEL: @test_mm256_mask_fcmadd_round_pch
1493 // CHECK: @llvm.x86.avx10.mask.vfcmaddcph256
1494 // CHECK:  %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1495   return _mm256_mask_fcmadd_round_pch(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1496 }
1497
1498 __m256h test_mm256_mask3_fcmadd_round_pch(__m256h __A, __m256h __B, __m256h __C, __mmask8 __U) {
1499 // CHECK-LABEL: @test_mm256_mask3_fcmadd_round_pch
1500 // CHECK: @llvm.x86.avx10.mask.vfcmaddcph256
1501 // CHECK-NOT:  %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1502   return _mm256_mask3_fcmadd_round_pch(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1503 }
1504
1505 __m256h test_mm256_maskz_fcmadd_round_pch(__mmask8 __U, __m256h __A, __m256h __B, __m256h __C) {
1506 // CHECK-LABEL: @test_mm256_maskz_fcmadd_round_pch
1507 // CHECK: @llvm.x86.avx10.maskz.vfcmaddcph256
1508   return _mm256_maskz_fcmadd_round_pch(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1509 }
1510
1511 __m256h test_mm256_cmul_round_pch(__m256h __A, __m256h __B) {
1512 // CHECK-LABEL: @test_mm256_cmul_round_pch
1513 // CHECK: @llvm.x86.avx10.mask.vfcmulcph256
1514   return _mm256_cmul_round_pch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1515 }
1516
1517 __m256h test_mm256_mask_cmul_round_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
1518 // CHECK-LABEL: @test_mm256_mask_cmul_round_pch
1519 // CHECK: @llvm.x86.avx10.mask.vfcmulcph256
1520   return _mm256_mask_cmul_round_pch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1521 }
1522
1523 __m256h test_mm256_maskz_cmul_round_pch(__mmask8 __U, __m256h __A, __m256h __B) {
1524 // CHECK-LABEL: @test_mm256_maskz_cmul_round_pch
1525 // CHECK: @llvm.x86.avx10.mask.vfcmulcph256
1526   return _mm256_maskz_cmul_round_pch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1527 }
1528
1529 __m256d test_mm256_fixupimm_round_pd(__m256d __A, __m256d __B, __m256i __C) {
1530 // CHECK-LABEL: @test_mm256_fixupimm_round_pd
1531 // CHECK: @llvm.x86.avx10.mask.vfixupimmpd256
1532   return _mm256_fixupimm_round_pd(__A, __B, __C, 5, 8);
1533 }
1534
1535 __m256d test_mm256_mask_fixupimm_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256i __C) {
1536 // CHECK-LABEL: @test_mm256_mask_fixupimm_round_pd
1537 // CHECK: @llvm.x86.avx10.mask.vfixupimmpd256
1538   return _mm256_mask_fixupimm_round_pd(__A, __U, __B, __C, 5, 8);
1539 }
1540
1541 __m256d test_mm256_maskz_fixupimm_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256i __C) {
1542 // CHECK-LABEL: @test_mm256_maskz_fixupimm_round_pd
1543 // CHECK: @llvm.x86.avx10.maskz.vfixupimmpd256
1544   return _mm256_maskz_fixupimm_round_pd(__U, __A, __B, __C, 5, 8);
1545 }
1546
1547 __m256 test_mm256_fixupimm_round_ps(__m256 __A, __m256 __B, __m256i __C) {
1548 // CHECK-LABEL: @test_mm256_fixupimm_round_ps
1549 // CHECK: @llvm.x86.avx10.mask.vfixupimmps256
1550   return _mm256_fixupimm_round_ps(__A, __B, __C, 5, 8);
1551 }
1552
1553 __m256 test_mm256_mask_fixupimm_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256i __C) {
1554 // CHECK-LABEL: @test_mm256_mask_fixupimm_round_ps
1555 // CHECK: @llvm.x86.avx10.mask.vfixupimmps256
1556   return _mm256_mask_fixupimm_round_ps(__A, __U, __B, __C, 5, 8);
1557 }
1558
1559 __m256 test_mm256_maskz_fixupimm_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256i __C) {
1560 // CHECK-LABEL: @test_mm256_maskz_fixupimm_round_ps
1561 // CHECK: @llvm.x86.avx10.maskz.vfixupimmps256
1562   return _mm256_maskz_fixupimm_round_ps(__U, __A, __B, __C, 5, 8);
1563 }
1564
1565 __m256d test_mm256_fmadd_round_pd(__m256d __A, __m256d __B, __m256d __C) {
1566 // CHECK-LABEL: @test_mm256_fmadd_round_pd
1567 // CHECK: @llvm.x86.avx10.vfmaddpd256
1568   return _mm256_fmadd_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1569 }
1570
1571 __m256d test_mm256_mask_fmadd_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) {
1572 // CHECK-LABEL: @test_mm256_mask_fmadd_round_pd
1573 // CHECK: @llvm.x86.avx10.vfmaddpd256
1574 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1575 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1576   return _mm256_mask_fmadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1577 }
1578
1579 __m256d test_mm256_mask3_fmadd_round_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) {
1580 // CHECK-LABEL: @test_mm256_mask3_fmadd_round_pd
1581 // CHECK: @llvm.x86.avx10.vfmaddpd256
1582 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1583 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1584   return _mm256_mask3_fmadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1585 }
1586
1587 __m256d test_mm256_maskz_fmadd_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) {
1588 // CHECK-LABEL: @test_mm256_maskz_fmadd_round_pd
1589 // CHECK: @llvm.x86.avx10.vfmaddpd256
1590 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1591 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> zeroinitializer
1592   return _mm256_maskz_fmadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1593 }
1594
1595 __m256d test_mm256_fmsub_round_pd(__m256d __A, __m256d __B, __m256d __C) {
1596 // CHECK-LABEL: @test_mm256_fmsub_round_pd
1597 // CHECK: fneg <4 x double>
1598 // CHECK: @llvm.x86.avx10.vfmaddpd256
1599   return _mm256_fmsub_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1600 }
1601
1602 __m256d test_mm256_mask_fmsub_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) {
1603 // CHECK-LABEL: @test_mm256_mask_fmsub_round_pd
1604 // CHECK: fneg <4 x double>
1605 // CHECK: @llvm.x86.avx10.vfmaddpd256
1606 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1607 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1608   return _mm256_mask_fmsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1609 }
1610
1611 __m256d test_mm256_maskz_fmsub_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) {
1612 // CHECK-LABEL: @test_mm256_maskz_fmsub_round_pd
1613 // CHECK: fneg <4 x double>
1614 // CHECK: @llvm.x86.avx10.vfmaddpd256
1615 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1616 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> zeroinitializer
1617   return _mm256_maskz_fmsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1618 }
1619
1620 __m256d test_mm256_fnmadd_round_pd(__m256d __A, __m256d __B, __m256d __C) {
1621 // CHECK-LABEL: @test_mm256_fnmadd_round_pd
1622 // CHECK: fneg <4 x double>
1623 // CHECK: @llvm.x86.avx10.vfmaddpd256
1624   return _mm256_fnmadd_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1625 }
1626
1627 __m256d test_mm256_mask3_fnmadd_round_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) {
1628 // CHECK-LABEL: @test_mm256_mask3_fnmadd_round_pd
1629 // CHECK: fneg <4 x double>
1630 // CHECK: @llvm.x86.avx10.vfmaddpd256
1631 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1632 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1633   return _mm256_mask3_fnmadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1634 }
1635
1636 __m256d test_mm256_maskz_fnmadd_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) {
1637 // CHECK-LABEL: @test_mm256_maskz_fnmadd_round_pd
1638 // CHECK: fneg <4 x double>
1639 // CHECK: @llvm.x86.avx10.vfmaddpd256
1640 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1641 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> zeroinitializer
1642   return _mm256_maskz_fnmadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1643 }
1644
1645 __m256d test_mm256_fnmsub_round_pd(__m256d __A, __m256d __B, __m256d __C) {
1646 // CHECK-LABEL: @test_mm256_fnmsub_round_pd
1647 // CHECK: fneg <4 x double>
1648 // CHECK: fneg <4 x double>
1649 // CHECK: @llvm.x86.avx10.vfmaddpd256
1650   return _mm256_fnmsub_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1651 }
1652
1653 __m256d test_mm256_maskz_fnmsub_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) {
1654 // CHECK-LABEL: @test_mm256_maskz_fnmsub_round_pd
1655 // CHECK: fneg <4 x double>
1656 // CHECK: fneg <4 x double>
1657 // CHECK: @llvm.x86.avx10.vfmaddpd256
1658 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1659 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> zeroinitializer
1660   return _mm256_maskz_fnmsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1661 }
1662
1663 __m256h test_mm256_fmadd_round_ph(__m256h __A, __m256h __B, __m256h __C) {
1664 // CHECK-LABEL: @test_mm256_fmadd_round_ph
1665 // CHECK: @llvm.x86.avx10.vfmaddph256
1666   return _mm256_fmadd_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1667 }
1668
1669 __m256h test_mm256_mask_fmadd_round_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
1670 // CHECK-LABEL: @test_mm256_mask_fmadd_round_ph
1671 // CHECK: @llvm.x86.avx10.vfmaddph256
1672 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1673 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1674   return _mm256_mask_fmadd_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1675 }
1676
1677 __m256h test_mm256_mask3_fmadd_round_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
1678 // CHECK-LABEL: @test_mm256_mask3_fmadd_round_ph
1679 // CHECK: @llvm.x86.avx10.vfmaddph256
1680 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1681 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1682   return _mm256_mask3_fmadd_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1683 }
1684
1685 __m256h test_mm256_maskz_fmadd_round_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
1686 // CHECK-LABEL: @test_mm256_maskz_fmadd_round_ph
1687 // CHECK: @llvm.x86.avx10.vfmaddph256
1688 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1689 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> zeroinitializer
1690   return _mm256_maskz_fmadd_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1691 }
1692
1693 __m256h test_mm256_fmsub_round_ph(__m256h __A, __m256h __B, __m256h __C) {
1694 // CHECK-LABEL: @test_mm256_fmsub_round_ph
1695 // CHECK: fneg
1696 // CHECK: @llvm.x86.avx10.vfmaddph256
1697   return _mm256_fmsub_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1698 }
1699
1700 __m256h test_mm256_mask_fmsub_round_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
1701 // CHECK-LABEL: @test_mm256_mask_fmsub_round_ph
1702 // CHECK: fneg
1703 // CHECK: @llvm.x86.avx10.vfmaddph256
1704 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1705 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1706   return _mm256_mask_fmsub_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1707 }
1708
1709 __m256h test_mm256_maskz_fmsub_round_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
1710 // CHECK-LABEL: @test_mm256_maskz_fmsub_round_ph
1711 // CHECK: fneg
1712 // CHECK: @llvm.x86.avx10.vfmaddph256
1713 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1714 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> zeroinitializer
1715   return _mm256_maskz_fmsub_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1716 }
1717
1718 __m256h test_mm256_fnmadd_round_ph(__m256h __A, __m256h __B, __m256h __C) {
1719 // CHECK-LABEL: @test_mm256_fnmadd_round_ph
1720 // CHECK: fneg
1721 // CHECK: @llvm.x86.avx10.vfmaddph256
1722   return _mm256_fnmadd_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1723 }
1724
1725 __m256h test_mm256_mask3_fnmadd_round_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
1726 // CHECK-LABEL: @test_mm256_mask3_fnmadd_round_ph
1727 // CHECK: fneg
1728 // CHECK: @llvm.x86.avx10.vfmaddph256
1729 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1730 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1731   return _mm256_mask3_fnmadd_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1732 }
1733
1734 __m256h test_mm256_maskz_fnmadd_round_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
1735 // CHECK-LABEL: @test_mm256_maskz_fnmadd_round_ph
1736 // CHECK: fneg
1737 // CHECK: @llvm.x86.avx10.vfmaddph256
1738 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1739 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> zeroinitializer
1740   return _mm256_maskz_fnmadd_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1741 }
1742
1743 __m256h test_mm256_fnmsub_round_ph(__m256h __A, __m256h __B, __m256h __C) {
1744 // CHECK-LABEL: @test_mm256_fnmsub_round_ph
1745 // CHECK: fneg
1746 // CHECK: fneg
1747 // CHECK: @llvm.x86.avx10.vfmaddph256
1748   return _mm256_fnmsub_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1749 }
1750
1751 __m256h test_mm256_maskz_fnmsub_round_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
1752 // CHECK-LABEL: @test_mm256_maskz_fnmsub_round_ph
1753 // CHECK: fneg
1754 // CHECK: fneg
1755 // CHECK: @llvm.x86.avx10.vfmaddph256
1756 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1757 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> zeroinitializer
1758   return _mm256_maskz_fnmsub_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1759 }
1760
1761 __m256 test_mm256_fmadd_round_ps(__m256 __A, __m256 __B, __m256 __C) {
1762 // CHECK-LABEL: @test_mm256_fmadd_round_ps
1763 // CHECK: @llvm.x86.avx10.vfmaddps256
1764   return _mm256_fmadd_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1765 }
1766
1767 __m256 test_mm256_mask_fmadd_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) {
1768 // CHECK-LABEL: @test_mm256_mask_fmadd_round_ps
1769 // CHECK: @llvm.x86.avx10.vfmaddps256
1770 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1771 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1772   return _mm256_mask_fmadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1773 }
1774
1775 __m256 test_mm256_mask3_fmadd_round_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) {
1776 // CHECK-LABEL: @test_mm256_mask3_fmadd_round_ps
1777 // CHECK: @llvm.x86.avx10.vfmaddps256
1778 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1779 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1780   return _mm256_mask3_fmadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1781 }
1782
1783 __m256 test_mm256_maskz_fmadd_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) {
1784 // CHECK-LABEL: @test_mm256_maskz_fmadd_round_ps
1785 // CHECK: @llvm.x86.avx10.vfmaddps256
1786 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1787 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> zeroinitializer
1788   return _mm256_maskz_fmadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1789 }
1790
1791 __m256 test_mm256_fmsub_round_ps(__m256 __A, __m256 __B, __m256 __C) {
1792 // CHECK-LABEL: @test_mm256_fmsub_round_ps
1793 // CHECK: fneg <8 x float> %{{.*}}
1794 // CHECK: @llvm.x86.avx10.vfmaddps256
1795   return _mm256_fmsub_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1796 }
1797
1798 __m256 test_mm256_mask_fmsub_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) {
1799 // CHECK-LABEL: @test_mm256_mask_fmsub_round_ps
1800 // CHECK: fneg <8 x float> %{{.*}}
1801 // CHECK: @llvm.x86.avx10.vfmaddps256
1802 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1803 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1804   return _mm256_mask_fmsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1805 }
1806
1807 __m256 test_mm256_maskz_fmsub_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) {
1808 // CHECK-LABEL: @test_mm256_maskz_fmsub_round_ps
1809 // CHECK: fneg <8 x float> %{{.*}}
1810 // CHECK: @llvm.x86.avx10.vfmaddps256
1811 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1812 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> zeroinitializer
1813   return _mm256_maskz_fmsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1814 }
1815
1816 __m256 test_mm256_fnmadd_round_ps(__m256 __A, __m256 __B, __m256 __C) {
1817 // CHECK-LABEL: @test_mm256_fnmadd_round_ps
1818 // CHECK: fneg <8 x float> %{{.*}}
1819 // CHECK: @llvm.x86.avx10.vfmaddps256
1820   return _mm256_fnmadd_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1821 }
1822
1823 __m256 test_mm256_mask3_fnmadd_round_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) {
1824 // CHECK-LABEL: @test_mm256_mask3_fnmadd_round_ps
1825 // CHECK: fneg <8 x float> %{{.*}}
1826 // CHECK: @llvm.x86.avx10.vfmaddps256
1827 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1828 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1829   return _mm256_mask3_fnmadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1830 }
1831
1832 __m256 test_mm256_maskz_fnmadd_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) {
1833 // CHECK-LABEL: @test_mm256_maskz_fnmadd_round_ps
1834 // CHECK: fneg <8 x float> %{{.*}}
1835 // CHECK: @llvm.x86.avx10.vfmaddps256
1836 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1837 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> zeroinitializer
1838   return _mm256_maskz_fnmadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1839 }
1840
1841 __m256 test_mm256_fnmsub_round_ps(__m256 __A, __m256 __B, __m256 __C) {
1842 // CHECK-LABEL: @test_mm256_fnmsub_round_ps
1843 // CHECK: fneg <8 x float> %{{.*}}
1844 // CHECK: fneg <8 x float> %{{.*}}
1845 // CHECK: @llvm.x86.avx10.vfmaddps256
1846   return _mm256_fnmsub_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1847 }
1848
1849 __m256 test_mm256_maskz_fnmsub_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) {
1850 // CHECK-LABEL: @test_mm256_maskz_fnmsub_round_ps
1851 // CHECK: fneg <8 x float> %{{.*}}
1852 // CHECK: fneg <8 x float> %{{.*}}
1853 // CHECK: @llvm.x86.avx10.vfmaddps256
1854 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1855 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> zeroinitializer
1856   return _mm256_maskz_fnmsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1857 }
1858
1859 __m256h test_mm256_fmadd_round_pch(__m256h __A, __m256h __B, __m256h __C) {
1860 // CHECK-LABEL: @test_mm256_fmadd_round_pch
1861 // CHECK: @llvm.x86.avx10.mask.vfmaddcph256
1862   return _mm256_fmadd_round_pch(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1863 }
1864
1865 __m256h test_mm256_mask_fmadd_round_pch(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
1866 // CHECK-LABEL: @test_mm256_mask_fmadd_round_pch
1867 // CHECK: @llvm.x86.avx10.mask.vfmaddcph256
1868 // CHECK:  %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1869   return _mm256_mask_fmadd_round_pch(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1870 }
1871
1872 __m256h test_mm256_mask3_fmadd_round_pch(__m256h __A, __m256h __B, __m256h __C, __mmask8 __U) {
1873 // CHECK-LABEL: @test_mm256_mask3_fmadd_round_pch
1874 // CHECK: @llvm.x86.avx10.mask.vfmaddcph256
1875 // CHECK-NOT:  %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1876   return _mm256_mask3_fmadd_round_pch(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1877 }
1878
1879 __m256h test_mm256_maskz_fmadd_round_pch(__mmask8 __U, __m256h __A, __m256h __B, __m256h __C) {
1880 // CHECK-LABEL: @test_mm256_maskz_fmadd_round_pch
1881 // CHECK: @llvm.x86.avx10.maskz.vfmaddcph256
1882   return _mm256_maskz_fmadd_round_pch(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1883 }
1884
1885 __m256d test_mm256_fmaddsub_round_pd(__m256d __A, __m256d __B, __m256d __C) {
1886 // CHECK-LABEL: @test_mm256_fmaddsub_round_pd
1887 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1888   return _mm256_fmaddsub_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1889 }
1890
1891 __m256d test_mm256_mask_fmaddsub_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) {
1892 // CHECK-LABEL: @test_mm256_mask_fmaddsub_round_pd
1893 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1894 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1895 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1896   return _mm256_mask_fmaddsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1897 }
1898
1899 __m256d test_mm256_mask3_fmaddsub_round_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) {
1900 // CHECK-LABEL: @test_mm256_mask3_fmaddsub_round_pd
1901 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1902 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1903 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1904   return _mm256_mask3_fmaddsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1905 }
1906
1907 __m256d test_mm256_maskz_fmaddsub_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) {
1908 // CHECK-LABEL: @test_mm256_maskz_fmaddsub_round_pd
1909 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1910 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1911 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> zeroinitializer
1912   return _mm256_maskz_fmaddsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1913 }
1914
1915 __m256d test_mm256_fmsubadd_round_pd(__m256d __A, __m256d __B, __m256d __C) {
1916 // CHECK-LABEL: @test_mm256_fmsubadd_round_pd
1917 // CHECK: fneg <4 x double> %{{.*}}
1918 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1919   return _mm256_fmsubadd_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1920 }
1921
1922 __m256d test_mm256_mask_fmsubadd_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) {
1923 // CHECK-LABEL: @test_mm256_mask_fmsubadd_round_pd
1924 // CHECK: fneg <4 x double> %{{.*}}
1925 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1926 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1927 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1928   return _mm256_mask_fmsubadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1929 }
1930
1931 __m256d test_mm256_maskz_fmsubadd_round_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) {
1932 // CHECK-LABEL: @test_mm256_maskz_fmsubadd_round_pd
1933 // CHECK: fneg <4 x double> %{{.*}}
1934 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
1935 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
1936 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> zeroinitializer
1937   return _mm256_maskz_fmsubadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1938 }
1939
1940 __m256h test_mm256_fmaddsub_round_ph(__m256h __A, __m256h __B, __m256h __C) {
1941 // CHECK-LABEL: @test_mm256_fmaddsub_round_ph
1942 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1943   return _mm256_fmaddsub_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1944 }
1945
1946 __m256h test_mm256_mask_fmaddsub_round_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
1947 // CHECK-LABEL: @test_mm256_mask_fmaddsub_round_ph
1948 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1949 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1950 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1951   return _mm256_mask_fmaddsub_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1952 }
1953
1954 __m256h test_mm256_mask3_fmaddsub_round_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
1955 // CHECK-LABEL: @test_mm256_mask3_fmaddsub_round_ph
1956 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1957 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1958 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1959   return _mm256_mask3_fmaddsub_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1960 }
1961
1962 __m256h test_mm256_maskz_fmaddsub_round_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
1963 // CHECK-LABEL: @test_mm256_maskz_fmaddsub_round_ph
1964 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1965 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1966 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> zeroinitializer
1967   return _mm256_maskz_fmaddsub_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1968 }
1969
1970 __m256h test_mm256_fmsubadd_round_ph(__m256h __A, __m256h __B, __m256h __C) {
1971 // CHECK-LABEL: @test_mm256_fmsubadd_round_ph
1972 // CHECK: fneg
1973 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1974   return _mm256_fmsubadd_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1975 }
1976
1977 __m256h test_mm256_mask_fmsubadd_round_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
1978 // CHECK-LABEL: @test_mm256_mask_fmsubadd_round_ph
1979 // CHECK: fneg
1980 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1981 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1982 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1983   return _mm256_mask_fmsubadd_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1984 }
1985
1986 __m256h test_mm256_maskz_fmsubadd_round_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
1987 // CHECK-LABEL: @test_mm256_maskz_fmsubadd_round_ph
1988 // CHECK: fneg
1989 // CHECK: @llvm.x86.avx10.vfmaddsubph256
1990 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
1991 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> zeroinitializer
1992   return _mm256_maskz_fmsubadd_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1993 }
1994
1995 __m256 test_mm256_fmaddsub_round_ps(__m256 __A, __m256 __B, __m256 __C) {
1996 // CHECK-LABEL: @test_mm256_fmaddsub_round_ps
1997 // CHECK: @llvm.x86.avx10.vfmaddsubps256
1998   return _mm256_fmaddsub_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1999 }
2000
2001 __m256 test_mm256_mask_fmaddsub_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) {
2002 // CHECK-LABEL: @test_mm256_mask_fmaddsub_round_ps
2003 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2004 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2005 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2006   return _mm256_mask_fmaddsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2007 }
2008
2009 __m256 test_mm256_mask3_fmaddsub_round_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) {
2010 // CHECK-LABEL: @test_mm256_mask3_fmaddsub_round_ps
2011 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2012 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2013 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2014   return _mm256_mask3_fmaddsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2015 }
2016
2017 __m256 test_mm256_maskz_fmaddsub_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) {
2018 // CHECK-LABEL: @test_mm256_maskz_fmaddsub_round_ps
2019 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2020 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2021 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> zeroinitializer
2022   return _mm256_maskz_fmaddsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2023 }
2024
2025 __m256 test_mm256_fmsubadd_round_ps(__m256 __A, __m256 __B, __m256 __C) {
2026 // CHECK-LABEL: @test_mm256_fmsubadd_round_ps
2027 // CHECK: fneg <8 x float> %{{.*}}
2028 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2029   return _mm256_fmsubadd_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2030 }
2031
2032 __m256 test_mm256_mask_fmsubadd_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) {
2033 // CHECK-LABEL: @test_mm256_mask_fmsubadd_round_ps
2034 // CHECK: fneg <8 x float> %{{.*}}
2035 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2036 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2037 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2038   return _mm256_mask_fmsubadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2039 }
2040
2041 __m256 test_mm256_maskz_fmsubadd_round_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) {
2042 // CHECK-LABEL: @test_mm256_maskz_fmsubadd_round_ps
2043 // CHECK: fneg <8 x float> %{{.*}}
2044 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2045 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2046 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> zeroinitializer
2047   return _mm256_maskz_fmsubadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2048 }
2049
2050 __m256d test_mm256_mask3_fmsub_round_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) {
2051 // CHECK-LABEL: @test_mm256_mask3_fmsub_round_pd
2052 // CHECK: fneg <4 x double> %{{.*}}
2053 // CHECK: @llvm.x86.avx10.vfmaddpd256
2054 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2055 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2056   return _mm256_mask3_fmsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2057 }
2058
2059 __m256d test_mm256_mask3_fmsubadd_round_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) {
2060 // CHECK-LABEL: @test_mm256_mask3_fmsubadd_round_pd
2061 // CHECK: fneg <4 x double> %{{.*}}
2062 // CHECK: @llvm.x86.avx10.vfmaddsubpd256
2063 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2064 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2065   return _mm256_mask3_fmsubadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2066 }
2067
2068 __m256d test_mm256_mask_fnmadd_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) {
2069 // CHECK-LABEL: @test_mm256_mask_fnmadd_round_pd
2070 // CHECK: fneg <4 x double>
2071 // CHECK: @llvm.x86.avx10.vfmaddpd256
2072 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2073 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2074   return _mm256_mask_fnmadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2075 }
2076
2077 __m256d test_mm256_mask_fnmsub_round_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) {
2078 // CHECK-LABEL: @test_mm256_mask_fnmsub_round_pd
2079 // CHECK: fneg <4 x double>
2080 // CHECK: fneg <4 x double>
2081 // CHECK: @llvm.x86.avx10.vfmaddpd256
2082 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2083 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2084   return _mm256_mask_fnmsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2085 }
2086
2087 __m256d test_mm256_mask3_fnmsub_round_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) {
2088 // CHECK-LABEL: @test_mm256_mask3_fnmsub_round_pd
2089 // CHECK: fneg <4 x double>
2090 // CHECK: fneg <4 x double>
2091 // CHECK: @llvm.x86.avx10.vfmaddpd256
2092 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2093 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2094   return _mm256_mask3_fnmsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2095 }
2096
2097 __m256h test_mm256_mask3_fmsub_round_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2098 // CHECK-LABEL: @test_mm256_mask3_fmsub_round_ph
2099 // CHECK: fneg
2100 // CHECK: @llvm.x86.avx10.vfmaddph256
2101 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2102 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2103   return _mm256_mask3_fmsub_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2104 }
2105
2106 __m256h test_mm256_mask3_fmsubadd_round_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2107 // CHECK-LABEL: @test_mm256_mask3_fmsubadd_round_ph
2108 // CHECK: fneg
2109 // CHECK: @llvm.x86.avx10.vfmaddsubph256
2110 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2111 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2112   return _mm256_mask3_fmsubadd_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2113 }
2114
2115 __m256h test_mm256_mask_fnmadd_round_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2116 // CHECK-LABEL: @test_mm256_mask_fnmadd_round_ph
2117 // CHECK: fneg
2118 // CHECK: @llvm.x86.avx10.vfmaddph256
2119 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2120 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2121   return _mm256_mask_fnmadd_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2122 }
2123
2124 __m256h test_mm256_mask_fnmsub_round_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2125 // CHECK-LABEL: @test_mm256_mask_fnmsub_round_ph
2126 // CHECK: fneg
2127 // CHECK: fneg
2128 // CHECK: @llvm.x86.avx10.vfmaddph256
2129 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2130 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2131   return _mm256_mask_fnmsub_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2132 }
2133
2134 __m256h test_mm256_mask3_fnmsub_round_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2135 // CHECK-LABEL: @test_mm256_mask3_fnmsub_round_ph
2136 // CHECK: fneg
2137 // CHECK: fneg
2138 // CHECK: @llvm.x86.avx10.vfmaddph256
2139 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2140 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2141   return _mm256_mask3_fnmsub_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2142 }
2143
2144 __m256 test_mm256_mask3_fmsub_round_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) {
2145 // CHECK-LABEL: @test_mm256_mask3_fmsub_round_ps
2146 // CHECK: fneg <8 x float> %{{.*}}
2147 // CHECK: @llvm.x86.avx10.vfmaddps256
2148 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2149 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2150   return _mm256_mask3_fmsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2151 }
2152
2153 __m256 test_mm256_mask3_fmsubadd_round_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) {
2154 // CHECK-LABEL: @test_mm256_mask3_fmsubadd_round_ps
2155 // CHECK: fneg <8 x float> %{{.*}}
2156 // CHECK: @llvm.x86.avx10.vfmaddsubps256
2157 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2158 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2159   return _mm256_mask3_fmsubadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2160 }
2161
2162 __m256 test_mm256_mask_fnmadd_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) {
2163 // CHECK-LABEL: @test_mm256_mask_fnmadd_round_ps
2164 // CHECK: fneg <8 x float> %{{.*}}
2165 // CHECK: @llvm.x86.avx10.vfmaddps256
2166 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2167 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2168   return _mm256_mask_fnmadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2169 }
2170
2171 __m256 test_mm256_mask_fnmsub_round_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) {
2172 // CHECK-LABEL: @test_mm256_mask_fnmsub_round_ps
2173 // CHECK: fneg <8 x float> %{{.*}}
2174 // CHECK: fneg <8 x float> %{{.*}}
2175 // CHECK: @llvm.x86.avx10.vfmaddps256
2176 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2177 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2178   return _mm256_mask_fnmsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2179 }
2180
2181 __m256 test_mm256_mask3_fnmsub_round_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) {
2182 // CHECK-LABEL: @test_mm256_mask3_fnmsub_round_ps
2183 // CHECK: fneg <8 x float> %{{.*}}
2184 // CHECK: fneg <8 x float> %{{.*}}
2185 // CHECK: @llvm.x86.avx10.vfmaddps256
2186 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2187 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2188   return _mm256_mask3_fnmsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2189 }
2190
2191 __m256h test_mm256_mul_round_pch(__m256h __A, __m256h __B) {
2192 // CHECK-LABEL: @test_mm256_mul_round_pch
2193 // CHECK: @llvm.x86.avx10.mask.vfmulcph256
2194   return _mm256_mul_round_pch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2195 }
2196
2197 __m256h test_mm256_mask_mul_round_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2198 // CHECK-LABEL: @test_mm256_mask_mul_round_pch
2199 // CHECK: @llvm.x86.avx10.mask.vfmulcph256
2200   return _mm256_mask_mul_round_pch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2201 }
2202
2203 __m256h test_mm256_maskz_mul_round_pch(__mmask8 __U, __m256h __A, __m256h __B) {
2204 // CHECK-LABEL: @test_mm256_maskz_mul_round_pch
2205 // CHECK: @llvm.x86.avx10.mask.vfmulcph256
2206   return _mm256_maskz_mul_round_pch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2207 }
2208
2209 __m256d test_mm256_getexp_round_pd(__m256d __A) {
2210 // CHECK-LABEL: @test_mm256_getexp_round_pd
2211 // CHECK: @llvm.x86.avx10.mask.vgetexppd256
2212   return _mm256_getexp_round_pd(__A, _MM_FROUND_NO_EXC);
2213 }
2214
2215 __m256d test_mm256_mask_getexp_round_pd(__m256d __W, __mmask8 __U, __m256d __A) {
2216 // CHECK-LABEL: @test_mm256_mask_getexp_round_pd
2217 // CHECK: @llvm.x86.avx10.mask.vgetexppd256
2218   return _mm256_mask_getexp_round_pd(__W, __U, __A, _MM_FROUND_NO_EXC);
2219 }
2220
2221 __m256d test_mm256_maskz_getexp_round_pd(__mmask8 __U, __m256d __A) {
2222 // CHECK-LABEL: @test_mm256_maskz_getexp_round_pd
2223 // CHECK: @llvm.x86.avx10.mask.vgetexppd256
2224   return _mm256_maskz_getexp_round_pd(__U, __A, _MM_FROUND_NO_EXC);
2225 }
2226
2227 __m256h test_mm256_getexp_round_ph(__m256h __A) {
2228 // CHECK-LABEL: @test_mm256_getexp_round_ph
2229 // CHECK: @llvm.x86.avx10.mask.vgetexpph256
2230   return _mm256_getexp_round_ph(__A, _MM_FROUND_NO_EXC);
2231 }
2232
2233 __m256h test_mm256_mask_getexp_round_ph(__m256h __W, __mmask16 __U, __m256h __A) {
2234 // CHECK-LABEL: @test_mm256_mask_getexp_round_ph
2235 // CHECK: @llvm.x86.avx10.mask.vgetexpph256
2236   return _mm256_mask_getexp_round_ph(__W, __U, __A, _MM_FROUND_NO_EXC);
2237 }
2238
2239 __m256h test_mm256_maskz_getexp_round_ph(__mmask16 __U, __m256h __A) {
2240 // CHECK-LABEL: @test_mm256_maskz_getexp_round_ph
2241 // CHECK: @llvm.x86.avx10.mask.vgetexpph256
2242   return _mm256_maskz_getexp_round_ph(__U, __A, _MM_FROUND_NO_EXC);
2243 }
2244
2245 __m256 test_mm256_getexp_round_ps(__m256 __A) {
2246 // CHECK-LABEL: @test_mm256_getexp_round_ps
2247 // CHECK: @llvm.x86.avx10.mask.vgetexpps256
2248   return _mm256_getexp_round_ps(__A, _MM_FROUND_NO_EXC);
2249 }
2250
2251 __m256 test_mm256_mask_getexp_round_ps(__m256 __W, __mmask8 __U, __m256 __A) {
2252 // CHECK-LABEL: @test_mm256_mask_getexp_round_ps
2253 // CHECK: @llvm.x86.avx10.mask.vgetexpps256
2254   return _mm256_mask_getexp_round_ps(__W, __U, __A, _MM_FROUND_NO_EXC);
2255 }
2256
2257 __m256 test_mm256_maskz_getexp_round_ps(__mmask8 __U, __m256 __A) {
2258 // CHECK-LABEL: @test_mm256_maskz_getexp_round_ps
2259 // CHECK: @llvm.x86.avx10.mask.vgetexpps256
2260   return _mm256_maskz_getexp_round_ps(__U, __A, _MM_FROUND_NO_EXC);
2261 }
2262
2263 __m256d test_mm256_getmant_round_pd(__m256d __A) {
2264 // CHECK-LABEL: @test_mm256_getmant_round_pd
2265 // CHECK: @llvm.x86.avx10.mask.vgetmantpd256
2266   return _mm256_getmant_round_pd(__A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2267 }
2268
2269 __m256d test_mm256_mask_getmant_round_pd(__m256d __W, __mmask8 __U, __m256d __A) {
2270 // CHECK-LABEL: @test_mm256_mask_getmant_round_pd
2271 // CHECK: @llvm.x86.avx10.mask.vgetmantpd256
2272   return _mm256_mask_getmant_round_pd(__W, __U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2273 }
2274
2275 __m256d test_mm256_maskz_getmant_round_pd(__mmask8 __U, __m256d __A) {
2276 // CHECK-LABEL: @test_mm256_maskz_getmant_round_pd
2277 // CHECK: @llvm.x86.avx10.mask.vgetmantpd256
2278   return _mm256_maskz_getmant_round_pd(__U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2279 }
2280
2281 __m256h test_mm256_getmant_round_ph(__m256h __A) {
2282 // CHECK-LABEL: @test_mm256_getmant_round_ph
2283 // CHECK: @llvm.x86.avx10.mask.vgetmantph256
2284   return _mm256_getmant_round_ph(__A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2285 }
2286
2287 __m256h test_mm256_mask_getmant_round_ph(__m256h __W, __mmask16 __U, __m256h __A) {
2288 // CHECK-LABEL: @test_mm256_mask_getmant_round_ph
2289 // CHECK: @llvm.x86.avx10.mask.vgetmantph256
2290   return _mm256_mask_getmant_round_ph(__W, __U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2291 }
2292
2293 __m256h test_mm256_maskz_getmant_round_ph(__mmask16 __U, __m256h __A) {
2294 // CHECK-LABEL: @test_mm256_maskz_getmant_round_ph
2295 // CHECK: @llvm.x86.avx10.mask.vgetmantph256
2296   return _mm256_maskz_getmant_round_ph(__U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2297 }
2298
2299 __m256 test_mm256_getmant_round_ps(__m256 __A) {
2300 // CHECK-LABEL: @test_mm256_getmant_round_ps
2301 // CHECK: @llvm.x86.avx10.mask.vgetmantps256
2302   return _mm256_getmant_round_ps(__A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2303 }
2304
2305 __m256 test_mm256_mask_getmant_round_ps(__m256 __W, __mmask8 __U, __m256 __A) {
2306 // CHECK-LABEL: @test_mm256_mask_getmant_round_ps
2307 // CHECK: @llvm.x86.avx10.mask.vgetmantps256
2308   return _mm256_mask_getmant_round_ps(__W, __U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2309 }
2310
2311 __m256 test_mm256_maskz_getmant_round_ps(__mmask8 __U, __m256 __A) {
2312 // CHECK-LABEL: @test_mm256_maskz_getmant_round_ps
2313 // CHECK: @llvm.x86.avx10.mask.vgetmantps256
2314   return _mm256_maskz_getmant_round_ps(__U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
2315 }
2316
2317 __m256d test_mm256_max_round_pd(__m256d __A, __m256d __B) {
2318 // CHECK-LABEL: @test_mm256_max_round_pd
2319 // CHECK: @llvm.x86.avx10.vmaxpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8)
2320   return _mm256_max_round_pd(__A, __B, _MM_FROUND_NO_EXC);
2321 }
2322
2323 __m256d test_mm256_mask_max_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
2324 // CHECK-LABEL: @test_mm256_mask_max_round_pd
2325 // CHECK: @llvm.x86.avx10.vmaxpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8)
2326 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2327   return _mm256_mask_max_round_pd(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
2328 }
2329
2330 __m256d test_mm256_maskz_max_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
2331 // CHECK-LABEL: @test_mm256_maskz_max_round_pd
2332 // CHECK: @llvm.x86.avx10.vmaxpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8)
2333 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2334   return _mm256_maskz_max_round_pd(__U, __A, __B, _MM_FROUND_NO_EXC);
2335 }
2336
2337 __m256h test_mm256_max_round_ph(__m256h __A, __m256h __B) {
2338 // CHECK-LABEL: @test_mm256_max_round_ph
2339 // CHECK: @llvm.x86.avx10.vmaxph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 8)
2340   return _mm256_max_round_ph(__A, __B, _MM_FROUND_NO_EXC);
2341 }
2342
2343 __m256h test_mm256_mask_max_round_ph(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2344 // CHECK-LABEL: @test_mm256_mask_max_round_ph
2345 // CHECK: @llvm.x86.avx10.vmaxph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 8)
2346 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2347   return _mm256_mask_max_round_ph(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
2348 }
2349
2350 __m256h test_mm256_maskz_max_round_ph(__mmask8 __U, __m256h __A, __m256h __B) {
2351 // CHECK-LABEL: @test_mm256_maskz_max_round_ph
2352 // CHECK: @llvm.x86.avx10.vmaxph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 8)
2353 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2354   return _mm256_maskz_max_round_ph(__U, __A, __B, _MM_FROUND_NO_EXC);
2355 }
2356
2357 __m256 test_mm256_max_round_ps(__m256 __A, __m256 __B) {
2358 // CHECK-LABEL: @test_mm256_max_round_ps
2359 // CHECK: @llvm.x86.avx10.vmaxps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8)
2360   return _mm256_max_round_ps(__A, __B, _MM_FROUND_NO_EXC);
2361 }
2362
2363 __m256 test_mm256_mask_max_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
2364 // CHECK-LABEL: @test_mm256_mask_max_round_ps
2365 // CHECK: @llvm.x86.avx10.vmaxps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8)
2366 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2367   return _mm256_mask_max_round_ps(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
2368 }
2369
2370 __m256 test_mm256_maskz_max_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
2371 // CHECK-LABEL: @test_mm256_maskz_max_round_ps
2372 // CHECK: @llvm.x86.avx10.vmaxps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8)
2373 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2374   return _mm256_maskz_max_round_ps(__U, __A, __B, _MM_FROUND_NO_EXC);
2375 }
2376
2377 __m256d test_mm256_min_round_pd(__m256d __A, __m256d __B) {
2378 // CHECK-LABEL: @test_mm256_min_round_pd
2379 // CHECK: @llvm.x86.avx10.vminpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8)
2380   return _mm256_min_round_pd(__A, __B, _MM_FROUND_NO_EXC);
2381 }
2382
2383 __m256d test_mm256_mask_min_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
2384 // CHECK-LABEL: @test_mm256_mask_min_round_pd
2385 // CHECK: @llvm.x86.avx10.vminpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8)
2386 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2387   return _mm256_mask_min_round_pd(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
2388 }
2389
2390 __m256d test_mm256_maskz_min_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
2391 // CHECK-LABEL: @test_mm256_maskz_min_round_pd
2392 // CHECK: @llvm.x86.avx10.vminpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8)
2393 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2394   return _mm256_maskz_min_round_pd(__U, __A, __B, _MM_FROUND_NO_EXC);
2395 }
2396
2397 __m256h test_mm256_min_round_ph(__m256h __A, __m256h __B) {
2398 // CHECK-LABEL: @test_mm256_min_round_ph
2399 // CHECK: @llvm.x86.avx10.vminph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 8)
2400   return _mm256_min_round_ph(__A, __B, _MM_FROUND_NO_EXC);
2401 }
2402
2403 __m256h test_mm256_mask_min_round_ph(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2404 // CHECK-LABEL: @test_mm256_mask_min_round_ph
2405 // CHECK: @llvm.x86.avx10.vminph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 8)
2406 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2407   return _mm256_mask_min_round_ph(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
2408 }
2409
2410 __m256h test_mm256_maskz_min_round_ph(__mmask8 __U, __m256h __A, __m256h __B) {
2411 // CHECK-LABEL: @test_mm256_maskz_min_round_ph
2412 // CHECK: @llvm.x86.avx10.vminph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 8)
2413 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2414   return _mm256_maskz_min_round_ph(__U, __A, __B, _MM_FROUND_NO_EXC);
2415 }
2416
2417 __m256 test_mm256_min_round_ps(__m256 __A, __m256 __B) {
2418 // CHECK-LABEL: @test_mm256_min_round_ps
2419 // CHECK: @llvm.x86.avx10.vminps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8)
2420   return _mm256_min_round_ps(__A, __B, _MM_FROUND_NO_EXC);
2421 }
2422
2423 __m256 test_mm256_mask_min_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
2424 // CHECK-LABEL: @test_mm256_mask_min_round_ps
2425 // CHECK: @llvm.x86.avx10.vminps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8)
2426 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2427   return _mm256_mask_min_round_ps(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
2428 }
2429
2430 __m256 test_mm256_maskz_min_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
2431 // CHECK-LABEL: @test_mm256_maskz_min_round_ps
2432 // CHECK: @llvm.x86.avx10.vminps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8)
2433 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2434   return _mm256_maskz_min_round_ps(__U, __A, __B, _MM_FROUND_NO_EXC);
2435 }
2436
2437 __m256d test_mm256_mul_round_pd(__m256d __A, __m256d __B) {
2438 // CHECK-LABEL: @test_mm256_mul_round_pd
2439 // CHECK: @llvm.x86.avx10.vmulpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 11)
2440   return _mm256_mul_round_pd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2441 }
2442
2443 __m256d test_mm256_mask_mul_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
2444 // CHECK-LABEL: @test_mm256_mask_mul_round_pd
2445 // CHECK: @llvm.x86.avx10.vmulpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 10)
2446 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2447   return _mm256_mask_mul_round_pd(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
2448 }
2449
2450 __m256d test_mm256_maskz_mul_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
2451 // CHECK-LABEL: @test_mm256_maskz_mul_round_pd
2452 // CHECK: @llvm.x86.avx10.vmulpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 9)
2453 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2454   return _mm256_maskz_mul_round_pd(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
2455 }
2456
2457 __m256h test_mm256_mul_round_ph(__m256h __A, __m256h __B) {
2458 // CHECK-LABEL: @test_mm256_mul_round_ph
2459 // CHECK: @llvm.x86.avx10.vmulph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 11)
2460   return _mm256_mul_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2461 }
2462
2463 __m256h test_mm256_mask_mul_round_ph(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2464 // CHECK-LABEL: @test_mm256_mask_mul_round_ph
2465 // CHECK: @llvm.x86.avx10.vmulph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 10)
2466 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2467   return _mm256_mask_mul_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
2468 }
2469
2470 __m256h test_mm256_maskz_mul_round_ph(__mmask8 __U, __m256h __A, __m256h __B) {
2471 // CHECK-LABEL: @test_mm256_maskz_mul_round_ph
2472 // CHECK: @llvm.x86.avx10.vmulph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 9)
2473 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2474   return _mm256_maskz_mul_round_ph(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
2475 }
2476
2477 __m256 test_mm256_mul_round_ps(__m256 __A, __m256 __B) {
2478 // CHECK-LABEL: @test_mm256_mul_round_ps
2479 // CHECK: @llvm.x86.avx10.vmulps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 11)
2480   return _mm256_mul_round_ps(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2481 }
2482
2483 __m256 test_mm256_mask_mul_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
2484 // CHECK-LABEL: @test_mm256_mask_mul_round_ps
2485 // CHECK: @llvm.x86.avx10.vmulps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 10)
2486 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2487   return _mm256_mask_mul_round_ps(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
2488 }
2489
2490 __m256 test_mm256_maskz_mul_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
2491 // CHECK-LABEL: @test_mm256_maskz_mul_round_ps
2492 // CHECK: @llvm.x86.avx10.vmulps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 9)
2493 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2494   return _mm256_maskz_mul_round_ps(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
2495 }
2496
2497 __m256d test_mm256_range_round_pd(__m256d __A, __m256d __B) {
2498 // CHECK-LABEL: @test_mm256_range_round_pd
2499 // CHECK: @llvm.x86.avx10.mask.vrangepd256
2500   return _mm256_range_round_pd(__A, __B, 4, 8);
2501 }
2502
2503 __m256d test_mm256_mask_range_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
2504 // CHECK-LABEL: @test_mm256_mask_range_round_pd
2505 // CHECK: @llvm.x86.avx10.mask.vrangepd256
2506   return _mm256_mask_range_round_pd(__W, __U, __A, __B, 4, 8);
2507 }
2508
2509 __m256d test_mm256_maskz_range_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
2510 // CHECK-LABEL: @test_mm256_maskz_range_round_pd
2511 // CHECK: @llvm.x86.avx10.mask.vrangepd256
2512   return _mm256_maskz_range_round_pd(__U, __A, __B, 4, 8);
2513 }
2514
2515 __m256 test_mm256_range_round_ps(__m256 __A, __m256 __B) {
2516 // CHECK-LABEL: @test_mm256_range_round_ps
2517 // CHECK: @llvm.x86.avx10.mask.vrangeps256
2518   return _mm256_range_round_ps(__A, __B, 4, 8);
2519 }
2520
2521 __m256 test_mm256_mask_range_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
2522 // CHECK-LABEL: @test_mm256_mask_range_round_ps
2523 // CHECK: @llvm.x86.avx10.mask.vrangeps256
2524   return _mm256_mask_range_round_ps(__W, __U, __A, __B, 4, 8);
2525 }
2526
2527 __m256 test_mm256_maskz_range_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
2528 // CHECK-LABEL: @test_mm256_maskz_range_round_ps
2529 // CHECK: @llvm.x86.avx10.mask.vrangeps256
2530   return _mm256_maskz_range_round_ps(__U, __A, __B, 4, 8);
2531 }
2532
2533 __m256d test_mm256_reduce_round_pd(__m256d __A) {
2534 // CHECK-LABEL: @test_mm256_reduce_round_pd
2535 // CHECK: @llvm.x86.avx10.mask.vreducepd256
2536   return _mm256_reduce_round_pd(__A, 4, 8);
2537 }
2538
2539 __m256d test_mm256_mask_reduce_round_pd(__m256d __W, __mmask8 __U, __m256d __A) {
2540 // CHECK-LABEL: @test_mm256_mask_reduce_round_pd
2541 // CHECK: @llvm.x86.avx10.mask.vreducepd256
2542   return _mm256_mask_reduce_round_pd(__W, __U, __A, 4, 8);
2543 }
2544
2545 __m256d test_mm256_maskz_reduce_round_pd(__mmask8 __U, __m256d __A) {
2546 // CHECK-LABEL: @test_mm256_maskz_reduce_round_pd
2547 // CHECK: @llvm.x86.avx10.mask.vreducepd256
2548   return _mm256_maskz_reduce_round_pd(__U, __A, 4, 8);
2549 }
2550
2551 __m256h test_mm256_mask_reduce_round_ph(__m256h __A, __mmask8 __U, __m256h __C) {
2552 // CHECK-LABEL: @test_mm256_mask_reduce_round_ph
2553 // CHECK: @llvm.x86.avx10.mask.vreduceph256
2554   return _mm256_mask_reduce_round_ph(__A, __U, __C, 3, _MM_FROUND_NO_EXC);
2555 }
2556
2557 __m256h test_mm256_maskz_reduce_round_ph(__m256h __A, __mmask8 __U) {
2558 // CHECK-LABEL: @test_mm256_maskz_reduce_round_ph
2559 // CHECK: @llvm.x86.avx10.mask.vreduceph256
2560   return _mm256_maskz_reduce_round_ph(__U, __A, 3, _MM_FROUND_NO_EXC);
2561 }
2562
2563 __m256h test_mm256_reduce_round_ph(__m256h __A) {
2564 // CHECK-LABEL: @test_mm256_reduce_round_ph
2565 // CHECK: @llvm.x86.avx10.mask.vreduceph256
2566   return _mm256_reduce_round_ph(__A, 3, _MM_FROUND_NO_EXC);
2567 }
2568
2569 __m256 test_mm256_reduce_round_ps(__m256 __A) {
2570 // CHECK-LABEL: @test_mm256_reduce_round_ps
2571 // CHECK: @llvm.x86.avx10.mask.vreduceps256
2572   return _mm256_reduce_round_ps(__A, 4, 8);
2573 }
2574
2575 __m256 test_mm256_mask_reduce_round_ps(__m256 __W, __mmask8 __U, __m256 __A) {
2576 // CHECK-LABEL: @test_mm256_mask_reduce_round_ps
2577 // CHECK: @llvm.x86.avx10.mask.vreduceps256
2578   return _mm256_mask_reduce_round_ps(__W, __U, __A, 4, 8);
2579 }
2580
2581 __m256 test_mm256_maskz_reduce_round_ps(__mmask8 __U, __m256 __A) {
2582 // CHECK-LABEL: @test_mm256_maskz_reduce_round_ps
2583 // CHECK: @llvm.x86.avx10.mask.vreduceps256
2584   return _mm256_maskz_reduce_round_ps(__U, __A, 4, 8);
2585 }
2586
2587 __m256d test_mm256_roundscale_round_pd(__m256d __A)
2588 {
2589 // CHECK-LABEL: @test_mm256_roundscale_round_pd
2590 // CHECK: @llvm.x86.avx10.mask.vrndscalepd256
2591   return _mm256_roundscale_round_pd(__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC);
2592 }
2593
2594 __m256d test_mm256_mask_roundscale_round_pd(__m256d __A,__mmask8 __U,__m256d __C)
2595 {
2596 // CHECK-LABEL: @test_mm256_mask_roundscale_round_pd
2597 // CHECK: @llvm.x86.avx10.mask.vrndscalepd256
2598   return _mm256_mask_roundscale_round_pd(__A,__U,__C,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC);
2599 }
2600
2601 __m256d test_mm256_maskz_roundscale_round_pd(__m256d __A,__mmask8 __U)
2602 {
2603 // CHECK-LABEL: @test_mm256_maskz_roundscale_round_pd
2604 // CHECK: @llvm.x86.avx10.mask.vrndscalepd256
2605   return _mm256_maskz_roundscale_round_pd(__U,__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC);
2606 }
2607
2608 __m256h test_mm256_mask_roundscale_round_ph(__m256h __A, __mmask8 __U, __m256h __C) {
2609 // CHECK-LABEL: @test_mm256_mask_roundscale_round_ph
2610 // CHECK: @llvm.x86.avx10.mask.vrndscaleph256
2611   return _mm256_mask_roundscale_round_ph(__A, __U, __C, 3, _MM_FROUND_NO_EXC);
2612 }
2613
2614 __m256h test_mm256_maskz_roundscale_round_ph(__m256h __A, __mmask8 __U) {
2615 // CHECK-LABEL: @test_mm256_maskz_roundscale_round_ph
2616 // CHECK: @llvm.x86.avx10.mask.vrndscaleph256
2617   return _mm256_maskz_roundscale_round_ph(__U, __A, 3, _MM_FROUND_NO_EXC);
2618 }
2619
2620 __m256h test_mm256_roundscale_round_ph(__m256h __A) {
2621 // CHECK-LABEL: @test_mm256_roundscale_round_ph
2622 // CHECK: @llvm.x86.avx10.mask.vrndscaleph256
2623   return _mm256_roundscale_round_ph(__A, 3, _MM_FROUND_NO_EXC);
2624 }
2625
2626 __m256 test_mm256_roundscale_round_ps(__m256 __A)
2627 {
2628 // CHECK-LABEL: @test_mm256_roundscale_round_ps
2629 // CHECK: @llvm.x86.avx10.mask.vrndscaleps256
2630   return _mm256_roundscale_round_ps(__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC);
2631 }
2632
2633 __m256 test_mm256_mask_roundscale_round_ps(__m256 __A,__mmask8 __U,__m256 __C)
2634 {
2635 // CHECK-LABEL: @test_mm256_mask_roundscale_round_ps
2636 // CHECK: @llvm.x86.avx10.mask.vrndscaleps256
2637   return _mm256_mask_roundscale_round_ps(__A,__U,__C,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC);
2638 }
2639
2640 __m256 test_mm256_maskz_roundscale_round_ps(__m256 __A,__mmask8 __U)
2641 {
2642 // CHECK-LABEL: @test_mm256_maskz_roundscale_round_ps
2643 // CHECK: @llvm.x86.avx10.mask.vrndscaleps256
2644   return _mm256_maskz_roundscale_round_ps(__U,__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC);
2645 }
2646
2647 __m256d test_mm256_scalef_round_pd(__m256d __A, __m256d __B) {
2648 // CHECK-LABEL: @test_mm256_scalef_round_pd
2649 // CHECK: @llvm.x86.avx10.mask.vscalefpd256
2650   return _mm256_scalef_round_pd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2651 }
2652
2653 __m256d test_mm256_mask_scalef_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
2654 // CHECK-LABEL: @test_mm256_mask_scalef_round_pd
2655 // CHECK: @llvm.x86.avx10.mask.vscalefpd256
2656   return _mm256_mask_scalef_round_pd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2657 }
2658
2659 __m256d test_mm256_maskz_scalef_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
2660 // CHECK-LABEL: @test_mm256_maskz_scalef_round_pd
2661 // CHECK: @llvm.x86.avx10.mask.vscalefpd256
2662   return _mm256_maskz_scalef_round_pd(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2663 }
2664
2665 __m256h test_mm256_scalef_round_ph(__m256h __A, __m256h __B) {
2666 // CHECK-LABEL: @test_mm256_scalef_round_ph
2667 // CHECK: @llvm.x86.avx10.mask.vscalefph256
2668   return _mm256_scalef_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2669 }
2670
2671 __m256h test_mm256_mask_scalef_round_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
2672 // CHECK-LABEL: @test_mm256_mask_scalef_round_ph
2673 // CHECK: @llvm.x86.avx10.mask.vscalefph256
2674   return _mm256_mask_scalef_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2675 }
2676
2677 __m256h test_mm256_maskz_scalef_round_ph(__mmask16 __U, __m256h __A, __m256h __B) {
2678 // CHECK-LABEL: @test_mm256_maskz_scalef_round_ph
2679 // CHECK: @llvm.x86.avx10.mask.vscalefph256
2680   return _mm256_maskz_scalef_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2681 }
2682
2683 __m256 test_mm256_scalef_round_ps(__m256 __A, __m256 __B) {
2684 // CHECK-LABEL: @test_mm256_scalef_round_ps
2685 // CHECK: @llvm.x86.avx10.mask.vscalefps256
2686   return _mm256_scalef_round_ps(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2687 }
2688
2689 __m256 test_mm256_mask_scalef_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
2690 // CHECK-LABEL: @test_mm256_mask_scalef_round_ps
2691 // CHECK: @llvm.x86.avx10.mask.vscalefps256
2692   return _mm256_mask_scalef_round_ps(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2693 }
2694
2695 __m256 test_mm256_maskz_scalef_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
2696 // CHECK-LABEL: @test_mm256_maskz_scalef_round_ps
2697 // CHECK: @llvm.x86.avx10.mask.vscalefps256
2698   return _mm256_maskz_scalef_round_ps(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2699 }
2700
2701 __m256d test_mm256_sqrt_round_pd(__m256d __A)
2702 {
2703 // CHECK-LABEL: @test_mm256_sqrt_round_pd
2704 // CHECK: call <4 x double> @llvm.x86.avx10.vsqrtpd256(<4 x double> %{{.*}}, i32 11)
2705   return _mm256_sqrt_round_pd(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2706 }
2707
2708 __m256d test_mm256_mask_sqrt_round_pd(__m256d __W,__mmask8 __U,__m256d __A)
2709 {
2710 // CHECK-LABEL: @test_mm256_mask_sqrt_round_pd
2711 // CHECK: call <4 x double> @llvm.x86.avx10.vsqrtpd256(<4 x double> %{{.*}}, i32 11)
2712 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2713 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2714   return _mm256_mask_sqrt_round_pd(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2715 }
2716
2717 __m256d test_mm256_maskz_sqrt_round_pd(__mmask8 __U,__m256d __A)
2718 {
2719 // CHECK-LABEL: @test_mm256_maskz_sqrt_round_pd
2720 // CHECK: call <4 x double> @llvm.x86.avx10.vsqrtpd256(<4 x double> %{{.*}}, i32 11)
2721 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2722 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> {{.*}}
2723   return _mm256_maskz_sqrt_round_pd(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2724 }
2725
2726 __m256h test_mm256_sqrt_round_ph(__m256h __A) {
2727 // CHECK-LABEL: @test_mm256_sqrt_round_ph
2728 // CHECK: call <16 x half> @llvm.x86.avx10.vsqrtph256(<16 x half> %{{.*}}, i32 11)
2729   return _mm256_sqrt_round_ph(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2730 }
2731
2732 __m256h test_mm256_mask_sqrt_round_ph(__m256h __W, __mmask16 __U, __m256h __A) {
2733 // CHECK-LABEL: @test_mm256_mask_sqrt_round_ph
2734 // CHECK: call <16 x half> @llvm.x86.avx10.vsqrtph256(<16 x half> %{{.*}}, i32 11)
2735 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2736 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2737   return _mm256_mask_sqrt_round_ph(__W, __U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2738 }
2739
2740 __m256h test_mm256_maskz_sqrt_round_ph(__mmask16 __U, __m256h __A) {
2741 // CHECK-LABEL: @test_mm256_maskz_sqrt_round_ph
2742 // CHECK: call <16 x half> @llvm.x86.avx10.vsqrtph256(<16 x half> %{{.*}}, i32 11)
2743 // CHECK: bitcast i16 %{{.*}} to <16 x i1>
2744 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> {{.*}}
2745   return _mm256_maskz_sqrt_round_ph(__U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2746 }
2747
2748 __m256 test_mm256_sqrt_round_ps(__m256 __A)
2749 {
2750 // CHECK-LABEL: @test_mm256_sqrt_round_ps
2751 // CHECK: call <8 x float> @llvm.x86.avx10.vsqrtps256(<8 x float> %{{.*}}, i32 11)
2752   return _mm256_sqrt_round_ps(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2753 }
2754
2755 __m256 test_mm256_mask_sqrt_round_ps(__m256 __W,__mmask8 __U,__m256 __A)
2756 {
2757 // CHECK-LABEL: @test_mm256_mask_sqrt_round_ps
2758 // CHECK: call <8 x float> @llvm.x86.avx10.vsqrtps256(<8 x float> %{{.*}}, i32 11)
2759 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2760 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2761   return _mm256_mask_sqrt_round_ps(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2762 }
2763
2764 __m256 test_mm256_maskz_sqrt_round_ps(__mmask8 __U,__m256 __A)
2765 {
2766 // CHECK-LABEL: @test_mm256_maskz_sqrt_round_ps
2767 // CHECK: call <8 x float> @llvm.x86.avx10.vsqrtps256(<8 x float> %{{.*}}, i32 11)
2768 // CHECK: bitcast i8 %{{.*}} to <8 x i1>
2769 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> {{.*}}
2770   return _mm256_maskz_sqrt_round_ps(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2771 }
2772
2773 __m256d test_mm256_sub_round_pd(__m256d __A, __m256d __B) {
2774 // CHECK-LABEL: @test_mm256_sub_round_pd
2775 // CHECK: @llvm.x86.avx10.vsubpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 11)
2776   return _mm256_sub_round_pd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2777 }
2778
2779 __m256d test_mm256_mask_sub_round_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
2780 // CHECK-LABEL: @test_mm256_mask_sub_round_pd
2781 // CHECK: @llvm.x86.avx10.vsubpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 10)
2782 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2783   return _mm256_mask_sub_round_pd(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
2784 }
2785
2786 __m256d test_mm256_maskz_sub_round_pd(__mmask8 __U, __m256d __A, __m256d __B) {
2787 // CHECK-LABEL: @test_mm256_maskz_sub_round_pd
2788 // CHECK: @llvm.x86.avx10.vsubpd256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 9)
2789 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
2790   return _mm256_maskz_sub_round_pd(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
2791 }
2792
2793 __m256h test_mm256_sub_round_ph(__m256h __A, __m256h __B) {
2794 // CHECK-LABEL: @test_mm256_sub_round_ph
2795 // CHECK: @llvm.x86.avx10.vsubph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 11)
2796   return _mm256_sub_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2797 }
2798
2799 __m256h test_mm256_mask_sub_round_ph(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2800 // CHECK-LABEL: @test_mm256_mask_sub_round_ph
2801 // CHECK: @llvm.x86.avx10.vsubph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 10)
2802 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2803   return _mm256_mask_sub_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
2804 }
2805
2806 __m256h test_mm256_maskz_sub_round_ph(__mmask8 __U, __m256h __A, __m256h __B) {
2807 // CHECK-LABEL: @test_mm256_maskz_sub_round_ph
2808 // CHECK: @llvm.x86.avx10.vsubph256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 9)
2809 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2810   return _mm256_maskz_sub_round_ph(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
2811 }
2812
2813 __m256 test_mm256_sub_round_ps(__m256 __A, __m256 __B) {
2814 // CHECK-LABEL: @test_mm256_sub_round_ps
2815 // CHECK: @llvm.x86.avx10.vsubps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 11)
2816   return _mm256_sub_round_ps(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2817 }
2818
2819 __m256 test_mm256_mask_sub_round_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
2820 // CHECK-LABEL: @test_mm256_mask_sub_round_ps
2821 // CHECK: @llvm.x86.avx10.vsubps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 10)
2822 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2823   return _mm256_mask_sub_round_ps(__W, __U, __A, __B, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
2824 }
2825
2826 __m256 test_mm256_maskz_sub_round_ps(__mmask8 __U, __m256 __A, __m256 __B) {
2827 // CHECK-LABEL: @test_mm256_maskz_sub_round_ps
2828 // CHECK: @llvm.x86.avx10.vsubps256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 9)
2829 // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2830   return _mm256_maskz_sub_round_ps(__U, __A, __B, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
2831 }