1 //===--- Module.cpp - Describe a module -----------------------------------===//
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 Module class, which describes a module in the source
11 // code.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Basic/Module.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Basic/LangOptions.h"
18 #include "clang/Basic/TargetInfo.h"
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringSwitch.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Support/raw_ostream.h"
24 
25 using namespace clang;
26 
27 Module::Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent,
28                bool IsFramework, bool IsExplicit, unsigned VisibilityID)
29     : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent), Directory(),
30       Umbrella(), ASTFile(nullptr), VisibilityID(VisibilityID),
31       IsMissingRequirement(false), HasIncompatibleModuleFile(false),
32       IsAvailable(true), IsFromModuleFile(false), IsFramework(IsFramework),
33       IsExplicit(IsExplicit), IsSystem(false), IsExternC(false),
34       IsInferred(false), InferSubmodules(false), InferExplicitSubmodules(false),
35       InferExportWildcard(false), ConfigMacrosExhaustive(false),
36       NoUndeclaredIncludes(false), NameVisibility(Hidden) {
37   if (Parent) {
38     if (!Parent->isAvailable())
39       IsAvailable = false;
40     if (Parent->IsSystem)
41       IsSystem = true;
42     if (Parent->IsExternC)
43       IsExternC = true;
44     if (Parent->NoUndeclaredIncludes)
45       NoUndeclaredIncludes = true;
46     IsMissingRequirement = Parent->IsMissingRequirement;
47 
48     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
49     Parent->SubModules.push_back(this);
50   }
51 }
52 
53 Module::~Module() {
54   for (submodule_iterator I = submodule_begin(), IEnd = submodule_end();
55        I != IEnd; ++I) {
56     delete *I;
57   }
58 }
59 
60 /// \brief Determine whether a translation unit built using the current
61 /// language options has the given feature.
62 static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
63                        const TargetInfo &Target) {
64   bool HasFeature = llvm::StringSwitch<bool>(Feature)
65                         .Case("altivec", LangOpts.AltiVec)
66                         .Case("blocks", LangOpts.Blocks)
67                         .Case("cplusplus", LangOpts.CPlusPlus)
68                         .Case("cplusplus11", LangOpts.CPlusPlus11)
69                         .Case("freestanding", LangOpts.Freestanding)
70                         .Case("gnuinlineasm", LangOpts.GNUAsm)
71                         .Case("objc", LangOpts.ObjC1)
72                         .Case("objc_arc", LangOpts.ObjCAutoRefCount)
73                         .Case("opencl", LangOpts.OpenCL)
74                         .Case("tls", Target.isTLSSupported())
75                         .Case("zvector", LangOpts.ZVector)
76                         .Default(Target.hasFeature(Feature));
77   if (!HasFeature)
78     HasFeature = std::find(LangOpts.ModuleFeatures.begin(),
79                            LangOpts.ModuleFeatures.end(),
80                            Feature) != LangOpts.ModuleFeatures.end();
81   return HasFeature;
82 }
83 
84 bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
85                          Requirement &Req,
86                          UnresolvedHeaderDirective &MissingHeader) const {
87   if (IsAvailable)
88     return true;
89 
90   for (const Module *Current = this; Current; Current = Current->Parent) {
91     for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
92       if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
93               Current->Requirements[I].second) {
94         Req = Current->Requirements[I];
95         return false;
96       }
97     }
98     if (!Current->MissingHeaders.empty()) {
99       MissingHeader = Current->MissingHeaders.front();
100       return false;
101     }
102   }
103 
104   llvm_unreachable("could not find a reason why module is unavailable");
105 }
106 
107 bool Module::isSubModuleOf(const Module *Other) const {
108   const Module *This = this;
109   do {
110     if (This == Other)
111       return true;
112 
113     This = This->Parent;
114   } while (This);
115 
116   return false;
117 }
118 
119 const Module *Module::getTopLevelModule() const {
120   const Module *Result = this;
121   while (Result->Parent)
122     Result = Result->Parent;
123 
124   return Result;
125 }
126 
127 std::string Module::getFullModuleName() const {
128   SmallVector<StringRef, 2> Names;
129 
130   // Build up the set of module names (from innermost to outermost).
131   for (const Module *M = this; M; M = M->Parent)
132     Names.push_back(M->Name);
133 
134   std::string Result;
135   for (SmallVectorImpl<StringRef>::reverse_iterator I = Names.rbegin(),
136                                                  IEnd = Names.rend();
137        I != IEnd; ++I) {
138     if (!Result.empty())
139       Result += '.';
140 
141     Result += *I;
142   }
143 
144   return Result;
145 }
146 
147 bool Module::fullModuleNameIs(ArrayRef<StringRef> nameParts) const {
148   for (const Module *M = this; M; M = M->Parent) {
149     if (nameParts.empty() || M->Name != nameParts.back())
150       return false;
151     nameParts = nameParts.drop_back();
152   }
153   return nameParts.empty();
154 }
155 
156 Module::DirectoryName Module::getUmbrellaDir() const {
157   if (Header U = getUmbrellaHeader())
158     return {"", U.Entry->getDir()};
159 
160   return {UmbrellaAsWritten, Umbrella.dyn_cast<const DirectoryEntry *>()};
161 }
162 
163 ArrayRef<const FileEntry *> Module::getTopHeaders(FileManager &FileMgr) {
164   if (!TopHeaderNames.empty()) {
165     for (std::vector<std::string>::iterator
166            I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
167       if (const FileEntry *FE = FileMgr.getFile(*I))
168         TopHeaders.insert(FE);
169     }
170     TopHeaderNames.clear();
171   }
172 
173   return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end());
174 }
175 
176 bool Module::directlyUses(const Module *Requested) const {
177   auto *Top = getTopLevelModule();
178 
179   // A top-level module implicitly uses itself.
180   if (Requested->isSubModuleOf(Top))
181     return true;
182 
183   for (auto *Use : Top->DirectUses)
184     if (Requested->isSubModuleOf(Use))
185       return true;
186 
187   // Anyone is allowed to use our builtin stddef.h and its accompanying module.
188   if (!Requested->Parent && Requested->Name == "_Builtin_stddef_max_align_t")
189     return true;
190 
191   return false;
192 }
193 
194 void Module::addRequirement(StringRef Feature, bool RequiredState,
195                             const LangOptions &LangOpts,
196                             const TargetInfo &Target) {
197   Requirements.push_back(Requirement(Feature, RequiredState));
198 
199   // If this feature is currently available, we're done.
200   if (hasFeature(Feature, LangOpts, Target) == RequiredState)
201     return;
202 
203   markUnavailable(/*MissingRequirement*/true);
204 }
205 
206 void Module::markUnavailable(bool MissingRequirement) {
207   auto needUpdate = [MissingRequirement](Module *M) {
208     return M->IsAvailable || (!M->IsMissingRequirement && MissingRequirement);
209   };
210 
211   if (!needUpdate(this))
212     return;
213 
214   SmallVector<Module *, 2> Stack;
215   Stack.push_back(this);
216   while (!Stack.empty()) {
217     Module *Current = Stack.back();
218     Stack.pop_back();
219 
220     if (!needUpdate(Current))
221       continue;
222 
223     Current->IsAvailable = false;
224     Current->IsMissingRequirement |= MissingRequirement;
225     for (submodule_iterator Sub = Current->submodule_begin(),
226                          SubEnd = Current->submodule_end();
227          Sub != SubEnd; ++Sub) {
228       if (needUpdate(*Sub))
229         Stack.push_back(*Sub);
230     }
231   }
232 }
233 
234 Module *Module::findSubmodule(StringRef Name) const {
235   llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
236   if (Pos == SubModuleIndex.end())
237     return nullptr;
238 
239   return SubModules[Pos->getValue()];
240 }
241 
242 static void printModuleId(raw_ostream &OS, const ModuleId &Id) {
243   for (unsigned I = 0, N = Id.size(); I != N; ++I) {
244     if (I)
245       OS << ".";
246     OS << Id[I].first;
247   }
248 }
249 
250 void Module::getExportedModules(SmallVectorImpl<Module *> &Exported) const {
251   // All non-explicit submodules are exported.
252   for (std::vector<Module *>::const_iterator I = SubModules.begin(),
253                                              E = SubModules.end();
254        I != E; ++I) {
255     Module *Mod = *I;
256     if (!Mod->IsExplicit)
257       Exported.push_back(Mod);
258   }
259 
260   // Find re-exported modules by filtering the list of imported modules.
261   bool AnyWildcard = false;
262   bool UnrestrictedWildcard = false;
263   SmallVector<Module *, 4> WildcardRestrictions;
264   for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
265     Module *Mod = Exports[I].getPointer();
266     if (!Exports[I].getInt()) {
267       // Export a named module directly; no wildcards involved.
268       Exported.push_back(Mod);
269 
270       continue;
271     }
272 
273     // Wildcard export: export all of the imported modules that match
274     // the given pattern.
275     AnyWildcard = true;
276     if (UnrestrictedWildcard)
277       continue;
278 
279     if (Module *Restriction = Exports[I].getPointer())
280       WildcardRestrictions.push_back(Restriction);
281     else {
282       WildcardRestrictions.clear();
283       UnrestrictedWildcard = true;
284     }
285   }
286 
287   // If there were any wildcards, push any imported modules that were
288   // re-exported by the wildcard restriction.
289   if (!AnyWildcard)
290     return;
291 
292   for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
293     Module *Mod = Imports[I];
294     bool Acceptable = UnrestrictedWildcard;
295     if (!Acceptable) {
296       // Check whether this module meets one of the restrictions.
297       for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
298         Module *Restriction = WildcardRestrictions[R];
299         if (Mod == Restriction || Mod->isSubModuleOf(Restriction)) {
300           Acceptable = true;
301           break;
302         }
303       }
304     }
305 
306     if (!Acceptable)
307       continue;
308 
309     Exported.push_back(Mod);
310   }
311 }
312 
313 void Module::buildVisibleModulesCache() const {
314   assert(VisibleModulesCache.empty() && "cache does not need building");
315 
316   // This module is visible to itself.
317   VisibleModulesCache.insert(this);
318 
319   // Every imported module is visible.
320   SmallVector<Module *, 16> Stack(Imports.begin(), Imports.end());
321   while (!Stack.empty()) {
322     Module *CurrModule = Stack.pop_back_val();
323 
324     // Every module transitively exported by an imported module is visible.
325     if (VisibleModulesCache.insert(CurrModule).second)
326       CurrModule->getExportedModules(Stack);
327   }
328 }
329 
330 void Module::print(raw_ostream &OS, unsigned Indent) const {
331   OS.indent(Indent);
332   if (IsFramework)
333     OS << "framework ";
334   if (IsExplicit)
335     OS << "explicit ";
336   OS << "module " << Name;
337 
338   if (IsSystem || IsExternC) {
339     OS.indent(Indent + 2);
340     if (IsSystem)
341       OS << " [system]";
342     if (IsExternC)
343       OS << " [extern_c]";
344   }
345 
346   OS << " {\n";
347 
348   if (!Requirements.empty()) {
349     OS.indent(Indent + 2);
350     OS << "requires ";
351     for (unsigned I = 0, N = Requirements.size(); I != N; ++I) {
352       if (I)
353         OS << ", ";
354       if (!Requirements[I].second)
355         OS << "!";
356       OS << Requirements[I].first;
357     }
358     OS << "\n";
359   }
360 
361   if (Header H = getUmbrellaHeader()) {
362     OS.indent(Indent + 2);
363     OS << "umbrella header \"";
364     OS.write_escaped(H.NameAsWritten);
365     OS << "\"\n";
366   } else if (DirectoryName D = getUmbrellaDir()) {
367     OS.indent(Indent + 2);
368     OS << "umbrella \"";
369     OS.write_escaped(D.NameAsWritten);
370     OS << "\"\n";
371   }
372 
373   if (!ConfigMacros.empty() || ConfigMacrosExhaustive) {
374     OS.indent(Indent + 2);
375     OS << "config_macros ";
376     if (ConfigMacrosExhaustive)
377       OS << "[exhaustive]";
378     for (unsigned I = 0, N = ConfigMacros.size(); I != N; ++I) {
379       if (I)
380         OS << ", ";
381       OS << ConfigMacros[I];
382     }
383     OS << "\n";
384   }
385 
386   struct {
387     StringRef Prefix;
388     HeaderKind Kind;
389   } Kinds[] = {{"", HK_Normal},
390                {"textual ", HK_Textual},
391                {"private ", HK_Private},
392                {"private textual ", HK_PrivateTextual},
393                {"exclude ", HK_Excluded}};
394 
395   for (auto &K : Kinds) {
396     for (auto &H : Headers[K.Kind]) {
397       OS.indent(Indent + 2);
398       OS << K.Prefix << "header \"";
399       OS.write_escaped(H.NameAsWritten);
400       OS << "\"\n";
401     }
402   }
403 
404   for (submodule_const_iterator MI = submodule_begin(), MIEnd = submodule_end();
405        MI != MIEnd; ++MI)
406     // Print inferred subframework modules so that we don't need to re-infer
407     // them (requires expensive directory iteration + stat calls) when we build
408     // the module. Regular inferred submodules are OK, as we need to look at all
409     // those header files anyway.
410     if (!(*MI)->IsInferred || (*MI)->IsFramework)
411       (*MI)->print(OS, Indent + 2);
412 
413   for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
414     OS.indent(Indent + 2);
415     OS << "export ";
416     if (Module *Restriction = Exports[I].getPointer()) {
417       OS << Restriction->getFullModuleName();
418       if (Exports[I].getInt())
419         OS << ".*";
420     } else {
421       OS << "*";
422     }
423     OS << "\n";
424   }
425 
426   for (unsigned I = 0, N = UnresolvedExports.size(); I != N; ++I) {
427     OS.indent(Indent + 2);
428     OS << "export ";
429     printModuleId(OS, UnresolvedExports[I].Id);
430     if (UnresolvedExports[I].Wildcard)
431       OS << (UnresolvedExports[I].Id.empty() ? "*" : ".*");
432     OS << "\n";
433   }
434 
435   for (unsigned I = 0, N = DirectUses.size(); I != N; ++I) {
436     OS.indent(Indent + 2);
437     OS << "use ";
438     OS << DirectUses[I]->getFullModuleName();
439     OS << "\n";
440   }
441 
442   for (unsigned I = 0, N = UnresolvedDirectUses.size(); I != N; ++I) {
443     OS.indent(Indent + 2);
444     OS << "use ";
445     printModuleId(OS, UnresolvedDirectUses[I]);
446     OS << "\n";
447   }
448 
449   for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
450     OS.indent(Indent + 2);
451     OS << "link ";
452     if (LinkLibraries[I].IsFramework)
453       OS << "framework ";
454     OS << "\"";
455     OS.write_escaped(LinkLibraries[I].Library);
456     OS << "\"";
457   }
458 
459   for (unsigned I = 0, N = UnresolvedConflicts.size(); I != N; ++I) {
460     OS.indent(Indent + 2);
461     OS << "conflict ";
462     printModuleId(OS, UnresolvedConflicts[I].Id);
463     OS << ", \"";
464     OS.write_escaped(UnresolvedConflicts[I].Message);
465     OS << "\"\n";
466   }
467 
468   for (unsigned I = 0, N = Conflicts.size(); I != N; ++I) {
469     OS.indent(Indent + 2);
470     OS << "conflict ";
471     OS << Conflicts[I].Other->getFullModuleName();
472     OS << ", \"";
473     OS.write_escaped(Conflicts[I].Message);
474     OS << "\"\n";
475   }
476 
477   if (InferSubmodules) {
478     OS.indent(Indent + 2);
479     if (InferExplicitSubmodules)
480       OS << "explicit ";
481     OS << "module * {\n";
482     if (InferExportWildcard) {
483       OS.indent(Indent + 4);
484       OS << "export *\n";
485     }
486     OS.indent(Indent + 2);
487     OS << "}\n";
488   }
489 
490   OS.indent(Indent);
491   OS << "}\n";
492 }
493 
494 LLVM_DUMP_METHOD void Module::dump() const {
495   print(llvm::errs());
496 }
497 
498 void VisibleModuleSet::setVisible(Module *M, SourceLocation Loc,
499                                   VisibleCallback Vis, ConflictCallback Cb) {
500   assert(Loc.isValid() && "setVisible expects a valid import location");
501   if (isVisible(M))
502     return;
503 
504   ++Generation;
505 
506   struct Visiting {
507     Module *M;
508     Visiting *ExportedBy;
509   };
510 
511   std::function<void(Visiting)> VisitModule = [&](Visiting V) {
512     // Modules that aren't available cannot be made visible.
513     if (!V.M->isAvailable())
514       return;
515 
516     // Nothing to do for a module that's already visible.
517     unsigned ID = V.M->getVisibilityID();
518     if (ImportLocs.size() <= ID)
519       ImportLocs.resize(ID + 1);
520     else if (ImportLocs[ID].isValid())
521       return;
522 
523     ImportLocs[ID] = Loc;
524     Vis(M);
525 
526     // Make any exported modules visible.
527     SmallVector<Module *, 16> Exports;
528     V.M->getExportedModules(Exports);
529     for (Module *E : Exports)
530       VisitModule({E, &V});
531 
532     for (auto &C : V.M->Conflicts) {
533       if (isVisible(C.Other)) {
534         llvm::SmallVector<Module*, 8> Path;
535         for (Visiting *I = &V; I; I = I->ExportedBy)
536           Path.push_back(I->M);
537         Cb(Path, C.Other, C.Message);
538       }
539     }
540   };
541   VisitModule({M, nullptr});
542 }
543