From 8bee90d5f33f49d4ebcb89aac780916fe3bfc65d Mon Sep 17 00:00:00 2001 From: Argyrios Kyrtzidis Date: Fri, 18 Jan 2013 20:59:01 +0000 Subject: [PATCH] [PCH/Modules] Re-apply r172620 and r172629, now with 100% less infinite loops! Makes sure that a deserialized macro is only added to the preprocessor macro definitions only once. Unfortunately I couldn't get a reduced test case. rdar://13016031 llvm-svn: 172843 --- clang/include/clang/Lex/MacroInfo.h | 8 ++++ clang/include/clang/Lex/Preprocessor.h | 3 +- clang/include/clang/Serialization/ASTReader.h | 13 +++---- clang/lib/Lex/PPMacroExpansion.cpp | 14 +++---- clang/lib/Serialization/ASTReader.cpp | 56 ++++++++++++++------------- clang/lib/Serialization/ASTWriter.cpp | 30 ++++++-------- 6 files changed, 62 insertions(+), 62 deletions(-) diff --git a/clang/include/clang/Lex/MacroInfo.h b/clang/include/clang/Lex/MacroInfo.h index aeedd73..c6b44a9 100644 --- a/clang/include/clang/Lex/MacroInfo.h +++ b/clang/include/clang/Lex/MacroInfo.h @@ -169,6 +169,14 @@ public: /// \brief Get previous definition of the macro with the same name. MacroInfo *getPreviousDefinition() { return PreviousDefinition; } + /// \brief Get the first definition in the chain. + MacroInfo *getFirstDefinition() { + MacroInfo *MI = this; + while (MI->PreviousDefinition) + MI = MI->PreviousDefinition; + return MI; + } + /// \brief Find macro definition active in the specified source location. If /// this macro was not defined there, return NULL. const MacroInfo *findDefinitionAtLoc(SourceLocation L, diff --git a/clang/include/clang/Lex/Preprocessor.h b/clang/include/clang/Lex/Preprocessor.h index 24b6a18..faaec35 100644 --- a/clang/include/clang/Lex/Preprocessor.h +++ b/clang/include/clang/Lex/Preprocessor.h @@ -533,8 +533,7 @@ public: /// \brief Specify a macro for this identifier. void setMacroInfo(IdentifierInfo *II, MacroInfo *MI); /// \brief Add a MacroInfo that was loaded from an AST file. - void addLoadedMacroInfo(IdentifierInfo *II, MacroInfo *MI, - MacroInfo *Hint = 0); + void addLoadedMacroInfo(IdentifierInfo *II, MacroInfo *MI); /// \brief Make the given MacroInfo, that was loaded from an AST file and /// previously hidden, visible. void makeLoadedMacroInfoVisible(IdentifierInfo *II, MacroInfo *MI); diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h index 07ccab4..1212887 100644 --- a/clang/include/clang/Serialization/ASTReader.h +++ b/clang/include/clang/Serialization/ASTReader.h @@ -1535,7 +1535,7 @@ public: unsigned LocalID); /// \brief Retrieve the macro with the given ID. - MacroInfo *getMacro(serialization::MacroID ID, MacroInfo *Hint = 0); + MacroInfo *getMacro(serialization::MacroID ID); /// \brief Retrieve the global macro ID corresponding to the given local /// ID within the given module file. @@ -1693,20 +1693,19 @@ public: Expr *ReadSubExpr(); /// \brief Reads the macro record located at the given offset. - void ReadMacroRecord(ModuleFile &F, uint64_t Offset, MacroInfo *Hint = 0); + void ReadMacroRecord(ModuleFile &F, uint64_t Offset); /// \brief Determine the global preprocessed entity ID that corresponds to /// the given local ID within the given module. serialization::PreprocessedEntityID getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const; - /// \brief Note that the identifier has a macro history. + /// \brief Add the macro ID assosiated with \c II for deserialization. /// /// \param II The name of the macro. - /// - /// \param IDs The global macro IDs that are associated with this identifier. - void setIdentifierIsMacro(IdentifierInfo *II, - ArrayRef IDs); + /// \param ID The global macro ID that is associated with this identifier. + void addMacroIDForDeserialization(IdentifierInfo *II, + serialization::MacroID ID); /// \brief Read the set of macros defined by this external macro source. virtual void ReadDefinedMacros(); diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp index 7901705..ba2b8ef 100644 --- a/clang/lib/Lex/PPMacroExpansion.cpp +++ b/clang/lib/Lex/PPMacroExpansion.cpp @@ -55,11 +55,9 @@ void Preprocessor::setMacroInfo(IdentifierInfo *II, MacroInfo *MI) { II->setChangedSinceDeserialization(); } -void Preprocessor::addLoadedMacroInfo(IdentifierInfo *II, MacroInfo *MI, - MacroInfo *Hint) { +void Preprocessor::addLoadedMacroInfo(IdentifierInfo *II, MacroInfo *MI) { assert(MI && "Missing macro?"); assert(MI->isFromAST() && "Macro is not from an AST?"); - assert(!MI->getPreviousDefinition() && "Macro already in chain?"); MacroInfo *&StoredMI = Macros[II]; @@ -79,7 +77,7 @@ void Preprocessor::addLoadedMacroInfo(IdentifierInfo *II, MacroInfo *MI, // Simple case: if this is the first actual definition, just put it at // th beginning. if (!StoredMI->isDefined()) { - MI->setPreviousDefinition(StoredMI); + MI->getFirstDefinition()->setPreviousDefinition(StoredMI); StoredMI = MI; II->setHasMacroDefinition(true); @@ -112,16 +110,14 @@ void Preprocessor::addLoadedMacroInfo(IdentifierInfo *II, MacroInfo *MI, MI->setAmbiguous(true); // Wire this macro information into the chain. - MI->setPreviousDefinition(Prev->getPreviousDefinition()); + MI->getFirstDefinition()->setPreviousDefinition( + Prev->getPreviousDefinition()); Prev->setPreviousDefinition(MI); return; } // The macro is not a definition; put it at the end of the list. - MacroInfo *Prev = Hint? Hint : StoredMI; - while (Prev->getPreviousDefinition()) - Prev = Prev->getPreviousDefinition(); - Prev->setPreviousDefinition(MI); + StoredMI->getFirstDefinition()->setPreviousDefinition(MI); } void Preprocessor::makeLoadedMacroInfoVisible(IdentifierInfo *II, diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 1bafc2a..17669b4 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -525,13 +525,9 @@ IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k, // If this identifier is a macro, deserialize the macro // definition. if (hadMacroDefinition) { - SmallVector MacroIDs; - while (uint32_t LocalID = ReadUnalignedLE32(d)) { - MacroIDs.push_back(Reader.getGlobalMacroID(F, LocalID)); - DataLen -= 4; - } DataLen -= 4; - Reader.setIdentifierIsMacro(II, MacroIDs); + uint32_t LocalID = ReadUnalignedLE32(d); + Reader.addMacroIDForDeserialization(II, Reader.getGlobalMacroID(F,LocalID)); } Reader.SetIdentifierInfo(ID, II); @@ -1061,8 +1057,7 @@ bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, } } -void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset, - MacroInfo *Hint) { +void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) { llvm::BitstreamCursor &Stream = F.MacroCursor; // Keep track of where we are in the stream, then jump back there @@ -1078,19 +1073,18 @@ void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset, // adding tokens. struct AddLoadedMacroInfoRAII { Preprocessor &PP; - MacroInfo *Hint; MacroInfo *MI; IdentifierInfo *II; - AddLoadedMacroInfoRAII(Preprocessor &PP, MacroInfo *Hint) - : PP(PP), Hint(Hint), MI(), II() { } + explicit AddLoadedMacroInfoRAII(Preprocessor &PP) + : PP(PP), MI(), II() { } ~AddLoadedMacroInfoRAII( ) { if (MI) { // Finally, install the macro. - PP.addLoadedMacroInfo(II, MI, Hint); + PP.addLoadedMacroInfo(II, MI); } } - } AddLoadedMacroInfo(PP, Hint); + } AddLoadedMacroInfo(PP); while (true) { unsigned Code = Stream.ReadCode(); @@ -1146,6 +1140,9 @@ void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset, SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex); MacroInfo *MI = PP.AllocateMacroInfo(Loc); MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex)); + bool isHeadMI = Record[NextIndex++]; + MacroInfo *PrevMI = getMacro(getGlobalMacroID(F, Record[NextIndex++])); + MI->setPreviousDefinition(PrevMI); // Record this macro. MacrosLoaded[GlobalID - NUM_PREDEF_MACRO_IDS] = MI; @@ -1230,9 +1227,11 @@ void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset, } MI->setHidden(Hidden); - // Make sure we install the macro once we're done. - AddLoadedMacroInfo.MI = MI; - AddLoadedMacroInfo.II = II; + if (isHeadMI) { + // Make sure we install the macro once we're done. + AddLoadedMacroInfo.MI = MI; + AddLoadedMacroInfo.II = II; + } // Remember that we saw this macro last so that we add the tokens that // form its body to it. @@ -1341,10 +1340,13 @@ HeaderFileInfoTrait::ReadData(const internal_key_type, const unsigned char *d, return HFI; } -void ASTReader::setIdentifierIsMacro(IdentifierInfo *II, ArrayRef IDs){ +void ASTReader::addMacroIDForDeserialization(IdentifierInfo *II, MacroID ID){ II->setHadMacroDefinition(true); assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); - PendingMacroIDs[II].append(IDs.begin(), IDs.end()); + SmallVector &MacroIDs = PendingMacroIDs[II]; + assert(std::find(MacroIDs.begin(), MacroIDs.end(), ID) == MacroIDs.end() && + "Already added the macro ID for deserialization"); + MacroIDs.push_back(ID); } void ASTReader::ReadDefinedMacros() { @@ -6160,7 +6162,7 @@ IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { return LocalID + I->second; } -MacroInfo *ASTReader::getMacro(MacroID ID, MacroInfo *Hint) { +MacroInfo *ASTReader::getMacro(MacroID ID) { if (ID == 0) return 0; @@ -6176,7 +6178,7 @@ MacroInfo *ASTReader::getMacro(MacroID ID, MacroInfo *Hint) { assert(I != GlobalMacroMap.end() && "Corrupted global macro map"); ModuleFile *M = I->second; unsigned Index = ID - M->BaseMacroID; - ReadMacroRecord(*M, M->MacroOffsets[Index], Hint); + ReadMacroRecord(*M, M->MacroOffsets[Index]); } return MacrosLoaded[ID]; @@ -6875,13 +6877,15 @@ void ASTReader::finishPendingActions() { PendingDeclChains.clear(); // Load any pending macro definitions. + // Note that new macros may be added while deserializing a macro. for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) { - // FIXME: std::move here - SmallVector GlobalIDs = PendingMacroIDs.begin()[I].second; - MacroInfo *Hint = 0; - for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; - ++IDIdx) { - Hint = getMacro(GlobalIDs[IDIdx], Hint); + PendingMacroIDsMap::iterator PMIt = PendingMacroIDs.begin() + I; + IdentifierInfo *II = PMIt->first; + SmallVector MacroIDs; + MacroIDs.swap(PMIt->second); + for (SmallVectorImpl::iterator + MIt = MacroIDs.begin(), ME = MacroIDs.end(); MIt != ME; ++MIt) { + getMacro(*MIt); } } PendingMacroIDs.clear(); diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 37577ce..df6d112 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -1798,12 +1798,10 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { // Construct the list of macro definitions that need to be serialized. SmallVector, 2> MacrosToEmit; - llvm::SmallPtrSet MacroDefinitionsSeen; for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0), E = PP.macro_end(Chain == 0); I != E; ++I) { if (!IsModule || I->second->isPublic()) { - MacroDefinitionsSeen.insert(I->first); MacrosToEmit.push_back(std::make_pair(I->first, I->second)); } } @@ -1823,9 +1821,9 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { for (unsigned I = 0, N = MacrosToEmit.size(); I != N; ++I) { const IdentifierInfo *Name = MacrosToEmit[I].first; + MacroInfo *HeadMI = MacrosToEmit[I].second; - for (MacroInfo *MI = MacrosToEmit[I].second; MI; - MI = MI->getPreviousDefinition()) { + for (MacroInfo *MI = HeadMI; MI; MI = MI->getPreviousDefinition()) { MacroID ID = getMacroRef(MI); if (!ID) continue; @@ -1856,6 +1854,13 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc())); AddSourceLocation(MI->getDefinitionLoc(), Record); AddSourceLocation(MI->getDefinitionEndLoc(), Record); + Record.push_back(MI == HeadMI); + MacroInfo *PrevMI = MI->getPreviousDefinition(); + // Serialize only the part of the definition chain that is local. + // The chain will be synthesized across modules by the ASTReader. + if (Chain && PrevMI && PrevMI->isFromAST()) + PrevMI = 0; + addMacroRef(PrevMI, Record); AddSourceLocation(MI->getUndefLoc(), Record); Record.push_back(MI->isUsed()); Record.push_back(MI->isPublic()); @@ -2737,14 +2742,8 @@ public: if (isInterestingIdentifier(II, Macro)) { DataLen += 2; // 2 bytes for builtin ID DataLen += 2; // 2 bytes for flags - if (hadMacroDefinition(II, Macro)) { - for (MacroInfo *M = Macro; M; M = M->getPreviousDefinition()) { - if (Writer.getMacroRef(M) != 0) - DataLen += 4; - } - + if (hadMacroDefinition(II, Macro)) DataLen += 4; - } for (IdentifierResolver::iterator D = IdResolver.begin(II), DEnd = IdResolver.end(); @@ -2789,13 +2788,8 @@ public: clang::io::Emit16(Out, Bits); if (HadMacroDefinition) { - // Write all of the macro IDs associated with this identifier. - for (MacroInfo *M = Macro; M; M = M->getPreviousDefinition()) { - if (MacroID ID = Writer.getMacroRef(M)) - clang::io::Emit32(Out, ID); - } - - clang::io::Emit32(Out, 0); + // Write the macro ID associated with this identifier. + clang::io::Emit32(Out, Writer.getMacroRef(Macro)); } // Emit the declaration IDs in reverse order, because the -- 2.7.4