blob: 9c4b3d92befef64c4a1d71808751be5bf867f270 [file] [log] [blame]
Douglas Gregor98339b92011-08-25 20:47:51 +00001//===--- 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//===----------------------------------------------------------------------===//
Douglas Gregor677e15f2013-03-19 00:28:20 +000014#include "clang/Lex/ModuleMap.h"
Douglas Gregor188bdcd2013-01-25 23:32:03 +000015#include "clang/Serialization/GlobalModuleIndex.h"
Benjamin Kramerae0cdff2013-08-24 13:16:22 +000016#include "clang/Serialization/ModuleManager.h"
Douglas Gregor98339b92011-08-25 20:47:51 +000017#include "llvm/Support/MemoryBuffer.h"
Rafael Espindola8229d222013-06-11 22:15:02 +000018#include "llvm/Support/Path.h"
Douglas Gregor98339b92011-08-25 20:47:51 +000019#include "llvm/Support/raw_ostream.h"
20#include "llvm/Support/system_error.h"
21
Douglas Gregor2492c892011-10-11 19:27:55 +000022#ifndef NDEBUG
23#include "llvm/Support/GraphWriter.h"
24#endif
25
Douglas Gregor98339b92011-08-25 20:47:51 +000026using namespace clang;
27using namespace serialization;
28
Douglas Gregor1a4761e2011-11-30 23:21:26 +000029ModuleFile *ModuleManager::lookup(StringRef Name) {
Douglas Gregorea14a872013-02-08 21:27:45 +000030 const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false,
31 /*cacheFailure=*/false);
Douglas Gregorc544ba02013-03-27 16:47:18 +000032 if (Entry)
33 return lookup(Entry);
34
35 return 0;
36}
37
38ModuleFile *ModuleManager::lookup(const FileEntry *File) {
39 llvm::DenseMap<const FileEntry *, ModuleFile *>::iterator Known
40 = Modules.find(File);
41 if (Known == Modules.end())
42 return 0;
43
44 return Known->second;
Douglas Gregor98339b92011-08-25 20:47:51 +000045}
46
47llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) {
Douglas Gregorea14a872013-02-08 21:27:45 +000048 const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false,
49 /*cacheFailure=*/false);
Douglas Gregor98339b92011-08-25 20:47:51 +000050 return InMemoryBuffers[Entry];
51}
52
Douglas Gregor677e15f2013-03-19 00:28:20 +000053ModuleManager::AddModuleResult
Douglas Gregor87e2cfc2012-11-30 19:28:05 +000054ModuleManager::addModule(StringRef FileName, ModuleKind Type,
55 SourceLocation ImportLoc, ModuleFile *ImportedBy,
Douglas Gregor677e15f2013-03-19 00:28:20 +000056 unsigned Generation,
57 off_t ExpectedSize, time_t ExpectedModTime,
58 ModuleFile *&Module,
59 std::string &ErrorStr) {
60 Module = 0;
61
62 // Look for the file entry. This only fails if the expected size or
63 // modification time differ.
64 const FileEntry *Entry;
Eli Friedmanedadb9a2013-09-05 23:50:58 +000065 if (lookupModuleFile(FileName, ExpectedSize, ExpectedModTime, Entry)) {
66 ErrorStr = "module file out of date";
Douglas Gregor677e15f2013-03-19 00:28:20 +000067 return OutOfDate;
Eli Friedmanedadb9a2013-09-05 23:50:58 +000068 }
Douglas Gregor677e15f2013-03-19 00:28:20 +000069
Douglas Gregor98339b92011-08-25 20:47:51 +000070 if (!Entry && FileName != "-") {
Eli Friedmanedadb9a2013-09-05 23:50:58 +000071 ErrorStr = "module file not found";
Douglas Gregor677e15f2013-03-19 00:28:20 +000072 return Missing;
Douglas Gregor98339b92011-08-25 20:47:51 +000073 }
Douglas Gregor677e15f2013-03-19 00:28:20 +000074
75 // Check whether we already loaded this module, before
Douglas Gregor1a4761e2011-11-30 23:21:26 +000076 ModuleFile *&ModuleEntry = Modules[Entry];
Douglas Gregor98339b92011-08-25 20:47:51 +000077 bool NewModule = false;
78 if (!ModuleEntry) {
79 // Allocate a new module.
Douglas Gregor057df202012-01-18 20:56:22 +000080 ModuleFile *New = new ModuleFile(Type, Generation);
Douglas Gregorcc71dbe2013-01-21 20:07:12 +000081 New->Index = Chain.size();
Douglas Gregor98339b92011-08-25 20:47:51 +000082 New->FileName = FileName.str();
Argyrios Kyrtzidisd64c26f2012-10-03 01:58:42 +000083 New->File = Entry;
Douglas Gregor87e2cfc2012-11-30 19:28:05 +000084 New->ImportLoc = ImportLoc;
Douglas Gregor98339b92011-08-25 20:47:51 +000085 Chain.push_back(New);
86 NewModule = true;
87 ModuleEntry = New;
Douglas Gregor87e2cfc2012-11-30 19:28:05 +000088
Douglas Gregor98339b92011-08-25 20:47:51 +000089 // Load the contents of the module
90 if (llvm::MemoryBuffer *Buffer = lookupBuffer(FileName)) {
91 // The buffer was already provided for us.
92 assert(Buffer && "Passed null buffer");
93 New->Buffer.reset(Buffer);
94 } else {
95 // Open the AST file.
96 llvm::error_code ec;
97 if (FileName == "-") {
98 ec = llvm::MemoryBuffer::getSTDIN(New->Buffer);
99 if (ec)
100 ErrorStr = ec.message();
101 } else
102 New->Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrorStr));
103
104 if (!New->Buffer)
Douglas Gregor677e15f2013-03-19 00:28:20 +0000105 return Missing;
Douglas Gregor98339b92011-08-25 20:47:51 +0000106 }
107
108 // Initialize the stream
109 New->StreamFile.init((const unsigned char *)New->Buffer->getBufferStart(),
Douglas Gregor677e15f2013-03-19 00:28:20 +0000110 (const unsigned char *)New->Buffer->getBufferEnd());
Douglas Gregor677e15f2013-03-19 00:28:20 +0000111 }
Douglas Gregor98339b92011-08-25 20:47:51 +0000112
113 if (ImportedBy) {
114 ModuleEntry->ImportedBy.insert(ImportedBy);
115 ImportedBy->Imports.insert(ModuleEntry);
116 } else {
Douglas Gregor87e2cfc2012-11-30 19:28:05 +0000117 if (!ModuleEntry->DirectlyImported)
118 ModuleEntry->ImportLoc = ImportLoc;
119
Douglas Gregor98339b92011-08-25 20:47:51 +0000120 ModuleEntry->DirectlyImported = true;
121 }
Douglas Gregor677e15f2013-03-19 00:28:20 +0000122
123 Module = ModuleEntry;
124 return NewModule? NewlyLoaded : AlreadyLoaded;
Douglas Gregor98339b92011-08-25 20:47:51 +0000125}
126
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000127namespace {
128 /// \brief Predicate that checks whether a module file occurs within
129 /// the given set.
130 class IsInModuleFileSet : public std::unary_function<ModuleFile *, bool> {
131 llvm::SmallPtrSet<ModuleFile *, 4> &Removed;
132
133 public:
134 IsInModuleFileSet(llvm::SmallPtrSet<ModuleFile *, 4> &Removed)
135 : Removed(Removed) { }
136
137 bool operator()(ModuleFile *MF) const {
138 return Removed.count(MF);
139 }
140 };
141}
142
Douglas Gregor677e15f2013-03-19 00:28:20 +0000143void ModuleManager::removeModules(ModuleIterator first, ModuleIterator last,
144 ModuleMap *modMap) {
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000145 if (first == last)
146 return;
147
148 // Collect the set of module file pointers that we'll be removing.
149 llvm::SmallPtrSet<ModuleFile *, 4> victimSet(first, last);
150
151 // Remove any references to the now-destroyed modules.
152 IsInModuleFileSet checkInSet(victimSet);
153 for (unsigned i = 0, n = Chain.size(); i != n; ++i) {
154 Chain[i]->ImportedBy.remove_if(checkInSet);
155 }
156
157 // Delete the modules and erase them from the various structures.
158 for (ModuleIterator victim = first; victim != last; ++victim) {
159 Modules.erase((*victim)->File);
Douglas Gregor677e15f2013-03-19 00:28:20 +0000160
161 FileMgr.invalidateCache((*victim)->File);
162 if (modMap) {
163 StringRef ModuleName = llvm::sys::path::stem((*victim)->FileName);
164 if (Module *mod = modMap->findModule(ModuleName)) {
165 mod->setASTFile(0);
166 }
167 }
Douglas Gregor7cdd2812012-11-07 17:46:15 +0000168 delete *victim;
169 }
170
171 // Remove the modules from the chain.
172 Chain.erase(first, last);
173}
174
Douglas Gregor98339b92011-08-25 20:47:51 +0000175void ModuleManager::addInMemoryBuffer(StringRef FileName,
176 llvm::MemoryBuffer *Buffer) {
177
178 const FileEntry *Entry = FileMgr.getVirtualFile(FileName,
179 Buffer->getBufferSize(), 0);
180 InMemoryBuffers[Entry] = Buffer;
181}
182
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000183ModuleManager::VisitState *ModuleManager::allocateVisitState() {
184 // Fast path: if we have a cached state, use it.
185 if (FirstVisitState) {
186 VisitState *Result = FirstVisitState;
187 FirstVisitState = FirstVisitState->NextState;
188 Result->NextState = 0;
189 return Result;
190 }
191
192 // Allocate and return a new state.
193 return new VisitState(size());
194}
195
196void ModuleManager::returnVisitState(VisitState *State) {
197 assert(State->NextState == 0 && "Visited state is in list?");
198 State->NextState = FirstVisitState;
199 FirstVisitState = State;
200}
201
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000202void ModuleManager::setGlobalIndex(GlobalModuleIndex *Index) {
203 GlobalIndex = Index;
Douglas Gregorfa69fc12013-03-22 18:50:14 +0000204 if (!GlobalIndex) {
205 ModulesInCommonWithGlobalIndex.clear();
206 return;
Douglas Gregor677e15f2013-03-19 00:28:20 +0000207 }
Douglas Gregorfa69fc12013-03-22 18:50:14 +0000208
209 // Notify the global module index about all of the modules we've already
210 // loaded.
211 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
212 if (!GlobalIndex->loadedModuleFile(Chain[I])) {
213 ModulesInCommonWithGlobalIndex.push_back(Chain[I]);
214 }
215 }
216}
217
218void ModuleManager::moduleFileAccepted(ModuleFile *MF) {
219 if (!GlobalIndex || GlobalIndex->loadedModuleFile(MF))
220 return;
221
222 ModulesInCommonWithGlobalIndex.push_back(MF);
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000223}
224
225ModuleManager::ModuleManager(FileManager &FileMgr)
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000226 : FileMgr(FileMgr), GlobalIndex(), FirstVisitState(0) { }
Douglas Gregor98339b92011-08-25 20:47:51 +0000227
228ModuleManager::~ModuleManager() {
229 for (unsigned i = 0, e = Chain.size(); i != e; ++i)
230 delete Chain[e - i - 1];
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000231 delete FirstVisitState;
Douglas Gregor98339b92011-08-25 20:47:51 +0000232}
233
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000234void
235ModuleManager::visit(bool (*Visitor)(ModuleFile &M, void *UserData),
236 void *UserData,
Douglas Gregor677e15f2013-03-19 00:28:20 +0000237 llvm::SmallPtrSet<ModuleFile *, 4> *ModuleFilesHit) {
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000238 // If the visitation order vector is the wrong size, recompute the order.
Douglas Gregord07865b2013-01-25 22:25:23 +0000239 if (VisitOrder.size() != Chain.size()) {
240 unsigned N = size();
241 VisitOrder.clear();
242 VisitOrder.reserve(N);
243
244 // Record the number of incoming edges for each module. When we
245 // encounter a module with no incoming edges, push it into the queue
246 // to seed the queue.
247 SmallVector<ModuleFile *, 4> Queue;
248 Queue.reserve(N);
249 llvm::SmallVector<unsigned, 4> UnusedIncomingEdges;
250 UnusedIncomingEdges.reserve(size());
251 for (ModuleIterator M = begin(), MEnd = end(); M != MEnd; ++M) {
252 if (unsigned Size = (*M)->ImportedBy.size())
253 UnusedIncomingEdges.push_back(Size);
254 else {
255 UnusedIncomingEdges.push_back(0);
256 Queue.push_back(*M);
257 }
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000258 }
Douglas Gregord07865b2013-01-25 22:25:23 +0000259
260 // Traverse the graph, making sure to visit a module before visiting any
261 // of its dependencies.
262 unsigned QueueStart = 0;
263 while (QueueStart < Queue.size()) {
264 ModuleFile *CurrentModule = Queue[QueueStart++];
265 VisitOrder.push_back(CurrentModule);
266
267 // For any module that this module depends on, push it on the
268 // stack (if it hasn't already been marked as visited).
269 for (llvm::SetVector<ModuleFile *>::iterator
270 M = CurrentModule->Imports.begin(),
271 MEnd = CurrentModule->Imports.end();
272 M != MEnd; ++M) {
273 // Remove our current module as an impediment to visiting the
274 // module we depend on. If we were the last unvisited module
275 // that depends on this particular module, push it into the
276 // queue to be visited.
277 unsigned &NumUnusedEdges = UnusedIncomingEdges[(*M)->Index];
278 if (NumUnusedEdges && (--NumUnusedEdges == 0))
279 Queue.push_back(*M);
280 }
281 }
282
283 assert(VisitOrder.size() == N && "Visitation order is wrong?");
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000284
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000285 delete FirstVisitState;
286 FirstVisitState = 0;
Douglas Gregor98339b92011-08-25 20:47:51 +0000287 }
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000288
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000289 VisitState *State = allocateVisitState();
290 unsigned VisitNumber = State->NextVisitNumber++;
Douglas Gregord07865b2013-01-25 22:25:23 +0000291
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000292 // If the caller has provided us with a hit-set that came from the global
293 // module index, mark every module file in common with the global module
294 // index that is *not* in that set as 'visited'.
295 if (ModuleFilesHit && !ModulesInCommonWithGlobalIndex.empty()) {
296 for (unsigned I = 0, N = ModulesInCommonWithGlobalIndex.size(); I != N; ++I)
297 {
298 ModuleFile *M = ModulesInCommonWithGlobalIndex[I];
Douglas Gregor677e15f2013-03-19 00:28:20 +0000299 if (!ModuleFilesHit->count(M))
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000300 State->VisitNumber[M->Index] = VisitNumber;
Douglas Gregor188bdcd2013-01-25 23:32:03 +0000301 }
302 }
303
Douglas Gregord07865b2013-01-25 22:25:23 +0000304 for (unsigned I = 0, N = VisitOrder.size(); I != N; ++I) {
305 ModuleFile *CurrentModule = VisitOrder[I];
306 // Should we skip this module file?
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000307 if (State->VisitNumber[CurrentModule->Index] == VisitNumber)
Douglas Gregor98339b92011-08-25 20:47:51 +0000308 continue;
Douglas Gregord07865b2013-01-25 22:25:23 +0000309
310 // Visit the module.
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000311 assert(State->VisitNumber[CurrentModule->Index] == VisitNumber - 1);
312 State->VisitNumber[CurrentModule->Index] = VisitNumber;
Douglas Gregord07865b2013-01-25 22:25:23 +0000313 if (!Visitor(*CurrentModule, UserData))
314 continue;
315
316 // The visitor has requested that cut off visitation of any
317 // module that the current module depends on. To indicate this
318 // behavior, we mark all of the reachable modules as having been visited.
319 ModuleFile *NextModule = CurrentModule;
Douglas Gregord07865b2013-01-25 22:25:23 +0000320 do {
321 // For any module that this module depends on, push it on the
322 // stack (if it hasn't already been marked as visited).
323 for (llvm::SetVector<ModuleFile *>::iterator
324 M = NextModule->Imports.begin(),
325 MEnd = NextModule->Imports.end();
326 M != MEnd; ++M) {
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000327 if (State->VisitNumber[(*M)->Index] != VisitNumber) {
328 State->Stack.push_back(*M);
329 State->VisitNumber[(*M)->Index] = VisitNumber;
Douglas Gregor98339b92011-08-25 20:47:51 +0000330 }
331 }
Douglas Gregord07865b2013-01-25 22:25:23 +0000332
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000333 if (State->Stack.empty())
Douglas Gregord07865b2013-01-25 22:25:23 +0000334 break;
335
336 // Pop the next module off the stack.
Robert Wilhelm344472e2013-08-23 16:11:15 +0000337 NextModule = State->Stack.pop_back_val();
Douglas Gregord07865b2013-01-25 22:25:23 +0000338 } while (true);
Douglas Gregor98339b92011-08-25 20:47:51 +0000339 }
Douglas Gregord3cf5fb2013-01-28 16:46:33 +0000340
341 returnVisitState(State);
Douglas Gregor98339b92011-08-25 20:47:51 +0000342}
343
344/// \brief Perform a depth-first visit of the current module.
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000345static bool visitDepthFirst(ModuleFile &M,
346 bool (*Visitor)(ModuleFile &M, bool Preorder,
Douglas Gregor98339b92011-08-25 20:47:51 +0000347 void *UserData),
348 void *UserData,
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000349 SmallVectorImpl<bool> &Visited) {
Douglas Gregor98339b92011-08-25 20:47:51 +0000350 // Preorder visitation
351 if (Visitor(M, /*Preorder=*/true, UserData))
352 return true;
353
354 // Visit children
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000355 for (llvm::SetVector<ModuleFile *>::iterator IM = M.Imports.begin(),
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000356 IMEnd = M.Imports.end();
Douglas Gregor98339b92011-08-25 20:47:51 +0000357 IM != IMEnd; ++IM) {
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000358 if (Visited[(*IM)->Index])
Douglas Gregor98339b92011-08-25 20:47:51 +0000359 continue;
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000360 Visited[(*IM)->Index] = true;
361
Douglas Gregor98339b92011-08-25 20:47:51 +0000362 if (visitDepthFirst(**IM, Visitor, UserData, Visited))
363 return true;
364 }
365
366 // Postorder visitation
367 return Visitor(M, /*Preorder=*/false, UserData);
368}
369
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000370void ModuleManager::visitDepthFirst(bool (*Visitor)(ModuleFile &M, bool Preorder,
Douglas Gregor98339b92011-08-25 20:47:51 +0000371 void *UserData),
372 void *UserData) {
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000373 SmallVector<bool, 16> Visited(size(), false);
Douglas Gregor98339b92011-08-25 20:47:51 +0000374 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000375 if (Visited[Chain[I]->Index])
Douglas Gregor98339b92011-08-25 20:47:51 +0000376 continue;
Douglas Gregorcc71dbe2013-01-21 20:07:12 +0000377 Visited[Chain[I]->Index] = true;
378
Douglas Gregor98339b92011-08-25 20:47:51 +0000379 if (::visitDepthFirst(*Chain[I], Visitor, UserData, Visited))
380 return;
381 }
382}
Douglas Gregor2492c892011-10-11 19:27:55 +0000383
Douglas Gregor677e15f2013-03-19 00:28:20 +0000384bool ModuleManager::lookupModuleFile(StringRef FileName,
385 off_t ExpectedSize,
386 time_t ExpectedModTime,
387 const FileEntry *&File) {
388 File = FileMgr.getFile(FileName, /*openFile=*/false, /*cacheFailure=*/false);
389
390 if (!File && FileName != "-") {
391 return false;
392 }
393
394 if ((ExpectedSize && ExpectedSize != File->getSize()) ||
395 (ExpectedModTime && ExpectedModTime != File->getModificationTime())) {
396 return true;
397 }
398
399 return false;
400}
401
Douglas Gregor2492c892011-10-11 19:27:55 +0000402#ifndef NDEBUG
403namespace llvm {
404 template<>
405 struct GraphTraits<ModuleManager> {
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000406 typedef ModuleFile NodeType;
407 typedef llvm::SetVector<ModuleFile *>::const_iterator ChildIteratorType;
Douglas Gregor2492c892011-10-11 19:27:55 +0000408 typedef ModuleManager::ModuleConstIterator nodes_iterator;
409
410 static ChildIteratorType child_begin(NodeType *Node) {
411 return Node->Imports.begin();
412 }
413
414 static ChildIteratorType child_end(NodeType *Node) {
415 return Node->Imports.end();
416 }
417
418 static nodes_iterator nodes_begin(const ModuleManager &Manager) {
419 return Manager.begin();
420 }
421
422 static nodes_iterator nodes_end(const ModuleManager &Manager) {
423 return Manager.end();
424 }
425 };
426
427 template<>
428 struct DOTGraphTraits<ModuleManager> : public DefaultDOTGraphTraits {
429 explicit DOTGraphTraits(bool IsSimple = false)
430 : DefaultDOTGraphTraits(IsSimple) { }
431
432 static bool renderGraphFromBottomUp() {
433 return true;
434 }
435
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000436 std::string getNodeLabel(ModuleFile *M, const ModuleManager&) {
Douglas Gregor2492c892011-10-11 19:27:55 +0000437 return llvm::sys::path::stem(M->FileName);
438 }
439 };
440}
441
442void ModuleManager::viewGraph() {
443 llvm::ViewGraph(*this, "Modules");
444}
445#endif