[clang] Don't define predefined macros multiple times

[john.brawn]

Summary

Fix several instances of macros being defined multiple times in several targets. Most of these are just simple duplication in a TargetInfo or OSTargetInfo of things already defined in InitializePredefinedMacros or InitializeStandardPredefinedMacros, but there are a few that aren't:

• AArch64 defines a couple of feature macros for armv8.1a that are handled generically by getTargetDefines.
• CSKY needs to take care when CPUName and ArchName are the same.
• Many os/target combinations result in ELF being defined twice. Instead define ELF just once in InitPreprocessor based on the Triple, which already knows what the object format is based on os and target.

These changes shouldn't change the final result of which macros are defined, with the exception of the changes to ELF where if you explicitly specify the object type in the triple then this affects if ELF is defined, e.g. --target=i686-windows-elf results in it being defined where it wasn't before, but this is more accurate as an ELF file is in fact generated.

[barannikov88]

Is it possible/worth to add an assertion to Builder.defineMacro to enforce this one definition rule?

clang/lib/Frontend/InitPreprocessor.cpp

1305

Redundant braces.

[barannikov88]

Q: What is it the -Wsystem-header can warn about? I mean, no system header is included by the test, what can go wrong?

clang/test/Preprocessor/predefined-macros-no-warnings.c

3

[john.brawn]

Remove redundant braces, explain more in test comment.

[john.brawn]

Send test output to /dev/null

[john.brawn]

In D150966#4356403, @barannikov88 wrote:

Is it possible/worth to add an assertion to Builder.defineMacro to enforce this one definition rule?

It just appends a string to a raw_ostream, so it's not possible to check what's previously been written.

In D150966#4356470, @barannikov88 wrote:

Q: What is it the -Wsystem-header can warn about? I mean, no system header is included by the test, what can go wrong?

The <built-in> buffer is treated as a system header. I've expanded on the comment to explain this more.

[barannikov88]

In D150966#4356695, @john.brawn wrote:

Q: What is it the -Wsystem-header can warn about? I mean, no system header is included by the test, what can go wrong?

The <built-in> buffer is treated as a system header. I've expanded on the comment to explain this more.

Thanks, I didn't know that <built-in> is treated as a system header, but I was mostly interested in this part

Check that the predefined macros don't contain anything that causes a warning

What is 'anything', exactly? Does it include duplicate predefined macros, or it tests something else?
Sorry for the silly question.

[john.brawn]

In D150966#4356779, @barannikov88 wrote:

Check that the predefined macros don't contain anything that causes a warning

What is 'anything', exactly? Does it include duplicate predefined macros, or it tests something else?
Sorry for the silly question.

D144654 caused a failure http://45.33.8.238/macm1/60903/step_7.txt that caused it to be reverted. The failure was in tests that use -Wsystem-headers and was because the host that clang was built on (aarch64 macos) had duplicate predefines and those tests don't specify a target and so the default (i.e. host) target is used. This test is mainly so that we have a test that uses -Wsystem-headers that doesn't depend on the host machine so that I know D144654 won't cause further problems when I re-commit it.

[aaron.ballman]

clang/lib/Basic/Targets/AArch64.cpp

241–242

Hmm, is this correct?

__ARM_FEATURE_ATOMICS is defined in one other place, but it's conditionally defined: https://github.com/llvm/llvm-project/blob/11926e6149d2a68ecb0652b248efe6890c163846/clang/lib/Basic/Targets/AArch64.cpp#L475

and __ARM_FEATURE_CRC32 is defined in two places, both conditional: https://github.com/llvm/llvm-project/blob/11926e6149d2a68ecb0652b248efe6890c163846/clang/lib/Basic/Targets/AArch64.cpp#L422 and https://github.com/llvm/llvm-project/blob/11926e6149d2a68ecb0652b248efe6890c163846/clang/lib/Basic/Targets/ARM.cpp#L747

343–347

