[clang] Adopt new FileManager error-returning APIs
[lldb.git] / clang / lib / Serialization / ModuleManager.cpp
1 //===- ModuleManager.cpp - Module Manager ---------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file defines the ModuleManager class, which manages a set of loaded
10 //  modules for the ASTReader.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Serialization/ModuleManager.h"
15 #include "clang/Basic/FileManager.h"
16 #include "clang/Basic/LLVM.h"
17 #include "clang/Lex/HeaderSearch.h"
18 #include "clang/Lex/ModuleMap.h"
19 #include "clang/Serialization/GlobalModuleIndex.h"
20 #include "clang/Serialization/InMemoryModuleCache.h"
21 #include "clang/Serialization/Module.h"
22 #include "clang/Serialization/PCHContainerOperations.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/SetVector.h"
25 #include "llvm/ADT/SmallPtrSet.h"
26 #include "llvm/ADT/SmallVector.h"
27 #include "llvm/ADT/StringRef.h"
28 #include "llvm/ADT/iterator.h"
29 #include "llvm/Support/Chrono.h"
30 #include "llvm/Support/DOTGraphTraits.h"
31 #include "llvm/Support/ErrorOr.h"
32 #include "llvm/Support/GraphWriter.h"
33 #include "llvm/Support/MemoryBuffer.h"
34 #include "llvm/Support/VirtualFileSystem.h"
35 #include <algorithm>
36 #include <cassert>
37 #include <memory>
38 #include <string>
39 #include <system_error>
40
41 using namespace clang;
42 using namespace serialization;
43
44 ModuleFile *ModuleManager::lookupByFileName(StringRef Name) const {
45   auto Entry = FileMgr.getFile(Name, /*OpenFile=*/false,
46                                /*CacheFailure=*/false);
47   if (Entry)
48     return lookup(*Entry);
49
50   return nullptr;
51 }
52
53 ModuleFile *ModuleManager::lookupByModuleName(StringRef Name) const {
54   if (const Module *Mod = HeaderSearchInfo.getModuleMap().findModule(Name))
55     if (const FileEntry *File = Mod->getASTFile())
56       return lookup(File);
57
58   return nullptr;
59 }
60
61 ModuleFile *ModuleManager::lookup(const FileEntry *File) const {
62   auto Known = Modules.find(File);
63   if (Known == Modules.end())
64     return nullptr;
65
66   return Known->second;
67 }
68
69 std::unique_ptr<llvm::MemoryBuffer>
70 ModuleManager::lookupBuffer(StringRef Name) {
71   auto Entry = FileMgr.getFile(Name, /*OpenFile=*/false,
72                                /*CacheFailure=*/false);
73   if (!Entry)
74     return nullptr;
75   return std::move(InMemoryBuffers[*Entry]);
76 }
77
78 static bool checkSignature(ASTFileSignature Signature,
79                            ASTFileSignature ExpectedSignature,
80                            std::string &ErrorStr) {
81   if (!ExpectedSignature || Signature == ExpectedSignature)
82     return false;
83
84   ErrorStr =
85       Signature ? "signature mismatch" : "could not read module signature";
86   return true;
87 }
88
89 static void updateModuleImports(ModuleFile &MF, ModuleFile *ImportedBy,
90                                 SourceLocation ImportLoc) {
91   if (ImportedBy) {
92     MF.ImportedBy.insert(ImportedBy);
93     ImportedBy->Imports.insert(&MF);
94   } else {
95     if (!MF.DirectlyImported)
96       MF.ImportLoc = ImportLoc;
97
98     MF.DirectlyImported = true;
99   }
100 }
101
102 ModuleManager::AddModuleResult
103 ModuleManager::addModule(StringRef FileName, ModuleKind Type,
104                          SourceLocation ImportLoc, ModuleFile *ImportedBy,
105                          unsigned Generation,
106                          off_t ExpectedSize, time_t ExpectedModTime,
107                          ASTFileSignature ExpectedSignature,
108                          ASTFileSignatureReader ReadSignature,
109                          ModuleFile *&Module,
110                          std::string &ErrorStr) {
111   Module = nullptr;
112
113   // Look for the file entry. This only fails if the expected size or
114   // modification time differ.
115   const FileEntry *Entry;
116   if (Type == MK_ExplicitModule || Type == MK_PrebuiltModule) {
117     // If we're not expecting to pull this file out of the module cache, it
118     // might have a different mtime due to being moved across filesystems in
119     // a distributed build. The size must still match, though. (As must the
120     // contents, but we can't check that.)
121     ExpectedModTime = 0;
122   }
123   // Note: ExpectedSize and ExpectedModTime will be 0 for MK_ImplicitModule
124   // when using an ASTFileSignature.
125   if (lookupModuleFile(FileName, ExpectedSize, ExpectedModTime, Entry)) {
126     ErrorStr = "module file out of date";
127     return OutOfDate;
128   }
129
130   if (!Entry && FileName != "-") {
131     ErrorStr = "module file not found";
132     return Missing;
133   }
134
135   // Check whether we already loaded this module, before
136   if (ModuleFile *ModuleEntry = Modules.lookup(Entry)) {
137     // Check the stored signature.
138     if (checkSignature(ModuleEntry->Signature, ExpectedSignature, ErrorStr))
139       return OutOfDate;
140
141     Module = ModuleEntry;
142     updateModuleImports(*ModuleEntry, ImportedBy, ImportLoc);
143     return AlreadyLoaded;
144   }
145
146   // Allocate a new module.
147   auto NewModule = llvm::make_unique<ModuleFile>(Type, Generation);
148   NewModule->Index = Chain.size();
149   NewModule->FileName = FileName.str();
150   NewModule->File = Entry;
151   NewModule->ImportLoc = ImportLoc;
152   NewModule->InputFilesValidationTimestamp = 0;
153
154   if (NewModule->Kind == MK_ImplicitModule) {
155     std::string TimestampFilename = NewModule->getTimestampFilename();
156     llvm::vfs::Status Status;
157     // A cached stat value would be fine as well.
158     if (!FileMgr.getNoncachedStatValue(TimestampFilename, Status))
159       NewModule->InputFilesValidationTimestamp =
160           llvm::sys::toTimeT(Status.getLastModificationTime());
161   }
162
163   // Load the contents of the module
164   if (std::unique_ptr<llvm::MemoryBuffer> Buffer = lookupBuffer(FileName)) {
165     // The buffer was already provided for us.
166     NewModule->Buffer = &ModuleCache->addBuiltPCM(FileName, std::move(Buffer));
167     // Since the cached buffer is reused, it is safe to close the file
168     // descriptor that was opened while stat()ing the PCM in
169     // lookupModuleFile() above, it won't be needed any longer.
170     Entry->closeFile();
171   } else if (llvm::MemoryBuffer *Buffer =
172                  getModuleCache().lookupPCM(FileName)) {
173     NewModule->Buffer = Buffer;
174     // As above, the file descriptor is no longer needed.
175     Entry->closeFile();
176   } else if (getModuleCache().shouldBuildPCM(FileName)) {
177     // Report that the module is out of date, since we tried (and failed) to
178     // import it earlier.
179     Entry->closeFile();
180     return OutOfDate;
181   } else {
182     // Open the AST file.
183     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buf((std::error_code()));
184     if (FileName == "-") {
185       Buf = llvm::MemoryBuffer::getSTDIN();
186     } else {
187       // Get a buffer of the file and close the file descriptor when done.
188       Buf = FileMgr.getBufferForFile(NewModule->File,
189                                      /*isVolatile=*/false,
190                                      /*ShouldClose=*/true);
191     }
192
193     if (!Buf) {
194       ErrorStr = Buf.getError().message();
195       return Missing;
196     }
197
198     NewModule->Buffer = &getModuleCache().addPCM(FileName, std::move(*Buf));
199   }
200
201   // Initialize the stream.
202   NewModule->Data = PCHContainerRdr.ExtractPCH(*NewModule->Buffer);
203
204   // Read the signature eagerly now so that we can check it.  Avoid calling
205   // ReadSignature unless there's something to check though.
206   if (ExpectedSignature && checkSignature(ReadSignature(NewModule->Data),
207                                           ExpectedSignature, ErrorStr)) {
208     // Try to remove the buffer.  If it can't be removed, then it was already
209     // validated by this process.
210     if (!getModuleCache().tryToDropPCM(NewModule->FileName))
211       FileMgr.invalidateCache(NewModule->File);
212     return OutOfDate;
213   }
214
215   // We're keeping this module.  Store it everywhere.
216   Module = Modules[Entry] = NewModule.get();
217
218   updateModuleImports(*NewModule, ImportedBy, ImportLoc);
219
220   if (!NewModule->isModule())
221     PCHChain.push_back(NewModule.get());
222   if (!ImportedBy)
223     Roots.push_back(NewModule.get());
224
225   Chain.push_back(std::move(NewModule));
226   return NewlyLoaded;
227 }
228
229 void ModuleManager::removeModules(
230     ModuleIterator First,
231     llvm::SmallPtrSetImpl<ModuleFile *> &LoadedSuccessfully,
232     ModuleMap *modMap) {
233   auto Last = end();
234   if (First == Last)
235     return;
236
237   // Explicitly clear VisitOrder since we might not notice it is stale.
238   VisitOrder.clear();
239
240   // Collect the set of module file pointers that we'll be removing.
241   llvm::SmallPtrSet<ModuleFile *, 4> victimSet(
242       (llvm::pointer_iterator<ModuleIterator>(First)),
243       (llvm::pointer_iterator<ModuleIterator>(Last)));
244
245   auto IsVictim = [&](ModuleFile *MF) {
246     return victimSet.count(MF);
247   };
248   // Remove any references to the now-destroyed modules.
249   for (auto I = begin(); I != First; ++I) {
250     I->Imports.remove_if(IsVictim);
251     I->ImportedBy.remove_if(IsVictim);
252   }
253   Roots.erase(std::remove_if(Roots.begin(), Roots.end(), IsVictim),
254               Roots.end());
255
256   // Remove the modules from the PCH chain.
257   for (auto I = First; I != Last; ++I) {
258     if (!I->isModule()) {
259       PCHChain.erase(llvm::find(PCHChain, &*I), PCHChain.end());
260       break;
261     }
262   }
263
264   // Delete the modules and erase them from the various structures.
265   for (ModuleIterator victim = First; victim != Last; ++victim) {
266     Modules.erase(victim->File);
267
268     if (modMap) {
269       StringRef ModuleName = victim->ModuleName;
270       if (Module *mod = modMap->findModule(ModuleName)) {
271         mod->setASTFile(nullptr);
272       }
273     }
274   }
275
276   // Delete the modules.
277   Chain.erase(Chain.begin() + (First - begin()), Chain.end());
278 }
279
280 void
281 ModuleManager::addInMemoryBuffer(StringRef FileName,
282                                  std::unique_ptr<llvm::MemoryBuffer> Buffer) {
283   const FileEntry *Entry =
284       FileMgr.getVirtualFile(FileName, Buffer->getBufferSize(), 0);
285   InMemoryBuffers[Entry] = std::move(Buffer);
286 }
287
288 ModuleManager::VisitState *ModuleManager::allocateVisitState() {
289   // Fast path: if we have a cached state, use it.
290   if (FirstVisitState) {
291     VisitState *Result = FirstVisitState;
292     FirstVisitState = FirstVisitState->NextState;
293     Result->NextState = nullptr;
294     return Result;
295   }
296
297   // Allocate and return a new state.
298   return new VisitState(size());
299 }
300
301 void ModuleManager::returnVisitState(VisitState *State) {
302   assert(State->NextState == nullptr && "Visited state is in list?");
303   State->NextState = FirstVisitState;
304   FirstVisitState = State;
305 }
306
307 void ModuleManager::setGlobalIndex(GlobalModuleIndex *Index) {
308   GlobalIndex = Index;
309   if (!GlobalIndex) {
310     ModulesInCommonWithGlobalIndex.clear();
311     return;
312   }
313
314   // Notify the global module index about all of the modules we've already
315   // loaded.
316   for (ModuleFile &M : *this)
317     if (!GlobalIndex->loadedModuleFile(&M))
318       ModulesInCommonWithGlobalIndex.push_back(&M);
319 }
320
321 void ModuleManager::moduleFileAccepted(ModuleFile *MF) {
322   if (!GlobalIndex || GlobalIndex->loadedModuleFile(MF))
323     return;
324
325   ModulesInCommonWithGlobalIndex.push_back(MF);
326 }
327
328 ModuleManager::ModuleManager(FileManager &FileMgr,
329                              InMemoryModuleCache &ModuleCache,
330                              const PCHContainerReader &PCHContainerRdr,
331                              const HeaderSearch &HeaderSearchInfo)
332     : FileMgr(FileMgr), ModuleCache(&ModuleCache),
333       PCHContainerRdr(PCHContainerRdr), HeaderSearchInfo(HeaderSearchInfo) {}
334
335 ModuleManager::~ModuleManager() { delete FirstVisitState; }
336
337 void ModuleManager::visit(llvm::function_ref<bool(ModuleFile &M)> Visitor,
338                           llvm::SmallPtrSetImpl<ModuleFile *> *ModuleFilesHit) {
339   // If the visitation order vector is the wrong size, recompute the order.
340   if (VisitOrder.size() != Chain.size()) {
341     unsigned N = size();
342     VisitOrder.clear();
343     VisitOrder.reserve(N);
344
345     // Record the number of incoming edges for each module. When we
346     // encounter a module with no incoming edges, push it into the queue
347     // to seed the queue.
348     SmallVector<ModuleFile *, 4> Queue;
349     Queue.reserve(N);
350     llvm::SmallVector<unsigned, 4> UnusedIncomingEdges;
351     UnusedIncomingEdges.resize(size());
352     for (ModuleFile &M : llvm::reverse(*this)) {
353       unsigned Size = M.ImportedBy.size();
354       UnusedIncomingEdges[M.Index] = Size;
355       if (!Size)
356         Queue.push_back(&M);
357     }
358
359     // Traverse the graph, making sure to visit a module before visiting any
360     // of its dependencies.
361     while (!Queue.empty()) {
362       ModuleFile *CurrentModule = Queue.pop_back_val();
363       VisitOrder.push_back(CurrentModule);
364
365       // For any module that this module depends on, push it on the
366       // stack (if it hasn't already been marked as visited).
367       for (auto M = CurrentModule->Imports.rbegin(),
368                 MEnd = CurrentModule->Imports.rend();
369            M != MEnd; ++M) {
370         // Remove our current module as an impediment to visiting the
371         // module we depend on. If we were the last unvisited module
372         // that depends on this particular module, push it into the
373         // queue to be visited.
374         unsigned &NumUnusedEdges = UnusedIncomingEdges[(*M)->Index];
375         if (NumUnusedEdges && (--NumUnusedEdges == 0))
376           Queue.push_back(*M);
377       }
378     }
379
380     assert(VisitOrder.size() == N && "Visitation order is wrong?");
381
382     delete FirstVisitState;
383     FirstVisitState = nullptr;
384   }
385
386   VisitState *State = allocateVisitState();
387   unsigned VisitNumber = State->NextVisitNumber++;
388
389   // If the caller has provided us with a hit-set that came from the global
390   // module index, mark every module file in common with the global module
391   // index that is *not* in that set as 'visited'.
392   if (ModuleFilesHit && !ModulesInCommonWithGlobalIndex.empty()) {
393     for (unsigned I = 0, N = ModulesInCommonWithGlobalIndex.size(); I != N; ++I)
394     {
395       ModuleFile *M = ModulesInCommonWithGlobalIndex[I];
396       if (!ModuleFilesHit->count(M))
397         State->VisitNumber[M->Index] = VisitNumber;
398     }
399   }
400
401   for (unsigned I = 0, N = VisitOrder.size(); I != N; ++I) {
402     ModuleFile *CurrentModule = VisitOrder[I];
403     // Should we skip this module file?
404     if (State->VisitNumber[CurrentModule->Index] == VisitNumber)
405       continue;
406
407     // Visit the module.
408     assert(State->VisitNumber[CurrentModule->Index] == VisitNumber - 1);
409     State->VisitNumber[CurrentModule->Index] = VisitNumber;
410     if (!Visitor(*CurrentModule))
411       continue;
412
413     // The visitor has requested that cut off visitation of any
414     // module that the current module depends on. To indicate this
415     // behavior, we mark all of the reachable modules as having been visited.
416     ModuleFile *NextModule = CurrentModule;
417     do {
418       // For any module that this module depends on, push it on the
419       // stack (if it hasn't already been marked as visited).
420       for (llvm::SetVector<ModuleFile *>::iterator
421              M = NextModule->Imports.begin(),
422              MEnd = NextModule->Imports.end();
423            M != MEnd; ++M) {
424         if (State->VisitNumber[(*M)->Index] != VisitNumber) {
425           State->Stack.push_back(*M);
426           State->VisitNumber[(*M)->Index] = VisitNumber;
427         }
428       }
429
430       if (State->Stack.empty())
431         break;
432
433       // Pop the next module off the stack.
434       NextModule = State->Stack.pop_back_val();
435     } while (true);
436   }
437
438   returnVisitState(State);
439 }
440
441 bool ModuleManager::lookupModuleFile(StringRef FileName,
442                                      off_t ExpectedSize,
443                                      time_t ExpectedModTime,
444                                      const FileEntry *&File) {
445   if (FileName == "-") {
446     File = nullptr;
447     return false;
448   }
449
450   // Open the file immediately to ensure there is no race between stat'ing and
451   // opening the file.
452   auto FileOrErr = FileMgr.getFile(FileName, /*OpenFile=*/true, 
453                                    /*CacheFailure=*/false);
454   if (!FileOrErr) {
455     File = nullptr;
456     return false;
457   }
458   File = *FileOrErr;
459
460   if ((ExpectedSize && ExpectedSize != File->getSize()) ||
461       (ExpectedModTime && ExpectedModTime != File->getModificationTime()))
462     // Do not destroy File, as it may be referenced. If we need to rebuild it,
463     // it will be destroyed by removeModules.
464     return true;
465
466   return false;
467 }
468
469 #ifndef NDEBUG
470 namespace llvm {
471
472   template<>
473   struct GraphTraits<ModuleManager> {
474     using NodeRef = ModuleFile *;
475     using ChildIteratorType = llvm::SetVector<ModuleFile *>::const_iterator;
476     using nodes_iterator = pointer_iterator<ModuleManager::ModuleConstIterator>;
477
478     static ChildIteratorType child_begin(NodeRef Node) {
479       return Node->Imports.begin();
480     }
481
482     static ChildIteratorType child_end(NodeRef Node) {
483       return Node->Imports.end();
484     }
485
486     static nodes_iterator nodes_begin(const ModuleManager &Manager) {
487       return nodes_iterator(Manager.begin());
488     }
489
490     static nodes_iterator nodes_end(const ModuleManager &Manager) {
491       return nodes_iterator(Manager.end());
492     }
493   };
494
495   template<>
496   struct DOTGraphTraits<ModuleManager> : public DefaultDOTGraphTraits {
497     explicit DOTGraphTraits(bool IsSimple = false)
498         : DefaultDOTGraphTraits(IsSimple) {}
499
500     static bool renderGraphFromBottomUp() { return true; }
501
502     std::string getNodeLabel(ModuleFile *M, const ModuleManager&) {
503       return M->ModuleName;
504     }
505   };
506
507 } // namespace llvm
508
509 void ModuleManager::viewGraph() {
510   llvm::ViewGraph(*this, "Modules");
511 }
512 #endif