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