I think this is correct -- the other definition has a different predicate (https://github.com/llvm/llvm-project/blob/11926e6149d2a68ecb0652b248efe6890c163846/clang/lib/Frontend/InitPreprocessor.cpp#L949) but I think it ends up being define in exactly the same scenarios.

clang/lib/Basic/Targets/VE.cpp

30–32

Shouldn't this be calling DefineStd(Builder, "unix", Opts); like all the others?

35

This is technically a breaking change but I think it's a good breaking change. The VE target seems to imply that there's never a freestanding mode unlike the general utility: https://github.com/llvm/llvm-project/blob/11926e6149d2a68ecb0652b248efe6890c163846/clang/lib/Frontend/InitPreprocessor.cpp#L431

[john.brawn]

clang/lib/Basic/Targets/AArch64.cpp

241–242

AArch64TargetInfo::setArchFeatures sets HasCRC and HasLSE to true for >= 8.1. This does mean that if you do -march=armv8.1-a+nocrc then the current behaviour is that __ARM_FEATURE_CRC32 is defined but the behaviour with this patch is that it's not defined, but the new behaviour is correct as we shouldn't be defining it in that case.

clang/lib/Basic/Targets/VE.cpp

30–32

Only the OS target should be defining OS-related macros, and in AllocateTarget in Targets.cpp VETargetInfo is hardcoded to always use LinuxTargetInfo, which calls DefineStd(Builder, "unix", Opts);.

[aaron.ballman]

clang/lib/Basic/Targets/AArch64.cpp

241–242

Ah, okay! I think it's worth adding a test case for that scenario to show we've made a bugfix here, not just an NFC change.

clang/lib/Basic/Targets/VE.cpp

30–32

Hmmm, we still have calls to this outside of getOSDefines() though?

https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/Targets/ARM.cpp#L1400
https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/Targets/Le64.cpp#L28
https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/Targets/X86.h#L634
https://github.com/llvm/llvm-project/blob/main/clang/lib/Basic/Targets/X86.h#L907

should those also be changing (perhaps in a follow-up)?

35

This might also be worth an explicit test case so it's clear that the behavioral change is intentional.

[john.brawn]

Add VE test.

[john.brawn]

clang/lib/Basic/Targets/AArch64.cpp

241–242

Actually I went and double-checked and I'm wrong, -march=armv8.N+nowhatever doesn't cause __ARM_FEATURE_WHATEVER to be undefined. Which seems wrong, but it's beyond the scope of this patch.

clang/lib/Basic/Targets/VE.cpp

30–32

Most of these are TargetInfos that combine OS plus target, e.g. CygwinARMTargetInfo is both Cygwin OS and ARM Target. The only exception is Le64, and I have no idea if it's correct or not for it to be doing that.

[aaron.ballman]

Basically LG though I had a question about the test case.

clang/lib/Basic/Targets/AArch64.cpp

241–242

Yeah, that does seem wrong. Agreed it's not in scope for this patch, but if you would file an issue in GitHub so we don't lose track of it, that'd be appreciated.

clang/lib/Basic/Targets/VE.cpp

30–32

Ahhh, that's a good point about being combined OS + target. Thanks for pointing that out!

clang/test/Preprocessor/predefined-macros-no-warnings.c

5

So the expectation is that any warnings that are emitted would be upgraded to an error and the test would be flagged as a failure because %clang_cc1 would return nonzero in that case?

(I was thrown for a loop by not using -verify and // expected-no-diagnostics)

Pretty sure -Eonly is equivalent (it runs the preprocessor without emitting output, so no extra overhead from piping to /dev/null).

[john.brawn]

clang/lib/Basic/Targets/AArch64.cpp

241–242

https://github.com/llvm/llvm-project/issues/62919

clang/test/Preprocessor/predefined-macros-no-warnings.c

5

Yes the intent is for the test to fail on any warning. Using -Werror and not -verify means that on failure you get which macro caused the error:

Exit Code: 1

Command Output (stderr):
--
<built-in>:351:9: error: redefining builtin macro [-Werror,-Wbuiltin-macro-redefined]
#define __LITTLE_ENDIAN__ 1
        ^
1 error generated.

--

whereas -verify just outputs

Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected:
  Line 351: redefining builtin macro
1 error generated.

--

Using -Eonly makes sense, I'll do that.

[john.brawn]

Use -Eonly in test.

[aaron.ballman]

LGTM

clang/test/Preprocessor/predefined-macros-no-warnings.c

5

Oh, that's a handy failure mechanism, thank you for pointing that out!

clang/lib/Basic/Targets/AArch64.cpp

 void AArch64TargetInfo::fillValidCPUList(
     SmallVectorImpl<StringRef> &Values) const {
   llvm::AArch64::fillValidCPUArchList(Values);
 }
 
 void AArch64TargetInfo::getTargetDefinesARMV81A(const LangOptions &Opts,
                                                 MacroBuilder &Builder) const {
   Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
-  Builder.defineMacro("__ARM_FEATURE_ATOMICS", "1");
-  Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
 }
 
 void AArch64TargetInfo::getTargetDefinesARMV82A(const LangOptions &Opts,
                                                 MacroBuilder &Builder) const {
   // Also include the ARMv8.1 defines
   getTargetDefinesARMV81A(Opts, Builder);
 }
 

 }
 
 void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                          MacroBuilder &Builder) const {
   // Target identification.
   Builder.defineMacro("__aarch64__");
   // Inline assembly supports AArch64 flag outputs.
   Builder.defineMacro("__GCC_ASM_FLAG_OUTPUTS__");
-  // For bare-metal.
-  if (getTriple().getOS() == llvm::Triple::UnknownOS &&
-      getTriple().isOSBinFormatELF())
-    Builder.defineMacro("__ELF__");
-
-  // Target properties.
-  if (!getTriple().isOSWindows() && getTriple().isArch64Bit()) {
-    Builder.defineMacro("_LP64");
-    Builder.defineMacro("__LP64__");
-  }
 
   std::string CodeModel = getTargetOpts().CodeModel;
   if (CodeModel == "default")
     CodeModel = "small";
   for (char &c : CodeModel)
     c = toupper(c);
   Builder.defineMacro("__AARCH64_CMODEL_" + CodeModel + "__");
 
void DarwinAArch64TargetInfo::getOSDefines(const LangOptions &Opts,
                                            const llvm::Triple &Triple,
                                            MacroBuilder &Builder) const {
   Builder.defineMacro("__AARCH64_SIMD__");
   if (Triple.isArch32Bit())
     Builder.defineMacro("__ARM64_ARCH_8_32__");
   else
     Builder.defineMacro("__ARM64_ARCH_8__");
   Builder.defineMacro("__ARM_NEON__");
-  Builder.defineMacro("__LITTLE_ENDIAN__");
   Builder.defineMacro("__REGISTER_PREFIX__", "");
   Builder.defineMacro("__arm64", "1");
   Builder.defineMacro("__arm64__", "1");
 
   if (Triple.isArm64e())
     Builder.defineMacro("__arm64e__", "1");
 
   getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);

clang/lib/Basic/Targets/ARM.cpp

 void ARMTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
   // Target identification.
   Builder.defineMacro("__arm");
   Builder.defineMacro("__arm__");
   // For bare-metal none-eabi.
   if (getTriple().getOS() == llvm::Triple::UnknownOS &&
       (getTriple().getEnvironment() == llvm::Triple::EABI ||
-       getTriple().getEnvironment() == llvm::Triple::EABIHF)) {
-    Builder.defineMacro("__ELF__");
-    if (Opts.CPlusPlus)
-      Builder.defineMacro("_GNU_SOURCE");
+       getTriple().getEnvironment() == llvm::Triple::EABIHF) &&
+      Opts.CPlusPlus) {
   }
 
   // Target properties.
   Builder.defineMacro("__REGISTER_PREFIX__", "");
 
   // Unfortunately, __ARM_ARCH_7K__ is now more of an ABI descriptor. The CPU
   // happens to be Cortex-A7 though, so it should still get __ARM_ARCH_7A__.
   if (getTriple().isWatchABI())

