Index: tools/clang/include/clang/Lex/MacroInfo.h =================================================================== --- tools/clang/include/clang/Lex/MacroInfo.h +++ tools/clang/include/clang/Lex/MacroInfo.h @@ -32,6 +32,12 @@ SourceLocation Location; /// EndLocation - The location of the last token in the macro. SourceLocation EndLocation; + /// \brief The location where the macro was #undef'd, or an invalid location + /// for macros that haven't been undefined. + SourceLocation UndefLocation; + /// \brief Previous definition, the identifier of this macro was defined to, + /// or NULL. + MacroInfo *PreviousDefinition; /// Arguments - The list of arguments for a function-like macro. This can be /// empty, for, e.g. "#define X()". In a C99-style variadic macro, this @@ -128,10 +134,31 @@ /// setDefinitionEndLoc - Set the location of the last token in the macro. /// void setDefinitionEndLoc(SourceLocation EndLoc) { EndLocation = EndLoc; } + /// getDefinitionEndLoc - Return the location of the last token in the macro. /// SourceLocation getDefinitionEndLoc() const { return EndLocation; } - + + /// \brief Set the location where macro was undefined. Can only be set once. + void setUndefLoc(SourceLocation UndefLoc) { + assert(UndefLocation.isInvalid() && "UndefLocation is already set!"); + assert(UndefLoc.isValid() && "Invalid UndefLoc!"); + UndefLocation = UndefLoc; + } + + /// \brief Get the location where macro was undefined. + SourceLocation getUndefLoc() const { return UndefLocation; } + + /// \brief Set previous definition of the macro with the same name. Can only + /// be set once. + void setPreviousDefinition(MacroInfo *PreviousDef) { + assert(!PreviousDefinition && "PreviousDefiniton is already set!"); + PreviousDefinition = PreviousDef; + } + + /// \brief Get previous definition of the macro with the same name. + MacroInfo *getPreviousDefinition() { return PreviousDefinition; } + /// \brief Get length in characters of the macro definition. unsigned getDefinitionLength(SourceManager &SM) const { if (IsDefinitionLengthCached) Index: tools/clang/include/clang/Lex/Preprocessor.h =================================================================== --- tools/clang/include/clang/Lex/Preprocessor.h +++ tools/clang/include/clang/Lex/Preprocessor.h @@ -274,8 +274,9 @@ }; SmallVector DelayedMacroExpandsCallbacks; - /// Macros - For each IdentifierInfo with 'HasMacro' set, we keep a mapping - /// to the actual definition of the macro. + /// Macros - For each IdentifierInfo that was associated with a macro, we + /// keep a mapping to the history of all macro definitions and #undefs in + /// the reverse order (the latest one is in the head of the list). llvm::DenseMap Macros; /// \brief Macros that we want to warn because they are not used at the end @@ -470,8 +471,10 @@ void setMacroInfo(IdentifierInfo *II, MacroInfo *MI, bool LoadedFromAST = false); - /// macro_iterator/macro_begin/macro_end - This allows you to walk the current - /// state of the macro table. This visits every currently-defined macro. + /// macro_iterator/macro_begin/macro_end - This allows you to walk the macro + /// history table. Currently defined macros have + /// IdentifierInfo::hasMacroDefinition() set and an empty + /// MacroInfo::getUndefLoc() at the head of the list. typedef llvm::DenseMap::const_iterator macro_iterator; macro_iterator macro_begin(bool IncludeExternalMacros = true) const; Index: tools/clang/lib/Frontend/PrintPreprocessedOutput.cpp =================================================================== --- tools/clang/lib/Frontend/PrintPreprocessedOutput.cpp +++ tools/clang/lib/Frontend/PrintPreprocessedOutput.cpp @@ -570,8 +570,12 @@ do PP.Lex(Tok); while (Tok.isNot(tok::eof)); - SmallVector - MacrosByID(PP.macro_begin(), PP.macro_end()); + SmallVector MacrosByID; + for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end(); + I != E; ++I) { + if (I->first->hasMacroDefinition()) + MacrosByID.push_back(id_macro_pair(I->first, I->second)); + } llvm::array_pod_sort(MacrosByID.begin(), MacrosByID.end(), MacroIDCompare); for (unsigned i = 0, e = MacrosByID.size(); i != e; ++i) { Index: tools/clang/lib/Lex/MacroInfo.cpp =================================================================== --- tools/clang/lib/Lex/MacroInfo.cpp +++ tools/clang/lib/Lex/MacroInfo.cpp @@ -15,44 +15,46 @@ #include "clang/Lex/Preprocessor.h" using namespace clang; -MacroInfo::MacroInfo(SourceLocation DefLoc) : Location(DefLoc) { - IsFunctionLike = false; - IsC99Varargs = false; - IsGNUVarargs = false; - IsBuiltinMacro = false; - IsFromAST = false; - ChangedAfterLoad = false; - IsDisabled = false; - IsUsed = false; - IsAllowRedefinitionsWithoutWarning = false; - IsWarnIfUnused = false; - IsDefinitionLengthCached = false; - IsPublic = true; - - ArgumentList = 0; - NumArguments = 0; +MacroInfo::MacroInfo(SourceLocation DefLoc) + : Location(DefLoc), + PreviousDefinition(0), + ArgumentList(0), + NumArguments(0), + IsDefinitionLengthCached(false), + IsFunctionLike(false), + IsC99Varargs(false), + IsGNUVarargs(false), + IsBuiltinMacro(false), + IsFromAST(false), + ChangedAfterLoad(false), + IsDisabled(false), + IsUsed(false), + IsAllowRedefinitionsWithoutWarning(false), + IsWarnIfUnused(false), + IsPublic(true) { } -MacroInfo::MacroInfo(const MacroInfo &MI, llvm::BumpPtrAllocator &PPAllocator) { - Location = MI.Location; - EndLocation = MI.EndLocation; - ReplacementTokens = MI.ReplacementTokens; - IsFunctionLike = MI.IsFunctionLike; - IsC99Varargs = MI.IsC99Varargs; - IsGNUVarargs = MI.IsGNUVarargs; - IsBuiltinMacro = MI.IsBuiltinMacro; - IsFromAST = MI.IsFromAST; - ChangedAfterLoad = MI.ChangedAfterLoad; - IsDisabled = MI.IsDisabled; - IsUsed = MI.IsUsed; - IsAllowRedefinitionsWithoutWarning = MI.IsAllowRedefinitionsWithoutWarning; - IsWarnIfUnused = MI.IsWarnIfUnused; - IsDefinitionLengthCached = MI.IsDefinitionLengthCached; - DefinitionLength = MI.DefinitionLength; - IsPublic = MI.IsPublic; - - ArgumentList = 0; - NumArguments = 0; +MacroInfo::MacroInfo(const MacroInfo &MI, llvm::BumpPtrAllocator &PPAllocator) + : Location(MI.Location), + EndLocation(MI.EndLocation), + UndefLocation(MI.UndefLocation), + PreviousDefinition(0), + ArgumentList(0), + NumArguments(0), + ReplacementTokens(MI.ReplacementTokens), + IsDefinitionLengthCached(MI.IsDefinitionLengthCached), + DefinitionLength(MI.DefinitionLength), + IsFunctionLike(MI.IsFunctionLike), + IsC99Varargs(MI.IsC99Varargs), + IsGNUVarargs(MI.IsGNUVarargs), + IsBuiltinMacro(MI.IsBuiltinMacro), + IsFromAST(MI.IsFromAST), + ChangedAfterLoad(MI.ChangedAfterLoad), + IsDisabled(MI.IsDisabled), + IsUsed(MI.IsUsed), + IsAllowRedefinitionsWithoutWarning(MI.IsAllowRedefinitionsWithoutWarning), + IsWarnIfUnused(MI.IsWarnIfUnused), + IsPublic(MI.IsPublic) { setArgumentList(MI.ArgumentList, MI.NumArguments, PPAllocator); } Index: tools/clang/lib/Lex/PPDirectives.cpp =================================================================== --- tools/clang/lib/Lex/PPDirectives.cpp +++ tools/clang/lib/Lex/PPDirectives.cpp @@ -1849,7 +1849,7 @@ MI->setDefinitionEndLoc(LastTok.getLocation()); // Finally, if this identifier already had a macro defined for it, verify that - // the macro bodies are identical and free the old definition. + // the macro bodies are identical, and issue diagnostics if they are not. if (MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo())) { // It is very common for system headers to have tons of macro redefinitions // and for warnings to be disabled in system headers. If this is the case, @@ -1870,7 +1870,6 @@ } if (OtherMI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc()); - ReleaseMacroInfo(OtherMI); } setMacroInfo(MacroNameTok.getIdentifierInfo(), MI); @@ -1921,9 +1920,11 @@ if (MI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); - // Free macro definition. - ReleaseMacroInfo(MI); - setMacroInfo(MacroNameTok.getIdentifierInfo(), 0); + MI->setUndefLoc(MacroNameTok.getLocation()); + IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); + II->setHasMacroDefinition(false); + if (II->isFromAST()) + II->setChangedSinceDeserialization(); } Index: tools/clang/lib/Lex/PPMacroExpansion.cpp =================================================================== --- tools/clang/lib/Lex/PPMacroExpansion.cpp +++ tools/clang/lib/Lex/PPMacroExpansion.cpp @@ -33,15 +33,15 @@ MacroInfo *Preprocessor::getInfoForMacro(IdentifierInfo *II) const { assert(II->hasMacroDefinition() && "Identifier is not a macro!"); - - llvm::DenseMap::const_iterator Pos - = Macros.find(II); + + macro_iterator Pos = Macros.find(II); if (Pos == Macros.end()) { // Load this macro from the external source. getExternalSource()->LoadMacroDefinition(II); Pos = Macros.find(II); } assert(Pos != Macros.end() && "Identifier macro info is missing!"); + assert(Pos->second->getUndefLoc().isInvalid() && "Macro is undefined!"); return Pos->second; } @@ -49,17 +49,12 @@ /// void Preprocessor::setMacroInfo(IdentifierInfo *II, MacroInfo *MI, bool LoadedFromAST) { - if (MI) { - Macros[II] = MI; - II->setHasMacroDefinition(true); - if (II->isFromAST() && !LoadedFromAST) - II->setChangedSinceDeserialization(); - } else if (II->hasMacroDefinition()) { - Macros.erase(II); - II->setHasMacroDefinition(false); - if (II->isFromAST() && !LoadedFromAST) - II->setChangedSinceDeserialization(); - } + assert(MI && "MacroInfo should be non-zero!"); + MI->setPreviousDefinition(Macros[II]); + Macros[II] = MI; + II->setHasMacroDefinition(true); + if (II->isFromAST() && !LoadedFromAST) + II->setChangedSinceDeserialization(); } /// RegisterBuiltinMacro - Register the specified identifier in the identifier Index: tools/clang/lib/Lex/Pragma.cpp =================================================================== --- tools/clang/lib/Lex/Pragma.cpp +++ tools/clang/lib/Lex/Pragma.cpp @@ -733,12 +733,10 @@ llvm::DenseMap >::iterator iter = PragmaPushMacroInfo.find(IdentInfo); if (iter != PragmaPushMacroInfo.end()) { - // Release the MacroInfo currently associated with IdentInfo. - MacroInfo *CurrentMI = getMacroInfo(IdentInfo); - if (CurrentMI) { + // Forget the MacroInfo currently associated with IdentInfo. + if (MacroInfo *CurrentMI = getMacroInfo(IdentInfo)) { if (CurrentMI->isWarnIfUnused()) WarnUnusedMacroLocs.erase(CurrentMI->getDefinitionLoc()); - ReleaseMacroInfo(CurrentMI); } // Get the MacroInfo we want to reinstall. Index: tools/clang/lib/Sema/SemaCodeComplete.cpp =================================================================== --- tools/clang/lib/Sema/SemaCodeComplete.cpp +++ tools/clang/lib/Sema/SemaCodeComplete.cpp @@ -2904,7 +2904,11 @@ for (Preprocessor::macro_iterator M = PP.macro_begin(), MEnd = PP.macro_end(); M != MEnd; ++M) { - Results.AddResult(Result(M->first, + // FIXME: Eventually, we'd want to be able to look back to the macro + // definition that was actually active at the point of code completion (even + // if that macro has since been #undef'd). + if (M->first->hasMacroDefinition()) + Results.AddResult(Result(M->first, getMacroUsagePriority(M->first->getName(), PP.getLangOpts(), TargetTypeIsPointer))); Index: tools/clang/lib/Serialization/ASTWriter.cpp =================================================================== --- tools/clang/lib/Serialization/ASTWriter.cpp +++ tools/clang/lib/Serialization/ASTWriter.cpp @@ -1677,10 +1677,12 @@ for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0), E = PP.macro_end(Chain == 0); I != E; ++I) { - const IdentifierInfo *Name = I->first; - if (!IsModule || I->second->isPublic()) { - MacroDefinitionsSeen.insert(Name); - MacrosToEmit.push_back(std::make_pair(I->first, I->second)); + // FIXME: We'll need to store macro history in PCH. + if (I->first->hasMacroDefinition()) { + if (!IsModule || I->second->isPublic()) { + MacroDefinitionsSeen.insert(I->first); + MacrosToEmit.push_back(std::make_pair(I->first, I->second)); + } } }