clang  14.0.0git
Module.cpp
Go to the documentation of this file.
1 //===- Module.cpp - Describe a module -------------------------------------===//
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 Module class, which describes a module in the source
10 // code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Basic/Module.h"
15 #include "clang/Basic/CharInfo.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Support/Compiler.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <algorithm>
29 #include <cassert>
30 #include <functional>
31 #include <string>
32 #include <utility>
33 #include <vector>
34 
35 using namespace clang;
36 
37 Module::Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent,
38  bool IsFramework, bool IsExplicit, unsigned VisibilityID)
39  : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent),
40  VisibilityID(VisibilityID), IsUnimportable(false),
41  HasIncompatibleModuleFile(false), IsAvailable(true),
42  IsFromModuleFile(false), IsFramework(IsFramework), IsExplicit(IsExplicit),
43  IsSystem(false), IsExternC(false), IsInferred(false),
44  InferSubmodules(false), InferExplicitSubmodules(false),
45  InferExportWildcard(false), ConfigMacrosExhaustive(false),
46  NoUndeclaredIncludes(false), ModuleMapIsPrivate(false),
47  NameVisibility(Hidden) {
48  if (Parent) {
55 
56  Parent->SubModuleIndex[Name] = Parent->SubModules.size();
57  Parent->SubModules.push_back(this);
58  }
59 }
60 
63  I != IEnd; ++I) {
64  delete *I;
65  }
66 }
67 
68 static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature) {
69  StringRef Platform = Target.getPlatformName();
70  StringRef Env = Target.getTriple().getEnvironmentName();
71 
72  // Attempt to match platform and environment.
73  if (Platform == Feature || Target.getTriple().getOSName() == Feature ||
74  Env == Feature)
75  return true;
76 
77  auto CmpPlatformEnv = [](StringRef LHS, StringRef RHS) {
78  auto Pos = LHS.find('-');
79  if (Pos == StringRef::npos)
80  return false;
81  SmallString<128> NewLHS = LHS.slice(0, Pos);
82  NewLHS += LHS.slice(Pos+1, LHS.size());
83  return NewLHS == RHS;
84  };
85 
86  SmallString<128> PlatformEnv = Target.getTriple().getOSAndEnvironmentName();
87  // Darwin has different but equivalent variants for simulators, example:
88  // 1. x86_64-apple-ios-simulator
89  // 2. x86_64-apple-iossimulator
90  // where both are valid examples of the same platform+environment but in the
91  // variant (2) the simulator is hardcoded as part of the platform name. Both
92  // forms above should match for "iossimulator" requirement.
93  if (Target.getTriple().isOSDarwin() && PlatformEnv.endswith("simulator"))
94  return PlatformEnv == Feature || CmpPlatformEnv(PlatformEnv, Feature);
95 
96  return PlatformEnv == Feature;
97 }
98 
99 /// Determine whether a translation unit built using the current
100 /// language options has the given feature.
101 static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
102  const TargetInfo &Target) {
103  bool HasFeature = llvm::StringSwitch<bool>(Feature)
104  .Case("altivec", LangOpts.AltiVec)
105  .Case("blocks", LangOpts.Blocks)
106  .Case("coroutines", LangOpts.Coroutines)
107  .Case("cplusplus", LangOpts.CPlusPlus)
108  .Case("cplusplus11", LangOpts.CPlusPlus11)
109  .Case("cplusplus14", LangOpts.CPlusPlus14)
110  .Case("cplusplus17", LangOpts.CPlusPlus17)
111  .Case("c99", LangOpts.C99)
112  .Case("c11", LangOpts.C11)
113  .Case("c17", LangOpts.C17)
114  .Case("freestanding", LangOpts.Freestanding)
115  .Case("gnuinlineasm", LangOpts.GNUAsm)
116  .Case("objc", LangOpts.ObjC)
117  .Case("objc_arc", LangOpts.ObjCAutoRefCount)
118  .Case("opencl", LangOpts.OpenCL)
119  .Case("tls", Target.isTLSSupported())
120  .Case("zvector", LangOpts.ZVector)
121  .Default(Target.hasFeature(Feature) ||
122  isPlatformEnvironment(Target, Feature));
123  if (!HasFeature)
124  HasFeature = llvm::is_contained(LangOpts.ModuleFeatures, Feature);
125  return HasFeature;
126 }
127 
128 bool Module::isUnimportable(const LangOptions &LangOpts,
129  const TargetInfo &Target, Requirement &Req,
130  Module *&ShadowingModule) const {
131  if (!IsUnimportable)
132  return false;
133 
134  for (const Module *Current = this; Current; Current = Current->Parent) {
135  if (Current->ShadowingModule) {
136  ShadowingModule = Current->ShadowingModule;
137  return true;
138  }
139  for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
140  if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
141  Current->Requirements[I].second) {
142  Req = Current->Requirements[I];
143  return true;
144  }
145  }
146  }
147 
148  llvm_unreachable("could not find a reason why module is unimportable");
149 }
150 
151 bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
152  Requirement &Req,
153  UnresolvedHeaderDirective &MissingHeader,
154  Module *&ShadowingModule) const {
155  if (IsAvailable)
156  return true;
157 
158  if (isUnimportable(LangOpts, Target, Req, ShadowingModule))
159  return false;
160 
161  // FIXME: All missing headers are listed on the top-level module. Should we
162  // just look there?
163  for (const Module *Current = this; Current; Current = Current->Parent) {
164  if (!Current->MissingHeaders.empty()) {
165  MissingHeader = Current->MissingHeaders.front();
166  return false;
167  }
168  }
169 
170  llvm_unreachable("could not find a reason why module is unavailable");
171 }
172 
173 bool Module::isSubModuleOf(const Module *Other) const {
174  for (auto *Parent = this; Parent; Parent = Parent->Parent) {
175  if (Parent == Other)
176  return true;
177  }
178  return false;
179 }
180 
181 const Module *Module::getTopLevelModule() const {
182  const Module *Result = this;
183  while (Result->Parent)
184  Result = Result->Parent;
185 
186  return Result;
187 }
188 
189 static StringRef getModuleNameFromComponent(
190  const std::pair<std::string, SourceLocation> &IdComponent) {
191  return IdComponent.first;
192 }
193 
194 static StringRef getModuleNameFromComponent(StringRef R) { return R; }
195 
196 template<typename InputIter>
197 static void printModuleId(raw_ostream &OS, InputIter Begin, InputIter End,
198  bool AllowStringLiterals = true) {
199  for (InputIter It = Begin; It != End; ++It) {
200  if (It != Begin)
201  OS << ".";
202 
203  StringRef Name = getModuleNameFromComponent(*It);
204  if (!AllowStringLiterals || isValidAsciiIdentifier(Name))
205  OS << Name;
206  else {
207  OS << '"';
208  OS.write_escaped(Name);
209  OS << '"';
210  }
211  }
212 }
213 
214 template<typename Container>
215 static void printModuleId(raw_ostream &OS, const Container &C) {
216  return printModuleId(OS, C.begin(), C.end());
217 }
218 
219 std::string Module::getFullModuleName(bool AllowStringLiterals) const {
221 
222  // Build up the set of module names (from innermost to outermost).
223  for (const Module *M = this; M; M = M->Parent)
224  Names.push_back(M->Name);
225 
226  std::string Result;
227 
228  llvm::raw_string_ostream Out(Result);
229  printModuleId(Out, Names.rbegin(), Names.rend(), AllowStringLiterals);
230  Out.flush();
231 
232  return Result;
233 }
234 
236  for (const Module *M = this; M; M = M->Parent) {
237  if (nameParts.empty() || M->Name != nameParts.back())
238  return false;
239  nameParts = nameParts.drop_back();
240  }
241  return nameParts.empty();
242 }
243 
245  if (Header U = getUmbrellaHeader())
246  return {"", "", U.Entry->getDir()};
247 
249  Umbrella.dyn_cast<const DirectoryEntry *>()};
250 }
251 
252 void Module::addTopHeader(const FileEntry *File) {
253  assert(File);
254  TopHeaders.insert(File);
255 }
256 
258  if (!TopHeaderNames.empty()) {
259  for (std::vector<std::string>::iterator
260  I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
261  if (auto FE = FileMgr.getFile(*I))
262  TopHeaders.insert(*FE);
263  }
264  TopHeaderNames.clear();
265  }
266 
267  return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end());
268 }
269 
270 bool Module::directlyUses(const Module *Requested) const {
271  auto *Top = getTopLevelModule();
272 
273  // A top-level module implicitly uses itself.
274  if (Requested->isSubModuleOf(Top))
275  return true;
276 
277  for (auto *Use : Top->DirectUses)
278  if (Requested->isSubModuleOf(Use))
279  return true;
280 
281  // Anyone is allowed to use our builtin stddef.h and its accompanying module.
282  if (!Requested->Parent && Requested->Name == "_Builtin_stddef_max_align_t")
283  return true;
284 
285  return false;
286 }
287 
288 void Module::addRequirement(StringRef Feature, bool RequiredState,
289  const LangOptions &LangOpts,
290  const TargetInfo &Target) {
291  Requirements.push_back(Requirement(std::string(Feature), RequiredState));
292 
293  // If this feature is currently available, we're done.
294  if (hasFeature(Feature, LangOpts, Target) == RequiredState)
295  return;
296 
297  markUnavailable(/*Unimportable*/true);
298 }
299 
300 void Module::markUnavailable(bool Unimportable) {
301  auto needUpdate = [Unimportable](Module *M) {
302  return M->IsAvailable || (!M->IsUnimportable && Unimportable);
303  };
304 
305  if (!needUpdate(this))
306  return;
307 
309  Stack.push_back(this);
310  while (!Stack.empty()) {
311  Module *Current = Stack.back();
312  Stack.pop_back();
313 
314  if (!needUpdate(Current))
315  continue;
316 
317  Current->IsAvailable = false;
318  Current->IsUnimportable |= Unimportable;
319  for (submodule_iterator Sub = Current->submodule_begin(),
320  SubEnd = Current->submodule_end();
321  Sub != SubEnd; ++Sub) {
322  if (needUpdate(*Sub))
323  Stack.push_back(*Sub);
324  }
325  }
326 }
327 
328 Module *Module::findSubmodule(StringRef Name) const {
329  llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
330  if (Pos == SubModuleIndex.end())
331  return nullptr;
332 
333  return SubModules[Pos->getValue()];
334 }
335 
337  llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
338  if (Pos != SubModuleIndex.end())
339  return SubModules[Pos->getValue()];
340  if (!InferSubmodules)
341  return nullptr;
342  Module *Result = new Module(Name, SourceLocation(), this, false, InferExplicitSubmodules, 0);
343  Result->InferExplicitSubmodules = InferExplicitSubmodules;
344  Result->InferSubmodules = InferSubmodules;
345  Result->InferExportWildcard = InferExportWildcard;
346  if (Result->InferExportWildcard)
347  Result->Exports.push_back(Module::ExportDecl(nullptr, true));
348  return Result;
349 }
350 
352  // All non-explicit submodules are exported.
353  for (std::vector<Module *>::const_iterator I = SubModules.begin(),
354  E = SubModules.end();
355  I != E; ++I) {
356  Module *Mod = *I;
357  if (!Mod->IsExplicit)
358  Exported.push_back(Mod);
359  }
360 
361  // Find re-exported modules by filtering the list of imported modules.
362  bool AnyWildcard = false;
363  bool UnrestrictedWildcard = false;
364  SmallVector<Module *, 4> WildcardRestrictions;
365  for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
366  Module *Mod = Exports[I].getPointer();
367  if (!Exports[I].getInt()) {
368  // Export a named module directly; no wildcards involved.
369  Exported.push_back(Mod);
370 
371  continue;
372  }
373 
374  // Wildcard export: export all of the imported modules that match
375  // the given pattern.
376  AnyWildcard = true;
377  if (UnrestrictedWildcard)
378  continue;
379 
380  if (Module *Restriction = Exports[I].getPointer())
381  WildcardRestrictions.push_back(Restriction);
382  else {
383  WildcardRestrictions.clear();
384  UnrestrictedWildcard = true;
385  }
386  }
387 
388  // If there were any wildcards, push any imported modules that were
389  // re-exported by the wildcard restriction.
390  if (!AnyWildcard)
391  return;
392 
393  for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
394  Module *Mod = Imports[I];
395  bool Acceptable = UnrestrictedWildcard;
396  if (!Acceptable) {
397  // Check whether this module meets one of the restrictions.
398  for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
399  Module *Restriction = WildcardRestrictions[R];
400  if (Mod == Restriction || Mod->isSubModuleOf(Restriction)) {
401  Acceptable = true;
402  break;
403  }
404  }
405  }
406 
407  if (!Acceptable)
408  continue;
409 
410  Exported.push_back(Mod);
411  }
412 }
413 
414 void Module::buildVisibleModulesCache() const {
415  assert(VisibleModulesCache.empty() && "cache does not need building");
416 
417  // This module is visible to itself.
418  VisibleModulesCache.insert(this);
419 
420  // Every imported module is visible.
421  SmallVector<Module *, 16> Stack(Imports.begin(), Imports.end());
422  while (!Stack.empty()) {
423  Module *CurrModule = Stack.pop_back_val();
424 
425  // Every module transitively exported by an imported module is visible.
426  if (VisibleModulesCache.insert(CurrModule).second)
427  CurrModule->getExportedModules(Stack);
428  }
429 }
430 
431 void Module::print(raw_ostream &OS, unsigned Indent, bool Dump) const {
432  OS.indent(Indent);
433  if (IsFramework)
434  OS << "framework ";
435  if (IsExplicit)
436  OS << "explicit ";
437  OS << "module ";
438  printModuleId(OS, &Name, &Name + 1);
439 
440  if (IsSystem || IsExternC) {
441  OS.indent(Indent + 2);
442  if (IsSystem)
443  OS << " [system]";
444  if (IsExternC)
445  OS << " [extern_c]";
446  }
447 
448  OS << " {\n";
449 
450  if (!Requirements.empty()) {
451  OS.indent(Indent + 2);
452  OS << "requires ";
453  for (unsigned I = 0, N = Requirements.size(); I != N; ++I) {
454  if (I)
455  OS << ", ";
456  if (!Requirements[I].second)
457  OS << "!";
458  OS << Requirements[I].first;
459  }
460  OS << "\n";
461  }
462 
463  if (Header H = getUmbrellaHeader()) {
464  OS.indent(Indent + 2);
465  OS << "umbrella header \"";
466  OS.write_escaped(H.NameAsWritten);
467  OS << "\"\n";
468  } else if (DirectoryName D = getUmbrellaDir()) {
469  OS.indent(Indent + 2);
470  OS << "umbrella \"";
471  OS.write_escaped(D.NameAsWritten);
472  OS << "\"\n";
473  }
474 
475  if (!ConfigMacros.empty() || ConfigMacrosExhaustive) {
476  OS.indent(Indent + 2);
477  OS << "config_macros ";
479  OS << "[exhaustive]";
480  for (unsigned I = 0, N = ConfigMacros.size(); I != N; ++I) {
481  if (I)
482  OS << ", ";
483  OS << ConfigMacros[I];
484  }
485  OS << "\n";
486  }
487 
488  struct {
489  StringRef Prefix;
491  } Kinds[] = {{"", HK_Normal},
492  {"textual ", HK_Textual},
493  {"private ", HK_Private},
494  {"private textual ", HK_PrivateTextual},
495  {"exclude ", HK_Excluded}};
496 
497  for (auto &K : Kinds) {
498  assert(&K == &Kinds[K.Kind] && "kinds in wrong order");
499  for (auto &H : Headers[K.Kind]) {
500  OS.indent(Indent + 2);
501  OS << K.Prefix << "header \"";
502  OS.write_escaped(H.NameAsWritten);
503  OS << "\" { size " << H.Entry->getSize()
504  << " mtime " << H.Entry->getModificationTime() << " }\n";
505  }
506  }
507  for (auto *Unresolved : {&UnresolvedHeaders, &MissingHeaders}) {
508  for (auto &U : *Unresolved) {
509  OS.indent(Indent + 2);
510  OS << Kinds[U.Kind].Prefix << "header \"";
511  OS.write_escaped(U.FileName);
512  OS << "\"";
513  if (U.Size || U.ModTime) {
514  OS << " {";
515  if (U.Size)
516  OS << " size " << *U.Size;
517  if (U.ModTime)
518  OS << " mtime " << *U.ModTime;
519  OS << " }";
520  }
521  OS << "\n";
522  }
523  }
524 
525  if (!ExportAsModule.empty()) {
526  OS.indent(Indent + 2);
527  OS << "export_as" << ExportAsModule << "\n";
528  }
529 
531  MI != MIEnd; ++MI)
532  // Print inferred subframework modules so that we don't need to re-infer
533  // them (requires expensive directory iteration + stat calls) when we build
534  // the module. Regular inferred submodules are OK, as we need to look at all
535  // those header files anyway.
536  if (!(*MI)->IsInferred || (*MI)->IsFramework)
537  (*MI)->print(OS, Indent + 2, Dump);
538 
539  for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
540  OS.indent(Indent + 2);
541  OS << "export ";
542  if (Module *Restriction = Exports[I].getPointer()) {
543  OS << Restriction->getFullModuleName(true);
544  if (Exports[I].getInt())
545  OS << ".*";
546  } else {
547  OS << "*";
548  }
549  OS << "\n";
550  }
551 
552  for (unsigned I = 0, N = UnresolvedExports.size(); I != N; ++I) {
553  OS.indent(Indent + 2);
554  OS << "export ";
556  if (UnresolvedExports[I].Wildcard)
557  OS << (UnresolvedExports[I].Id.empty() ? "*" : ".*");
558  OS << "\n";
559  }
560 
561  if (Dump) {
562  for (Module *M : Imports) {
563  OS.indent(Indent + 2);
564  llvm::errs() << "import " << M->getFullModuleName() << "\n";
565  }
566  }
567 
568  for (unsigned I = 0, N = DirectUses.size(); I != N; ++I) {
569  OS.indent(Indent + 2);
570  OS << "use ";
571  OS << DirectUses[I]->getFullModuleName(true);
572  OS << "\n";
573  }
574 
575  for (unsigned I = 0, N = UnresolvedDirectUses.size(); I != N; ++I) {
576  OS.indent(Indent + 2);
577  OS << "use ";
579  OS << "\n";
580  }
581 
582  for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
583  OS.indent(Indent + 2);
584  OS << "link ";
585  if (LinkLibraries[I].IsFramework)
586  OS << "framework ";
587  OS << "\"";
588  OS.write_escaped(LinkLibraries[I].Library);
589  OS << "\"";
590  }
591 
592  for (unsigned I = 0, N = UnresolvedConflicts.size(); I != N; ++I) {
593  OS.indent(Indent + 2);
594  OS << "conflict ";
596  OS << ", \"";
597  OS.write_escaped(UnresolvedConflicts[I].Message);
598  OS << "\"\n";
599  }
600 
601  for (unsigned I = 0, N = Conflicts.size(); I != N; ++I) {
602  OS.indent(Indent + 2);
603  OS << "conflict ";
604  OS << Conflicts[I].Other->getFullModuleName(true);
605  OS << ", \"";
606  OS.write_escaped(Conflicts[I].Message);
607  OS << "\"\n";
608  }
609 
610  if (InferSubmodules) {
611  OS.indent(Indent + 2);
613  OS << "explicit ";
614  OS << "module * {\n";
615  if (InferExportWildcard) {
616  OS.indent(Indent + 4);
617  OS << "export *\n";
618  }
619  OS.indent(Indent + 2);
620  OS << "}\n";
621  }
622 
623  OS.indent(Indent);
624  OS << "}\n";
625 }
626 
627 LLVM_DUMP_METHOD void Module::dump() const {
628  print(llvm::errs(), 0, true);
629 }
630 
633  assert(Loc.isValid() && "setVisible expects a valid import location");
634  if (isVisible(M))
635  return;
636 
637  ++Generation;
638 
639  struct Visiting {
640  Module *M;
641  Visiting *ExportedBy;
642  };
643 
644  std::function<void(Visiting)> VisitModule = [&](Visiting V) {
645  // Nothing to do for a module that's already visible.
646  unsigned ID = V.M->getVisibilityID();
647  if (ImportLocs.size() <= ID)
648  ImportLocs.resize(ID + 1);
649  else if (ImportLocs[ID].isValid())
650  return;
651 
652  ImportLocs[ID] = Loc;
653  Vis(M);
654 
655  // Make any exported modules visible.
657  V.M->getExportedModules(Exports);
658  for (Module *E : Exports) {
659  // Don't import non-importable modules.
660  if (!E->isUnimportable())
661  VisitModule({E, &V});
662  }
663 
664  for (auto &C : V.M->Conflicts) {
665  if (isVisible(C.Other)) {
667  for (Visiting *I = &V; I; I = I->ExportedBy)
668  Path.push_back(I->M);
669  Cb(Path, C.Other, C.Message);
670  }
671  }
672  };
673  VisitModule({M, nullptr});
674 }
675 
677  : Signature(M.Signature), ClangModule(&M) {
678  if (M.Directory)
679  Path = M.Directory->getName();
680  if (auto File = M.getASTFile())
681  ASTFile = File->getName();
682 }
683 
685  if (ClangModule)
686  return ClangModule->Name;
687  else
688  return std::string(PCHModuleName);
689 }
clang::Module::DirectUses
SmallVector< Module *, 2 > DirectUses
The directly used modules.
Definition: Module.h:357
clang::Module::directlyUses
bool directlyUses(const Module *Requested) const
Determine whether this module has declared its intention to directly use another module.
Definition: Module.cpp:270
getModuleNameFromComponent
static StringRef getModuleNameFromComponent(const std::pair< std::string, SourceLocation > &IdComponent)
Definition: Module.cpp:189
clang::Module::Requirement
std::pair< std::string, bool > Requirement
An individual requirement: a feature name and a flag indicating the required state of that feature.
Definition: Module.h:235
clang::Module::getTopLevelModule
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:519
clang::Module::InferSubmodules
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
Definition: Module.h:285
clang::Module::Requirements
SmallVector< Requirement, 2 > Requirements
The set of language features required to use this module.
Definition: Module.h:241
clang::Module::fullModuleNameIs
bool fullModuleNameIs(ArrayRef< StringRef > nameParts) const
Whether the full name of this module is equal to joining nameParts with "."s.
Definition: Module.cpp:235
clang::DeclaratorContext::File
@ File
clang::Module::getUmbrellaDir
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:244
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::ExplicitSpecKind::Unresolved
@ Unresolved
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::Module::getFullModuleName
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:219
clang::DirectoryEntry::getName
StringRef getName() const
Definition: DirectoryEntry.h:40
TargetInfo.h
clang::MultiVersionKind::Target
@ Target
printModuleId
static void printModuleId(raw_ostream &OS, InputIter Begin, InputIter End, bool AllowStringLiterals=true)
Definition: Module.cpp:197
clang::Module::HK_PrivateTextual
@ HK_PrivateTextual
Definition: Module.h:185
clang::Module::submodule_begin
submodule_iterator submodule_begin()
Definition: Module.h:623
clang::Module::Module
Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent, bool IsFramework, bool IsExplicit, unsigned VisibilityID)
Construct a new module or submodule.
Definition: Module.cpp:37
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:189
Module.h
clang::Module::Name
std::string Name
The name of this module.
Definition: Module.h:99
clang::Module::InferExportWildcard
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e....
Definition: Module.h:293
clang::Module::findSubmodule
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:328
clang::Module::ModuleMapIsPrivate
unsigned ModuleMapIsPrivate
Whether this module came from a "private" module map, found next to a regular (public) module map.
Definition: Module.h:308
clang::VisibleModuleSet::isVisible
bool isVisible(const Module *M) const
Determine whether a module is visible.
Definition: Module.h:680
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::Module::isAvailable
bool isAvailable() const
Determine whether this module is available for use within the current translation unit.
Definition: Module.h:443
clang::Module::~Module
~Module()
Definition: Module.cpp:61
clang::Module::UnresolvedExports
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
Definition: Module.h:354
clang::Module::UnresolvedDirectUses
SmallVector< ModuleId, 2 > UnresolvedDirectUses
The set of use declarations that have yet to be resolved.
Definition: Module.h:360
U
clang::Module::NoUndeclaredIncludes
unsigned NoUndeclaredIncludes
Whether files in this module can only include non-modular headers and headers from used modules.
Definition: Module.h:304
V
#define V(N, I)
Definition: ASTContext.h:3121
clang::Module::getTopHeaders
ArrayRef< const FileEntry * > getTopHeaders(FileManager &FileMgr)
The top-level headers associated with this module.
Definition: Module.cpp:257
clang::Module::submodule_const_iterator
std::vector< Module * >::const_iterator submodule_const_iterator
Definition: Module.h:621
clang::Module::isUnimportable
bool isUnimportable() const
Determine whether this module has been declared unimportable.
Definition: Module.h:423
clang::isValidAsciiIdentifier
LLVM_READONLY bool isValidAsciiIdentifier(StringRef S, bool AllowDollar=false)
Return true if this is a valid ASCII identifier.
Definition: CharInfo.h:189
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::Module::findOrInferSubmodule
Module * findOrInferSubmodule(StringRef Name)
Definition: Module.cpp:336
clang::DirectoryEntry
Cached information about one directory (either on disk or in the virtual file system).
Definition: DirectoryEntry.h:33
Id
int Id
Definition: ASTDiff.cpp:191
clang::Module::Exports
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:336
clang::Module::HK_Textual
@ HK_Textual
Definition: Module.h:183
clang::Module::IsFramework
unsigned IsFramework
Whether this is a framework module.
Definition: Module.h:264
LangOptions.h
clang::Module::HeaderKind
HeaderKind
Definition: Module.h:181
clang::LangOptions::ModuleFeatures
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
Definition: LangOptions.h:349
clang::Module::Conflicts
std::vector< Conflict > Conflicts
The list of conflicts.
Definition: Module.h:414
clang::Module::UnresolvedConflicts
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
Definition: Module.h:402
llvm::SmallString< 128 >
HasFeature
static bool HasFeature(const Preprocessor &PP, StringRef Feature)
HasFeature - Return true if we recognize and implement the feature specified by the identifier as a s...
Definition: PPMacroExpansion.cpp:1114
clang::Module::MissingHeaders
SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders
Headers that are mentioned in the module map file but could not be found on the file system.
Definition: Module.h:231
clang::Module::IsExplicit
unsigned IsExplicit
Whether this is an explicit submodule.
Definition: Module.h:267
clang::Module::getASTFile
OptionalFileEntryRefDegradesToFileEntryPtr getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:534
clang::VisibleModuleSet::setVisible
void setVisible(Module *M, SourceLocation Loc, VisibleCallback Vis=[](Module *) {}, ConflictCallback Cb=[](ArrayRef< Module * >, Module *, StringRef) {})
Make a specific module visible.
Definition: Module.cpp:631
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
clang::ASTSourceDescriptor::getModuleName
std::string getModuleName() const
Definition: Module.cpp:684
clang::Module::Parent
Module * Parent
The parent of this module.
Definition: Module.h:124
clang::Module::submodule_iterator
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:620
clang::Module::UmbrellaAsWritten
std::string UmbrellaAsWritten
The name of the umbrella entry, as written in the module map.
Definition: Module.h:142
clang::Module::HK_Normal
@ HK_Normal
Definition: Module.h:182
clang::Module::markUnavailable
void markUnavailable(bool Unimportable)
Mark this module and all of its submodules as unavailable.
Definition: Module.cpp:300
clang::Module::LinkLibraries
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
Definition: Module.h:381
SourceLocation.h
clang::Indent
raw_ostream & Indent(raw_ostream &Out, const unsigned int Space, bool IsDot)
Definition: JsonSupport.h:20
clang::Module::HK_Private
@ HK_Private
Definition: Module.h:184
clang::Module::Directory
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:129
clang::Module::Headers
SmallVector< Header, 2 > Headers[5]
The headers that are part of this module.
Definition: Module.h:211
CharInfo.h
isPlatformEnvironment
static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature)
Definition: Module.cpp:68
false
#define false
Definition: stdbool.h:17
clang::Module::IsSystem
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers).
Definition: Module.h:271
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:165
llvm::ArrayRef
Definition: LLVM.h:34
clang::Module::Umbrella
llvm::PointerUnion< const FileEntry *, const DirectoryEntry * > Umbrella
The umbrella header or directory.
Definition: Module.h:136
clang::Module::Imports
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:327
clang::Module::HK_Excluded
@ HK_Excluded
Definition: Module.h:186
clang::Module::InferExplicitSubmodules
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Definition: Module.h:289
clang::Module::IsAvailable
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:258
clang::VisibleModuleSet::ConflictCallback
llvm::function_ref< void(ArrayRef< Module * > Path, Module *Conflict, StringRef Message)> ConflictCallback
A callback to call when a module conflict is found.
Definition: Module.h:700
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:58
clang::Module::UnresolvedHeaderDirective
Stored information about a header directive that was found in the module map file but has not been re...
Definition: Module.h:215
clang::Module::Kind
ModuleKind Kind
The kind of this module.
Definition: Module.h:120
clang::Module::DirectoryName
Information about a directory name as found in the module map file.
Definition: Module.h:202
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang
Definition: CalledOnceCheck.h:17
clang::FileManager
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
clang::Module::isSubModuleOf
bool isSubModuleOf(const Module *Other) const
Check if this module is a (possibly transitive) submodule of Other.
Definition: Module.cpp:173
clang::Module::ExportAsModule
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed,...
Definition: Module.h:149
clang::VisibleModuleSet::VisibleCallback
llvm::function_ref< void(Module *M)> VisibleCallback
A callback to call when a module is made visible (directly or indirectly) by a call to setVisible.
Definition: Module.h:693
clang::ASTSourceDescriptor::ASTSourceDescriptor
ASTSourceDescriptor()=default
clang::Module::Header
Information about a header directive as found in the module map file.
Definition: Module.h:192
clang::Module::print
void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const
Print the module map for this module to the given stream.
Definition: Module.cpp:431
clang::Module::IsUnimportable
unsigned IsUnimportable
Whether this module has declared itself unimportable, either because it's missing a requirement from ...
Definition: Module.h:249
clang::Module::getUmbrellaHeader
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:551
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:112
clang::Module::ConfigMacros
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:389
clang::Module::dump
void dump() const
Dump the contents of this module to the given output stream.
Definition: APINotesYAMLCompiler.cpp:577
clang::Module::IsExternC
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...
Definition: Module.h:276
clang::Module::ConfigMacrosExhaustive
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
Definition: Module.h:300
clang::Module::submodule_end
submodule_iterator submodule_end()
Definition: Module.h:625
clang::FileManager::getFile
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Definition: FileManager.cpp:196
clang::Module::getExportedModules
void getExportedModules(SmallVectorImpl< Module * > &Exported) const
Appends this module's list of exported modules to Exported.
Definition: Module.cpp:351
Parent
NodeId Parent
Definition: ASTDiff.cpp:192
clang::Module::addRequirement
void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)
Add the given feature requirement to the list of features required by this module.
Definition: Module.cpp:288
clang::Module::addTopHeader
void addTopHeader(const FileEntry *File)
Add a top-level header associated with this module.
Definition: Module.cpp:252
llvm::SmallVectorImpl
Definition: LLVM.h:39
FileManager.h
true
#define true
Definition: stdbool.h:16
clang::Module::ShadowingModule
Module * ShadowingModule
A module with the same name that shadows this module.
Definition: Module.h:244
clang::Module::UmbrellaRelativeToRootModuleDirectory
std::string UmbrellaRelativeToRootModuleDirectory
Definition: Module.h:145
clang::Module::ExportDecl
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
Definition: Module.h:333
clang::interp::Sub
bool Sub(InterpState &S, CodePtr OpPC)
Definition: Interp.h:142
hasFeature
static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)
Determine whether a translation unit built using the current language options has the given feature.
Definition: Module.cpp:101
clang::Module::UnresolvedHeaders
SmallVector< UnresolvedHeaderDirective, 1 > UnresolvedHeaders
Headers that are mentioned in the module map file but that we have not yet attempted to resolve to a ...
Definition: Module.h:227