static void InitializeStandardPredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, MacroBuilder &Builder) { if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP) Builder.defineMacro("__STDC__"); if (LangOpts.Freestanding) Builder.defineMacro("__STDC_HOSTED__", "0"); else Builder.defineMacro("__STDC_HOSTED__"); if (!LangOpts.CPlusPlus) { if (LangOpts.C11) Builder.defineMacro("__STDC_VERSION__", "201112L"); else if (LangOpts.C99) Builder.defineMacro("__STDC_VERSION__", "199901L"); else if (!LangOpts.GNUMode && LangOpts.Digraphs) Builder.defineMacro("__STDC_VERSION__", "199409L"); } else { // FIXME: Use correct value for C++17. if (LangOpts.CPlusPlus1z) Builder.defineMacro("__cplusplus", "201406L"); // C++1y [cpp.predefined]p1: // The name __cplusplus is defined to the value 201402L when compiling a // C++ translation unit. else if (LangOpts.CPlusPlus14) Builder.defineMacro("__cplusplus", "201402L"); // C++11 [cpp.predefined]p1: // The name __cplusplus is defined to the value 201103L when compiling a // C++ translation unit. else if (LangOpts.CPlusPlus11) Builder.defineMacro("__cplusplus", "201103L"); // C++03 [cpp.predefined]p1: // The name __cplusplus is defined to the value 199711L when compiling a // C++ translation unit. else Builder.defineMacro("__cplusplus", "199711L"); // C++1z [cpp.predefined]p1: // An integer literal of type std::size_t whose value is the alignment // guaranteed by a call to operator new(std::size_t) // // We provide this in all language modes, since it seems generally useful. Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__", Twine(TI.getNewAlign() / TI.getCharWidth()) + TI.getTypeConstantSuffix(TI.getSizeType())); } // In C11 these are environment macros. In C++11 they are only defined // as part of <cuchar>. To prevent breakage when mixing C and C++ // code, define these macros unconditionally. We can define them // unconditionally, as Clang always uses UTF-16 and UTF-32 for 16-bit // and 32-bit character literals. Builder.defineMacro("__STDC_UTF_16__", "1"); Builder.defineMacro("__STDC_UTF_32__", "1"); if (LangOpts.ObjC1) Builder.defineMacro("__OBJC__"); // OpenCL v1.0/1.1 s6.9, v1.2/2.0 s6.10: Preprocessor Directives and Macros. if (LangOpts.OpenCL) { // OpenCL v1.0 and v1.1 do not have a predefined macro to indicate the // language standard with which the program is compiled. __OPENCL_VERSION__ // is for the OpenCL version supported by the OpenCL device, which is not // necessarily the language standard with which the program is compiled. // A shared OpenCL header file requires a macro to indicate the language // standard. As a workaround, __OPENCL_C_VERSION__ is defined for // OpenCL v1.0 and v1.1. switch (LangOpts.OpenCLVersion) { case 100: Builder.defineMacro("__OPENCL_C_VERSION__", "100"); break; case 110: Builder.defineMacro("__OPENCL_C_VERSION__", "110"); break; case 120: Builder.defineMacro("__OPENCL_C_VERSION__", "120"); break; case 200: Builder.defineMacro("__OPENCL_C_VERSION__", "200"); break; default: llvm_unreachable("Unsupported OpenCL version"); } Builder.defineMacro("CL_VERSION_1_0", "100"); Builder.defineMacro("CL_VERSION_1_1", "110"); Builder.defineMacro("CL_VERSION_1_2", "120"); Builder.defineMacro("CL_VERSION_2_0", "200"); if (TI.isLittleEndian()) Builder.defineMacro("__ENDIAN_LITTLE__"); if (LangOpts.FastRelaxedMath) Builder.defineMacro("__FAST_RELAXED_MATH__"); } // Not "standard" per se, but available even with the -undef flag. if (LangOpts.AsmPreprocessor) Builder.defineMacro("__ASSEMBLER__"); if (LangOpts.CUDA) Builder.defineMacro("__CUDA__"); }