test/CodeGen/sse2-builtins.c

   1 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -emit-llvm -o - -Wall -Werror | FileCheck %s
   2 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
   3
   4
   5 #include <x86intrin.h>
   6
   7 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse2-intrinsics-fast-isel.ll
   8
   9 __m128i test_mm_add_epi8(__m128i A, __m128i B) {
  10   // CHECK-LABEL: test_mm_add_epi8
  11   // CHECK: add <16 x i8>
  12   return _mm_add_epi8(A, B);
  13 }
  14
  15 __m128i test_mm_add_epi16(__m128i A, __m128i B) {
  16   // CHECK-LABEL: test_mm_add_epi16
  17   // CHECK: add <8 x i16>
  18   return _mm_add_epi16(A, B);
  19 }
  20
  21 __m128i test_mm_add_epi32(__m128i A, __m128i B) {
  22   // CHECK-LABEL: test_mm_add_epi32
  23   // CHECK: add <4 x i32>
  24   return _mm_add_epi32(A, B);
  25 }
  26
  27 __m128i test_mm_add_epi64(__m128i A, __m128i B) {
  28   // CHECK-LABEL: test_mm_add_epi64
  29   // CHECK: add <2 x i64>
  30   return _mm_add_epi64(A, B);
  31 }
  32
  33 __m128d test_mm_add_pd(__m128d A, __m128d B) {
  34   // CHECK-LABEL: test_mm_add_pd
  35   // CHECK: fadd <2 x double>
  36   return _mm_add_pd(A, B);
  37 }
  38
  39 __m128d test_mm_add_sd(__m128d A, __m128d B) {
  40   // CHECK-LABEL: test_mm_add_sd
  41   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
  42   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
  43   // CHECK: fadd double
  44   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
  45   return _mm_add_sd(A, B);
  46 }
  47
  48 __m128i test_mm_adds_epi8(__m128i A, __m128i B) {
  49   // CHECK-LABEL: test_mm_adds_epi8
  50   // CHECK: call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
  51   return _mm_adds_epi8(A, B);
  52 }
  53
  54 __m128i test_mm_adds_epi16(__m128i A, __m128i B) {
  55   // CHECK-LABEL: test_mm_adds_epi16
  56   // CHECK: call <8 x i16> @llvm.x86.sse2.padds.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
  57   return _mm_adds_epi16(A, B);
  58 }
  59
  60 __m128i test_mm_adds_epu8(__m128i A, __m128i B) {
  61   // CHECK-LABEL: test_mm_adds_epu8
  62   // CHECK: call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
  63   return _mm_adds_epu8(A, B);
  64 }
  65
  66 __m128i test_mm_adds_epu16(__m128i A, __m128i B) {
  67   // CHECK-LABEL: test_mm_adds_epu16
  68   // CHECK: call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
  69   return _mm_adds_epu16(A, B);
  70 }
  71
  72 __m128d test_mm_and_pd(__m128d A, __m128d B) {
  73   // CHECK-LABEL: test_mm_and_pd
  74   // CHECK: and <2 x i64>
  75   return _mm_and_pd(A, B);
  76 }
  77
  78 __m128i test_mm_and_si128(__m128i A, __m128i B) {
  79   // CHECK-LABEL: test_mm_and_si128
  80   // CHECK: and <2 x i64>
  81   return _mm_and_si128(A, B);
  82 }
  83
  84 __m128d test_mm_andnot_pd(__m128d A, __m128d B) {
  85   // CHECK-LABEL: test_mm_andnot_pd
  86   // CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
  87   // CHECK: and <2 x i64>
  88   return _mm_andnot_pd(A, B);
  89 }
  90
  91 __m128i test_mm_andnot_si128(__m128i A, __m128i B) {
  92   // CHECK-LABEL: test_mm_andnot_si128
  93   // CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
  94   // CHECK: and <2 x i64>
  95   return _mm_andnot_si128(A, B);
  96 }
  97
  98 __m128i test_mm_avg_epu8(__m128i A, __m128i B) {
  99   // CHECK-LABEL: test_mm_avg_epu8
 100   // CHECK: call <16 x i8> @llvm.x86.sse2.pavg.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 101   return _mm_avg_epu8(A, B);
 102 }
 103
 104 __m128i test_mm_avg_epu16(__m128i A, __m128i B) {
 105   // CHECK-LABEL: test_mm_avg_epu16
 106   // CHECK: call <8 x i16> @llvm.x86.sse2.pavg.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 107   return _mm_avg_epu16(A, B);
 108 }
 109
 110 __m128i test_mm_bslli_si128(__m128i A) {
 111   // CHECK-LABEL: test_mm_bslli_si128
 112   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <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>
 113   return _mm_bslli_si128(A, 5);
 114 }
 115
 116 __m128i test_mm_bsrli_si128(__m128i A) {
 117   // CHECK-LABEL: test_mm_bsrli_si128
 118   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <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>
 119   return _mm_bsrli_si128(A, 5);
 120 }
 121
 122 __m128 test_mm_castpd_ps(__m128d A) {
 123   // CHECK-LABEL: test_mm_castpd_ps
 124   // CHECK: bitcast <2 x double> %{{.*}} to <4 x float>
 125   return _mm_castpd_ps(A);
 126 }
 127
 128 __m128i test_mm_castpd_si128(__m128d A) {
 129   // CHECK-LABEL: test_mm_castpd_si128
 130   // CHECK: bitcast <2 x double> %{{.*}} to <2 x i64>
 131   return _mm_castpd_si128(A);
 132 }
 133
 134 __m128d test_mm_castps_pd(__m128 A) {
 135   // CHECK-LABEL: test_mm_castps_pd
 136   // CHECK: bitcast <4 x float> %{{.*}} to <2 x double>
 137   return _mm_castps_pd(A);
 138 }
 139
 140 __m128i test_mm_castps_si128(__m128 A) {
 141   // CHECK-LABEL: test_mm_castps_si128
 142   // CHECK: bitcast <4 x float> %{{.*}} to <2 x i64>
 143   return _mm_castps_si128(A);
 144 }
 145
 146 __m128d test_mm_castsi128_pd(__m128i A) {
 147   // CHECK-LABEL: test_mm_castsi128_pd
 148   // CHECK: bitcast <2 x i64> %{{.*}} to <2 x double>
 149   return _mm_castsi128_pd(A);
 150 }
 151
 152 __m128 test_mm_castsi128_ps(__m128i A) {
 153   // CHECK-LABEL: test_mm_castsi128_ps
 154   // CHECK: bitcast <2 x i64> %{{.*}} to <4 x float>
 155   return _mm_castsi128_ps(A);
 156 }
 157
 158 void test_mm_clflush(void* A) {
 159   // CHECK-LABEL: test_mm_clflush
 160   // CHECK: call void @llvm.x86.sse2.clflush(i8* %{{.*}})
 161   _mm_clflush(A);
 162 }
 163
 164 __m128i test_mm_cmpeq_epi8(__m128i A, __m128i B) {
 165   // CHECK-LABEL: test_mm_cmpeq_epi8
 166   // CHECK: icmp eq <16 x i8>
 167   return _mm_cmpeq_epi8(A, B);
 168 }
 169
 170 __m128i test_mm_cmpeq_epi16(__m128i A, __m128i B) {
 171   // CHECK-LABEL: test_mm_cmpeq_epi16
 172   // CHECK: icmp eq <8 x i16>
 173   return _mm_cmpeq_epi16(A, B);
 174 }
 175
 176 __m128i test_mm_cmpeq_epi32(__m128i A, __m128i B) {
 177   // CHECK-LABEL: test_mm_cmpeq_epi32
 178   // CHECK: icmp eq <4 x i32>
 179   return _mm_cmpeq_epi32(A, B);
 180 }
 181
 182 __m128d test_mm_cmpeq_pd(__m128d A, __m128d B) {
 183   // CHECK-LABEL: test_mm_cmpeq_pd
 184   // CHECK:         [[CMP:%.*]] = fcmp oeq <2 x double>
 185   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 186   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 187   // CHECK-NEXT:    ret <2 x double> [[BC]]
 188   return _mm_cmpeq_pd(A, B);
 189 }
 190
 191 __m128d test_mm_cmpeq_sd(__m128d A, __m128d B) {
 192   // CHECK-LABEL: test_mm_cmpeq_sd
 193   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0)
 194   return _mm_cmpeq_sd(A, B);
 195 }
 196
 197 __m128d test_mm_cmpge_pd(__m128d A, __m128d B) {
 198   // CHECK-LABEL: test_mm_cmpge_pd
 199   // CHECK:         [[CMP:%.*]] = fcmp ole <2 x double>
 200   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 201   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 202   // CHECK-NEXT:    ret <2 x double> [[BC]]
 203   return _mm_cmpge_pd(A, B);
 204 }
 205
 206 __m128d test_mm_cmpge_sd(__m128d A, __m128d B) {
 207   // CHECK-LABEL: test_mm_cmpge_sd
 208   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 209   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 210   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 211   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
 212   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 213   return _mm_cmpge_sd(A, B);
 214 }
 215
 216 __m128i test_mm_cmpgt_epi8(__m128i A, __m128i B) {
 217   // CHECK-LABEL: test_mm_cmpgt_epi8
 218   // CHECK: icmp sgt <16 x i8>
 219   return _mm_cmpgt_epi8(A, B);
 220 }
 221
 222 __m128i test_mm_cmpgt_epi16(__m128i A, __m128i B) {
 223   // CHECK-LABEL: test_mm_cmpgt_epi16
 224   // CHECK: icmp sgt <8 x i16>
 225   return _mm_cmpgt_epi16(A, B);
 226 }
 227
 228 __m128i test_mm_cmpgt_epi32(__m128i A, __m128i B) {
 229   // CHECK-LABEL: test_mm_cmpgt_epi32
 230   // CHECK: icmp sgt <4 x i32>
 231   return _mm_cmpgt_epi32(A, B);
 232 }
 233
 234 __m128d test_mm_cmpgt_pd(__m128d A, __m128d B) {
 235   // CHECK-LABEL: test_mm_cmpgt_pd
 236   // CHECK:         [[CMP:%.*]] = fcmp olt <2 x double>
 237   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 238   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 239   // CHECK-NEXT:    ret <2 x double> [[BC]]
 240   return _mm_cmpgt_pd(A, B);
 241 }
 242
 243 __m128d test_mm_cmpgt_sd(__m128d A, __m128d B) {
 244   // CHECK-LABEL: test_mm_cmpgt_sd
 245   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1)
 246   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 247   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 248   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
 249   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 250   return _mm_cmpgt_sd(A, B);
 251 }
 252
 253 __m128d test_mm_cmple_pd(__m128d A, __m128d B) {
 254   // CHECK-LABEL: test_mm_cmple_pd
 255   // CHECK:         [[CMP:%.*]] = fcmp ole <2 x double>
 256   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 257   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 258   // CHECK-NEXT:    ret <2 x double> [[BC]]
 259   return _mm_cmple_pd(A, B);
 260 }
 261
 262 __m128d test_mm_cmple_sd(__m128d A, __m128d B) {
 263   // CHECK-LABEL: test_mm_cmple_sd
 264   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 265   return _mm_cmple_sd(A, B);
 266 }
 267
 268 __m128i test_mm_cmplt_epi8(__m128i A, __m128i B) {
 269   // CHECK-LABEL: test_mm_cmplt_epi8
 270   // CHECK: icmp sgt <16 x i8>
 271   return _mm_cmplt_epi8(A, B);
 272 }
 273
 274 __m128i test_mm_cmplt_epi16(__m128i A, __m128i B) {
 275   // CHECK-LABEL: test_mm_cmplt_epi16
 276   // CHECK: icmp sgt <8 x i16>
 277   return _mm_cmplt_epi16(A, B);
 278 }
 279
 280 __m128i test_mm_cmplt_epi32(__m128i A, __m128i B) {
 281   // CHECK-LABEL: test_mm_cmplt_epi32
 282   // CHECK: icmp sgt <4 x i32>
 283   return _mm_cmplt_epi32(A, B);
 284 }
 285
 286 __m128d test_mm_cmplt_pd(__m128d A, __m128d B) {
 287   // CHECK-LABEL: test_mm_cmplt_pd
 288   // CHECK:         [[CMP:%.*]] = fcmp olt <2 x double>
 289   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 290   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 291   // CHECK-NEXT:    ret <2 x double> [[BC]]
 292   return _mm_cmplt_pd(A, B);
 293 }
 294
 295 __m128d test_mm_cmplt_sd(__m128d A, __m128d B) {
 296   // CHECK-LABEL: test_mm_cmplt_sd
 297   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1)
 298   return _mm_cmplt_sd(A, B);
 299 }
 300
 301 __m128d test_mm_cmpneq_pd(__m128d A, __m128d B) {
 302   // CHECK-LABEL: test_mm_cmpneq_pd
 303   // CHECK:         [[CMP:%.*]] = fcmp une <2 x double>
 304   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 305   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 306   // CHECK-NEXT:    ret <2 x double> [[BC]]
 307   return _mm_cmpneq_pd(A, B);
 308 }
 309
 310 __m128d test_mm_cmpneq_sd(__m128d A, __m128d B) {
 311   // CHECK-LABEL: test_mm_cmpneq_sd
 312   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4)
 313   return _mm_cmpneq_sd(A, B);
 314 }
 315
 316 __m128d test_mm_cmpnge_pd(__m128d A, __m128d B) {
 317   // CHECK-LABEL: test_mm_cmpnge_pd
 318   // CHECK:         [[CMP:%.*]] = fcmp ugt <2 x double>
 319   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 320   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 321   // CHECK-NEXT:    ret <2 x double> [[BC]]
 322   return _mm_cmpnge_pd(A, B);
 323 }
 324
 325 __m128d test_mm_cmpnge_sd(__m128d A, __m128d B) {
 326   // CHECK-LABEL: test_mm_cmpnge_sd
 327   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6)
 328   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 329   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 330   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
 331   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 332   return _mm_cmpnge_sd(A, B);
 333 }
 334
 335 __m128d test_mm_cmpngt_pd(__m128d A, __m128d B) {
 336   // CHECK-LABEL: test_mm_cmpngt_pd
 337   // CHECK:         [[CMP:%.*]] = fcmp uge <2 x double>
 338   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 339   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 340   // CHECK-NEXT:    ret <2 x double> [[BC]]
 341   return _mm_cmpngt_pd(A, B);
 342 }
 343
 344 __m128d test_mm_cmpngt_sd(__m128d A, __m128d B) {
 345   // CHECK-LABEL: test_mm_cmpngt_sd
 346   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5)
 347   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 348   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 349   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
 350   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 351   return _mm_cmpngt_sd(A, B);
 352 }
 353
 354 __m128d test_mm_cmpnle_pd(__m128d A, __m128d B) {
 355   // CHECK-LABEL: test_mm_cmpnle_pd
 356   // CHECK:         [[CMP:%.*]] = fcmp ugt <2 x double>
 357   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 358   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 359   // CHECK-NEXT:    ret <2 x double> [[BC]]
 360   return _mm_cmpnle_pd(A, B);
 361 }
 362
 363 __m128d test_mm_cmpnle_sd(__m128d A, __m128d B) {
 364   // CHECK-LABEL: test_mm_cmpnle_sd
 365   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6)
 366   return _mm_cmpnle_sd(A, B);
 367 }
 368
 369 __m128d test_mm_cmpnlt_pd(__m128d A, __m128d B) {
 370   // CHECK-LABEL: test_mm_cmpnlt_pd
 371   // CHECK:         [[CMP:%.*]] = fcmp uge <2 x double>
 372   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 373   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 374   // CHECK-NEXT:    ret <2 x double> [[BC]]
 375   return _mm_cmpnlt_pd(A, B);
 376 }
 377
 378 __m128d test_mm_cmpnlt_sd(__m128d A, __m128d B) {
 379   // CHECK-LABEL: test_mm_cmpnlt_sd
 380   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5)
 381   return _mm_cmpnlt_sd(A, B);
 382 }
 383
 384 __m128d test_mm_cmpord_pd(__m128d A, __m128d B) {
 385   // CHECK-LABEL: test_mm_cmpord_pd
 386   // CHECK:         [[CMP:%.*]] = fcmp ord <2 x double>
 387   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 388   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 389   // CHECK-NEXT:    ret <2 x double> [[BC]]
 390   return _mm_cmpord_pd(A, B);
 391 }
 392
 393 __m128d test_mm_cmpord_sd(__m128d A, __m128d B) {
 394   // CHECK-LABEL: test_mm_cmpord_sd
 395   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7)
 396   return _mm_cmpord_sd(A, B);
 397 }
 398
 399 __m128d test_mm_cmpunord_pd(__m128d A, __m128d B) {
 400   // CHECK-LABEL: test_mm_cmpunord_pd
 401   // CHECK:         [[CMP:%.*]] = fcmp uno <2 x double>
 402   // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 403   // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 404   // CHECK-NEXT:    ret <2 x double> [[BC]]
 405   return _mm_cmpunord_pd(A, B);
 406 }
 407
 408 __m128d test_mm_cmpunord_sd(__m128d A, __m128d B) {
 409   // CHECK-LABEL: test_mm_cmpunord_sd
 410   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3)
 411   return _mm_cmpunord_sd(A, B);
 412 }
 413
 414 int test_mm_comieq_sd(__m128d A, __m128d B) {
 415   // CHECK-LABEL: test_mm_comieq_sd
 416   // CHECK: call i32 @llvm.x86.sse2.comieq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 417   return _mm_comieq_sd(A, B);
 418 }
 419
 420 int test_mm_comige_sd(__m128d A, __m128d B) {
 421   // CHECK-LABEL: test_mm_comige_sd
 422   // CHECK: call i32 @llvm.x86.sse2.comige.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 423   return _mm_comige_sd(A, B);
 424 }
 425
 426 int test_mm_comigt_sd(__m128d A, __m128d B) {
 427   // CHECK-LABEL: test_mm_comigt_sd
 428   // CHECK: call i32 @llvm.x86.sse2.comigt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 429   return _mm_comigt_sd(A, B);
 430 }
 431
 432 int test_mm_comile_sd(__m128d A, __m128d B) {
 433   // CHECK-LABEL: test_mm_comile_sd
 434   // CHECK: call i32 @llvm.x86.sse2.comile.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 435   return _mm_comile_sd(A, B);
 436 }
 437
 438 int test_mm_comilt_sd(__m128d A, __m128d B) {
 439   // CHECK-LABEL: test_mm_comilt_sd
 440   // CHECK: call i32 @llvm.x86.sse2.comilt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 441   return _mm_comilt_sd(A, B);
 442 }
 443
 444 int test_mm_comineq_sd(__m128d A, __m128d B) {
 445   // CHECK-LABEL: test_mm_comineq_sd
 446   // CHECK: call i32 @llvm.x86.sse2.comineq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 447   return _mm_comineq_sd(A, B);
 448 }
 449
 450 __m128d test_mm_cvtepi32_pd(__m128i A) {
 451   // CHECK-LABEL: test_mm_cvtepi32_pd
 452   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i32> <i32 0, i32 1>
 453   // CHECK: sitofp <2 x i32> %{{.*}} to <2 x double>
 454   return _mm_cvtepi32_pd(A);
 455 }
 456
 457 __m128 test_mm_cvtepi32_ps(__m128i A) {
 458   // CHECK-LABEL: test_mm_cvtepi32_ps
 459   // CHECK: call <4 x float> @llvm.x86.sse2.cvtdq2ps(<4 x i32> %{{.*}})
 460   return _mm_cvtepi32_ps(A);
 461 }
 462
 463 __m128i test_mm_cvtpd_epi32(__m128d A) {
 464   // CHECK-LABEL: test_mm_cvtpd_epi32
 465   // CHECK: call <4 x i32> @llvm.x86.sse2.cvtpd2dq(<2 x double> %{{.*}})
 466   return _mm_cvtpd_epi32(A);
 467 }
 468
 469 __m128 test_mm_cvtpd_ps(__m128d A) {
 470   // CHECK-LABEL: test_mm_cvtpd_ps
 471   // CHECK: call <4 x float> @llvm.x86.sse2.cvtpd2ps(<2 x double> %{{.*}})
 472   return _mm_cvtpd_ps(A);
 473 }
 474
 475 __m128i test_mm_cvtps_epi32(__m128 A) {
 476   // CHECK-LABEL: test_mm_cvtps_epi32
 477   // CHECK: call <4 x i32> @llvm.x86.sse2.cvtps2dq(<4 x float> %{{.*}})
 478   return _mm_cvtps_epi32(A);
 479 }
 480
 481 __m128d test_mm_cvtps_pd(__m128 A) {
 482   // CHECK-LABEL: test_mm_cvtps_pd
 483   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <2 x i32> <i32 0, i32 1>
 484   // CHECK: fpext <2 x float> %{{.*}} to <2 x double>
 485   return _mm_cvtps_pd(A);
 486 }
 487
 488 double test_mm_cvtsd_f64(__m128d A) {
 489   // CHECK-LABEL: test_mm_cvtsd_f64
 490   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 491   return _mm_cvtsd_f64(A);
 492 }
 493
 494 int test_mm_cvtsd_si32(__m128d A) {
 495   // CHECK-LABEL: test_mm_cvtsd_si32
 496   // CHECK: call i32 @llvm.x86.sse2.cvtsd2si(<2 x double> %{{.*}})
 497   return _mm_cvtsd_si32(A);
 498 }
 499
 500 long long test_mm_cvtsd_si64(__m128d A) {
 501   // CHECK-LABEL: test_mm_cvtsd_si64
 502   // CHECK: call i64 @llvm.x86.sse2.cvtsd2si64(<2 x double> %{{.*}})
 503   return _mm_cvtsd_si64(A);
 504 }
 505
 506 __m128 test_mm_cvtsd_ss(__m128 A, __m128d B) {
 507   // CHECK-LABEL: test_mm_cvtsd_ss
 508   // CHECK: call <4 x float> @llvm.x86.sse2.cvtsd2ss(<4 x float> %{{.*}}, <2 x double> %{{.*}})
 509   return _mm_cvtsd_ss(A, B);
 510 }
 511
 512 int test_mm_cvtsi128_si32(__m128i A) {
 513   // CHECK-LABEL: test_mm_cvtsi128_si32
 514   // CHECK: extractelement <4 x i32> %{{.*}}, i32 0
 515   return _mm_cvtsi128_si32(A);
 516 }
 517
 518 long long test_mm_cvtsi128_si64(__m128i A) {
 519   // CHECK-LABEL: test_mm_cvtsi128_si64
 520   // CHECK: extractelement <2 x i64> %{{.*}}, i32 0
 521   return _mm_cvtsi128_si64(A);
 522 }
 523
 524 __m128d test_mm_cvtsi32_sd(__m128d A, int B) {
 525   // CHECK-LABEL: test_mm_cvtsi32_sd
 526   // CHECK: sitofp i32 %{{.*}} to double
 527   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
 528   return _mm_cvtsi32_sd(A, B);
 529 }
 530
 531 __m128i test_mm_cvtsi32_si128(int A) {
 532   // CHECK-LABEL: test_mm_cvtsi32_si128
 533   // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
 534   // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 1
 535   // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 2
 536   // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 3
 537   return _mm_cvtsi32_si128(A);
 538 }
 539
 540 __m128d test_mm_cvtsi64_sd(__m128d A, long long B) {
 541   // CHECK-LABEL: test_mm_cvtsi64_sd
 542   // CHECK: sitofp i64 %{{.*}} to double
 543   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
 544   return _mm_cvtsi64_sd(A, B);
 545 }
 546
 547 __m128i test_mm_cvtsi64_si128(long long A) {
 548   // CHECK-LABEL: test_mm_cvtsi64_si128
 549   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
 550   // CHECK: insertelement <2 x i64> %{{.*}}, i64 0, i32 1
 551   return _mm_cvtsi64_si128(A);
 552 }
 553
 554 __m128d test_mm_cvtss_sd(__m128d A, __m128 B) {
 555   // CHECK-LABEL: test_mm_cvtss_sd
 556   // CHECK: extractelement <4 x float> %{{.*}}, i32 0
 557   // CHECK: fpext float %{{.*}} to double
 558   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
 559   return _mm_cvtss_sd(A, B);
 560 }
 561
 562 __m128i test_mm_cvttpd_epi32(__m128d A) {
 563   // CHECK-LABEL: test_mm_cvttpd_epi32
 564   // CHECK: call <4 x i32> @llvm.x86.sse2.cvttpd2dq(<2 x double> %{{.*}})
 565   return _mm_cvttpd_epi32(A);
 566 }
 567
 568 __m128i test_mm_cvttps_epi32(__m128 A) {
 569   // CHECK-LABEL: test_mm_cvttps_epi32
 570   // CHECK: call <4 x i32> @llvm.x86.sse2.cvttps2dq(<4 x float> %{{.*}})
 571   return _mm_cvttps_epi32(A);
 572 }
 573
 574 int test_mm_cvttsd_si32(__m128d A) {
 575   // CHECK-LABEL: test_mm_cvttsd_si32
 576   // CHECK: call i32 @llvm.x86.sse2.cvttsd2si(<2 x double> %{{.*}})
 577   return _mm_cvttsd_si32(A);
 578 }
 579
 580 long long test_mm_cvttsd_si64(__m128d A) {
 581   // CHECK-LABEL: test_mm_cvttsd_si64
 582   // CHECK: call i64 @llvm.x86.sse2.cvttsd2si64(<2 x double> %{{.*}})
 583   return _mm_cvttsd_si64(A);
 584 }
 585
 586 __m128d test_mm_div_pd(__m128d A, __m128d B) {
 587   // CHECK-LABEL: test_mm_div_pd
 588   // CHECK: fdiv <2 x double>
 589   return _mm_div_pd(A, B);
 590 }
 591
 592 __m128d test_mm_div_sd(__m128d A, __m128d B) {
 593   // CHECK-LABEL: test_mm_div_sd
 594   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 595   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 596   // CHECK: fdiv double
 597   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
 598   return _mm_div_sd(A, B);
 599 }
 600
 601 // Lowering to pextrw requires optimization.
 602 int test_mm_extract_epi16(__m128i A) {
 603   // CHECK-LABEL: test_mm_extract_epi16
 604   // CHECK: [[x:%.*]] = and i32 %{{.*}}, 7
 605   // CHECK: extractelement <8 x i16> %{{.*}}, i32 [[x]]
 606   // CHECK: zext i16 %{{.*}} to i32
 607   return _mm_extract_epi16(A, 9);
 608 }
 609
 610 __m128i test_mm_insert_epi16(__m128i A, int B) {
 611   // CHECK-LABEL: test_mm_insert_epi16
 612   // CHECK: [[x:%.*]] = and i32 %{{.*}}, 7
 613   // CHECK: insertelement <8 x i16> %{{.*}}, i32 [[x]]
 614   return _mm_insert_epi16(A, B, 8);
 615 }
 616
 617 void test_mm_lfence() {
 618   // CHECK-LABEL: test_mm_lfence
 619   // CHECK: call void @llvm.x86.sse2.lfence()
 620   _mm_lfence();
 621 }
 622
 623 __m128d test_mm_load_pd(double const* A) {
 624   // CHECK-LABEL: test_mm_load_pd
 625   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 16
 626   return _mm_load_pd(A);
 627 }
 628
 629 __m128d test_mm_load_pd1(double const* A) {
 630   // CHECK-LABEL: test_mm_load_pd1
 631   // CHECK: load double, double* %{{.*}}, align 8
 632   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 633   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 634   return _mm_load_pd1(A);
 635 }
 636
 637 __m128d test_mm_load_sd(double const* A) {
 638   // CHECK-LABEL: test_mm_load_sd
 639   // CHECK: load double, double* %{{.*}}, align 1{{$}}
 640   return _mm_load_sd(A);
 641 }
 642
 643 __m128i test_mm_load_si128(__m128i const* A) {
 644   // CHECK-LABEL: test_mm_load_si128
 645   // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 16
 646   return _mm_load_si128(A);
 647 }
 648
 649 __m128d test_mm_load1_pd(double const* A) {
 650   // CHECK-LABEL: test_mm_load1_pd
 651   // CHECK: load double, double* %{{.*}}, align 8
 652   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 653   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 654   return _mm_load1_pd(A);
 655 }
 656
 657 __m128d test_mm_loadh_pd(__m128d x, void* y) {
 658   // CHECK-LABEL: test_mm_loadh_pd
 659   // CHECK: load double, double* %{{.*}}, align 1{{$}}
 660   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 661   return _mm_loadh_pd(x, y);
 662 }
 663
 664 __m128i test_mm_loadl_epi64(__m128i* y) {
 665   // CHECK: test_mm_loadl_epi64
 666   // CHECK: load i64, i64* {{.*}}, align 1{{$}}
 667   // CHECK: insertelement <2 x i64> undef, i64 {{.*}}, i32 0
 668   // CHECK: insertelement <2 x i64> {{.*}}, i64 0, i32 1
 669   return _mm_loadl_epi64(y);
 670 }
 671
 672 __m128d test_mm_loadl_pd(__m128d x, void* y) {
 673   // CHECK-LABEL: test_mm_loadl_pd
 674   // CHECK: load double, double* %{{.*}}, align 1{{$}}
 675   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 676   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
 677   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 678   return _mm_loadl_pd(x, y);
 679 }
 680
 681 __m128d test_mm_loadr_pd(double const* A) {
 682   // CHECK-LABEL: test_mm_loadr_pd
 683   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 16
 684   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 1, i32 0>
 685   return _mm_loadr_pd(A);
 686 }
 687
 688 __m128d test_mm_loadu_pd(double const* A) {
 689   // CHECK-LABEL: test_mm_loadu_pd
 690   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
 691   return _mm_loadu_pd(A);
 692 }
 693
 694 __m128i test_mm_loadu_si128(__m128i const* A) {
 695   // CHECK-LABEL: test_mm_loadu_si128
 696   // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
 697   return _mm_loadu_si128(A);
 698 }
 699
 700 __m128i test_mm_loadu_si64(void const* A) {
 701   // CHECK-LABEL: test_mm_loadu_si64
 702   // CHECK: load i64, i64* %{{.*}}, align 1{{$}}
 703   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
 704   // CHECK: insertelement <2 x i64> %{{.*}}, i64 0, i32 1
 705   return _mm_loadu_si64(A);
 706 }
 707
 708 __m128i test_mm_madd_epi16(__m128i A, __m128i B) {
 709   // CHECK-LABEL: test_mm_madd_epi16
 710   // CHECK: call <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 711   return _mm_madd_epi16(A, B);
 712 }
 713
 714 void test_mm_maskmoveu_si128(__m128i A, __m128i B, char* C) {
 715   // CHECK-LABEL: test_mm_maskmoveu_si128
 716   // CHECK: call void @llvm.x86.sse2.maskmov.dqu(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i8* %{{.*}})
 717   _mm_maskmoveu_si128(A, B, C);
 718 }
 719
 720 __m128i test_mm_max_epi16(__m128i A, __m128i B) {
 721   // CHECK-LABEL: test_mm_max_epi16
 722   // CHECK:       [[CMP:%.*]] = icmp sgt <8 x i16> [[X:%.*]], [[Y:%.*]]
 723   // CHECK-NEXT:  select <8 x i1> [[CMP]], <8 x i16> [[X]], <8 x i16> [[Y]]
 724   return _mm_max_epi16(A, B);
 725 }
 726
 727 __m128i test_mm_max_epu8(__m128i A, __m128i B) {
 728   // CHECK-LABEL: test_mm_max_epu8
 729   // CHECK:       [[CMP:%.*]] = icmp ugt <16 x i8> [[X:%.*]], [[Y:%.*]]
 730   // CHECK-NEXT:  select <16 x i1> [[CMP]], <16 x i8> [[X]], <16 x i8> [[Y]]
 731   return _mm_max_epu8(A, B);
 732 }
 733
 734 __m128d test_mm_max_pd(__m128d A, __m128d B) {
 735   // CHECK-LABEL: test_mm_max_pd
 736   // CHECK: call <2 x double> @llvm.x86.sse2.max.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 737   return _mm_max_pd(A, B);
 738 }
 739
 740 __m128d test_mm_max_sd(__m128d A, __m128d B) {
 741   // CHECK-LABEL: test_mm_max_sd
 742   // CHECK: call <2 x double> @llvm.x86.sse2.max.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 743   return _mm_max_sd(A, B);
 744 }
 745
 746 void test_mm_mfence() {
 747   // CHECK-LABEL: test_mm_mfence
 748   // CHECK: call void @llvm.x86.sse2.mfence()
 749   _mm_mfence();
 750 }
 751
 752 __m128i test_mm_min_epi16(__m128i A, __m128i B) {
 753   // CHECK-LABEL: test_mm_min_epi16
 754   // CHECK:       [[CMP:%.*]] = icmp slt <8 x i16> [[X:%.*]], [[Y:%.*]]
 755   // CHECK-NEXT:  select <8 x i1> [[CMP]], <8 x i16> [[X]], <8 x i16> [[Y]]
 756   return _mm_min_epi16(A, B);
 757 }
 758
 759 __m128i test_mm_min_epu8(__m128i A, __m128i B) {
 760   // CHECK-LABEL: test_mm_min_epu8
 761   // CHECK:       [[CMP:%.*]] = icmp ult <16 x i8> [[X:%.*]], [[Y:%.*]]
 762   // CHECK-NEXT:  select <16 x i1> [[CMP]], <16 x i8> [[X]], <16 x i8> [[Y]]
 763   return _mm_min_epu8(A, B);
 764 }
 765
 766 __m128d test_mm_min_pd(__m128d A, __m128d B) {
 767   // CHECK-LABEL: test_mm_min_pd
 768   // CHECK: call <2 x double> @llvm.x86.sse2.min.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 769   return _mm_min_pd(A, B);
 770 }
 771
 772 __m128d test_mm_min_sd(__m128d A, __m128d B) {
 773   // CHECK-LABEL: test_mm_min_sd
 774   // CHECK: call <2 x double> @llvm.x86.sse2.min.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
 775   return _mm_min_sd(A, B);
 776 }
 777
 778 __m128i test_mm_move_epi64(__m128i A) {
 779   // CHECK-LABEL: test_mm_move_epi64
 780   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
 781   return _mm_move_epi64(A);
 782 }
 783
 784 __m128d test_mm_move_sd(__m128d A, __m128d B) {
 785   // CHECK-LABEL: test_mm_move_sd
 786   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 787   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 788   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
 789   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 790   return _mm_move_sd(A, B);
 791 }
 792
 793 int test_mm_movemask_epi8(__m128i A) {
 794   // CHECK-LABEL: test_mm_movemask_epi8
 795   // CHECK: call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %{{.*}})
 796   return _mm_movemask_epi8(A);
 797 }
 798
 799 int test_mm_movemask_pd(__m128d A) {
 800   // CHECK-LABEL: test_mm_movemask_pd
 801   // CHECK: call i32 @llvm.x86.sse2.movmsk.pd(<2 x double> %{{.*}})
 802   return _mm_movemask_pd(A);
 803 }
 804
 805 __m128i test_mm_mul_epu32(__m128i A, __m128i B) {
 806   // CHECK-LABEL: test_mm_mul_epu32
 807   // CHECK: call <2 x i64> @llvm.x86.sse2.pmulu.dq(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 808   return _mm_mul_epu32(A, B);
 809 }
 810
 811 __m128d test_mm_mul_pd(__m128d A, __m128d B) {
 812   // CHECK-LABEL: test_mm_mul_pd
 813   // CHECK: fmul <2 x double> %{{.*}}, %{{.*}}
 814   return _mm_mul_pd(A, B);
 815 }
 816
 817 __m128d test_mm_mul_sd(__m128d A, __m128d B) {
 818   // CHECK-LABEL: test_mm_mul_sd
 819   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 820   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
 821   // CHECK: fmul double
 822   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
 823   return _mm_mul_sd(A, B);
 824 }
 825
 826 __m128i test_mm_mulhi_epi16(__m128i A, __m128i B) {
 827   // CHECK-LABEL: test_mm_mulhi_epi16
 828   // CHECK: call <8 x i16> @llvm.x86.sse2.pmulh.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 829   return _mm_mulhi_epi16(A, B);
 830 }
 831
 832 __m128i test_mm_mulhi_epu16(__m128i A, __m128i B) {
 833   // CHECK-LABEL: test_mm_mulhi_epu16
 834   // CHECK: call <8 x i16> @llvm.x86.sse2.pmulhu.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 835   return _mm_mulhi_epu16(A, B);
 836 }
 837
 838 __m128i test_mm_mullo_epi16(__m128i A, __m128i B) {
 839   // CHECK-LABEL: test_mm_mullo_epi16
 840   // CHECK: mul <8 x i16> %{{.*}}, %{{.*}}
 841   return _mm_mullo_epi16(A, B);
 842 }
 843
 844 __m128d test_mm_or_pd(__m128d A, __m128d B) {
 845   // CHECK-LABEL: test_mm_or_pd
 846   // CHECK: or <2 x i64> %{{.*}}, %{{.*}}
 847   return _mm_or_pd(A, B);
 848 }
 849
 850 __m128i test_mm_or_si128(__m128i A, __m128i B) {
 851   // CHECK-LABEL: test_mm_or_si128
 852   // CHECK: or <2 x i64> %{{.*}}, %{{.*}}
 853   return _mm_or_si128(A, B);
 854 }
 855
 856 __m128i test_mm_packs_epi16(__m128i A, __m128i B) {
 857   // CHECK-LABEL: test_mm_packs_epi16
 858   // CHECK: call <16 x i8> @llvm.x86.sse2.packsswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 859   return _mm_packs_epi16(A, B);
 860 }
 861
 862 __m128i test_mm_packs_epi32(__m128i A, __m128i B) {
 863   // CHECK-LABEL: test_mm_packs_epi32
 864   // CHECK: call <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 865   return _mm_packs_epi32(A, B);
 866 }
 867
 868 __m128i test_mm_packus_epi16(__m128i A, __m128i B) {
 869   // CHECK-LABEL: test_mm_packus_epi16
 870   // CHECK: call <16 x i8> @llvm.x86.sse2.packuswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
 871   return _mm_packus_epi16(A, B);
 872 }
 873
 874 void test_mm_pause() {
 875   // CHECK-LABEL: test_mm_pause
 876   // CHECK: call void @llvm.x86.sse2.pause()
 877   return _mm_pause();
 878 }
 879
 880 __m128i test_mm_sad_epu8(__m128i A, __m128i B) {
 881   // CHECK-LABEL: test_mm_sad_epu8
 882   // CHECK: call <2 x i64> @llvm.x86.sse2.psad.bw(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
 883   return _mm_sad_epu8(A, B);
 884 }
 885
 886 __m128i test_mm_set_epi8(char A, char B, char C, char D,
 887                          char E, char F, char G, char H,
 888                          char I, char J, char K, char L,
 889                          char M, char N, char O, char P) {
 890   // CHECK-LABEL: test_mm_set_epi8
 891   // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 0
 892   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 1
 893   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 2
 894   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 3
 895   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 4
 896   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 5
 897   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 6
 898   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 7
 899   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 8
 900   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 9
 901   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 10
 902   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 11
 903   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 12
 904   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 13
 905   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 14
 906   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 15
 907   return _mm_set_epi8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
 908 }
 909
 910 __m128i test_mm_set_epi16(short A, short B, short C, short D,
 911                           short E, short F, short G, short H) {
 912   // CHECK-LABEL: test_mm_set_epi16
 913   // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
 914   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 1
 915   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 2
 916   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 3
 917   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 4
 918   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 5
 919   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 6
 920   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 7
 921   return _mm_set_epi16(A, B, C, D, E, F, G, H);
 922 }
 923
 924 __m128i test_mm_set_epi32(int A, int B, int C, int D) {
 925   // CHECK-LABEL: test_mm_set_epi32
 926   // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
 927   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 1
 928   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 2
 929   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 3
 930   return _mm_set_epi32(A, B, C, D);
 931 }
 932
 933 __m128i test_mm_set_epi64(__m64 A, __m64 B) {
 934   // CHECK-LABEL: test_mm_set_epi64
 935   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
 936   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
 937   return _mm_set_epi64(A, B);
 938 }
 939
 940 __m128i test_mm_set_epi64x(long long A, long long B) {
 941   // CHECK-LABEL: test_mm_set_epi64x
 942   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
 943   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
 944   return _mm_set_epi64x(A, B);
 945 }
 946
 947 __m128d test_mm_set_pd(double A, double B) {
 948   // CHECK-LABEL: test_mm_set_pd
 949   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 950   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
 951   return _mm_set_pd(A, B);
 952 }
 953
 954 __m128d test_mm_set_sd(double A) {
 955   // CHECK-LABEL: test_mm_set_sd
 956   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
 957   // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i32 1
 958   return _mm_set_sd(A);
 959 }
 960
 961 __m128i test_mm_set1_epi8(char A) {
 962   // CHECK-LABEL: test_mm_set1_epi8
 963   // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 0
 964   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 1
 965   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 2
 966   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 3
 967   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 4
 968   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 5
 969   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 6
 970   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 7
 971   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 8
 972   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 9
 973   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 10
 974   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 11
 975   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 12
 976   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 13
 977   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 14
 978   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 15
 979   return _mm_set1_epi8(A);
 980 }
 981
 982 __m128i test_mm_set1_epi16(short A) {
 983   // CHECK-LABEL: test_mm_set1_epi16
 984   // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
 985   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 1
 986   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 2
 987   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 3
 988   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 4
 989   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 5
 990   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 6
 991   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 7
 992   return _mm_set1_epi16(A);
 993 }
 994
 995 __m128i test_mm_set1_epi32(int A) {
 996   // CHECK-LABEL: test_mm_set1_epi32
 997   // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
 998   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 1
 999   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1000   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1001   return _mm_set1_epi32(A);
1002 }
1003
1004 __m128i test_mm_set1_epi64(__m64 A) {
1005   // CHECK-LABEL: test_mm_set1_epi64
1006   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
1007   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1008   return _mm_set1_epi64(A);
1009 }
1010
1011 __m128i test_mm_set1_epi64x(long long A) {
1012   // CHECK-LABEL: test_mm_set1_epi64x
1013   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
1014   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1015   return _mm_set1_epi64x(A);
1016 }
1017
1018 __m128d test_mm_set1_pd(double A) {
1019   // CHECK-LABEL: test_mm_set1_pd
1020   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
1021   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
1022   return _mm_set1_pd(A);
1023 }
1024
1025 __m128i test_mm_setr_epi8(char A, char B, char C, char D,
1026                           char E, char F, char G, char H,
1027                           char I, char J, char K, char L,
1028                           char M, char N, char O, char P) {
1029   // CHECK-LABEL: test_mm_setr_epi8
1030   // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 0
1031   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1032   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1033   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1034   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1035   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1036   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1037   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1038   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1039   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1040   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1041   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1042   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1043   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1044   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1045   // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1046   return _mm_setr_epi8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
1047 }
1048
1049 __m128i test_mm_setr_epi16(short A, short B, short C, short D,
1050                            short E, short F, short G, short H) {
1051   // CHECK-LABEL: test_mm_setr_epi16
1052   // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
1053   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1054   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1055   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1056   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1057   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1058   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1059   // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1060   return _mm_setr_epi16(A, B, C, D, E, F, G, H);
1061 }
1062
1063 __m128i test_mm_setr_epi32(int A, int B, int C, int D) {
1064   // CHECK-LABEL: test_mm_setr_epi32
1065   // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
1066   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1067   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1068   // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1069   return _mm_setr_epi32(A, B, C, D);
1070 }
1071
1072 __m128i test_mm_setr_epi64(__m64 A, __m64 B) {
1073   // CHECK-LABEL: test_mm_setr_epi64
1074   // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
1075   // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1076   return _mm_setr_epi64(A, B);
1077 }
1078
1079 __m128d test_mm_setr_pd(double A, double B) {
1080   // CHECK-LABEL: test_mm_setr_pd
1081   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
1082   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
1083   return _mm_setr_pd(A, B);
1084 }
1085
1086 __m128d test_mm_setzero_pd() {
1087   // CHECK-LABEL: test_mm_setzero_pd
1088   // CHECK: store <2 x double> zeroinitializer
1089   return _mm_setzero_pd();
1090 }
1091
1092 __m128i test_mm_setzero_si128() {
1093   // CHECK-LABEL: test_mm_setzero_si128
1094   // CHECK: store <2 x i64> zeroinitializer
1095   return _mm_setzero_si128();
1096 }
1097
1098 __m128i test_mm_shuffle_epi32(__m128i A) {
1099   // CHECK-LABEL: test_mm_shuffle_epi32
1100   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> zeroinitializer
1101   return _mm_shuffle_epi32(A, 0);
1102 }
1103
1104 __m128d test_mm_shuffle_pd(__m128d A, __m128d B) {
1105   // CHECK-LABEL: test_mm_shuffle_pd
1106   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 1, i32 2>
1107   return _mm_shuffle_pd(A, B, 1);
1108 }
1109
1110 __m128i test_mm_shufflehi_epi16(__m128i A) {
1111   // CHECK-LABEL: test_mm_shufflehi_epi16
1112   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 4, i32 4, i32 4>
1113   return _mm_shufflehi_epi16(A, 0);
1114 }
1115
1116 __m128i test_mm_shufflelo_epi16(__m128i A) {
1117   // CHECK-LABEL: test_mm_shufflelo_epi16
1118   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 5, i32 6, i32 7>
1119   return _mm_shufflelo_epi16(A, 0);
1120 }
1121
1122 __m128i test_mm_sll_epi16(__m128i A, __m128i B) {
1123   // CHECK-LABEL: test_mm_sll_epi16
1124   // CHECK: call <8 x i16> @llvm.x86.sse2.psll.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1125   return _mm_sll_epi16(A, B);
1126 }
1127
1128 __m128i test_mm_sll_epi32(__m128i A, __m128i B) {
1129   // CHECK-LABEL: test_mm_sll_epi32
1130   // CHECK: call <4 x i32> @llvm.x86.sse2.psll.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1131   return _mm_sll_epi32(A, B);
1132 }
1133
1134 __m128i test_mm_sll_epi64(__m128i A, __m128i B) {
1135   // CHECK-LABEL: test_mm_sll_epi64
1136   // CHECK: call <2 x i64> @llvm.x86.sse2.psll.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1137   return _mm_sll_epi64(A, B);
1138 }
1139
1140 __m128i test_mm_slli_epi16(__m128i A) {
1141   // CHECK-LABEL: test_mm_slli_epi16
1142   // CHECK: call <8 x i16> @llvm.x86.sse2.pslli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1143   return _mm_slli_epi16(A, 1);
1144 }
1145
1146 __m128i test_mm_slli_epi32(__m128i A) {
1147   // CHECK-LABEL: test_mm_slli_epi32
1148   // CHECK: call <4 x i32> @llvm.x86.sse2.pslli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1149   return _mm_slli_epi32(A, 1);
1150 }
1151
1152 __m128i test_mm_slli_epi64(__m128i A) {
1153   // CHECK-LABEL: test_mm_slli_epi64
1154   // CHECK: call <2 x i64> @llvm.x86.sse2.pslli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1155   return _mm_slli_epi64(A, 1);
1156 }
1157
1158 __m128i test_mm_slli_si128(__m128i A) {
1159   // CHECK-LABEL: test_mm_slli_si128
1160   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <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>
1161   return _mm_slli_si128(A, 5);
1162 }
1163
1164 __m128i test_mm_slli_si128_2(__m128i A) {
1165   // CHECK-LABEL: test_mm_slli_si128_2
1166   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <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>
1167   return _mm_slli_si128(A, 17);
1168 }
1169
1170 __m128d test_mm_sqrt_pd(__m128d A) {
1171   // CHECK-LABEL: test_mm_sqrt_pd
1172   // CHECK: call <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double> %{{.*}})
1173   return _mm_sqrt_pd(A);
1174 }
1175
1176 __m128d test_mm_sqrt_sd(__m128d A, __m128d B) {
1177   // CHECK-LABEL: test_mm_sqrt_sd
1178   // CHECK: call <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double> %{{.*}})
1179   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1180   // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
1181   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
1182   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
1183   return _mm_sqrt_sd(A, B);
1184 }
1185
1186 __m128i test_mm_sra_epi16(__m128i A, __m128i B) {
1187   // CHECK-LABEL: test_mm_sra_epi16
1188   // CHECK: call <8 x i16> @llvm.x86.sse2.psra.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1189   return _mm_sra_epi16(A, B);
1190 }
1191
1192 __m128i test_mm_sra_epi32(__m128i A, __m128i B) {
1193   // CHECK-LABEL: test_mm_sra_epi32
1194   // CHECK: call <4 x i32> @llvm.x86.sse2.psra.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1195   return _mm_sra_epi32(A, B);
1196 }
1197
1198 __m128i test_mm_srai_epi16(__m128i A) {
1199   // CHECK-LABEL: test_mm_srai_epi16
1200   // CHECK: call <8 x i16> @llvm.x86.sse2.psrai.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1201   return _mm_srai_epi16(A, 1);
1202 }
1203
1204 __m128i test_mm_srai_epi32(__m128i A) {
1205   // CHECK-LABEL: test_mm_srai_epi32
1206   // CHECK: call <4 x i32> @llvm.x86.sse2.psrai.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1207   return _mm_srai_epi32(A, 1);
1208 }
1209
1210 __m128i test_mm_srl_epi16(__m128i A, __m128i B) {
1211   // CHECK-LABEL: test_mm_srl_epi16
1212   // CHECK: call <8 x i16> @llvm.x86.sse2.psrl.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1213   return _mm_srl_epi16(A, B);
1214 }
1215
1216 __m128i test_mm_srl_epi32(__m128i A, __m128i B) {
1217   // CHECK-LABEL: test_mm_srl_epi32
1218   // CHECK: call <4 x i32> @llvm.x86.sse2.psrl.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1219   return _mm_srl_epi32(A, B);
1220 }
1221
1222 __m128i test_mm_srl_epi64(__m128i A, __m128i B) {
1223   // CHECK-LABEL: test_mm_srl_epi64
1224   // CHECK: call <2 x i64> @llvm.x86.sse2.psrl.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1225   return _mm_srl_epi64(A, B);
1226 }
1227
1228 __m128i test_mm_srli_epi16(__m128i A) {
1229   // CHECK-LABEL: test_mm_srli_epi16
1230   // CHECK: call <8 x i16> @llvm.x86.sse2.psrli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1231   return _mm_srli_epi16(A, 1);
1232 }
1233
1234 __m128i test_mm_srli_epi32(__m128i A) {
1235   // CHECK-LABEL: test_mm_srli_epi32
1236   // CHECK: call <4 x i32> @llvm.x86.sse2.psrli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1237   return _mm_srli_epi32(A, 1);
1238 }
1239
1240 __m128i test_mm_srli_epi64(__m128i A) {
1241   // CHECK-LABEL: test_mm_srli_epi64
1242   // CHECK: call <2 x i64> @llvm.x86.sse2.psrli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1243   return _mm_srli_epi64(A, 1);
1244 }
1245
1246 __m128i test_mm_srli_si128(__m128i A) {
1247   // CHECK-LABEL: test_mm_srli_si128
1248   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <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>
1249   return _mm_srli_si128(A, 5);
1250 }
1251
1252 __m128i test_mm_srli_si128_2(__m128i A) {
1253   // CHECK-LABEL: test_mm_srli_si128_2
1254   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <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>
1255   return _mm_srli_si128(A, 17);
1256 }
1257
1258 void test_mm_store_pd(double* A, __m128d B) {
1259   // CHECK-LABEL: test_mm_store_pd
1260   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16
1261   _mm_store_pd(A, B);
1262 }
1263
1264 void test_mm_store_pd1(double* x, __m128d y) {
1265   // CHECK-LABEL: test_mm_store_pd1
1266   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
1267   // CHECK: store <2 x double> %{{.*}}, <2 x double>* {{.*}}, align 16
1268   _mm_store_pd1(x, y);
1269 }
1270
1271 void test_mm_store_sd(double* A, __m128d B) {
1272   // CHECK-LABEL: test_mm_store_sd
1273   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1274   // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}}
1275   _mm_store_sd(A, B);
1276 }
1277
1278 void test_mm_store_si128(__m128i* A, __m128i B) {
1279   // CHECK-LABEL: test_mm_store_si128
1280   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16
1281   _mm_store_si128(A, B);
1282 }
1283
1284 void test_mm_store1_pd(double* x, __m128d y) {
1285   // CHECK-LABEL: test_mm_store1_pd
1286   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
1287   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16
1288   _mm_store1_pd(x, y);
1289 }
1290
1291 void test_mm_storeh_pd(double* A, __m128d B) {
1292   // CHECK-LABEL: test_mm_storeh_pd
1293   // CHECK: extractelement <2 x double> %{{.*}}, i32 1
1294   // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}}
1295   _mm_storeh_pd(A, B);
1296 }
1297
1298 void test_mm_storel_epi64(__m128i x, void* y) {
1299   // CHECK-LABEL: test_mm_storel_epi64
1300   // CHECK: extractelement <2 x i64> %{{.*}}, i32 0
1301   // CHECK: store {{.*}} i64* {{.*}}, align 1{{$}}
1302   _mm_storel_epi64(y, x);
1303 }
1304
1305 void test_mm_storel_pd(double* A, __m128d B) {
1306   // CHECK-LABEL: test_mm_storel_pd
1307   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1308   // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}}
1309   _mm_storel_pd(A, B);
1310 }
1311
1312 void test_mm_storer_pd(__m128d A, double* B) {
1313   // CHECK-LABEL: test_mm_storer_pd
1314   // CHECK: shufflevector <2 x double> {{.*}}, <2 x double> {{.*}}, <2 x i32> <i32 1, i32 0>
1315   // CHECK: store {{.*}} <2 x double>* {{.*}}, align 16{{$}}
1316   _mm_storer_pd(B, A);
1317 }
1318
1319 void test_mm_storeu_pd(double* A, __m128d B) {
1320   // CHECK-LABEL: test_mm_storeu_pd
1321   // CHECK: store {{.*}} <2 x double>* {{.*}}, align 1{{$}}
1322   // CHECK-NEXT: ret void
1323   _mm_storeu_pd(A, B);
1324 }
1325
1326 void test_mm_storeu_si128(__m128i* A, __m128i B) {
1327   // CHECK-LABEL: test_mm_storeu_si128
1328   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
1329   // CHECK-NEXT: ret void
1330   _mm_storeu_si128(A, B);
1331 }
1332
1333 void test_mm_stream_pd(double *A, __m128d B) {
1334   // CHECK-LABEL: test_mm_stream_pd
1335   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16, !nontemporal
1336   _mm_stream_pd(A, B);
1337 }
1338
1339 void test_mm_stream_si32(int *A, int B) {
1340   // CHECK-LABEL: test_mm_stream_si32
1341   // CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1, !nontemporal
1342   _mm_stream_si32(A, B);
1343 }
1344
1345 void test_mm_stream_si64(long long *A, long long B) {
1346   // CHECK-LABEL: test_mm_stream_si64
1347   // CHECK: store i64 %{{.*}}, i64* %{{.*}}, align 1, !nontemporal
1348   _mm_stream_si64(A, B);
1349 }
1350
1351 void test_mm_stream_si128(__m128i *A, __m128i B) {
1352   // CHECK-LABEL: test_mm_stream_si128
1353   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16, !nontemporal
1354   _mm_stream_si128(A, B);
1355 }
1356
1357 __m128i test_mm_sub_epi8(__m128i A, __m128i B) {
1358   // CHECK-LABEL: test_mm_sub_epi8
1359   // CHECK: sub <16 x i8>
1360   return _mm_sub_epi8(A, B);
1361 }
1362
1363 __m128i test_mm_sub_epi16(__m128i A, __m128i B) {
1364   // CHECK-LABEL: test_mm_sub_epi16
1365   // CHECK: sub <8 x i16>
1366   return _mm_sub_epi16(A, B);
1367 }
1368
1369 __m128i test_mm_sub_epi32(__m128i A, __m128i B) {
1370   // CHECK-LABEL: test_mm_sub_epi32
1371   // CHECK: sub <4 x i32>
1372   return _mm_sub_epi32(A, B);
1373 }
1374
1375 __m128i test_mm_sub_epi64(__m128i A, __m128i B) {
1376   // CHECK-LABEL: test_mm_sub_epi64
1377   // CHECK: sub <2 x i64>
1378   return _mm_sub_epi64(A, B);
1379 }
1380
1381 __m128d test_mm_sub_pd(__m128d A, __m128d B) {
1382   // CHECK-LABEL: test_mm_sub_pd
1383   // CHECK: fsub <2 x double>
1384   return _mm_sub_pd(A, B);
1385 }
1386
1387 __m128d test_mm_sub_sd(__m128d A, __m128d B) {
1388   // CHECK-LABEL: test_mm_sub_sd
1389   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1390   // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1391   // CHECK: fsub double
1392   // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
1393   return _mm_sub_sd(A, B);
1394 }
1395
1396 __m128i test_mm_subs_epi8(__m128i A, __m128i B) {
1397   // CHECK-LABEL: test_mm_subs_epi8
1398   // CHECK: call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1399   return _mm_subs_epi8(A, B);
1400 }
1401
1402 __m128i test_mm_subs_epi16(__m128i A, __m128i B) {
1403   // CHECK-LABEL: test_mm_subs_epi16
1404   // CHECK: call <8 x i16> @llvm.x86.sse2.psubs.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1405   return _mm_subs_epi16(A, B);
1406 }
1407
1408 __m128i test_mm_subs_epu8(__m128i A, __m128i B) {
1409   // CHECK-LABEL: test_mm_subs_epu8
1410   // CHECK: call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1411   return _mm_subs_epu8(A, B);
1412 }
1413
1414 __m128i test_mm_subs_epu16(__m128i A, __m128i B) {
1415   // CHECK-LABEL: test_mm_subs_epu16
1416   // CHECK: call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1417   return _mm_subs_epu16(A, B);
1418 }
1419
1420 int test_mm_ucomieq_sd(__m128d A, __m128d B) {
1421   // CHECK-LABEL: test_mm_ucomieq_sd
1422   // CHECK: call i32 @llvm.x86.sse2.ucomieq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1423   return _mm_ucomieq_sd(A, B);
1424 }
1425
1426 int test_mm_ucomige_sd(__m128d A, __m128d B) {
1427   // CHECK-LABEL: test_mm_ucomige_sd
1428   // CHECK: call i32 @llvm.x86.sse2.ucomige.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1429   return _mm_ucomige_sd(A, B);
1430 }
1431
1432 int test_mm_ucomigt_sd(__m128d A, __m128d B) {
1433   // CHECK-LABEL: test_mm_ucomigt_sd
1434   // CHECK: call i32 @llvm.x86.sse2.ucomigt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1435   return _mm_ucomigt_sd(A, B);
1436 }
1437
1438 int test_mm_ucomile_sd(__m128d A, __m128d B) {
1439   // CHECK-LABEL: test_mm_ucomile_sd
1440   // CHECK: call i32 @llvm.x86.sse2.ucomile.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1441   return _mm_ucomile_sd(A, B);
1442 }
1443
1444 int test_mm_ucomilt_sd(__m128d A, __m128d B) {
1445   // CHECK-LABEL: test_mm_ucomilt_sd
1446   // CHECK: call i32 @llvm.x86.sse2.ucomilt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1447   return _mm_ucomilt_sd(A, B);
1448 }
1449
1450 int test_mm_ucomineq_sd(__m128d A, __m128d B) {
1451   // CHECK-LABEL: test_mm_ucomineq_sd
1452   // CHECK: call i32 @llvm.x86.sse2.ucomineq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1453   return _mm_ucomineq_sd(A, B);
1454 }
1455
1456 __m128d test_mm_undefined_pd() {
1457   // CHECK-LABEL: @test_mm_undefined_pd
1458   // CHECK: ret <2 x double> zeroinitializer
1459   return _mm_undefined_pd();
1460 }
1461
1462 __m128i test_mm_undefined_si128() {
1463   // CHECK-LABEL: @test_mm_undefined_si128
1464   // CHECK: ret <2 x i64> zeroinitializer
1465   return _mm_undefined_si128();
1466 }
1467
1468 __m128i test_mm_unpackhi_epi8(__m128i A, __m128i B) {
1469   // CHECK-LABEL: test_mm_unpackhi_epi8
1470   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1471   return _mm_unpackhi_epi8(A, B);
1472 }
1473
1474 __m128i test_mm_unpackhi_epi16(__m128i A, __m128i B) {
1475   // CHECK-LABEL: test_mm_unpackhi_epi16
1476   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1477   return _mm_unpackhi_epi16(A, B);
1478 }
1479
1480 __m128i test_mm_unpackhi_epi32(__m128i A, __m128i B) {
1481   // CHECK-LABEL: test_mm_unpackhi_epi32
1482   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1483   return _mm_unpackhi_epi32(A, B);
1484 }
1485
1486 __m128i test_mm_unpackhi_epi64(__m128i A, __m128i B) {
1487   // CHECK-LABEL: test_mm_unpackhi_epi64
1488   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 1, i32 3>
1489   return _mm_unpackhi_epi64(A, B);
1490 }
1491
1492 __m128d test_mm_unpackhi_pd(__m128d A, __m128d B) {
1493   // CHECK-LABEL: test_mm_unpackhi_pd
1494   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 1, i32 3>
1495   return _mm_unpackhi_pd(A, B);
1496 }
1497
1498 __m128i test_mm_unpacklo_epi8(__m128i A, __m128i B) {
1499   // CHECK-LABEL: test_mm_unpacklo_epi8
1500   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1501   return _mm_unpacklo_epi8(A, B);
1502 }
1503
1504 __m128i test_mm_unpacklo_epi16(__m128i A, __m128i B) {
1505   // CHECK-LABEL: test_mm_unpacklo_epi16
1506   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1507   return _mm_unpacklo_epi16(A, B);
1508 }
1509
1510 __m128i test_mm_unpacklo_epi32(__m128i A, __m128i B) {
1511   // CHECK-LABEL: test_mm_unpacklo_epi32
1512   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1513   return _mm_unpacklo_epi32(A, B);
1514 }
1515
1516 __m128i test_mm_unpacklo_epi64(__m128i A, __m128i B) {
1517   // CHECK-LABEL: test_mm_unpacklo_epi64
1518   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
1519   return _mm_unpacklo_epi64(A, B);
1520 }
1521
1522 __m128d test_mm_unpacklo_pd(__m128d A, __m128d B) {
1523   // CHECK-LABEL: test_mm_unpacklo_pd
1524   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
1525   return _mm_unpacklo_pd(A, B);
1526 }
1527
1528 __m128d test_mm_xor_pd(__m128d A, __m128d B) {
1529   // CHECK-LABEL: test_mm_xor_pd
1530   // CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
1531   return _mm_xor_pd(A, B);
1532 }
1533
1534 __m128i test_mm_xor_si128(__m128i A, __m128i B) {
1535   // CHECK-LABEL: test_mm_xor_si128
1536   // CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
1537   return _mm_xor_si128(A, B);
1538 }