1 //===--- ModuleManager.cpp - Module Manager ---------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the ModuleManager class, which manages a set of loaded 11 // modules for the ASTReader. 12 // 13 //===----------------------------------------------------------------------===// 14 #include "clang/Serialization/ModuleManager.h" 15 #include "llvm/Support/MemoryBuffer.h" 16 #include "llvm/Support/raw_ostream.h" 17 #include "llvm/Support/system_error.h" 18 19 #ifndef NDEBUG 20 #include "llvm/Support/GraphWriter.h" 21 #endif 22 23 using namespace clang; 24 using namespace serialization; 25 26 ModuleFile *ModuleManager::lookup(StringRef Name) { 27 const FileEntry *Entry = FileMgr.getFile(Name); 28 return Modules[Entry]; 29 } 30 31 llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { 32 const FileEntry *Entry = FileMgr.getFile(Name); 33 return InMemoryBuffers[Entry]; 34 } 35 36 std::pair<ModuleFile *, bool> 37 ModuleManager::addModule(StringRef FileName, ModuleKind Type, 38 ModuleFile *ImportedBy, unsigned Generation, 39 std::string &ErrorStr) { 40 const FileEntry *Entry = FileMgr.getFile(FileName); 41 if (!Entry && FileName != "-") { 42 ErrorStr = "file not found"; 43 return std::make_pair(static_cast<ModuleFile*>(0), false); 44 } 45 46 // Check whether we already loaded this module, before 47 ModuleFile *&ModuleEntry = Modules[Entry]; 48 bool NewModule = false; 49 if (!ModuleEntry) { 50 // Allocate a new module. 51 ModuleFile *New = new ModuleFile(Type, Generation); 52 New->FileName = FileName.str(); 53 Chain.push_back(New); 54 NewModule = true; 55 ModuleEntry = New; 56 57 // Load the contents of the module 58 if (llvm::MemoryBuffer *Buffer = lookupBuffer(FileName)) { 59 // The buffer was already provided for us. 60 assert(Buffer && "Passed null buffer"); 61 New->Buffer.reset(Buffer); 62 } else { 63 // Open the AST file. 64 llvm::error_code ec; 65 if (FileName == "-") { 66 ec = llvm::MemoryBuffer::getSTDIN(New->Buffer); 67 if (ec) 68 ErrorStr = ec.message(); 69 } else 70 New->Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrorStr)); 71 72 if (!New->Buffer) 73 return std::make_pair(static_cast<ModuleFile*>(0), false); 74 } 75 76 // Initialize the stream 77 New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(), 78 (const unsigned char *)New->Buffer->getBufferEnd()); } 79 80 if (ImportedBy) { 81 ModuleEntry->ImportedBy.insert(ImportedBy); 82 ImportedBy->Imports.insert(ModuleEntry); 83 } else { 84 ModuleEntry->DirectlyImported = true; 85 } 86 87 return std::make_pair(ModuleEntry, NewModule); 88 } 89 90 void ModuleManager::addInMemoryBuffer(StringRef FileName, 91 llvm::MemoryBuffer *Buffer) { 92 93 const FileEntry *Entry = FileMgr.getVirtualFile(FileName, 94 Buffer->getBufferSize(), 0); 95 InMemoryBuffers[Entry] = Buffer; 96 } 97 98 ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { } 99 100 ModuleManager::~ModuleManager() { 101 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 102 delete Chain[e - i - 1]; 103 } 104 105 void ModuleManager::visit(bool (*Visitor)(ModuleFile &M, void *UserData), 106 void *UserData) { 107 unsigned N = size(); 108 109 // Record the number of incoming edges for each module. When we 110 // encounter a module with no incoming edges, push it into the queue 111 // to seed the queue. 112 SmallVector<ModuleFile *, 4> Queue; 113 Queue.reserve(N); 114 llvm::DenseMap<ModuleFile *, unsigned> UnusedIncomingEdges; 115 for (ModuleIterator M = begin(), MEnd = end(); M != MEnd; ++M) { 116 if (unsigned Size = (*M)->ImportedBy.size()) 117 UnusedIncomingEdges[*M] = Size; 118 else 119 Queue.push_back(*M); 120 } 121 122 llvm::SmallPtrSet<ModuleFile *, 4> Skipped; 123 unsigned QueueStart = 0; 124 while (QueueStart < Queue.size()) { 125 ModuleFile *CurrentModule = Queue[QueueStart++]; 126 127 // Check whether this module should be skipped. 128 if (Skipped.count(CurrentModule)) 129 continue; 130 131 if (Visitor(*CurrentModule, UserData)) { 132 // The visitor has requested that cut off visitation of any 133 // module that the current module depends on. To indicate this 134 // behavior, we mark all of the reachable modules as having N 135 // incoming edges (which is impossible otherwise). 136 SmallVector<ModuleFile *, 4> Stack; 137 Stack.push_back(CurrentModule); 138 Skipped.insert(CurrentModule); 139 while (!Stack.empty()) { 140 ModuleFile *NextModule = Stack.back(); 141 Stack.pop_back(); 142 143 // For any module that this module depends on, push it on the 144 // stack (if it hasn't already been marked as visited). 145 for (llvm::SetVector<ModuleFile *>::iterator 146 M = NextModule->Imports.begin(), 147 MEnd = NextModule->Imports.end(); 148 M != MEnd; ++M) { 149 if (Skipped.insert(*M)) 150 Stack.push_back(*M); 151 } 152 } 153 continue; 154 } 155 156 // For any module that this module depends on, push it on the 157 // stack (if it hasn't already been marked as visited). 158 for (llvm::SetVector<ModuleFile *>::iterator M = CurrentModule->Imports.begin(), 159 MEnd = CurrentModule->Imports.end(); 160 M != MEnd; ++M) { 161 162 // Remove our current module as an impediment to visiting the 163 // module we depend on. If we were the last unvisited module 164 // that depends on this particular module, push it into the 165 // queue to be visited. 166 unsigned &NumUnusedEdges = UnusedIncomingEdges[*M]; 167 if (NumUnusedEdges && (--NumUnusedEdges == 0)) 168 Queue.push_back(*M); 169 } 170 } 171 } 172 173 /// \brief Perform a depth-first visit of the current module. 174 static bool visitDepthFirst(ModuleFile &M, 175 bool (*Visitor)(ModuleFile &M, bool Preorder, 176 void *UserData), 177 void *UserData, 178 llvm::SmallPtrSet<ModuleFile *, 4> &Visited) { 179 // Preorder visitation 180 if (Visitor(M, /*Preorder=*/true, UserData)) 181 return true; 182 183 // Visit children 184 for (llvm::SetVector<ModuleFile *>::iterator IM = M.Imports.begin(), 185 IMEnd = M.Imports.end(); 186 IM != IMEnd; ++IM) { 187 if (!Visited.insert(*IM)) 188 continue; 189 190 if (visitDepthFirst(**IM, Visitor, UserData, Visited)) 191 return true; 192 } 193 194 // Postorder visitation 195 return Visitor(M, /*Preorder=*/false, UserData); 196 } 197 198 void ModuleManager::visitDepthFirst(bool (*Visitor)(ModuleFile &M, bool Preorder, 199 void *UserData), 200 void *UserData) { 201 llvm::SmallPtrSet<ModuleFile *, 4> Visited; 202 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 203 if (!Visited.insert(Chain[I])) 204 continue; 205 206 if (::visitDepthFirst(*Chain[I], Visitor, UserData, Visited)) 207 return; 208 } 209 } 210 211 #ifndef NDEBUG 212 namespace llvm { 213 template<> 214 struct GraphTraits<ModuleManager> { 215 typedef ModuleFile NodeType; 216 typedef llvm::SetVector<ModuleFile *>::const_iterator ChildIteratorType; 217 typedef ModuleManager::ModuleConstIterator nodes_iterator; 218 219 static ChildIteratorType child_begin(NodeType *Node) { 220 return Node->Imports.begin(); 221 } 222 223 static ChildIteratorType child_end(NodeType *Node) { 224 return Node->Imports.end(); 225 } 226 227 static nodes_iterator nodes_begin(const ModuleManager &Manager) { 228 return Manager.begin(); 229 } 230 231 static nodes_iterator nodes_end(const ModuleManager &Manager) { 232 return Manager.end(); 233 } 234 }; 235 236 template<> 237 struct DOTGraphTraits<ModuleManager> : public DefaultDOTGraphTraits { 238 explicit DOTGraphTraits(bool IsSimple = false) 239 : DefaultDOTGraphTraits(IsSimple) { } 240 241 static bool renderGraphFromBottomUp() { 242 return true; 243 } 244 245 std::string getNodeLabel(ModuleFile *M, const ModuleManager&) { 246 return llvm::sys::path::stem(M->FileName); 247 } 248 }; 249 } 250 251 void ModuleManager::viewGraph() { 252 llvm::ViewGraph(*this, "Modules"); 253 } 254 #endif 255
