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