clang/lib/Basic/Targets/AVR.cpp

AVRTargetInfo::handleAsmEscapedChar(char EscChar) const {
   }
 }
 
 void AVRTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
   Builder.defineMacro("AVR");
   Builder.defineMacro("__AVR");
   Builder.defineMacro("__AVR__");
-  Builder.defineMacro("__ELF__");
 
   if (ABI == "avrtiny")
     Builder.defineMacro("__AVR_TINY__", "1");
 
   if (DefineName.size() != 0)
       Builder.defineMacro(DefineName);
 
   Builder.defineMacro("__AVR_ARCH__", Arch);

clang/lib/Basic/Targets/CSKY.cpp

if (isValid) {
     Arch = archKind;
   }
 
   return isValid;
 }
 
 void CSKYTargetInfo::getTargetDefines(const LangOptions &Opts,
                                       MacroBuilder &Builder) const {
-  Builder.defineMacro("__ELF__");
   Builder.defineMacro("__csky__", "2");
   Builder.defineMacro("__CSKY__", "2");
   Builder.defineMacro("__ckcore__", "2");
   Builder.defineMacro("__CKCORE__", "2");
 
   Builder.defineMacro("__CSKYABI__", ABI == "abiv2" ? "2" : "1");
   Builder.defineMacro("__cskyabi__", ABI == "abiv2" ? "2" : "1");
 
   StringRef ArchName = "ck810";
   StringRef CPUName = "ck810";
 
   if (Arch != llvm::CSKY::ArchKind::INVALID) {
     ArchName = llvm::CSKY::getArchName(Arch);
     CPUName = CPU;
   }
 
   Builder.defineMacro("__" + ArchName.upper() + "__");
   Builder.defineMacro("__" + ArchName.lower() + "__");
+  if (ArchName != CPUName) {
     Builder.defineMacro("__" + CPUName.upper() + "__");
     Builder.defineMacro("__" + CPUName.lower() + "__");
+  }
 
   // TODO: Add support for BE if BE was supported later
   StringRef endian = "__cskyLE__";
 
   Builder.defineMacro(endian);
   Builder.defineMacro(endian.upper());
   Builder.defineMacro(endian.lower());
 

clang/lib/Basic/Targets/Hexagon.cpp

 using namespace clang;
 using namespace clang::targets;
 
 void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
                                          MacroBuilder &Builder) const {
   Builder.defineMacro("__qdsp6__", "1");
   Builder.defineMacro("__hexagon__", "1");
 
-  Builder.defineMacro("__ELF__");
-
   // The macro __HVXDBL__ is deprecated.
   bool DefineHvxDbl = false;
 
   if (CPU == "hexagonv5") {
     Builder.defineMacro("__HEXAGON_V5__");
     Builder.defineMacro("__HEXAGON_ARCH__", "5");
     if (Opts.HexagonQdsp6Compat) {
       Builder.defineMacro("__QDSP6_V5__");

clang/lib/Basic/Targets/Le64.cpp

 ArrayRef<Builtin::Info> Le64TargetInfo::getTargetBuiltins() const {
   return {};
 }
 
 void Le64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                       MacroBuilder &Builder) const {
   DefineStd(Builder, "unix", Opts);
   defineCPUMacros(Builder, "le64", /*Tuning=*/false);
-  Builder.defineMacro("__ELF__");
 }

clang/lib/Basic/Targets/MSP430.cpp

 ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
   return llvm::ArrayRef(GCCRegNames);
 }
 
 void MSP430TargetInfo::getTargetDefines(const LangOptions &Opts,
                                         MacroBuilder &Builder) const {
   Builder.defineMacro("MSP430");
   Builder.defineMacro("__MSP430__");
-  Builder.defineMacro("__ELF__");
   // FIXME: defines for different 'flavours' of MCU
 }

clang/lib/Basic/Targets/OSTargets.h

 
 // CloudABI Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY CloudABITargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     Builder.defineMacro("__CloudABI__");
-    Builder.defineMacro("__ELF__");
 
     // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
     Builder.defineMacro("__STDC_ISO_10646__", "201206L");
-    Builder.defineMacro("__STDC_UTF_16__");
-    Builder.defineMacro("__STDC_UTF_32__");
   }
 
 public:
   using OSTargetInfo<Target>::OSTargetInfo;
 };
 
 // Ananas target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY AnanasTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Ananas defines
     Builder.defineMacro("__Ananas__");
