Module.cpp revision 263508 
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)
29  : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent),
30    Umbrella(), ASTFile(0), IsAvailable(true), IsFromModuleFile(false),
31    IsFramework(IsFramework), IsExplicit(IsExplicit), IsSystem(false),
32    InferSubmodules(false), InferExplicitSubmodules(false),
33    InferExportWildcard(false), ConfigMacrosExhaustive(false),
34    NameVisibility(Hidden)
35{
36  if (Parent) {
37    if (!Parent->isAvailable())
38      IsAvailable = false;
39    if (Parent->IsSystem)
40      IsSystem = true;
41
42    Parent->SubModuleIndex[Name] = Parent->SubModules.size();
43    Parent->SubModules.push_back(this);
44  }
45}
46
47Module::~Module() {
48  for (submodule_iterator I = submodule_begin(), IEnd = submodule_end();
49       I != IEnd; ++I) {
50    delete *I;
51  }
52}
53
54/// \brief Determine whether a translation unit built using the current
55/// language options has the given feature.
56static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
57                       const TargetInfo &Target) {
58  return llvm::StringSwitch<bool>(Feature)
59           .Case("altivec", LangOpts.AltiVec)
60           .Case("blocks", LangOpts.Blocks)
61           .Case("cplusplus", LangOpts.CPlusPlus)
62           .Case("cplusplus11", LangOpts.CPlusPlus11)
63           .Case("objc", LangOpts.ObjC1)
64           .Case("objc_arc", LangOpts.ObjCAutoRefCount)
65           .Case("opencl", LangOpts.OpenCL)
66           .Case("tls", Target.isTLSSupported())
67           .Default(Target.hasFeature(Feature));
68}
69
70bool
71Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
72                    Requirement &Req) const {
73  if (IsAvailable)
74    return true;
75
76  for (const Module *Current = this; Current; Current = Current->Parent) {
77    for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
78      if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
79              Current->Requirements[I].second) {
80        Req = Current->Requirements[I];
81        return false;
82      }
83    }
84  }
85
86  llvm_unreachable("could not find a reason why module is unavailable");
87}
88
89bool Module::isSubModuleOf(Module *Other) const {
90  const Module *This = this;
91  do {
92    if (This == Other)
93      return true;
94
95    This = This->Parent;
96  } while (This);
97
98  return false;
99}
100
101const Module *Module::getTopLevelModule() const {
102  const Module *Result = this;
103  while (Result->Parent)
104    Result = Result->Parent;
105
106  return Result;
107}
108
109std::string Module::getFullModuleName() const {
110  SmallVector<StringRef, 2> Names;
111
112  // Build up the set of module names (from innermost to outermost).
113  for (const Module *M = this; M; M = M->Parent)
114    Names.push_back(M->Name);
115
116  std::string Result;
117  for (SmallVectorImpl<StringRef>::reverse_iterator I = Names.rbegin(),
118                                                 IEnd = Names.rend();
119       I != IEnd; ++I) {
120    if (!Result.empty())
121      Result += '.';
122
123    Result += *I;
124  }
125
126  return Result;
127}
128
129const DirectoryEntry *Module::getUmbrellaDir() const {
130  if (const FileEntry *Header = getUmbrellaHeader())
131    return Header->getDir();
132
133  return Umbrella.dyn_cast<const DirectoryEntry *>();
134}
135
136ArrayRef<const FileEntry *> Module::getTopHeaders(FileManager &FileMgr) {
137  if (!TopHeaderNames.empty()) {
138    for (std::vector<std::string>::iterator
139           I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
140      if (const FileEntry *FE = FileMgr.getFile(*I))
141        TopHeaders.insert(FE);
142    }
143    TopHeaderNames.clear();
144  }
145
146  return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end());
147}
148
149void Module::addRequirement(StringRef Feature, bool RequiredState,
150                            const LangOptions &LangOpts,
151                            const TargetInfo &Target) {
152  Requirements.push_back(Requirement(Feature, RequiredState));
153
154  // If this feature is currently available, we're done.
155  if (hasFeature(Feature, LangOpts, Target) == RequiredState)
156    return;
157
158  if (!IsAvailable)
159    return;
160
161  SmallVector<Module *, 2> Stack;
162  Stack.push_back(this);
163  while (!Stack.empty()) {
164    Module *Current = Stack.back();
165    Stack.pop_back();
166
167    if (!Current->IsAvailable)
168      continue;
169
170    Current->IsAvailable = false;
171    for (submodule_iterator Sub = Current->submodule_begin(),
172                         SubEnd = Current->submodule_end();
173         Sub != SubEnd; ++Sub) {
174      if ((*Sub)->IsAvailable)
175        Stack.push_back(*Sub);
176    }
177  }
178}
179
180Module *Module::findSubmodule(StringRef Name) const {
181  llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
182  if (Pos == SubModuleIndex.end())
183    return 0;
184
185  return SubModules[Pos->getValue()];
186}
187
188static void printModuleId(raw_ostream &OS, const ModuleId &Id) {
189  for (unsigned I = 0, N = Id.size(); I != N; ++I) {
190    if (I)
191      OS << ".";
192    OS << Id[I].first;
193  }
194}
195
196void Module::getExportedModules(SmallVectorImpl<Module *> &Exported) const {
197  // All non-explicit submodules are exported.
198  for (std::vector<Module *>::const_iterator I = SubModules.begin(),
199                                             E = SubModules.end();
200       I != E; ++I) {
201    Module *Mod = *I;
202    if (!Mod->IsExplicit)
203      Exported.push_back(Mod);
204  }
205
206  // Find re-exported modules by filtering the list of imported modules.
207  bool AnyWildcard = false;
208  bool UnrestrictedWildcard = false;
209  SmallVector<Module *, 4> WildcardRestrictions;
210  for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
211    Module *Mod = Exports[I].getPointer();
212    if (!Exports[I].getInt()) {
213      // Export a named module directly; no wildcards involved.
214      Exported.push_back(Mod);
215
216      continue;
217    }
218
219    // Wildcard export: export all of the imported modules that match
220    // the given pattern.
221    AnyWildcard = true;
222    if (UnrestrictedWildcard)
223      continue;
224
225    if (Module *Restriction = Exports[I].getPointer())
226      WildcardRestrictions.push_back(Restriction);
227    else {
228      WildcardRestrictions.clear();
229      UnrestrictedWildcard = true;
230    }
231  }
232
233  // If there were any wildcards, push any imported modules that were
234  // re-exported by the wildcard restriction.
235  if (!AnyWildcard)
236    return;
237
238  for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
239    Module *Mod = Imports[I];
240    bool Acceptable = UnrestrictedWildcard;
241    if (!Acceptable) {
242      // Check whether this module meets one of the restrictions.
243      for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
244        Module *Restriction = WildcardRestrictions[R];
245        if (Mod == Restriction || Mod->isSubModuleOf(Restriction)) {
246          Acceptable = true;
247          break;
248        }
249      }
250    }
251
252    if (!Acceptable)
253      continue;
254
255    Exported.push_back(Mod);
256  }
257}
258
259void Module::buildVisibleModulesCache() const {
260  assert(VisibleModulesCache.empty() && "cache does not need building");
261
262  // This module is visible to itself.
263  VisibleModulesCache.insert(this);
264
265  // Every imported module is visible.
266  SmallVector<Module *, 16> Stack(Imports.begin(), Imports.end());
267  while (!Stack.empty()) {
268    Module *CurrModule = Stack.pop_back_val();
269
270    // Every module transitively exported by an imported module is visible.
271    if (VisibleModulesCache.insert(CurrModule).second)
272      CurrModule->getExportedModules(Stack);
273  }
274}
275
276void Module::print(raw_ostream &OS, unsigned Indent) const {
277  OS.indent(Indent);
278  if (IsFramework)
279    OS << "framework ";
280  if (IsExplicit)
281    OS << "explicit ";
282  OS << "module " << Name;
283
284  if (IsSystem) {
285    OS.indent(Indent + 2);
286    OS << " [system]";
287  }
288
289  OS << " {\n";
290
291  if (!Requirements.empty()) {
292    OS.indent(Indent + 2);
293    OS << "requires ";
294    for (unsigned I = 0, N = Requirements.size(); I != N; ++I) {
295      if (I)
296        OS << ", ";
297      if (!Requirements[I].second)
298        OS << "!";
299      OS << Requirements[I].first;
300    }
301    OS << "\n";
302  }
303
304  if (const FileEntry *UmbrellaHeader = getUmbrellaHeader()) {
305    OS.indent(Indent + 2);
306    OS << "umbrella header \"";
307    OS.write_escaped(UmbrellaHeader->getName());
308    OS << "\"\n";
309  } else if (const DirectoryEntry *UmbrellaDir = getUmbrellaDir()) {
310    OS.indent(Indent + 2);
311    OS << "umbrella \"";
312    OS.write_escaped(UmbrellaDir->getName());
313    OS << "\"\n";
314  }
315
316  if (!ConfigMacros.empty() || ConfigMacrosExhaustive) {
317    OS.indent(Indent + 2);
318    OS << "config_macros ";
319    if (ConfigMacrosExhaustive)
320      OS << "[exhaustive]";
321    for (unsigned I = 0, N = ConfigMacros.size(); I != N; ++I) {
322      if (I)
323        OS << ", ";
324      OS << ConfigMacros[I];
325    }
326    OS << "\n";
327  }
328
329  for (unsigned I = 0, N = NormalHeaders.size(); I != N; ++I) {
330    OS.indent(Indent + 2);
331    OS << "header \"";
332    OS.write_escaped(NormalHeaders[I]->getName());
333    OS << "\"\n";
334  }
335
336  for (unsigned I = 0, N = ExcludedHeaders.size(); I != N; ++I) {
337    OS.indent(Indent + 2);
338    OS << "exclude header \"";
339    OS.write_escaped(ExcludedHeaders[I]->getName());
340    OS << "\"\n";
341  }
342
343  for (unsigned I = 0, N = PrivateHeaders.size(); I != N; ++I) {
344    OS.indent(Indent + 2);
345    OS << "private header \"";
346    OS.write_escaped(PrivateHeaders[I]->getName());
347    OS << "\"\n";
348  }
349
350  for (submodule_const_iterator MI = submodule_begin(), MIEnd = submodule_end();
351       MI != MIEnd; ++MI)
352    (*MI)->print(OS, Indent + 2);
353
354  for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
355    OS.indent(Indent + 2);
356    OS << "export ";
357    if (Module *Restriction = Exports[I].getPointer()) {
358      OS << Restriction->getFullModuleName();
359      if (Exports[I].getInt())
360        OS << ".*";
361    } else {
362      OS << "*";
363    }
364    OS << "\n";
365  }
366
367  for (unsigned I = 0, N = UnresolvedExports.size(); I != N; ++I) {
368    OS.indent(Indent + 2);
369    OS << "export ";
370    printModuleId(OS, UnresolvedExports[I].Id);
371    if (UnresolvedExports[I].Wildcard) {
372      if (UnresolvedExports[I].Id.empty())
373        OS << "*";
374      else
375        OS << ".*";
376    }
377    OS << "\n";
378  }
379
380  for (unsigned I = 0, N = DirectUses.size(); I != N; ++I) {
381    OS.indent(Indent + 2);
382    OS << "use ";
383    OS << DirectUses[I]->getFullModuleName();
384    OS << "\n";
385  }
386
387  for (unsigned I = 0, N = UnresolvedDirectUses.size(); I != N; ++I) {
388    OS.indent(Indent + 2);
389    OS << "use ";
390    printModuleId(OS, UnresolvedDirectUses[I]);
391    OS << "\n";
392  }
393
394  for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
395    OS.indent(Indent + 2);
396    OS << "link ";
397    if (LinkLibraries[I].IsFramework)
398      OS << "framework ";
399    OS << "\"";
400    OS.write_escaped(LinkLibraries[I].Library);
401    OS << "\"";
402  }
403
404  for (unsigned I = 0, N = UnresolvedConflicts.size(); I != N; ++I) {
405    OS.indent(Indent + 2);
406    OS << "conflict ";
407    printModuleId(OS, UnresolvedConflicts[I].Id);
408    OS << ", \"";
409    OS.write_escaped(UnresolvedConflicts[I].Message);
410    OS << "\"\n";
411  }
412
413  for (unsigned I = 0, N = Conflicts.size(); I != N; ++I) {
414    OS.indent(Indent + 2);
415    OS << "conflict ";
416    OS << Conflicts[I].Other->getFullModuleName();
417    OS << ", \"";
418    OS.write_escaped(Conflicts[I].Message);
419    OS << "\"\n";
420  }
421
422  if (InferSubmodules) {
423    OS.indent(Indent + 2);
424    if (InferExplicitSubmodules)
425      OS << "explicit ";
426    OS << "module * {\n";
427    if (InferExportWildcard) {
428      OS.indent(Indent + 4);
429      OS << "export *\n";
430    }
431    OS.indent(Indent + 2);
432    OS << "}\n";
433  }
434
435  OS.indent(Indent);
436  OS << "}\n";
437}
438
439void Module::dump() const {
440  print(llvm::errs());
441}
442
443
444