From fd8707029eb0bc5157374ed49f51665bf04859b2 Mon Sep 17 00:00:00 2001 From: Nico Weber Date: Fri, 9 Dec 2016 17:32:52 +0000 Subject: [PATCH] Don't assert when redefining a built-in macro in a PCH, PR29119 PCH files store the macro history for a given macro, and the whole history list for one identifier is given to the Preprocessor at once via Preprocessor::setLoadedMacroDirective(). This contained an assert that no macro history exists yet for that identifier. That's usually true, but it's not true for builtin macros, which are created in Preprocessor() before flags and pchs are processed. Luckily, ASTWriter stops writing macro history lists at builtins (see shouldIgnoreMacro() in ASTWriter.cpp), so the head of the history list was missing for builtin macros. So make the assert weaker, and splice the history list to the existing single define for builtins. https://reviews.llvm.org/D27545 llvm-svn: 289228 --- clang/include/clang/Lex/Preprocessor.h | 3 ++- clang/lib/Lex/PPMacroExpansion.cpp | 29 +++++++++++++++++++++++++--- clang/lib/Serialization/ASTReader.cpp | 2 +- clang/test/PCH/builtin-macro.c | 35 ++++++++++++++++++++++++++++++++++ 4 files changed, 64 insertions(+), 5 deletions(-) create mode 100644 clang/test/PCH/builtin-macro.c diff --git a/clang/include/clang/Lex/Preprocessor.h b/clang/include/clang/Lex/Preprocessor.h index ccef9ee..bb71f49 100644 --- a/clang/include/clang/Lex/Preprocessor.h +++ b/clang/include/clang/Lex/Preprocessor.h @@ -887,7 +887,8 @@ public: return appendDefMacroDirective(II, MI, MI->getDefinitionLoc()); } /// \brief Set a MacroDirective that was loaded from a PCH file. - void setLoadedMacroDirective(IdentifierInfo *II, MacroDirective *MD); + void setLoadedMacroDirective(IdentifierInfo *II, MacroDirective *ED, + MacroDirective *MD); /// \brief Register an exported macro for a module and identifier. ModuleMacro *addModuleMacro(Module *Mod, IdentifierInfo *II, MacroInfo *Macro, diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp index f3a57e3..aebebaa 100644 --- a/clang/lib/Lex/PPMacroExpansion.cpp +++ b/clang/lib/Lex/PPMacroExpansion.cpp @@ -92,12 +92,35 @@ void Preprocessor::appendMacroDirective(IdentifierInfo *II, MacroDirective *MD){ } void Preprocessor::setLoadedMacroDirective(IdentifierInfo *II, + MacroDirective *ED, MacroDirective *MD) { + // Normally, when a macro is defined, it goes through appendMacroDirective() + // above, which chains a macro to previous defines, undefs, etc. + // However, in a pch, the whole macro history up to the end of the pch is + // stored, so ASTReader goes through this function instead. + // However, built-in macros are already registered in the Preprocessor + // ctor, and ASTWriter stops writing the macro chain at built-in macros, + // so in that case the chain from the pch needs to be spliced to the existing + // built-in. + assert(II && MD); MacroState &StoredMD = CurSubmoduleState->Macros[II]; - assert(!StoredMD.getLatest() && - "the macro history was modified before initializing it from a pch"); - StoredMD = MD; + + if (auto *OldMD = StoredMD.getLatest()) { + // shouldIgnoreMacro() in ASTWriter also stops at macros from the + // predefines buffer in module builds. However, in module builds, modules + // are loaded completely before predefines are processed, so StoredMD + // will be nullptr for them when they're loaded. StoredMD should only be + // non-nullptr for builtins read from a pch file. + assert(OldMD->getMacroInfo()->isBuiltinMacro() && + "only built-ins should have an entry here"); + assert(!OldMD->getPrevious() && "builtin should only have a single entry"); + ED->setPrevious(OldMD); + StoredMD.setLatest(MD); + } else { + StoredMD = MD; + } + // Setup the identifier as having associated macro history. II->setHasMacroDefinition(true); if (!MD->isDefined() && LeafModuleMacros.find(II) == LeafModuleMacros.end()) diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 14cc774..2df90da 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -1953,7 +1953,7 @@ void ASTReader::resolvePendingMacro(IdentifierInfo *II, } if (Latest) - PP.setLoadedMacroDirective(II, Latest); + PP.setLoadedMacroDirective(II, Earliest, Latest); } ASTReader::InputFileInfo diff --git a/clang/test/PCH/builtin-macro.c b/clang/test/PCH/builtin-macro.c new file mode 100644 index 0000000..4d01540 --- /dev/null +++ b/clang/test/PCH/builtin-macro.c @@ -0,0 +1,35 @@ +// Test this without pch. +// RUN: %clang_cc1 -D__DATE__= -D__TIMESTAMP__= -include %s -Wno-builtin-macro-redefined -fsyntax-only -verify %s + +// Test with pch. +// RUN: %clang_cc1 -D__DATE__= -D__TIMESTAMP__= -Wno-builtin-macro-redefined -emit-pch -o %t %s +// RUN: %clang_cc1 -D__DATE__= -D__TIMESTAMP__= -Wno-builtin-macro-redefined -include-pch %t -fsyntax-only -verify %s + +#if !defined(HEADER) +#define HEADER + +#define __TIME__ + +#undef __TIMESTAMP__ +#define __TIMESTAMP__ + +// FIXME: undefs don't work well with pchs yet, see PR31311 +// Once that's fixed, add -U__COUNTER__ to all command lines and check that +// an attempt to use __COUNTER__ at the bottom produces an error in both non-pch +// and pch case (works fine in the former case already). +// Same for #undef __FILE__ right here and a use of that at the bottom. +//#undef __FILE__ + +// Also spot-check a predefine +#undef __STDC_HOSTED__ + +#else + +const char s[] = __DATE__ " " __TIME__ " " __TIMESTAMP__; + +// Check that we pick up __DATE__ from the -D flag: +int i = __DATE__ 4; + +const int d = __STDC_HOSTED__; // expected-error{{use of undeclared identifier '__STDC_HOSTED__'}} + +#endif -- 2.7.4