-    Builder.defineMacro("__ELF__");
   }
 
 public:
   using OSTargetInfo<Target>::OSTargetInfo;
 };
 
 void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
                       const llvm::Triple &Triple, StringRef &PlatformName,

 class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo
     : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // DragonFly defines; list based off of gcc output
     Builder.defineMacro("__DragonFly__");
     Builder.defineMacro("__DragonFly_cc_version", "100001");
-    Builder.defineMacro("__ELF__");
     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
     Builder.defineMacro("__tune_i386__");
     DefineStd(Builder, "unix", Opts);
     if (this->HasFloat128)
       Builder.defineMacro("__FLOAT128__");
   }
 
 public:
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     unsigned CCVersion = FREEBSD_CC_VERSION;
     if (CCVersion == 0U)
       CCVersion = Release * 100000U + 1U;
 
     Builder.defineMacro("__FreeBSD__", Twine(Release));
     Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
     DefineStd(Builder, "unix", Opts);
-    Builder.defineMacro("__ELF__");
 
     // On FreeBSD, wchar_t contains the number of the code point as
     // used by the character set of the locale. These character sets are
     // not necessarily a superset of ASCII.
     //
     // FIXME: This is wrong; the macro refers to the numerical values
     // of wchar_t *literals*, which are not locale-dependent. However,
     // FreeBSD systems apparently depend on us getting this wrong, and

 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // GNU/kFreeBSD defines; list based off of gcc output
 
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("__FreeBSD_kernel__");
     Builder.defineMacro("__GLIBC__");
