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

   1 // RUN: %clang_cc1 -ffreestanding -flax-vector-conversions=none %s -triple=x86_64-unknown-unknown -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s
   2
   3 #include <immintrin.h>
   4
   5 _Float16 test_mm512_cvtsh_h(__m512h __A) {
   6   // CHECK-LABEL: @test_mm512_cvtsh_h
   7   // CHECK: extractelement <32 x half> %{{.*}}, i32 0
   8   return _mm512_cvtsh_h(__A);
   9 }
  10
  11 __m128h test_mm_setzero_ph(void) {
  12   // CHECK-LABEL: @test_mm_setzero_ph
  13   // CHECK: zeroinitializer
  14   return _mm_setzero_ph();
  15 }
  16
  17 __m256h test_mm256_setzero_ph(void) {
  18   // CHECK-LABEL: @test_mm256_setzero_ph
  19   // CHECK: zeroinitializer
  20   return _mm256_setzero_ph();
  21 }
  22
  23 __m256h test_mm256_undefined_ph(void) {
  24   // CHECK-LABEL: @test_mm256_undefined_ph
  25   // CHECK: ret <16 x half> zeroinitializer
  26   return _mm256_undefined_ph();
  27 }
  28
  29 __m512h test_mm512_setzero_ph(void) {
  30   // CHECK-LABEL: @test_mm512_setzero_ph
  31   // CHECK: zeroinitializer
  32   return _mm512_setzero_ph();
  33 }
  34
  35 __m128h test_mm_undefined_ph(void) {
  36   // CHECK-LABEL: @test_mm_undefined_ph
  37   // CHECK: ret <8 x half> zeroinitializer
  38   return _mm_undefined_ph();
  39 }
  40
  41 __m512h test_mm512_undefined_ph(void) {
  42   // CHECK-LABEL: @test_mm512_undefined_ph
  43   // CHECK: ret <32 x half> zeroinitializer
  44   return _mm512_undefined_ph();
  45 }
  46
  47 __m512h test_mm512_set1_ph(_Float16 h) {
  48   // CHECK-LABEL: @test_mm512_set1_ph
  49   // CHECK: insertelement <32 x half> {{.*}}, i32 0
  50   // CHECK: insertelement <32 x half> {{.*}}, i32 1
  51   // CHECK: insertelement <32 x half> {{.*}}, i32 2
  52   // CHECK: insertelement <32 x half> {{.*}}, i32 3
  53   // CHECK: insertelement <32 x half> {{.*}}, i32 4
  54   // CHECK: insertelement <32 x half> {{.*}}, i32 5
  55   // CHECK: insertelement <32 x half> {{.*}}, i32 6
  56   // CHECK: insertelement <32 x half> {{.*}}, i32 7
  57   // CHECK: insertelement <32 x half> {{.*}}, i32 8
  58   // CHECK: insertelement <32 x half> {{.*}}, i32 9
  59   // CHECK: insertelement <32 x half> {{.*}}, i32 10
  60   // CHECK: insertelement <32 x half> {{.*}}, i32 11
  61   // CHECK: insertelement <32 x half> {{.*}}, i32 12
  62   // CHECK: insertelement <32 x half> {{.*}}, i32 13
  63   // CHECK: insertelement <32 x half> {{.*}}, i32 14
  64   // CHECK: insertelement <32 x half> {{.*}}, i32 15
  65   // CHECK: insertelement <32 x half> {{.*}}, i32 16
  66   // CHECK: insertelement <32 x half> {{.*}}, i32 17
  67   // CHECK: insertelement <32 x half> {{.*}}, i32 18
  68   // CHECK: insertelement <32 x half> {{.*}}, i32 19
  69   // CHECK: insertelement <32 x half> {{.*}}, i32 20
  70   // CHECK: insertelement <32 x half> {{.*}}, i32 21
  71   // CHECK: insertelement <32 x half> {{.*}}, i32 22
  72   // CHECK: insertelement <32 x half> {{.*}}, i32 23
  73   // CHECK: insertelement <32 x half> {{.*}}, i32 24
  74   // CHECK: insertelement <32 x half> {{.*}}, i32 25
  75   // CHECK: insertelement <32 x half> {{.*}}, i32 26
  76   // CHECK: insertelement <32 x half> {{.*}}, i32 27
  77   // CHECK: insertelement <32 x half> {{.*}}, i32 28
  78   // CHECK: insertelement <32 x half> {{.*}}, i32 29
  79   // CHECK: insertelement <32 x half> {{.*}}, i32 30
  80   // CHECK: insertelement <32 x half> {{.*}}, i32 31
  81   return _mm512_set1_ph(h);
  82 }
  83
  84 __m512h test_mm512_set1_pch(_Float16 _Complex h) {
  85   // CHECK-LABEL: @test_mm512_set1_pch
  86   // CHECK: insertelement <16 x float> {{.*}}, i32 0
  87   // CHECK: insertelement <16 x float> {{.*}}, i32 1
  88   // CHECK: insertelement <16 x float> {{.*}}, i32 2
  89   // CHECK: insertelement <16 x float> {{.*}}, i32 3
  90   // CHECK: insertelement <16 x float> {{.*}}, i32 4
  91   // CHECK: insertelement <16 x float> {{.*}}, i32 5
  92   // CHECK: insertelement <16 x float> {{.*}}, i32 6
  93   // CHECK: insertelement <16 x float> {{.*}}, i32 7
  94   // CHECK: insertelement <16 x float> {{.*}}, i32 8
  95   // CHECK: insertelement <16 x float> {{.*}}, i32 9
  96   // CHECK: insertelement <16 x float> {{.*}}, i32 10
  97   // CHECK: insertelement <16 x float> {{.*}}, i32 11
  98   // CHECK: insertelement <16 x float> {{.*}}, i32 12
  99   // CHECK: insertelement <16 x float> {{.*}}, i32 13
 100   // CHECK: insertelement <16 x float> {{.*}}, i32 14
 101   // CHECK: insertelement <16 x float> {{.*}}, i32 15
 102   // CHECK: bitcast <16 x float>{{.*}} to <32 x half>
 103   return _mm512_set1_pch(h);
 104 }
 105
 106 __m512h test_mm512_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
 107                           _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
 108                           _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
 109                           _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16,
 110                           _Float16 __h17, _Float16 __h18, _Float16 __h19, _Float16 __h20,
 111                           _Float16 __h21, _Float16 __h22, _Float16 __h23, _Float16 __h24,
 112                           _Float16 __h25, _Float16 __h26, _Float16 __h27, _Float16 __h28,
 113                           _Float16 __h29, _Float16 __h30, _Float16 __h31, _Float16 __h32) {
 114   // CHECK-LABEL: @test_mm512_set_ph
 115   // CHECK: insertelement <32 x half> {{.*}}, i32 0
 116   // CHECK: insertelement <32 x half> {{.*}}, i32 1
 117   // CHECK: insertelement <32 x half> {{.*}}, i32 2
 118   // CHECK: insertelement <32 x half> {{.*}}, i32 3
 119   // CHECK: insertelement <32 x half> {{.*}}, i32 4
 120   // CHECK: insertelement <32 x half> {{.*}}, i32 5
 121   // CHECK: insertelement <32 x half> {{.*}}, i32 6
 122   // CHECK: insertelement <32 x half> {{.*}}, i32 7
 123   // CHECK: insertelement <32 x half> {{.*}}, i32 8
 124   // CHECK: insertelement <32 x half> {{.*}}, i32 9
 125   // CHECK: insertelement <32 x half> {{.*}}, i32 10
 126   // CHECK: insertelement <32 x half> {{.*}}, i32 11
 127   // CHECK: insertelement <32 x half> {{.*}}, i32 12
 128   // CHECK: insertelement <32 x half> {{.*}}, i32 13
 129   // CHECK: insertelement <32 x half> {{.*}}, i32 14
 130   // CHECK: insertelement <32 x half> {{.*}}, i32 15
 131   // CHECK: insertelement <32 x half> {{.*}}, i32 16
 132   // CHECK: insertelement <32 x half> {{.*}}, i32 17
 133   // CHECK: insertelement <32 x half> {{.*}}, i32 18
 134   // CHECK: insertelement <32 x half> {{.*}}, i32 19
 135   // CHECK: insertelement <32 x half> {{.*}}, i32 20
 136   // CHECK: insertelement <32 x half> {{.*}}, i32 21
 137   // CHECK: insertelement <32 x half> {{.*}}, i32 22
 138   // CHECK: insertelement <32 x half> {{.*}}, i32 23
 139   // CHECK: insertelement <32 x half> {{.*}}, i32 24
 140   // CHECK: insertelement <32 x half> {{.*}}, i32 25
 141   // CHECK: insertelement <32 x half> {{.*}}, i32 26
 142   // CHECK: insertelement <32 x half> {{.*}}, i32 27
 143   // CHECK: insertelement <32 x half> {{.*}}, i32 28
 144   // CHECK: insertelement <32 x half> {{.*}}, i32 29
 145   // CHECK: insertelement <32 x half> {{.*}}, i32 30
 146   // CHECK: insertelement <32 x half> {{.*}}, i32 31
 147   return _mm512_set_ph(__h1, __h2, __h3, __h4, __h5, __h6, __h7, __h8,
 148                        __h9, __h10, __h11, __h12, __h13, __h14, __h15, __h16,
 149                        __h17, __h18, __h19, __h20, __h21, __h22, __h23, __h24,
 150                        __h25, __h26, __h27, __h28, __h29, __h30, __h31, __h32);
 151 }
 152
 153 __m512h test_mm512_setr_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
 154                            _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
 155                            _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
 156                            _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16,
 157                            _Float16 __h17, _Float16 __h18, _Float16 __h19, _Float16 __h20,
 158                            _Float16 __h21, _Float16 __h22, _Float16 __h23, _Float16 __h24,
 159                            _Float16 __h25, _Float16 __h26, _Float16 __h27, _Float16 __h28,
 160                            _Float16 __h29, _Float16 __h30, _Float16 __h31, _Float16 __h32) {
 161   // CHECK-LABEL: @test_mm512_setr_ph
 162   // CHECK: insertelement <32 x half> {{.*}}, i32 0
 163   // CHECK: insertelement <32 x half> {{.*}}, i32 1
 164   // CHECK: insertelement <32 x half> {{.*}}, i32 2
 165   // CHECK: insertelement <32 x half> {{.*}}, i32 3
 166   // CHECK: insertelement <32 x half> {{.*}}, i32 4
 167   // CHECK: insertelement <32 x half> {{.*}}, i32 5
 168   // CHECK: insertelement <32 x half> {{.*}}, i32 6
 169   // CHECK: insertelement <32 x half> {{.*}}, i32 7
 170   // CHECK: insertelement <32 x half> {{.*}}, i32 8
 171   // CHECK: insertelement <32 x half> {{.*}}, i32 9
 172   // CHECK: insertelement <32 x half> {{.*}}, i32 10
 173   // CHECK: insertelement <32 x half> {{.*}}, i32 11
 174   // CHECK: insertelement <32 x half> {{.*}}, i32 12
 175   // CHECK: insertelement <32 x half> {{.*}}, i32 13
 176   // CHECK: insertelement <32 x half> {{.*}}, i32 14
 177   // CHECK: insertelement <32 x half> {{.*}}, i32 15
 178   // CHECK: insertelement <32 x half> {{.*}}, i32 16
 179   // CHECK: insertelement <32 x half> {{.*}}, i32 17
 180   // CHECK: insertelement <32 x half> {{.*}}, i32 18
 181   // CHECK: insertelement <32 x half> {{.*}}, i32 19
 182   // CHECK: insertelement <32 x half> {{.*}}, i32 20
 183   // CHECK: insertelement <32 x half> {{.*}}, i32 21
 184   // CHECK: insertelement <32 x half> {{.*}}, i32 22
 185   // CHECK: insertelement <32 x half> {{.*}}, i32 23
 186   // CHECK: insertelement <32 x half> {{.*}}, i32 24
 187   // CHECK: insertelement <32 x half> {{.*}}, i32 25
 188   // CHECK: insertelement <32 x half> {{.*}}, i32 26
 189   // CHECK: insertelement <32 x half> {{.*}}, i32 27
 190   // CHECK: insertelement <32 x half> {{.*}}, i32 28
 191   // CHECK: insertelement <32 x half> {{.*}}, i32 29
 192   // CHECK: insertelement <32 x half> {{.*}}, i32 30
 193   // CHECK: insertelement <32 x half> {{.*}}, i32 31
 194   return _mm512_setr_ph(__h1, __h2, __h3, __h4, __h5, __h6, __h7, __h8,
 195                         __h9, __h10, __h11, __h12, __h13, __h14, __h15, __h16,
 196                         __h17, __h18, __h19, __h20, __h21, __h22, __h23, __h24,
 197                         __h25, __h26, __h27, __h28, __h29, __h30, __h31, __h32);
 198 }
 199
 200 __m128 test_mm_castph_ps(__m128h A) {
 201   // CHECK-LABEL: test_mm_castph_ps
 202   // CHECK: bitcast <8 x half> %{{.*}} to <4 x float>
 203   return _mm_castph_ps(A);
 204 }
 205
 206 __m256 test_mm256_castph_ps(__m256h A) {
 207   // CHECK-LABEL: test_mm256_castph_ps
 208   // CHECK: bitcast <16 x half> %{{.*}} to <8 x float>
 209   return _mm256_castph_ps(A);
 210 }
 211
 212 __m512 test_mm512_castph_ps(__m512h A) {
 213   // CHECK-LABEL: test_mm512_castph_ps
 214   // CHECK: bitcast <32 x half> %{{.*}} to <16 x float>
 215   return _mm512_castph_ps(A);
 216 }
 217
 218 __m128d test_mm_castph_pd(__m128h A) {
 219   // CHECK-LABEL: test_mm_castph_pd
 220   // CHECK: bitcast <8 x half> %{{.*}} to <2 x double>
 221   return _mm_castph_pd(A);
 222 }
 223
 224 __m256d test_mm256_castph_pd(__m256h A) {
 225   // CHECK-LABEL: test_mm256_castph_pd
 226   // CHECK: bitcast <16 x half> %{{.*}} to <4 x double>
 227   return _mm256_castph_pd(A);
 228 }
 229
 230 __m512d test_mm512_castph_pd(__m512h A) {
 231   // CHECK-LABEL: test_mm512_castph_pd
 232   // CHECK: bitcast <32 x half> %{{.*}} to <8 x double>
 233   return _mm512_castph_pd(A);
 234 }
 235
 236 __m128i test_mm_castph_si128(__m128h A) {
 237   // CHECK-LABEL: test_mm_castph_si128
 238   // CHECK: bitcast <8 x half> %{{.*}} to <2 x i64>
 239   return _mm_castph_si128(A);
 240 }
 241
 242 __m256i test_mm256_castph_si256(__m256h A) {
 243   // CHECK-LABEL: test_mm256_castph_si256
 244   // CHECK: bitcast <16 x half> %{{.*}} to <4 x i64>
 245   return _mm256_castph_si256(A);
 246 }
 247
 248 __m512i test_mm512_castph_si512(__m512h A) {
 249   // CHECK-LABEL: test_mm512_castph_si512
 250   // CHECK: bitcast <32 x half> %{{.*}} to <8 x i64>
 251   return _mm512_castph_si512(A);
 252 }
 253
 254 __m128h test_mm_castps_ph(__m128 A) {
 255   // CHECK-LABEL: test_mm_castps_ph
 256   // CHECK: bitcast <4 x float> %{{.*}} to <8 x half>
 257   return _mm_castps_ph(A);
 258 }
 259
 260 __m256h test_mm256_castps_ph(__m256 A) {
 261   // CHECK-LABEL: test_mm256_castps_ph
 262   // CHECK: bitcast <8 x float> %{{.*}} to <16 x half>
 263   return _mm256_castps_ph(A);
 264 }
 265
 266 __m512h test_mm512_castps_ph(__m512 A) {
 267   // CHECK-LABEL: test_mm512_castps_ph
 268   // CHECK: bitcast <16 x float> %{{.*}} to <32 x half>
 269   return _mm512_castps_ph(A);
 270 }
 271
 272 __m128h test_mm_castpd_ph(__m128d A) {
 273   // CHECK-LABEL: test_mm_castpd_ph
 274   // CHECK: bitcast <2 x double> %{{.*}} to <8 x half>
 275   return _mm_castpd_ph(A);
 276 }
 277
 278 __m256h test_mm256_castpd_ph(__m256d A) {
 279   // CHECK-LABEL: test_mm256_castpd_ph
 280   // CHECK: bitcast <4 x double> %{{.*}} to <16 x half>
 281   return _mm256_castpd_ph(A);
 282 }
 283
 284 __m512h test_mm512_castpd_ph(__m512d A) {
 285   // CHECK-LABEL: test_mm512_castpd_ph
 286   // CHECK: bitcast <8 x double> %{{.*}} to <32 x half>
 287   return _mm512_castpd_ph(A);
 288 }
 289
 290 __m128h test_mm_castsi128_ph(__m128i A) {
 291   // CHECK-LABEL: test_mm_castsi128_ph
 292   // CHECK: bitcast <2 x i64> %{{.*}} to <8 x half>
 293   return _mm_castsi128_ph(A);
 294 }
 295
 296 __m256h test_mm256_castsi256_ph(__m256i A) {
 297   // CHECK-LABEL: test_mm256_castsi256_ph
 298   // CHECK: bitcast <4 x i64> %{{.*}} to <16 x half>
 299   return _mm256_castsi256_ph(A);
 300 }
 301
 302 __m512h test_mm512_castsi512_ph(__m512i A) {
 303   // CHECK-LABEL: test_mm512_castsi512_ph
 304   // CHECK: bitcast <8 x i64> %{{.*}} to <32 x half>
 305   return _mm512_castsi512_ph(A);
 306 }
 307
 308 __m128h test_mm256_castph256_ph128(__m256h __a) {
 309   // CHECK-LABEL: test_mm256_castph256_ph128
 310   // CHECK: shufflevector <16 x half> %{{.*}}, <16 x half> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 311   return _mm256_castph256_ph128(__a);
 312 }
 313
 314 __m128h test_mm512_castph512_ph128(__m512h __a) {
 315   // CHECK-LABEL: test_mm512_castph512_ph128
 316   // CHECK: shufflevector <32 x half> %{{.*}}, <32 x half> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 317   return _mm512_castph512_ph128(__a);
 318 }
 319
 320 __m256h test_mm512_castph512_ph256(__m512h __a) {
 321   // CHECK-LABEL: test_mm512_castph512_ph256
 322   // CHECK: shufflevector <32 x half> %{{.*}}, <32 x half> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 323   return _mm512_castph512_ph256(__a);
 324 }
 325
 326 __m256h test_mm256_castph128_ph256(__m128h __a) {
 327   // CHECK-LABEL: test_mm256_castph128_ph256
 328   // CHECK: [[A:%.*]] = freeze <8 x half> poison
 329   // CHECK: shufflevector <8 x half> %{{.*}}, <8 x half> [[A]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 330   return _mm256_castph128_ph256(__a);
 331 }
 332
 333 __m512h test_mm512_castph128_ph512(__m128h __a) {
 334   // CHECK-LABEL: test_mm512_castph128_ph512
 335   // CHECK: [[B:%.*]] = freeze <16 x half> poison
 336   // CHECK: store <16 x half> [[B]], ptr [[BA:%.*]]
 337   // CHECK: [[A:%.*]] = freeze <8 x half> poison
 338   // CHECK: [[SV:%.*]] = shufflevector <8 x half> %{{.*}}, <8 x half> [[A]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 339   // CHECK: [[C:%.*]] = load <16 x half>, ptr [[BA]]
 340   // CHECK: shufflevector <16 x half> [[SV]], <16 x half> [[C]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
 341   return _mm512_castph128_ph512(__a);
 342 }
 343
 344 __m512h test_mm512_castph256_ph512(__m256h __a) {
 345   // CHECK-LABEL: test_mm512_castph256_ph512
 346   // CHECK: [[A:%.*]] = freeze <16 x half> poison
 347   // CHECK: shufflevector <16 x half> %{{.*}}, <16 x half> [[A]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
 348   return _mm512_castph256_ph512(__a);
 349 }
 350
 351 __m256h test_mm256_zextph128_ph256(__m128h __a) {
 352   // CHECK-LABEL: test_mm256_zextph128_ph256
 353   // CHECK: shufflevector <8 x half> %{{.*}}, <8 x half> {{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 354   return _mm256_zextph128_ph256(__a);
 355 }
 356
 357 __m512h test_mm512_zextph128_ph512(__m128h __a) {
 358   // CHECK-LABEL: test_mm512_zextph128_ph512
 359   // CHECK: shufflevector <8 x half> %{{.*}}, <8 x half> {{.*}}, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 360   return _mm512_zextph128_ph512(__a);
 361 }
 362
 363 __m512h test_mm512_zextph256_ph512(__m256h __a) {
 364   // CHECK-LABEL: test_mm512_zextph256_ph512
 365   // CHECK: shufflevector <16 x half> %{{.*}}, <16 x half> {{.*}}, <32 x i32>
 366   return _mm512_zextph256_ph512(__a);
 367 }
 368
 369 int test_mm_comi_round_sh(__m128h __A, __m128h __B) {
 370   // CHECK-LABEL: test_mm_comi_round_sh
 371   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 8)
 372   return _mm_comi_round_sh(__A, __B, 0, _MM_FROUND_NO_EXC);
 373 }
 374
 375 int test_mm_comi_sh(__m128h __A, __m128h __B) {
 376   // CHECK-LABEL: test_mm_comi_sh
 377   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 4)
 378   return _mm_comi_sh(__A, __B, 0);
 379 }
 380
 381 int test_mm_comieq_sh(__m128h __A, __m128h __B) {
 382   // CHECK-LABEL: test_mm_comieq_sh
 383   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 16, i32 4)
 384   return _mm_comieq_sh(__A, __B);
 385 }
 386
 387 int test_mm_comilt_sh(__m128h __A, __m128h __B) {
 388   // CHECK-LABEL: test_mm_comilt_sh
 389   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 1, i32 4)
 390   return _mm_comilt_sh(__A, __B);
 391 }
 392
 393 int test_mm_comile_sh(__m128h __A, __m128h __B) {
 394   // CHECK-LABEL: test_mm_comile_sh
 395   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 2, i32 4)
 396   return _mm_comile_sh(__A, __B);
 397 }
 398
 399 int test_mm_comigt_sh(__m128h __A, __m128h __B) {
 400   // CHECK-LABEL: test_mm_comigt_sh
 401   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 14, i32 4)
 402   return _mm_comigt_sh(__A, __B);
 403 }
 404
 405 int test_mm_comige_sh(__m128h __A, __m128h __B) {
 406   // CHECK-LABEL: test_mm_comige_sh
 407   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 13, i32 4)
 408   return _mm_comige_sh(__A, __B);
 409 }
 410
 411 int test_mm_comineq_sh(__m128h __A, __m128h __B) {
 412   // CHECK-LABEL: test_mm_comineq_sh
 413   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 20, i32 4)
 414   return _mm_comineq_sh(__A, __B);
 415 }
 416
 417 int test_mm_ucomieq_sh(__m128h __A, __m128h __B) {
 418   // CHECK-LABEL: test_mm_ucomieq_sh
 419   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 4)
 420   return _mm_ucomieq_sh(__A, __B);
 421 }
 422
 423 int test_mm_ucomilt_sh(__m128h __A, __m128h __B) {
 424   // CHECK-LABEL: test_mm_ucomilt_sh
 425   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 17, i32 4)
 426   return _mm_ucomilt_sh(__A, __B);
 427 }
 428
 429 int test_mm_ucomile_sh(__m128h __A, __m128h __B) {
 430   // CHECK-LABEL: test_mm_ucomile_sh
 431   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 18, i32 4)
 432   return _mm_ucomile_sh(__A, __B);
 433 }
 434
 435 int test_mm_ucomigt_sh(__m128h __A, __m128h __B) {
 436   // CHECK-LABEL: test_mm_ucomigt_sh
 437   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 30, i32 4)
 438   return _mm_ucomigt_sh(__A, __B);
 439 }
 440
 441 int test_mm_ucomige_sh(__m128h __A, __m128h __B) {
 442   // CHECK-LABEL: test_mm_ucomige_sh
 443   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 29, i32 4)
 444   return _mm_ucomige_sh(__A, __B);
 445 }
 446
 447 int test_mm_ucomineq_sh(__m128h __A, __m128h __B) {
 448   // CHECK-LABEL: test_mm_ucomineq_sh
 449   // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 4, i32 4)
 450   return _mm_ucomineq_sh(__A, __B);
 451 }
 452
 453 __m512h test_mm512_add_ph(__m512h __A, __m512h __B) {
 454   // CHECK-LABEL: @test_mm512_add_ph
 455   // CHECK: %{{.*}} = fadd <32 x half> %{{.*}}, %{{.*}}
 456   return _mm512_add_ph(__A, __B);
 457 }
 458
 459 __m512h test_mm512_mask_add_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 460   // CHECK-LABEL: @test_mm512_mask_add_ph
 461   // CHECK: %{{.*}} = fadd <32 x half> %{{.*}}, %{{.*}}
 462   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 463   return (__m512h)_mm512_mask_add_ph(__W, __U, __A, __B);
 464 }
 465
 466 __m512h test_mm512_maskz_add_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 467   // CHECK-LABEL: @test_mm512_maskz_add_ph
 468   // CHECK: %{{.*}} = fadd <32 x half> %{{.*}}, %{{.*}}
 469   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 470   return _mm512_maskz_add_ph(__U, __A, __B);
 471 }
 472
 473 __m512h test_mm512_add_round_ph(__m512h __A, __m512h __B) {
 474   // CHECK-LABEL: @test_mm512_add_round_ph
 475   // CHECK: @llvm.x86.avx512fp16.add.ph.512
 476   return _mm512_add_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 477 }
 478 __m512h test_mm512_mask_add_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 479   // CHECK-LABEL: @test_mm512_mask_add_round_ph
 480   // CHECK: @llvm.x86.avx512fp16.add.ph.512
 481   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 482   return _mm512_mask_add_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 483 }
 484 __m512h test_mm512_maskz_add_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 485   // CHECK-LABEL: @test_mm512_maskz_add_round_ph
 486   // CHECK: @llvm.x86.avx512fp16.add.ph.512
 487   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 488   return _mm512_maskz_add_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 489 }
 490
 491 __m512h test_mm512_sub_ph(__m512h __A, __m512h __B) {
 492   // CHECK-LABEL: @test_mm512_sub_ph
 493   // CHECK: %{{.*}} = fsub <32 x half> %{{.*}}, %{{.*}}
 494   return _mm512_sub_ph(__A, __B);
 495 }
 496
 497 __m512h test_mm512_mask_sub_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 498   // CHECK-LABEL: @test_mm512_mask_sub_ph
 499   // CHECK: %{{.*}} = fsub <32 x half> %{{.*}}, %{{.*}}
 500   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 501   return (__m512h)_mm512_mask_sub_ph(__W, __U, __A, __B);
 502 }
 503
 504 __m512h test_mm512_maskz_sub_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 505   // CHECK-LABEL: @test_mm512_maskz_sub_ph
 506   // CHECK: %{{.*}} = fsub <32 x half> %{{.*}}, %{{.*}}
 507   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 508   return _mm512_maskz_sub_ph(__U, __A, __B);
 509 }
 510
 511 __m512h test_mm512_sub_round_ph(__m512h __A, __m512h __B) {
 512   // CHECK-LABEL: @test_mm512_sub_round_ph
 513   // CHECK: @llvm.x86.avx512fp16.sub.ph.512
 514   return _mm512_sub_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 515 }
 516 __m512h test_mm512_mask_sub_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 517   // CHECK-LABEL: @test_mm512_mask_sub_round_ph
 518   // CHECK: @llvm.x86.avx512fp16.sub.ph.512
 519   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 520   return _mm512_mask_sub_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 521 }
 522 __m512h test_mm512_maskz_sub_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 523   // CHECK-LABEL: @test_mm512_maskz_sub_round_ph
 524   // CHECK: @llvm.x86.avx512fp16.sub.ph.512
 525   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 526   return _mm512_maskz_sub_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 527 }
 528
 529 __m512h test_mm512_mul_ph(__m512h __A, __m512h __B) {
 530   // CHECK-LABEL: @test_mm512_mul_ph
 531   // CHECK: %{{.*}} = fmul <32 x half> %{{.*}}, %{{.*}}
 532   return _mm512_mul_ph(__A, __B);
 533 }
 534
 535 __m512h test_mm512_mask_mul_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 536   // CHECK-LABEL: @test_mm512_mask_mul_ph
 537   // CHECK: %{{.*}} = fmul <32 x half> %{{.*}}, %{{.*}}
 538   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 539   return (__m512h)_mm512_mask_mul_ph(__W, __U, __A, __B);
 540 }
 541
 542 __m512h test_mm512_maskz_mul_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 543   // CHECK-LABEL: @test_mm512_maskz_mul_ph
 544   // CHECK: %{{.*}} = fmul <32 x half> %{{.*}}, %{{.*}}
 545   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 546   return _mm512_maskz_mul_ph(__U, __A, __B);
 547 }
 548
 549 __m512h test_mm512_mul_round_ph(__m512h __A, __m512h __B) {
 550   // CHECK-LABEL: @test_mm512_mul_round_ph
 551   // CHECK: @llvm.x86.avx512fp16.mul.ph.512
 552   return _mm512_mul_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 553 }
 554 __m512h test_mm512_mask_mul_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 555   // CHECK-LABEL: @test_mm512_mask_mul_round_ph
 556   // CHECK: @llvm.x86.avx512fp16.mul.ph.512
 557   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 558   return _mm512_mask_mul_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 559 }
 560 __m512h test_mm512_maskz_mul_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 561   // CHECK-LABEL: @test_mm512_maskz_mul_round_ph
 562   // CHECK: @llvm.x86.avx512fp16.mul.ph.512
 563   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 564   return _mm512_maskz_mul_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 565 }
 566
 567 __m512h test_mm512_div_ph(__m512h __A, __m512h __B) {
 568   // CHECK-LABEL: @test_mm512_div_ph
 569   // CHECK: %{{.*}} = fdiv <32 x half> %{{.*}}, %{{.*}}
 570   return _mm512_div_ph(__A, __B);
 571 }
 572
 573 __m512h test_mm512_mask_div_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 574   // CHECK-LABEL: @test_mm512_mask_div_ph
 575   // CHECK: %{{.*}} = fdiv <32 x half> %{{.*}}, %{{.*}}
 576   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 577   return (__m512h)_mm512_mask_div_ph(__W, __U, __A, __B);
 578 }
 579
 580 __m512h test_mm512_maskz_div_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 581   // CHECK-LABEL: @test_mm512_maskz_div_ph
 582   // CHECK: %{{.*}} = fdiv <32 x half> %{{.*}}, %{{.*}}
 583   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 584   return _mm512_maskz_div_ph(__U, __A, __B);
 585 }
 586
 587 __m512h test_mm512_div_round_ph(__m512h __A, __m512h __B) {
 588   // CHECK-LABEL: @test_mm512_div_round_ph
 589   // CHECK: @llvm.x86.avx512fp16.div.ph.512
 590   return _mm512_div_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 591 }
 592 __m512h test_mm512_mask_div_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 593   // CHECK-LABEL: @test_mm512_mask_div_round_ph
 594   // CHECK: @llvm.x86.avx512fp16.div.ph.512
 595   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 596   return _mm512_mask_div_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 597 }
 598 __m512h test_mm512_maskz_div_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 599   // CHECK-LABEL: @test_mm512_maskz_div_round_ph
 600   // CHECK: @llvm.x86.avx512fp16.div.ph.512
 601   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 602   return _mm512_maskz_div_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 603 }
 604
 605 __m512h test_mm512_min_ph(__m512h __A, __m512h __B) {
 606   // CHECK-LABEL: @test_mm512_min_ph
 607   // CHECK: @llvm.x86.avx512fp16.min.ph.512
 608   return _mm512_min_ph(__A, __B);
 609 }
 610
 611 __m512h test_mm512_mask_min_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 612   // CHECK-LABEL: @test_mm512_mask_min_ph
 613   // CHECK: @llvm.x86.avx512fp16.min.ph.512
 614   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 615   return (__m512h)_mm512_mask_min_ph(__W, __U, __A, __B);
 616 }
 617
 618 __m512h test_mm512_maskz_min_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 619   // CHECK-LABEL: @test_mm512_maskz_min_ph
 620   // CHECK: @llvm.x86.avx512fp16.min.ph.512
 621   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 622   return _mm512_maskz_min_ph(__U, __A, __B);
 623 }
 624
 625 __m512h test_mm512_min_round_ph(__m512h __A, __m512h __B) {
 626   // CHECK-LABEL: @test_mm512_min_round_ph
 627   // CHECK: @llvm.x86.avx512fp16.min.ph.512
 628   return _mm512_min_round_ph(__A, __B, _MM_FROUND_NO_EXC);
 629 }
 630 __m512h test_mm512_mask_min_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 631   // CHECK-LABEL: @test_mm512_mask_min_round_ph
 632   // CHECK: @llvm.x86.avx512fp16.min.ph.512
 633   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 634   return _mm512_mask_min_round_ph(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
 635 }
 636 __m512h test_mm512_maskz_min_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 637   // CHECK-LABEL: @test_mm512_maskz_min_round_ph
 638   // CHECK: @llvm.x86.avx512fp16.min.ph.512
 639   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 640   return _mm512_maskz_min_round_ph(__U, __A, __B, _MM_FROUND_NO_EXC);
 641 }
 642
 643 __m512h test_mm512_max_ph(__m512h __A, __m512h __B) {
 644   // CHECK-LABEL: @test_mm512_max_ph
 645   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 646
 647   return _mm512_max_ph(__A, __B);
 648 }
 649
 650 __m512h test_mm512_mask_max_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 651   // CHECK-LABEL: @test_mm512_mask_max_ph
 652   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 653   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 654   return (__m512h)_mm512_mask_max_ph(__W, __U, __A, __B);
 655 }
 656
 657 __m512h test_mm512_maskz_max_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 658   // CHECK-LABEL: @test_mm512_maskz_max_ph
 659   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 660   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 661   return _mm512_maskz_max_ph(__U, __A, __B);
 662 }
 663
 664 __m512h test_mm512_max_round_ph(__m512h __A, __m512h __B) {
 665   // CHECK-LABEL: @test_mm512_max_round_ph
 666   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 667   return _mm512_max_round_ph(__A, __B, _MM_FROUND_NO_EXC);
 668 }
 669
 670 __m512h test_mm512_mask_max_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
 671   // CHECK-LABEL: @test_mm512_mask_max_round_ph
 672   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 673   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 674   return _mm512_mask_max_round_ph(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
 675 }
 676
 677 __m512h test_mm512_maskz_max_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
 678   // CHECK-LABEL: @test_mm512_maskz_max_round_ph
 679   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 680   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
 681   return _mm512_maskz_max_round_ph(__U, __A, __B, _MM_FROUND_NO_EXC);
 682 }
 683
 684 __m512h test_mm512_abs_ph(__m512h a) {
 685   // CHECK-LABEL: @test_mm512_abs_ph
 686   // CHECK: and <16 x i32>
 687   return _mm512_abs_ph(a);
 688 }
 689
 690 __m512h test_mm512_conj_pch(__m512h __A) {
 691   // CHECK-LABEL: @test_mm512_conj_pch
 692   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <16 x float>
 693   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <16 x i32>
 694   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <16 x i32>
 695   // CHECK:  %{{.*}} = xor <16 x i32> %{{.*}}, %{{.*}}
 696   // CHECK:  %{{.*}} = bitcast <16 x i32> %{{.*}} to <16 x float>
 697   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <32 x half>
 698   return _mm512_conj_pch(__A);
 699 }
 700
 701 __m512h test_mm512_mask_conj_pch(__m512h __W, __mmask32 __U, __m512h __A) {
 702   // CHECK-LABEL: @test_mm512_mask_conj_pch
 703   // CHECK:  %{{.*}} = trunc i32 %{{.*}} to i16
 704   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <16 x float>
 705   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <16 x i32>
 706   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <16 x i32>
 707   // CHECK:  %{{.*}} = xor <16 x i32> %{{.*}}, %{{.*}}
 708   // CHECK:  %{{.*}} = bitcast <16 x i32> %{{.*}} to <16 x float>
 709   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <32 x half>
 710   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <16 x float>
 711   // CHECK:  %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
 712   // CHECK:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
 713   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <32 x half>
 714   return _mm512_mask_conj_pch(__W, __U, __A);
 715 }
 716
 717 __m512h test_mm512_maskz_conj_pch(__mmask32 __U, __m512h __A) {
 718   // CHECK-LABEL: @test_mm512_maskz_conj_pch
 719   // CHECK:  %{{.*}} = trunc i32 %{{.*}} to i16
 720   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <16 x float>
 721   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <16 x i32>
 722   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <16 x i32>
 723   // CHECK:  %{{.*}} = xor <16 x i32> %{{.*}}, %{{.*}}
 724   // CHECK:  %{{.*}} = bitcast <16 x i32> %{{.*}} to <16 x float>
 725   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <32 x half>
 726   // CHECK:  %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
 727   // CHECK:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
 728   // CHECK:  %{{.*}} = bitcast <16 x float> %{{.*}} to <32 x half>
 729   return _mm512_maskz_conj_pch(__U, __A);
 730 }
 731
 732 __m128h test_mm_add_round_sh(__m128h __A, __m128h __B) {
 733   // CHECK-LABEL: @test_mm_add_round_sh
 734   // CHECK: @llvm.x86.avx512fp16.mask.add.sh.round
 735   return _mm_add_round_sh(__A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 736 }
 737 __m128h test_mm_mask_add_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 738   // CHECK-LABEL: @test_mm_mask_add_round_sh
 739   // CHECK: @llvm.x86.avx512fp16.mask.add.sh.round
 740   return _mm_mask_add_round_sh(__W, __U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 741 }
 742 __m128h test_mm_maskz_add_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 743   // CHECK-LABEL: @test_mm_maskz_add_round_sh
 744   // CHECK: @llvm.x86.avx512fp16.mask.add.sh.round
 745   return _mm_maskz_add_round_sh(__U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 746 }
 747 __m128h test_mm_mask_add_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 748   // CHECK-LABEL: @test_mm_mask_add_sh
 749   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 750   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 751   // CHECK: %{{.*}} = fadd half %{{.*}}, %{{.*}}
 752   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 753   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 754   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 755   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 756   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 757   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 758   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 759   return _mm_mask_add_sh(__W, __U, __A, __B);
 760 }
 761 __m128h test_mm_maskz_add_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 762   // CHECK-LABEL: @test_mm_maskz_add_sh
 763   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 764   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 765   // CHECK: %{{.*}} = fadd half %{{.*}}, %{{.*}}
 766   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 767   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 768   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 769   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 770   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 771   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 772   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 773   return _mm_maskz_add_sh(__U, __A, __B);
 774 }
 775
 776 __m128h test_mm_add_sh(__m128h __A, __m128h __B) {
 777   // CHECK-LABEL: @test_mm_add_sh
 778   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 779   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 780   // CHECK: %{{.*}} = fadd half %{{.*}}, %{{.*}}
 781   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 782   return _mm_add_sh(__A, __B);
 783 }
 784
 785 __m128h test_mm_sub_round_sh(__m128h __A, __m128h __B) {
 786   // CHECK-LABEL: @test_mm_sub_round_sh
 787   // CHECK: @llvm.x86.avx512fp16.mask.sub.sh.round
 788   return _mm_sub_round_sh(__A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 789 }
 790 __m128h test_mm_mask_sub_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 791   // CHECK-LABEL: @test_mm_mask_sub_round_sh
 792   // CHECK: @llvm.x86.avx512fp16.mask.sub.sh.round
 793   return _mm_mask_sub_round_sh(__W, __U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 794 }
 795 __m128h test_mm_maskz_sub_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 796   // CHECK-LABEL: @test_mm_maskz_sub_round_sh
 797   // CHECK: @llvm.x86.avx512fp16.mask.sub.sh.round
 798   return _mm_maskz_sub_round_sh(__U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 799 }
 800 __m128h test_mm_mask_sub_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 801   // CHECK-LABEL: @test_mm_mask_sub_sh
 802   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 803   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 804   // CHECK: %{{.*}} = fsub half %{{.*}}, %{{.*}}
 805   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 806   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 807   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 808   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 809   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 810   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 811   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 812   return _mm_mask_sub_sh(__W, __U, __A, __B);
 813 }
 814 __m128h test_mm_maskz_sub_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 815   // CHECK-LABEL: @test_mm_maskz_sub_sh
 816   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 817   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 818   // CHECK: %{{.*}} = fsub half %{{.*}}, %{{.*}}
 819   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 820   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 821   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 822   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 823   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 824   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 825   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 826   return _mm_maskz_sub_sh(__U, __A, __B);
 827 }
 828
 829 __m128h test_mm_sub_sh(__m128h __A, __m128h __B) {
 830   // CHECK-LABEL: @test_mm_sub_sh
 831   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 832   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 833   // CHECK: %{{.*}} = fsub half %{{.*}}, %{{.*}}
 834   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 835   return _mm_sub_sh(__A, __B);
 836 }
 837
 838 __m128h test_mm_mul_round_sh(__m128h __A, __m128h __B) {
 839   // CHECK-LABEL: @test_mm_mul_round_sh
 840   // CHECK: @llvm.x86.avx512fp16.mask.mul.sh.round
 841   return _mm_mul_round_sh(__A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 842 }
 843 __m128h test_mm_mask_mul_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 844   // CHECK-LABEL: @test_mm_mask_mul_round_sh
 845   // CHECK: @llvm.x86.avx512fp16.mask.mul.sh.round
 846   return _mm_mask_mul_round_sh(__W, __U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 847 }
 848 __m128h test_mm_maskz_mul_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 849   // CHECK-LABEL: @test_mm_maskz_mul_round_sh
 850   // CHECK: @llvm.x86.avx512fp16.mask.mul.sh.round
 851   return _mm_maskz_mul_round_sh(__U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 852 }
 853 __m128h test_mm_mask_mul_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 854   // CHECK-LABEL: @test_mm_mask_mul_sh
 855   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 856   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 857   // CHECK: %{{.*}} = fmul half %{{.*}}, %{{.*}}
 858   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 859   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 860   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 861   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 862   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 863   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 864   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 865   return _mm_mask_mul_sh(__W, __U, __A, __B);
 866 }
 867 __m128h test_mm_maskz_mul_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 868   // CHECK-LABEL: @test_mm_maskz_mul_sh
 869   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 870   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 871   // CHECK: %{{.*}} = fmul half %{{.*}}, %{{.*}}
 872   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 873   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 874   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 875   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 876   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 877   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 878   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 879   return _mm_maskz_mul_sh(__U, __A, __B);
 880 }
 881
 882 __m128h test_mm_mul_sh(__m128h __A, __m128h __B) {
 883   // CHECK-LABEL: @test_mm_mul_sh
 884   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 885   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 886   // CHECK: %{{.*}} = fmul half %{{.*}}, %{{.*}}
 887   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 888   return _mm_mul_sh(__A, __B);
 889 }
 890
 891 __m128h test_mm_div_round_sh(__m128h __A, __m128h __B) {
 892   // CHECK-LABEL: @test_mm_div_round_sh
 893   // CHECK: @llvm.x86.avx512fp16.mask.div.sh.round
 894   return _mm_div_round_sh(__A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 895 }
 896 __m128h test_mm_mask_div_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 897   // CHECK-LABEL: @test_mm_mask_div_round_sh
 898   // CHECK: @llvm.x86.avx512fp16.mask.div.sh.round
 899   return _mm_mask_div_round_sh(__W, __U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 900 }
 901 __m128h test_mm_maskz_div_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 902   // CHECK-LABEL: @test_mm_maskz_div_round_sh
 903   // CHECK: @llvm.x86.avx512fp16.mask.div.sh.round
 904   return _mm_maskz_div_round_sh(__U, __A, __B, _MM_FROUND_NO_EXC | _MM_FROUND_TO_ZERO);
 905 }
 906 __m128h test_mm_mask_div_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 907   // CHECK-LABEL: @test_mm_mask_div_sh
 908   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 909   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 910   // CHECK: %{{.*}} = fdiv half %{{.*}}, %{{.*}}
 911   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 912   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 913   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 914   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 915   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 916   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 917   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 918   return _mm_mask_div_sh(__W, __U, __A, __B);
 919 }
 920 __m128h test_mm_maskz_div_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 921   // CHECK-LABEL: @test_mm_maskz_div_sh
 922   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 923   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 924   // CHECK: %{{.*}} = fdiv half %{{.*}}, %{{.*}}
 925   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 926   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 927   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
 928   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 929   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
 930   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
 931   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
 932   return _mm_maskz_div_sh(__U, __A, __B);
 933 }
 934
 935 __m128h test_mm_div_sh(__m128h __A, __m128h __B) {
 936   // CHECK-LABEL: @test_mm_div_sh
 937   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 938   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i32 0
 939   // CHECK: %{{.*}} = fdiv half %{{.*}}, %{{.*}}
 940   // CHECK: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
 941   return _mm_div_sh(__A, __B);
 942 }
 943
 944 __m128h test_mm_min_round_sh(__m128h __A, __m128h __B) {
 945   // CHECK-LABEL: @test_mm_min_round_sh
 946   // CHECK: @llvm.x86.avx512fp16.mask.min.sh.round
 947   return _mm_min_round_sh(__A, __B, 0x08);
 948 }
 949 __m128h test_mm_mask_min_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 950   // CHECK-LABEL: @test_mm_mask_min_round_sh
 951   // CHECK: @llvm.x86.avx512fp16.mask.min.sh.round
 952   return _mm_mask_min_round_sh(__W, __U, __A, __B, 0x08);
 953 }
 954 __m128h test_mm_maskz_min_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 955   // CHECK-LABEL: @test_mm_maskz_min_round_sh
 956   // CHECK: @llvm.x86.avx512fp16.mask.min.sh.round
 957   return _mm_maskz_min_round_sh(__U, __A, __B, 0x08);
 958 }
 959 __m128h test_mm_mask_min_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 960   // CHECK-LABEL: @test_mm_mask_min_sh
 961   // CHECK: @llvm.x86.avx512fp16.mask.min.sh.round
 962   return _mm_mask_min_sh(__W, __U, __A, __B);
 963 }
 964 __m128h test_mm_maskz_min_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 965   // CHECK-LABEL: @test_mm_maskz_min_sh
 966   // CHECK: @llvm.x86.avx512fp16.mask.min.sh.round
 967   return _mm_maskz_min_sh(__U, __A, __B);
 968 }
 969
 970 __m128h test_mm_min_sh(__m128h __A, __m128h __B) {
 971   // CHECK-LABEL: @test_mm_min_sh
 972   // CHECK: @llvm.x86.avx512fp16.mask.min.sh.round
 973   return _mm_min_sh(__A, __B);
 974 }
 975
 976 __m128h test_mm_max_round_sh(__m128h __A, __m128h __B) {
 977   // CHECK-LABEL: @test_mm_max_round_sh
 978   // CHECK: @llvm.x86.avx512fp16.mask.max.sh.round
 979   return _mm_max_round_sh(__A, __B, 0x08);
 980 }
 981 __m128h test_mm_mask_max_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 982   // CHECK-LABEL: @test_mm_mask_max_round_sh
 983   // CHECK: @llvm.x86.avx512fp16.mask.max.sh.round
 984   return _mm_mask_max_round_sh(__W, __U, __A, __B, 0x08);
 985 }
 986 __m128h test_mm_maskz_max_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 987   // CHECK-LABEL: @test_mm_maskz_max_round_sh
 988   // CHECK: @llvm.x86.avx512fp16.mask.max.sh.round
 989   return _mm_maskz_max_round_sh(__U, __A, __B, 0x08);
 990 }
 991 __m128h test_mm_mask_max_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
 992   // CHECK-LABEL: @test_mm_mask_max_sh
 993   // CHECK: @llvm.x86.avx512fp16.mask.max.sh.round
 994   return _mm_mask_max_sh(__W, __U, __A, __B);
 995 }
 996 __m128h test_mm_maskz_max_sh(__mmask8 __U, __m128h __A, __m128h __B) {
 997   // CHECK-LABEL: @test_mm_maskz_max_sh
 998   // CHECK: @llvm.x86.avx512fp16.mask.max.sh.round
 999   return _mm_maskz_max_sh(__U, __A, __B);
1000 }
1001
1002 __m128h test_mm_max_sh(__m128h __A, __m128h __B) {
1003   // CHECK-LABEL: @test_mm_max_sh
1004   // CHECK: @llvm.x86.avx512fp16.mask.max.sh.round
1005   return _mm_max_sh(__A, __B);
1006 }
1007 __mmask32 test_mm512_cmp_round_ph_mask(__m512h a, __m512h b) {
1008   // CHECK-LABEL: @test_mm512_cmp_round_ph_mask
1009   // CHECK: fcmp oeq <32 x half> %{{.*}}, %{{.*}}
1010   return _mm512_cmp_round_ph_mask(a, b, 0, _MM_FROUND_NO_EXC);
1011 }
1012
1013 __mmask32 test_mm512_mask_cmp_round_ph_mask(__mmask32 m, __m512h a, __m512h b) {
1014   // CHECK-LABEL: @test_mm512_mask_cmp_round_ph_mask
1015   // CHECK: [[CMP:%.*]] = fcmp oeq <32 x half> %{{.*}}, %{{.*}}
1016   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1017   return _mm512_mask_cmp_round_ph_mask(m, a, b, 0, _MM_FROUND_NO_EXC);
1018 }
1019
1020 __mmask32 test_mm512_cmp_ph_mask_eq_oq(__m512h a, __m512h b) {
1021   // CHECK-LABEL: @test_mm512_cmp_ph_mask_eq_oq
1022   // CHECK: fcmp oeq <32 x half> %{{.*}}, %{{.*}}
1023   return _mm512_cmp_ph_mask(a, b, _CMP_EQ_OQ);
1024 }
1025
1026 __mmask32 test_mm512_cmp_ph_mask_lt_os(__m512h a, __m512h b) {
1027   // CHECK-LABEL: test_mm512_cmp_ph_mask_lt_os
1028   // CHECK: fcmp olt <32 x half> %{{.*}}, %{{.*}}
1029   return _mm512_cmp_ph_mask(a, b, _CMP_LT_OS);
1030 }
1031
1032 __mmask32 test_mm512_cmp_ph_mask_le_os(__m512h a, __m512h b) {
1033   // CHECK-LABEL: test_mm512_cmp_ph_mask_le_os
1034   // CHECK: fcmp ole <32 x half> %{{.*}}, %{{.*}}
1035   return _mm512_cmp_ph_mask(a, b, _CMP_LE_OS);
1036 }
1037
1038 __mmask32 test_mm512_cmp_ph_mask_unord_q(__m512h a, __m512h b) {
1039   // CHECK-LABEL: test_mm512_cmp_ph_mask_unord_q
1040   // CHECK: fcmp uno <32 x half> %{{.*}}, %{{.*}}
1041   return _mm512_cmp_ph_mask(a, b, _CMP_UNORD_Q);
1042 }
1043
1044 __mmask32 test_mm512_cmp_ph_mask_neq_uq(__m512h a, __m512h b) {
1045   // CHECK-LABEL: test_mm512_cmp_ph_mask_neq_uq
1046   // CHECK: fcmp une <32 x half> %{{.*}}, %{{.*}}
1047   return _mm512_cmp_ph_mask(a, b, _CMP_NEQ_UQ);
1048 }
1049
1050 __mmask32 test_mm512_cmp_ph_mask_nlt_us(__m512h a, __m512h b) {
1051   // CHECK-LABEL: test_mm512_cmp_ph_mask_nlt_us
1052   // CHECK: fcmp uge <32 x half> %{{.*}}, %{{.*}}
1053   return _mm512_cmp_ph_mask(a, b, _CMP_NLT_US);
1054 }
1055
1056 __mmask32 test_mm512_cmp_ph_mask_nle_us(__m512h a, __m512h b) {
1057   // CHECK-LABEL: test_mm512_cmp_ph_mask_nle_us
1058   // CHECK: fcmp ugt <32 x half> %{{.*}}, %{{.*}}
1059   return _mm512_cmp_ph_mask(a, b, _CMP_NLE_US);
1060 }
1061
1062 __mmask32 test_mm512_cmp_ph_mask_ord_q(__m512h a, __m512h b) {
1063   // CHECK-LABEL: test_mm512_cmp_ph_mask_ord_q
1064   // CHECK: fcmp ord <32 x half> %{{.*}}, %{{.*}}
1065   return _mm512_cmp_ph_mask(a, b, _CMP_ORD_Q);
1066 }
1067
1068 __mmask32 test_mm512_cmp_ph_mask_eq_uq(__m512h a, __m512h b) {
1069   // CHECK-LABEL: test_mm512_cmp_ph_mask_eq_uq
1070   // CHECK: fcmp ueq <32 x half> %{{.*}}, %{{.*}}
1071   return _mm512_cmp_ph_mask(a, b, _CMP_EQ_UQ);
1072 }
1073
1074 __mmask32 test_mm512_cmp_ph_mask_nge_us(__m512h a, __m512h b) {
1075   // CHECK-LABEL: test_mm512_cmp_ph_mask_nge_us
1076   // CHECK: fcmp ult <32 x half> %{{.*}}, %{{.*}}
1077   return _mm512_cmp_ph_mask(a, b, _CMP_NGE_US);
1078 }
1079
1080 __mmask32 test_mm512_cmp_ph_mask_ngt_us(__m512h a, __m512h b) {
1081   // CHECK-LABEL: test_mm512_cmp_ph_mask_ngt_us
1082   // CHECK: fcmp ule <32 x half> %{{.*}}, %{{.*}}
1083   return _mm512_cmp_ph_mask(a, b, _CMP_NGT_US);
1084 }
1085
1086 __mmask32 test_mm512_cmp_ph_mask_false_oq(__m512h a, __m512h b) {
1087   // CHECK-LABEL: test_mm512_cmp_ph_mask_false_oq
1088   // CHECK: fcmp false <32 x half> %{{.*}}, %{{.*}}
1089   return _mm512_cmp_ph_mask(a, b, _CMP_FALSE_OQ);
1090 }
1091
1092 __mmask32 test_mm512_cmp_ph_mask_neq_oq(__m512h a, __m512h b) {
1093   // CHECK-LABEL: test_mm512_cmp_ph_mask_neq_oq
1094   // CHECK: fcmp one <32 x half> %{{.*}}, %{{.*}}
1095   return _mm512_cmp_ph_mask(a, b, _CMP_NEQ_OQ);
1096 }
1097
1098 __mmask32 test_mm512_cmp_ph_mask_ge_os(__m512h a, __m512h b) {
1099   // CHECK-LABEL: test_mm512_cmp_ph_mask_ge_os
1100   // CHECK: fcmp oge <32 x half> %{{.*}}, %{{.*}}
1101   return _mm512_cmp_ph_mask(a, b, _CMP_GE_OS);
1102 }
1103
1104 __mmask32 test_mm512_cmp_ph_mask_gt_os(__m512h a, __m512h b) {
1105   // CHECK-LABEL: test_mm512_cmp_ph_mask_gt_os
1106   // CHECK: fcmp ogt <32 x half> %{{.*}}, %{{.*}}
1107   return _mm512_cmp_ph_mask(a, b, _CMP_GT_OS);
1108 }
1109
1110 __mmask32 test_mm512_cmp_ph_mask_true_uq(__m512h a, __m512h b) {
1111   // CHECK-LABEL: test_mm512_cmp_ph_mask_true_uq
1112   // CHECK: fcmp true <32 x half> %{{.*}}, %{{.*}}
1113   return _mm512_cmp_ph_mask(a, b, _CMP_TRUE_UQ);
1114 }
1115
1116 __mmask32 test_mm512_cmp_ph_mask_eq_os(__m512h a, __m512h b) {
1117   // CHECK-LABEL: test_mm512_cmp_ph_mask_eq_os
1118   // CHECK: fcmp oeq <32 x half> %{{.*}}, %{{.*}}
1119   return _mm512_cmp_ph_mask(a, b, _CMP_EQ_OS);
1120 }
1121
1122 __mmask32 test_mm512_cmp_ph_mask_lt_oq(__m512h a, __m512h b) {
1123   // CHECK-LABEL: test_mm512_cmp_ph_mask_lt_oq
1124   // CHECK: fcmp olt <32 x half> %{{.*}}, %{{.*}}
1125   return _mm512_cmp_ph_mask(a, b, _CMP_LT_OQ);
1126 }
1127
1128 __mmask32 test_mm512_cmp_ph_mask_le_oq(__m512h a, __m512h b) {
1129   // CHECK-LABEL: test_mm512_cmp_ph_mask_le_oq
1130   // CHECK: fcmp ole <32 x half> %{{.*}}, %{{.*}}
1131   return _mm512_cmp_ph_mask(a, b, _CMP_LE_OQ);
1132 }
1133
1134 __mmask32 test_mm512_cmp_ph_mask_unord_s(__m512h a, __m512h b) {
1135   // CHECK-LABEL: test_mm512_cmp_ph_mask_unord_s
1136   // CHECK: fcmp uno <32 x half> %{{.*}}, %{{.*}}
1137   return _mm512_cmp_ph_mask(a, b, _CMP_UNORD_S);
1138 }
1139
1140 __mmask32 test_mm512_cmp_ph_mask_neq_us(__m512h a, __m512h b) {
1141   // CHECK-LABEL: test_mm512_cmp_ph_mask_neq_us
1142   // CHECK: fcmp une <32 x half> %{{.*}}, %{{.*}}
1143   return _mm512_cmp_ph_mask(a, b, _CMP_NEQ_US);
1144 }
1145
1146 __mmask32 test_mm512_cmp_ph_mask_nlt_uq(__m512h a, __m512h b) {
1147   // CHECK-LABEL: test_mm512_cmp_ph_mask_nlt_uq
1148   // CHECK: fcmp uge <32 x half> %{{.*}}, %{{.*}}
1149   return _mm512_cmp_ph_mask(a, b, _CMP_NLT_UQ);
1150 }
1151
1152 __mmask32 test_mm512_cmp_ph_mask_nle_uq(__m512h a, __m512h b) {
1153   // CHECK-LABEL: test_mm512_cmp_ph_mask_nle_uq
1154   // CHECK: fcmp ugt <32 x half> %{{.*}}, %{{.*}}
1155   return _mm512_cmp_ph_mask(a, b, _CMP_NLE_UQ);
1156 }
1157
1158 __mmask32 test_mm512_cmp_ph_mask_ord_s(__m512h a, __m512h b) {
1159   // CHECK-LABEL: test_mm512_cmp_ph_mask_ord_s
1160   // CHECK: fcmp ord <32 x half> %{{.*}}, %{{.*}}
1161   return _mm512_cmp_ph_mask(a, b, _CMP_ORD_S);
1162 }
1163
1164 __mmask32 test_mm512_cmp_ph_mask_eq_us(__m512h a, __m512h b) {
1165   // CHECK-LABEL: test_mm512_cmp_ph_mask_eq_us
1166   // CHECK: fcmp ueq <32 x half> %{{.*}}, %{{.*}}
1167   return _mm512_cmp_ph_mask(a, b, _CMP_EQ_US);
1168 }
1169
1170 __mmask32 test_mm512_cmp_ph_mask_nge_uq(__m512h a, __m512h b) {
1171   // CHECK-LABEL: test_mm512_cmp_ph_mask_nge_uq
1172   // CHECK: fcmp ult <32 x half> %{{.*}}, %{{.*}}
1173   return _mm512_cmp_ph_mask(a, b, _CMP_NGE_UQ);
1174 }
1175
1176 __mmask32 test_mm512_cmp_ph_mask_ngt_uq(__m512h a, __m512h b) {
1177   // CHECK-LABEL: test_mm512_cmp_ph_mask_ngt_uq
1178   // CHECK: fcmp ule <32 x half> %{{.*}}, %{{.*}}
1179   return _mm512_cmp_ph_mask(a, b, _CMP_NGT_UQ);
1180 }
1181
1182 __mmask32 test_mm512_cmp_ph_mask_false_os(__m512h a, __m512h b) {
1183   // CHECK-LABEL: test_mm512_cmp_ph_mask_false_os
1184   // CHECK: fcmp false <32 x half> %{{.*}}, %{{.*}}
1185   return _mm512_cmp_ph_mask(a, b, _CMP_FALSE_OS);
1186 }
1187
1188 __mmask32 test_mm512_cmp_ph_mask_neq_os(__m512h a, __m512h b) {
1189   // CHECK-LABEL: test_mm512_cmp_ph_mask_neq_os
1190   // CHECK: fcmp one <32 x half> %{{.*}}, %{{.*}}
1191   return _mm512_cmp_ph_mask(a, b, _CMP_NEQ_OS);
1192 }
1193
1194 __mmask32 test_mm512_cmp_ph_mask_ge_oq(__m512h a, __m512h b) {
1195   // CHECK-LABEL: test_mm512_cmp_ph_mask_ge_oq
1196   // CHECK: fcmp oge <32 x half> %{{.*}}, %{{.*}}
1197   return _mm512_cmp_ph_mask(a, b, _CMP_GE_OQ);
1198 }
1199
1200 __mmask32 test_mm512_cmp_ph_mask_gt_oq(__m512h a, __m512h b) {
1201   // CHECK-LABEL: test_mm512_cmp_ph_mask_gt_oq
1202   // CHECK: fcmp ogt <32 x half> %{{.*}}, %{{.*}}
1203   return _mm512_cmp_ph_mask(a, b, _CMP_GT_OQ);
1204 }
1205
1206 __mmask32 test_mm512_cmp_ph_mask_true_us(__m512h a, __m512h b) {
1207   // CHECK-LABEL: test_mm512_cmp_ph_mask_true_us
1208   // CHECK: fcmp true <32 x half> %{{.*}}, %{{.*}}
1209   return _mm512_cmp_ph_mask(a, b, _CMP_TRUE_US);
1210 }
1211
1212 __mmask32 test_mm512_mask_cmp_ph_mask_eq_oq(__mmask32 m, __m512h a, __m512h b) {
1213   // CHECK-LABEL: @test_mm512_mask_cmp_ph_mask_eq_oq
1214   // CHECK: [[CMP:%.*]] = fcmp oeq <32 x half> %{{.*}}, %{{.*}}
1215   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1216   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OQ);
1217 }
1218
1219 __mmask32 test_mm512_mask_cmp_ph_mask_lt_os(__mmask32 m, __m512h a, __m512h b) {
1220   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_lt_os
1221   // CHECK: [[CMP:%.*]] = fcmp olt <32 x half> %{{.*}}, %{{.*}}
1222   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1223   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_LT_OS);
1224 }
1225
1226 __mmask32 test_mm512_mask_cmp_ph_mask_le_os(__mmask32 m, __m512h a, __m512h b) {
1227   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_le_os
1228   // CHECK: [[CMP:%.*]] = fcmp ole <32 x half> %{{.*}}, %{{.*}}
1229   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1230   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_LE_OS);
1231 }
1232
1233 __mmask32 test_mm512_mask_cmp_ph_mask_unord_q(__mmask32 m, __m512h a, __m512h b) {
1234   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_unord_q
1235   // CHECK: [[CMP:%.*]] = fcmp uno <32 x half> %{{.*}}, %{{.*}}
1236   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1237   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_Q);
1238 }
1239
1240 __mmask32 test_mm512_mask_cmp_ph_mask_neq_uq(__mmask32 m, __m512h a, __m512h b) {
1241   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_uq
1242   // CHECK: [[CMP:%.*]] = fcmp une <32 x half> %{{.*}}, %{{.*}}
1243   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1244   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_UQ);
1245 }
1246
1247 __mmask32 test_mm512_mask_cmp_ph_mask_nlt_us(__mmask32 m, __m512h a, __m512h b) {
1248   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nlt_us
1249   // CHECK: [[CMP:%.*]] = fcmp uge <32 x half> %{{.*}}, %{{.*}}
1250   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1251   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLT_US);
1252 }
1253
1254 __mmask32 test_mm512_mask_cmp_ph_mask_nle_us(__mmask32 m, __m512h a, __m512h b) {
1255   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nle_us
1256   // CHECK: [[CMP:%.*]] = fcmp ugt <32 x half> %{{.*}}, %{{.*}}
1257   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1258   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLE_US);
1259 }
1260
1261 __mmask32 test_mm512_mask_cmp_ph_mask_ord_q(__mmask32 m, __m512h a, __m512h b) {
1262   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ord_q
1263   // CHECK: [[CMP:%.*]] = fcmp ord <32 x half> %{{.*}}, %{{.*}}
1264   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1265   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_ORD_Q);
1266 }
1267
1268 __mmask32 test_mm512_mask_cmp_ph_mask_eq_uq(__mmask32 m, __m512h a, __m512h b) {
1269   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_eq_uq
1270   // CHECK: [[CMP:%.*]] = fcmp ueq <32 x half> %{{.*}}, %{{.*}}
1271   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1272   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_UQ);
1273 }
1274
1275 __mmask32 test_mm512_mask_cmp_ph_mask_nge_us(__mmask32 m, __m512h a, __m512h b) {
1276   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nge_us
1277   // CHECK: [[CMP:%.*]] = fcmp ult <32 x half> %{{.*}}, %{{.*}}
1278   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1279   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGE_US);
1280 }
1281
1282 __mmask32 test_mm512_mask_cmp_ph_mask_ngt_us(__mmask32 m, __m512h a, __m512h b) {
1283   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ngt_us
1284   // CHECK: [[CMP:%.*]] = fcmp ule <32 x half> %{{.*}}, %{{.*}}
1285   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1286   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGT_US);
1287 }
1288
1289 __mmask32 test_mm512_mask_cmp_ph_mask_false_oq(__mmask32 m, __m512h a, __m512h b) {
1290   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_false_oq
1291   // CHECK: [[CMP:%.*]] = fcmp false <32 x half> %{{.*}}, %{{.*}}
1292   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1293   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OQ);
1294 }
1295
1296 __mmask32 test_mm512_mask_cmp_ph_mask_neq_oq(__mmask32 m, __m512h a, __m512h b) {
1297   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_oq
1298   // CHECK: [[CMP:%.*]] = fcmp one <32 x half> %{{.*}}, %{{.*}}
1299   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1300   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OQ);
1301 }
1302
1303 __mmask32 test_mm512_mask_cmp_ph_mask_ge_os(__mmask32 m, __m512h a, __m512h b) {
1304   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ge_os
1305   // CHECK: [[CMP:%.*]] = fcmp oge <32 x half> %{{.*}}, %{{.*}}
1306   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1307   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GE_OS);
1308 }
1309
1310 __mmask32 test_mm512_mask_cmp_ph_mask_gt_os(__mmask32 m, __m512h a, __m512h b) {
1311   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_gt_os
1312   // CHECK: [[CMP:%.*]] = fcmp ogt <32 x half> %{{.*}}, %{{.*}}
1313   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1314   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GT_OS);
1315 }
1316
1317 __mmask32 test_mm512_mask_cmp_ph_mask_true_uq(__mmask32 m, __m512h a, __m512h b) {
1318   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_true_uq
1319   // CHECK: [[CMP:%.*]] = fcmp true <32 x half> %{{.*}}, %{{.*}}
1320   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1321   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_UQ);
1322 }
1323
1324 __mmask32 test_mm512_mask_cmp_ph_mask_eq_os(__mmask32 m, __m512h a, __m512h b) {
1325   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_eq_os
1326   // CHECK: [[CMP:%.*]] = fcmp oeq <32 x half> %{{.*}}, %{{.*}}
1327   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1328   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OS);
1329 }
1330
1331 __mmask32 test_mm512_mask_cmp_ph_mask_lt_oq(__mmask32 m, __m512h a, __m512h b) {
1332   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_lt_oq
1333   // CHECK: [[CMP:%.*]] = fcmp olt <32 x half> %{{.*}}, %{{.*}}
1334   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1335   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_LT_OQ);
1336 }
1337
1338 __mmask32 test_mm512_mask_cmp_ph_mask_le_oq(__mmask32 m, __m512h a, __m512h b) {
1339   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_le_oq
1340   // CHECK: [[CMP:%.*]] = fcmp ole <32 x half> %{{.*}}, %{{.*}}
1341   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1342   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_LE_OQ);
1343 }
1344
1345 __mmask32 test_mm512_mask_cmp_ph_mask_unord_s(__mmask32 m, __m512h a, __m512h b) {
1346   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_unord_s
1347   // CHECK: [[CMP:%.*]] = fcmp uno <32 x half> %{{.*}}, %{{.*}}
1348   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1349   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_S);
1350 }
1351
1352 __mmask32 test_mm512_mask_cmp_ph_mask_neq_us(__mmask32 m, __m512h a, __m512h b) {
1353   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_us
1354   // CHECK: [[CMP:%.*]] = fcmp une <32 x half> %{{.*}}, %{{.*}}
1355   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1356   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_US);
1357 }
1358
1359 __mmask32 test_mm512_mask_cmp_ph_mask_nlt_uq(__mmask32 m, __m512h a, __m512h b) {
1360   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nlt_uq
1361   // CHECK: [[CMP:%.*]] = fcmp uge <32 x half> %{{.*}}, %{{.*}}
1362   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1363   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLT_UQ);
1364 }
1365
1366 __mmask32 test_mm512_mask_cmp_ph_mask_nle_uq(__mmask32 m, __m512h a, __m512h b) {
1367   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nle_uq
1368   // CHECK: [[CMP:%.*]] = fcmp ugt <32 x half> %{{.*}}, %{{.*}}
1369   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1370   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLE_UQ);
1371 }
1372
1373 __mmask32 test_mm512_mask_cmp_ph_mask_ord_s(__mmask32 m, __m512h a, __m512h b) {
1374   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ord_s
1375   // CHECK: [[CMP:%.*]] = fcmp ord <32 x half> %{{.*}}, %{{.*}}
1376   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1377   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_ORD_S);
1378 }
1379
1380 __mmask32 test_mm512_mask_cmp_ph_mask_eq_us(__mmask32 m, __m512h a, __m512h b) {
1381   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_eq_us
1382   // CHECK: [[CMP:%.*]] = fcmp ueq <32 x half> %{{.*}}, %{{.*}}
1383   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1384   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_US);
1385 }
1386
1387 __mmask32 test_mm512_mask_cmp_ph_mask_nge_uq(__mmask32 m, __m512h a, __m512h b) {
1388   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nge_uq
1389   // CHECK: [[CMP:%.*]] = fcmp ult <32 x half> %{{.*}}, %{{.*}}
1390   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1391   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGE_UQ);
1392 }
1393
1394 __mmask32 test_mm512_mask_cmp_ph_mask_ngt_uq(__mmask32 m, __m512h a, __m512h b) {
1395   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ngt_uq
1396   // CHECK: [[CMP:%.*]] = fcmp ule <32 x half> %{{.*}}, %{{.*}}
1397   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1398   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGT_UQ);
1399 }
1400
1401 __mmask32 test_mm512_mask_cmp_ph_mask_false_os(__mmask32 m, __m512h a, __m512h b) {
1402   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_false_os
1403   // CHECK: [[CMP:%.*]] = fcmp false <32 x half> %{{.*}}, %{{.*}}
1404   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1405   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OS);
1406 }
1407
1408 __mmask32 test_mm512_mask_cmp_ph_mask_neq_os(__mmask32 m, __m512h a, __m512h b) {
1409   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_os
1410   // CHECK: [[CMP:%.*]] = fcmp one <32 x half> %{{.*}}, %{{.*}}
1411   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1412   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OS);
1413 }
1414
1415 __mmask32 test_mm512_mask_cmp_ph_mask_ge_oq(__mmask32 m, __m512h a, __m512h b) {
1416   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ge_oq
1417   // CHECK: [[CMP:%.*]] = fcmp oge <32 x half> %{{.*}}, %{{.*}}
1418   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1419   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GE_OQ);
1420 }
1421
1422 __mmask32 test_mm512_mask_cmp_ph_mask_gt_oq(__mmask32 m, __m512h a, __m512h b) {
1423   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_gt_oq
1424   // CHECK: [[CMP:%.*]] = fcmp ogt <32 x half> %{{.*}}, %{{.*}}
1425   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1426   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GT_OQ);
1427 }
1428
1429 __mmask32 test_mm512_mask_cmp_ph_mask_true_us(__mmask32 m, __m512h a, __m512h b) {
1430   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_true_us
1431   // CHECK: [[CMP:%.*]] = fcmp true <32 x half> %{{.*}}, %{{.*}}
1432   // CHECK: and <32 x i1> [[CMP]], {{.*}}
1433   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_US);
1434 }
1435
1436 __mmask8 test_mm_cmp_round_sh_mask(__m128h __X, __m128h __Y) {
1437   // CHECK-LABEL: @test_mm_cmp_round_sh_mask
1438   // CHECK: @llvm.x86.avx512fp16.mask.cmp.sh
1439   return _mm_cmp_round_sh_mask(__X, __Y, _CMP_NLT_US, _MM_FROUND_NO_EXC);
1440 }
1441
1442 __mmask8 test_mm_mask_cmp_round_sh_mask(__mmask8 __M, __m128h __X, __m128h __Y) {
1443   // CHECK-LABEL: @test_mm_mask_cmp_round_sh_mask
1444   // CHECK: @llvm.x86.avx512fp16.mask.cmp.sh
1445   return _mm_mask_cmp_round_sh_mask(__M, __X, __Y, _CMP_NLT_US, _MM_FROUND_NO_EXC);
1446 }
1447
1448 __mmask8 test_mm_cmp_sh_mask(__m128h __X, __m128h __Y) {
1449   // CHECK-LABEL: @test_mm_cmp_sh_mask
1450   // CHECK: @llvm.x86.avx512fp16.mask.cmp.sh
1451   return _mm_cmp_sh_mask(__X, __Y, _CMP_NLT_US);
1452 }
1453
1454 __mmask8 test_mm_mask_cmp_sh_mask(__mmask8 __M, __m128h __X, __m128h __Y) {
1455   // CHECK-LABEL: @test_mm_mask_cmp_sh_mask
1456   // CHECK: @llvm.x86.avx512fp16.mask.cmp.sh
1457   return _mm_mask_cmp_sh_mask(__M, __X, __Y, _CMP_NLT_US);
1458 }
1459
1460 // VMOVSH
1461
1462 __m128h test_mm_load_sh(void const *A) {
1463   // CHECK-LABEL: test_mm_load_sh
1464   // CHECK: load half, ptr %{{.*}}, align 1{{$}}
1465   return _mm_load_sh(A);
1466 }
1467
1468 __m128h test_mm_mask_load_sh(__m128h __A, __mmask8 __U, const void *__W) {
1469   // CHECK-LABEL: @test_mm_mask_load_sh
1470   // CHECK: %{{.*}} = call <8 x half> @llvm.masked.load.v8f16.p0(ptr %{{.*}}, i32 1, <8 x i1> %{{.*}}, <8 x half> %{{.*}})
1471   return _mm_mask_load_sh(__A, __U, __W);
1472 }
1473
1474 __m128h test_mm_maskz_load_sh(__mmask8 __U, const void *__W) {
1475   // CHECK-LABEL: @test_mm_maskz_load_sh
1476   // CHECK: %{{.*}} = call <8 x half> @llvm.masked.load.v8f16.p0(ptr %{{.*}}, i32 1, <8 x i1> %{{.*}}, <8 x half> %{{.*}})
1477   return _mm_maskz_load_sh(__U, __W);
1478 }
1479
1480 __m512h test_mm512_load_ph(void *p) {
1481   // CHECK-LABEL: @test_mm512_load_ph
1482   // CHECK: load <32 x half>, ptr %{{.*}}, align 64{{$}}
1483   return _mm512_load_ph(p);
1484 }
1485
1486 __m256h test_mm256_load_ph(void *p) {
1487   // CHECK-LABEL: @test_mm256_load_ph
1488   // CHECK: load <16 x half>, ptr %{{.*}}, align 32{{$}}
1489   return _mm256_load_ph(p);
1490 }
1491
1492 __m128h test_mm_load_ph(void *p) {
1493   // CHECK-LABEL: @test_mm_load_ph
1494   // CHECK: load <8 x half>, ptr %{{.*}}, align 16{{$}}
1495   return _mm_load_ph(p);
1496 }
1497
1498 __m512h test_mm512_loadu_ph(void *p) {
1499   // CHECK-LABEL: @test_mm512_loadu_ph
1500   // CHECK: load <32 x half>, ptr {{.*}}, align 1{{$}}
1501   return _mm512_loadu_ph(p);
1502 }
1503
1504 __m256h test_mm256_loadu_ph(void *p) {
1505   // CHECK-LABEL: @test_mm256_loadu_ph
1506   // CHECK: load <16 x half>, ptr {{.*}}, align 1{{$}}
1507   return _mm256_loadu_ph(p);
1508 }
1509
1510 __m128h test_mm_loadu_ph(void *p) {
1511   // CHECK-LABEL: @test_mm_loadu_ph
1512   // CHECK: load <8 x half>, ptr {{.*}}, align 1{{$}}
1513   return _mm_loadu_ph(p);
1514 }
1515
1516 void test_mm_store_sh(void *A, __m128h B) {
1517   // CHECK-LABEL: test_mm_store_sh
1518   // CHECK: extractelement <8 x half> %{{.*}}, i32 0
1519   // CHECK: store half %{{.*}}, ptr %{{.*}}, align 1{{$}}
1520   _mm_store_sh(A, B);
1521 }
1522
1523 void test_mm_mask_store_sh(void *__P, __mmask8 __U, __m128h __A) {
1524   // CHECK-LABEL: @test_mm_mask_store_sh
1525   // CHECK: call void @llvm.masked.store.v8f16.p0(<8 x half> %{{.*}}, ptr %{{.*}}, i32 1, <8 x i1> %{{.*}})
1526   _mm_mask_store_sh(__P, __U, __A);
1527 }
1528
1529 void test_mm512_store_ph(void *p, __m512h a) {
1530   // CHECK-LABEL: @test_mm512_store_ph
1531   // CHECK: store <32 x half> %{{.*}}, ptr %{{.*}}, align 64
1532   _mm512_store_ph(p, a);
1533 }
1534
1535 void test_mm256_store_ph(void *p, __m256h a) {
1536   // CHECK-LABEL: @test_mm256_store_ph
1537   // CHECK: store <16 x half> %{{.*}}, ptr %{{.*}}, align 32
1538   _mm256_store_ph(p, a);
1539 }
1540
1541 void test_mm_store_ph(void *p, __m128h a) {
1542   // CHECK-LABEL: @test_mm_store_ph
1543   // CHECK: store <8 x half> %{{.*}}, ptr %{{.*}}, align 16
1544   _mm_store_ph(p, a);
1545 }
1546
1547 void test_mm512_storeu_ph(void *p, __m512h a) {
1548   // CHECK-LABEL: @test_mm512_storeu_ph
1549   // CHECK: store <32 x half> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1550   // CHECK-NEXT: ret void
1551   _mm512_storeu_ph(p, a);
1552 }
1553
1554 void test_mm256_storeu_ph(void *p, __m256h a) {
1555   // CHECK-LABEL: @test_mm256_storeu_ph
1556   // CHECK: store <16 x half> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1557   // CHECK-NEXT: ret void
1558   _mm256_storeu_ph(p, a);
1559 }
1560
1561 void test_mm_storeu_ph(void *p, __m128h a) {
1562   // CHECK-LABEL: @test_mm_storeu_ph
1563   // CHECK: store <8 x half> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1564   // CHECK-NEXT: ret void
1565   _mm_storeu_ph(p, a);
1566 }
1567
1568 __m128h test_mm_move_sh(__m128h A, __m128h B) {
1569   // CHECK-LABEL: test_mm_move_sh
1570   // CHECK: extractelement <8 x half> %{{.*}}, i32 0
1571   // CHECK: insertelement <8 x half> %{{.*}}, half %{{.*}}, i32 0
1572   return _mm_move_sh(A, B);
1573 }
1574
1575 __m128h test_mm_mask_move_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1576   // CHECK-LABEL: @test_mm_mask_move_sh
1577   // CHECK: [[EXT:%.*]] = extractelement <8 x half> %{{.*}}, i32 0
1578   // CHECK: insertelement <8 x half> %{{.*}}, half [[EXT]], i32 0
1579   // CHECK: [[A:%.*]] = extractelement <8 x half> [[VEC:%.*]], i64 0
1580   // CHECK-NEXT: [[B:%.*]] = extractelement <8 x half> %{{.*}}, i64 0
1581   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
1582   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
1583   // CHECK-NEXT: [[SEL:%.*]] = select i1 %{{.*}}, half [[A]], half [[B]]
1584   // CHECK-NEXT: insertelement <8 x half> [[VEC]], half [[SEL]], i64 0
1585   return _mm_mask_move_sh(__W, __U, __A, __B);
1586 }
1587
1588 __m128h test_mm_maskz_move_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1589   // CHECK-LABEL: @test_mm_maskz_move_sh
1590   // CHECK: [[EXT:%.*]] = extractelement <8 x half> %{{.*}}, i32 0
1591   // CHECK: insertelement <8 x half> %{{.*}}, half [[EXT]], i32 0
1592   // CHECK: [[A:%.*]] = extractelement <8 x half> [[VEC:%.*]], i64 0
1593   // CHECK-NEXT: [[B:%.*]] = extractelement <8 x half> %{{.*}}, i64 0
1594   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
1595   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
1596   // CHECK-NEXT: [[SEL:%.*]] = select i1 %{{.*}}, half [[A]], half [[B]]
1597   // CHECK-NEXT: insertelement <8 x half> [[VEC]], half [[SEL]], i64 0
1598   return _mm_maskz_move_sh(__U, __A, __B);
1599 }
1600
1601 short test_mm_cvtsi128_si16(__m128i A) {
1602   // CHECK-LABEL: test_mm_cvtsi128_si16
1603   // CHECK: extractelement <8 x i16> %{{.*}}, i32 0
1604   return _mm_cvtsi128_si16(A);
1605 }
1606
1607 __m128i test_mm_cvtsi16_si128(short A) {
1608   // CHECK-LABEL: test_mm_cvtsi16_si128
1609   // CHECK: insertelement <8 x i16> poison, i16 %{{.*}}, i32 0
1610   // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 1
1611   // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 2
1612   // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 3
1613   return _mm_cvtsi16_si128(A);
1614 }
1615
1616 __m512h test_mm512_rcp_ph(__m512h __A) {
1617   // CHECK-LABEL: @test_mm512_rcp_ph
1618   // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.512
1619   return _mm512_rcp_ph(__A);
1620 }
1621
1622 __m512h test_mm512_mask_rcp_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1623   // CHECK-LABEL: @test_mm512_mask_rcp_ph
1624   // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.512
1625   return (__m512h)_mm512_mask_rcp_ph(__W, __U, __A);
1626 }
1627
1628 __m512h test_mm512_maskz_rcp_ph(__mmask32 __U, __m512h __A) {
1629   // CHECK-LABEL: @test_mm512_maskz_rcp_ph
1630   // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.512
1631   return _mm512_maskz_rcp_ph(__U, __A);
1632 }
1633
1634 __m512h test_mm512_rsqrt_ph(__m512h __A) {
1635   // CHECK-LABEL: @test_mm512_rsqrt_ph
1636   // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.512
1637   return _mm512_rsqrt_ph(__A);
1638 }
1639
1640 __m512h test_mm512_mask_rsqrt_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1641   // CHECK-LABEL: @test_mm512_mask_rsqrt_ph
1642   // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.512
1643   return (__m512h)_mm512_mask_rsqrt_ph(__W, __U, __A);
1644 }
1645
1646 __m512h test_mm512_maskz_rsqrt_ph(__mmask32 __U, __m512h __A) {
1647   // CHECK-LABEL: @test_mm512_maskz_rsqrt_ph
1648   // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.512
1649   return _mm512_maskz_rsqrt_ph(__U, __A);
1650 }
1651
1652 __m512h test_mm512_getmant_round_ph(__m512h __A) {
1653   // CHECK-LABEL: @test_mm512_getmant_round_ph
1654   // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.512
1655   return _mm512_getmant_round_ph(__A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
1656 }
1657
1658 __m512h test_mm512_mask_getmant_round_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1659   // CHECK-LABEL: @test_mm512_mask_getmant_round_ph
1660   // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.512
1661   return _mm512_mask_getmant_round_ph(__W, __U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
1662 }
1663
1664 __m512h test_mm512_maskz_getmant_round_ph(__mmask32 __U, __m512h __A) {
1665   // CHECK-LABEL: @test_mm512_maskz_getmant_round_ph
1666   // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.512
1667   return _mm512_maskz_getmant_round_ph(__U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC);
1668 }
1669
1670 __m512h test_mm512_getmant_ph(__m512h __A) {
1671   // CHECK-LABEL: @test_mm512_getmant_ph
1672   // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.512
1673   return _mm512_getmant_ph(__A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1674 }
1675
1676 __m512h test_mm512_mask_getmant_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1677   // CHECK-LABEL: @test_mm512_mask_getmant_ph
1678   // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.512
1679   return _mm512_mask_getmant_ph(__W, __U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1680 }
1681
1682 __m512h test_mm512_maskz_getmant_ph(__mmask32 __U, __m512h __A) {
1683   // CHECK-LABEL: @test_mm512_maskz_getmant_ph
1684   // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.512
1685   return _mm512_maskz_getmant_ph(__U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1686 }
1687
1688 __m512h test_mm512_scalef_round_ph(__m512h __A, __m512h __B) {
1689   // CHECK-LABEL: @test_mm512_scalef_round_ph
1690   // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.512
1691   return _mm512_scalef_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1692 }
1693
1694 __m512h test_mm512_mask_scalef_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
1695   // CHECK-LABEL: @test_mm512_mask_scalef_round_ph
1696   // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.512
1697   return _mm512_mask_scalef_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1698 }
1699
1700 __m512h test_mm512_maskz_scalef_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
1701   // CHECK-LABEL: @test_mm512_maskz_scalef_round_ph
1702   // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.512
1703   return _mm512_maskz_scalef_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1704 }
1705
1706 __m512h test_mm512_scalef_ph(__m512h __A, __m512h __B) {
1707   // CHECK-LABEL: @test_mm512_scalef_ph
1708   // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.512
1709   return _mm512_scalef_ph(__A, __B);
1710 }
1711
1712 __m512h test_mm512_mask_scalef_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
1713   // CHECK-LABEL: @test_mm512_mask_scalef_ph
1714   // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.512
1715   return _mm512_mask_scalef_ph(__W, __U, __A, __B);
1716 }
1717
1718 __m512h test_mm512_maskz_scalef_ph(__mmask32 __U, __m512h __A, __m512h __B) {
1719   // CHECK-LABEL: @test_mm512_maskz_scalef_ph
1720   // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.512
1721   return _mm512_maskz_scalef_ph(__U, __A, __B);
1722 }
1723
1724 __m512h test_mm512_mask_roundscale_ph(__m512h __W, __mmask16 __U, __m512h __A) {
1725   // CHECK-LABEL: @test_mm512_mask_roundscale_ph
1726   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.512
1727   return _mm512_mask_roundscale_ph(__W, __U, __A, 1);
1728 }
1729
1730 __m512h test_mm512_maskz_roundscale_ph(__mmask16 __U, __m512h __A) {
1731   // CHECK-LABEL: @test_mm512_maskz_roundscale_ph
1732   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.512
1733   return _mm512_maskz_roundscale_ph(__U, __A, 1);
1734 }
1735
1736 __m512h test_mm512_mask_roundscale_round_ph(__m512h __A, __mmask16 __U, __m512h __C) {
1737   // CHECK-LABEL: @test_mm512_mask_roundscale_round_ph
1738   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.512
1739   return _mm512_mask_roundscale_round_ph(__A, __U, __C, 3, _MM_FROUND_NO_EXC);
1740 }
1741
1742 __m512h test_mm512_maskz_roundscale_round_ph(__m512h __A, __mmask16 __U) {
1743   // CHECK-LABEL: @test_mm512_maskz_roundscale_round_ph
1744   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.512
1745   return _mm512_maskz_roundscale_round_ph(__U, __A, 3, _MM_FROUND_NO_EXC);
1746 }
1747
1748 __m512h test_mm512_roundscale_round_ph(__m512h __A) {
1749   // CHECK-LABEL: @test_mm512_roundscale_round_ph
1750   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.512
1751   return _mm512_roundscale_round_ph(__A, 3, _MM_FROUND_NO_EXC);
1752 }
1753
1754 __m512h test_mm512_roundscale_ph(__m512h __A) {
1755   // CHECK-LABEL: @test_mm512_roundscale_ph
1756   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.512
1757   return _mm512_roundscale_ph(__A, 3);
1758 }
1759
1760 __m512h test_mm512_getexp_round_ph(__m512h __A) {
1761   // CHECK-LABEL: @test_mm512_getexp_round_ph
1762   // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.512
1763   return _mm512_getexp_round_ph(__A, _MM_FROUND_NO_EXC);
1764 }
1765
1766 __m512h test_mm512_mask_getexp_round_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1767   // CHECK-LABEL: @test_mm512_mask_getexp_round_ph
1768   // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.512
1769   return _mm512_mask_getexp_round_ph(__W, __U, __A, _MM_FROUND_NO_EXC);
1770 }
1771
1772 __m512h test_mm512_maskz_getexp_round_ph(__mmask32 __U, __m512h __A) {
1773   // CHECK-LABEL: @test_mm512_maskz_getexp_round_ph
1774   // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.512
1775   return _mm512_maskz_getexp_round_ph(__U, __A, _MM_FROUND_NO_EXC);
1776 }
1777
1778 __m512h test_mm512_getexp_ph(__m512h __A) {
1779   // CHECK-LABEL: @test_mm512_getexp_ph
1780   // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.512
1781   return _mm512_getexp_ph(__A);
1782 }
1783
1784 __m512h test_mm512_mask_getexp_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1785   // CHECK-LABEL: @test_mm512_mask_getexp_ph
1786   // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.512
1787   return _mm512_mask_getexp_ph(__W, __U, __A);
1788 }
1789
1790 __m512h test_mm512_maskz_getexp_ph(__mmask32 __U, __m512h __A) {
1791   // CHECK-LABEL: @test_mm512_maskz_getexp_ph
1792   // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.512
1793   return _mm512_maskz_getexp_ph(__U, __A);
1794 }
1795
1796 __m512h test_mm512_mask_reduce_ph(__m512h __W, __mmask16 __U, __m512h __A) {
1797   // CHECK-LABEL: @test_mm512_mask_reduce_ph
1798   // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.512
1799   return _mm512_mask_reduce_ph(__W, __U, __A, 1);
1800 }
1801
1802 __m512h test_mm512_maskz_reduce_ph(__mmask16 __U, __m512h __A) {
1803   // CHECK-LABEL: @test_mm512_maskz_reduce_ph
1804   // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.512
1805   return _mm512_maskz_reduce_ph(__U, __A, 1);
1806 }
1807
1808 __m512h test_mm512_mask_reduce_round_ph(__m512h __A, __mmask16 __U, __m512h __C) {
1809   // CHECK-LABEL: @test_mm512_mask_reduce_round_ph
1810   // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.512
1811   return _mm512_mask_reduce_round_ph(__A, __U, __C, 3, _MM_FROUND_NO_EXC);
1812 }
1813
1814 __m512h test_mm512_maskz_reduce_round_ph(__m512h __A, __mmask16 __U) {
1815   // CHECK-LABEL: @test_mm512_maskz_reduce_round_ph
1816   // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.512
1817   return _mm512_maskz_reduce_round_ph(__U, __A, 3, _MM_FROUND_NO_EXC);
1818 }
1819
1820 __m512h test_mm512_reduce_round_ph(__m512h __A) {
1821   // CHECK-LABEL: @test_mm512_reduce_round_ph
1822   // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.512
1823   return _mm512_reduce_round_ph(__A, 3, _MM_FROUND_NO_EXC);
1824 }
1825
1826 __m512h test_mm512_reduce_ph(__m512h __A) {
1827   // CHECK-LABEL: @test_mm512_reduce_ph
1828   // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.512
1829   return _mm512_reduce_ph(__A, 3);
1830 }
1831 __m128h test_mm_rcp_sh(__m128h __A, __m128h __B) {
1832   // CHECK-LABEL: @test_mm_rcp_sh
1833   // CHECK: @llvm.x86.avx512fp16.mask.rcp.sh
1834   return _mm_rcp_sh(__A, __B);
1835 }
1836
1837 __m128h test_mm_mask_rcp_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1838   // CHECK-LABEL: @test_mm_mask_rcp_sh
1839   // CHECK: @llvm.x86.avx512fp16.mask.rcp.sh
1840   return _mm_mask_rcp_sh(__W, __U, __A, __B);
1841 }
1842
1843 __m128h test_mm_maskz_rcp_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1844   // CHECK-LABEL: @test_mm_maskz_rcp_sh
1845   // CHECK: @llvm.x86.avx512fp16.mask.rcp.sh
1846   return _mm_maskz_rcp_sh(__U, __A, __B);
1847 }
1848
1849 __m128h test_mm_rsqrt_sh(__m128h __A, __m128h __B) {
1850   // CHECK-LABEL: @test_mm_rsqrt_sh
1851   // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.sh
1852   return _mm_rsqrt_sh(__A, __B);
1853 }
1854
1855 __m128h test_mm_mask_rsqrt_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1856   // CHECK-LABEL: @test_mm_mask_rsqrt_sh
1857   // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.sh
1858   return _mm_mask_rsqrt_sh(__W, __U, __A, __B);
1859 }
1860
1861 __m128h test_mm_maskz_rsqrt_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1862   // CHECK-LABEL: @test_mm_maskz_rsqrt_sh
1863   // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.sh
1864   return _mm_maskz_rsqrt_sh(__U, __A, __B);
1865 }
1866
1867 __m128h test_mm_getmant_round_sh(__m128h __A, __m128h __B) {
1868   // CHECK-LABEL: @test_mm_getmant_round_sh
1869   // CHECK: @llvm.x86.avx512fp16.mask.getmant.sh
1870   return _mm_getmant_round_sh(__A, __B, _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src, 8);
1871 }
1872
1873 __m128h test_mm_getmant_sh(__m128h __A, __m128h __B) {
1874   // CHECK-LABEL: @test_mm_getmant_sh
1875   // CHECK: @llvm.x86.avx512fp16.mask.getmant.sh
1876   return _mm_getmant_sh(__A, __B, _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src);
1877 }
1878
1879 __m128h test_mm_mask_getmant_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1880   // CHECK-LABEL: @test_mm_mask_getmant_sh
1881   // CHECK: @llvm.x86.avx512fp16.mask.getmant.sh
1882   return _mm_mask_getmant_sh(__W, __U, __A, __B, 1, 2);
1883 }
1884
1885 __m128h test_mm_mask_getmant_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1886   // CHECK-LABEL: @test_mm_mask_getmant_round_sh
1887   // CHECK: @llvm.x86.avx512fp16.mask.getmant.sh
1888   return _mm_mask_getmant_round_sh(__W, __U, __A, __B, 1, 2, _MM_FROUND_NO_EXC);
1889 }
1890
1891 __m128h test_mm_maskz_getmant_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1892   // CHECK-LABEL: @test_mm_maskz_getmant_sh
1893   // CHECK: @llvm.x86.avx512fp16.mask.getmant.sh
1894   return _mm_maskz_getmant_sh(__U, __A, __B, 1, 2);
1895 }
1896
1897 __m128h test_mm_maskz_getmant_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1898   // CHECK-LABEL: @test_mm_maskz_getmant_round_sh
1899   // CHECK: @llvm.x86.avx512fp16.mask.getmant.sh
1900   return _mm_maskz_getmant_round_sh(__U, __A, __B, 1, 2, _MM_FROUND_NO_EXC);
1901 }
1902
1903 __m128h test_mm_getexp_round_sh(__m128h __A, __m128h __B) {
1904   // CHECK-LABEL: @test_mm_getexp_round_sh
1905   // CHECK: @llvm.x86.avx512fp16.mask.getexp.sh
1906   return _mm_getexp_round_sh(__A, __B, 8);
1907 }
1908
1909 __m128h test_mm_getexp_sh(__m128h __A, __m128h __B) {
1910   // CHECK-LABEL: @test_mm_getexp_sh
1911   // CHECK: @llvm.x86.avx512fp16.mask.getexp.sh
1912   return _mm_getexp_sh(__A, __B);
1913 }
1914
1915 __m128h test_mm_mask_getexp_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1916   // CHECK-LABEL: @test_mm_mask_getexp_sh
1917   // CHECK: @llvm.x86.avx512fp16.mask.getexp.sh
1918   return _mm_mask_getexp_sh(__W, __U, __A, __B);
1919 }
1920
1921 __m128h test_mm_mask_getexp_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1922   // CHECK-LABEL: @test_mm_mask_getexp_round_sh
1923   // CHECK: @llvm.x86.avx512fp16.mask.getexp.sh
1924   return _mm_mask_getexp_round_sh(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
1925 }
1926
1927 __m128h test_mm_maskz_getexp_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1928   // CHECK-LABEL: @test_mm_maskz_getexp_sh
1929   // CHECK: @llvm.x86.avx512fp16.mask.getexp.sh
1930   return _mm_maskz_getexp_sh(__U, __A, __B);
1931 }
1932
1933 __m128h test_mm_maskz_getexp_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1934   // CHECK-LABEL: @test_mm_maskz_getexp_round_sh
1935   // CHECK: @llvm.x86.avx512fp16.mask.getexp.sh
1936   return _mm_maskz_getexp_round_sh(__U, __A, __B, _MM_FROUND_NO_EXC);
1937 }
1938
1939 __m128h test_mm_scalef_round_sh(__m128h __A, __m128h __B) {
1940   // CHECK-LABEL: @test_mm_scalef_round_sh
1941   // CHECK: @llvm.x86.avx512fp16.mask.scalef.sh(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}, i8 -1, i32 11)
1942   return _mm_scalef_round_sh(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1943 }
1944
1945 __m128h test_mm_scalef_sh(__m128h __A, __m128h __B) {
1946   // CHECK-LABEL: @test_mm_scalef_sh
1947   // CHECK: @llvm.x86.avx512fp16.mask.scalef.sh
1948   return _mm_scalef_sh(__A, __B);
1949 }
1950
1951 __m128h test_mm_mask_scalef_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1952   // CHECK-LABEL: @test_mm_mask_scalef_sh
1953   // CHECK: @llvm.x86.avx512fp16.mask.scalef.sh
1954   return _mm_mask_scalef_sh(__W, __U, __A, __B);
1955 }
1956
1957 __m128h test_mm_mask_scalef_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1958   // CHECK-LABEL: @test_mm_mask_scalef_round_sh
1959   // CHECK: @llvm.x86.avx512fp16.mask.scalef.sh(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}, i8 %{{.*}}, i32 11)
1960   return _mm_mask_scalef_round_sh(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1961 }
1962
1963 __m128h test_mm_maskz_scalef_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1964   // CHECK-LABEL: @test_mm_maskz_scalef_sh
1965   // CHECK: @llvm.x86.avx512fp16.mask.scalef.sh
1966   return _mm_maskz_scalef_sh(__U, __A, __B);
1967 }
1968
1969 __m128h test_mm_maskz_scalef_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1970   // CHECK-LABEL: @test_mm_maskz_scalef_round_sh
1971   // CHECK: @llvm.x86.avx512fp16.mask.scalef.sh(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}, i8 %{{.*}}, i32 11)
1972   return _mm_maskz_scalef_round_sh(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
1973 }
1974
1975 __m128h test_mm_roundscale_round_sh(__m128h __A, __m128h __B) {
1976   // CHECK-LABEL: @test_mm_roundscale_round_sh
1977   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.sh
1978   return _mm_roundscale_round_sh(__A, __B, 3, _MM_FROUND_NO_EXC);
1979 }
1980
1981 __m128h test_mm_roundscale_sh(__m128h __A, __m128h __B) {
1982   // CHECK-LABEL: @test_mm_roundscale_sh
1983   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.sh
1984   return _mm_roundscale_sh(__A, __B, 3);
1985 }
1986
1987 __m128h test_mm_mask_roundscale_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1988   // CHECK-LABEL: @test_mm_mask_roundscale_sh
1989   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.sh
1990   return _mm_mask_roundscale_sh(__W, __U, __A, __B, 3);
1991 }
1992
1993 __m128h test_mm_mask_roundscale_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1994   // CHECK-LABEL: @test_mm_mask_roundscale_round_sh
1995   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.sh
1996   return _mm_mask_roundscale_round_sh(__W, __U, __A, __B, 3, _MM_FROUND_NO_EXC);
1997 }
1998
1999 __m128h test_mm_maskz_roundscale_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
2000   // CHECK-LABEL: @test_mm_maskz_roundscale_round_sh
2001   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.sh
2002   return _mm_maskz_roundscale_round_sh(__U, __A, __B, 3, _MM_FROUND_NO_EXC);
2003 }
2004
2005 __m128h test_mm_maskz_roundscale_sh(__mmask8 __U, __m128h __A, __m128h __B) {
2006   // CHECK-LABEL: @test_mm_maskz_roundscale_sh
2007   // CHECK: @llvm.x86.avx512fp16.mask.rndscale.sh
2008   return _mm_maskz_roundscale_sh(__U, __A, __B, 3);
2009 }
2010
2011 __m128h test_mm_reduce_sh(__m128h __A, __m128h __B) {
2012   // CHECK-LABEL: @test_mm_reduce_sh
2013   // CHECK: @llvm.x86.avx512fp16.mask.reduce.sh
2014   return _mm_reduce_sh(__A, __B, 4);
2015 }
2016
2017 __m128h test_mm_mask_reduce_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2018   // CHECK-LABEL: @test_mm_mask_reduce_sh
2019   // CHECK: @llvm.x86.avx512fp16.mask.reduce.sh
2020   return _mm_mask_reduce_sh(__W, __U, __A, __B, 4);
2021 }
2022
2023 __m128h test_mm_maskz_reduce_sh(__mmask8 __U, __m128h __A, __m128h __B) {
2024   // CHECK-LABEL: @test_mm_maskz_reduce_sh
2025   // CHECK: @llvm.x86.avx512fp16.mask.reduce.sh
2026   return _mm_maskz_reduce_sh(__U, __A, __B, 4);
2027 }
2028
2029 __m128h test_mm_reduce_round_sh(__m128h __A, __m128h __B) {
2030   // CHECK-LABEL: @test_mm_reduce_round_sh
2031   // CHECK: @llvm.x86.avx512fp16.mask.reduce.sh
2032   return _mm_reduce_round_sh(__A, __B, 4, 8);
2033 }
2034
2035 __m128h test_mm_mask_reduce_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2036   // CHECK-LABEL: @test_mm_mask_reduce_round_sh
2037   // CHECK: @llvm.x86.avx512fp16.mask.reduce.sh
2038   return _mm_mask_reduce_round_sh(__W, __U, __A, __B, 4, 8);
2039 }
2040
2041 __m128h test_mm_maskz_reduce_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
2042   // CHECK-LABEL: @test_mm_maskz_reduce_round_sh
2043   // CHECK: @llvm.x86.avx512fp16.mask.reduce.sh
2044   return _mm_maskz_reduce_round_sh(__U, __A, __B, 4, 8);
2045 }
2046
2047 __m512h test_mm512_sqrt_round_ph(__m512h __A) {
2048   // CHECK-LABEL: @test_mm512_sqrt_round_ph
2049   // CHECK: call <32 x half> @llvm.x86.avx512fp16.sqrt.ph.512(<32 x half> %{{.*}}, i32 11)
2050   return _mm512_sqrt_round_ph(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2051 }
2052
2053 __m512h test_mm512_mask_sqrt_round_ph(__m512h __W, __mmask32 __U, __m512h __A) {
2054   // CHECK-LABEL: @test_mm512_mask_sqrt_round_ph
2055   // CHECK: call <32 x half> @llvm.x86.avx512fp16.sqrt.ph.512(<32 x half> %{{.*}}, i32 11)
2056   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
2057   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
2058   return _mm512_mask_sqrt_round_ph(__W, __U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2059 }
2060
2061 __m512h test_mm512_maskz_sqrt_round_ph(__mmask32 __U, __m512h __A) {
2062   // CHECK-LABEL: @test_mm512_maskz_sqrt_round_ph
2063   // CHECK: call <32 x half> @llvm.x86.avx512fp16.sqrt.ph.512(<32 x half> %{{.*}}, i32 11)
2064   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
2065   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> {{.*}}
2066   return _mm512_maskz_sqrt_round_ph(__U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2067 }
2068
2069 __m512h test_mm512_sqrt_ph(__m512h __A) {
2070   // CHECK-LABEL: @test_mm512_sqrt_ph
2071   // CHECK: %{{.*}} = call <32 x half> @llvm.sqrt.v32f16(<32 x half> %{{.*}})
2072   return _mm512_sqrt_ph(__A);
2073 }
2074 __m512h test_mm512_mask_sqrt_ph(__m512h __W, __mmask32 __U, __m512h __A) {
2075   // CHECK-LABEL: @test_mm512_mask_sqrt_ph
2076   // CHECK: %{{.*}} = call <32 x half> @llvm.sqrt.v32f16(<32 x half> %{{.*}})
2077   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
2078   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
2079   return _mm512_mask_sqrt_ph(__W, __U, __A);
2080 }
2081 __m512h test_mm512_maskz_sqrt_ph(__mmask32 __U, __m512h __A) {
2082   // CHECK-LABEL: @test_mm512_maskz_sqrt_ph
2083   // CHECK: %{{.*}} = call <32 x half> @llvm.sqrt.v32f16(<32 x half> %{{.*}})
2084   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
2085   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> {{.*}}
2086   return _mm512_maskz_sqrt_ph(__U, __A);
2087 }
2088
2089 __m128h test_mm_sqrt_round_sh(__m128h __A, __m128h __B) {
2090   // CHECK-LABEL: @test_mm_sqrt_round_sh
2091   // CHECK: call <8 x half> @llvm.x86.avx512fp16.mask.sqrt.sh(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}, i8 -1, i32 11)
2092   return _mm_sqrt_round_sh(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2093 }
2094
2095 __m128h test_mm_mask_sqrt_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2096   // CHECK-LABEL: @test_mm_mask_sqrt_round_sh
2097   // CHECK: call <8 x half> @llvm.x86.avx512fp16.mask.sqrt.sh(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}, i8 {{.*}}, i32 11)
2098   return _mm_mask_sqrt_round_sh(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2099 }
2100
2101 __m128h test_mm_maskz_sqrt_round_sh(__mmask8 __U, __m128h __A, __m128h __B) {
2102   // CHECK-LABEL: @test_mm_maskz_sqrt_round_sh
2103   // CHECK: call <8 x half> @llvm.x86.avx512fp16.mask.sqrt.sh(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}, i8 {{.*}}, i32 11)
2104   return _mm_maskz_sqrt_round_sh(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2105 }
2106
2107 __m128h test_mm_sqrt_sh(__m128h __A, __m128h __B) {
2108   // CHECK-LABEL: @test_mm_sqrt_sh
2109   // CHECK: %{{.*}} = call half @llvm.sqrt.f16(half %{{.*}})
2110   return _mm_sqrt_sh(__A, __B);
2111 }
2112 __m128h test_mm_mask_sqrt_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2113   // CHECK-LABEL: @test_mm_mask_sqrt_sh
2114   // CHECK: %{{.*}} = call half @llvm.sqrt.f16(half %{{.*}})
2115   return _mm_mask_sqrt_sh(__W, __U, __A, __B);
2116 }
2117 __m128h test_mm_maskz_sqrt_sh(__mmask8 __U, __m128h __A, __m128h __B) {
2118   // CHECK-LABEL: @test_mm_maskz_sqrt_sh
2119   // CHECK: %{{.*}} = call half @llvm.sqrt.f16(half %{{.*}})
2120   return _mm_maskz_sqrt_sh(__U, __A, __B);
2121 }
2122
2123 __mmask32 test_mm512_mask_fpclass_ph_mask(__mmask32 __U, __m512h __A) {
2124   // CHECK-LABEL: @test_mm512_mask_fpclass_ph_mask
2125   // CHECK: @llvm.x86.avx512fp16.fpclass.ph.512
2126   return _mm512_mask_fpclass_ph_mask(__U, __A, 4);
2127 }
2128
2129 __mmask32 test_mm512_fpclass_ph_mask(__m512h __A) {
2130   // CHECK-LABEL: @test_mm512_fpclass_ph_mask
2131   // CHECK: @llvm.x86.avx512fp16.fpclass.ph.512
2132   return _mm512_fpclass_ph_mask(__A, 4);
2133 }
2134
2135 __mmask8 test_mm_fpclash_sh_mask(__m128 __A) {
2136   // CHECK-LABEL: @test_mm_fpclash_sh_mask
2137   // CHECK: @llvm.x86.avx512fp16.mask.fpclass.sh
2138   return _mm_fpclass_sh_mask(__A, 2);
2139 }
2140
2141 __mmask8 test_mm_mask_fpclash_sh_mask(__mmask8 __U, __m128 __A) {
2142   // CHECK-LABEL: @test_mm_mask_fpclash_sh_mask
2143   // CHECK: @llvm.x86.avx512fp16.mask.fpclass.sh
2144   return _mm_mask_fpclass_sh_mask(__U, __A, 2);
2145 }
2146
2147 __m128h test_mm512_cvt_roundpd_ph(__m512d A) {
2148   // CHECK-LABEL: test_mm512_cvt_roundpd_ph
2149   // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.512
2150   return _mm512_cvt_roundpd_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2151 }
2152
2153 __m128h test_mm512_mask_cvt_roundpd_ph(__m128h A, __mmask8 B, __m512d C) {
2154   // CHECK-LABEL: test_mm512_mask_cvt_roundpd_ph
2155   // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.512
2156   return _mm512_mask_cvt_roundpd_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2157 }
2158
2159 __m128h test_mm512_maskz_cvt_roundpd_ph(__mmask8 A, __m512d B) {
2160   // CHECK-LABEL: test_mm512_maskz_cvt_roundpd_ph
2161   // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.512
2162   return _mm512_maskz_cvt_roundpd_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2163 }
2164
2165 __m128h test_mm512_cvtpd_ph(__m512d A) {
2166   // CHECK-LABEL: test_mm512_cvtpd_ph
2167   // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.512
2168   return _mm512_cvtpd_ph(A);
2169 }
2170
2171 __m128h test_mm512_mask_cvtpd_ph(__m128h A, __mmask8 B, __m512d C) {
2172   // CHECK-LABEL: test_mm512_mask_cvtpd_ph
2173   // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.512
2174   return _mm512_mask_cvtpd_ph(A, B, C);
2175 }
2176
2177 __m128h test_mm512_maskz_cvtpd_ph(__mmask8 A, __m512d B) {
2178   // CHECK-LABEL: test_mm512_maskz_cvtpd_ph
2179   // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.512
2180   return _mm512_maskz_cvtpd_ph(A, B);
2181 }
2182
2183 __m512d test_mm512_cvt_roundph_pd(__m128h A) {
2184   // CHECK-LABEL: test_mm512_cvt_roundph_pd
2185   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.512
2186   return _mm512_cvt_roundph_pd(A, _MM_FROUND_NO_EXC);
2187 }
2188
2189 __m512d test_mm512_mask_cvt_roundph_pd(__m512d A, __mmask8 B, __m128h C) {
2190   // CHECK-LABEL: test_mm512_mask_cvt_roundph_pd
2191   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.512
2192   return _mm512_mask_cvt_roundph_pd(A, B, C, _MM_FROUND_NO_EXC);
2193 }
2194
2195 __m512d test_mm512_maskz_cvt_roundph_pd(__mmask8 A, __m128h B) {
2196   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_pd
2197   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.512
2198   return _mm512_maskz_cvt_roundph_pd(A, B, _MM_FROUND_NO_EXC);
2199 }
2200
2201 __m512d test_mm512_cvtph_pd(__m128h A) {
2202   // CHECK-LABEL: test_mm512_cvtph_pd
2203   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.512
2204   return _mm512_cvtph_pd(A);
2205 }
2206
2207 __m512d test_mm512_mask_cvtph_pd(__m512d A, __mmask8 B, __m128h C) {
2208   // CHECK-LABEL: test_mm512_mask_cvtph_pd
2209   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.512
2210   return _mm512_mask_cvtph_pd(A, B, C);
2211 }
2212
2213 __m512d test_mm512_maskz_cvtph_pd(__mmask8 A, __m128h B) {
2214   // CHECK-LABEL: test_mm512_maskz_cvtph_pd
2215   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.512
2216   return _mm512_maskz_cvtph_pd(A, B);
2217 }
2218
2219 __m128 test_mm_cvt_roundsh_ss(__m128 A, __m128h B) {
2220   // CHECK-LABEL: test_mm_cvt_roundsh_ss
2221   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2ss.round
2222   return _mm_cvt_roundsh_ss(A, B, _MM_FROUND_NO_EXC);
2223 }
2224
2225 __m128 test_mm_mask_cvt_roundsh_ss(__m128 A, __mmask8 B, __m128 C, __m128h D) {
2226   // CHECK-LABEL: test_mm_mask_cvt_roundsh_ss
2227   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2ss.round
2228   return _mm_mask_cvt_roundsh_ss(A, B, C, D, _MM_FROUND_NO_EXC);
2229 }
2230
2231 __m128 test_mm_maskz_cvt_roundsh_ss(__mmask8 A, __m128 B, __m128h C) {
2232   // CHECK-LABEL: test_mm_maskz_cvt_roundsh_ss
2233   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2ss.round
2234   return _mm_maskz_cvt_roundsh_ss(A, B, C, _MM_FROUND_NO_EXC);
2235 }
2236
2237 __m128 test_mm_cvtsh_ss(__m128 A, __m128h B) {
2238   // CHECK-LABEL: test_mm_cvtsh_ss
2239   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2ss.round
2240   return _mm_cvtsh_ss(A, B);
2241 }
2242
2243 __m128 test_mm_mask_cvtsh_ss(__m128 A, __mmask8 B, __m128 C, __m128h D) {
2244   // CHECK-LABEL: test_mm_mask_cvtsh_ss
2245   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2ss.round
2246   return _mm_mask_cvtsh_ss(A, B, C, D);
2247 }
2248
2249 __m128 test_mm_maskz_cvtsh_ss(__mmask8 A, __m128 B, __m128h C) {
2250   // CHECK-LABEL: test_mm_maskz_cvtsh_ss
2251   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2ss.round
2252   return _mm_maskz_cvtsh_ss(A, B, C);
2253 }
2254
2255 __m128h test_mm_cvt_roundss_sh(__m128h A, __m128 B) {
2256   // CHECK-LABEL: test_mm_cvt_roundss_sh
2257   // CHECK: @llvm.x86.avx512fp16.mask.vcvtss2sh.round
2258   return _mm_cvt_roundss_sh(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2259 }
2260
2261 __m128h test_mm_mask_cvt_roundss_sh(__m128h A, __mmask8 B, __m128h C, __m128 D) {
2262   // CHECK-LABEL: test_mm_mask_cvt_roundss_sh
2263   // CHECK: @llvm.x86.avx512fp16.mask.vcvtss2sh.round
2264   return _mm_mask_cvt_roundss_sh(A, B, C, D, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2265 }
2266
2267 __m128h test_mm_maskz_cvt_roundss_sh(__mmask8 A, __m128h B, __m128 C) {
2268   // CHECK-LABEL: test_mm_maskz_cvt_roundss_sh
2269   // CHECK: @llvm.x86.avx512fp16.mask.vcvtss2sh.round
2270   return _mm_maskz_cvt_roundss_sh(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2271 }
2272
2273 __m128h test_mm_cvtss_sh(__m128h A, __m128 B) {
2274   // CHECK-LABEL: test_mm_cvtss_sh
2275   // CHECK: @llvm.x86.avx512fp16.mask.vcvtss2sh.round
2276   return _mm_cvtss_sh(A, B);
2277 }
2278
2279 __m128h test_mm_mask_cvtss_sh(__m128h A, __mmask8 B, __m128h C, __m128 D) {
2280   // CHECK-LABEL: test_mm_mask_cvtss_sh
2281   // CHECK: @llvm.x86.avx512fp16.mask.vcvtss2sh.round
2282   return _mm_mask_cvtss_sh(A, B, C, D);
2283 }
2284
2285 __m128h test_mm_maskz_cvtss_sh(__mmask8 A, __m128h B, __m128 C) {
2286   // CHECK-LABEL: test_mm_maskz_cvtss_sh
2287   // CHECK: @llvm.x86.avx512fp16.mask.vcvtss2sh.round
2288   return _mm_maskz_cvtss_sh(A, B, C);
2289 }
2290
2291 __m128h test_mm_cvt_roundsd_sh(__m128h A, __m128d B) {
2292   // CHECK-LABEL: test_mm_cvt_roundsd_sh
2293   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsd2sh.round
2294   return _mm_cvt_roundsd_sh(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2295 }
2296
2297 __m128h test_mm_mask_cvt_roundsd_sh(__m128h A, __mmask8 B, __m128h C, __m128d D) {
2298   // CHECK-LABEL: test_mm_mask_cvt_roundsd_sh
2299   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsd2sh.round
2300   return _mm_mask_cvt_roundsd_sh(A, B, C, D, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2301 }
2302
2303 __m128h test_mm_maskz_cvt_roundsd_sh(__mmask8 A, __m128h B, __m128d C) {
2304   // CHECK-LABEL: test_mm_maskz_cvt_roundsd_sh
2305   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsd2sh.round
2306   return _mm_maskz_cvt_roundsd_sh(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2307 }
2308
2309 __m128h test_mm_cvtsd_sh(__m128h A, __m128d B) {
2310   // CHECK-LABEL: test_mm_cvtsd_sh
2311   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsd2sh.round
2312   return _mm_cvtsd_sh(A, B);
2313 }
2314
2315 __m128h test_mm_mask_cvtsd_sh(__m128h A, __mmask8 B, __m128h C, __m128d D) {
2316   // CHECK-LABEL: test_mm_mask_cvtsd_sh
2317   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsd2sh.round
2318   return _mm_mask_cvtsd_sh(A, B, C, D);
2319 }
2320
2321 __m128h test_mm_maskz_cvtsd_sh(__mmask8 A, __m128h B, __m128d C) {
2322   // CHECK-LABEL: test_mm_maskz_cvtsd_sh
2323   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsd2sh.round
2324   return _mm_maskz_cvtsd_sh(A, B, C);
2325 }
2326
2327 __m128d test_mm_cvt_roundsh_sd(__m128d A, __m128h B) {
2328   // CHECK-LABEL: test_mm_cvt_roundsh_sd
2329   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2sd.round
2330   return _mm_cvt_roundsh_sd(A, B, _MM_FROUND_NO_EXC);
2331 }
2332
2333 __m128d test_mm_mask_cvt_roundsh_sd(__m128d A, __mmask8 B, __m128d C, __m128h D) {
2334   // CHECK-LABEL: test_mm_mask_cvt_roundsh_sd
2335   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2sd.round
2336   return _mm_mask_cvt_roundsh_sd(A, B, C, D, _MM_FROUND_NO_EXC);
2337 }
2338
2339 __m128d test_mm_maskz_cvt_roundsh_sd(__mmask8 A, __m128d B, __m128h C) {
2340   // CHECK-LABEL: test_mm_maskz_cvt_roundsh_sd
2341   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2sd.round
2342   return _mm_maskz_cvt_roundsh_sd(A, B, C, _MM_FROUND_NO_EXC);
2343 }
2344
2345 __m128d test_mm_cvtsh_sd(__m128d A, __m128h B) {
2346   // CHECK-LABEL: test_mm_cvtsh_sd
2347   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2sd.round
2348   return _mm_cvtsh_sd(A, B);
2349 }
2350
2351 __m128d test_mm_mask_cvtsh_sd(__m128d A, __mmask8 B, __m128d C, __m128h D) {
2352   // CHECK-LABEL: test_mm_mask_cvtsh_sd
2353   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2sd.round
2354   return _mm_mask_cvtsh_sd(A, B, C, D);
2355 }
2356
2357 __m128d test_mm_maskz_cvtsh_sd(__mmask8 A, __m128d B, __m128h C) {
2358   // CHECK-LABEL: test_mm_maskz_cvtsh_sd
2359   // CHECK: @llvm.x86.avx512fp16.mask.vcvtsh2sd.round
2360   return _mm_maskz_cvtsh_sd(A, B, C);
2361 }
2362
2363 __m512i test_mm512_cvt_roundph_epi16(__m512h A) {
2364   // CHECK-LABEL: test_mm512_cvt_roundph_epi16
2365   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.512
2366   return _mm512_cvt_roundph_epi16(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2367 }
2368
2369 __m512i test_mm512_mask_cvt_roundph_epi16(__m512i A, __mmask32 B, __m512h C) {
2370   // CHECK-LABEL: test_mm512_mask_cvt_roundph_epi16
2371   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.512
2372   return _mm512_mask_cvt_roundph_epi16(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2373 }
2374
2375 __m512i test_mm512_maskz_cvt_roundph_epi16(__mmask32 A, __m512h B) {
2376   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_epi16
2377   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.512
2378   return _mm512_maskz_cvt_roundph_epi16(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2379 }
2380
2381 __m512i test_mm512_cvtph_epi16(__m512h A) {
2382   // CHECK-LABEL: test_mm512_cvtph_epi16
2383   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.512
2384   return _mm512_cvtph_epi16(A);
2385 }
2386
2387 __m512i test_mm512_mask_cvtph_epi16(__m512i A, __mmask32 B, __m512h C) {
2388   // CHECK-LABEL: test_mm512_mask_cvtph_epi16
2389   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.512
2390   return _mm512_mask_cvtph_epi16(A, B, C);
2391 }
2392
2393 __m512i test_mm512_maskz_cvtph_epi16(__mmask32 A, __m512h B) {
2394   // CHECK-LABEL: test_mm512_maskz_cvtph_epi16
2395   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.512
2396   return _mm512_maskz_cvtph_epi16(A, B);
2397 }
2398
2399 __m512i test_mm512_cvtt_roundph_epi16(__m512h A) {
2400   // CHECK-LABEL: test_mm512_cvtt_roundph_epi16
2401   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.512
2402   return _mm512_cvtt_roundph_epi16(A, _MM_FROUND_NO_EXC);
2403 }
2404
2405 __m512i test_mm512_mask_cvtt_roundph_epi16(__m512i A, __mmask32 B, __m512h C) {
2406   // CHECK-LABEL: test_mm512_mask_cvtt_roundph_epi16
2407   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.512
2408   return _mm512_mask_cvtt_roundph_epi16(A, B, C, _MM_FROUND_NO_EXC);
2409 }
2410
2411 __m512i test_mm512_maskz_cvtt_roundph_epi16(__mmask32 A, __m512h B) {
2412   // CHECK-LABEL: test_mm512_maskz_cvtt_roundph_epi16
2413   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.512
2414   return _mm512_maskz_cvtt_roundph_epi16(A, B, _MM_FROUND_NO_EXC);
2415 }
2416
2417 __m512i test_mm512_cvttph_epi16(__m512h A) {
2418   // CHECK-LABEL: test_mm512_cvttph_epi16
2419   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.512
2420   return _mm512_cvttph_epi16(A);
2421 }
2422
2423 __m512i test_mm512_mask_cvttph_epi16(__m512i A, __mmask32 B, __m512h C) {
2424   // CHECK-LABEL: test_mm512_mask_cvttph_epi16
2425   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.512
2426   return _mm512_mask_cvttph_epi16(A, B, C);
2427 }
2428
2429 __m512i test_mm512_maskz_cvttph_epi16(__mmask32 A, __m512h B) {
2430   // CHECK-LABEL: test_mm512_maskz_cvttph_epi16
2431   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.512
2432   return _mm512_maskz_cvttph_epi16(A, B);
2433 }
2434
2435 __m512h test_mm512_cvt_roundepi16_ph(__m512i A) {
2436   // CHECK-LABEL: test_mm512_cvt_roundepi16_ph
2437   // CHECK:   @llvm.x86.avx512.sitofp.round.v32f16.v32i16
2438   return _mm512_cvt_roundepi16_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2439 }
2440
2441 __m512h test_mm512_mask_cvt_roundepi16_ph(__m512h A, __mmask32 B, __m512i C) {
2442   // CHECK-LABEL: test_mm512_mask_cvt_roundepi16_ph
2443   // CHECK: @llvm.x86.avx512.sitofp.round.v32f16.v32i16
2444   return _mm512_mask_cvt_roundepi16_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2445 }
2446
2447 __m512h test_mm512_maskz_cvt_roundepi16_ph(__mmask32 A, __m512i B) {
2448   // CHECK-LABEL: test_mm512_maskz_cvt_roundepi16_ph
2449   // CHECK: @llvm.x86.avx512.sitofp.round.v32f16.v32i16
2450   return _mm512_maskz_cvt_roundepi16_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2451 }
2452
2453 __m512h test_mm512_cvtepi16_ph(__m512i A) {
2454   // CHECK-LABEL: test_mm512_cvtepi16_ph
2455   // CHECK: %{{.*}} = sitofp <32 x i16> %{{.*}} to <32 x half>
2456   return _mm512_cvtepi16_ph(A);
2457 }
2458
2459 __m512h test_mm512_mask_cvtepi16_ph(__m512h A, __mmask32 B, __m512i C) {
2460   // CHECK-LABEL: test_mm512_mask_cvtepi16_ph
2461   // CHECK: %{{.*}} = sitofp <32 x i16> %{{.*}} to <32 x half>
2462   return _mm512_mask_cvtepi16_ph(A, B, C);
2463 }
2464
2465 __m512h test_mm512_maskz_cvtepi16_ph(__mmask32 A, __m512i B) {
2466   // CHECK-LABEL: test_mm512_maskz_cvtepi16_ph
2467   // CHECK: %{{.*}} = sitofp <32 x i16> %{{.*}} to <32 x half>
2468   return _mm512_maskz_cvtepi16_ph(A, B);
2469 }
2470
2471 __m512i test_mm512_cvt_roundph_epu16(__m512h A) {
2472   // CHECK-LABEL: test_mm512_cvt_roundph_epu16
2473   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.512
2474   return _mm512_cvt_roundph_epu16(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2475 }
2476
2477 __m512i test_mm512_mask_cvt_roundph_epu16(__m512i A, __mmask32 B, __m512h C) {
2478   // CHECK-LABEL: test_mm512_mask_cvt_roundph_epu16
2479   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.512
2480   return _mm512_mask_cvt_roundph_epu16(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2481 }
2482
2483 __m512i test_mm512_maskz_cvt_roundph_epu16(__mmask32 A, __m512h B) {
2484   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_epu16
2485   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.512
2486   return _mm512_maskz_cvt_roundph_epu16(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2487 }
2488
2489 __m512i test_mm512_cvtph_epu16(__m512h A) {
2490   // CHECK-LABEL: test_mm512_cvtph_epu16
2491   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.512
2492   return _mm512_cvtph_epu16(A);
2493 }
2494
2495 __m512i test_mm512_mask_cvtph_epu16(__m512i A, __mmask32 B, __m512h C) {
2496   // CHECK-LABEL: test_mm512_mask_cvtph_epu16
2497   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.512
2498   return _mm512_mask_cvtph_epu16(A, B, C);
2499 }
2500
2501 __m512i test_mm512_maskz_cvtph_epu16(__mmask32 A, __m512h B) {
2502   // CHECK-LABEL: test_mm512_maskz_cvtph_epu16
2503   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.512
2504   return _mm512_maskz_cvtph_epu16(A, B);
2505 }
2506
2507 __m512i test_mm512_cvtt_roundph_epu16(__m512h A) {
2508   // CHECK-LABEL: test_mm512_cvtt_roundph_epu16
2509   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.512
2510   return _mm512_cvtt_roundph_epu16(A, _MM_FROUND_NO_EXC);
2511 }
2512
2513 __m512i test_mm512_mask_cvtt_roundph_epu16(__m512i A, __mmask32 B, __m512h C) {
2514   // CHECK-LABEL: test_mm512_mask_cvtt_roundph_epu16
2515   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.512
2516   return _mm512_mask_cvtt_roundph_epu16(A, B, C, _MM_FROUND_NO_EXC);
2517 }
2518
2519 __m512i test_mm512_maskz_cvtt_roundph_epu16(__mmask32 A, __m512h B) {
2520   // CHECK-LABEL: test_mm512_maskz_cvtt_roundph_epu16
2521   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.512
2522   return _mm512_maskz_cvtt_roundph_epu16(A, B, _MM_FROUND_NO_EXC);
2523 }
2524
2525 __m512i test_mm512_cvttph_epu16(__m512h A) {
2526   // CHECK-LABEL: test_mm512_cvttph_epu16
2527   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.512
2528   return _mm512_cvttph_epu16(A);
2529 }
2530
2531 __m512i test_mm512_mask_cvttph_epu16(__m512i A, __mmask32 B, __m512h C) {
2532   // CHECK-LABEL: test_mm512_mask_cvttph_epu16
2533   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.512
2534   return _mm512_mask_cvttph_epu16(A, B, C);
2535 }
2536
2537 __m512i test_mm512_maskz_cvttph_epu16(__mmask32 A, __m512h B) {
2538   // CHECK-LABEL: test_mm512_maskz_cvttph_epu16
2539   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.512
2540   return _mm512_maskz_cvttph_epu16(A, B);
2541 }
2542
2543 __m512h test_mm512_cvt_roundepu16_ph(__m512i A) {
2544   // CHECK-LABEL: test_mm512_cvt_roundepu16_ph
2545   // CHECK: @llvm.x86.avx512.uitofp.round.v32f16.v32i16
2546   return _mm512_cvt_roundepu16_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2547 }
2548
2549 __m512h test_mm512_mask_cvt_roundepu16_ph(__m512h A, __mmask32 B, __m512i C) {
2550   // CHECK-LABEL: test_mm512_mask_cvt_roundepu16_ph
2551   // CHECK: @llvm.x86.avx512.uitofp.round.v32f16.v32i16
2552   return _mm512_mask_cvt_roundepu16_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2553 }
2554
2555 __m512h test_mm512_maskz_cvt_roundepu16_ph(__mmask32 A, __m512i B) {
2556   // CHECK-LABEL: test_mm512_maskz_cvt_roundepu16_ph
2557   // CHECK: @llvm.x86.avx512.uitofp.round.v32f16.v32i16
2558   return _mm512_maskz_cvt_roundepu16_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2559 }
2560
2561 __m512h test_mm512_cvtepu16_ph(__m512i A) {
2562   // CHECK-LABEL: test_mm512_cvtepu16_ph
2563   // CHECK: %{{.*}} = uitofp <32 x i16> %{{.*}} to <32 x half>
2564   return _mm512_cvtepu16_ph(A);
2565 }
2566
2567 __m512h test_mm512_mask_cvtepu16_ph(__m512h A, __mmask32 B, __m512i C) {
2568   // CHECK-LABEL: test_mm512_mask_cvtepu16_ph
2569   // CHECK: %{{.*}} = uitofp <32 x i16> %{{.*}} to <32 x half>
2570   return _mm512_mask_cvtepu16_ph(A, B, C);
2571 }
2572
2573 __m512h test_mm512_maskz_cvtepu16_ph(__mmask32 A, __m512i B) {
2574   // CHECK-LABEL: test_mm512_maskz_cvtepu16_ph
2575   // CHECK: %{{.*}} = uitofp <32 x i16> %{{.*}} to <32 x half>
2576   return _mm512_maskz_cvtepu16_ph(A, B);
2577 }
2578
2579 __m512i test_mm512_cvt_roundph_epi32(__m256h A) {
2580   // CHECK-LABEL: test_mm512_cvt_roundph_epi32
2581   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.512
2582   return _mm512_cvt_roundph_epi32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2583 }
2584
2585 __m512i test_mm512_mask_cvt_roundph_epi32(__m512i A, __mmask16 B, __m256h C) {
2586   // CHECK-LABEL: test_mm512_mask_cvt_roundph_epi32
2587   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.512
2588   return _mm512_mask_cvt_roundph_epi32(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2589 }
2590
2591 __m512i test_mm512_maskz_cvt_roundph_epi32(__mmask16 A, __m256h B) {
2592   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_epi32
2593   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.512
2594   return _mm512_maskz_cvt_roundph_epi32(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2595 }
2596
2597 __m512i test_mm512_cvtph_epi32(__m256h A) {
2598   // CHECK-LABEL: test_mm512_cvtph_epi32
2599   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.512
2600   return _mm512_cvtph_epi32(A);
2601 }
2602
2603 __m512i test_mm512_mask_cvtph_epi32(__m512i A, __mmask16 B, __m256h C) {
2604   // CHECK-LABEL: test_mm512_mask_cvtph_epi32
2605   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.512
2606   return _mm512_mask_cvtph_epi32(A, B, C);
2607 }
2608
2609 __m512i test_mm512_maskz_cvtph_epi32(__mmask16 A, __m256h B) {
2610   // CHECK-LABEL: test_mm512_maskz_cvtph_epi32
2611   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.512
2612   return _mm512_maskz_cvtph_epi32(A, B);
2613 }
2614
2615 __m512i test_mm512_cvt_roundph_epu32(__m256h A) {
2616   // CHECK-LABEL: test_mm512_cvt_roundph_epu32
2617   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.512
2618   return _mm512_cvt_roundph_epu32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2619 }
2620
2621 __m512i test_mm512_mask_cvt_roundph_epu32(__m512i A, __mmask16 B, __m256h C) {
2622   // CHECK-LABEL: test_mm512_mask_cvt_roundph_epu32
2623   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.512
2624   return _mm512_mask_cvt_roundph_epu32(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2625 }
2626
2627 __m512i test_mm512_maskz_cvt_roundph_epu32(__mmask16 A, __m256h B) {
2628   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_epu32
2629   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.512
2630   return _mm512_maskz_cvt_roundph_epu32(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2631 }
2632
2633 __m512i test_mm512_cvtph_epu32(__m256h A) {
2634   // CHECK-LABEL: test_mm512_cvtph_epu32
2635   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.512
2636   return _mm512_cvtph_epu32(A);
2637 }
2638
2639 __m512i test_mm512_mask_cvtph_epu32(__m512i A, __mmask16 B, __m256h C) {
2640   // CHECK-LABEL: test_mm512_mask_cvtph_epu32
2641   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.512
2642   return _mm512_mask_cvtph_epu32(A, B, C);
2643 }
2644
2645 __m512i test_mm512_maskz_cvtph_epu32(__mmask16 A, __m256h B) {
2646   // CHECK-LABEL: test_mm512_maskz_cvtph_epu32
2647   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.512
2648   return _mm512_maskz_cvtph_epu32(A, B);
2649 }
2650
2651 __m256h test_mm512_cvt_roundepi32_ph(__m512i A) {
2652   // CHECK-LABEL: test_mm512_cvt_roundepi32_ph
2653   // CHECK: @llvm.x86.avx512.sitofp.round.v16f16.v16i32
2654   return _mm512_cvt_roundepi32_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2655 }
2656
2657 __m256h test_mm512_mask_cvt_roundepi32_ph(__m256h A, __mmask16 B, __m512i C) {
2658   // CHECK-LABEL: test_mm512_mask_cvt_roundepi32_ph
2659   // CHECK: @llvm.x86.avx512.sitofp.round.v16f16.v16i32
2660   return _mm512_mask_cvt_roundepi32_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2661 }
2662
2663 __m256h test_mm512_maskz_cvt_roundepi32_ph(__mmask16 A, __m512i B) {
2664   // CHECK-LABEL: test_mm512_maskz_cvt_roundepi32_ph
2665   // CHECK: @llvm.x86.avx512.sitofp.round.v16f16.v16i32
2666   return _mm512_maskz_cvt_roundepi32_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2667 }
2668
2669 __m256h test_mm512_cvtepi32_ph(__m512i A) {
2670   // CHECK-LABEL: test_mm512_cvtepi32_ph
2671   // CHECK: %{{.*}} = sitofp <16 x i32> %{{.*}} to <16 x half>
2672   return _mm512_cvtepi32_ph(A);
2673 }
2674
2675 __m256h test_mm512_mask_cvtepi32_ph(__m256h A, __mmask16 B, __m512i C) {
2676   // CHECK-LABEL: test_mm512_mask_cvtepi32_ph
2677   // CHECK: %{{.*}} = sitofp <16 x i32> %{{.*}} to <16 x half>
2678   return _mm512_mask_cvtepi32_ph(A, B, C);
2679 }
2680
2681 __m256h test_mm512_maskz_cvtepi32_ph(__mmask16 A, __m512i B) {
2682   // CHECK-LABEL: test_mm512_maskz_cvtepi32_ph
2683   // CHECK: %{{.*}} = sitofp <16 x i32> %{{.*}} to <16 x half>
2684   return _mm512_maskz_cvtepi32_ph(A, B);
2685 }
2686
2687 __m256h test_mm512_cvt_roundepu32_ph(__m512i A) {
2688   // CHECK-LABEL: test_mm512_cvt_roundepu32_ph
2689   // CHECK: @llvm.x86.avx512.uitofp.round.v16f16.v16i32
2690   return _mm512_cvt_roundepu32_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2691 }
2692
2693 __m256h test_mm512_mask_cvt_roundepu32_ph(__m256h A, __mmask16 B, __m512i C) {
2694   // CHECK-LABEL: test_mm512_mask_cvt_roundepu32_ph
2695   // CHECK: @llvm.x86.avx512.uitofp.round.v16f16.v16i32
2696   return _mm512_mask_cvt_roundepu32_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2697 }
2698
2699 __m256h test_mm512_maskz_cvt_roundepu32_ph(__mmask16 A, __m512i B) {
2700   // CHECK-LABEL: test_mm512_maskz_cvt_roundepu32_ph
2701   // CHECK: @llvm.x86.avx512.uitofp.round.v16f16.v16i32
2702   return _mm512_maskz_cvt_roundepu32_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2703 }
2704
2705 __m256h test_mm512_cvtepu32_ph(__m512i A) {
2706   // CHECK-LABEL: test_mm512_cvtepu32_ph
2707   // CHECK: %{{.*}} = uitofp <16 x i32> %{{.*}} to <16 x half>
2708   return _mm512_cvtepu32_ph(A);
2709 }
2710
2711 __m256h test_mm512_mask_cvtepu32_ph(__m256h A, __mmask16 B, __m512i C) {
2712   // CHECK-LABEL: test_mm512_mask_cvtepu32_ph
2713   // CHECK: %{{.*}} = uitofp <16 x i32> %{{.*}} to <16 x half>
2714   return _mm512_mask_cvtepu32_ph(A, B, C);
2715 }
2716
2717 __m256h test_mm512_maskz_cvtepu32_ph(__mmask16 A, __m512i B) {
2718   // CHECK-LABEL: test_mm512_maskz_cvtepu32_ph
2719   // CHECK: %{{.*}} = uitofp <16 x i32> %{{.*}} to <16 x half>
2720   return _mm512_maskz_cvtepu32_ph(A, B);
2721 }
2722
2723 __m512i test_mm512_cvtt_roundph_epi32(__m256h A) {
2724   // CHECK-LABEL: test_mm512_cvtt_roundph_epi32
2725   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.512
2726   return _mm512_cvtt_roundph_epi32(A, _MM_FROUND_NO_EXC);
2727 }
2728
2729 __m512i test_mm512_mask_cvtt_roundph_epi32(__m512i A, __mmask16 B, __m256h C) {
2730   // CHECK-LABEL: test_mm512_mask_cvtt_roundph_epi32
2731   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.512
2732   return _mm512_mask_cvtt_roundph_epi32(A, B, C, _MM_FROUND_NO_EXC);
2733 }
2734
2735 __m512i test_mm512_maskz_cvtt_roundph_epi32(__mmask16 A, __m256h B) {
2736   // CHECK-LABEL: test_mm512_maskz_cvtt_roundph_epi32
2737   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.512
2738   return _mm512_maskz_cvtt_roundph_epi32(A, B, _MM_FROUND_NO_EXC);
2739 }
2740
2741 __m512i test_mm512_cvttph_epi32(__m256h A) {
2742   // CHECK-LABEL: test_mm512_cvttph_epi32
2743   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.512
2744   return _mm512_cvttph_epi32(A);
2745 }
2746
2747 __m512i test_mm512_mask_cvttph_epi32(__m512i A, __mmask16 B, __m256h C) {
2748   // CHECK-LABEL: test_mm512_mask_cvttph_epi32
2749   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.512
2750   return _mm512_mask_cvttph_epi32(A, B, C);
2751 }
2752
2753 __m512i test_mm512_maskz_cvttph_epi32(__mmask16 A, __m256h B) {
2754   // CHECK-LABEL: test_mm512_maskz_cvttph_epi32
2755   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.512
2756   return _mm512_maskz_cvttph_epi32(A, B);
2757 }
2758
2759 __m512i test_mm512_cvtt_roundph_epu32(__m256h A) {
2760   // CHECK-LABEL: test_mm512_cvtt_roundph_epu32
2761   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.512
2762   return _mm512_cvtt_roundph_epu32(A, _MM_FROUND_NO_EXC);
2763 }
2764
2765 __m512i test_mm512_mask_cvtt_roundph_epu32(__m512i A, __mmask16 B, __m256h C) {
2766   // CHECK-LABEL: test_mm512_mask_cvtt_roundph_epu32
2767   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.512
2768   return _mm512_mask_cvtt_roundph_epu32(A, B, C, _MM_FROUND_NO_EXC);
2769 }
2770
2771 __m512i test_mm512_maskz_cvtt_roundph_epu32(__mmask16 A, __m256h B) {
2772   // CHECK-LABEL: test_mm512_maskz_cvtt_roundph_epu32
2773   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.512
2774   return _mm512_maskz_cvtt_roundph_epu32(A, B, _MM_FROUND_NO_EXC);
2775 }
2776
2777 __m512i test_mm512_cvttph_epu32(__m256h A) {
2778   // CHECK-LABEL: test_mm512_cvttph_epu32
2779   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.512
2780   return _mm512_cvttph_epu32(A);
2781 }
2782
2783 __m512i test_mm512_mask_cvttph_epu32(__m512i A, __mmask16 B, __m256h C) {
2784   // CHECK-LABEL: test_mm512_mask_cvttph_epu32
2785   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.512
2786   return _mm512_mask_cvttph_epu32(A, B, C);
2787 }
2788
2789 __m512i test_mm512_maskz_cvttph_epu32(__mmask16 A, __m256h B) {
2790   // CHECK-LABEL: test_mm512_maskz_cvttph_epu32
2791   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.512
2792   return _mm512_maskz_cvttph_epu32(A, B);
2793 }
2794
2795 __m128h test_mm512_cvt_roundepi64_ph(__m512i A) {
2796   // CHECK-LABEL: test_mm512_cvt_roundepi64_ph
2797   // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v8i64
2798   return _mm512_cvt_roundepi64_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2799 }
2800
2801 __m128h test_mm512_mask_cvt_roundepi64_ph(__m128h A, __mmask8 B, __m512i C) {
2802   // CHECK-LABEL: test_mm512_mask_cvt_roundepi64_ph
2803   // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v8i64
2804   return _mm512_mask_cvt_roundepi64_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2805 }
2806
2807 __m128h test_mm512_maskz_cvt_roundepi64_ph(__mmask8 A, __m512i B) {
2808   // CHECK-LABEL: test_mm512_maskz_cvt_roundepi64_ph
2809   // CHECK: @llvm.x86.avx512.sitofp.round.v8f16.v8i64
2810   return _mm512_maskz_cvt_roundepi64_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2811 }
2812
2813 __m128h test_mm512_cvtepi64_ph(__m512i A) {
2814   // CHECK-LABEL: test_mm512_cvtepi64_ph
2815   // CHECK: %{{.*}} = sitofp <8 x i64> %{{.*}} to <8 x half>
2816   return _mm512_cvtepi64_ph(A);
2817 }
2818
2819 __m128h test_mm512_mask_cvtepi64_ph(__m128h A, __mmask8 B, __m512i C) {
2820   // CHECK-LABEL: test_mm512_mask_cvtepi64_ph
2821   // CHECK: %{{.*}} = sitofp <8 x i64> %{{.*}} to <8 x half>
2822   return _mm512_mask_cvtepi64_ph(A, B, C);
2823 }
2824
2825 __m128h test_mm512_maskz_cvtepi64_ph(__mmask8 A, __m512i B) {
2826   // CHECK-LABEL: test_mm512_maskz_cvtepi64_ph
2827   // CHECK: %{{.*}} = sitofp <8 x i64> %{{.*}} to <8 x half>
2828   return _mm512_maskz_cvtepi64_ph(A, B);
2829 }
2830
2831 __m512i test_mm512_cvt_roundph_epi64(__m128h A) {
2832   // CHECK-LABEL: test_mm512_cvt_roundph_epi64
2833   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.512
2834   return _mm512_cvt_roundph_epi64(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2835 }
2836
2837 __m512i test_mm512_mask_cvt_roundph_epi64(__m512i A, __mmask8 B, __m128h C) {
2838   // CHECK-LABEL: test_mm512_mask_cvt_roundph_epi64
2839   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.512
2840   return _mm512_mask_cvt_roundph_epi64(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2841 }
2842
2843 __m512i test_mm512_maskz_cvt_roundph_epi64(__mmask8 A, __m128h B) {
2844   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_epi64
2845   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.512
2846   return _mm512_maskz_cvt_roundph_epi64(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2847 }
2848
2849 __m512i test_mm512_cvtph_epi64(__m128h A) {
2850   // CHECK-LABEL: test_mm512_cvtph_epi64
2851   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.512
2852   return _mm512_cvtph_epi64(A);
2853 }
2854
2855 __m512i test_mm512_mask_cvtph_epi64(__m512i A, __mmask8 B, __m128h C) {
2856   // CHECK-LABEL: test_mm512_mask_cvtph_epi64
2857   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.512
2858   return _mm512_mask_cvtph_epi64(A, B, C);
2859 }
2860
2861 __m512i test_mm512_maskz_cvtph_epi64(__mmask8 A, __m128h B) {
2862   // CHECK-LABEL: test_mm512_maskz_cvtph_epi64
2863   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.512
2864   return _mm512_maskz_cvtph_epi64(A, B);
2865 }
2866
2867 __m128h test_mm512_cvt_roundepu64_ph(__m512i A) {
2868   // CHECK-LABEL: test_mm512_cvt_roundepu64_ph
2869   // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v8i64
2870   return _mm512_cvt_roundepu64_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2871 }
2872
2873 __m128h test_mm512_mask_cvt_roundepu64_ph(__m128h A, __mmask8 B, __m512i C) {
2874   // CHECK-LABEL: test_mm512_mask_cvt_roundepu64_ph
2875   // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v8i64
2876   return _mm512_mask_cvt_roundepu64_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2877 }
2878
2879 __m128h test_mm512_maskz_cvt_roundepu64_ph(__mmask8 A, __m512i B) {
2880   // CHECK-LABEL: test_mm512_maskz_cvt_roundepu64_ph
2881   // CHECK: @llvm.x86.avx512.uitofp.round.v8f16.v8i64
2882   return _mm512_maskz_cvt_roundepu64_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2883 }
2884
2885 __m128h test_mm512_cvtepu64_ph(__m512i A) {
2886   // CHECK-LABEL: test_mm512_cvtepu64_ph
2887   // CHECK: %{{.*}} = uitofp <8 x i64> %{{.*}} to <8 x half>
2888   return _mm512_cvtepu64_ph(A);
2889 }
2890
2891 __m128h test_mm512_mask_cvtepu64_ph(__m128h A, __mmask8 B, __m512i C) {
2892   // CHECK-LABEL: test_mm512_mask_cvtepu64_ph
2893   // CHECK: %{{.*}} = uitofp <8 x i64> %{{.*}} to <8 x half>
2894   return _mm512_mask_cvtepu64_ph(A, B, C);
2895 }
2896
2897 __m128h test_mm512_maskz_cvtepu64_ph(__mmask8 A, __m512i B) {
2898   // CHECK-LABEL: test_mm512_maskz_cvtepu64_ph
2899   // CHECK: %{{.*}} = uitofp <8 x i64> %{{.*}} to <8 x half>
2900   return _mm512_maskz_cvtepu64_ph(A, B);
2901 }
2902
2903 __m512i test_mm512_cvt_roundph_epu64(__m128h A) {
2904   // CHECK-LABEL: test_mm512_cvt_roundph_epu64
2905   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.512
2906   return _mm512_cvt_roundph_epu64(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2907 }
2908
2909 __m512i test_mm512_mask_cvt_roundph_epu64(__m512i A, __mmask8 B, __m128h C) {
2910   // CHECK-LABEL: test_mm512_mask_cvt_roundph_epu64
2911   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.512
2912   return _mm512_mask_cvt_roundph_epu64(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2913 }
2914
2915 __m512i test_mm512_maskz_cvt_roundph_epu64(__mmask8 A, __m128h B) {
2916   // CHECK-LABEL: test_mm512_maskz_cvt_roundph_epu64
2917   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.512
2918   return _mm512_maskz_cvt_roundph_epu64(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
2919 }
2920
2921 __m512i test_mm512_cvtph_epu64(__m128h A) {
2922   // CHECK-LABEL: test_mm512_cvtph_epu64
2923   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.512
2924   return _mm512_cvtph_epu64(A);
2925 }
2926
2927 __m512i test_mm512_mask_cvtph_epu64(__m512i A, __mmask8 B, __m128h C) {
2928   // CHECK-LABEL: test_mm512_mask_cvtph_epu64
2929   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.512
2930   return _mm512_mask_cvtph_epu64(A, B, C);
2931 }
2932
2933 __m512i test_mm512_maskz_cvtph_epu64(__mmask8 A, __m128h B) {
2934   // CHECK-LABEL: test_mm512_maskz_cvtph_epu64
2935   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.512
2936   return _mm512_maskz_cvtph_epu64(A, B);
2937 }
2938
2939 __m512i test_mm512_cvtt_roundph_epi64(__m128h A) {
2940   // CHECK-LABEL: test_mm512_cvtt_roundph_epi64
2941   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.512
2942   return _mm512_cvtt_roundph_epi64(A, _MM_FROUND_NO_EXC);
2943 }
2944
2945 __m512i test_mm512_mask_cvtt_roundph_epi64(__m512i A, __mmask8 B, __m128h C) {
2946   // CHECK-LABEL: test_mm512_mask_cvtt_roundph_epi64
2947   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.512
2948   return _mm512_mask_cvtt_roundph_epi64(A, B, C, _MM_FROUND_NO_EXC);
2949 }
2950
2951 __m512i test_mm512_maskz_cvtt_roundph_epi64(__mmask8 A, __m128h B) {
2952   // CHECK-LABEL: test_mm512_maskz_cvtt_roundph_epi64
2953   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.512
2954   return _mm512_maskz_cvtt_roundph_epi64(A, B, _MM_FROUND_NO_EXC);
2955 }
2956
2957 __m512i test_mm512_cvttph_epi64(__m128h A) {
2958   // CHECK-LABEL: test_mm512_cvttph_epi64
2959   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.512
2960   return _mm512_cvttph_epi64(A);
2961 }
2962
2963 __m512i test_mm512_mask_cvttph_epi64(__m512i A, __mmask8 B, __m128h C) {
2964   // CHECK-LABEL: test_mm512_mask_cvttph_epi64
2965   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.512
2966   return _mm512_mask_cvttph_epi64(A, B, C);
2967 }
2968
2969 __m512i test_mm512_maskz_cvttph_epi64(__mmask8 A, __m128h B) {
2970   // CHECK-LABEL: test_mm512_maskz_cvttph_epi64
2971   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.512
2972   return _mm512_maskz_cvttph_epi64(A, B);
2973 }
2974
2975 __m512i test_mm512_cvtt_roundph_epu64(__m128h A) {
2976   // CHECK-LABEL: test_mm512_cvtt_roundph_epu64
2977   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.512
2978   return _mm512_cvtt_roundph_epu64(A, _MM_FROUND_NO_EXC);
2979 }
2980
2981 __m512i test_mm512_mask_cvtt_roundph_epu64(__m512i A, __mmask8 B, __m128h C) {
2982   // CHECK-LABEL: test_mm512_mask_cvtt_roundph_epu64
2983   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.512
2984   return _mm512_mask_cvtt_roundph_epu64(A, B, C, _MM_FROUND_NO_EXC);
2985 }
2986
2987 __m512i test_mm512_maskz_cvtt_roundph_epu64(__mmask8 A, __m128h B) {
2988   // CHECK-LABEL: test_mm512_maskz_cvtt_roundph_epu64
2989   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.512
2990   return _mm512_maskz_cvtt_roundph_epu64(A, B, _MM_FROUND_NO_EXC);
2991 }
2992
2993 __m512i test_mm512_cvttph_epu64(__m128h A) {
2994   // CHECK-LABEL: test_mm512_cvttph_epu64
2995   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.512
2996   return _mm512_cvttph_epu64(A);
2997 }
2998
2999 __m512i test_mm512_mask_cvttph_epu64(__m512i A, __mmask8 B, __m128h C) {
3000   // CHECK-LABEL: test_mm512_mask_cvttph_epu64
3001   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.512
3002   return _mm512_mask_cvttph_epu64(A, B, C);
3003 }
3004
3005 __m512i test_mm512_maskz_cvttph_epu64(__mmask8 A, __m128h B) {
3006   // CHECK-LABEL: test_mm512_maskz_cvttph_epu64
3007   // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.512
3008   return _mm512_maskz_cvttph_epu64(A, B);
3009 }
3010
3011 int test_mm_cvt_roundsh_i32(__m128h A) {
3012   // CHECK-LABEL: test_mm_cvt_roundsh_i32
3013   // CHECK: @llvm.x86.avx512fp16.vcvtsh2si32
3014   return _mm_cvt_roundsh_i32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3015 }
3016
3017 int test_mm_cvtsh_i32(__m128h A) {
3018   // CHECK-LABEL: test_mm_cvtsh_i32
3019   // CHECK: @llvm.x86.avx512fp16.vcvtsh2si32
3020   return _mm_cvtsh_i32(A);
3021 }
3022
3023 unsigned int test_mm_cvt_roundsh_u32(__m128h A) {
3024   // CHECK-LABEL: test_mm_cvt_roundsh_u32
3025   // CHECK: @llvm.x86.avx512fp16.vcvtsh2usi32
3026   return _mm_cvt_roundsh_u32(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3027 }
3028
3029 unsigned int test_mm_cvtsh_u32(__m128h A) {
3030   // CHECK-LABEL: test_mm_cvtsh_u32
3031   // CHECK: @llvm.x86.avx512fp16.vcvtsh2usi32
3032   return _mm_cvtsh_u32(A);
3033 }
3034
3035 #ifdef __x86_64__
3036 long long test_mm_cvt_roundsh_i64(__m128h A) {
3037   // CHECK-LABEL: test_mm_cvt_roundsh_i64
3038   // CHECK: @llvm.x86.avx512fp16.vcvtsh2si64
3039   return _mm_cvt_roundsh_i64(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3040 }
3041
3042 long long test_mm_cvtsh_i64(__m128h A) {
3043   // CHECK-LABEL: test_mm_cvtsh_i64
3044   // CHECK: @llvm.x86.avx512fp16.vcvtsh2si64
3045   return _mm_cvtsh_i64(A);
3046 }
3047
3048 unsigned long long test_mm_cvt_roundsh_u64(__m128h A) {
3049   // CHECK-LABEL: test_mm_cvt_roundsh_u64
3050   // CHECK: @llvm.x86.avx512fp16.vcvtsh2usi64
3051   return _mm_cvt_roundsh_u64(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3052 }
3053
3054 unsigned long long test_mm_cvtsh_u64(__m128h A) {
3055   // CHECK-LABEL: test_mm_cvtsh_u64
3056   // CHECK: @llvm.x86.avx512fp16.vcvtsh2usi64
3057   return _mm_cvtsh_u64(A);
3058 }
3059 #endif
3060
3061 __m128h test_mm_cvt_roundu32_sh(__m128h A, unsigned int B) {
3062   // CHECK-LABEL: test_mm_cvt_roundu32_sh
3063   // CHECK: @llvm.x86.avx512fp16.vcvtusi2sh
3064   return _mm_cvt_roundu32_sh(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3065 }
3066
3067 __m128h test_mm_cvtu32_sh(__m128h A, unsigned int B) {
3068   // CHECK-LABEL: test_mm_cvtu32_sh
3069   // CHECK: %{{.*}} = uitofp i32 %{{.*}} to half
3070   return _mm_cvtu32_sh(A, B);
3071 }
3072
3073 #ifdef __x86_64__
3074 __m128h test_mm_cvt_roundu64_sh(__m128h A, unsigned long long B) {
3075   // CHECK-LABEL: test_mm_cvt_roundu64_sh
3076   // CHECK: @llvm.x86.avx512fp16.vcvtusi642sh
3077   return _mm_cvt_roundu64_sh(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3078 }
3079
3080 __m128h test_mm_cvtu64_sh(__m128h A, unsigned long long B) {
3081   // CHECK-LABEL: test_mm_cvtu64_sh
3082   // CHECK: %{{.*}} = uitofp i64 %{{.*}} to half
3083   return _mm_cvtu64_sh(A, B);
3084 }
3085 #endif
3086
3087 __m128h test_mm_cvt_roundi32_sh(__m128h A, int B) {
3088   // CHECK-LABEL: test_mm_cvt_roundi32_sh
3089   // CHECK: @llvm.x86.avx512fp16.vcvtsi2sh
3090   return _mm_cvt_roundi32_sh(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3091 }
3092
3093 __m128h test_mm_cvti32_sh(__m128h A, int B) {
3094   // CHECK-LABEL: test_mm_cvti32_sh
3095   // CHECK: %{{.*}} = sitofp i32 %{{.*}} to half
3096   return _mm_cvti32_sh(A, B);
3097 }
3098
3099 #ifdef __x86_64__
3100 __m128h test_mm_cvt_roundi64_sh(__m128h A, long long B) {
3101   // CHECK-LABEL: test_mm_cvt_roundi64_sh
3102   // CHECK: @llvm.x86.avx512fp16.vcvtsi642sh
3103   return _mm_cvt_roundi64_sh(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3104 }
3105
3106 __m128h test_mm_cvti64_sh(__m128h A, long long B) {
3107   // CHECK-LABEL: test_mm_cvti64_sh
3108   // CHECK: %{{.*}} = sitofp i64 %{{.*}} to half
3109   return _mm_cvti64_sh(A, B);
3110 }
3111 #endif
3112
3113 int test_mm_cvtt_roundsh_i32(__m128h A) {
3114   // CHECK-LABEL: test_mm_cvtt_roundsh_i32
3115   // CHECK: @llvm.x86.avx512fp16.vcvttsh2si32
3116   return _mm_cvtt_roundsh_i32(A, _MM_FROUND_NO_EXC);
3117 }
3118
3119 int test_mm_cvttsh_i32(__m128h A) {
3120   // CHECK-LABEL: test_mm_cvttsh_i32
3121   // CHECK: @llvm.x86.avx512fp16.vcvttsh2si32
3122   return _mm_cvttsh_i32(A);
3123 }
3124
3125 #ifdef __x86_64__
3126 long long test_mm_cvtt_roundsh_i64(__m128h A) {
3127   // CHECK-LABEL: test_mm_cvtt_roundsh_i64
3128   // CHECK: @llvm.x86.avx512fp16.vcvttsh2si64
3129   return _mm_cvtt_roundsh_i64(A, _MM_FROUND_NO_EXC);
3130 }
3131
3132 long long test_mm_cvttsh_i64(__m128h A) {
3133   // CHECK-LABEL: test_mm_cvttsh_i64
3134   // CHECK: @llvm.x86.avx512fp16.vcvttsh2si64
3135   return _mm_cvttsh_i64(A);
3136 }
3137 #endif
3138
3139 unsigned int test_mm_cvtt_roundsh_u32(__m128h A) {
3140   // CHECK-LABEL: test_mm_cvtt_roundsh_u32
3141   // CHECK: @llvm.x86.avx512fp16.vcvttsh2usi32
3142   return _mm_cvtt_roundsh_u32(A, _MM_FROUND_NO_EXC);
3143 }
3144
3145 unsigned int test_mm_cvttsh_u32(__m128h A) {
3146   // CHECK-LABEL: test_mm_cvttsh_u32
3147   // CHECK: @llvm.x86.avx512fp16.vcvttsh2usi32
3148   return _mm_cvttsh_u32(A);
3149 }
3150
3151 #ifdef __x86_64__
3152 unsigned long long test_mm_cvtt_roundsh_u64(__m128h A) {
3153   // CHECK-LABEL: test_mm_cvtt_roundsh_u64
3154   // CHECK: @llvm.x86.avx512fp16.vcvttsh2usi64
3155   return _mm_cvtt_roundsh_u64(A, _MM_FROUND_NO_EXC);
3156 }
3157
3158 unsigned long long test_mm_cvttsh_u64(__m128h A) {
3159   // CHECK-LABEL: test_mm_cvttsh_u64
3160   // CHECK: @llvm.x86.avx512fp16.vcvttsh2usi64
3161   return _mm_cvttsh_u64(A);
3162 }
3163 #endif
3164
3165 __m512 test_mm512_cvtx_roundph_ps(__m256h A) {
3166   // CHECK-LABEL: test_mm512_cvtx_roundph_ps
3167   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.512
3168   return _mm512_cvtx_roundph_ps(A, _MM_FROUND_NO_EXC);
3169 }
3170
3171 __m512 test_mm512_mask_cvtx_roundph_ps(__m512 A, __mmask16 B, __m256h C) {
3172   // CHECK-LABEL: test_mm512_mask_cvtx_roundph_ps
3173   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.512
3174   return _mm512_mask_cvtx_roundph_ps(A, B, C, _MM_FROUND_NO_EXC);
3175 }
3176
3177 __m512 test_mm512_maskz_cvtx_roundph_ps(__mmask16 A, __m256h B) {
3178   // CHECK-LABEL: test_mm512_maskz_cvtx_roundph_ps
3179   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.512
3180   return _mm512_maskz_cvtx_roundph_ps(A, B, _MM_FROUND_NO_EXC);
3181 }
3182
3183 __m512 test_mm512_cvtxph_ps(__m256h A) {
3184   // CHECK-LABEL: test_mm512_cvtxph_ps
3185   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.512
3186   return _mm512_cvtxph_ps(A);
3187 }
3188
3189 __m512 test_mm512_mask_cvtxph_ps(__m512 A, __mmask16 B, __m256h C) {
3190   // CHECK-LABEL: test_mm512_mask_cvtxph_ps
3191   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.512
3192   return _mm512_mask_cvtxph_ps(A, B, C);
3193 }
3194
3195 __m512 test_mm512_maskz_cvtxph_ps(__mmask16 A, __m256h B) {
3196   // CHECK-LABEL: test_mm512_maskz_cvtxph_ps
3197   // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.512
3198   return _mm512_maskz_cvtxph_ps(A, B);
3199 }
3200
3201 __m256h test_mm512_cvtx_roundps_ph(__m512 A) {
3202   // CHECK-LABEL: test_mm512_cvtx_roundps_ph
3203   // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.512
3204   return _mm512_cvtx_roundps_ph(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3205 }
3206
3207 __m256h test_mm512_mask_cvtx_roundps_ph(__m256h A, __mmask16 B, __m512 C) {
3208   // CHECK-LABEL: test_mm512_mask_cvtx_roundps_ph
3209   // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.512
3210   return _mm512_mask_cvtx_roundps_ph(A, B, C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3211 }
3212
3213 __m256h test_mm512_maskz_cvtx_roundps_ph(__mmask16 A, __m512 B) {
3214   // CHECK-LABEL: test_mm512_maskz_cvtx_roundps_ph
3215   // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.512
3216   return _mm512_maskz_cvtx_roundps_ph(A, B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3217 }
3218
3219 __m256h test_mm512_cvtxps_ph(__m512 A) {
3220   // CHECK-LABEL: test_mm512_cvtxps_ph
3221   // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.512
3222   return _mm512_cvtxps_ph(A);
3223 }
3224
3225 __m256h test_mm512_mask_cvtxps_ph(__m256h A, __mmask16 B, __m512 C) {
3226   // CHECK-LABEL: test_mm512_mask_cvtxps_ph
3227   // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.512
3228   return _mm512_mask_cvtxps_ph(A, B, C);
3229 }
3230
3231 __m256h test_mm512_maskz_cvtxps_ph(__mmask16 A, __m512 B) {
3232   // CHECK-LABEL: test_mm512_maskz_cvtxps_ph
3233   // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.512
3234   return _mm512_maskz_cvtxps_ph(A, B);
3235 }
3236
3237 __m512h test_mm512_fmadd_round_ph(__m512h __A, __m512h __B, __m512h __C) {
3238   // CHECK-LABEL: @test_mm512_fmadd_round_ph
3239   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3240   return _mm512_fmadd_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3241 }
3242
3243 __m512h test_mm512_mask_fmadd_round_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3244   // CHECK-LABEL: @test_mm512_mask_fmadd_round_ph
3245   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3246   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3247   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3248   return _mm512_mask_fmadd_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3249 }
3250
3251 __m512h test_mm512_mask3_fmadd_round_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3252   // CHECK-LABEL: @test_mm512_mask3_fmadd_round_ph
3253   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3254   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3255   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3256   return _mm512_mask3_fmadd_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3257 }
3258
3259 __m512h test_mm512_maskz_fmadd_round_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3260   // CHECK-LABEL: @test_mm512_maskz_fmadd_round_ph
3261   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3262   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3263   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3264   return _mm512_maskz_fmadd_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3265 }
3266
3267 __m512h test_mm512_fmsub_round_ph(__m512h __A, __m512h __B, __m512h __C) {
3268   // CHECK-LABEL: @test_mm512_fmsub_round_ph
3269   // CHECK: fneg
3270   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3271   return _mm512_fmsub_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3272 }
3273
3274 __m512h test_mm512_mask_fmsub_round_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3275   // CHECK-LABEL: @test_mm512_mask_fmsub_round_ph
3276   // CHECK: fneg
3277   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3278   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3279   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3280   return _mm512_mask_fmsub_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3281 }
3282
3283 __m512h test_mm512_maskz_fmsub_round_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3284   // CHECK-LABEL: @test_mm512_maskz_fmsub_round_ph
3285   // CHECK: fneg
3286   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3287   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3288   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3289   return _mm512_maskz_fmsub_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3290 }
3291
3292 __m512h test_mm512_fnmadd_round_ph(__m512h __A, __m512h __B, __m512h __C) {
3293   // CHECK-LABEL: @test_mm512_fnmadd_round_ph
3294   // CHECK: fneg
3295   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3296   return _mm512_fnmadd_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3297 }
3298
3299 __m512h test_mm512_mask3_fnmadd_round_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3300   // CHECK-LABEL: @test_mm512_mask3_fnmadd_round_ph
3301   // CHECK: fneg
3302   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3303   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3304   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3305   return _mm512_mask3_fnmadd_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3306 }
3307
3308 __m512h test_mm512_maskz_fnmadd_round_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3309   // CHECK-LABEL: @test_mm512_maskz_fnmadd_round_ph
3310   // CHECK: fneg
3311   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3312   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3313   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3314   return _mm512_maskz_fnmadd_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3315 }
3316
3317 __m512h test_mm512_fnmsub_round_ph(__m512h __A, __m512h __B, __m512h __C) {
3318   // CHECK-LABEL: @test_mm512_fnmsub_round_ph
3319   // CHECK: fneg
3320   // CHECK: fneg
3321   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3322   return _mm512_fnmsub_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3323 }
3324
3325 __m512h test_mm512_maskz_fnmsub_round_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3326   // CHECK-LABEL: @test_mm512_maskz_fnmsub_round_ph
3327   // CHECK: fneg
3328   // CHECK: fneg
3329   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3330   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3331   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3332   return _mm512_maskz_fnmsub_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3333 }
3334
3335 __m512h test_mm512_fmadd_ph(__m512h __A, __m512h __B, __m512h __C) {
3336   // CHECK-LABEL: @test_mm512_fmadd_ph
3337   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3338   return _mm512_fmadd_ph(__A, __B, __C);
3339 }
3340
3341 __m512h test_mm512_mask_fmadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3342   // CHECK-LABEL: @test_mm512_mask_fmadd_ph
3343   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3344   return _mm512_mask_fmadd_ph(__A, __U, __B, __C);
3345 }
3346
3347 __m512h test_mm512_mask3_fmadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3348   // CHECK-LABEL: @test_mm512_mask3_fmadd_ph
3349   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3350   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3351   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3352   return _mm512_mask3_fmadd_ph(__A, __B, __C, __U);
3353 }
3354
3355 __m512h test_mm512_maskz_fmadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3356   // CHECK-LABEL: @test_mm512_maskz_fmadd_ph
3357   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3358   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3359   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3360   return _mm512_maskz_fmadd_ph(__U, __A, __B, __C);
3361 }
3362
3363 __m512h test_mm512_fmsub_ph(__m512h __A, __m512h __B, __m512h __C) {
3364   // CHECK-LABEL: @test_mm512_fmsub_ph
3365   // CHECK: fneg
3366   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3367   return _mm512_fmsub_ph(__A, __B, __C);
3368 }
3369
3370 __m512h test_mm512_mask_fmsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3371   // CHECK-LABEL: @test_mm512_mask_fmsub_ph
3372   // CHECK: fneg
3373   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3374   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3375   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3376   return _mm512_mask_fmsub_ph(__A, __U, __B, __C);
3377 }
3378
3379 __m512h test_mm512_maskz_fmsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3380   // CHECK-LABEL: @test_mm512_maskz_fmsub_ph
3381   // CHECK: fneg
3382   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3383   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3384   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3385   return _mm512_maskz_fmsub_ph(__U, __A, __B, __C);
3386 }
3387
3388 __m512h test_mm512_fnmadd_ph(__m512h __A, __m512h __B, __m512h __C) {
3389   // CHECK-LABEL: @test_mm512_fnmadd_ph
3390   // CHECK: fneg
3391   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3392   return _mm512_fnmadd_ph(__A, __B, __C);
3393 }
3394
3395 __m512h test_mm512_mask3_fnmadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3396   // CHECK-LABEL: @test_mm512_mask3_fnmadd_ph
3397   // CHECK: fneg
3398   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3399   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3400   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3401   return _mm512_mask3_fnmadd_ph(__A, __B, __C, __U);
3402 }
3403
3404 __m512h test_mm512_maskz_fnmadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3405   // CHECK-LABEL: @test_mm512_maskz_fnmadd_ph
3406   // CHECK: fneg
3407   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3408   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3409   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3410   return _mm512_maskz_fnmadd_ph(__U, __A, __B, __C);
3411 }
3412
3413 __m512h test_mm512_fnmsub_ph(__m512h __A, __m512h __B, __m512h __C) {
3414   // CHECK-LABEL: @test_mm512_fnmsub_ph
3415   // CHECK: fneg
3416   // CHECK: fneg
3417   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3418   return _mm512_fnmsub_ph(__A, __B, __C);
3419 }
3420
3421 __m512h test_mm512_maskz_fnmsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3422   // CHECK-LABEL: @test_mm512_maskz_fnmsub_ph
3423   // CHECK: fneg
3424   // CHECK: fneg
3425   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3426   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3427   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3428   return _mm512_maskz_fnmsub_ph(__U, __A, __B, __C);
3429 }
3430
3431 __m512h test_mm512_fmaddsub_round_ph(__m512h __A, __m512h __B, __m512h __C) {
3432   // CHECK-LABEL: @test_mm512_fmaddsub_round_ph
3433   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3434   return _mm512_fmaddsub_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3435 }
3436
3437 __m512h test_mm512_mask_fmaddsub_round_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3438   // CHECK-LABEL: @test_mm512_mask_fmaddsub_round_ph
3439   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3440   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3441   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3442   return _mm512_mask_fmaddsub_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3443 }
3444
3445 __m512h test_mm512_mask3_fmaddsub_round_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3446   // CHECK-LABEL: @test_mm512_mask3_fmaddsub_round_ph
3447   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3448   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3449   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3450   return _mm512_mask3_fmaddsub_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3451 }
3452
3453 __m512h test_mm512_maskz_fmaddsub_round_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3454   // CHECK-LABEL: @test_mm512_maskz_fmaddsub_round_ph
3455   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3456   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3457   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3458   return _mm512_maskz_fmaddsub_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3459 }
3460
3461 __m512h test_mm512_fmsubadd_round_ph(__m512h __A, __m512h __B, __m512h __C) {
3462   // CHECK-LABEL: @test_mm512_fmsubadd_round_ph
3463   // CHECK: fneg
3464   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3465   return _mm512_fmsubadd_round_ph(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3466 }
3467
3468 __m512h test_mm512_mask_fmsubadd_round_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3469   // CHECK-LABEL: @test_mm512_mask_fmsubadd_round_ph
3470   // CHECK: fneg
3471   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3472   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3473   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3474   return _mm512_mask_fmsubadd_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3475 }
3476
3477 __m512h test_mm512_maskz_fmsubadd_round_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3478   // CHECK-LABEL: @test_mm512_maskz_fmsubadd_round_ph
3479   // CHECK: fneg
3480   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3481   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3482   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3483   return _mm512_maskz_fmsubadd_round_ph(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3484 }
3485
3486 __m512h test_mm512_fmaddsub_ph(__m512h __A, __m512h __B, __m512h __C) {
3487   // CHECK-LABEL: @test_mm512_fmaddsub_ph
3488   // CHECK-NOT: fneg
3489   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 4)
3490   return _mm512_fmaddsub_ph(__A, __B, __C);
3491 }
3492
3493 __m512h test_mm512_mask_fmaddsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3494   // CHECK-LABEL: @test_mm512_mask_fmaddsub_ph
3495   // CHECK-NOT: fneg
3496   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 4)
3497   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3498   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3499   return _mm512_mask_fmaddsub_ph(__A, __U, __B, __C);
3500 }
3501
3502 __m512h test_mm512_mask3_fmaddsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3503   // CHECK-LABEL: @test_mm512_mask3_fmaddsub_ph
3504   // CHECK-NOT: fneg
3505   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 4)
3506   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3507   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3508   return _mm512_mask3_fmaddsub_ph(__A, __B, __C, __U);
3509 }
3510
3511 __m512h test_mm512_maskz_fmaddsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3512   // CHECK-LABEL: @test_mm512_maskz_fmaddsub_ph
3513   // CHECK-NOT: fneg
3514   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 4)
3515   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3516   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3517   return _mm512_maskz_fmaddsub_ph(__U, __A, __B, __C);
3518 }
3519
3520 __m512h test_mm512_fmsubadd_ph(__m512h __A, __m512h __B, __m512h __C) {
3521   // CHECK-LABEL: @test_mm512_fmsubadd_ph
3522   // CHECK: [[NEG:%.+]] = fneg
3523   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> [[NEG]], i32 4)
3524   return _mm512_fmsubadd_ph(__A, __B, __C);
3525 }
3526
3527 __m512h test_mm512_mask_fmsubadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3528   // CHECK-LABEL: @test_mm512_mask_fmsubadd_ph
3529   // CHECK: [[NEG:%.+]] = fneg
3530   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> [[NEG]], i32 4)
3531   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3532   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3533   return _mm512_mask_fmsubadd_ph(__A, __U, __B, __C);
3534 }
3535
3536 __m512h test_mm512_maskz_fmsubadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
3537   // CHECK-LABEL: @test_mm512_maskz_fmsubadd_ph
3538   // CHECK: [[NEG:%.+]] = fneg
3539   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> [[NEG]], i32 4)
3540   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3541   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> zeroinitializer
3542   return _mm512_maskz_fmsubadd_ph(__U, __A, __B, __C);
3543 }
3544
3545 __m512h test_mm512_mask3_fmsub_round_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3546   // CHECK-LABEL: @test_mm512_mask3_fmsub_round_ph
3547   // CHECK: fneg
3548   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3549   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3550   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3551   return _mm512_mask3_fmsub_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3552 }
3553
3554 __m512h test_mm512_mask3_fmsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3555   // CHECK-LABEL: @test_mm512_mask3_fmsub_ph
3556   // CHECK: fneg
3557   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3558   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3559   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3560   return _mm512_mask3_fmsub_ph(__A, __B, __C, __U);
3561 }
3562
3563 __m512h test_mm512_mask3_fmsubadd_round_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3564   // CHECK-LABEL: @test_mm512_mask3_fmsubadd_round_ph
3565   // CHECK: fneg
3566   // CHECK: @llvm.x86.avx512fp16.vfmaddsub.ph.512
3567   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3568   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3569   return _mm512_mask3_fmsubadd_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3570 }
3571
3572 __m512h test_mm512_mask3_fmsubadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3573   // CHECK-LABEL: @test_mm512_mask3_fmsubadd_ph
3574   // CHECK: [[NEG:%.+]] = fneg
3575   // CHECK: call <32 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> [[NEG]], i32 4)
3576   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3577   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3578   return _mm512_mask3_fmsubadd_ph(__A, __B, __C, __U);
3579 }
3580
3581 __m512h test_mm512_mask_fnmadd_round_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3582   // CHECK-LABEL: @test_mm512_mask_fnmadd_round_ph
3583   // CHECK: fneg
3584   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3585   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3586   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3587   return _mm512_mask_fnmadd_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3588 }
3589
3590 __m512h test_mm512_mask_fnmadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3591   // CHECK-LABEL: @test_mm512_mask_fnmadd_ph
3592   // CHECK: fneg
3593   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3594   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3595   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3596   return _mm512_mask_fnmadd_ph(__A, __U, __B, __C);
3597 }
3598
3599 __m512h test_mm512_mask_fnmsub_round_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3600   // CHECK-LABEL: @test_mm512_mask_fnmsub_round_ph
3601   // CHECK: fneg
3602   // CHECK: fneg
3603   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3604   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3605   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3606   return _mm512_mask_fnmsub_round_ph(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3607 }
3608
3609 __m512h test_mm512_mask3_fnmsub_round_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3610   // CHECK-LABEL: @test_mm512_mask3_fnmsub_round_ph
3611   // CHECK: fneg
3612   // CHECK: fneg
3613   // CHECK: @llvm.x86.avx512fp16.vfmadd.ph.512
3614   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3615   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3616   return _mm512_mask3_fnmsub_round_ph(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3617 }
3618
3619 __m512h test_mm512_mask_fnmsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
3620   // CHECK-LABEL: @test_mm512_mask_fnmsub_ph
3621   // CHECK: fneg
3622   // CHECK: fneg
3623   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3624   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3625   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3626   return _mm512_mask_fnmsub_ph(__A, __U, __B, __C);
3627 }
3628
3629 __m512h test_mm512_mask3_fnmsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
3630   // CHECK-LABEL: @test_mm512_mask3_fnmsub_ph
3631   // CHECK: fneg
3632   // CHECK: fneg
3633   // CHECK: call <32 x half> @llvm.fma.v32f16(<32 x half> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}})
3634   // CHECK: bitcast i32 %{{.*}} to <32 x i1>
3635   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
3636   return _mm512_mask3_fnmsub_ph(__A, __B, __C, __U);
3637 }
3638
3639 __m128h test_mm_fmadd_sh(__m128h __W, __m128h __A, __m128h __B) {
3640   // CHECK-LABEL: @test_mm_fmadd_sh
3641   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3642   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3643   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3644   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3645   return _mm_fmadd_sh(__W, __A, __B);
3646 }
3647
3648 __m128h test_mm_mask_fmadd_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3649   // CHECK-LABEL: @test_mm_mask_fmadd_sh
3650   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3651   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3652   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3653   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3654   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3655   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3656   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[A]]
3657   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3658   return _mm_mask_fmadd_sh(__W, __U, __A, __B);
3659 }
3660
3661 __m128h test_mm_fmadd_round_sh(__m128h __A, __m128h __B, __m128h __C) {
3662   // CHECK-LABEL: @test_mm_fmadd_round_sh
3663   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3664   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3665   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3666   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3667   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[FMA]], i64 0
3668   return _mm_fmadd_round_sh(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3669 }
3670
3671 __m128h test_mm_mask_fmadd_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3672   // CHECK-LABEL: @test_mm_mask_fmadd_round_sh
3673   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3674   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3675   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3676   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3677   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3678   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3679   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[A]]
3680   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3681   return _mm_mask_fmadd_round_sh(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3682 }
3683
3684 __m128h test_mm_maskz_fmadd_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
3685   // CHECK-LABEL: @test_mm_maskz_fmadd_sh
3686   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3687   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3688   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3689   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3690   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3691   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3692   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half 0xH0000
3693   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3694   return _mm_maskz_fmadd_sh(__U, __A, __B, __C);
3695 }
3696
3697 __m128h test_mm_maskz_fmadd_round_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
3698   // CHECK-LABEL: @test_mm_maskz_fmadd_round_sh
3699   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3700   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3701   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3702   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3703   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3704   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3705   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half 0xH0000
3706   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3707   return _mm_maskz_fmadd_round_sh(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3708 }
3709
3710 __m128h test_mm_mask3_fmadd_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
3711   // CHECK-LABEL: @test_mm_mask3_fmadd_sh
3712   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3713   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3714   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
3715   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3716   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3717   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3718   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C]]
3719   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
3720   return _mm_mask3_fmadd_sh(__W, __X, __Y, __U);
3721 }
3722
3723 __m128h test_mm_mask3_fmadd_round_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
3724   // CHECK-LABEL: @test_mm_mask3_fmadd_round_sh
3725   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3726   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3727   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
3728   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3729   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3730   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3731   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C]]
3732   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
3733   return _mm_mask3_fmadd_round_sh(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3734 }
3735
3736 __m128h test_mm_fmsub_sh(__m128h __W, __m128h __A, __m128h __B) {
3737   // CHECK-LABEL: @test_mm_fmsub_sh
3738   // CHECK: %{{.*}} = fneg <8 x half> %{{.*}}
3739   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3740   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3741   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3742   // CHECK-NEXT: %{{.*}} = call half @llvm.fma.f16(half %{{.*}}, half %{{.*}}, half %{{.*}})
3743   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
3744   // CHECK-NEXT: ret <8 x half> %{{.*}}
3745   return _mm_fmsub_sh(__W, __A, __B);
3746 }
3747
3748 __m128h test_mm_mask_fmsub_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3749   // CHECK-LABEL: @test_mm_mask_fmsub_sh
3750   // CHECK: %{{.*}} = fneg <8 x half> %{{.*}}
3751   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3752   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3753   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3754   // CHECK-NEXT: %{{.*}} = call half @llvm.fma.f16(half %{{.*}}, half %{{.*}}, half %{{.*}})
3755   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
3756   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
3757   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
3758   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
3759   // CHECK-NEXT: ret <8 x half> %{{.*}}
3760   return _mm_mask_fmsub_sh(__W, __U, __A, __B);
3761 }
3762
3763 __m128h test_mm_fmsub_round_sh(__m128h __A, __m128h __B, __m128h __C) {
3764   // CHECK-LABEL: @test_mm_fmsub_round_sh
3765   // CHECK: %{{.*}} = fneg <8 x half> %{{.*}}
3766   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3767   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3768   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3769   // CHECK-NEXT: %{{.*}} = call half @llvm.x86.avx512fp16.vfmadd.f16(half %{{.*}}, half %{{.*}}, half %{{.*}}, i32 11)
3770   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
3771   // CHECK-NEXT: ret <8 x half> %{{.*}}
3772   return _mm_fmsub_round_sh(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3773 }
3774
3775 __m128h test_mm_mask_fmsub_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3776   // CHECK-LABEL: @test_mm_mask_fmsub_round_sh
3777   // CHECK: %{{.*}} = fneg <8 x half> %{{.*}}
3778   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3779   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3780   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3781   // CHECK-NEXT: %{{.*}} = call half @llvm.x86.avx512fp16.vfmadd.f16(half %{{.*}}, half %{{.*}}, half %{{.*}}, i32 11)
3782   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
3783   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
3784   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half %{{.*}}
3785   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
3786   // CHECK-NEXT: ret <8 x half> %{{.*}}
3787   return _mm_mask_fmsub_round_sh(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3788 }
3789
3790 __m128h test_mm_maskz_fmsub_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
3791   // CHECK-LABEL: @test_mm_maskz_fmsub_sh
3792   // CHECK: %{{.*}} = fneg <8 x half> %{{.*}}
3793   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3794   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3795   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3796   // CHECK-NEXT: %{{.*}} = call half @llvm.fma.f16(half %{{.*}}, half %{{.*}}, half %{{.*}})
3797   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
3798   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
3799   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half 0xH0000
3800   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
3801   // CHECK-NEXT: ret <8 x half> %{{.*}}
3802   return _mm_maskz_fmsub_sh(__U, __A, __B, __C);
3803 }
3804
3805 __m128h test_mm_maskz_fmsub_round_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
3806   // CHECK-LABEL: @test_mm_maskz_fmsub_round_sh
3807   // CHECK: %{{.*}} = fneg <8 x half> %{{.*}}
3808   // CHECK: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3809   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3810   // CHECK-NEXT: %{{.*}} = extractelement <8 x half> %{{.*}}, i64 0
3811   // CHECK-NEXT: %{{.*}} = call half @llvm.x86.avx512fp16.vfmadd.f16(half %{{.*}}, half %{{.*}}, half %{{.*}}, i32 11)
3812   // CHECK-NEXT: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
3813   // CHECK-NEXT: %{{.*}} = extractelement <8 x i1> %{{.*}}, i64 0
3814   // CHECK-NEXT: %{{.*}} = select i1 %{{.*}}, half %{{.*}}, half 0xH0000
3815   // CHECK-NEXT: %{{.*}} = insertelement <8 x half> %{{.*}}, half %{{.*}}, i64 0
3816   // CHECK-NEXT: ret <8 x half> %{{.*}}
3817   return _mm_maskz_fmsub_round_sh(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3818 }
3819
3820 __m128h test_mm_mask3_fmsub_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
3821   // CHECK-LABEL: @test_mm_mask3_fmsub_sh
3822   // CHECK: [[NEG:%.+]] = fneg
3823   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3824   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3825   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3826   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3827   // CHECK-NEXT: [[C2:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
3828   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3829   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3830   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C2]]
3831   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
3832   return _mm_mask3_fmsub_sh(__W, __X, __Y, __U);
3833 }
3834
3835 __m128h test_mm_mask3_fmsub_round_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
3836   // CHECK-LABEL: @test_mm_mask3_fmsub_round_sh
3837   // CHECK: [[NEG:%.+]] = fneg
3838   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3839   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3840   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3841   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3842   // CHECK-NEXT: [[C2:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
3843   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3844   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3845   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C2]]
3846   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
3847   return _mm_mask3_fmsub_round_sh(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3848 }
3849
3850 __m128h test_mm_fnmadd_sh(__m128h __W, __m128h __A, __m128h __B) {
3851   // CHECK-LABEL: @test_mm_fnmadd_sh
3852   // CHECK: [[NEG:%.+]] = fneg
3853   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3854   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3855   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3856   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3857   return _mm_fnmadd_sh(__W, __A, __B);
3858 }
3859
3860 __m128h test_mm_mask_fnmadd_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3861   // CHECK-LABEL: @test_mm_mask_fnmadd_sh
3862   // CHECK: [[NEG:%.+]] = fneg
3863   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3864   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3865   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3866   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3867   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3868   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3869   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[A]]
3870   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3871   return _mm_mask_fnmadd_sh(__W, __U, __A, __B);
3872 }
3873
3874 __m128h test_mm_fnmadd_round_sh(__m128h __A, __m128h __B, __m128h __C) {
3875   // CHECK-LABEL: @test_mm_fnmadd_round_sh
3876   // CHECK: [[NEG:%.+]] = fneg
3877   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3878   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3879   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3880   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3881   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[FMA]], i64 0
3882   return _mm_fnmadd_round_sh(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3883 }
3884
3885 __m128h test_mm_mask_fnmadd_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3886   // CHECK-LABEL: @test_mm_mask_fnmadd_round_sh
3887   // CHECK: [[NEG:%.+]] = fneg
3888   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3889   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3890   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3891   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3892   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3893   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3894   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[A]]
3895   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3896   return _mm_mask_fnmadd_round_sh(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3897 }
3898
3899 __m128h test_mm_maskz_fnmadd_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
3900   // CHECK-LABEL: @test_mm_maskz_fnmadd_sh
3901   // CHECK: [[NEG:%.+]] = fneg
3902   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3903   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3904   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3905   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3906   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3907   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3908   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half 0xH0000
3909   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3910   return _mm_maskz_fnmadd_sh(__U, __A, __B, __C);
3911 }
3912
3913 __m128h test_mm_maskz_fnmadd_round_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
3914   // CHECK-LABEL: @test_mm_maskz_fnmadd_round_sh
3915   // CHECK: [[NEG:%.+]] = fneg
3916   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3917   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3918   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3919   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3920   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3921   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3922   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half 0xH0000
3923   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3924   return _mm_maskz_fnmadd_round_sh(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3925 }
3926
3927 __m128h test_mm_mask3_fnmadd_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
3928   // CHECK-LABEL: @test_mm_mask3_fnmadd_sh
3929   // CHECK: [[NEG:%.+]] = fneg
3930   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3931   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3932   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
3933   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3934   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3935   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3936   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C]]
3937   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
3938   return _mm_mask3_fnmadd_sh(__W, __X, __Y, __U);
3939 }
3940
3941 __m128h test_mm_mask3_fnmadd_round_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
3942   // CHECK-LABEL: @test_mm_mask3_fnmadd_round_sh
3943   // CHECK: [[NEG:%.+]] = fneg
3944   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3945   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3946   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
3947   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3948   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3949   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3950   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C]]
3951   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
3952   return _mm_mask3_fnmadd_round_sh(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3953 }
3954
3955 __m128h test_mm_fnmsub_sh(__m128h __W, __m128h __A, __m128h __B) {
3956   // CHECK-LABEL: @test_mm_fnmsub_sh
3957   // CHECK: [[NEG:%.+]] = fneg
3958   // CHECK: [[NEG2:%.+]] = fneg
3959   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3960   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3961   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3962   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3963   return _mm_fnmsub_sh(__W, __A, __B);
3964 }
3965
3966 __m128h test_mm_mask_fnmsub_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3967   // CHECK-LABEL: @test_mm_mask_fnmsub_sh
3968   // CHECK: [[NEG:%.+]] = fneg
3969   // CHECK: [[NEG2:%.+]] = fneg
3970   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3971   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3972   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3973   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
3974   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
3975   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
3976   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[A]]
3977   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
3978   return _mm_mask_fnmsub_sh(__W, __U, __A, __B);
3979 }
3980
3981 __m128h test_mm_fnmsub_round_sh(__m128h __A, __m128h __B, __m128h __C) {
3982   // CHECK-LABEL: @test_mm_fnmsub_round_sh
3983   // CHECK: [[NEG:%.+]] = fneg
3984   // CHECK: [[NEG2:%.+]] = fneg
3985   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3986   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3987   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3988   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
3989   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[FMA]], i64 0
3990   return _mm_fnmsub_round_sh(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
3991 }
3992
3993 __m128h test_mm_mask_fnmsub_round_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3994   // CHECK-LABEL: @test_mm_mask_fnmsub_round_sh
3995   // CHECK: [[NEG:%.+]] = fneg
3996   // CHECK: [[NEG2:%.+]] = fneg
3997   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
3998   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
3999   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4000   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
4001   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
4002   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
4003   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[A]]
4004   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
4005   return _mm_mask_fnmsub_round_sh(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4006 }
4007
4008 __m128h test_mm_maskz_fnmsub_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
4009   // CHECK-LABEL: @test_mm_maskz_fnmsub_sh
4010   // CHECK: [[NEG:%.+]] = fneg
4011   // CHECK: [[NEG2:%.+]] = fneg
4012   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
4013   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4014   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4015   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
4016   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
4017   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
4018   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half 0xH0000
4019   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
4020   return _mm_maskz_fnmsub_sh(__U, __A, __B, __C);
4021 }
4022
4023 __m128h test_mm_maskz_fnmsub_round_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
4024   // CHECK-LABEL: @test_mm_maskz_fnmsub_round_sh
4025   // CHECK: [[NEG:%.+]] = fneg
4026   // CHECK: [[NEG2:%.+]] = fneg
4027   // CHECK: [[A:%.+]] = extractelement <8 x half> [[ORIGA:%.+]], i64 0
4028   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4029   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4030   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
4031   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
4032   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
4033   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half 0xH0000
4034   // CHECK-NEXT: insertelement <8 x half> [[ORIGA]], half [[SEL]], i64 0
4035   return _mm_maskz_fnmsub_round_sh(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4036 }
4037
4038 __m128h test_mm_mask3_fnmsub_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
4039   // CHECK-LABEL: @test_mm_mask3_fnmsub_sh
4040   // CHECK: [[NEG:%.+]] = fneg
4041   // CHECK: [[NEG2:%.+]] = fneg
4042   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4043   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4044   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4045   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.fma.f16(half [[A]], half [[B]], half [[C]])
4046   // CHECK-NEXT: [[C2:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
4047   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
4048   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
4049   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C2]]
4050   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
4051   return _mm_mask3_fnmsub_sh(__W, __X, __Y, __U);
4052 }
4053
4054 __m128h test_mm_mask3_fnmsub_round_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
4055   // CHECK-LABEL: @test_mm_mask3_fnmsub_round_sh
4056   // CHECK: [[NEG:%.+]] = fneg
4057   // CHECK: [[NEG2:%.+]] = fneg
4058   // CHECK: [[A:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4059   // CHECK-NEXT: [[B:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4060   // CHECK-NEXT: [[C:%.+]] = extractelement <8 x half> %{{.*}}, i64 0
4061   // CHECK-NEXT: [[FMA:%.+]] = call half @llvm.x86.avx512fp16.vfmadd.f16(half [[A]], half [[B]], half [[C]], i32 11)
4062   // CHECK-NEXT: [[C2:%.+]] = extractelement <8 x half> [[ORIGC:%.+]], i64 0
4063   // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1>
4064   // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0
4065   // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, half [[FMA]], half [[C2]]
4066   // CHECK-NEXT: insertelement <8 x half> [[ORIGC]], half [[SEL]], i64 0
4067   return _mm_mask3_fnmsub_round_sh(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4068 }
4069
4070 __m128h test_mm_fcmadd_sch(__m128h __A, __m128h __B, __m128h __C) {
4071   // CHECK-LABEL: @test_mm_fcmadd_sch
4072   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.csh
4073   return _mm_fcmadd_sch(__A, __B, __C);
4074 }
4075
4076 __m128h test_mm_mask_fcmadd_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
4077   // CHECK-LABEL: @test_mm_mask_fcmadd_sch
4078   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.csh
4079   // CHECK:  %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
4080   // CHECK:  %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
4081   return _mm_mask_fcmadd_sch(__A, __U, __B, __C);
4082 }
4083
4084 __m128h test_mm_maskz_fcmadd_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
4085   // CHECK-LABEL: @test_mm_maskz_fcmadd_sch
4086   // CHECK: @llvm.x86.avx512fp16.maskz.vfcmadd.csh
4087   return _mm_maskz_fcmadd_sch(__U, __A, __B, __C);
4088 }
4089
4090 __m128h test_mm_mask3_fcmadd_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
4091   // CHECK-LABEL: @test_mm_mask3_fcmadd_sch
4092   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4093   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4094   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4095   // CHECK:  %{{.*}} = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmadd.csh(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 %{{.*}}, i32 4)
4096   // CHECK:  %{{.*}} = shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
4097   // CHECK:  %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
4098   return _mm_mask3_fcmadd_sch(__A, __B, __C, __U);
4099 }
4100
4101 __m128h test_mm_fcmadd_round_sch(__m128h __A, __m128h __B, __m128h __C) {
4102   // CHECK-LABEL: @test_mm_fcmadd_round_sch
4103   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.csh
4104   return _mm_fcmadd_round_sch(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4105 }
4106
4107 __m128h test_mm_mask_fcmadd_round_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
4108   // CHECK-LABEL: @test_mm_mask_fcmadd_round_sch
4109   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.csh
4110   // CHECK:  %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
4111   // CHECK:  %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
4112   return _mm_mask_fcmadd_round_sch(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4113 }
4114
4115 __m128h test_mm_maskz_fcmadd_round_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
4116   // CHECK-LABEL: @test_mm_maskz_fcmadd_round_sch
4117   // CHECK: @llvm.x86.avx512fp16.maskz.vfcmadd.csh
4118   return _mm_maskz_fcmadd_round_sch(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4119 }
4120
4121 __m128h test_mm_mask3_fcmadd_round_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
4122   // CHECK-LABEL: @test_mm_mask3_fcmadd_round_sch
4123   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4124   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4125   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4126   // CHECK:  %{{.*}} = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmadd.csh(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 %{{.*}}, i32 11)
4127   // CHECK:  %{{.*}} = shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
4128   // CHECK:  %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
4129   return _mm_mask3_fcmadd_round_sch(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4130 }
4131
4132 __m128h test_mm_fmadd_sch(__m128h __A, __m128h __B, __m128h __C) {
4133   // CHECK-LABEL: @test_mm_fmadd_sch
4134   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.csh
4135   return _mm_fmadd_sch(__A, __B, __C);
4136 }
4137
4138 __m128h test_mm_mask_fmadd_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
4139   // CHECK-LABEL: @test_mm_mask_fmadd_sch
4140   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.csh
4141   // CHECK:  %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
4142   // CHECK:  %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
4143   return _mm_mask_fmadd_sch(__A, __U, __B, __C);
4144 }
4145
4146 __m128h test_mm_maskz_fmadd_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
4147   // CHECK-LABEL: @test_mm_maskz_fmadd_sch
4148   // CHECK: @llvm.x86.avx512fp16.maskz.vfmadd.csh
4149   return _mm_maskz_fmadd_sch(__U, __A, __B, __C);
4150 }
4151
4152 __m128h test_mm_mask3_fmadd_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
4153   // CHECK-LABEL: @test_mm_mask3_fmadd_sch
4154   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4155   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4156   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4157   // CHECK:  %{{.*}} = call <4 x float> @llvm.x86.avx512fp16.mask.vfmadd.csh(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 %{{.*}}, i32 4)
4158   // CHECK:  %{{.*}} = shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
4159   // CHECK:  %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
4160   return _mm_mask3_fmadd_sch(__A, __B, __C, __U);
4161 }
4162
4163 __m128h test_mm_fmadd_round_sch(__m128h __A, __m128h __B, __m128h __C) {
4164   // CHECK-LABEL: @test_mm_fmadd_round_sch
4165   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.csh
4166   return _mm_fmadd_round_sch(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4167 }
4168
4169 __m128h test_mm_mask_fmadd_round_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
4170   // CHECK-LABEL: @test_mm_mask_fmadd_round_sch
4171   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.csh
4172   // CHECK:  %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
4173   // CHECK:  %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
4174   return _mm_mask_fmadd_round_sch(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4175 }
4176
4177 __m128h test_mm_maskz_fmadd_round_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
4178   // CHECK-LABEL: @test_mm_maskz_fmadd_round_sch
4179   // CHECK: @llvm.x86.avx512fp16.maskz.vfmadd.csh
4180   return _mm_maskz_fmadd_round_sch(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4181 }
4182
4183 __m128h test_mm_mask3_fmadd_round_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
4184   // CHECK-LABEL: @test_mm_mask3_fmadd_round_sch
4185   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4186   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4187   // CHECK:  %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
4188   // CHECK:  %{{.*}} = call <4 x float> @llvm.x86.avx512fp16.mask.vfmadd.csh(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 %{{.*}}, i32 11)
4189   // CHECK:  %{{.*}} = shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
4190   // CHECK:  %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
4191   return _mm_mask3_fmadd_round_sch(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4192 }
4193
4194 __m128h test_mm_fcmul_sch(__m128h __A, __m128h __B) {
4195   // CHECK-LABEL: @test_mm_fcmul_sch
4196   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4197   return _mm_fcmul_sch(__A, __B);
4198 }
4199
4200 __m128h test_mm_mask_fcmul_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4201   // CHECK-LABEL: @test_mm_mask_fcmul_sch
4202   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4203   return _mm_mask_fcmul_sch(__W, __U, __A, __B);
4204 }
4205
4206 __m128h test_mm_maskz_fcmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4207   // CHECK-LABEL: @test_mm_maskz_fcmul_sch
4208   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4209   return _mm_maskz_fcmul_sch(__U, __A, __B);
4210 }
4211
4212 __m128h test_mm_fcmul_round_sch(__m128h __A, __m128h __B) {
4213   // CHECK-LABEL: @test_mm_fcmul_round_sch
4214   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4215   return _mm_fcmul_round_sch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4216 }
4217
4218 __m128h test_mm_mask_fcmul_round_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4219   // CHECK-LABEL: @test_mm_mask_fcmul_round_sch
4220   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4221   return _mm_mask_fcmul_round_sch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4222 }
4223
4224 __m128h test_mm_maskz_fcmul_round_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4225   // CHECK-LABEL: @test_mm_maskz_fcmul_round_sch
4226   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4227   return _mm_maskz_fcmul_round_sch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4228 }
4229
4230 __m512h test_mm512_fcmul_pch(__m512h __A, __m512h __B) {
4231   // CHECK-LABEL: @test_mm512_fcmul_pch
4232   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4233   return _mm512_fcmul_pch(__A, __B);
4234 }
4235
4236 __m512h test_mm512_mask_fcmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4237   // CHECK-LABEL: @test_mm512_mask_fcmul_pch
4238   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4239   return _mm512_mask_fcmul_pch(__W, __U, __A, __B);
4240 }
4241
4242 __m512h test_mm512_maskz_fcmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4243   // CHECK-LABEL: @test_mm512_maskz_fcmul_pch
4244   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4245   return _mm512_maskz_fcmul_pch(__U, __A, __B);
4246 }
4247
4248 __m512h test_mm512_fcmul_round_pch(__m512h __A, __m512h __B) {
4249   // CHECK-LABEL: @test_mm512_fcmul_round_pch
4250   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4251   return _mm512_fcmul_round_pch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4252 }
4253
4254 __m512h test_mm512_mask_fcmul_round_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4255   // CHECK-LABEL: @test_mm512_mask_fcmul_round_pch
4256   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4257   return _mm512_mask_fcmul_round_pch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4258 }
4259
4260 __m512h test_mm512_maskz_fcmul_round_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4261   // CHECK-LABEL: @test_mm512_maskz_fcmul_round_pch
4262   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4263   return _mm512_maskz_fcmul_round_pch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4264 }
4265
4266 __m512h test_mm512_fcmadd_pch(__m512h __A, __m512h __B, __m512h __C) {
4267   // CHECK-LABEL: @test_mm512_fcmadd_pch
4268   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.512
4269   return _mm512_fcmadd_pch(__A, __B, __C);
4270 }
4271
4272 __m512h test_mm512_mask_fcmadd_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
4273   // CHECK-LABEL: @test_mm512_mask_fcmadd_pch
4274   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.512
4275   // CHECK:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4276   return _mm512_mask_fcmadd_pch(__A, __U, __B, __C);
4277 }
4278
4279 __m512h test_mm512_mask3_fcmadd_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
4280   // CHECK-LABEL: @test_mm512_mask3_fcmadd_pch
4281   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.512
4282   // CHECK-NOT:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4283   return _mm512_mask3_fcmadd_pch(__A, __B, __C, __U);
4284 }
4285
4286 __m512h test_mm512_maskz_fcmadd_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
4287   // CHECK-LABEL: @test_mm512_maskz_fcmadd_pch
4288   // CHECK: @llvm.x86.avx512fp16.maskz.vfcmadd.cph.512
4289   return _mm512_maskz_fcmadd_pch(__U, __A, __B, __C);
4290 }
4291
4292 __m512h test_mm512_fcmadd_round_pch(__m512h __A, __m512h __B, __m512h __C) {
4293   // CHECK-LABEL: @test_mm512_fcmadd_round_pch
4294   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.512
4295   return _mm512_fcmadd_round_pch(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4296 }
4297
4298 __m512h test_mm512_mask_fcmadd_round_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
4299   // CHECK-LABEL: @test_mm512_mask_fcmadd_round_pch
4300   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.512
4301   // CHECK:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4302   return _mm512_mask_fcmadd_round_pch(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4303 }
4304
4305 __m512h test_mm512_mask3_fcmadd_round_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
4306   // CHECK-LABEL: @test_mm512_mask3_fcmadd_round_pch
4307   // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.512
4308   // CHECK-NOT:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4309   return _mm512_mask3_fcmadd_round_pch(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4310 }
4311
4312 __m512h test_mm512_maskz_fcmadd_round_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
4313   // CHECK-LABEL: @test_mm512_maskz_fcmadd_round_pch
4314   // CHECK: @llvm.x86.avx512fp16.maskz.vfcmadd.cph.512
4315   return _mm512_maskz_fcmadd_round_pch(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4316 }
4317
4318 __m512h test_mm512_fmul_pch(__m512h __A, __m512h __B) {
4319   // CHECK-LABEL: @test_mm512_fmul_pch
4320   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4321   return _mm512_fmul_pch(__A, __B);
4322 }
4323
4324 __m512h test_mm512_mask_fmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4325   // CHECK-LABEL: @test_mm512_mask_fmul_pch
4326   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4327   return _mm512_mask_fmul_pch(__W, __U, __A, __B);
4328 }
4329
4330 __m512h test_mm512_maskz_fmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4331   // CHECK-LABEL: @test_mm512_maskz_fmul_pch
4332   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4333   return _mm512_maskz_fmul_pch(__U, __A, __B);
4334 }
4335
4336 __m512h test_mm512_fmul_round_pch(__m512h __A, __m512h __B) {
4337   // CHECK-LABEL: @test_mm512_fmul_round_pch
4338   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4339   return _mm512_fmul_round_pch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4340 }
4341
4342 __m512h test_mm512_mask_fmul_round_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4343   // CHECK-LABEL: @test_mm512_mask_fmul_round_pch
4344   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4345   return _mm512_mask_fmul_round_pch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4346 }
4347
4348 __m512h test_mm512_maskz_fmul_round_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4349   // CHECK-LABEL: @test_mm512_maskz_fmul_round_pch
4350   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4351   return _mm512_maskz_fmul_round_pch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4352 }
4353
4354 __m512h test_mm512_fmadd_pch(__m512h __A, __m512h __B, __m512h __C) {
4355   // CHECK-LABEL: @test_mm512_fmadd_pch
4356   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.512
4357   return _mm512_fmadd_pch(__A, __B, __C);
4358 }
4359
4360 __m512h test_mm512_mask_fmadd_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
4361   // CHECK-LABEL: @test_mm512_mask_fmadd_pch
4362   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.512
4363   // CHECK:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4364   return _mm512_mask_fmadd_pch(__A, __U, __B, __C);
4365 }
4366
4367 __m512h test_mm512_mask3_fmadd_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
4368   // CHECK-LABEL: @test_mm512_mask3_fmadd_pch
4369   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.512
4370   // CHECK-NOT:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4371   return _mm512_mask3_fmadd_pch(__A, __B, __C, __U);
4372 }
4373
4374 __m512h test_mm512_maskz_fmadd_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
4375   // CHECK-LABEL: @test_mm512_maskz_fmadd_pch
4376   // CHECK: @llvm.x86.avx512fp16.maskz.vfmadd.cph.512
4377   return _mm512_maskz_fmadd_pch(__U, __A, __B, __C);
4378 }
4379
4380 __m512h test_mm512_fmadd_round_pch(__m512h __A, __m512h __B, __m512h __C) {
4381   // CHECK-LABEL: @test_mm512_fmadd_round_pch
4382   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.512
4383   return _mm512_fmadd_round_pch(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4384 }
4385
4386 __m512h test_mm512_mask_fmadd_round_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
4387   // CHECK-LABEL: @test_mm512_mask_fmadd_round_pch
4388   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.512
4389   // CHECK:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4390   return _mm512_mask_fmadd_round_pch(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4391 }
4392
4393 __m512h test_mm512_mask3_fmadd_round_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
4394   // CHECK-LABEL: @test_mm512_mask3_fmadd_round_pch
4395   // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.512
4396   // CHECK-NOT:  %{{.*}} = select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
4397   return _mm512_mask3_fmadd_round_pch(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4398 }
4399
4400 __m512h test_mm512_maskz_fmadd_round_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
4401   // CHECK-LABEL: @test_mm512_maskz_fmadd_round_pch
4402   // CHECK: @llvm.x86.avx512fp16.maskz.vfmadd.cph.512
4403   return _mm512_maskz_fmadd_round_pch(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4404 }
4405
4406 __m128h test_mm_fmul_sch(__m128h __A, __m128h __B) {
4407   // CHECK-LABEL: @test_mm_fmul_sch
4408   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4409   return _mm_fmul_sch(__A, __B);
4410 }
4411
4412 __m128h test_mm_mask_fmul_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4413   // CHECK-LABEL: @test_mm_mask_fmul_sch
4414   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4415   return _mm_mask_fmul_sch(__W, __U, __A, __B);
4416 }
4417
4418 __m128h test_mm_maskz_fmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4419   // CHECK-LABEL: @test_mm_maskz_fmul_sch
4420   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4421   return _mm_maskz_fmul_sch(__U, __A, __B);
4422 }
4423
4424 __m128h test_mm_fmul_round_sch(__m128h __A, __m128h __B) {
4425   // CHECK-LABEL: @test_mm_fmul_round_sch
4426   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4427   return _mm_fmul_round_sch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4428 }
4429
4430 __m128h test_mm_mask_fmul_round_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4431   // CHECK-LABEL: @test_mm_mask_fmul_round_sch
4432   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4433   return _mm_mask_fmul_round_sch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4434 }
4435
4436 __m128h test_mm_maskz_fmul_round_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4437   // CHECK-LABEL: @test_mm_maskz_fmul_round_sch
4438   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4439   return _mm_maskz_fmul_round_sch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4440 }
4441
4442 _Float16 test_mm512_reduce_add_ph(__m512h __W) {
4443   // CHECK-LABEL: @test_mm512_reduce_add_ph
4444   // CHECK: call reassoc half @llvm.vector.reduce.fadd.v32f16(half 0xH8000, <32 x half> %{{.*}})
4445   return _mm512_reduce_add_ph(__W);
4446 }
4447
4448 _Float16 test_mm512_reduce_mul_ph(__m512h __W) {
4449   // CHECK-LABEL: @test_mm512_reduce_mul_ph
4450   // CHECK: call reassoc half @llvm.vector.reduce.fmul.v32f16(half 0xH3C00, <32 x half> %{{.*}})
4451   return _mm512_reduce_mul_ph(__W);
4452 }
4453
4454 _Float16 test_mm512_reduce_max_ph(__m512h __W) {
4455   // CHECK-LABEL: @test_mm512_reduce_max_ph
4456   // CHECK: call nnan half @llvm.vector.reduce.fmax.v32f16(<32 x half> %{{.*}})
4457   return _mm512_reduce_max_ph(__W);
4458 }
4459
4460 _Float16 test_mm512_reduce_min_ph(__m512h __W) {
4461   // CHECK-LABEL: @test_mm512_reduce_min_ph
4462   // CHECK: call nnan half @llvm.vector.reduce.fmin.v32f16(<32 x half> %{{.*}})
4463   return _mm512_reduce_min_ph(__W);
4464 }
4465
4466 __m512h test_mm512_mask_blend_ph(__mmask32 __U, __m512h __A, __m512h __W) {
4467   // CHECK-LABEL: @test_mm512_mask_blend_ph
4468   // CHECK:  %{{.*}} = bitcast i32 %{{.*}} to <32 x i1>
4469   // CHECK:  %{{.*}} = select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
4470   return _mm512_mask_blend_ph(__U, __A, __W);
4471 }
4472
4473 __m512h test_mm512_permutex2var_ph(__m512h __A, __m512i __I, __m512h __B) {
4474   // CHECK-LABEL: @test_mm512_permutex2var_ph
4475   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <32 x i16>
4476   // CHECK:  %{{.*}} = bitcast <8 x i64> %{{.*}} to <32 x i16>
4477   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <32 x i16>
4478   // CHECK:  %{{.*}} = call <32 x i16> @llvm.x86.avx512.vpermi2var.hi.512(<32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}})
4479   // CHECK:  %{{.*}} = bitcast <32 x i16> %{{.*}} to <32 x half>
4480   return _mm512_permutex2var_ph(__A, __I, __B);
4481 }
4482
4483 __m512h test_mm512_permutexvar_epi16(__m512i __A, __m512h __B) {
4484   // CHECK-LABEL: @test_mm512_permutexvar_epi16
4485   // CHECK:  %{{.*}} = bitcast <32 x half> %{{.*}} to <32 x i16>
4486   // CHECK:  %{{.*}} = bitcast <8 x i64> %{{.*}} to <32 x i16>
4487   // CHECK:  %{{.*}} = call <32 x i16> @llvm.x86.avx512.permvar.hi.512(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
4488   // CHECK:  %{{.*}} = bitcast <32 x i16> %{{.*}} to <32 x half>
4489   return _mm512_permutexvar_ph(__A, __B);
4490 }
4491
4492 // tests below are for alias intrinsics.
4493 __m512h test_mm512_mul_pch(__m512h __A, __m512h __B) {
4494   // CHECK-LABEL: @test_mm512_mul_pch
4495   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4496   return _mm512_mul_pch(__A, __B);
4497 }
4498
4499 __m512h test_mm512_mask_mul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4500   // CHECK-LABEL: @test_mm512_mask_mul_pch
4501   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4502   return _mm512_mask_mul_pch(__W, __U, __A, __B);
4503 }
4504
4505 __m512h test_mm512_maskz_mul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4506   // CHECK-LABEL: @test_mm512_maskz_mul_pch
4507   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4508   return _mm512_maskz_mul_pch(__U, __A, __B);
4509 }
4510
4511 __m512h test_mm512_cmul_pch(__m512h __A, __m512h __B) {
4512   // CHECK-LABEL: @test_mm512_cmul_pch
4513   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4514   return _mm512_cmul_pch(__A, __B);
4515 }
4516 __m512h test_mm512_mask_cmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4517   // CHECK-LABEL: @test_mm512_mask_cmul_pch
4518   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4519   return _mm512_mask_cmul_pch(__W, __U, __A, __B);
4520 }
4521
4522 __m512h test_mm512_maskz_cmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4523   // CHECK-LABEL: @test_mm512_maskz_cmul_pch
4524   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4525   return _mm512_maskz_cmul_pch(__U, __A, __B);
4526 }
4527
4528 __m128h test_mm_mul_sch(__m128h __A, __m128h __B) {
4529   // CHECK-LABEL: @test_mm_mul_sch
4530   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4531   return _mm_mul_sch(__A, __B);
4532 }
4533
4534 __m128h test_mm_mask_mul_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4535   // CHECK-LABEL: @test_mm_mask_mul_sch
4536   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4537   return _mm_mask_mul_sch(__W, __U, __A, __B);
4538 }
4539
4540 __m128h test_mm_maskz_mul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4541   // CHECK-LABEL: @test_mm_maskz_mul_sch
4542   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4543   return _mm_maskz_mul_sch(__U, __A, __B);
4544 }
4545
4546 __m128h test_mm_mul_round_sch(__m128h __A, __m128h __B) {
4547   // CHECK-LABEL: @test_mm_mul_round_sch
4548   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4549   return _mm_mul_round_sch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4550 }
4551
4552 __m128h test_mm_mask_mul_round_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4553   // CHECK-LABEL: @test_mm_mask_mul_round_sch
4554   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4555   return _mm_mask_mul_round_sch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4556 }
4557
4558 __m128h test_mm_maskz_mul_round_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4559   // CHECK-LABEL: @test_mm_maskz_mul_round_sch
4560   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.csh
4561   return _mm_maskz_mul_round_sch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4562 }
4563
4564 __m512h test_mm512_mul_round_pch(__m512h __A, __m512h __B) {
4565   // CHECK-LABEL: @test_mm512_mul_round_pch
4566   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4567   return _mm512_mul_round_pch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4568 }
4569
4570 __m512h test_mm512_mask_mul_round_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4571   // CHECK-LABEL: @test_mm512_mask_mul_round_pch
4572   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4573   return _mm512_mask_mul_round_pch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4574 }
4575
4576 __m512h test_mm512_maskz_mul_round_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4577   // CHECK-LABEL: @test_mm512_maskz_mul_round_pch
4578   // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.512
4579   return _mm512_maskz_mul_round_pch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4580 }
4581
4582 __m512h test_mm512_cmul_round_pch(__m512h __A, __m512h __B) {
4583   // CHECK-LABEL: @test_mm512_cmul_round_pch
4584   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4585   return _mm512_cmul_round_pch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4586 }
4587
4588 __m512h test_mm512_mask_cmul_round_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
4589   // CHECK-LABEL: @test_mm512_mask_cmul_round_pch
4590   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4591   return _mm512_mask_cmul_round_pch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4592 }
4593
4594 __m512h test_mm512_maskz_cmul_round_pch(__mmask16 __U, __m512h __A, __m512h __B) {
4595   // CHECK-LABEL: @test_mm512_maskz_cmul_round_pch
4596   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.512
4597   return _mm512_maskz_cmul_round_pch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4598 }
4599
4600 __m128h test_mm_cmul_sch(__m128h __A, __m128h __B) {
4601   // CHECK-LABEL: @test_mm_cmul_sch
4602   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4603   return _mm_cmul_sch(__A, __B);
4604 }
4605
4606 __m128h test_mm_mask_cmul_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4607   // CHECK-LABEL: @test_mm_mask_cmul_sch
4608   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4609   return _mm_mask_cmul_sch(__W, __U, __A, __B);
4610 }
4611
4612 __m128h test_mm_maskz_cmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4613   // CHECK-LABEL: @test_mm_maskz_cmul_sch
4614   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4615   return _mm_maskz_cmul_sch(__U, __A, __B);
4616 }
4617
4618 __m128h test_mm_cmul_round_sch(__m128h __A, __m128h __B) {
4619   // CHECK-LABEL: @test_mm_cmul_round_sch
4620   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4621   return _mm_cmul_round_sch(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4622 }
4623
4624 __m128h test_mm_mask_cmul_round_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
4625   // CHECK-LABEL: @test_mm_mask_cmul_round_sch
4626   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4627   return _mm_mask_cmul_round_sch(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4628 }
4629
4630 __m128h test_mm_maskz_cmul_round_sch(__mmask8 __U, __m128h __A, __m128h __B) {
4631   // CHECK-LABEL: @test_mm_maskz_cmul_round_sch
4632   // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.csh
4633   return _mm_maskz_cmul_round_sch(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
4634 }