Vendor import of clang 6.0.1 release r335540:vendor/clang/clang-release_601-r335540vendor/clang-60

https://llvm.org/svn/llvm-project/cfe/tags/RELEASE_601/final@335540

9 files changed, 260 insertions, 221 deletions

diff --git a/test/CodeGen/aarch64-inline-asm.c b/test/CodeGen/aarch64-inline-asm.c
index a1078f1bab83..264df9d5fc03 100644
--- a/test/CodeGen/aarch64-inline-asm.c
+++ b/test/CodeGen/aarch64-inline-asm.c
@@ -54,3 +54,23 @@ void test_constraint_Q(void) {
     asm("ldxr %0, %1" : "=r"(val) : "Q"(var));
 // CHECK: call i32 asm "ldxr $0, $1", "=r,*Q"(i64* @var)
 }
+
+void test_gcc_registers(void) {
+    register unsigned long reg0 asm("r0") = 0;
+    register unsigned long reg1 asm("r1") = 1;
+    register unsigned int  reg29 asm("r29") = 2;
+    register unsigned int  reg30 asm("r30") = 3;
+
+    // Test remapping register names in register ... asm("rN") statments.
+    // rN register operands in these two inline assembly lines
+    // should get renamed to valid AArch64 registers.
+    asm volatile("hvc #0" : : "r" (reg0), "r" (reg1));
+    // CHECK: call void asm sideeffect "hvc #0", "{x0},{x1}"
+    asm volatile("hvc #0" : : "r" (reg29), "r" (reg30));
+    // CHECK: call void asm sideeffect "hvc #0", "{fp},{lr}"
+
+    // rN registers when used without register ... asm("rN") syntax
+    // should not be remapped.
+    asm volatile("mov r0, r1\n");
+    // CHECK: call void asm sideeffect "mov r0, r1\0A", ""()
+}
diff --git a/test/CodeGen/attr-target-x86.c b/test/CodeGen/attr-target-x86.c
index 9e46de74916b..43faab37a1a9 100644
--- a/test/CodeGen/attr-target-x86.c
+++ b/test/CodeGen/attr-target-x86.c
@@ -37,10 +37,10 @@ int __attribute__((target("arch=lakemont,mmx"))) lake(int a) { return 4; }
 // CHECK: qq{{.*}} #6
 // CHECK: lake{{.*}} #7
 // CHECK: #0 = {{.*}}"target-cpu"="i686" "target-features"="+x87"
-// CHECK: #1 = {{.*}}"target-cpu"="ivybridge" "target-features"="+aes,+avx,+cx16,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt"
+// CHECK: #1 = {{.*}}"target-cpu"="ivybridge" "target-features"="+aes,+avx,+cx16,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt"
 // CHECK: #2 = {{.*}}"target-cpu"="i686" "target-features"="+x87,-aes,-avx,-avx2,-avx512bitalg,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vbmi2,-avx512vl,-avx512vnni,-avx512vpopcntdq,-f16c,-fma,-fma4,-gfni,-pclmul,-sha,-sse2,-sse3,-sse4.1,-sse4.2,-sse4a,-ssse3,-vaes,-vpclmulqdq,-xop,-xsave,-xsaveopt"
 // CHECK: #3 = {{.*}}"target-cpu"="i686" "target-features"="+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87"
 // CHECK: #4 = {{.*}}"target-cpu"="i686" "target-features"="+x87,-avx,-avx2,-avx512bitalg,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vbmi2,-avx512vl,-avx512vnni,-avx512vpopcntdq,-f16c,-fma,-fma4,-sse4.1,-sse4.2,-vaes,-vpclmulqdq,-xop,-xsave,-xsaveopt"
-// CHECK: #5 = {{.*}}"target-cpu"="ivybridge" "target-features"="+avx,+cx16,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt,-aes,-vaes"
+// CHECK: #5 = {{.*}}"target-cpu"="ivybridge" "target-features"="+avx,+cx16,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt,-aes,-vaes"
 // CHECK: #6 = {{.*}}"target-cpu"="i686" "target-features"="+x87,-3dnow,-3dnowa,-mmx"
 // CHECK: #7 = {{.*}}"target-cpu"="lakemont" "target-features"="+mmx"
diff --git a/test/CodeGen/avx512vlbitalg-builtins.c b/test/CodeGen/avx512vlbitalg-builtins.c
index 9b2a1a469b2a..3dd5b68fd463 100644
--- a/test/CodeGen/avx512vlbitalg-builtins.c
+++ b/test/CodeGen/avx512vlbitalg-builtins.c
@@ -21,23 +21,23 @@ __m256i test_mm256_maskz_popcnt_epi16(__mmask16 __U, __m256i __B) {
   return _mm256_maskz_popcnt_epi16(__U, __B);
 }
 