-    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
   }
 
 public:
   using OSTargetInfo<Target>::OSTargetInfo;
 };
 
 // Haiku Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Haiku defines; list based off of gcc output
     Builder.defineMacro("__HAIKU__");
-    Builder.defineMacro("__ELF__");
     DefineStd(Builder, "unix", Opts);
     if (this->HasFloat128)
       Builder.defineMacro("__FLOAT128__");
   }
 
 public:
   HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Hurd defines; list based off of gcc output.
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("__GNU__");
     Builder.defineMacro("__gnu_hurd__");
     Builder.defineMacro("__MACH__");
     Builder.defineMacro("__GLIBC__");
-    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
   }
 public:
   using OSTargetInfo<Target>::OSTargetInfo;
 };
 
 // Minix Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY MinixTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Minix defines
 
     Builder.defineMacro("__minix", "3");
     Builder.defineMacro("_EM_WSIZE", "4");
     Builder.defineMacro("_EM_PSIZE", "4");
     Builder.defineMacro("_EM_SSIZE", "2");
     Builder.defineMacro("_EM_LSIZE", "4");
     Builder.defineMacro("_EM_FSIZE", "4");
     Builder.defineMacro("_EM_DSIZE", "8");
-    Builder.defineMacro("__ELF__");
     DefineStd(Builder, "unix", Opts);
   }
 
 public:
   using OSTargetInfo<Target>::OSTargetInfo;
 };
 
 // Linux target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Linux defines; list based off of gcc output
     DefineStd(Builder, "unix", Opts);
     DefineStd(Builder, "linux", Opts);
-    Builder.defineMacro("__ELF__");
     if (Triple.isAndroid()) {
       Builder.defineMacro("__ANDROID__", "1");
       this->PlatformName = "android";
       this->PlatformMinVersion = Triple.getEnvironmentVersion();
       const unsigned Maj = this->PlatformMinVersion.getMajor();
       if (Maj) {
         Builder.defineMacro("__ANDROID_MIN_SDK_VERSION__", Twine(Maj));
         // This historical but ambiguous name for the minSdkVersion macro. Keep

 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // NetBSD defines; list based off of gcc output
     Builder.defineMacro("__NetBSD__");
     Builder.defineMacro("__unix__");
-    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
   }
 
 public:
   NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     this->MCountName = "__mcount";
   }
 };
 
 // OpenBSD Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // OpenBSD defines; list based off of gcc output
 
     Builder.defineMacro("__OpenBSD__");
     DefineStd(Builder, "unix", Opts);
