diff options
Diffstat (limited to 'lib/Frontend/InitPreprocessor.cpp')
| -rw-r--r-- | lib/Frontend/InitPreprocessor.cpp | 335 |
1 files changed, 200 insertions, 135 deletions
diff --git a/lib/Frontend/InitPreprocessor.cpp b/lib/Frontend/InitPreprocessor.cpp index c7d25509e595..7a9d09a5e7ac 100644 --- a/lib/Frontend/InitPreprocessor.cpp +++ b/lib/Frontend/InitPreprocessor.cpp @@ -86,7 +86,7 @@ static void AddImplicitIncludePTH(MacroBuilder &Builder, Preprocessor &PP, StringRef ImplicitIncludePTH) { PTHManager *P = PP.getPTHManager(); // Null check 'P' in the corner case where it couldn't be created. - const char *OriginalFile = P ? P->getOriginalSourceFile() : 0; + const char *OriginalFile = P ? P->getOriginalSourceFile() : nullptr; if (!OriginalFile) { PP.getDiagnostics().Report(diag::err_fe_pth_file_has_no_source_header) @@ -180,7 +180,7 @@ static void DefineFloatMacros(MacroBuilder &Builder, StringRef Prefix, /// DefineTypeSize - Emit a macro to the predefines buffer that declares a macro /// named MacroName with the max value for a type with width 'TypeWidth' a /// signedness of 'isSigned' and with a value suffix of 'ValSuffix' (e.g. LL). -static void DefineTypeSize(StringRef MacroName, unsigned TypeWidth, +static void DefineTypeSize(const Twine &MacroName, unsigned TypeWidth, StringRef ValSuffix, bool isSigned, MacroBuilder &Builder) { llvm::APInt MaxVal = isSigned ? llvm::APInt::getSignedMaxValue(TypeWidth) @@ -190,12 +190,22 @@ static void DefineTypeSize(StringRef MacroName, unsigned TypeWidth, /// DefineTypeSize - An overloaded helper that uses TargetInfo to determine /// the width, suffix, and signedness of the given type -static void DefineTypeSize(StringRef MacroName, TargetInfo::IntType Ty, +static void DefineTypeSize(const Twine &MacroName, TargetInfo::IntType Ty, const TargetInfo &TI, MacroBuilder &Builder) { DefineTypeSize(MacroName, TI.getTypeWidth(Ty), TI.getTypeConstantSuffix(Ty), TI.isTypeSigned(Ty), Builder); } +static void DefineFmt(const Twine &Prefix, TargetInfo::IntType Ty, + const TargetInfo &TI, MacroBuilder &Builder) { + bool IsSigned = TI.isTypeSigned(Ty); + StringRef FmtModifier = TI.getTypeFormatModifier(Ty); + for (const char *Fmt = IsSigned ? "di" : "ouxX"; *Fmt; ++Fmt) { + Builder.defineMacro(Prefix + "_FMT" + Twine(*Fmt) + "__", + Twine("\"") + FmtModifier + Twine(*Fmt) + "\""); + } +} + static void DefineType(const Twine &MacroName, TargetInfo::IntType Ty, MacroBuilder &Builder) { Builder.defineMacro(MacroName, TargetInfo::getTypeName(Ty)); @@ -212,23 +222,70 @@ static void DefineTypeSizeof(StringRef MacroName, unsigned BitWidth, Twine(BitWidth / TI.getCharWidth())); } -static void DefineExactWidthIntType(TargetInfo::IntType Ty, - const TargetInfo &TI, MacroBuilder &Builder) { +static void DefineExactWidthIntType(TargetInfo::IntType Ty, + const TargetInfo &TI, + MacroBuilder &Builder) { + int TypeWidth = TI.getTypeWidth(Ty); + bool IsSigned = TI.isTypeSigned(Ty); + + // Use the target specified int64 type, when appropriate, so that [u]int64_t + // ends up being defined in terms of the correct type. + if (TypeWidth == 64) + Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type(); + + const char *Prefix = IsSigned ? "__INT" : "__UINT"; + + DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder); + DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder); + + StringRef ConstSuffix(TI.getTypeConstantSuffix(Ty)); + Builder.defineMacro(Prefix + Twine(TypeWidth) + "_C_SUFFIX__", ConstSuffix); +} + +static void DefineExactWidthIntTypeSize(TargetInfo::IntType Ty, + const TargetInfo &TI, + MacroBuilder &Builder) { int TypeWidth = TI.getTypeWidth(Ty); + bool IsSigned = TI.isTypeSigned(Ty); // Use the target specified int64 type, when appropriate, so that [u]int64_t // ends up being defined in terms of the correct type. if (TypeWidth == 64) - Ty = TI.getInt64Type(); + Ty = IsSigned ? TI.getInt64Type() : TI.getUInt64Type(); + + const char *Prefix = IsSigned ? "__INT" : "__UINT"; + DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder); +} + +static void DefineLeastWidthIntType(unsigned TypeWidth, bool IsSigned, + const TargetInfo &TI, + MacroBuilder &Builder) { + TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned); + if (Ty == TargetInfo::NoInt) + return; + + const char *Prefix = IsSigned ? "__INT_LEAST" : "__UINT_LEAST"; + DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder); + DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder); + DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder); +} + +static void DefineFastIntType(unsigned TypeWidth, bool IsSigned, + const TargetInfo &TI, MacroBuilder &Builder) { + // stdint.h currently defines the fast int types as equivalent to the least + // types. + TargetInfo::IntType Ty = TI.getLeastIntTypeByWidth(TypeWidth, IsSigned); + if (Ty == TargetInfo::NoInt) + return; - DefineType("__INT" + Twine(TypeWidth) + "_TYPE__", Ty, Builder); + const char *Prefix = IsSigned ? "__INT_FAST" : "__UINT_FAST"; + DefineType(Prefix + Twine(TypeWidth) + "_TYPE__", Ty, Builder); + DefineTypeSize(Prefix + Twine(TypeWidth) + "_MAX__", Ty, TI, Builder); - StringRef ConstSuffix(TargetInfo::getTypeConstantSuffix(Ty)); - if (!ConstSuffix.empty()) - Builder.defineMacro("__INT" + Twine(TypeWidth) + "_C_SUFFIX__", - ConstSuffix); + DefineFmt(Prefix + Twine(TypeWidth), Ty, TI, Builder); } + /// Get the value the ATOMIC_*_LOCK_FREE macro should have for a type with /// the specified properties. static const char *getLockFreeValue(unsigned TypeWidth, unsigned TypeAlign, @@ -300,7 +357,7 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI, const LangOptions &LangOpts, const FrontendOptions &FEOpts, MacroBuilder &Builder) { - if (!LangOpts.MicrosoftMode && !LangOpts.TraditionalCPP) + if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP) Builder.defineMacro("__STDC__"); if (LangOpts.Freestanding) Builder.defineMacro("__STDC_HOSTED__", "0"); @@ -315,9 +372,14 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI, else if (!LangOpts.GNUMode && LangOpts.Digraphs) Builder.defineMacro("__STDC_VERSION__", "199409L"); } else { - // FIXME: Use the right value for __cplusplus for C++1y once one is chosen. - if (LangOpts.CPlusPlus1y) - Builder.defineMacro("__cplusplus", "201305L"); + // 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.CPlusPlus1y) + Builder.defineMacro("__cplusplus", "201402L"); // C++11 [cpp.predefined]p1: // The name __cplusplus is defined to the value 201103L when compiling a // C++ translation unit. @@ -399,7 +461,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, + getClangFullRepositoryVersion() + "\""); #undef TOSTR #undef TOSTR2 - if (!LangOpts.MicrosoftMode) { + if (!LangOpts.MSVCCompat) { // Currently claim to be compatible with GCC 4.2.1-5621, but only if we're // not compiling for MSVC compatibility Builder.defineMacro("__GNUC_MINOR__", "2"); @@ -428,10 +490,10 @@ static void InitializePredefinedMacros(const TargetInfo &TI, // Initialize language-specific preprocessor defines. // Standard conforming mode? - if (!LangOpts.GNUMode) + if (!LangOpts.GNUMode && !LangOpts.MSVCCompat) Builder.defineMacro("__STRICT_ANSI__"); - if (LangOpts.CPlusPlus11) + if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus11) Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__"); if (LangOpts.ObjC1) { @@ -489,9 +551,9 @@ static void InitializePredefinedMacros(const TargetInfo &TI, Builder.defineMacro("__BLOCKS__"); } - if (LangOpts.CXXExceptions) + if (!LangOpts.MSVCCompat && LangOpts.CXXExceptions) Builder.defineMacro("__EXCEPTIONS"); - if (LangOpts.RTTI) + if (!LangOpts.MSVCCompat && LangOpts.RTTI) Builder.defineMacro("__GXX_RTTI"); if (LangOpts.SjLjExceptions) Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__"); @@ -499,27 +561,18 @@ static void InitializePredefinedMacros(const TargetInfo &TI, if (LangOpts.Deprecated) Builder.defineMacro("__DEPRECATED"); - if (LangOpts.CPlusPlus) { + if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) { Builder.defineMacro("__GNUG__", "4"); Builder.defineMacro("__GXX_WEAK__"); Builder.defineMacro("__private_extern__", "extern"); } if (LangOpts.MicrosoftExt) { - // Both __PRETTY_FUNCTION__ and __FUNCTION__ are GCC extensions, however - // VC++ appears to only like __FUNCTION__. - Builder.defineMacro("__PRETTY_FUNCTION__", "__FUNCTION__"); - // Work around some issues with Visual C++ headers. if (LangOpts.WChar) { // wchar_t supported as a keyword. Builder.defineMacro("_WCHAR_T_DEFINED"); Builder.defineMacro("_NATIVE_WCHAR_T_DEFINED"); } - if (LangOpts.CPlusPlus) { - // FIXME: Support Microsoft's __identifier extension in the lexer. - Builder.append("#define __identifier(x) x"); - Builder.append("class type_info;"); - } } if (LangOpts.Optimize) @@ -540,11 +593,13 @@ static void InitializePredefinedMacros(const TargetInfo &TI, Builder.defineMacro("__ORDER_LITTLE_ENDIAN__", "1234"); Builder.defineMacro("__ORDER_BIG_ENDIAN__", "4321"); Builder.defineMacro("__ORDER_PDP_ENDIAN__", "3412"); - if (TI.isBigEndian()) + if (TI.isBigEndian()) { Builder.defineMacro("__BYTE_ORDER__", "__ORDER_BIG_ENDIAN__"); - else + Builder.defineMacro("__BIG_ENDIAN__"); + } else { Builder.defineMacro("__BYTE_ORDER__", "__ORDER_LITTLE_ENDIAN__"); - + Builder.defineMacro("__LITTLE_ENDIAN__"); + } if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64 && TI.getIntWidth() == 32) { @@ -552,6 +607,12 @@ static void InitializePredefinedMacros(const TargetInfo &TI, Builder.defineMacro("__LP64__"); } + if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32 + && TI.getIntWidth() == 32) { + Builder.defineMacro("_ILP32"); + Builder.defineMacro("__ILP32__"); + } + // Define type sizing macros based on the target properties. assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far"); Builder.defineMacro("__CHAR_BIT__", "8"); @@ -565,6 +626,13 @@ static void InitializePredefinedMacros(const TargetInfo &TI, DefineTypeSize("__INTMAX_MAX__", TI.getIntMaxType(), TI, Builder); DefineTypeSize("__SIZE_MAX__", TI.getSizeType(), TI, Builder); + if (!LangOpts.MSVCCompat) { + DefineTypeSize("__UINTMAX_MAX__", TI.getUIntMaxType(), TI, Builder); + DefineTypeSize("__PTRDIFF_MAX__", TI.getPtrDiffType(0), TI, Builder); + DefineTypeSize("__INTPTR_MAX__", TI.getIntPtrType(), TI, Builder); + DefineTypeSize("__UINTPTR_MAX__", TI.getUIntPtrType(), TI, Builder); + } + DefineTypeSizeof("__SIZEOF_DOUBLE__", TI.getDoubleWidth(), TI, Builder); DefineTypeSizeof("__SIZEOF_FLOAT__", TI.getFloatWidth(), TI, Builder); DefineTypeSizeof("__SIZEOF_INT__", TI.getIntWidth(), TI, Builder); @@ -585,22 +653,39 @@ static void InitializePredefinedMacros(const TargetInfo &TI, DefineTypeSizeof("__SIZEOF_INT128__", 128, TI, Builder); DefineType("__INTMAX_TYPE__", TI.getIntMaxType(), Builder); + DefineFmt("__INTMAX", TI.getIntMaxType(), TI, Builder); + Builder.defineMacro("__INTMAX_C_SUFFIX__", + TI.getTypeConstantSuffix(TI.getIntMaxType())); DefineType("__UINTMAX_TYPE__", TI.getUIntMaxType(), Builder); + DefineFmt("__UINTMAX", TI.getUIntMaxType(), TI, Builder); + Builder.defineMacro("__UINTMAX_C_SUFFIX__", + TI.getTypeConstantSuffix(TI.getUIntMaxType())); DefineTypeWidth("__INTMAX_WIDTH__", TI.getIntMaxType(), TI, Builder); DefineType("__PTRDIFF_TYPE__", TI.getPtrDiffType(0), Builder); + DefineFmt("__PTRDIFF", TI.getPtrDiffType(0), TI, Builder); DefineTypeWidth("__PTRDIFF_WIDTH__", TI.getPtrDiffType(0), TI, Builder); DefineType("__INTPTR_TYPE__", TI.getIntPtrType(), Builder); + DefineFmt("__INTPTR", TI.getIntPtrType(), TI, Builder); DefineTypeWidth("__INTPTR_WIDTH__", TI.getIntPtrType(), TI, Builder); DefineType("__SIZE_TYPE__", TI.getSizeType(), Builder); + DefineFmt("__SIZE", TI.getSizeType(), TI, Builder); DefineTypeWidth("__SIZE_WIDTH__", TI.getSizeType(), TI, Builder); DefineType("__WCHAR_TYPE__", TI.getWCharType(), Builder); DefineTypeWidth("__WCHAR_WIDTH__", TI.getWCharType(), TI, Builder); DefineType("__WINT_TYPE__", TI.getWIntType(), Builder); DefineTypeWidth("__WINT_WIDTH__", TI.getWIntType(), TI, Builder); DefineTypeWidth("__SIG_ATOMIC_WIDTH__", TI.getSigAtomicType(), TI, Builder); + DefineTypeSize("__SIG_ATOMIC_MAX__", TI.getSigAtomicType(), TI, Builder); DefineType("__CHAR16_TYPE__", TI.getChar16Type(), Builder); DefineType("__CHAR32_TYPE__", TI.getChar32Type(), Builder); + if (!LangOpts.MSVCCompat) { + DefineTypeWidth("__UINTMAX_WIDTH__", TI.getUIntMaxType(), TI, Builder); + DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder); + DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder); + DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder); + } + DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F"); DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), ""); DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L"); @@ -619,8 +704,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, Builder.defineMacro("__WINT_UNSIGNED__"); // Define exact-width integer types for stdint.h - Builder.defineMacro("__INT" + Twine(TI.getCharWidth()) + "_TYPE__", - "char"); + DefineExactWidthIntType(TargetInfo::SignedChar, TI, Builder); if (TI.getShortWidth() > TI.getCharWidth()) DefineExactWidthIntType(TargetInfo::SignedShort, TI, Builder); @@ -634,6 +718,54 @@ static void InitializePredefinedMacros(const TargetInfo &TI, if (TI.getLongLongWidth() > TI.getLongWidth()) DefineExactWidthIntType(TargetInfo::SignedLongLong, TI, Builder); + if (!LangOpts.MSVCCompat) { + DefineExactWidthIntType(TargetInfo::UnsignedChar, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::UnsignedChar, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::SignedChar, TI, Builder); + + if (TI.getShortWidth() > TI.getCharWidth()) { + DefineExactWidthIntType(TargetInfo::UnsignedShort, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::UnsignedShort, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::SignedShort, TI, Builder); + } + + if (TI.getIntWidth() > TI.getShortWidth()) { + DefineExactWidthIntType(TargetInfo::UnsignedInt, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::UnsignedInt, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::SignedInt, TI, Builder); + } + + if (TI.getLongWidth() > TI.getIntWidth()) { + DefineExactWidthIntType(TargetInfo::UnsignedLong, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::UnsignedLong, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::SignedLong, TI, Builder); + } + + if (TI.getLongLongWidth() > TI.getLongWidth()) { + DefineExactWidthIntType(TargetInfo::UnsignedLongLong, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::UnsignedLongLong, TI, Builder); + DefineExactWidthIntTypeSize(TargetInfo::SignedLongLong, TI, Builder); + } + + DefineLeastWidthIntType(8, true, TI, Builder); + DefineLeastWidthIntType(8, false, TI, Builder); + DefineLeastWidthIntType(16, true, TI, Builder); + DefineLeastWidthIntType(16, false, TI, Builder); + DefineLeastWidthIntType(32, true, TI, Builder); + DefineLeastWidthIntType(32, false, TI, Builder); + DefineLeastWidthIntType(64, true, TI, Builder); + DefineLeastWidthIntType(64, false, TI, Builder); + + DefineFastIntType(8, true, TI, Builder); + DefineFastIntType(8, false, TI, Builder); + DefineFastIntType(16, true, TI, Builder); + DefineFastIntType(16, false, TI, Builder); + DefineFastIntType(32, true, TI, Builder); + DefineFastIntType(32, false, TI, Builder); + DefineFastIntType(64, true, TI, Builder); + DefineFastIntType(64, false, TI, Builder); + } + if (const char *Prefix = TI.getUserLabelPrefix()) Builder.defineMacro("__USER_LABEL_PREFIX__", Prefix); @@ -642,36 +774,38 @@ static void InitializePredefinedMacros(const TargetInfo &TI, else Builder.defineMacro("__FINITE_MATH_ONLY__", "0"); - if (LangOpts.GNUInline) - Builder.defineMacro("__GNUC_GNU_INLINE__"); - else - Builder.defineMacro("__GNUC_STDC_INLINE__"); + if (!LangOpts.MSVCCompat) { + if (LangOpts.GNUInline) + Builder.defineMacro("__GNUC_GNU_INLINE__"); + else + Builder.defineMacro("__GNUC_STDC_INLINE__"); - // The value written by __atomic_test_and_set. - // FIXME: This is target-dependent. - Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1"); + // The value written by __atomic_test_and_set. + // FIXME: This is target-dependent. + Builder.defineMacro("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", "1"); - // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE. - unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth(); + // Used by libstdc++ to implement ATOMIC_<foo>_LOCK_FREE. + unsigned InlineWidthBits = TI.getMaxAtomicInlineWidth(); #define DEFINE_LOCK_FREE_MACRO(TYPE, Type) \ - Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \ - getLockFreeValue(TI.get##Type##Width(), \ - TI.get##Type##Align(), \ - InlineWidthBits)); - DEFINE_LOCK_FREE_MACRO(BOOL, Bool); - DEFINE_LOCK_FREE_MACRO(CHAR, Char); - DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16); - DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32); - DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar); - DEFINE_LOCK_FREE_MACRO(SHORT, Short); - DEFINE_LOCK_FREE_MACRO(INT, Int); - DEFINE_LOCK_FREE_MACRO(LONG, Long); - DEFINE_LOCK_FREE_MACRO(LLONG, LongLong); - Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE", - getLockFreeValue(TI.getPointerWidth(0), - TI.getPointerAlign(0), - InlineWidthBits)); + Builder.defineMacro("__GCC_ATOMIC_" #TYPE "_LOCK_FREE", \ + getLockFreeValue(TI.get##Type##Width(), \ + TI.get##Type##Align(), \ + InlineWidthBits)); + DEFINE_LOCK_FREE_MACRO(BOOL, Bool); + DEFINE_LOCK_FREE_MACRO(CHAR, Char); + DEFINE_LOCK_FREE_MACRO(CHAR16_T, Char16); + DEFINE_LOCK_FREE_MACRO(CHAR32_T, Char32); + DEFINE_LOCK_FREE_MACRO(WCHAR_T, WChar); + DEFINE_LOCK_FREE_MACRO(SHORT, Short); + DEFINE_LOCK_FREE_MACRO(INT, Int); + DEFINE_LOCK_FREE_MACRO(LONG, Long); + DEFINE_LOCK_FREE_MACRO(LLONG, LongLong); + Builder.defineMacro("__GCC_ATOMIC_POINTER_LOCK_FREE", + getLockFreeValue(TI.getPointerWidth(0), + TI.getPointerAlign(0), + InlineWidthBits)); #undef DEFINE_LOCK_FREE_MACRO + } if (LangOpts.NoInlineDefine) Builder.defineMacro("__NO_INLINE__"); @@ -693,8 +827,10 @@ static void InitializePredefinedMacros(const TargetInfo &TI, if (LangOpts.getStackProtector() == LangOptions::SSPOn) Builder.defineMacro("__SSP__"); + else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) + Builder.defineMacro("__SSP_STRONG__", "2"); else if (LangOpts.getStackProtector() == LangOptions::SSPReq) - Builder.defineMacro("__SSP_ALL__", "2"); + Builder.defineMacro("__SSP_ALL__", "3"); if (FEOpts.ProgramAction == frontend::RewriteObjC) Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))"); @@ -717,86 +853,23 @@ static void InitializePredefinedMacros(const TargetInfo &TI, // OpenMP definition if (LangOpts.OpenMP) { - // OpenMP 2.2: + // OpenMP 2.2: // In implementations that support a preprocessor, the _OPENMP // macro name is defined to have the decimal value yyyymm where // yyyy and mm are the year and the month designations of the // version of the OpenMP API that the implementation support. - Builder.defineMacro("_OPENMP", "201107"); + Builder.defineMacro("_OPENMP", "201307"); } // Get other target #defines. TI.getTargetDefines(LangOpts, Builder); } -// Initialize the remapping of files to alternative contents, e.g., -// those specified through other files. -static void InitializeFileRemapping(DiagnosticsEngine &Diags, - SourceManager &SourceMgr, - FileManager &FileMgr, - const PreprocessorOptions &InitOpts) { - // Remap files in the source manager (with buffers). - for (PreprocessorOptions::const_remapped_file_buffer_iterator - Remap = InitOpts.remapped_file_buffer_begin(), - RemapEnd = InitOpts.remapped_file_buffer_end(); - Remap != RemapEnd; - ++Remap) { - // Create the file entry for the file that we're mapping from. - const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, - Remap->second->getBufferSize(), - 0); - if (!FromFile) { - Diags.Report(diag::err_fe_remap_missing_from_file) - << Remap->first; - if (!InitOpts.RetainRemappedFileBuffers) - delete Remap->second; - continue; - } - - // Override the contents of the "from" file with the contents of - // the "to" file. - SourceMgr.overrideFileContents(FromFile, Remap->second, - InitOpts.RetainRemappedFileBuffers); - } - - // Remap files in the source manager (with other files). - for (PreprocessorOptions::const_remapped_file_iterator - Remap = InitOpts.remapped_file_begin(), - RemapEnd = InitOpts.remapped_file_end(); - Remap != RemapEnd; - ++Remap) { - // Find the file that we're mapping to. - const FileEntry *ToFile = FileMgr.getFile(Remap->second); - if (!ToFile) { - Diags.Report(diag::err_fe_remap_missing_to_file) - << Remap->first << Remap->second; - continue; - } - - // Create the file entry for the file that we're mapping from. - const FileEntry *FromFile = FileMgr.getVirtualFile(Remap->first, - ToFile->getSize(), 0); - if (!FromFile) { - Diags.Report(diag::err_fe_remap_missing_from_file) - << Remap->first; - continue; - } - - // Override the contents of the "from" file with the contents of - // the "to" file. - SourceMgr.overrideFileContents(FromFile, ToFile); - } - - SourceMgr.setOverridenFilesKeepOriginalName( - InitOpts.RemappedFilesKeepOriginalName); -} - /// InitializePreprocessor - Initialize the preprocessor getting it and the /// environment ready to process a single file. This returns true on error. /// void clang::InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &InitOpts, - const HeaderSearchOptions &HSOpts, const FrontendOptions &FEOpts) { const LangOptions &LangOpts = PP.getLangOpts(); std::string PredefineBuffer; @@ -804,9 +877,6 @@ void clang::InitializePreprocessor(Preprocessor &PP, llvm::raw_string_ostream Predefines(PredefineBuffer); MacroBuilder Builder(Predefines); - InitializeFileRemapping(PP.getDiagnostics(), PP.getSourceManager(), - PP.getFileManager(), InitOpts); - // Emit line markers for various builtin sections of the file. We don't do // this in asm preprocessor mode, because "# 4" is not a line marker directive // in this mode. @@ -880,9 +950,4 @@ void clang::InitializePreprocessor(Preprocessor &PP, // Copy PredefinedBuffer into the Preprocessor. PP.setPredefines(Predefines.str()); - - // Initialize the header search object. - ApplyHeaderSearchOptions(PP.getHeaderSearchInfo(), HSOpts, - PP.getLangOpts(), - PP.getTargetInfo().getTriple()); } |