[Modules] Add a command line option for enabling the modules feature exclusively for the Clang builtins.

[eladcohen]

Summary

-fexclusive-builtin-modules enables the clang 'modules' feature exclusively for the clang intrinsic header files.

The end goal of this effort is to have this option on by default for x86 targets so we could reduce the long compile time of the x86 intrinsic header files.

[bruno]

Hi Elad,

Is there any reason why you can't explicit model this in your build system by pre-building the intrinsics and pointing to a module cache path containing the pcm files? By doing that we don't need to have a specific compile flag.

[eladcohen]

Hi Bruno,

The short answer is yes. Essentially it can be done, but we would actually like for all the users to always get this behavior, implicitly.

The long answer is that there is a history of problems regarding the intrinsic files:
http://lists.llvm.org/pipermail/cfe-dev/2016-May/048837.html
http://lists.llvm.org/pipermail/cfe-dev/2016-September/050943.html
Mainly compatibility issues because MSVC makes all the intrinsics available all the time, while in clang this is not always the case (On Windows the different h files are not-included unless asked for explicitly since AVX512 was added which impacted compile-time).
A suggestion was made to try and mitigate this by reducing the compile time using modules (only for the x86 intrinsics). This patch aims at adding this option. The new compile flag is just a milestone - if all goes well, we can turn this on by default (Then we won't actually need to use a specific compile flag, and we could always include all the intrinsic h files without their long compile time).

[bruno]

The long answer is that there is a history of problems regarding the intrinsic files:
http://lists.llvm.org/pipermail/cfe-dev/2016-May/048837.html
http://lists.llvm.org/pipermail/cfe-dev/2016-September/050943.html
Mainly compatibility issues because MSVC makes all the intrinsics available all the time, while in clang this is not always the case (On Windows the different h files are not-included unless asked for explicitly since AVX512 was added which impacted compile-time).

Thinking a bit more about this: did you ever consider a solution where "immintrin.h" (or any similar other) would use "#include_next" and "__has_include_next" to point to a second level (user specified) immintrin.h, which then could use ifdefs to only include what's relevant?

A suggestion was made to try and mitigate this by reducing the compile time using modules (only for the x86 intrinsics). This patch aims at adding this option. The new compile flag is just a milestone - if all goes well, we can turn this on by default (Then we won't actually need to use a specific compile flag, and we could always include all the intrinsic h files without their long compile time).

The speedup sounds nice, but it seems awkward IMO to have such specific behavior for x86 intrinsics only.

[rsmith]

I really don't like the command-line interface you're proposing here. It seems like it will be extremely confusing what something like -fmodules -fexclusive-builtin-modules means, for instance (usually, later -f flags override earlier ones, so does this *turn off* modules for everything other than builtin headers?). Instead, we should use a command-line interface that more naturally / obviously composes with other flags.

It seems like the behavior you want here is precisely:

`-fmodules -fno-implicit-module-maps -fmodule-map-file=<resource dir>/include/module.modulemap`

(The -fmodules-validate-system-headers part would only make sense for people using clang directly from their build area; installed / released versions of clang should not need this. Adding it makes your flag compose poorly with other uses of modules.)

I'd be happy with you adding a flag that is equivalent to -fmodule-map-file=<resource dir>/include/module.modulemap.

Also, it seems unlikely to me that we would ever turn this on by default. It will cause havoc for distributed builds, especially ones that run compilation actions in 'clean' environments, as (for instance) it will cause the complete set of intrinsics headers to be compiled into a module on every compile. So if this is your proposed solution for slow compiles using intrinsics headers, you should be aware that this is not a complete solution to that problem.

[eladcohen]

In D25337#571845, @bruno wrote:

The long answer is that there is a history of problems regarding the intrinsic files:
http://lists.llvm.org/pipermail/cfe-dev/2016-May/048837.html
http://lists.llvm.org/pipermail/cfe-dev/2016-September/050943.html
Mainly compatibility issues because MSVC makes all the intrinsics available all the time, while in clang this is not always the case (On Windows the different h files are not-included unless asked for explicitly since AVX512 was added which impacted compile-time).

Thinking a bit more about this: did you ever consider a solution where "immintrin.h" (or any similar other) would use "#include_next" and "__has_include_next" to point to a second level (user specified) immintrin.h, which then could use ifdefs to only include what's relevant?

I don't think we really want the users to have to maintain an updated user specific version of immintrin.h. Moreover, I think that at the end we actually do want clang to always include all the intrinsics same as MSVC.

A suggestion was made to try and mitigate this by reducing the compile time using modules (only for the x86 intrinsics). This patch aims at adding this option. The new compile flag is just a milestone - if all goes well, we can turn this on by default (Then we won't actually need to use a specific compile flag, and we could always include all the intrinsic h files without their long compile time).

The speedup sounds nice, but it seems awkward IMO to have such specific behavior for x86 intrinsics only.

The feature itself is not x86 specific. It can be used for all the clang builtins. As for enabling it by default, I did have only x86 in mind but it can be done for all targets as well. (will probably require checking that all the other intrinsic headers are modular and that the modulemap is up to date).

[eladcohen]

In D25337#571877, @rsmith wrote:

I really don't like the command-line interface you're proposing here. It seems like it will be extremely confusing what something like -fmodules -fexclusive-builtin-modules means, for instance (usually, later -f flags override earlier ones, so does this *turn off* modules for everything other than builtin headers?). Instead, we should use a command-line interface that more naturally / obviously composes with other flags.

It seems like the behavior you want here is precisely:

`-fmodules -fno-implicit-module-maps -fmodule-map-file=<resource dir>/include/module.modulemap`

(The -fmodules-validate-system-headers part would only make sense for people using clang directly from their build area; installed / released versions of clang should not need this. Adding it makes your flag compose poorly with other uses of modules.)

I'd be happy with you adding a flag that is equivalent to -fmodule-map-file=<resource dir>/include/module.modulemap.

You are right, this is the behavior I was aiming at. I just hoped I could get a single flag to achieve it instead of 3, but I agree that it doesn't behave well with the other module flags.
I uploaded the new flag in a separate review: https://reviews.llvm.org/D25767

Also, it seems unlikely to me that we would ever turn this on by default. It will cause havoc for distributed builds, especially ones that run compilation actions in 'clean' environments, as (for instance) it will cause the complete set of intrinsics headers to be compiled into a module on every compile. So if this is your proposed solution for slow compiles using intrinsics headers, you should be aware that this is not a complete solution to that problem.

What do you mean by 'clean' environments? As in no intermediate artifacts (such as the .pcm files) could be cached?

Do you have any thoughts or suggestions on how we can make the solution more complete?

I guess one possibility to handle this matter (IIRC mentioned by Chandler in one of the discussions) is to pre-compile the actual builtins module as part of the build system. But IIUC this is not feasible since there could be a huge matrix of all the different configurations we will have to maintain, right?

docs/Modules.rst

 
 Modules maintain references to each of the headers that were part of the module build. If any of those headers changes, or if any of the modules on which a module depends change, then the module will be (automatically) recompiled. The process should never require any user intervention.
 
 Command-line parameters
 -----------------------
 ``-fmodules``
   Enable the modules feature.
 
+``-fexclusive-builtin-modules``
+  Enable the modules feature exclusively for the Clang builtins.
+
 ``-fimplicit-module-maps``
   Enable implicit search for module map files named ``module.modulemap`` and similar. This option is implied by ``-fmodules``. If this is disabled with ``-fno-implicit-module-maps``, module map files will only be loaded if they are explicitly specified via ``-fmodule-map-file`` or transitively used by another module map file.
 
 ``-fmodules-cache-path=<directory>``
   Specify the path to the modules cache. If not provided, Clang will select a system-appropriate default.
 
 ``-fno-autolink``
   Disable automatic linking against the libraries associated with imported modules.

include/clang/Driver/Options.td

 def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>;
 def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>;
 def finline_functions : Flag<["-"], "finline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline suitable functions">;
 def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline functions wich are (explicitly or implicitly) marked inline">;
 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
+def fexclusive_builtin_modules : Flag <["-"], "fexclusive-builtin-modules">, Group<f_Group>,
+  Flags<[DriverOption]>,
+  HelpText<"Enable the 'modules' language feature exclusively for the builtin header files">;
 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Generate calls to instrument function entry and exit">;
 
 def fxray_instrument : Flag<["-"], "fxray-instrument">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Generate XRay instrumentation sleds on function entry and exit">;
 def fnoxray_instrument : Flag<["-"], "fno-xray-instrument">, Group<f_Group>,

 def fno_declspec : Flag<["-"], "fno-declspec">, Group<f_clang_Group>,
   HelpText<"Disallow __declspec as a keyword">, Flags<[CC1Option]>;
 def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>,
   HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;
 def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
   HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;
 def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
 def fno_exceptions : Flag<["-"], "fno-exceptions">, Group<f_Group>;
+def fno_exclusive_builtin_modules : Flag <["-"], "fno-exclusive-builtin-modules">, Group<f_Group>,
+  Flags<[DriverOption]>;
 def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Use the given vector functions library">;
 def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
   HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>;
 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,

lib/Driver/Tools.cpp

   }
 
   bool HaveAnyModules = HaveClangModules;
   if (Args.hasArg(options::OPT_fmodules_ts)) {
     CmdArgs.push_back("-fmodules-ts");
     HaveAnyModules = true;
   }
 
+  // -fexclusive-builtin-modules enables the use of precompiled modules
+  // exclusively for the Clang builtins (off by default).
+  // This is disabled if the user is using -fmodules or -fmodules-ts
+  bool HaveExclusiveBuiltinModules = false;
+  if (!HaveAnyModules &&
+      Args.hasFlag(options::OPT_fexclusive_builtin_modules,
+                   options::OPT_fno_exclusive_builtin_modules, false)) {
+    HaveExclusiveBuiltinModules = true;
+  }
+
+  if (HaveExclusiveBuiltinModules) {
+    SmallString<128> BuiltinModuleMap(getToolChain().getDriver().ResourceDir);
+    llvm::sys::path::append(BuiltinModuleMap, "include");
+    llvm::sys::path::append(BuiltinModuleMap, "module.modulemap");
+    if (llvm::sys::fs::exists(BuiltinModuleMap)) {
+      HaveAnyModules = HaveClangModules = true;
+      CmdArgs.push_back("-fmodules");
+      CmdArgs.push_back(Args.MakeArgString("-fmodule-map-file=" +
+                                           BuiltinModuleMap));
+      CmdArgs.push_back("-fmodules-validate-system-headers");
+    }
+  } else if (Args.hasFlag(options::OPT_fimplicit_module_maps,
+                   options::OPT_fno_implicit_module_maps, HaveClangModules)) {
   // -fmodule-maps enables implicit reading of module map files. By default,
   // this is enabled if we are using Clang's flavor of precompiled modules.
-  if (Args.hasFlag(options::OPT_fimplicit_module_maps,
-                   options::OPT_fno_implicit_module_maps, HaveClangModules)) {
     CmdArgs.push_back("-fimplicit-module-maps");
   }
 
   // -fmodules-decluse checks that modules used are declared so (off by
   // default).
   if (Args.hasFlag(options::OPT_fmodules_decluse,
                    options::OPT_fno_modules_decluse, false)) {
     CmdArgs.push_back("-fmodules-decluse");

test/CodeGen/3dnow-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-unknown-unknown -target-feature +3dnowa -emit-llvm -o - -Wall -Werror | FileCheck %s -check-prefix=GCC -check-prefix=CHECK
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-scei-ps4 -target-feature +3dnowa -emit-llvm -o - -Wall -Werror | FileCheck %s -check-prefix=PS4 -check-prefix=CHECK
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-unknown-unknown -target-feature +3dnowa -emit-llvm -o - -Wall -Werror | FileCheck %s -check-prefix=GCC -check-prefix=CHECK
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-scei-ps4 -target-feature +3dnowa -emit-llvm -o - -Wall -Werror | FileCheck %s -check-prefix=PS4 -check-prefix=CHECK
 
 #include <x86intrin.h>
 
 __m64 test_m_pavgusb(__m64 m1, __m64 m2) {
   // PS4-LABEL: define i64 @test_m_pavgusb
   // GCC-LABEL: define double @test_m_pavgusb
   // CHECK: @llvm.x86.3dnow.pavgusb
   return _m_pavgusb(m1, m2);

test/CodeGen/adc-builtins.c

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -ffreestanding -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
 
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
 
 #include <x86intrin.h>
 
 unsigned char test_addcarry_u32(unsigned char __cf, unsigned int __x,
                                 unsigned int __y, unsigned int *__p) {
 // CHECK-LABEL: test_addcarry_u32
 // CHECK: call i8 @llvm.x86.addcarry.u32
   return _addcarry_u32(__cf, __x, __y, __p);

test/CodeGen/adx-builtins.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -ffreestanding -target-feature +adx -emit-llvm -o - %s | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -triple x86_64-unknown-unknown -ffreestanding -target-feature +adx -emit-llvm -o - %s | FileCheck %s
+
 #include <x86intrin.h>
 
 unsigned char test_addcarryx_u32(unsigned char __cf, unsigned int __x,
                                  unsigned int __y, unsigned int *__p) {
 // CHECK-LABEL: test_addcarryx_u32
 // CHECK: call i8 @llvm.x86.addcarryx.u32
   return _addcarryx_u32(__cf, __x, __y, __p);
 }
 
 unsigned char test_addcarryx_u64(unsigned char __cf, unsigned long long __x,
                                  unsigned long long __y,
                                  unsigned long long *__p) {
 // CHECK-LABEL: test_addcarryx_u64
 // CHECK: call i8 @llvm.x86.addcarryx.u64
   return _addcarryx_u64(__cf, __x, __y, __p);
 }

test/CodeGen/attr-target-x86-mmx.c

-// RUN: %clang_cc1 -triple i386-linux-gnu -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -ffreestanding -triple i386-linux-gnu -emit-llvm %s -o - | FileCheck %s
 // Picking a cpu that doesn't have mmx or sse by default so we can enable it later.
 
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding -triple i386-linux-gnu -emit-llvm %s -o - | FileCheck %s
 
 #include <x86intrin.h>
 
 // Verify that when we turn on sse that we also turn on mmx.
 void __attribute__((target("sse"))) shift(__m64 a, __m64 b, int c) {
   _mm_slli_pi16(a, c);
   _mm_slli_pi32(a, c);
   _mm_slli_si64(a, c);

test/CodeGen/avx-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll
 
 __m256d test_mm256_add_pd(__m256d A, __m256d B) {
   // CHECK-LABEL: test_mm256_add_pd
   // CHECK: fadd <4 x double>

test/CodeGen/avx-cmp-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -O3 -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - | FileCheck %s
 // FIXME: The shufflevector instructions in test_cmpgt_sd are relying on O3 here.
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -O3 -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - | FileCheck %s
 
 #include <immintrin.h>
 
 //
 // Test LLVM IR codegen of cmpXY instructions
 //
 
 __m128d test_cmp_pd(__m128d a, __m128d b) {

test/CodeGen/avx-shuffle-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -O3 -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - | FileCheck %s
 // FIXME: This is testing optimized generation of shuffle instructions and should be fixed.
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -O3 -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - | FileCheck %s
 
 #include <immintrin.h>
 
 //
 // Test LLVM IR codegen of shuffle instructions
 //
 
 __m256 x(__m256 a, __m256 b) {

test/CodeGen/avx2-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/avx2-intrinsics-fast-isel.ll
 
 __m256i test_mm256_abs_epi8(__m256i a) {
   // CHECK-LABEL: test_mm256_abs_epi8
   // CHECK: call <32 x i8> @llvm.x86.avx2.pabs.b(<32 x i8> %{{.*}})

test/CodeGen/avx512bw-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __mmask64 test_mm512_cmpeq_epi8_mask(__m512i __a, __m512i __b) {
   // CHECK-LABEL: @test_mm512_cmpeq_epi8_mask
   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
   return (__mmask64)_mm512_cmpeq_epi8_mask(__a, __b);
 }

test/CodeGen/avx512cdintrin.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512cd -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512cd -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m512i test_mm512_conflict_epi64(__m512i __A) {
   // CHECK-LABEL: @test_mm512_conflict_epi64
   // CHECK: @llvm.x86.avx512.mask.conflict.q.512
   return _mm512_conflict_epi64(__A); 
 }

test/CodeGen/avx512dq-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512dq -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512dq -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m512i test_mm512_mullo_epi64 (__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mullo_epi64
   // CHECK: mul <8 x i64>
   return (__m512i) ((__v8di) __A * (__v8di) __B);
 }

test/CodeGen/avx512er-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512er -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512er -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m512d test_mm512_rsqrt28_round_pd(__m512d a) {
   // CHECK-LABEL: @test_mm512_rsqrt28_round_pd
   // CHECK: @llvm.x86.avx512.rsqrt28.pd
   return _mm512_rsqrt28_round_pd(a, _MM_FROUND_CUR_DIRECTION);
 }

test/CodeGen/avx512f-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -emit-llvm -o - -Wall -Werror | FileCheck %s
+
 #include <immintrin.h>
 
 __m512d test_mm512_sqrt_pd(__m512d a)
 {
   // CHECK-LABEL: @test_mm512_sqrt_pd
   // CHECK: @llvm.x86.avx512.mask.sqrt.pd.512
   return _mm512_sqrt_pd(a);
 }

test/CodeGen/avx512ifma-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512ifma -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512ifma -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m512i test_mm512_madd52hi_epu64(__m512i __X, __m512i __Y, __m512i __Z) {
   // CHECK-LABEL: @test_mm512_madd52hi_epu64
   // CHECK: @llvm.x86.avx512.mask.vpmadd52h.uq.512
   return _mm512_madd52hi_epu64(__X, __Y, __Z); 
 }

test/CodeGen/avx512ifmavl-builtins.c

-// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx512ifma -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512ifma -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512ifma -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m128i test_mm_madd52hi_epu64(__m128i __X, __m128i __Y, __m128i __Z) {
   // CHECK-LABEL: @test_mm_madd52hi_epu64
   // CHECK: @llvm.x86.avx512.mask.vpmadd52h.uq.128
   return _mm_madd52hi_epu64(__X, __Y, __Z); 
 }

test/CodeGen/avx512pf-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512pf -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512pf -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 void test_mm512_mask_prefetch_i32gather_pd(__m256i index, __mmask8 mask, void const *addr, int hint) {
   // CHECK-LABEL: @test_mm512_mask_prefetch_i32gather_pd
   // CHECK: @llvm.x86.avx512.gatherpf.dpd
   return _mm512_mask_prefetch_i32gather_pd(index, mask, addr, 2, 1); 
 }

test/CodeGen/avx512vbmi-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512vbmi -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512vbmi -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m512i test_mm512_mask2_permutex2var_epi8(__m512i __A, __m512i __I, __mmask64 __U, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask2_permutex2var_epi8
   // CHECK: @llvm.x86.avx512.mask.vpermi2var.qi.512
   return _mm512_mask2_permutex2var_epi8(__A, __I, __U, __B); 
 }

test/CodeGen/avx512vbmivl-builtin.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512vbmi -target-feature +avx512vl -target-feature +avx512bw -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512vbmi -target-feature +avx512vl -target-feature +avx512bw -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m128i test_mm_permutexvar_epi8(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_permutexvar_epi8
   // CHECK: @llvm.x86.avx512.mask.permvar.qi.128
   return _mm_permutexvar_epi8(__A, __B); 
 }

test/CodeGen/avx512vl-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __mmask8 test_mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) {
   // CHECK-LABEL: @test_mm_cmpeq_epu32_mask
   // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: shufflevector <4 x i1> %{{.*}}, <4 x i1> zeroinitializer, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
   return (__mmask8)_mm_cmpeq_epu32_mask(__a, __b);

test/CodeGen/avx512vlbw-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -target-feature +avx512vl -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -target-feature +avx512vl -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __mmask32 test_mm256_cmpeq_epi8_mask(__m256i __a, __m256i __b) {
   // CHECK-LABEL: @test_mm256_cmpeq_epi8_mask
   // CHECK: icmp eq <32 x i8> %{{.*}}, %{{.*}}
   return (__mmask32)_mm256_cmpeq_epi8_mask(__a, __b);
 }

test/CodeGen/avx512vlcd-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512vl -target-feature +avx512cd -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512vl -target-feature +avx512cd -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m128i test_mm_broadcastmb_epi64(__mmask8 __A) {
   // CHECK-LABEL: @test_mm_broadcastmb_epi64
   // CHECK: @llvm.x86.avx512.broadcastmb.128
   return _mm_broadcastmb_epi64(__A); 
 }

test/CodeGen/avx512vldq-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512dq -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512dq -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 __m256i test_mm256_mullo_epi64 (__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mullo_epi64
   // CHECK: mul <4 x i64>
   return _mm256_mullo_epi64(__A, __B);
 }

test/CodeGen/bitscan-builtins.c

 // RUN: %clang_cc1 -ffreestanding -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
 #include <immintrin.h>
 
 int test_bit_scan_forward(int a) {
   return _bit_scan_forward(a);
 // CHECK: @test_bit_scan_forward
 // CHECK: %[[call:.*]] = call i32 @llvm.cttz.i32(
 // CHECK: ret i32 %[[call]]
 }
 
 int test_bit_scan_reverse(int a) {
   return _bit_scan_reverse(a);
 // CHECK:  %[[call:.*]] = call i32 @llvm.ctlz.i32(
 // CHECK:  %[[sub:.*]] = sub nsw i32 31, %[[call]]
 // CHECK: ret i32 %[[sub]]
 }

test/CodeGen/bmi-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +bmi -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +bmi -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/bmi-intrinsics-fast-isel.ll
 
 // The double underscore intrinsics are for compatibility with
 // AMD's BMI interface. The single underscore intrinsics
 // are for compatibility with Intel's BMI interface.

test/CodeGen/bmi2-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +bmi2 -emit-llvm -o - | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=i386-apple-darwin -target-feature +bmi2 -emit-llvm -o - | FileCheck %s --check-prefix=B32
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +bmi2 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=i386-apple-darwin -target-feature +bmi2 -emit-llvm -o - | FileCheck %s --check-prefix=B32
 
 #include <x86intrin.h>
 
 unsigned int test_bzhi_u32(unsigned int __X, unsigned int __Y) {
   // CHECK: @llvm.x86.bmi.bzhi.32
   return _bzhi_u32(__X, __Y);
 }
 

test/CodeGen/builtin-clflushopt.c

-// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +clflushopt  -emit-llvm -o - -Wall -Werror | FileCheck %s
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +clflushopt  -emit-llvm -o - -Wall -Werror | FileCheck %s
+
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +clflushopt  -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 void test_mm_clflushopt(char * __m) {
   //CHECK-LABLE: @test_mm_clflushopt
   //CHECK: @llvm.x86.clflushopt
   _mm_clflushopt(__m);
 }

test/CodeGen/f16c-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +f16c -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +f16c -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 float test_cvtsh_ss(unsigned short a) {
   // CHECK-LABEL: test_cvtsh_ss
   // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
   // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 1
   // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 2

test/CodeGen/fma-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +fma -emit-llvm -o - | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +fma -emit-llvm -o - | FileCheck %s
 
 #include <immintrin.h>
 
 __m128 test_mm_fmadd_ps(__m128 a, __m128 b, __m128 c) {
   // CHECK: @llvm.x86.fma.vfmadd.ps
   return _mm_fmadd_ps(a, b, c);
 }
 

test/CodeGen/fma4-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +fma4 -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +fma4 -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 __m128 test_mm_macc_ps(__m128 a, __m128 b, __m128 c) {
   // CHECK-LABEL: test_mm_macc_ps
   // CHECK: @llvm.x86.fma.vfmadd.ps
   return _mm_macc_ps(a, b, c);
 }

test/CodeGen/fsgsbase-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +fsgsbase -emit-llvm -o - | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +fsgsbase -emit-llvm -o - | FileCheck %s
 
 #include <x86intrin.h>
 
 unsigned int test_readfsbase_u32()
 {
   // CHECK: @llvm.x86.rdfsbase.32
   return _readfsbase_u32();
 }

test/CodeGen/lzcnt-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +lzcnt -emit-llvm -o - | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +lzcnt -emit-llvm -o - | FileCheck %s
 
 #include <x86intrin.h>
 
 unsigned short test__lzcnt16(unsigned short __X)
 {
   // CHECK: @llvm.ctlz.i16
   return __lzcnt16(__X);
 }

test/CodeGen/mmx-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +ssse3 -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +ssse3 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +ssse3 -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +ssse3 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 __m64 test_mm_abs_pi8(__m64 a) {
   // CHECK-LABEL: test_mm_abs_pi8
   // CHECK: call x86_mmx @llvm.x86.ssse3.pabs.b
   return _mm_abs_pi8(a);
 }

test/CodeGen/pku.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +pku -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +pku -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 unsigned int test_rdpkru_u32() {
   // CHECK-LABEL: @test_rdpkru_u32
   // CHECK: @llvm.x86.rdpkru
   return _rdpkru_u32(); 
 }
 void test_wrpkru(unsigned int __A) {
   // CHECK-LABEL: @test_wrpkru
   // CHECK: @llvm.x86.wrpkru
   _wrpkru(__A);
   return ;
 }

test/CodeGen/popcnt-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +popcnt -emit-llvm -o - | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +popcnt -emit-llvm -o - | FileCheck %s
 
 #include <x86intrin.h>
 
 unsigned int test_mm_popcnt_u32(unsigned int __X) {
   //CHECK: call i32 @llvm.ctpop.i32
   return _mm_popcnt_u32(__X);
 }
 

test/CodeGen/prefetchw-builtins.c

 // RUN: %clang_cc1 -ffreestanding -triple x86_64-unknown-unknown -target-feature +prfchw -emit-llvm -o - %s | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding -triple x86_64-unknown-unknown -target-feature +prfchw -emit-llvm -o - %s | FileCheck %s
 
 #include <x86intrin.h>
 
 void test_m_prefetch(void *p) {
   return _m_prefetch(p);
 // CHECK-LABEL: define void @test_m_prefetch
 // CHECK: call void @llvm.prefetch({{.*}}, i32 0, i32 3, i32 1)
 }
 
 void test_m_prefetch_w(void *p) {
   return _m_prefetchw(p);
 // CHECK-LABEL: define void @test_m_prefetch_w
 // CHECK: call void @llvm.prefetch({{.*}}, i32 1, i32 3, i32 1)
 }

test/CodeGen/rd-builtins.c

 // RUN: %clang_cc1 -ffreestanding -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
 
 #include <x86intrin.h>
 
 unsigned long long test_rdpmc(int a) {
   return _rdpmc(a);
 // CHECK: @test_rdpmc
 // CHECK: call i64 @llvm.x86.rdpmc
 }
 
 int test_rdtsc() {
   return _rdtsc();
 // CHECK: @test_rdtsc
 // CHECK: call i64 @llvm.x86.rdtsc
 }

test/CodeGen/rdrand-builtins.c

 // RUN: %clang_cc1 -ffreestanding -triple x86_64-unknown-unknown -target-feature +rdrnd -target-feature +rdseed -emit-llvm -o - %s | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding -triple x86_64-unknown-unknown -target-feature +rdrnd -target-feature +rdseed -emit-llvm -o - %s | FileCheck %s
 
 #include <x86intrin.h>
 
 int rdrand16(unsigned short *p) {
   return _rdrand16_step(p);
 // CHECK: @rdrand16
 // CHECK: call { i16, i32 } @llvm.x86.rdrand.16
 // CHECK: store i16

test/CodeGen/rtm-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +rtm -emit-llvm -o - | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +rtm -emit-llvm -o - | FileCheck %s
 
 #include <immintrin.h>
 
 unsigned int test_xbegin(void) {
   // CHECK: i32 @llvm.x86.xbegin()
   return _xbegin();
 }
 

test/CodeGen/sha-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-unknown-unknown -target-feature +sha -emit-llvm -o - | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-unknown-unknown -target-feature +sha -emit-llvm -o - | FileCheck %s
 
 #include <immintrin.h>
 
 __m128i test_sha1rnds4(__m128i a, __m128i b) {
   // CHECK: call <4 x i32> @llvm.x86.sha1rnds4
   return _mm_sha1rnds4_epu32(a, b, 3);
 }
 __m128i test_sha1nexte(__m128i a, __m128i b) {

test/CodeGen/sse-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll
 
 __m128 test_mm_add_ps(__m128 A, __m128 B) {
   // CHECK-LABEL: test_mm_add_ps
   // CHECK: fadd <4 x float>

test/CodeGen/sse2-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse2-intrinsics-fast-isel.ll
 
 __m128i test_mm_add_epi8(__m128i A, __m128i B) {
   // CHECK-LABEL: test_mm_add_epi8
   // CHECK: add <16 x i8>

test/CodeGen/sse3-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse3 -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse3 -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse3-intrinsics-fast-isel.ll
 
 __m128d test_mm_addsub_pd(__m128d A, __m128d B) {
   // CHECK-LABEL: test_mm_addsub_pd
   // CHECK: call <2 x double> @llvm.x86.sse3.addsub.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})

test/CodeGen/sse41-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse41-intrinsics-fast-isel.ll
 
 __m128i test_mm_blend_epi16(__m128i V1, __m128i V2) {
   // CHECK-LABEL: test_mm_blend_epi16
   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 9, i32 2, i32 11, i32 4, i32 13, i32 6, i32 7>

test/CodeGen/sse42-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse42-intrinsics-fast-isel.ll
 
 int test_mm_cmpestra(__m128i A, int LA, __m128i B, int LB) {
   // CHECK-LABEL: test_mm_cmpestra
   // CHECK: call i32 @llvm.x86.sse42.pcmpestria128(<16 x i8> %{{.*}}, i32 %{{.*}}, <16 x i8> %{{.*}}, i32 %{{.*}}, i8 7)

test/CodeGen/sse4a-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4a -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse4a -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse4a-intrinsics-fast-isel.ll
 
 __m128i test_mm_extracti_si64(__m128i x) {
   // CHECK-LABEL: test_mm_extracti_si64
   // CHECK: call <2 x i64> @llvm.x86.sse4a.extrqi(<2 x i64> %{{[^,]+}}, i8 3, i8 2)

test/CodeGen/ssse3-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +ssse3 -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +ssse3 -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/ssse3-intrinsics-fast-isel.ll
 
 __m128i test_mm_abs_epi8(__m128i a) {
   // CHECK-LABEL: test_mm_abs_epi8
   // CHECK: call <16 x i8> @llvm.x86.ssse3.pabs.b.128(<16 x i8> %{{.*}})

test/CodeGen/target-builtin-error-2.c

-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o -
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o -
+
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o -
 
 #include <x86intrin.h>
 
 // Since we do code generation on a function level this needs to error out since
 // the subtarget feature won't be available.
 __m128 wombat(__m128i a) {
   if (__builtin_cpu_supports("avx"))
     return __builtin_ia32_vpermilvarps((__v4sf) {0.0f, 1.0f, 2.0f, 3.0f}, (__v4si)a); // expected-error {{'__builtin_ia32_vpermilvarps' needs target feature avx}}
   else
     return (__m128){0, 0};
 }

test/CodeGen/target-builtin-error.c

-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o -
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o -
+
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o -
 
 #include <x86intrin.h>
 
 __m128d foo(__m128d a, __m128d b) {
   return __builtin_ia32_addsubps(b, a); // expected-error {{'__builtin_ia32_addsubps' needs target feature sse3}}
 }

test/CodeGen/target-builtin-noerror.c

 // REQUIRES: x86-registered-target
-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -o -
-#define __MM_MALLOC_H
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -o -
+
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -o -
 
 #include <x86intrin.h>
 
 // No warnings.
 extern __m256i a;
 int __attribute__((target("avx"))) bar(__m256i a) {
   return _mm256_extract_epi32(a, 3);
 }

test/CodeGen/target-features-error-2.c

-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_SSE42
-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_1
-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_2
-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_3
-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_4
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_SSE42
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_1
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_2
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_3
+// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_4
+
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_SSE42
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_1
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_2
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_3
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-linux-gnu -S -verify -o - -D NEED_AVX_4
 
-#define __MM_MALLOC_H
 #include <x86intrin.h>
 
 #if NEED_SSE42
 int baz(__m256i a) {
   return _mm256_extract_epi32(a, 3); // expected-error {{always_inline function '_mm256_extract_epi32' requires target feature 'sse4.2', but would be inlined into function 'baz' that is compiled without support for 'sse4.2'}}
 }
 #endif
 

test/CodeGen/tbm-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -O3 -triple=x86_64-unknown-unknown -target-feature +tbm -emit-llvm -o - | FileCheck %s
+
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -O3 -triple=x86_64-unknown-unknown -target-feature +tbm -emit-llvm -o - | FileCheck %s
+
 // FIXME: The code generation checks for add/sub and/or are depending on the optimizer.
 // The REQUIRES keyword will be removed when the FIXME is complete.
 // REQUIRES: x86-registered-target
 
 
+
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/tbm-intrinsics-fast-isel.ll
 
 unsigned int test__bextri_u32(unsigned int a) {
   // CHECK-LABEL: test__bextri_u32
   // CHECK: call i32 @llvm.x86.tbm.bextri.u32(i32 %{{.*}}, i32 1)
   return __bextri_u32(a, 1);

test/CodeGen/xop-builtins.c

 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +xop -emit-llvm -o - -Wall -Werror | FileCheck %s
 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +xop -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +xop -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 %use_builtin_modules -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +xop -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <x86intrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/xop-intrinsics-fast-isel.ll
 
 __m128i test_mm_maccs_epi16(__m128i a, __m128i b, __m128i c) {
   // CHECK-LABEL: test_mm_maccs_epi16
   // CHECK: call <8 x i16> @llvm.x86.xop.vpmacssww(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})

test/CodeGenCXX/mangle-ms-vector-types.cpp

 // RUN: %clang_cc1 -fms-extensions -ffreestanding -target-feature +avx -emit-llvm %s -o - -triple=i686-pc-win32 | FileCheck %s
 
+// RUN: %clang_cc1 %use_builtin_modules -fms-extensions -ffreestanding -target-feature +avx -emit-llvm %s -o - -triple=i686-pc-win32 | FileCheck %s
+
 #include <xmmintrin.h>
 #include <emmintrin.h>
 #include <immintrin.h>
 
 void foo64(__m64) {}
 // CHECK: define void @"\01?foo64@@YAXT__m64@@@Z"
 
 void foo128(__m128) {}

test/Driver/modules.m

 // MODULES_VALIDATE_SYSTEM_HEADERS: -fmodules-validate-system-headers
 
 // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=MODULES_DISABLE_DIAGNOSTIC_VALIDATION_DEFAULT %s
 // MODULES_DISABLE_DIAGNOSTIC_VALIDATION_DEFAULT-NOT: -fmodules-disable-diagnostic-validation
 
 // RUN: %clang -fmodules-disable-diagnostic-validation -### %s 2>&1 | FileCheck -check-prefix=MODULES_DISABLE_DIAGNOSTIC_VALIDATION %s
 // MODULES_DISABLE_DIAGNOSTIC_VALIDATION: -fmodules-disable-diagnostic-validation
 
+// RUN: %clang -fexclusive-builtin-modules -### %s 2>&1 | FileCheck -check-prefix=EXCLUSIVE_BUILTIN_MODULES %s
+// EXCLUSIVE_BUILTIN_MODULES-DAG: -fmodules
+// EXCLUSIVE_BUILTIN_MODULES-DAG: -fmodule-map-file={{.*}}module.modulemap
+// EXCLUSIVE_BUILTIN_MODULES-DAG: -fmodules-cache-path=
+// EXCLUSIVE_BUILTIN_MODULES-DAG: -fmodules-validate-system-headers
+
 // RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=MODULES_PREBUILT_PATH_DEFAULT %s
 // MODULES_PREBUILT_PATH_DEFAULT-NOT: -fprebuilt-module-path
 
 // RUN: %clang -fmodules -fprebuilt-module-path=foo -fprebuilt-module-path=bar -### %s 2>&1 | FileCheck -check-prefix=MODULES_PREBUILT_PATH %s
 // MODULES_PREBUILT_PATH: "-fprebuilt-module-path=foo"
 // MODULES_PREBUILT_PATH: "-fprebuilt-module-path=bar"
 
 // RUN: %clang -fmodules -fmodule-map-file=foo.map -fmodule-map-file=bar.map -### %s 2>&1 | FileCheck -check-prefix=CHECK-MODULE-MAP-FILES %s

test/Driver/modules.mm

 // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
 // RUN: %clang -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
 // RUN: %clang -fmodules -fno-cxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
+// RUN: %clang -fno-exclusive-builtin-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
 // CHECK-NO-MODULES-NOT: -fmodules
 
 // RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s
 // RUN: %clang -fmodules -fno-cxx-modules -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s
+// RUN: %clang -fexclusive-builtin-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s
 // CHECK-HAS-MODULES: -fmodules
 
 // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s
 // RUN: %clang -fimplicit-module-maps -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s
 // RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s
 // RUN: %clang -fmodules -fno-implicit-module-maps -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s
+// RUN: %clang -fexclusive-builtin-modules -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s
+// RUN: %clang -fexclusive-builtin-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s
 // CHECK-HAS-MAPS: -fimplicit-module-maps
 // CHECK-NO-MAPS-NOT: -fimplicit-module-maps

test/Headers/x86-intrinsics-headers.c

 // RUN: %clang_cc1 -fsyntax-only -ffreestanding %s
 // RUN: %clang_cc1 -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s
 // RUN: %clang_cc1 -fsyntax-only -ffreestanding -x c++ %s
 
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding %s
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding -x c++ %s
+
 #if defined(i386) || defined(__x86_64__)
 
 #ifdef __SSE4_2__
 // nmmintrin forwards to smmintrin.
 #include <nmmintrin.h>
 #endif
 
 // immintrin includes all other intel intrinsic headers.
 #include <immintrin.h>
 
 #endif

test/Headers/x86intrin-2.c

 // RUN: %clang_cc1 -fsyntax-only -ffreestanding %s -verify
 // RUN: %clang_cc1 -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s -verify
 // RUN: %clang_cc1 -fsyntax-only -ffreestanding -x c++ %s -verify
+
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding %s -verify
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s -verify
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding -x c++ %s -verify
+
 // expected-no-diagnostics
 
 #if defined(i386) || defined(__x86_64__)
 
 // Include the metaheader that includes all x86 intrinsic headers.
 #include <x86intrin.h>
 
 void __attribute__((__target__("mmx"))) mm_empty_wrap(void) {

test/Headers/x86intrin.c

 // RUN: %clang_cc1 -fsyntax-only -ffreestanding %s -verify
 // RUN: %clang_cc1 -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s -verify
 // RUN: %clang_cc1 -fsyntax-only -ffreestanding -x c++ %s -verify
+
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding %s -verify
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding -fno-lax-vector-conversions %s -verify
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding -x c++ %s -verify
+
 // expected-no-diagnostics
 
 #if defined(i386) || defined(__x86_64__)
 
 // Include the metaheader that includes all x86 intrinsic headers.
 #include <x86intrin.h>
 
 #endif

test/Headers/x86intrin.cpp

 // RUN: %clang_cc1 -fsyntax-only -ffreestanding %s -verify
+
+// RUN: %clang_cc1 %use_builtin_modules -fsyntax-only -ffreestanding %s -verify
+
 // expected-no-diagnostics
 
 #if defined(i386) || defined(__x86_64__)
 
 // Include the metaheader that includes all x86 intrinsic headers.
 extern "C++" {
 #include <x86intrin.h>
 }
 
 #endif

test/lit.cfg

 config.substitutions.append( ('%clang_cl', ' ' + config.clang +
                               ' --driver-mode=cl '))
 config.substitutions.append( ('%clangxx', ' ' + config.clang +
                               ' --driver-mode=g++ '))
 config.substitutions.append( ('%clang', ' ' + config.clang + ' ') )
 config.substitutions.append( ('%test_debuginfo', ' ' + config.llvm_src_root + '/utils/test_debuginfo.pl ') )
 config.substitutions.append( ('%itanium_abi_triple', makeItaniumABITriple(config.target_triple)) )
 config.substitutions.append( ('%ms_abi_triple', makeMSABITriple(config.target_triple)) )
+config.substitutions.append( ('%use_builtin_modules',
+                              ' -fmodules -fmodule-map-file=' + 
+                              getClangBuiltinIncludeDir(config.clang) +
+                              '/module.modulemap '
+                              '-fmodules-cache-path=%t_builtin_modules '
+                              '-fmodules-validate-system-headers ' ))
 
 # The host triple might not be set, at least if we're compiling clang from
 # an already installed llvm.
 if config.host_triple and config.host_triple != '@LLVM_HOST_TRIPLE@':
     config.substitutions.append( ('%target_itanium_abi_host_triple', '--target=%s' % makeItaniumABITriple(config.host_triple)) )
 else:
     config.substitutions.append( ('%target_itanium_abi_host_triple', '') )