-    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (this->HasFloat128)
       Builder.defineMacro("__FLOAT128__");
 
     if (Opts.C11)
       Builder.defineMacro("__STDC_NO_THREADS__");
   }

 
 // PS3 PPU Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // PS3 PPU defines.
-    Builder.defineMacro("__PPC__");
     Builder.defineMacro("__PPU__");
     Builder.defineMacro("__CELLOS_LV2__");
-    Builder.defineMacro("__ELF__");
     Builder.defineMacro("__LP32__");
     Builder.defineMacro("_ARCH_PPC64");
     Builder.defineMacro("__powerpc64__");
   }
 
 public:
   PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {

 class LLVM_LIBRARY_VISIBILITY PSOSTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     Builder.defineMacro("__FreeBSD__", "9");
     Builder.defineMacro("__FreeBSD_cc_version", "900001");
     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
     DefineStd(Builder, "unix", Opts);
-    Builder.defineMacro("__ELF__");
     Builder.defineMacro("__SCE__");
     Builder.defineMacro("__STDC_NO_COMPLEX__");
     Builder.defineMacro("__STDC_NO_THREADS__");
   }
 
 public:
   PSOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {

 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // RTEMS defines; list based off of gcc output
 
     Builder.defineMacro("__rtems__");
-    Builder.defineMacro("__ELF__");
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
   }
 
 public:
   RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     switch (Triple.getArch()) {

 // Solaris target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     DefineStd(Builder, "sun", Opts);
     DefineStd(Builder, "unix", Opts);
-    Builder.defineMacro("__ELF__");
     Builder.defineMacro("__svr4__");
     Builder.defineMacro("__SVR4");
     // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
     // newer, but to 500 for everything else.  feature_test.h has a check to
     // ensure that you are not using C99 with an old version of X/Open or C89
     // with a new version.
     if (Opts.C99)
       Builder.defineMacro("_XOPEN_SOURCE", "600");
protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
 
     DefineStd(Builder, "unix", Opts);
-    Builder.defineMacro("__ELF__");
     Builder.defineMacro("__native_client__");
   }
 
 public:
   NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     this->LongAlign = 32;
     this->LongWidth = 32;

 
 // Fuchsia Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     Builder.defineMacro("__Fuchsia__");
-    Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     // Required by the libc++ locale support.
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
     Builder.defineMacro("__Fuchsia_API_level__", Twine(Opts.FuchsiaAPILevel));
     this->PlatformName = "fuchsia";
     this->PlatformMinVersion = VersionTuple(Opts.FuchsiaAPILevel);

 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY OHOSTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Linux defines; list based off of gcc output
     DefineStd(Builder, "unix", Opts);
 