-__m128i test_mm128_popcnt_epi16(__m128i __A) {
-  // CHECK-LABEL: @test_mm128_popcnt_epi16
+__m128i test_mm_popcnt_epi16(__m128i __A) {
+  // CHECK-LABEL: @test_mm_popcnt_epi16
   // CHECK: @llvm.ctpop.v8i16
-  return _mm128_popcnt_epi16(__A);
+  return _mm_popcnt_epi16(__A);
 }
 
-__m128i test_mm128_mask_popcnt_epi16(__m128i __A, __mmask8 __U, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_popcnt_epi16
+__m128i test_mm_mask_popcnt_epi16(__m128i __A, __mmask8 __U, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_popcnt_epi16
   // CHECK: @llvm.ctpop.v8i16
   // CHECK: select <8 x i1> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i16> {{.*}}
-  return _mm128_mask_popcnt_epi16(__A, __U, __B);
+  return _mm_mask_popcnt_epi16(__A, __U, __B);
 }
-__m128i test_mm128_maskz_popcnt_epi16(__mmask8 __U, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_popcnt_epi16
+__m128i test_mm_maskz_popcnt_epi16(__mmask8 __U, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_popcnt_epi16
   // CHECK: @llvm.ctpop.v8i16
   // CHECK: select <8 x i1> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i16> {{.*}}
-  return _mm128_maskz_popcnt_epi16(__U, __B);
+  return _mm_maskz_popcnt_epi16(__U, __B);
 }
 
 __m256i test_mm256_popcnt_epi8(__m256i __A) {
@@ -59,46 +59,46 @@ __m256i test_mm256_maskz_popcnt_epi8(__mmask32 __U, __m256i __B) {
   return _mm256_maskz_popcnt_epi8(__U, __B);
 }
 
-__m128i test_mm128_popcnt_epi8(__m128i __A) {
-  // CHECK-LABEL: @test_mm128_popcnt_epi8
+__m128i test_mm_popcnt_epi8(__m128i __A) {
+  // CHECK-LABEL: @test_mm_popcnt_epi8
   // CHECK: @llvm.ctpop.v16i8
-  return _mm128_popcnt_epi8(__A);
+  return _mm_popcnt_epi8(__A);
 }
 
-__m128i test_mm128_mask_popcnt_epi8(__m128i __A, __mmask16 __U, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_popcnt_epi8
+__m128i test_mm_mask_popcnt_epi8(__m128i __A, __mmask16 __U, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_popcnt_epi8
   // CHECK: @llvm.ctpop.v16i8
   // CHECK: select <16 x i1> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i8> {{.*}}
-  return _mm128_mask_popcnt_epi8(__A, __U, __B);
+  return _mm_mask_popcnt_epi8(__A, __U, __B);
 }
-__m128i test_mm128_maskz_popcnt_epi8(__mmask16 __U, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_popcnt_epi8
+__m128i test_mm_maskz_popcnt_epi8(__mmask16 __U, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_popcnt_epi8
   // CHECK: @llvm.ctpop.v16i8
   // CHECK: select <16 x i1> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i8> {{.*}}
-  return _mm128_maskz_popcnt_epi8(__U, __B);
+  return _mm_maskz_popcnt_epi8(__U, __B);
 }
 
-__mmask32 test_mm256_mask_bitshuffle_epi32_mask(__mmask32 __U, __m256i __A, __m256i __B) {
-  // CHECK-LABEL: @test_mm256_mask_bitshuffle_epi32_mask
+__mmask32 test_mm256_mask_bitshuffle_epi64_mask(__mmask32 __U, __m256i __A, __m256i __B) {
+  // CHECK-LABEL: @test_mm256_mask_bitshuffle_epi64_mask
   // CHECK: @llvm.x86.avx512.mask.vpshufbitqmb.256
-  return _mm256_mask_bitshuffle_epi32_mask(__U, __A, __B);
+  return _mm256_mask_bitshuffle_epi64_mask(__U, __A, __B);
 }
 
-__mmask32 test_mm256_bitshuffle_epi32_mask(__m256i __A, __m256i __B) {
-  // CHECK-LABEL: @test_mm256_bitshuffle_epi32_mask
+__mmask32 test_mm256_bitshuffle_epi64_mask(__m256i __A, __m256i __B) {
+  // CHECK-LABEL: @test_mm256_bitshuffle_epi64_mask
   // CHECK: @llvm.x86.avx512.mask.vpshufbitqmb.256
-  return _mm256_bitshuffle_epi32_mask(__A, __B);
+  return _mm256_bitshuffle_epi64_mask(__A, __B);
 }
 
-__mmask16 test_mm128_mask_bitshuffle_epi16_mask(__mmask16 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_bitshuffle_epi16_mask
+__mmask16 test_mm_mask_bitshuffle_epi64_mask(__mmask16 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_bitshuffle_epi64_mask
   // CHECK: @llvm.x86.avx512.mask.vpshufbitqmb.128
-  return _mm128_mask_bitshuffle_epi16_mask(__U, __A, __B);
+  return _mm_mask_bitshuffle_epi64_mask(__U, __A, __B);
 }
 
-__mmask16 test_mm128_bitshuffle_epi16_mask(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_bitshuffle_epi16_mask
+__mmask16 test_mm_bitshuffle_epi64_mask(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_bitshuffle_epi64_mask
   // CHECK: @llvm.x86.avx512.mask.vpshufbitqmb.128
-  return _mm128_bitshuffle_epi16_mask(__A, __B);
+  return _mm_bitshuffle_epi64_mask(__A, __B);
 }
 
diff --git a/test/CodeGen/avx512vlvbmi2-builtins.c b/test/CodeGen/avx512vlvbmi2-builtins.c
index 6edc66d30eee..6615616c6f9b 100644
--- a/test/CodeGen/avx512vlvbmi2-builtins.c
+++ b/test/CodeGen/avx512vlvbmi2-builtins.c
@@ -2,88 +2,88 @@
 
 #include <immintrin.h>
 
-__m128i test_mm128_mask_compress_epi16(__m128i __S, __mmask8 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_mask_compress_epi16
+__m128i test_mm_mask_compress_epi16(__m128i __S, __mmask8 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_mask_compress_epi16
   // CHECK: @llvm.x86.avx512.mask.compress.w.128
-  return _mm128_mask_compress_epi16(__S, __U, __D);
+  return _mm_mask_compress_epi16(__S, __U, __D);
 }
 
-__m128i test_mm128_maskz_compress_epi16(__mmask8 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_maskz_compress_epi16
+__m128i test_mm_maskz_compress_epi16(__mmask8 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_maskz_compress_epi16
   // CHECK: @llvm.x86.avx512.mask.compress.w.128
-  return _mm128_maskz_compress_epi16(__U, __D);
+  return _mm_maskz_compress_epi16(__U, __D);
 }
 
-__m128i test_mm128_mask_compress_epi8(__m128i __S, __mmask16 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_mask_compress_epi8
+__m128i test_mm_mask_compress_epi8(__m128i __S, __mmask16 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_mask_compress_epi8
   // CHECK: @llvm.x86.avx512.mask.compress.b.128
-  return _mm128_mask_compress_epi8(__S, __U, __D);
+  return _mm_mask_compress_epi8(__S, __U, __D);
 }
 
-__m128i test_mm128_maskz_compress_epi8(__mmask16 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_maskz_compress_epi8
+__m128i test_mm_maskz_compress_epi8(__mmask16 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_maskz_compress_epi8
   // CHECK: @llvm.x86.avx512.mask.compress.b.128
-  return _mm128_maskz_compress_epi8(__U, __D);
+  return _mm_maskz_compress_epi8(__U, __D);
 }
 
-void test_mm128_mask_compressstoreu_epi16(void *__P, __mmask8 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_mask_compressstoreu_epi16
+void test_mm_mask_compressstoreu_epi16(void *__P, __mmask8 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_mask_compressstoreu_epi16
   // CHECK: @llvm.x86.avx512.mask.compress.store.w.128
-  _mm128_mask_compressstoreu_epi16(__P, __U, __D);
+  _mm_mask_compressstoreu_epi16(__P, __U, __D);
 }
 
-void test_mm128_mask_compressstoreu_epi8(void *__P, __mmask16 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_mask_compressstoreu_epi8
+void test_mm_mask_compressstoreu_epi8(void *__P, __mmask16 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_mask_compressstoreu_epi8
   // CHECK: @llvm.x86.avx512.mask.compress.store.b.128
-  _mm128_mask_compressstoreu_epi8(__P, __U, __D);
+  _mm_mask_compressstoreu_epi8(__P, __U, __D);
 }
 
-__m128i test_mm128_mask_expand_epi16(__m128i __S, __mmask8 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_mask_expand_epi16
+__m128i test_mm_mask_expand_epi16(__m128i __S, __mmask8 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_mask_expand_epi16
   // CHECK: @llvm.x86.avx512.mask.expand.w.128
-  return _mm128_mask_expand_epi16(__S, __U, __D);
+  return _mm_mask_expand_epi16(__S, __U, __D);
 }
 
-__m128i test_mm128_maskz_expand_epi16(__mmask8 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_maskz_expand_epi16
+__m128i test_mm_maskz_expand_epi16(__mmask8 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_maskz_expand_epi16
   // CHECK: @llvm.x86.avx512.mask.expand.w.128
-  return _mm128_maskz_expand_epi16(__U, __D);
+  return _mm_maskz_expand_epi16(__U, __D);
 }
 
-__m128i test_mm128_mask_expand_epi8(__m128i __S, __mmask16 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_mask_expand_epi8
+__m128i test_mm_mask_expand_epi8(__m128i __S, __mmask16 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_mask_expand_epi8
   // CHECK: @llvm.x86.avx512.mask.expand.b.128
-  return _mm128_mask_expand_epi8(__S, __U, __D);
+  return _mm_mask_expand_epi8(__S, __U, __D);
 }
 
-__m128i test_mm128_maskz_expand_epi8(__mmask16 __U, __m128i __D) {
-  // CHECK-LABEL: @test_mm128_maskz_expand_epi8
+__m128i test_mm_maskz_expand_epi8(__mmask16 __U, __m128i __D) {
+  // CHECK-LABEL: @test_mm_maskz_expand_epi8
   // CHECK: @llvm.x86.avx512.mask.expand.b.128
-  return _mm128_maskz_expand_epi8(__U, __D);
+  return _mm_maskz_expand_epi8(__U, __D);
 }
 
-__m128i test_mm128_mask_expandloadu_epi16(__m128i __S, __mmask8 __U, void const* __P) {
-  // CHECK-LABEL: @test_mm128_mask_expandloadu_epi16
+__m128i test_mm_mask_expandloadu_epi16(__m128i __S, __mmask8 __U, void const* __P) {
+  // CHECK-LABEL: @test_mm_mask_expandloadu_epi16
   // CHECK: @llvm.x86.avx512.mask.expand.load.w.128
-  return _mm128_mask_expandloadu_epi16(__S, __U, __P);
+  return _mm_mask_expandloadu_epi16(__S, __U, __P);
 }
 
-__m128i test_mm128_maskz_expandloadu_epi16(__mmask8 __U, void const* __P) {
-  // CHECK-LABEL: @test_mm128_maskz_expandloadu_epi16
+__m128i test_mm_maskz_expandloadu_epi16(__mmask8 __U, void const* __P) {
+  // CHECK-LABEL: @test_mm_maskz_expandloadu_epi16
   // CHECK: @llvm.x86.avx512.mask.expand.load.w.128
-  return _mm128_maskz_expandloadu_epi16(__U, __P);
+  return _mm_maskz_expandloadu_epi16(__U, __P);
 }
 
-__m128i test_mm128_mask_expandloadu_epi8(__m128i __S, __mmask16 __U, void const* __P) {
-  // CHECK-LABEL: @test_mm128_mask_expandloadu_epi8
+__m128i test_mm_mask_expandloadu_epi8(__m128i __S, __mmask16 __U, void const* __P) {
+  // CHECK-LABEL: @test_mm_mask_expandloadu_epi8
   // CHECK: @llvm.x86.avx512.mask.expand.load.b.128
-  return _mm128_mask_expandloadu_epi8(__S, __U, __P);
+  return _mm_mask_expandloadu_epi8(__S, __U, __P);
 }
 
-__m128i test_mm128_maskz_expandloadu_epi8(__mmask16 __U, void const* __P) {
-  // CHECK-LABEL: @test_mm128_maskz_expandloadu_epi8
+__m128i test_mm_maskz_expandloadu_epi8(__mmask16 __U, void const* __P) {
+  // CHECK-LABEL: @test_mm_maskz_expandloadu_epi8
   // CHECK: @llvm.x86.avx512.mask.expand.load.b.128
-  return _mm128_maskz_expandloadu_epi8(__U, __P);
+  return _mm_maskz_expandloadu_epi8(__U, __P);
 }
 
 __m256i test_mm256_mask_compress_epi16(__m256i __S, __mmask16 __U, __m256i __D) {
@@ -188,22 +188,22 @@ __m256i test_mm256_shldi_epi64(__m256i __A, __m256i __B) {
   return _mm256_shldi_epi64(__A, __B, 31);
 }
 
-__m128i test_mm128_mask_shldi_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shldi_epi64
+__m128i test_mm_mask_shldi_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shldi_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshld.q.128
-  return _mm128_mask_shldi_epi64(__S, __U, __A, __B, 127);
+  return _mm_mask_shldi_epi64(__S, __U, __A, __B, 127);
 }
 
-__m128i test_mm128_maskz_shldi_epi64(__mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shldi_epi64
+__m128i test_mm_maskz_shldi_epi64(__mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shldi_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshld.q.128
-  return _mm128_maskz_shldi_epi64(__U, __A, __B, 63);
+  return _mm_maskz_shldi_epi64(__U, __A, __B, 63);
 }
 
-__m128i test_mm128_shldi_epi64(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shldi_epi64
+__m128i test_mm_shldi_epi64(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shldi_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshld.q.128
-  return _mm128_shldi_epi64(__A, __B, 31);
+  return _mm_shldi_epi64(__A, __B, 31);
 }
 
 __m256i test_mm256_mask_shldi_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -224,22 +224,22 @@ __m256i test_mm256_shldi_epi32(__m256i __A, __m256i __B) {
   return _mm256_shldi_epi32(__A, __B, 31);
 }
 
-__m128i test_mm128_mask_shldi_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shldi_epi32
+__m128i test_mm_mask_shldi_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shldi_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshld.d.128
-  return _mm128_mask_shldi_epi32(__S, __U, __A, __B, 127);
+  return _mm_mask_shldi_epi32(__S, __U, __A, __B, 127);
 }
 
-__m128i test_mm128_maskz_shldi_epi32(__mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shldi_epi32
+__m128i test_mm_maskz_shldi_epi32(__mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shldi_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshld.d.128
-  return _mm128_maskz_shldi_epi32(__U, __A, __B, 63);
+  return _mm_maskz_shldi_epi32(__U, __A, __B, 63);
 }
 
-__m128i test_mm128_shldi_epi32(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shldi_epi32
+__m128i test_mm_shldi_epi32(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shldi_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshld.d.128
-  return _mm128_shldi_epi32(__A, __B, 31);
+  return _mm_shldi_epi32(__A, __B, 31);
 }
 
 __m256i test_mm256_mask_shldi_epi16(__m256i __S, __mmask16 __U, __m256i __A, __m256i __B) {
@@ -260,22 +260,22 @@ __m256i test_mm256_shldi_epi16(__m256i __A, __m256i __B) {
   return _mm256_shldi_epi16(__A, __B, 31);
 }
 
-__m128i test_mm128_mask_shldi_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shldi_epi16
+__m128i test_mm_mask_shldi_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shldi_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshld.w.128
-  return _mm128_mask_shldi_epi16(__S, __U, __A, __B, 127);
+  return _mm_mask_shldi_epi16(__S, __U, __A, __B, 127);
 }
 
-__m128i test_mm128_maskz_shldi_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shldi_epi16
+__m128i test_mm_maskz_shldi_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shldi_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshld.w.128
-  return _mm128_maskz_shldi_epi16(__U, __A, __B, 63);
+  return _mm_maskz_shldi_epi16(__U, __A, __B, 63);
 }
 
-__m128i test_mm128_shldi_epi16(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shldi_epi16
+__m128i test_mm_shldi_epi16(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shldi_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshld.w.128
-  return _mm128_shldi_epi16(__A, __B, 31);
+  return _mm_shldi_epi16(__A, __B, 31);
 }
 
 __m256i test_mm256_mask_shrdi_epi64(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -296,22 +296,22 @@ __m256i test_mm256_shrdi_epi64(__m256i __A, __m256i __B) {
   return _mm256_shrdi_epi64(__A, __B, 31);
 }
 
-__m128i test_mm128_mask_shrdi_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shrdi_epi64
+__m128i test_mm_mask_shrdi_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shrdi_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshrd.q.128
-  return _mm128_mask_shrdi_epi64(__S, __U, __A, __B, 127);
+  return _mm_mask_shrdi_epi64(__S, __U, __A, __B, 127);
 }
 
-__m128i test_mm128_maskz_shrdi_epi64(__mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shrdi_epi64
+__m128i test_mm_maskz_shrdi_epi64(__mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shrdi_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshrd.q.128
-  return _mm128_maskz_shrdi_epi64(__U, __A, __B, 63);
+  return _mm_maskz_shrdi_epi64(__U, __A, __B, 63);
 }
 
-__m128i test_mm128_shrdi_epi64(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shrdi_epi64
+__m128i test_mm_shrdi_epi64(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shrdi_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshrd.q.128
-  return _mm128_shrdi_epi64(__A, __B, 31);
+  return _mm_shrdi_epi64(__A, __B, 31);
 }
 
 __m256i test_mm256_mask_shrdi_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -332,22 +332,22 @@ __m256i test_mm256_shrdi_epi32(__m256i __A, __m256i __B) {
   return _mm256_shrdi_epi32(__A, __B, 31);
 }
 
-__m128i test_mm128_mask_shrdi_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shrdi_epi32
+__m128i test_mm_mask_shrdi_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shrdi_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshrd.d.128
-  return _mm128_mask_shrdi_epi32(__S, __U, __A, __B, 127);
+  return _mm_mask_shrdi_epi32(__S, __U, __A, __B, 127);
 }
 
-__m128i test_mm128_maskz_shrdi_epi32(__mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shrdi_epi32
+__m128i test_mm_maskz_shrdi_epi32(__mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shrdi_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshrd.d.128
-  return _mm128_maskz_shrdi_epi32(__U, __A, __B, 63);
+  return _mm_maskz_shrdi_epi32(__U, __A, __B, 63);
 }
 
-__m128i test_mm128_shrdi_epi32(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shrdi_epi32
+__m128i test_mm_shrdi_epi32(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shrdi_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshrd.d.128
-  return _mm128_shrdi_epi32(__A, __B, 31);
+  return _mm_shrdi_epi32(__A, __B, 31);
 }
 
 __m256i test_mm256_mask_shrdi_epi16(__m256i __S, __mmask16 __U, __m256i __A, __m256i __B) {
@@ -368,22 +368,22 @@ __m256i test_mm256_shrdi_epi16(__m256i __A, __m256i __B) {
   return _mm256_shrdi_epi16(__A, __B, 31);
 }
 
-__m128i test_mm128_mask_shrdi_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shrdi_epi16
+__m128i test_mm_mask_shrdi_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shrdi_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshrd.w.128
-  return _mm128_mask_shrdi_epi16(__S, __U, __A, __B, 127);
+  return _mm_mask_shrdi_epi16(__S, __U, __A, __B, 127);
 }
 
-__m128i test_mm128_maskz_shrdi_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shrdi_epi16
+__m128i test_mm_maskz_shrdi_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shrdi_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshrd.w.128
-  return _mm128_maskz_shrdi_epi16(__U, __A, __B, 63);
+  return _mm_maskz_shrdi_epi16(__U, __A, __B, 63);
 }
 
-__m128i test_mm128_shrdi_epi16(__m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shrdi_epi16
+__m128i test_mm_shrdi_epi16(__m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shrdi_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshrd.w.128
-  return _mm128_shrdi_epi16(__A, __B, 31);
+  return _mm_shrdi_epi16(__A, __B, 31);
 }
 
 __m256i test_mm256_mask_shldv_epi64(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -404,22 +404,22 @@ __m256i test_mm256_shldv_epi64(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_shldv_epi64(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_shldv_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shldv_epi64
+__m128i test_mm_mask_shldv_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shldv_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshldv.q.128
-  return _mm128_mask_shldv_epi64(__S, __U, __A, __B);
+  return _mm_mask_shldv_epi64(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_shldv_epi64(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shldv_epi64
+__m128i test_mm_maskz_shldv_epi64(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shldv_epi64
   // CHECK: @llvm.x86.avx512.maskz.vpshldv.q.128
-  return _mm128_maskz_shldv_epi64(__U, __S, __A, __B);
+  return _mm_maskz_shldv_epi64(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_shldv_epi64(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shldv_epi64
+__m128i test_mm_shldv_epi64(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shldv_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshldv.q.128
-  return _mm128_shldv_epi64(__S, __A, __B);
+  return _mm_shldv_epi64(__S, __A, __B);
 }
 
 __m256i test_mm256_mask_shldv_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -440,22 +440,22 @@ __m256i test_mm256_shldv_epi32(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_shldv_epi32(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_shldv_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shldv_epi32
+__m128i test_mm_mask_shldv_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shldv_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshldv.d.128
-  return _mm128_mask_shldv_epi32(__S, __U, __A, __B);
+  return _mm_mask_shldv_epi32(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_shldv_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shldv_epi32
+__m128i test_mm_maskz_shldv_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shldv_epi32
   // CHECK: @llvm.x86.avx512.maskz.vpshldv.d.128
-  return _mm128_maskz_shldv_epi32(__U, __S, __A, __B);
+  return _mm_maskz_shldv_epi32(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_shldv_epi32(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shldv_epi32
+__m128i test_mm_shldv_epi32(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shldv_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshldv.d.128
-  return _mm128_shldv_epi32(__S, __A, __B);
+  return _mm_shldv_epi32(__S, __A, __B);
 }
 
 __m256i test_mm256_mask_shldv_epi16(__m256i __S, __mmask16 __U, __m256i __A, __m256i __B) {
@@ -476,22 +476,22 @@ __m256i test_mm256_shldv_epi16(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_shldv_epi16(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_shldv_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shldv_epi16
+__m128i test_mm_mask_shldv_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shldv_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshldv.w.128
-  return _mm128_mask_shldv_epi16(__S, __U, __A, __B);
+  return _mm_mask_shldv_epi16(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_shldv_epi16(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shldv_epi16
+__m128i test_mm_maskz_shldv_epi16(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shldv_epi16
   // CHECK: @llvm.x86.avx512.maskz.vpshldv.w.128
-  return _mm128_maskz_shldv_epi16(__U, __S, __A, __B);
+  return _mm_maskz_shldv_epi16(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_shldv_epi16(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shldv_epi16
+__m128i test_mm_shldv_epi16(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shldv_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshldv.w.128
-  return _mm128_shldv_epi16(__S, __A, __B);
+  return _mm_shldv_epi16(__S, __A, __B);
 }
 
 __m256i test_mm256_mask_shrdv_epi64(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -512,22 +512,22 @@ __m256i test_mm256_shrdv_epi64(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_shrdv_epi64(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_shrdv_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shrdv_epi64
+__m128i test_mm_mask_shrdv_epi64(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shrdv_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshrdv.q.128
-  return _mm128_mask_shrdv_epi64(__S, __U, __A, __B);
+  return _mm_mask_shrdv_epi64(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_shrdv_epi64(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shrdv_epi64
+__m128i test_mm_maskz_shrdv_epi64(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shrdv_epi64
   // CHECK: @llvm.x86.avx512.maskz.vpshrdv.q.128
-  return _mm128_maskz_shrdv_epi64(__U, __S, __A, __B);
+  return _mm_maskz_shrdv_epi64(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_shrdv_epi64(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shrdv_epi64
+__m128i test_mm_shrdv_epi64(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shrdv_epi64
   // CHECK: @llvm.x86.avx512.mask.vpshrdv.q.128
-  return _mm128_shrdv_epi64(__S, __A, __B);
+  return _mm_shrdv_epi64(__S, __A, __B);
 }
 
 __m256i test_mm256_mask_shrdv_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B) {
@@ -548,22 +548,22 @@ __m256i test_mm256_shrdv_epi32(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_shrdv_epi32(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_shrdv_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shrdv_epi32
+__m128i test_mm_mask_shrdv_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shrdv_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshrdv.d.128
-  return _mm128_mask_shrdv_epi32(__S, __U, __A, __B);
+  return _mm_mask_shrdv_epi32(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_shrdv_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shrdv_epi32
+__m128i test_mm_maskz_shrdv_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shrdv_epi32
   // CHECK: @llvm.x86.avx512.maskz.vpshrdv.d.128
-  return _mm128_maskz_shrdv_epi32(__U, __S, __A, __B);
+  return _mm_maskz_shrdv_epi32(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_shrdv_epi32(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shrdv_epi32
+__m128i test_mm_shrdv_epi32(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shrdv_epi32
   // CHECK: @llvm.x86.avx512.mask.vpshrdv.d.128
-  return _mm128_shrdv_epi32(__S, __A, __B);
+  return _mm_shrdv_epi32(__S, __A, __B);
 }
 
 __m256i test_mm256_mask_shrdv_epi16(__m256i __S, __mmask16 __U, __m256i __A, __m256i __B) {
@@ -584,21 +584,21 @@ __m256i test_mm256_shrdv_epi16(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_shrdv_epi16(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_shrdv_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_shrdv_epi16
+__m128i test_mm_mask_shrdv_epi16(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_shrdv_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshrdv.w.128
-  return _mm128_mask_shrdv_epi16(__S, __U, __A, __B);
+  return _mm_mask_shrdv_epi16(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_shrdv_epi16(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_shrdv_epi16
+__m128i test_mm_maskz_shrdv_epi16(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_shrdv_epi16
   // CHECK: @llvm.x86.avx512.maskz.vpshrdv.w.128
-  return _mm128_maskz_shrdv_epi16(__U, __S, __A, __B);
+  return _mm_maskz_shrdv_epi16(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_shrdv_epi16(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_shrdv_epi16
+__m128i test_mm_shrdv_epi16(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_shrdv_epi16
   // CHECK: @llvm.x86.avx512.mask.vpshrdv.w.128
-  return _mm128_shrdv_epi16(__S, __A, __B);
+  return _mm_shrdv_epi16(__S, __A, __B);
 }
 
diff --git a/test/CodeGen/avx512vlvnni-builtins.c b/test/CodeGen/avx512vlvnni-builtins.c
index 861b915fdb29..f6265f4189f9 100644
--- a/test/CodeGen/avx512vlvnni-builtins.c
+++ b/test/CodeGen/avx512vlvnni-builtins.c
@@ -74,75 +74,75 @@ __m256i test_mm256_dpwssds_epi32(__m256i __S, __m256i __A, __m256i __B) {
   return _mm256_dpwssds_epi32(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_dpbusd_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_dpbusd_epi32
+__m128i test_mm_mask_dpbusd_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_dpbusd_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpbusd.128
-  return _mm128_mask_dpbusd_epi32(__S, __U, __A, __B);
+  return _mm_mask_dpbusd_epi32(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_dpbusd_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_dpbusd_epi32
+__m128i test_mm_maskz_dpbusd_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_dpbusd_epi32
   // CHECK: @llvm.x86.avx512.maskz.vpdpbusd.128
-  return _mm128_maskz_dpbusd_epi32(__U, __S, __A, __B);
+  return _mm_maskz_dpbusd_epi32(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_dpbusd_epi32(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_dpbusd_epi32
+__m128i test_mm_dpbusd_epi32(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_dpbusd_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpbusd.128
-  return _mm128_dpbusd_epi32(__S, __A, __B);
+  return _mm_dpbusd_epi32(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_dpbusds_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_dpbusds_epi32
+__m128i test_mm_mask_dpbusds_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_dpbusds_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpbusds.128
-  return _mm128_mask_dpbusds_epi32(__S, __U, __A, __B);
+  return _mm_mask_dpbusds_epi32(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_dpbusds_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_dpbusds_epi32
+__m128i test_mm_maskz_dpbusds_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_dpbusds_epi32
   // CHECK: @llvm.x86.avx512.maskz.vpdpbusds.128
-  return _mm128_maskz_dpbusds_epi32(__U, __S, __A, __B);
+  return _mm_maskz_dpbusds_epi32(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_dpbusds_epi32(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_dpbusds_epi32
+__m128i test_mm_dpbusds_epi32(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_dpbusds_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpbusds.128
-  return _mm128_dpbusds_epi32(__S, __A, __B);
+  return _mm_dpbusds_epi32(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_dpwssd_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_dpwssd_epi32
+__m128i test_mm_mask_dpwssd_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_dpwssd_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpwssd.128
-  return _mm128_mask_dpwssd_epi32(__S, __U, __A, __B);
+  return _mm_mask_dpwssd_epi32(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_dpwssd_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_dpwssd_epi32
+__m128i test_mm_maskz_dpwssd_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_dpwssd_epi32
   // CHECK: @llvm.x86.avx512.maskz.vpdpwssd.128
-  return _mm128_maskz_dpwssd_epi32(__U, __S, __A, __B);
+  return _mm_maskz_dpwssd_epi32(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_dpwssd_epi32(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_dpwssd_epi32
+__m128i test_mm_dpwssd_epi32(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_dpwssd_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpwssd.128
-  return _mm128_dpwssd_epi32(__S, __A, __B);
+  return _mm_dpwssd_epi32(__S, __A, __B);
 }
 
-__m128i test_mm128_mask_dpwssds_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_mask_dpwssds_epi32
+__m128i test_mm_mask_dpwssds_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_mask_dpwssds_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpwssds.128
-  return _mm128_mask_dpwssds_epi32(__S, __U, __A, __B);
+  return _mm_mask_dpwssds_epi32(__S, __U, __A, __B);
 }
 
-__m128i test_mm128_maskz_dpwssds_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_maskz_dpwssds_epi32
+__m128i test_mm_maskz_dpwssds_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_maskz_dpwssds_epi32
   // CHECK: @llvm.x86.avx512.maskz.vpdpwssds.128
-  return _mm128_maskz_dpwssds_epi32(__U, __S, __A, __B);
+  return _mm_maskz_dpwssds_epi32(__U, __S, __A, __B);
 }
 
-__m128i test_mm128_dpwssds_epi32(__m128i __S, __m128i __A, __m128i __B) {
-  // CHECK-LABEL: @test_mm128_dpwssds_epi32
+__m128i test_mm_dpwssds_epi32(__m128i __S, __m128i __A, __m128i __B) {
+  // CHECK-LABEL: @test_mm_dpwssds_epi32
   // CHECK: @llvm.x86.avx512.mask.vpdpwssds.128
-  return _mm128_dpwssds_epi32(__S, __A, __B);
+  return _mm_dpwssds_epi32(__S, __A, __B);
 }
 
diff --git a/test/CodeGen/decl.c b/test/CodeGen/decl.c
index 2065e3364bcd..2734ea7c5910 100644
--- a/test/CodeGen/decl.c
+++ b/test/CodeGen/decl.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -w -emit-llvm < %s | FileCheck %s
+// RUN: %clang_cc1 -w -fmerge-all-constants -emit-llvm < %s | FileCheck %s
 
 // CHECK: @test1.x = internal constant [12 x i32] [i32 1
 // CHECK: @test2.x = private unnamed_addr constant [13 x i32] [i32 1,
diff --git a/test/CodeGen/function-attributes.c b/test/CodeGen/function-attributes.c
index e14397440100..9174b8785d9e 100644
--- a/test/CodeGen/function-attributes.c
+++ b/test/CodeGen/function-attributes.c
@@ -71,7 +71,7 @@ void f15(void) {
 
 // PR5254
 // CHECK-LABEL: define void @f16
-// CHECK: [[ALIGN:#[0-9]+]]
+// CHECK: [[SR:#[0-9]+]]
 // CHECK: {
 void __attribute__((force_align_arg_pointer)) f16(void) {
 }
@@ -112,7 +112,7 @@ void f20(void) {
 // CHECK: attributes [[NUW]] = { nounwind optsize{{.*}} }
 // CHECK: attributes [[AI]] = { alwaysinline nounwind optsize{{.*}} }
 // CHECK: attributes [[NUW_OS_RN]] = { nounwind optsize readnone{{.*}} }
-// CHECK: attributes [[ALIGN]] = { nounwind optsize alignstack=16{{.*}} }
+// CHECK: attributes [[SR]] = { nounwind optsize{{.*}} "stackrealign"{{.*}} }
 // CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} }
 // CHECK: attributes [[NR]] = { noreturn optsize }
 // CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone }
diff --git a/test/CodeGen/mingw-long-double.c b/test/CodeGen/mingw-long-double.c
index 1c7c31f88be3..166f7decfc3a 100644
--- a/test/CodeGen/mingw-long-double.c
+++ b/test/CodeGen/mingw-long-double.c
@@ -1,5 +1,7 @@
 // RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -o - %s \
 // RUN:    | FileCheck %s --check-prefix=GNU32
+// RUN: %clang_cc1 -triple i686-windows-gnu -emit-llvm -o - %s -mms-bitfields \
+// RUN:    | FileCheck %s --check-prefix=GNU32
 // RUN: %clang_cc1 -triple x86_64-windows-gnu -emit-llvm -o - %s \
 // RUN:    | FileCheck %s --check-prefix=GNU64
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -emit-llvm -o - %s \
diff --git a/test/CodeGen/ms_struct-long-double.c b/test/CodeGen/ms_struct-long-double.c
new file mode 100644
index 000000000000..9b3ea7947a03
--- /dev/null
+++ b/test/CodeGen/ms_struct-long-double.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -emit-llvm-only -triple i686-windows-gnu -fdump-record-layouts %s | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm-only -triple i686-linux -fdump-record-layouts -Wno-incompatible-ms-struct %s | FileCheck %s
+// RUN: not %clang_cc1 -emit-llvm-only -triple i686-linux -fdump-record-layouts %s 2>&1 | FileCheck %s -check-prefix=ERROR
+
+struct ldb_struct {
+  char c;
+  long double ldb;
+} __attribute__((__ms_struct__));
+
+struct ldb_struct a;
+
+// CHECK:             0 | struct ldb_struct
+// CHECK-NEXT:        0 |   char c
+// CHECK-NEXT:        4 |   long double ldb
+// CHECK-NEXT:          | [sizeof=16, align=4]
+
+// ERROR: error: ms_struct may not produce Microsoft-compatible layouts with fundamental data types with sizes that aren't a power of two