head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.10 netbsd-11-0-RC3:1.1.1.10 netbsd-11-0-RC2:1.1.1.10 netbsd-11-0-RC1:1.1.1.10 perseant-exfatfs-base-20250801:1.1.1.10 netbsd-11:1.1.1.10.0.10 netbsd-11-base:1.1.1.10 netbsd-10-1-RELEASE:1.1.1.10 perseant-exfatfs-base-20240630:1.1.1.10 perseant-exfatfs:1.1.1.10.0.8 perseant-exfatfs-base:1.1.1.10 netbsd-8-3-RELEASE:1.1.1.7 netbsd-9-4-RELEASE:1.1.1.9 netbsd-10-0-RELEASE:1.1.1.10 netbsd-10-0-RC6:1.1.1.10 netbsd-10-0-RC5:1.1.1.10 netbsd-10-0-RC4:1.1.1.10 netbsd-10-0-RC3:1.1.1.10 netbsd-10-0-RC2:1.1.1.10 netbsd-10-0-RC1:1.1.1.10 netbsd-10:1.1.1.10.0.6 netbsd-10-base:1.1.1.10 netbsd-9-3-RELEASE:1.1.1.9 cjep_sun2x:1.1.1.10.0.4 cjep_sun2x-base:1.1.1.10 cjep_staticlib_x-base1:1.1.1.10 netbsd-9-2-RELEASE:1.1.1.9 cjep_staticlib_x:1.1.1.10.0.2 cjep_staticlib_x-base:1.1.1.10 netbsd-9-1-RELEASE:1.1.1.9 phil-wifi-20200421:1.1.1.10 phil-wifi-20200411:1.1.1.10 phil-wifi-20200406:1.1.1.10 netbsd-8-2-RELEASE:1.1.1.7 netbsd-9-0-RELEASE:1.1.1.9 netbsd-9-0-RC2:1.1.1.9 netbsd-9-0-RC1:1.1.1.9 netbsd-9:1.1.1.9.0.2 netbsd-9-base:1.1.1.9 phil-wifi-20190609:1.1.1.9 netbsd-8-1-RELEASE:1.1.1.7 netbsd-8-1-RC1:1.1.1.7 pgoyette-compat-merge-20190127:1.1.1.8.2.1 pgoyette-compat-20190127:1.1.1.9 pgoyette-compat-20190118:1.1.1.9 pgoyette-compat-1226:1.1.1.9 pgoyette-compat-1126:1.1.1.9 pgoyette-compat-1020:1.1.1.9 pgoyette-compat-0930:1.1.1.9 pgoyette-compat-0906:1.1.1.9 netbsd-7-2-RELEASE:1.1.1.4.2.1 pgoyette-compat-0728:1.1.1.9 clang-337282:1.1.1.9 netbsd-8-0-RELEASE:1.1.1.7 phil-wifi:1.1.1.8.0.4 phil-wifi-base:1.1.1.8 pgoyette-compat-0625:1.1.1.8 netbsd-8-0-RC2:1.1.1.7 pgoyette-compat-0521:1.1.1.8 pgoyette-compat-0502:1.1.1.8 pgoyette-compat-0422:1.1.1.8 netbsd-8-0-RC1:1.1.1.7 pgoyette-compat-0415:1.1.1.8 pgoyette-compat-0407:1.1.1.8 pgoyette-compat-0330:1.1.1.8 pgoyette-compat-0322:1.1.1.8 pgoyette-compat-0315:1.1.1.8 netbsd-7-1-2-RELEASE:1.1.1.4.2.1 pgoyette-compat:1.1.1.8.0.2 pgoyette-compat-base:1.1.1.8 netbsd-7-1-1-RELEASE:1.1.1.4.2.1 clang-319952:1.1.1.8 matt-nb8-mediatek:1.1.1.7.0.10 matt-nb8-mediatek-base:1.1.1.7 clang-309604:1.1.1.8 perseant-stdc-iso10646:1.1.1.7.0.8 perseant-stdc-iso10646-base:1.1.1.7 netbsd-8:1.1.1.7.0.6 netbsd-8-base:1.1.1.7 prg-localcount2-base3:1.1.1.7 prg-localcount2-base2:1.1.1.7 prg-localcount2-base1:1.1.1.7 prg-localcount2:1.1.1.7.0.4 prg-localcount2-base:1.1.1.7 pgoyette-localcount-20170426:1.1.1.7 bouyer-socketcan-base1:1.1.1.7 pgoyette-localcount-20170320:1.1.1.7 netbsd-7-1:1.1.1.4.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.4.2.1 netbsd-7-1-RC2:1.1.1.4.2.1 clang-294123:1.1.1.7 netbsd-7-nhusb-base-20170116:1.1.1.4.2.1 bouyer-socketcan:1.1.1.7.0.2 bouyer-socketcan-base:1.1.1.7 clang-291444:1.1.1.7 pgoyette-localcount-20170107:1.1.1.6 netbsd-7-1-RC1:1.1.1.4.2.1 pgoyette-localcount-20161104:1.1.1.6 netbsd-7-0-2-RELEASE:1.1.1.4.2.1 localcount-20160914:1.1.1.6 netbsd-7-nhusb:1.1.1.4.2.1.0.4 netbsd-7-nhusb-base:1.1.1.4.2.1 clang-280599:1.1.1.6 pgoyette-localcount-20160806:1.1.1.6 pgoyette-localcount-20160726:1.1.1.6 pgoyette-localcount:1.1.1.6.0.2 pgoyette-localcount-base:1.1.1.6 netbsd-7-0-1-RELEASE:1.1.1.4.2.1 clang-261930:1.1.1.6 netbsd-7-0:1.1.1.4.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.4.2.1 netbsd-7-0-RC3:1.1.1.4.2.1 netbsd-7-0-RC2:1.1.1.4.2.1 netbsd-7-0-RC1:1.1.1.4.2.1 clang-237755:1.1.1.5 clang-232565:1.1.1.5 clang-227398:1.1.1.5 tls-maxphys-base:1.1.1.4 tls-maxphys:1.1.1.4.0.4 netbsd-7:1.1.1.4.0.2 netbsd-7-base:1.1.1.4 clang-215315:1.1.1.4 clang-209886:1.1.1.3 yamt-pagecache:1.1.1.2.0.4 yamt-pagecache-base9:1.1.1.2 tls-earlyentropy:1.1.1.2.0.2 tls-earlyentropy-base:1.1.1.3 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.2 riastradh-drm2-base3:1.1.1.2 clang-202566:1.1.1.2 clang-201163:1.1.1.1 clang-199312:1.1.1.1 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.03.04.19.53.34; author joerg; state Exp; branches 1.1.1.2.2.1 1.1.1.2.4.1; next 1.1.1.3; commitid 29z1hJonZISIXprx; 1.1.1.3 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.4; commitid 8q0kdlBlCn09GACx; 1.1.1.4 date 2014.08.10.17.08.26; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid N85tXAN6Ex9VZPLx; 1.1.1.5 date 2015.01.29.19.57.32; author joerg; state Exp; branches; next 1.1.1.6; commitid mlISSizlPKvepX7y; 1.1.1.6 date 2016.02.27.22.11.50; author joerg; state Exp; branches 1.1.1.6.2.1; next 1.1.1.7; commitid tIimz3oDlh1NpBWy; 1.1.1.7 date 2017.01.11.10.35.25; author joerg; state Exp; branches; next 1.1.1.8; commitid CNnUNfII1jgNmxBz; 1.1.1.8 date 2017.08.01.19.35.36; author joerg; state Exp; branches 1.1.1.8.2.1 1.1.1.8.4.1; next 1.1.1.9; commitid pMuDy65V0VicSx1A; 1.1.1.9 date 2018.07.17.18.31.26; author joerg; state Exp; branches; next 1.1.1.10; commitid wDzL46ALjrCZgwKA; 1.1.1.10 date 2019.11.13.22.19.28; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.2.2.1 date 2014.08.10.07.08.10; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.2.4.1 date 2014.03.04.19.53.34; author yamt; state dead; branches; next 1.1.1.2.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.2.4.2 date 2014.05.22.16.18.30; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.4.4.1 date 2014.08.10.17.08.26; author tls; state dead; branches; next 1.1.1.4.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.4.4.2 date 2014.08.19.23.47.31; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.2.1 date 2017.03.20.06.52.41; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.2.1 date 2018.07.28.04.33.23; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.8.4.1 date 2019.06.10.21.45.28; author christos; state Exp; branches; next 1.1.1.8.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.8.4.2 date 2020.04.13.07.46.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- ModuleManager.cpp - Module Manager ---------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the ModuleManager class, which manages a set of loaded // modules for the ASTReader. // //===----------------------------------------------------------------------===// #include "clang/Lex/ModuleMap.h" #include "clang/Serialization/GlobalModuleIndex.h" #include "clang/Serialization/ModuleManager.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/system_error.h" #ifndef NDEBUG #include "llvm/Support/GraphWriter.h" #endif using namespace clang; using namespace serialization; ModuleFile *ModuleManager::lookup(StringRef Name) { const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false, /*cacheFailure=*/false); if (Entry) return lookup(Entry); return 0; } ModuleFile *ModuleManager::lookup(const FileEntry *File) { llvm::DenseMap::iterator Known = Modules.find(File); if (Known == Modules.end()) return 0; return Known->second; } llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false, /*cacheFailure=*/false); return InMemoryBuffers[Entry]; } ModuleManager::AddModuleResult ModuleManager::addModule(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, ModuleFile *ImportedBy, unsigned Generation, off_t ExpectedSize, time_t ExpectedModTime, ModuleFile *&Module, std::string &ErrorStr) { Module = 0; // Look for the file entry. This only fails if the expected size or // modification time differ. const FileEntry *Entry; if (lookupModuleFile(FileName, ExpectedSize, ExpectedModTime, Entry)) { ErrorStr = "module file out of date"; return OutOfDate; } if (!Entry && FileName != "-") { ErrorStr = "module file not found"; return Missing; } // Check whether we already loaded this module, before ModuleFile *&ModuleEntry = Modules[Entry]; bool NewModule = false; if (!ModuleEntry) { // Allocate a new module. ModuleFile *New = new ModuleFile(Type, Generation); New->Index = Chain.size(); New->FileName = FileName.str(); New->File = Entry; New->ImportLoc = ImportLoc; Chain.push_back(New); NewModule = true; ModuleEntry = New; // Load the contents of the module if (llvm::MemoryBuffer *Buffer = lookupBuffer(FileName)) { // The buffer was already provided for us. assert(Buffer && "Passed null buffer"); New->Buffer.reset(Buffer); } else { // Open the AST file. llvm::error_code ec; if (FileName == "-") { ec = llvm::MemoryBuffer::getSTDIN(New->Buffer); if (ec) ErrorStr = ec.message(); } else New->Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrorStr)); if (!New->Buffer) return Missing; } // Initialize the stream New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(), (const unsigned char *)New->Buffer->getBufferEnd()); } if (ImportedBy) { ModuleEntry->ImportedBy.insert(ImportedBy); ImportedBy->Imports.insert(ModuleEntry); } else { if (!ModuleEntry->DirectlyImported) ModuleEntry->ImportLoc = ImportLoc; ModuleEntry->DirectlyImported = true; } Module = ModuleEntry; return NewModule? NewlyLoaded : AlreadyLoaded; } namespace { /// \brief Predicate that checks whether a module file occurs within /// the given set. class IsInModuleFileSet : public std::unary_function { llvm::SmallPtrSet &Removed; public: IsInModuleFileSet(llvm::SmallPtrSet &Removed) : Removed(Removed) { } bool operator()(ModuleFile *MF) const { return Removed.count(MF); } }; } void ModuleManager::removeModules(ModuleIterator first, ModuleIterator last, ModuleMap *modMap) { if (first == last) return; // Collect the set of module file pointers that we'll be removing. llvm::SmallPtrSet victimSet(first, last); // Remove any references to the now-destroyed modules. IsInModuleFileSet checkInSet(victimSet); for (unsigned i = 0, n = Chain.size(); i != n; ++i) { Chain[i]->ImportedBy.remove_if(checkInSet); } // Delete the modules and erase them from the various structures. for (ModuleIterator victim = first; victim != last; ++victim) { Modules.erase((*victim)->File); FileMgr.invalidateCache((*victim)->File); if (modMap) { StringRef ModuleName = llvm::sys::path::stem((*victim)->FileName); if (Module *mod = modMap->findModule(ModuleName)) { mod->setASTFile(0); } } delete *victim; } // Remove the modules from the chain. Chain.erase(first, last); } void ModuleManager::addInMemoryBuffer(StringRef FileName, llvm::MemoryBuffer *Buffer) { const FileEntry *Entry = FileMgr.getVirtualFile(FileName, Buffer->getBufferSize(), 0); InMemoryBuffers[Entry] = Buffer; } ModuleManager::VisitState *ModuleManager::allocateVisitState() { // Fast path: if we have a cached state, use it. if (FirstVisitState) { VisitState *Result = FirstVisitState; FirstVisitState = FirstVisitState->NextState; Result->NextState = 0; return Result; } // Allocate and return a new state. return new VisitState(size()); } void ModuleManager::returnVisitState(VisitState *State) { assert(State->NextState == 0 && "Visited state is in list?"); State->NextState = FirstVisitState; FirstVisitState = State; } void ModuleManager::setGlobalIndex(GlobalModuleIndex *Index) { GlobalIndex = Index; if (!GlobalIndex) { ModulesInCommonWithGlobalIndex.clear(); return; } // Notify the global module index about all of the modules we've already // loaded. for (unsigned I = 0, N = Chain.size(); I != N; ++I) { if (!GlobalIndex->loadedModuleFile(Chain[I])) { ModulesInCommonWithGlobalIndex.push_back(Chain[I]); } } } void ModuleManager::moduleFileAccepted(ModuleFile *MF) { if (!GlobalIndex || GlobalIndex->loadedModuleFile(MF)) return; ModulesInCommonWithGlobalIndex.push_back(MF); } ModuleManager::ModuleManager(FileManager &FileMgr) : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(0) { } ModuleManager::~ModuleManager() { for (unsigned i = 0, e = Chain.size(); i != e; ++i) delete Chain[e - i - 1]; delete FirstVisitState; } void ModuleManager::visit(bool (*Visitor)(ModuleFile &M, void *UserData), void *UserData, llvm::SmallPtrSet *ModuleFilesHit) { // If the visitation order vector is the wrong size, recompute the order. if (VisitOrder.size() != Chain.size()) { unsigned N = size(); VisitOrder.clear(); VisitOrder.reserve(N); // Record the number of incoming edges for each module. When we // encounter a module with no incoming edges, push it into the queue // to seed the queue. SmallVector Queue; Queue.reserve(N); llvm::SmallVector UnusedIncomingEdges; UnusedIncomingEdges.reserve(size()); for (ModuleIterator M = begin(), MEnd = end(); M != MEnd; ++M) { if (unsigned Size = (*M)->ImportedBy.size()) UnusedIncomingEdges.push_back(Size); else { UnusedIncomingEdges.push_back(0); Queue.push_back(*M); } } // Traverse the graph, making sure to visit a module before visiting any // of its dependencies. unsigned QueueStart = 0; while (QueueStart < Queue.size()) { ModuleFile *CurrentModule = Queue[QueueStart++]; VisitOrder.push_back(CurrentModule); // For any module that this module depends on, push it on the // stack (if it hasn't already been marked as visited). for (llvm::SetVector::iterator M = CurrentModule->Imports.begin(), MEnd = CurrentModule->Imports.end(); M != MEnd; ++M) { // Remove our current module as an impediment to visiting the // module we depend on. If we were the last unvisited module // that depends on this particular module, push it into the // queue to be visited. unsigned &NumUnusedEdges = UnusedIncomingEdges[(*M)->Index]; if (NumUnusedEdges && (--NumUnusedEdges == 0)) Queue.push_back(*M); } } assert(VisitOrder.size() == N && "Visitation order is wrong?"); delete FirstVisitState; FirstVisitState = 0; } VisitState *State = allocateVisitState(); unsigned VisitNumber = State->NextVisitNumber++; // If the caller has provided us with a hit-set that came from the global // module index, mark every module file in common with the global module // index that is *not* in that set as 'visited'. if (ModuleFilesHit && !ModulesInCommonWithGlobalIndex.empty()) { for (unsigned I = 0, N = ModulesInCommonWithGlobalIndex.size(); I != N; ++I) { ModuleFile *M = ModulesInCommonWithGlobalIndex[I]; if (!ModuleFilesHit->count(M)) State->VisitNumber[M->Index] = VisitNumber; } } for (unsigned I = 0, N = VisitOrder.size(); I != N; ++I) { ModuleFile *CurrentModule = VisitOrder[I]; // Should we skip this module file? if (State->VisitNumber[CurrentModule->Index] == VisitNumber) continue; // Visit the module. assert(State->VisitNumber[CurrentModule->Index] == VisitNumber - 1); State->VisitNumber[CurrentModule->Index] = VisitNumber; if (!Visitor(*CurrentModule, UserData)) continue; // The visitor has requested that cut off visitation of any // module that the current module depends on. To indicate this // behavior, we mark all of the reachable modules as having been visited. ModuleFile *NextModule = CurrentModule; do { // For any module that this module depends on, push it on the // stack (if it hasn't already been marked as visited). for (llvm::SetVector::iterator M = NextModule->Imports.begin(), MEnd = NextModule->Imports.end(); M != MEnd; ++M) { if (State->VisitNumber[(*M)->Index] != VisitNumber) { State->Stack.push_back(*M); State->VisitNumber[(*M)->Index] = VisitNumber; } } if (State->Stack.empty()) break; // Pop the next module off the stack. NextModule = State->Stack.pop_back_val(); } while (true); } returnVisitState(State); } /// \brief Perform a depth-first visit of the current module. static bool visitDepthFirst(ModuleFile &M, bool (*Visitor)(ModuleFile &M, bool Preorder, void *UserData), void *UserData, SmallVectorImpl &Visited) { // Preorder visitation if (Visitor(M, /*Preorder=*/true, UserData)) return true; // Visit children for (llvm::SetVector::iterator IM = M.Imports.begin(), IMEnd = M.Imports.end(); IM != IMEnd; ++IM) { if (Visited[(*IM)->Index]) continue; Visited[(*IM)->Index] = true; if (visitDepthFirst(**IM, Visitor, UserData, Visited)) return true; } // Postorder visitation return Visitor(M, /*Preorder=*/false, UserData); } void ModuleManager::visitDepthFirst(bool (*Visitor)(ModuleFile &M, bool Preorder, void *UserData), void *UserData) { SmallVector Visited(size(), false); for (unsigned I = 0, N = Chain.size(); I != N; ++I) { if (Visited[Chain[I]->Index]) continue; Visited[Chain[I]->Index] = true; if (::visitDepthFirst(*Chain[I], Visitor, UserData, Visited)) return; } } bool ModuleManager::lookupModuleFile(StringRef FileName, off_t ExpectedSize, time_t ExpectedModTime, const FileEntry *&File) { File = FileMgr.getFile(FileName, /*openFile=*/false, /*cacheFailure=*/false); if (!File && FileName != "-") { return false; } if ((ExpectedSize && ExpectedSize != File->getSize()) || (ExpectedModTime && ExpectedModTime != File->getModificationTime())) { return true; } return false; } #ifndef NDEBUG namespace llvm { template<> struct GraphTraits { typedef ModuleFile NodeType; typedef llvm::SetVector::const_iterator ChildIteratorType; typedef ModuleManager::ModuleConstIterator nodes_iterator; static ChildIteratorType child_begin(NodeType *Node) { return Node->Imports.begin(); } static ChildIteratorType child_end(NodeType *Node) { return Node->Imports.end(); } static nodes_iterator nodes_begin(const ModuleManager &Manager) { return Manager.begin(); } static nodes_iterator nodes_end(const ModuleManager &Manager) { return Manager.end(); } }; template<> struct DOTGraphTraits : public DefaultDOTGraphTraits { explicit DOTGraphTraits(bool IsSimple = false) : DefaultDOTGraphTraits(IsSimple) { } static bool renderGraphFromBottomUp() { return true; } std::string getNodeLabel(ModuleFile *M, const ModuleManager&) { return llvm::sys::path::stem(M->FileName); } }; } void ModuleManager::viewGraph() { llvm::ViewGraph(*this, "Modules"); } #endif @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import Clang 3.5svn r202566. @ text @a88 10 New->InputFilesValidationTimestamp = 0; if (New->Kind == MK_Module) { std::string TimestampFilename = New->getTimestampFilename(); vfs::Status Status; // A cached stat value would be fine as well. if (!FileMgr.getNoncachedStatValue(TimestampFilename, Status)) New->InputFilesValidationTimestamp = Status.getLastModificationTime().toEpochTime(); } @ 1.1.1.2.2.1 log @Rebase. @ text @a13 1 #include "clang/Lex/HeaderSearch.h" d35 1 a35 1 return nullptr; d42 1 a42 1 return nullptr; d60 1 a60 1 Module = nullptr; d137 16 a157 5 // The first file entry is about to be rebuilt (or there was an error), so // there should be no references to it. Remove it from the cache to close it, // as Windows doesn't seem to allow renaming over an open file. FileMgr.invalidateCache((*first)->File); d162 1 d164 1 a164 3 Chain[i]->ImportedBy.remove_if([&](ModuleFile *MF) { return victimSet.count(MF); }); d171 1 d173 1 a173 1 StringRef ModuleName = (*victim)->ModuleName; d175 1 a175 1 mod->setASTFile(nullptr); d198 1 a198 1 Result->NextState = nullptr; d207 1 a207 1 assert(State->NextState == nullptr && "Visited state is in list?"); d236 1 a236 1 : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(nullptr) {} d296 1 a296 1 FirstVisitState = nullptr; d398 1 a398 3 // Open the file immediately to ensure there is no race between stat'ing and // opening the file. File = FileMgr.getFile(FileName, /*openFile=*/true, /*cacheFailure=*/false); d405 1 a405 3 (ExpectedModTime && ExpectedModTime != File->getModificationTime())) // Do not destroy File, as it may be referenced. If we need to rebuild it, // it will be destroyed by removeModules. d407 1 d447 1 a447 1 return M->ModuleName; @ 1.1.1.3 log @Import Clang 3.5svn r209886. @ text @a13 1 #include "clang/Lex/HeaderSearch.h" d35 1 a35 1 return nullptr; d42 1 a42 1 return nullptr; d60 1 a60 1 Module = nullptr; d137 16 a157 5 // The first file entry is about to be rebuilt (or there was an error), so // there should be no references to it. Remove it from the cache to close it, // as Windows doesn't seem to allow renaming over an open file. FileMgr.invalidateCache((*first)->File); d162 1 d164 1 a164 3 Chain[i]->ImportedBy.remove_if([&](ModuleFile *MF) { return victimSet.count(MF); }); d171 1 d173 1 a173 1 StringRef ModuleName = (*victim)->ModuleName; d175 1 a175 1 mod->setASTFile(nullptr); d198 1 a198 1 Result->NextState = nullptr; d207 1 a207 1 assert(State->NextState == nullptr && "Visited state is in list?"); d236 1 a236 1 : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(nullptr) {} d296 1 a296 1 FirstVisitState = nullptr; d398 1 a398 3 // Open the file immediately to ensure there is no race between stat'ing and // opening the file. File = FileMgr.getFile(FileName, /*openFile=*/true, /*cacheFailure=*/false); d405 1 a405 3 (ExpectedModTime && ExpectedModTime != File->getModificationTime())) // Do not destroy File, as it may be referenced. If we need to rebuild it, // it will be destroyed by removeModules. d407 1 d447 1 a447 1 return M->ModuleName; @ 1.1.1.4 log @Import clang 3.6svn r215315. @ text @d21 1 a21 1 #include d107 1 a107 1 std::error_code ec; d109 1 a109 3 llvm::ErrorOr> Buf = llvm::MemoryBuffer::getSTDIN(); ec = Buf.getError(); d112 2 a113 11 else New->Buffer = std::move(Buf.get()); } else { // Leave the FileEntry open so if it gets read again by another // ModuleManager it must be the same underlying file. // FIXME: Because FileManager::getFile() doesn't guarantee that it will // give us an open file, this may not be 100% reliable. New->Buffer.reset(FileMgr.getBufferForFile(New->File, &ErrorStr, /*IsVolatile*/false, /*ShouldClose*/false)); } d138 2 a139 4 void ModuleManager::removeModules( ModuleIterator first, ModuleIterator last, llvm::SmallPtrSetImpl &LoadedSuccessfully, ModuleMap *modMap) { d143 5 a167 7 // Files that didn't make it through ReadASTCore successfully will be // rebuilt (or there was an error). Invalidate them so that we can load the // new files that will be renamed over the old ones. if (LoadedSuccessfully.count(*victim) == 0) FileMgr.invalidateCache((*victim)->File); @ 1.1.1.4.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d48 1 a48 2 std::unique_ptr ModuleManager::lookupBuffer(StringRef Name) { d51 1 a51 1 return std::move(InMemoryBuffers[Entry]); a58 3 ASTFileSignature ExpectedSignature, std::function ReadSignature, a65 7 if (Type == MK_ExplicitModule) { // If we're not expecting to pull this file out of the module cache, it // might have a different mtime due to being moved across filesystems in // a distributed build. The size must still match, though. (As must the // contents, but we can't check that.) ExpectedModTime = 0; } d91 1 a91 1 if (New->Kind == MK_ImplicitModule) { d101 1 a101 1 if (std::unique_ptr Buffer = lookupBuffer(FileName)) { d103 2 a104 1 New->Buffer = std::move(Buffer); d107 1 a107 2 llvm::ErrorOr> Buf( (std::error_code())); d109 7 a115 1 Buf = llvm::MemoryBuffer::getSTDIN(); d121 3 a123 3 Buf = FileMgr.getBufferForFile(New->File, /*IsVolatile=*/false, /*ShouldClose=*/false); d125 2 a126 3 if (!Buf) { ErrorStr = Buf.getError().message(); a127 3 } New->Buffer = std::move(*Buf); a133 22 if (ExpectedSignature) { if (NewModule) ModuleEntry->Signature = ReadSignature(ModuleEntry->StreamFile); else assert(ModuleEntry->Signature == ReadSignature(ModuleEntry->StreamFile)); if (ModuleEntry->Signature != ExpectedSignature) { ErrorStr = ModuleEntry->Signature ? "signature mismatch" : "could not read module signature"; if (NewModule) { // Remove the module file immediately, since removeModules might try to // invalidate the file cache for Entry, and that is not safe if this // module is *itself* up to date, but has an out-of-date importer. Modules.erase(Entry); Chain.pop_back(); delete ModuleEntry; } return OutOfDate; } } d190 6 a195 7 void ModuleManager::addInMemoryBuffer(StringRef FileName, std::unique_ptr Buffer) { const FileEntry *Entry = FileMgr.getVirtualFile(FileName, Buffer->getBufferSize(), 0); InMemoryBuffers[Entry] = std::move(Buffer); d252 1 a252 1 llvm::SmallPtrSetImpl *ModuleFilesHit) { @ 1.1.1.5 log @Import Clang 3.6RC1 r227398. @ text @d48 1 a48 2 std::unique_ptr ModuleManager::lookupBuffer(StringRef Name) { d51 1 a51 1 return std::move(InMemoryBuffers[Entry]); a58 3 ASTFileSignature ExpectedSignature, std::function ReadSignature, a65 7 if (Type == MK_ExplicitModule) { // If we're not expecting to pull this file out of the module cache, it // might have a different mtime due to being moved across filesystems in // a distributed build. The size must still match, though. (As must the // contents, but we can't check that.) ExpectedModTime = 0; } d91 1 a91 1 if (New->Kind == MK_ImplicitModule) { d101 1 a101 1 if (std::unique_ptr Buffer = lookupBuffer(FileName)) { d103 2 a104 1 New->Buffer = std::move(Buffer); d107 1 a107 2 llvm::ErrorOr> Buf( (std::error_code())); d109 7 a115 1 Buf = llvm::MemoryBuffer::getSTDIN(); d121 3 a123 3 Buf = FileMgr.getBufferForFile(New->File, /*IsVolatile=*/false, /*ShouldClose=*/false); d125 2 a126 3 if (!Buf) { ErrorStr = Buf.getError().message(); a127 3 } New->Buffer = std::move(*Buf); a133 22 if (ExpectedSignature) { if (NewModule) ModuleEntry->Signature = ReadSignature(ModuleEntry->StreamFile); else assert(ModuleEntry->Signature == ReadSignature(ModuleEntry->StreamFile)); if (ModuleEntry->Signature != ExpectedSignature) { ErrorStr = ModuleEntry->Signature ? "signature mismatch" : "could not read module signature"; if (NewModule) { // Remove the module file immediately, since removeModules might try to // invalidate the file cache for Entry, and that is not safe if this // module is *itself* up to date, but has an out-of-date importer. Modules.erase(Entry); Chain.pop_back(); delete ModuleEntry; } return OutOfDate; } } d190 6 a195 7 void ModuleManager::addInMemoryBuffer(StringRef FileName, std::unique_ptr Buffer) { const FileEntry *Entry = FileMgr.getVirtualFile(FileName, Buffer->getBufferSize(), 0); InMemoryBuffers[Entry] = std::move(Buffer); d252 1 a252 1 llvm::SmallPtrSetImpl *ModuleFilesHit) { @ 1.1.1.6 log @Import Clang 3.8.0rc3 r261930. @ text @a13 1 #include "clang/Frontend/PCHContainerOperations.h" d61 2 a62 1 ASTFileSignatureReader ReadSignature, a97 4 if (!New->isModule()) PCHChain.push_back(New); if (!ImportedBy) Roots.push_back(New); d138 4 a141 3 // Initialize the stream. PCHContainerRdr.ExtractPCH(New->Buffer->getMemBufferRef(), New->StreamFile); a158 1 assert(Chain.back() == ModuleEntry); a159 6 if (!ModuleEntry->isModule()) PCHChain.pop_back(); if (Roots.back() == ModuleEntry) Roots.pop_back(); else assert(ImportedBy); a186 3 // Explicitly clear VisitOrder since we might not notice it is stale. VisitOrder.clear(); a189 3 auto IsVictim = [&](ModuleFile *MF) { return victimSet.count(MF); }; d192 3 a194 12 Chain[i]->ImportedBy.remove_if(IsVictim); } Roots.erase(std::remove_if(Roots.begin(), Roots.end(), IsVictim), Roots.end()); // Remove the modules from the PCH chain. for (auto I = first; I != last; ++I) { if (!(*I)->isModule()) { PCHChain.erase(std::find(PCHChain.begin(), PCHChain.end(), *I), PCHChain.end()); break; } d272 2 a273 4 ModuleManager::ModuleManager(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr) : FileMgr(FileMgr), PCHContainerRdr(PCHContainerRdr), GlobalIndex(), FirstVisitState(nullptr) {} d281 4 a284 2 void ModuleManager::visit(llvm::function_ref Visitor, llvm::SmallPtrSetImpl *ModuleFilesHit) { d297 6 a302 5 UnusedIncomingEdges.resize(size()); for (auto M = rbegin(), MEnd = rend(); M != MEnd; ++M) { unsigned Size = (*M)->ImportedBy.size(); UnusedIncomingEdges[(*M)->Index] = Size; if (!Size) d304 1 d309 3 a311 2 while (!Queue.empty()) { ModuleFile *CurrentModule = Queue.pop_back_val(); d316 3 a318 2 for (auto M = CurrentModule->Imports.rbegin(), MEnd = CurrentModule->Imports.rend(); d360 1 a360 1 if (!Visitor(*CurrentModule)) d391 40 @ 1.1.1.6.2.1 log @Sync with HEAD @ text @a13 1 #include "clang/Serialization/ModuleManager.h" d18 1 d21 1 d70 1 a70 1 if (Type == MK_ExplicitModule || Type == MK_PrebuiltModule) { d88 1 a88 1 ModuleFile *ModuleEntry = Modules[Entry]; d92 10 d103 1 a103 6 ModuleEntry = new ModuleFile(Type, Generation); ModuleEntry->Index = Chain.size(); ModuleEntry->FileName = FileName.str(); ModuleEntry->File = Entry; ModuleEntry->ImportLoc = ImportLoc; ModuleEntry->InputFilesValidationTimestamp = 0; d105 3 a107 2 if (ModuleEntry->Kind == MK_ImplicitModule) { std::string TimestampFilename = ModuleEntry->getTimestampFilename(); d111 2 a112 2 ModuleEntry->InputFilesValidationTimestamp = llvm::sys::toTimeT(Status.getLastModificationTime()); d118 1 a118 1 ModuleEntry->Buffer = std::move(Buffer); d130 1 a130 1 Buf = FileMgr.getBufferForFile(ModuleEntry->File, a136 1 delete ModuleEntry; d140 1 a140 1 ModuleEntry->Buffer = std::move(*Buf); d144 1 a144 1 ModuleEntry->Data = PCHContainerRdr.ExtractPCH(*ModuleEntry->Buffer); d148 4 a151 4 // If we've not read the control block yet, read the signature eagerly now // so that we can check it. if (!ModuleEntry->Signature) ModuleEntry->Signature = ReadSignature(ModuleEntry->Data); d157 13 a169 1 if (NewModule) d171 1 d175 1 a175 1 d187 1 a187 14 if (!NewModule) return AlreadyLoaded; assert(!Modules[Entry] && "module loaded twice"); Modules[Entry] = ModuleEntry; Chain.push_back(ModuleEntry); if (!ModuleEntry->isModule()) PCHChain.push_back(ModuleEntry); if (!ImportedBy) Roots.push_back(ModuleEntry); return NewlyLoaded; d323 3 a325 3 for (ModuleFile *M : llvm::reverse(*this)) { unsigned Size = M->ImportedBy.size(); UnusedIncomingEdges[M->Index] = Size; d327 1 a327 1 Queue.push_back(M); a415 5 if (FileName == "-") { File = nullptr; return false; } d419 2 a420 1 if (!File) d422 1 d437 1 a437 1 typedef ModuleFile *NodeRef; d440 2 a441 2 static ChildIteratorType child_begin(NodeRef Node) { d445 1 a445 1 static ChildIteratorType child_end(NodeRef Node) { @ 1.1.1.7 log @Import Clang pre-4.0.0 r291444. @ text @a13 1 #include "clang/Serialization/ModuleManager.h" d18 1 d21 1 d70 1 a70 1 if (Type == MK_ExplicitModule || Type == MK_PrebuiltModule) { d88 1 a88 1 ModuleFile *ModuleEntry = Modules[Entry]; d92 10 d103 1 a103 6 ModuleEntry = new ModuleFile(Type, Generation); ModuleEntry->Index = Chain.size(); ModuleEntry->FileName = FileName.str(); ModuleEntry->File = Entry; ModuleEntry->ImportLoc = ImportLoc; ModuleEntry->InputFilesValidationTimestamp = 0; d105 3 a107 2 if (ModuleEntry->Kind == MK_ImplicitModule) { std::string TimestampFilename = ModuleEntry->getTimestampFilename(); d111 2 a112 2 ModuleEntry->InputFilesValidationTimestamp = llvm::sys::toTimeT(Status.getLastModificationTime()); d118 1 a118 1 ModuleEntry->Buffer = std::move(Buffer); d130 1 a130 1 Buf = FileMgr.getBufferForFile(ModuleEntry->File, a136 1 delete ModuleEntry; d140 1 a140 1 ModuleEntry->Buffer = std::move(*Buf); d144 1 a144 1 ModuleEntry->Data = PCHContainerRdr.ExtractPCH(*ModuleEntry->Buffer); d148 4 a151 4 // If we've not read the control block yet, read the signature eagerly now // so that we can check it. if (!ModuleEntry->Signature) ModuleEntry->Signature = ReadSignature(ModuleEntry->Data); d157 13 a169 1 if (NewModule) d171 1 d175 1 a175 1 d187 1 a187 14 if (!NewModule) return AlreadyLoaded; assert(!Modules[Entry] && "module loaded twice"); Modules[Entry] = ModuleEntry; Chain.push_back(ModuleEntry); if (!ModuleEntry->isModule()) PCHChain.push_back(ModuleEntry); if (!ImportedBy) Roots.push_back(ModuleEntry); return NewlyLoaded; d323 3 a325 3 for (ModuleFile *M : llvm::reverse(*this)) { unsigned Size = M->ImportedBy.size(); UnusedIncomingEdges[M->Index] = Size; d327 1 a327 1 Queue.push_back(M); a415 5 if (FileName == "-") { File = nullptr; return false; } d419 2 a420 1 if (!File) d422 1 d437 1 a437 1 typedef ModuleFile *NodeRef; d440 2 a441 2 static ChildIteratorType child_begin(NodeRef Node) { d445 1 a445 1 static ChildIteratorType child_end(NodeRef Node) { @ 1.1.1.8 log @Import clang r309604 from branches/release_50 @ text @a14 1 #include "clang/Basic/MemoryBufferCache.h" d30 1 a30 1 ModuleFile *ModuleManager::lookup(StringRef Name) const { d39 3 a41 2 ModuleFile *ModuleManager::lookup(const FileEntry *File) const { auto Known = Modules.find(File); a54 24 static bool checkSignature(ASTFileSignature Signature, ASTFileSignature ExpectedSignature, std::string &ErrorStr) { if (!ExpectedSignature || Signature == ExpectedSignature) return false; ErrorStr = Signature ? "signature mismatch" : "could not read module signature"; return true; } static void updateModuleImports(ModuleFile &MF, ModuleFile *ImportedBy, SourceLocation ImportLoc) { if (ImportedBy) { MF.ImportedBy.insert(ImportedBy); ImportedBy->Imports.insert(&MF); } else { if (!MF.DirectlyImported) MF.ImportLoc = ImportLoc; MF.DirectlyImported = true; } } d87 66 a152 3 if (ModuleFile *ModuleEntry = Modules.lookup(Entry)) { // Check the stored signature. if (checkSignature(ModuleEntry->Signature, ExpectedSignature, ErrorStr)) d154 1 a154 4 Module = ModuleEntry; updateModuleImports(*ModuleEntry, ImportedBy, ImportLoc); return AlreadyLoaded; d157 3 a159 23 // Allocate a new module. auto NewModule = llvm::make_unique(Type, Generation); NewModule->Index = Chain.size(); NewModule->FileName = FileName.str(); NewModule->File = Entry; NewModule->ImportLoc = ImportLoc; NewModule->InputFilesValidationTimestamp = 0; if (NewModule->Kind == MK_ImplicitModule) { std::string TimestampFilename = NewModule->getTimestampFilename(); vfs::Status Status; // A cached stat value would be fine as well. if (!FileMgr.getNoncachedStatValue(TimestampFilename, Status)) NewModule->InputFilesValidationTimestamp = llvm::sys::toTimeT(Status.getLastModificationTime()); } // Load the contents of the module if (std::unique_ptr Buffer = lookupBuffer(FileName)) { // The buffer was already provided for us. NewModule->Buffer = &PCMCache->addBuffer(FileName, std::move(Buffer)); } else if (llvm::MemoryBuffer *Buffer = PCMCache->lookupBuffer(FileName)) { NewModule->Buffer = Buffer; d161 4 a164 34 // Open the AST file. llvm::ErrorOr> Buf((std::error_code())); if (FileName == "-") { Buf = llvm::MemoryBuffer::getSTDIN(); } else { // Leave the FileEntry open so if it gets read again by another // ModuleManager it must be the same underlying file. // FIXME: Because FileManager::getFile() doesn't guarantee that it will // give us an open file, this may not be 100% reliable. Buf = FileMgr.getBufferForFile(NewModule->File, /*IsVolatile=*/false, /*ShouldClose=*/false); } if (!Buf) { ErrorStr = Buf.getError().message(); return Missing; } NewModule->Buffer = &PCMCache->addBuffer(FileName, std::move(*Buf)); } // Initialize the stream. NewModule->Data = PCHContainerRdr.ExtractPCH(*NewModule->Buffer); // Read the signature eagerly now so that we can check it. Avoid calling // ReadSignature unless there's something to check though. if (ExpectedSignature && checkSignature(ReadSignature(NewModule->Data), ExpectedSignature, ErrorStr)) { // Try to remove the buffer. If it can't be removed, then it was already // validated by this process. if (!PCMCache->tryToRemoveBuffer(NewModule->FileName)) FileMgr.invalidateCache(NewModule->File); return OutOfDate; d167 4 a170 2 // We're keeping this module. Store it everywhere. Module = Modules[Entry] = NewModule.get(); d172 2 a173 1 updateModuleImports(*NewModule, ImportedBy, ImportLoc); d175 3 a177 2 if (!NewModule->isModule()) PCHChain.push_back(NewModule.get()); d179 1 a179 1 Roots.push_back(NewModule.get()); a180 1 Chain.push_back(std::move(NewModule)); d185 1 a185 1 ModuleIterator First, d188 1 a188 2 auto Last = end(); if (First == Last) a190 1 d195 1 a195 3 llvm::SmallPtrSet victimSet( (llvm::pointer_iterator(First)), (llvm::pointer_iterator(Last))); d201 2 a202 3 for (auto I = begin(); I != First; ++I) { I->Imports.remove_if(IsVictim); I->ImportedBy.remove_if(IsVictim); d208 3 a210 3 for (auto I = First; I != Last; ++I) { if (!I->isModule()) { PCHChain.erase(std::find(PCHChain.begin(), PCHChain.end(), &*I), d217 2 a218 2 for (ModuleIterator victim = First; victim != Last; ++victim) { Modules.erase(victim->File); d221 1 a221 1 StringRef ModuleName = victim->ModuleName; d230 4 a233 7 // // The PCMCache tracks whether the module was successfully loaded in another // thread/context; in that case, it won't need to be rebuilt (and we can't // safely invalidate it anyway). if (LoadedSuccessfully.count(&*victim) == 0 && !PCMCache->tryToRemoveBuffer(victim->FileName)) FileMgr.invalidateCache(victim->File); d236 2 a237 2 // Delete the modules. Chain.erase(Chain.begin() + (First - begin()), Chain.end()); d277 5 a281 3 for (ModuleFile &M : *this) if (!GlobalIndex->loadedModuleFile(&M)) ModulesInCommonWithGlobalIndex.push_back(&M); d291 1 a291 1 ModuleManager::ModuleManager(FileManager &FileMgr, MemoryBufferCache &PCMCache, d293 2 a294 2 : FileMgr(FileMgr), PCMCache(&PCMCache), PCHContainerRdr(PCHContainerRdr), GlobalIndex(), FirstVisitState(nullptr) {} d296 5 a300 1 ModuleManager::~ModuleManager() { delete FirstVisitState; } d317 3 a319 3 for (ModuleFile &M : llvm::reverse(*this)) { unsigned Size = M.ImportedBy.size(); UnusedIncomingEdges[M.Index] = Size; d321 1 a321 1 Queue.push_back(&M); d436 1 a436 1 typedef pointer_iterator nodes_iterator; d447 1 a447 1 return nodes_iterator(Manager.begin()); d451 1 a451 1 return nodes_iterator(Manager.end()); @ 1.1.1.8.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ModuleManager.cpp - Module Manager ---------------------------------===// a13 1 a14 2 #include "clang/Basic/FileManager.h" #include "clang/Basic/LLVM.h" a15 1 #include "clang/Basic/VirtualFileSystem.h" a19 11 #include "clang/Serialization/Module.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetVector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/iterator.h" #include "llvm/Support/Chrono.h" #include "llvm/Support/DOTGraphTraits.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/GraphWriter.h" d21 1 a21 4 #include #include #include #include d24 4 d31 1 a31 1 ModuleFile *ModuleManager::lookupByFileName(StringRef Name) const { a39 8 ModuleFile *ModuleManager::lookupByModuleName(StringRef Name) const { if (const Module *Mod = HeaderSearchInfo.getModuleMap().findModule(Name)) if (const FileEntry *File = Mod->getASTFile()) return lookup(File); return nullptr; } d203 1 d262 1 d309 1 a309 2 const PCHContainerReader &PCHContainerRdr, const HeaderSearch& HeaderSearchInfo) d311 1 a311 1 HeaderSearchInfo(HeaderSearchInfo) {} a444 1 d447 3 a449 3 using NodeRef = ModuleFile *; using ChildIteratorType = llvm::SetVector::const_iterator; using nodes_iterator = pointer_iterator; d471 1 a471 1 : DefaultDOTGraphTraits(IsSimple) {} d473 3 a475 1 static bool renderGraphFromBottomUp() { return true; } d481 1 a481 2 } // namespace llvm @ 1.1.1.8.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.8.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- ModuleManager.cpp - Module Manager ---------------------------------===// a13 1 a14 2 #include "clang/Basic/FileManager.h" #include "clang/Basic/LLVM.h" a15 1 #include "clang/Basic/VirtualFileSystem.h" a19 11 #include "clang/Serialization/Module.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetVector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/iterator.h" #include "llvm/Support/Chrono.h" #include "llvm/Support/DOTGraphTraits.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/GraphWriter.h" d21 1 a21 4 #include #include #include #include d24 4 d31 1 a31 1 ModuleFile *ModuleManager::lookupByFileName(StringRef Name) const { a39 8 ModuleFile *ModuleManager::lookupByModuleName(StringRef Name) const { if (const Module *Mod = HeaderSearchInfo.getModuleMap().findModule(Name)) if (const FileEntry *File = Mod->getASTFile()) return lookup(File); return nullptr; } d203 1 d262 1 d309 1 a309 2 const PCHContainerReader &PCHContainerRdr, const HeaderSearch& HeaderSearchInfo) d311 1 a311 1 HeaderSearchInfo(HeaderSearchInfo) {} a444 1 d447 3 a449 3 using NodeRef = ModuleFile *; using ChildIteratorType = llvm::SetVector::const_iterator; using nodes_iterator = pointer_iterator; d471 1 a471 1 : DefaultDOTGraphTraits(IsSimple) {} d473 3 a475 1 static bool renderGraphFromBottomUp() { return true; } d481 1 a481 2 } // namespace llvm @ 1.1.1.9 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- ModuleManager.cpp - Module Manager ---------------------------------===// a13 1 a14 2 #include "clang/Basic/FileManager.h" #include "clang/Basic/LLVM.h" a15 1 #include "clang/Basic/VirtualFileSystem.h" a19 11 #include "clang/Serialization/Module.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetVector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/iterator.h" #include "llvm/Support/Chrono.h" #include "llvm/Support/DOTGraphTraits.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/GraphWriter.h" d21 1 a21 4 #include #include #include #include d24 4 d31 1 a31 1 ModuleFile *ModuleManager::lookupByFileName(StringRef Name) const { a39 8 ModuleFile *ModuleManager::lookupByModuleName(StringRef Name) const { if (const Module *Mod = HeaderSearchInfo.getModuleMap().findModule(Name)) if (const FileEntry *File = Mod->getASTFile()) return lookup(File); return nullptr; } d203 1 d262 1 d309 1 a309 2 const PCHContainerReader &PCHContainerRdr, const HeaderSearch& HeaderSearchInfo) d311 1 a311 1 HeaderSearchInfo(HeaderSearchInfo) {} a444 1 d447 3 a449 3 using NodeRef = ModuleFile *; using ChildIteratorType = llvm::SetVector::const_iterator; using nodes_iterator = pointer_iterator; d471 1 a471 1 : DefaultDOTGraphTraits(IsSimple) {} d473 3 a475 1 static bool renderGraphFromBottomUp() { return true; } d481 1 a481 2 } // namespace llvm @ 1.1.1.10 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.4.4.1 log @file ModuleManager.cpp was added on branch tls-maxphys on 2014-08-19 23:47:31 +0000 @ text @d1 463 @ 1.1.1.4.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 463 //===--- ModuleManager.cpp - Module Manager ---------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the ModuleManager class, which manages a set of loaded // modules for the ASTReader. // //===----------------------------------------------------------------------===// #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/ModuleMap.h" #include "clang/Serialization/GlobalModuleIndex.h" #include "clang/Serialization/ModuleManager.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include #ifndef NDEBUG #include "llvm/Support/GraphWriter.h" #endif using namespace clang; using namespace serialization; ModuleFile *ModuleManager::lookup(StringRef Name) { const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false, /*cacheFailure=*/false); if (Entry) return lookup(Entry); return nullptr; } ModuleFile *ModuleManager::lookup(const FileEntry *File) { llvm::DenseMap::iterator Known = Modules.find(File); if (Known == Modules.end()) return nullptr; return Known->second; } llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false, /*cacheFailure=*/false); return InMemoryBuffers[Entry]; } ModuleManager::AddModuleResult ModuleManager::addModule(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, ModuleFile *ImportedBy, unsigned Generation, off_t ExpectedSize, time_t ExpectedModTime, ModuleFile *&Module, std::string &ErrorStr) { Module = nullptr; // Look for the file entry. This only fails if the expected size or // modification time differ. const FileEntry *Entry; if (lookupModuleFile(FileName, ExpectedSize, ExpectedModTime, Entry)) { ErrorStr = "module file out of date"; return OutOfDate; } if (!Entry && FileName != "-") { ErrorStr = "module file not found"; return Missing; } // Check whether we already loaded this module, before ModuleFile *&ModuleEntry = Modules[Entry]; bool NewModule = false; if (!ModuleEntry) { // Allocate a new module. ModuleFile *New = new ModuleFile(Type, Generation); New->Index = Chain.size(); New->FileName = FileName.str(); New->File = Entry; New->ImportLoc = ImportLoc; Chain.push_back(New); NewModule = true; ModuleEntry = New; New->InputFilesValidationTimestamp = 0; if (New->Kind == MK_Module) { std::string TimestampFilename = New->getTimestampFilename(); vfs::Status Status; // A cached stat value would be fine as well. if (!FileMgr.getNoncachedStatValue(TimestampFilename, Status)) New->InputFilesValidationTimestamp = Status.getLastModificationTime().toEpochTime(); } // Load the contents of the module if (llvm::MemoryBuffer *Buffer = lookupBuffer(FileName)) { // The buffer was already provided for us. assert(Buffer && "Passed null buffer"); New->Buffer.reset(Buffer); } else { // Open the AST file. std::error_code ec; if (FileName == "-") { llvm::ErrorOr> Buf = llvm::MemoryBuffer::getSTDIN(); ec = Buf.getError(); if (ec) ErrorStr = ec.message(); else New->Buffer = std::move(Buf.get()); } else { // Leave the FileEntry open so if it gets read again by another // ModuleManager it must be the same underlying file. // FIXME: Because FileManager::getFile() doesn't guarantee that it will // give us an open file, this may not be 100% reliable. New->Buffer.reset(FileMgr.getBufferForFile(New->File, &ErrorStr, /*IsVolatile*/false, /*ShouldClose*/false)); } if (!New->Buffer) return Missing; } // Initialize the stream New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(), (const unsigned char *)New->Buffer->getBufferEnd()); } if (ImportedBy) { ModuleEntry->ImportedBy.insert(ImportedBy); ImportedBy->Imports.insert(ModuleEntry); } else { if (!ModuleEntry->DirectlyImported) ModuleEntry->ImportLoc = ImportLoc; ModuleEntry->DirectlyImported = true; } Module = ModuleEntry; return NewModule? NewlyLoaded : AlreadyLoaded; } void ModuleManager::removeModules( ModuleIterator first, ModuleIterator last, llvm::SmallPtrSetImpl &LoadedSuccessfully, ModuleMap *modMap) { if (first == last) return; // Collect the set of module file pointers that we'll be removing. llvm::SmallPtrSet victimSet(first, last); // Remove any references to the now-destroyed modules. for (unsigned i = 0, n = Chain.size(); i != n; ++i) { Chain[i]->ImportedBy.remove_if([&](ModuleFile *MF) { return victimSet.count(MF); }); } // Delete the modules and erase them from the various structures. for (ModuleIterator victim = first; victim != last; ++victim) { Modules.erase((*victim)->File); if (modMap) { StringRef ModuleName = (*victim)->ModuleName; if (Module *mod = modMap->findModule(ModuleName)) { mod->setASTFile(nullptr); } } // Files that didn't make it through ReadASTCore successfully will be // rebuilt (or there was an error). Invalidate them so that we can load the // new files that will be renamed over the old ones. if (LoadedSuccessfully.count(*victim) == 0) FileMgr.invalidateCache((*victim)->File); delete *victim; } // Remove the modules from the chain. Chain.erase(first, last); } void ModuleManager::addInMemoryBuffer(StringRef FileName, llvm::MemoryBuffer *Buffer) { const FileEntry *Entry = FileMgr.getVirtualFile(FileName, Buffer->getBufferSize(), 0); InMemoryBuffers[Entry] = Buffer; } ModuleManager::VisitState *ModuleManager::allocateVisitState() { // Fast path: if we have a cached state, use it. if (FirstVisitState) { VisitState *Result = FirstVisitState; FirstVisitState = FirstVisitState->NextState; Result->NextState = nullptr; return Result; } // Allocate and return a new state. return new VisitState(size()); } void ModuleManager::returnVisitState(VisitState *State) { assert(State->NextState == nullptr && "Visited state is in list?"); State->NextState = FirstVisitState; FirstVisitState = State; } void ModuleManager::setGlobalIndex(GlobalModuleIndex *Index) { GlobalIndex = Index; if (!GlobalIndex) { ModulesInCommonWithGlobalIndex.clear(); return; } // Notify the global module index about all of the modules we've already // loaded. for (unsigned I = 0, N = Chain.size(); I != N; ++I) { if (!GlobalIndex->loadedModuleFile(Chain[I])) { ModulesInCommonWithGlobalIndex.push_back(Chain[I]); } } } void ModuleManager::moduleFileAccepted(ModuleFile *MF) { if (!GlobalIndex || GlobalIndex->loadedModuleFile(MF)) return; ModulesInCommonWithGlobalIndex.push_back(MF); } ModuleManager::ModuleManager(FileManager &FileMgr) : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(nullptr) {} ModuleManager::~ModuleManager() { for (unsigned i = 0, e = Chain.size(); i != e; ++i) delete Chain[e - i - 1]; delete FirstVisitState; } void ModuleManager::visit(bool (*Visitor)(ModuleFile &M, void *UserData), void *UserData, llvm::SmallPtrSet *ModuleFilesHit) { // If the visitation order vector is the wrong size, recompute the order. if (VisitOrder.size() != Chain.size()) { unsigned N = size(); VisitOrder.clear(); VisitOrder.reserve(N); // Record the number of incoming edges for each module. When we // encounter a module with no incoming edges, push it into the queue // to seed the queue. SmallVector Queue; Queue.reserve(N); llvm::SmallVector UnusedIncomingEdges; UnusedIncomingEdges.reserve(size()); for (ModuleIterator M = begin(), MEnd = end(); M != MEnd; ++M) { if (unsigned Size = (*M)->ImportedBy.size()) UnusedIncomingEdges.push_back(Size); else { UnusedIncomingEdges.push_back(0); Queue.push_back(*M); } } // Traverse the graph, making sure to visit a module before visiting any // of its dependencies. unsigned QueueStart = 0; while (QueueStart < Queue.size()) { ModuleFile *CurrentModule = Queue[QueueStart++]; VisitOrder.push_back(CurrentModule); // For any module that this module depends on, push it on the // stack (if it hasn't already been marked as visited). for (llvm::SetVector::iterator M = CurrentModule->Imports.begin(), MEnd = CurrentModule->Imports.end(); M != MEnd; ++M) { // Remove our current module as an impediment to visiting the // module we depend on. If we were the last unvisited module // that depends on this particular module, push it into the // queue to be visited. unsigned &NumUnusedEdges = UnusedIncomingEdges[(*M)->Index]; if (NumUnusedEdges && (--NumUnusedEdges == 0)) Queue.push_back(*M); } } assert(VisitOrder.size() == N && "Visitation order is wrong?"); delete FirstVisitState; FirstVisitState = nullptr; } VisitState *State = allocateVisitState(); unsigned VisitNumber = State->NextVisitNumber++; // If the caller has provided us with a hit-set that came from the global // module index, mark every module file in common with the global module // index that is *not* in that set as 'visited'. if (ModuleFilesHit && !ModulesInCommonWithGlobalIndex.empty()) { for (unsigned I = 0, N = ModulesInCommonWithGlobalIndex.size(); I != N; ++I) { ModuleFile *M = ModulesInCommonWithGlobalIndex[I]; if (!ModuleFilesHit->count(M)) State->VisitNumber[M->Index] = VisitNumber; } } for (unsigned I = 0, N = VisitOrder.size(); I != N; ++I) { ModuleFile *CurrentModule = VisitOrder[I]; // Should we skip this module file? if (State->VisitNumber[CurrentModule->Index] == VisitNumber) continue; // Visit the module. assert(State->VisitNumber[CurrentModule->Index] == VisitNumber - 1); State->VisitNumber[CurrentModule->Index] = VisitNumber; if (!Visitor(*CurrentModule, UserData)) continue; // The visitor has requested that cut off visitation of any // module that the current module depends on. To indicate this // behavior, we mark all of the reachable modules as having been visited. ModuleFile *NextModule = CurrentModule; do { // For any module that this module depends on, push it on the // stack (if it hasn't already been marked as visited). for (llvm::SetVector::iterator M = NextModule->Imports.begin(), MEnd = NextModule->Imports.end(); M != MEnd; ++M) { if (State->VisitNumber[(*M)->Index] != VisitNumber) { State->Stack.push_back(*M); State->VisitNumber[(*M)->Index] = VisitNumber; } } if (State->Stack.empty()) break; // Pop the next module off the stack. NextModule = State->Stack.pop_back_val(); } while (true); } returnVisitState(State); } /// \brief Perform a depth-first visit of the current module. static bool visitDepthFirst(ModuleFile &M, bool (*Visitor)(ModuleFile &M, bool Preorder, void *UserData), void *UserData, SmallVectorImpl &Visited) { // Preorder visitation if (Visitor(M, /*Preorder=*/true, UserData)) return true; // Visit children for (llvm::SetVector::iterator IM = M.Imports.begin(), IMEnd = M.Imports.end(); IM != IMEnd; ++IM) { if (Visited[(*IM)->Index]) continue; Visited[(*IM)->Index] = true; if (visitDepthFirst(**IM, Visitor, UserData, Visited)) return true; } // Postorder visitation return Visitor(M, /*Preorder=*/false, UserData); } void ModuleManager::visitDepthFirst(bool (*Visitor)(ModuleFile &M, bool Preorder, void *UserData), void *UserData) { SmallVector Visited(size(), false); for (unsigned I = 0, N = Chain.size(); I != N; ++I) { if (Visited[Chain[I]->Index]) continue; Visited[Chain[I]->Index] = true; if (::visitDepthFirst(*Chain[I], Visitor, UserData, Visited)) return; } } bool ModuleManager::lookupModuleFile(StringRef FileName, off_t ExpectedSize, time_t ExpectedModTime, const FileEntry *&File) { // Open the file immediately to ensure there is no race between stat'ing and // opening the file. File = FileMgr.getFile(FileName, /*openFile=*/true, /*cacheFailure=*/false); if (!File && FileName != "-") { return false; } if ((ExpectedSize && ExpectedSize != File->getSize()) || (ExpectedModTime && ExpectedModTime != File->getModificationTime())) // Do not destroy File, as it may be referenced. If we need to rebuild it, // it will be destroyed by removeModules. return true; return false; } #ifndef NDEBUG namespace llvm { template<> struct GraphTraits { typedef ModuleFile NodeType; typedef llvm::SetVector::const_iterator ChildIteratorType; typedef ModuleManager::ModuleConstIterator nodes_iterator; static ChildIteratorType child_begin(NodeType *Node) { return Node->Imports.begin(); } static ChildIteratorType child_end(NodeType *Node) { return Node->Imports.end(); } static nodes_iterator nodes_begin(const ModuleManager &Manager) { return Manager.begin(); } static nodes_iterator nodes_end(const ModuleManager &Manager) { return Manager.end(); } }; template<> struct DOTGraphTraits : public DefaultDOTGraphTraits { explicit DOTGraphTraits(bool IsSimple = false) : DefaultDOTGraphTraits(IsSimple) { } static bool renderGraphFromBottomUp() { return true; } std::string getNodeLabel(ModuleFile *M, const ModuleManager&) { return M->ModuleName; } }; } void ModuleManager::viewGraph() { llvm::ViewGraph(*this, "Modules"); } #endif @ 1.1.1.2.4.1 log @file ModuleManager.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:30 +0000 @ text @d1 455 @ 1.1.1.2.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 455 //===--- ModuleManager.cpp - Module Manager ---------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the ModuleManager class, which manages a set of loaded // modules for the ASTReader. // //===----------------------------------------------------------------------===// #include "clang/Lex/ModuleMap.h" #include "clang/Serialization/GlobalModuleIndex.h" #include "clang/Serialization/ModuleManager.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/system_error.h" #ifndef NDEBUG #include "llvm/Support/GraphWriter.h" #endif using namespace clang; using namespace serialization; ModuleFile *ModuleManager::lookup(StringRef Name) { const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false, /*cacheFailure=*/false); if (Entry) return lookup(Entry); return 0; } ModuleFile *ModuleManager::lookup(const FileEntry *File) { llvm::DenseMap::iterator Known = Modules.find(File); if (Known == Modules.end()) return 0; return Known->second; } llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false, /*cacheFailure=*/false); return InMemoryBuffers[Entry]; } ModuleManager::AddModuleResult ModuleManager::addModule(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, ModuleFile *ImportedBy, unsigned Generation, off_t ExpectedSize, time_t ExpectedModTime, ModuleFile *&Module, std::string &ErrorStr) { Module = 0; // Look for the file entry. This only fails if the expected size or // modification time differ. const FileEntry *Entry; if (lookupModuleFile(FileName, ExpectedSize, ExpectedModTime, Entry)) { ErrorStr = "module file out of date"; return OutOfDate; } if (!Entry && FileName != "-") { ErrorStr = "module file not found"; return Missing; } // Check whether we already loaded this module, before ModuleFile *&ModuleEntry = Modules[Entry]; bool NewModule = false; if (!ModuleEntry) { // Allocate a new module. ModuleFile *New = new ModuleFile(Type, Generation); New->Index = Chain.size(); New->FileName = FileName.str(); New->File = Entry; New->ImportLoc = ImportLoc; Chain.push_back(New); NewModule = true; ModuleEntry = New; New->InputFilesValidationTimestamp = 0; if (New->Kind == MK_Module) { std::string TimestampFilename = New->getTimestampFilename(); vfs::Status Status; // A cached stat value would be fine as well. if (!FileMgr.getNoncachedStatValue(TimestampFilename, Status)) New->InputFilesValidationTimestamp = Status.getLastModificationTime().toEpochTime(); } // Load the contents of the module if (llvm::MemoryBuffer *Buffer = lookupBuffer(FileName)) { // The buffer was already provided for us. assert(Buffer && "Passed null buffer"); New->Buffer.reset(Buffer); } else { // Open the AST file. llvm::error_code ec; if (FileName == "-") { ec = llvm::MemoryBuffer::getSTDIN(New->Buffer); if (ec) ErrorStr = ec.message(); } else New->Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrorStr)); if (!New->Buffer) return Missing; } // Initialize the stream New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(), (const unsigned char *)New->Buffer->getBufferEnd()); } if (ImportedBy) { ModuleEntry->ImportedBy.insert(ImportedBy); ImportedBy->Imports.insert(ModuleEntry); } else { if (!ModuleEntry->DirectlyImported) ModuleEntry->ImportLoc = ImportLoc; ModuleEntry->DirectlyImported = true; } Module = ModuleEntry; return NewModule? NewlyLoaded : AlreadyLoaded; } namespace { /// \brief Predicate that checks whether a module file occurs within /// the given set. class IsInModuleFileSet : public std::unary_function { llvm::SmallPtrSet &Removed; public: IsInModuleFileSet(llvm::SmallPtrSet &Removed) : Removed(Removed) { } bool operator()(ModuleFile *MF) const { return Removed.count(MF); } }; } void ModuleManager::removeModules(ModuleIterator first, ModuleIterator last, ModuleMap *modMap) { if (first == last) return; // Collect the set of module file pointers that we'll be removing. llvm::SmallPtrSet victimSet(first, last); // Remove any references to the now-destroyed modules. IsInModuleFileSet checkInSet(victimSet); for (unsigned i = 0, n = Chain.size(); i != n; ++i) { Chain[i]->ImportedBy.remove_if(checkInSet); } // Delete the modules and erase them from the various structures. for (ModuleIterator victim = first; victim != last; ++victim) { Modules.erase((*victim)->File); FileMgr.invalidateCache((*victim)->File); if (modMap) { StringRef ModuleName = llvm::sys::path::stem((*victim)->FileName); if (Module *mod = modMap->findModule(ModuleName)) { mod->setASTFile(0); } } delete *victim; } // Remove the modules from the chain. Chain.erase(first, last); } void ModuleManager::addInMemoryBuffer(StringRef FileName, llvm::MemoryBuffer *Buffer) { const FileEntry *Entry = FileMgr.getVirtualFile(FileName, Buffer->getBufferSize(), 0); InMemoryBuffers[Entry] = Buffer; } ModuleManager::VisitState *ModuleManager::allocateVisitState() { // Fast path: if we have a cached state, use it. if (FirstVisitState) { VisitState *Result = FirstVisitState; FirstVisitState = FirstVisitState->NextState; Result->NextState = 0; return Result; } // Allocate and return a new state. return new VisitState(size()); } void ModuleManager::returnVisitState(VisitState *State) { assert(State->NextState == 0 && "Visited state is in list?"); State->NextState = FirstVisitState; FirstVisitState = State; } void ModuleManager::setGlobalIndex(GlobalModuleIndex *Index) { GlobalIndex = Index; if (!GlobalIndex) { ModulesInCommonWithGlobalIndex.clear(); return; } // Notify the global module index about all of the modules we've already // loaded. for (unsigned I = 0, N = Chain.size(); I != N; ++I) { if (!GlobalIndex->loadedModuleFile(Chain[I])) { ModulesInCommonWithGlobalIndex.push_back(Chain[I]); } } } void ModuleManager::moduleFileAccepted(ModuleFile *MF) { if (!GlobalIndex || GlobalIndex->loadedModuleFile(MF)) return; ModulesInCommonWithGlobalIndex.push_back(MF); } ModuleManager::ModuleManager(FileManager &FileMgr) : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(0) { } ModuleManager::~ModuleManager() { for (unsigned i = 0, e = Chain.size(); i != e; ++i) delete Chain[e - i - 1]; delete FirstVisitState; } void ModuleManager::visit(bool (*Visitor)(ModuleFile &M, void *UserData), void *UserData, llvm::SmallPtrSet *ModuleFilesHit) { // If the visitation order vector is the wrong size, recompute the order. if (VisitOrder.size() != Chain.size()) { unsigned N = size(); VisitOrder.clear(); VisitOrder.reserve(N); // Record the number of incoming edges for each module. When we // encounter a module with no incoming edges, push it into the queue // to seed the queue. SmallVector Queue; Queue.reserve(N); llvm::SmallVector UnusedIncomingEdges; UnusedIncomingEdges.reserve(size()); for (ModuleIterator M = begin(), MEnd = end(); M != MEnd; ++M) { if (unsigned Size = (*M)->ImportedBy.size()) UnusedIncomingEdges.push_back(Size); else { UnusedIncomingEdges.push_back(0); Queue.push_back(*M); } } // Traverse the graph, making sure to visit a module before visiting any // of its dependencies. unsigned QueueStart = 0; while (QueueStart < Queue.size()) { ModuleFile *CurrentModule = Queue[QueueStart++]; VisitOrder.push_back(CurrentModule); // For any module that this module depends on, push it on the // stack (if it hasn't already been marked as visited). for (llvm::SetVector::iterator M = CurrentModule->Imports.begin(), MEnd = CurrentModule->Imports.end(); M != MEnd; ++M) { // Remove our current module as an impediment to visiting the // module we depend on. If we were the last unvisited module // that depends on this particular module, push it into the // queue to be visited. unsigned &NumUnusedEdges = UnusedIncomingEdges[(*M)->Index]; if (NumUnusedEdges && (--NumUnusedEdges == 0)) Queue.push_back(*M); } } assert(VisitOrder.size() == N && "Visitation order is wrong?"); delete FirstVisitState; FirstVisitState = 0; } VisitState *State = allocateVisitState(); unsigned VisitNumber = State->NextVisitNumber++; // If the caller has provided us with a hit-set that came from the global // module index, mark every module file in common with the global module // index that is *not* in that set as 'visited'. if (ModuleFilesHit && !ModulesInCommonWithGlobalIndex.empty()) { for (unsigned I = 0, N = ModulesInCommonWithGlobalIndex.size(); I != N; ++I) { ModuleFile *M = ModulesInCommonWithGlobalIndex[I]; if (!ModuleFilesHit->count(M)) State->VisitNumber[M->Index] = VisitNumber; } } for (unsigned I = 0, N = VisitOrder.size(); I != N; ++I) { ModuleFile *CurrentModule = VisitOrder[I]; // Should we skip this module file? if (State->VisitNumber[CurrentModule->Index] == VisitNumber) continue; // Visit the module. assert(State->VisitNumber[CurrentModule->Index] == VisitNumber - 1); State->VisitNumber[CurrentModule->Index] = VisitNumber; if (!Visitor(*CurrentModule, UserData)) continue; // The visitor has requested that cut off visitation of any // module that the current module depends on. To indicate this // behavior, we mark all of the reachable modules as having been visited. ModuleFile *NextModule = CurrentModule; do { // For any module that this module depends on, push it on the // stack (if it hasn't already been marked as visited). for (llvm::SetVector::iterator M = NextModule->Imports.begin(), MEnd = NextModule->Imports.end(); M != MEnd; ++M) { if (State->VisitNumber[(*M)->Index] != VisitNumber) { State->Stack.push_back(*M); State->VisitNumber[(*M)->Index] = VisitNumber; } } if (State->Stack.empty()) break; // Pop the next module off the stack. NextModule = State->Stack.pop_back_val(); } while (true); } returnVisitState(State); } /// \brief Perform a depth-first visit of the current module. static bool visitDepthFirst(ModuleFile &M, bool (*Visitor)(ModuleFile &M, bool Preorder, void *UserData), void *UserData, SmallVectorImpl &Visited) { // Preorder visitation if (Visitor(M, /*Preorder=*/true, UserData)) return true; // Visit children for (llvm::SetVector::iterator IM = M.Imports.begin(), IMEnd = M.Imports.end(); IM != IMEnd; ++IM) { if (Visited[(*IM)->Index]) continue; Visited[(*IM)->Index] = true; if (visitDepthFirst(**IM, Visitor, UserData, Visited)) return true; } // Postorder visitation return Visitor(M, /*Preorder=*/false, UserData); } void ModuleManager::visitDepthFirst(bool (*Visitor)(ModuleFile &M, bool Preorder, void *UserData), void *UserData) { SmallVector Visited(size(), false); for (unsigned I = 0, N = Chain.size(); I != N; ++I) { if (Visited[Chain[I]->Index]) continue; Visited[Chain[I]->Index] = true; if (::visitDepthFirst(*Chain[I], Visitor, UserData, Visited)) return; } } bool ModuleManager::lookupModuleFile(StringRef FileName, off_t ExpectedSize, time_t ExpectedModTime, const FileEntry *&File) { File = FileMgr.getFile(FileName, /*openFile=*/false, /*cacheFailure=*/false); if (!File && FileName != "-") { return false; } if ((ExpectedSize && ExpectedSize != File->getSize()) || (ExpectedModTime && ExpectedModTime != File->getModificationTime())) { return true; } return false; } #ifndef NDEBUG namespace llvm { template<> struct GraphTraits { typedef ModuleFile NodeType; typedef llvm::SetVector::const_iterator ChildIteratorType; typedef ModuleManager::ModuleConstIterator nodes_iterator; static ChildIteratorType child_begin(NodeType *Node) { return Node->Imports.begin(); } static ChildIteratorType child_end(NodeType *Node) { return Node->Imports.end(); } static nodes_iterator nodes_begin(const ModuleManager &Manager) { return Manager.begin(); } static nodes_iterator nodes_end(const ModuleManager &Manager) { return Manager.end(); } }; template<> struct DOTGraphTraits : public DefaultDOTGraphTraits { explicit DOTGraphTraits(bool IsSimple = false) : DefaultDOTGraphTraits(IsSimple) { } static bool renderGraphFromBottomUp() { return true; } std::string getNodeLabel(ModuleFile *M, const ModuleManager&) { return llvm::sys::path::stem(M->FileName); } }; } void ModuleManager::viewGraph() { llvm::ViewGraph(*this, "Modules"); } #endif @