-    Builder.defineMacro("__ELF__");
-
     // Generic OHOS target defines
     if (Triple.isOHOSFamily()) {
       Builder.defineMacro("__OHOS_FAMILY__", "1");
 
       auto Version = Triple.getEnvironmentVersion();
       this->PlatformName = "ohos";
       this->PlatformMinVersion = Version;
       Builder.defineMacro("__OHOS_Major__", Twine(Version.getMajor()));

clang/lib/Basic/Targets/RISCV.cpp

 }
 
 static unsigned getVersionValue(unsigned MajorVersion, unsigned MinorVersion) {
   return MajorVersion * 1000000 + MinorVersion * 1000;
 }
 
 void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts,
                                        MacroBuilder &Builder) const {
-  Builder.defineMacro("__ELF__");
   Builder.defineMacro("__riscv");
   bool Is64Bit = getTriple().getArch() == llvm::Triple::riscv64;
   Builder.defineMacro("__riscv_xlen", Is64Bit ? "64" : "32");
   StringRef CodeModel = getTargetOpts().CodeModel;
   unsigned FLen = ISAInfo->getFLen();
   unsigned MinVLen = ISAInfo->getMinVLen();
   unsigned MaxELen = ISAInfo->getMaxELen();
   unsigned MaxELenFp = ISAInfo->getMaxELenFp();

clang/lib/Basic/Targets/VE.cpp

 static constexpr Builtin::Info BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
   {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
 #include "clang/Basic/BuiltinsVE.def"
 };
 
 void VETargetInfo::getTargetDefines(const LangOptions &Opts,
                                     MacroBuilder &Builder) const {
-  Builder.defineMacro("_LP64", "1");
-  Builder.defineMacro("unix", "1");
-  Builder.defineMacro("__unix__", "1");
-  Builder.defineMacro("__linux__", "1");
   Builder.defineMacro("__ve", "1");
   Builder.defineMacro("__ve__", "1");
-  Builder.defineMacro("__STDC_HOSTED__", "1");
-  Builder.defineMacro("__STDC__", "1");
   Builder.defineMacro("__NEC__", "1");
   // FIXME: define __FAST_MATH__ 1 if -ffast-math is enabled
   // FIXME: define __OPTIMIZE__ n if -On is enabled
   // FIXME: define __VECTOR__ n 1 if automatic vectorization is enabled
 
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 }
 
 ArrayRef<Builtin::Info> VETargetInfo::getTargetBuiltins() const {
   return llvm::ArrayRef(BuiltinInfo,
                         clang::VE::LastTSBuiltin - Builtin::FirstTSBuiltin);
 }

clang/lib/Frontend/InitPreprocessor.cpp

#undef DEFINE_LOCK_FREE_MACRO
   if (TI.hasInt128Type() && LangOpts.CPlusPlus && LangOpts.GNUMode) {
     // For each extended integer type, g++ defines a macro mapping the
     // index of the type (0 in this case) in some list of extended types
     // to the type.
     Builder.defineMacro("__GLIBCXX_TYPE_INT_N_0", "__int128");
     Builder.defineMacro("__GLIBCXX_BITSIZE_INT_N_0", "128");
   }
 
+  // ELF targets define __ELF__
+  if (TI.getTriple().isOSBinFormatELF())
+    Builder.defineMacro("__ELF__");
+
   // Get other target #defines.
   TI.getTargetDefines(LangOpts, Builder);
 }
 
 /// InitializePreprocessor - Initialize the preprocessor getting it and the
 /// environment ready to process a single file.
 void clang::InitializePreprocessor(
     Preprocessor &PP, const PreprocessorOptions &InitOpts,

clang/test/Preprocessor/init-ve.c

 /// Check predefinitions for NEC Aurora VE
 /// REQUIRES: ve-registered-target
 
 // RUN: %clang_cc1 -E -dM -triple=ve < /dev/null | \
-// RUN:     FileCheck -match-full-lines -check-prefix VE %s
+// RUN:     FileCheck -match-full-lines -check-prefixes=VE,VE-HOSTED %s
+// RUN: %clang_cc1 -E -dM -triple=ve -ffreestanding < /dev/null | \
+// RUN:     FileCheck -match-full-lines -check-prefixes=VE,VE-FREESTANDING %s
 // RUN: %clang_cc1 -x c++ -E -dM -triple=ve < /dev/null | \
-// RUN:     FileCheck -match-full-lines -check-prefix VE -check-prefix VE-CXX %s
+// RUN:     FileCheck -match-full-lines -check-prefixes=VE,VE-HOSTED,VE-CXX %s
 //
 // VE:#define _LP64 1
 // VE:#define __BIGGEST_ALIGNMENT__ 8
 // VE:#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // VE:#define __CHAR16_TYPE__ unsigned short
 // VE:#define __CHAR32_TYPE__ unsigned int
 // VE:#define __CHAR_BIT__ 8
 // VE:#define __DBL_DECIMAL_DIG__ 17

 // VE:#define __SIZE_FMTX__ "lX"
 // VE:#define __SIZE_FMTo__ "lo"
 // VE:#define __SIZE_FMTu__ "lu"
 // VE:#define __SIZE_FMTx__ "lx"
 // VE:#define __SIZE_MAX__ 18446744073709551615UL
 // VE:#define __SIZE_TYPE__ long unsigned int
 // VE:#define __SIZE_WIDTH__ 64
 // VE-CXX:#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
-// VE:#define __STDC_HOSTED__ 1
+// VE-HOSTED:#define __STDC_HOSTED__ 1
+// VE-FREESTANDING:#define __STDC_HOSTED__ 0
 // VE:#define __UINT16_C_SUFFIX__
 // VE:#define __UINT16_FMTX__ "hX"
 // VE:#define __UINT16_FMTo__ "ho"
 // VE:#define __UINT16_FMTu__ "hu"
 // VE:#define __UINT16_FMTx__ "hx"
 // VE:#define __UINT16_MAX__ 65535
 // VE:#define __UINT16_TYPE__ unsigned short
 // VE:#define __UINT32_C_SUFFIX__ U

clang/test/Preprocessor/predefined-macros-no-warnings.c

+// Check that the predefined macros don't contain anything that causes a
+// warning, which needs -Wsystem-headers to detect as the predefined macros
+// are in the <built-in> file which is treated as a system header and so has
+// warnings suppressed by default.
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple xcore
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple hexagon
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple hexagon-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple lanai
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64_32-darwin
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-darwin
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-cloudabi
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-fuchsia
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-linux-openhos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-win32-gnu
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64-win32-msvc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64_be
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64_be-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64_be-fuchsia
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64_be-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple aarch64_be-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-darwin
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-cloudabi
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-fuchsia
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-linux-openhos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-liteos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-nacl
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-win32-cygnus
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-win32-gnu
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-win32-itanium
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple arm-win32-msvc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple armeb
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple armeb-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple armeb-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple armeb-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple armeb-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple armeb-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple avr
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple bpfeb
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple bpfel
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple msp430
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel-linux-openhos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mipsel-nacl
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64el
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64el-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64el-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64el-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64el-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple mips64el-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple m68k
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple m68k-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple m68k-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple le32-nacl
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple le64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc-aix
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppcle
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppcle-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppcle-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64-lv2
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64-aix
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64le-
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64le-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64le-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64le-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ppc64le-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple nvptx
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple nvptx64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple amdgcn
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple r600
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv32
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv32-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv32-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv64-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv64-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv64-fuchsia
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv64-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple riscv64-linux-openhos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparc-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparc-solaris
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparc-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparc-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcel
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcel-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcel-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcel-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-solaris
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-systemz
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple sparcv9-zos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple tce
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple tcele
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-darwin
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-ananas
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-cloudabi
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-linux-android
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-dragonfly
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-fuchsia
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-kfreebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-minix
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-solaris
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-win32-cygnus
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-win32-gnu
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-win32-itanium
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-win32-msvc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-haiku
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-rtems
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-nacl
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-elfiamcu
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple i686-hurd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-darwin
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-ananas
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-cloudabi
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-linux-android
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-linux-openhos
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-dragonfly
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-netbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-openbsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-freebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-fuchsia
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-kfreebsd
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-solaris
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-win32cygnus
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-win32gnu
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-win32msvc
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-haiku
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-nacl
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-ps4
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple x86_64-ps5
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple spir
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple spir64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple spirv32
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple spirv64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple wasm32
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple wasm32-wasi
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple wasm32-emscripten
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple wasm64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple wasm64-wasi
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple wasm64-emscripten
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple dxil
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple renderscript32
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple renderscript64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple ve
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple csky
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple csky-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple loongarch32
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple loongarch32-linux
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple loongarch64
+// RUN: %clang_cc1 %s -E -o /dev/null -Wsystem-headers -Werror -triple loongarch64-linux