contrib/llvm/tools/clang/lib/Basic/Module.cpp

   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),
  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
  47 Module::~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.
  56 static 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
  70 bool
  71 Module::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
  89 bool 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
 101 const Module *Module::getTopLevelModule() const {
 102   const Module *Result = this;
 103   while (Result->Parent)
 104     Result = Result->Parent;
 105
 106   return Result;
 107 }
 108
 109 std::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
 129 const DirectoryEntry *Module::getUmbrellaDir() const {
 130   if (const FileEntry *Header = getUmbrellaHeader())
 131     return Header->getDir();
 132
 133   return Umbrella.dyn_cast<const DirectoryEntry *>();
 134 }
 135
 136 ArrayRef<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
 149 void 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
 180 Module *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
 188 static 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
 196 void 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
 259 void 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
 276 void 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
 439 void Module::dump() const {
 440   print(llvm::errs());
 441 }
 442
 443