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 #include "clang/Basic/Module.h"
     15 #include "clang/Basic/FileManager.h"
     16 #include "clang/Basic/LangOptions.h"
     17 #include "clang/Basic/TargetInfo.h"
     18 #include "llvm/ADT/ArrayRef.h"
     19 #include "llvm/ADT/SmallVector.h"
     20 #include "llvm/ADT/StringSwitch.h"
     21 #include "llvm/Support/ErrorHandling.h"
     22 #include "llvm/Support/raw_ostream.h"
     23 using namespace clang;
     24 
     25 Module::Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent,
     26                bool IsFramework, bool IsExplicit)
     27   : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent),
     28     Umbrella(), ASTFile(0), IsAvailable(true), IsFromModuleFile(false),
     29     IsFramework(IsFramework), IsExplicit(IsExplicit), IsSystem(false),
     30     InferSubmodules(false), InferExplicitSubmodules(false),
     31     InferExportWildcard(false), NameVisibility(Hidden)
     32 {
     33   if (Parent) {
     34     if (!Parent->isAvailable())
     35       IsAvailable = false;
     36     if (Parent->IsSystem)
     37       IsSystem = true;
     38 
     39     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
     40     Parent->SubModules.push_back(this);
     41   }
     42 }
     43 
     44 Module::~Module() {
     45   for (submodule_iterator I = submodule_begin(), IEnd = submodule_end();
     46        I != IEnd; ++I) {
     47     delete *I;
     48   }
     49 
     50 }
     51 
     52 /// \brief Determine whether a translation unit built using the current
     53 /// language options has the given feature.
     54 static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
     55                        const TargetInfo &Target) {
     56   return llvm::StringSwitch<bool>(Feature)
     57            .Case("altivec", LangOpts.AltiVec)
     58            .Case("blocks", LangOpts.Blocks)
     59            .Case("cplusplus", LangOpts.CPlusPlus)
     60            .Case("cplusplus11", LangOpts.CPlusPlus11)
     61            .Case("objc", LangOpts.ObjC1)
     62            .Case("objc_arc", LangOpts.ObjCAutoRefCount)
     63            .Case("opencl", LangOpts.OpenCL)
     64            .Case("tls", Target.isTLSSupported())
     65            .Default(Target.hasFeature(Feature));
     66 }
     67 
     68 bool
     69 Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
     70                     StringRef &Feature) const {
     71   if (IsAvailable)
     72     return true;
     73 
     74   for (const Module *Current = this; Current; Current = Current->Parent) {
     75     for (unsigned I = 0, N = Current->Requires.size(); I != N; ++I) {
     76       if (!hasFeature(Current->Requires[I], LangOpts, Target)) {
     77         Feature = Current->Requires[I];
     78         return false;
     79       }
     80     }
     81   }
     82 
     83   llvm_unreachable("could not find a reason why module is unavailable");
     84 }
     85 
     86 bool Module::isSubModuleOf(Module *Other) const {
     87   const Module *This = this;
     88   do {
     89     if (This == Other)
     90       return true;
     91 
     92     This = This->Parent;
     93   } while (This);
     94 
     95   return false;
     96 }
     97 
     98 const Module *Module::getTopLevelModule() const {
     99   const Module *Result = this;
    100   while (Result->Parent)
    101     Result = Result->Parent;
    102 
    103   return Result;
    104 }
    105 
    106 std::string Module::getFullModuleName() const {
    107   SmallVector<StringRef, 2> Names;
    108 
    109   // Build up the set of module names (from innermost to outermost).
    110   for (const Module *M = this; M; M = M->Parent)
    111     Names.push_back(M->Name);
    112 
    113   std::string Result;
    114   for (SmallVector<StringRef, 2>::reverse_iterator I = Names.rbegin(),
    115                                                 IEnd = Names.rend();
    116        I != IEnd; ++I) {
    117     if (!Result.empty())
    118       Result += '.';
    119 
    120     Result += *I;
    121   }
    122 
    123   return Result;
    124 }
    125 
    126 const DirectoryEntry *Module::getUmbrellaDir() const {
    127   if (const FileEntry *Header = getUmbrellaHeader())
    128     return Header->getDir();
    129 
    130   return Umbrella.dyn_cast<const DirectoryEntry *>();
    131 }
    132 
    133 ArrayRef<const FileEntry *> Module::getTopHeaders(FileManager &FileMgr) {
    134   if (!TopHeaderNames.empty()) {
    135     for (std::vector<std::string>::iterator
    136            I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
    137       if (const FileEntry *FE = FileMgr.getFile(*I))
    138         TopHeaders.insert(FE);
    139     }
    140     TopHeaderNames.clear();
    141   }
    142 
    143   return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end());
    144 }
    145 
    146 void Module::addRequirement(StringRef Feature, const LangOptions &LangOpts,
    147                             const TargetInfo &Target) {
    148   Requires.push_back(Feature);
    149 
    150   // If this feature is currently available, we're done.
    151   if (hasFeature(Feature, LangOpts, Target))
    152     return;
    153 
    154   if (!IsAvailable)
    155     return;
    156 
    157   SmallVector<Module *, 2> Stack;
    158   Stack.push_back(this);
    159   while (!Stack.empty()) {
    160     Module *Current = Stack.back();
    161     Stack.pop_back();
    162 
    163     if (!Current->IsAvailable)
    164       continue;
    165 
    166     Current->IsAvailable = false;
    167     for (submodule_iterator Sub = Current->submodule_begin(),
    168                          SubEnd = Current->submodule_end();
    169          Sub != SubEnd; ++Sub) {
    170       if ((*Sub)->IsAvailable)
    171         Stack.push_back(*Sub);
    172     }
    173   }
    174 }
    175 
    176 Module *Module::findSubmodule(StringRef Name) const {
    177   llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
    178   if (Pos == SubModuleIndex.end())
    179     return 0;
    180 
    181   return SubModules[Pos->getValue()];
    182 }
    183 
    184 static void printModuleId(raw_ostream &OS, const ModuleId &Id) {
    185   for (unsigned I = 0, N = Id.size(); I != N; ++I) {
    186     if (I)
    187       OS << ".";
    188     OS << Id[I].first;
    189   }
    190 }
    191 
    192 void Module::getExportedModules(SmallVectorImpl<Module *> &Exported) const {
    193   bool AnyWildcard = false;
    194   bool UnrestrictedWildcard = false;
    195   SmallVector<Module *, 4> WildcardRestrictions;
    196   for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
    197     Module *Mod = Exports[I].getPointer();
    198     if (!Exports[I].getInt()) {
    199       // Export a named module directly; no wildcards involved.
    200       Exported.push_back(Mod);
    201 
    202       continue;
    203     }
    204 
    205     // Wildcard export: export all of the imported modules that match
    206     // the given pattern.
    207     AnyWildcard = true;
    208     if (UnrestrictedWildcard)
    209       continue;
    210 
    211     if (Module *Restriction = Exports[I].getPointer())
    212       WildcardRestrictions.push_back(Restriction);
    213     else {
    214       WildcardRestrictions.clear();
    215       UnrestrictedWildcard = true;
    216     }
    217   }
    218 
    219   // If there were any wildcards, push any imported modules that were
    220   // re-exported by the wildcard restriction.
    221   if (!AnyWildcard)
    222     return;
    223 
    224   for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
    225     Module *Mod = Imports[I];
    226     bool Acceptable = UnrestrictedWildcard;
    227     if (!Acceptable) {
    228       // Check whether this module meets one of the restrictions.
    229       for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
    230         Module *Restriction = WildcardRestrictions[R];
    231         if (Mod == Restriction || Mod->isSubModuleOf(Restriction)) {
    232           Acceptable = true;
    233           break;
    234         }
    235       }
    236     }
    237 
    238     if (!Acceptable)
    239       continue;
    240 
    241     Exported.push_back(Mod);
    242   }
    243 }
    244 
    245 void Module::print(raw_ostream &OS, unsigned Indent) const {
    246   OS.indent(Indent);
    247   if (IsFramework)
    248     OS << "framework ";
    249   if (IsExplicit)
    250     OS << "explicit ";
    251   OS << "module " << Name;
    252 
    253   if (IsSystem) {
    254     OS.indent(Indent + 2);
    255     OS << " [system]";
    256   }
    257 
    258   OS << " {\n";
    259 
    260   if (!Requires.empty()) {
    261     OS.indent(Indent + 2);
    262     OS << "requires ";
    263     for (unsigned I = 0, N = Requires.size(); I != N; ++I) {
    264       if (I)
    265         OS << ", ";
    266       OS << Requires[I];
    267     }
    268     OS << "\n";
    269   }
    270 
    271   if (const FileEntry *UmbrellaHeader = getUmbrellaHeader()) {
    272     OS.indent(Indent + 2);
    273     OS << "umbrella header \"";
    274     OS.write_escaped(UmbrellaHeader->getName());
    275     OS << "\"\n";
    276   } else if (const DirectoryEntry *UmbrellaDir = getUmbrellaDir()) {
    277     OS.indent(Indent + 2);
    278     OS << "umbrella \"";
    279     OS.write_escaped(UmbrellaDir->getName());
    280     OS << "\"\n";
    281   }
    282 
    283   for (unsigned I = 0, N = Headers.size(); I != N; ++I) {
    284     OS.indent(Indent + 2);
    285     OS << "header \"";
    286     OS.write_escaped(Headers[I]->getName());
    287     OS << "\"\n";
    288   }
    289 
    290   for (unsigned I = 0, N = ExcludedHeaders.size(); I != N; ++I) {
    291     OS.indent(Indent + 2);
    292     OS << "exclude header \"";
    293     OS.write_escaped(ExcludedHeaders[I]->getName());
    294     OS << "\"\n";
    295   }
    296 
    297   for (submodule_const_iterator MI = submodule_begin(), MIEnd = submodule_end();
    298        MI != MIEnd; ++MI)
    299     (*MI)->print(OS, Indent + 2);
    300 
    301   for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
    302     OS.indent(Indent + 2);
    303     OS << "export ";
    304     if (Module *Restriction = Exports[I].getPointer()) {
    305       OS << Restriction->getFullModuleName();
    306       if (Exports[I].getInt())
    307         OS << ".*";
    308     } else {
    309       OS << "*";
    310     }
    311     OS << "\n";
    312   }
    313 
    314   for (unsigned I = 0, N = UnresolvedExports.size(); I != N; ++I) {
    315     OS.indent(Indent + 2);
    316     OS << "export ";
    317     printModuleId(OS, UnresolvedExports[I].Id);
    318     if (UnresolvedExports[I].Wildcard) {
    319       if (UnresolvedExports[I].Id.empty())
    320         OS << "*";
    321       else
    322         OS << ".*";
    323     }
    324     OS << "\n";
    325   }
    326 
    327   for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
    328     OS.indent(Indent + 2);
    329     OS << "link ";
    330     if (LinkLibraries[I].IsFramework)
    331       OS << "framework ";
    332     OS << "\"";
    333     OS.write_escaped(LinkLibraries[I].Library);
    334     OS << "\"";
    335   }
    336 
    337   if (InferSubmodules) {
    338     OS.indent(Indent + 2);
    339     if (InferExplicitSubmodules)
    340       OS << "explicit ";
    341     OS << "module * {\n";
    342     if (InferExportWildcard) {
    343       OS.indent(Indent + 4);
    344       OS << "export *\n";
    345     }
    346     OS.indent(Indent + 2);
    347     OS << "}\n";
    348   }
    349 
    350   OS.indent(Indent);
    351   OS << "}\n";
    352 }
    353 
    354 void Module::dump() const {
    355   print(llvm::errs());
    356 }
    357 
    358 
    359