contrib/llvm/tools/clang/lib/CrossTU/CrossTranslationUnit.cpp

   1 //===--- CrossTranslationUnit.cpp - -----------------------------*- C++ -*-===//
   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 implements the CrossTranslationUnit interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #include "clang/CrossTU/CrossTranslationUnit.h"
  14 #include "clang/AST/ASTImporter.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/Basic/TargetInfo.h"
  17 #include "clang/CrossTU/CrossTUDiagnostic.h"
  18 #include "clang/Frontend/ASTUnit.h"
  19 #include "clang/Frontend/CompilerInstance.h"
  20 #include "clang/Frontend/TextDiagnosticPrinter.h"
  21 #include "clang/Index/USRGeneration.h"
  22 #include "llvm/ADT/Triple.h"
  23 #include "llvm/ADT/Statistic.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25 #include "llvm/Support/ManagedStatic.h"
  26 #include "llvm/Support/Path.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include <fstream>
  29 #include <sstream>
  30
  31 namespace clang {
  32 namespace cross_tu {
  33
  34 namespace {
  35
  36 #define DEBUG_TYPE "CrossTranslationUnit"
  37 STATISTIC(NumGetCTUCalled, "The # of getCTUDefinition function called");
  38 STATISTIC(
  39     NumNotInOtherTU,
  40     "The # of getCTUDefinition called but the function is not in any other TU");
  41 STATISTIC(NumGetCTUSuccess,
  42           "The # of getCTUDefinition successfully returned the "
  43           "requested function's body");
  44 STATISTIC(NumTripleMismatch, "The # of triple mismatches");
  45 STATISTIC(NumLangMismatch, "The # of language mismatches");
  46
  47 // Same as Triple's equality operator, but we check a field only if that is
  48 // known in both instances.
  49 bool hasEqualKnownFields(const llvm::Triple &Lhs, const llvm::Triple &Rhs) {
  50   using llvm::Triple;
  51   if (Lhs.getArch() != Triple::UnknownArch &&
  52       Rhs.getArch() != Triple::UnknownArch && Lhs.getArch() != Rhs.getArch())
  53     return false;
  54   if (Lhs.getSubArch() != Triple::NoSubArch &&
  55       Rhs.getSubArch() != Triple::NoSubArch &&
  56       Lhs.getSubArch() != Rhs.getSubArch())
  57     return false;
  58   if (Lhs.getVendor() != Triple::UnknownVendor &&
  59       Rhs.getVendor() != Triple::UnknownVendor &&
  60       Lhs.getVendor() != Rhs.getVendor())
  61     return false;
  62   if (!Lhs.isOSUnknown() && !Rhs.isOSUnknown() &&
  63       Lhs.getOS() != Rhs.getOS())
  64     return false;
  65   if (Lhs.getEnvironment() != Triple::UnknownEnvironment &&
  66       Rhs.getEnvironment() != Triple::UnknownEnvironment &&
  67       Lhs.getEnvironment() != Rhs.getEnvironment())
  68     return false;
  69   if (Lhs.getObjectFormat() != Triple::UnknownObjectFormat &&
  70       Rhs.getObjectFormat() != Triple::UnknownObjectFormat &&
  71       Lhs.getObjectFormat() != Rhs.getObjectFormat())
  72     return false;
  73   return true;
  74 }
  75
  76 // FIXME: This class is will be removed after the transition to llvm::Error.
  77 class IndexErrorCategory : public std::error_category {
  78 public:
  79   const char *name() const noexcept override { return "clang.index"; }
  80
  81   std::string message(int Condition) const override {
  82     switch (static_cast<index_error_code>(Condition)) {
  83     case index_error_code::unspecified:
  84       return "An unknown error has occurred.";
  85     case index_error_code::missing_index_file:
  86       return "The index file is missing.";
  87     case index_error_code::invalid_index_format:
  88       return "Invalid index file format.";
  89     case index_error_code::multiple_definitions:
  90       return "Multiple definitions in the index file.";
  91     case index_error_code::missing_definition:
  92       return "Missing definition from the index file.";
  93     case index_error_code::failed_import:
  94       return "Failed to import the definition.";
  95     case index_error_code::failed_to_get_external_ast:
  96       return "Failed to load external AST source.";
  97     case index_error_code::failed_to_generate_usr:
  98       return "Failed to generate USR.";
  99     case index_error_code::triple_mismatch:
 100       return "Triple mismatch";
 101     case index_error_code::lang_mismatch:
 102       return "Language mismatch";
 103     }
 104     llvm_unreachable("Unrecognized index_error_code.");
 105   }
 106 };
 107
 108 static llvm::ManagedStatic<IndexErrorCategory> Category;
 109 } // end anonymous namespace
 110
 111 char IndexError::ID;
 112
 113 void IndexError::log(raw_ostream &OS) const {
 114   OS << Category->message(static_cast<int>(Code)) << '\n';
 115 }
 116
 117 std::error_code IndexError::convertToErrorCode() const {
 118   return std::error_code(static_cast<int>(Code), *Category);
 119 }
 120
 121 llvm::Expected<llvm::StringMap<std::string>>
 122 parseCrossTUIndex(StringRef IndexPath, StringRef CrossTUDir) {
 123   std::ifstream ExternalMapFile(IndexPath);
 124   if (!ExternalMapFile)
 125     return llvm::make_error<IndexError>(index_error_code::missing_index_file,
 126                                         IndexPath.str());
 127
 128   llvm::StringMap<std::string> Result;
 129   std::string Line;
 130   unsigned LineNo = 1;
 131   while (std::getline(ExternalMapFile, Line)) {
 132     const size_t Pos = Line.find(" ");
 133     if (Pos > 0 && Pos != std::string::npos) {
 134       StringRef LineRef{Line};
 135       StringRef LookupName = LineRef.substr(0, Pos);
 136       if (Result.count(LookupName))
 137         return llvm::make_error<IndexError>(
 138             index_error_code::multiple_definitions, IndexPath.str(), LineNo);
 139       StringRef FileName = LineRef.substr(Pos + 1);
 140       SmallString<256> FilePath = CrossTUDir;
 141       llvm::sys::path::append(FilePath, FileName);
 142       Result[LookupName] = FilePath.str().str();
 143     } else
 144       return llvm::make_error<IndexError>(
 145           index_error_code::invalid_index_format, IndexPath.str(), LineNo);
 146     LineNo++;
 147   }
 148   return Result;
 149 }
 150
 151 std::string
 152 createCrossTUIndexString(const llvm::StringMap<std::string> &Index) {
 153   std::ostringstream Result;
 154   for (const auto &E : Index)
 155     Result << E.getKey().str() << " " << E.getValue() << '\n';
 156   return Result.str();
 157 }
 158
 159 CrossTranslationUnitContext::CrossTranslationUnitContext(CompilerInstance &CI)
 160     : CI(CI), Context(CI.getASTContext()) {}
 161
 162 CrossTranslationUnitContext::~CrossTranslationUnitContext() {}
 163
 164 std::string CrossTranslationUnitContext::getLookupName(const NamedDecl *ND) {
 165   SmallString<128> DeclUSR;
 166   bool Ret = index::generateUSRForDecl(ND, DeclUSR); (void)Ret;
 167   assert(!Ret && "Unable to generate USR");
 168   return DeclUSR.str();
 169 }
 170
 171 /// Recursively visits the function decls of a DeclContext, and looks up a
 172 /// function based on USRs.
 173 const FunctionDecl *
 174 CrossTranslationUnitContext::findFunctionInDeclContext(const DeclContext *DC,
 175                                                        StringRef LookupFnName) {
 176   assert(DC && "Declaration Context must not be null");
 177   for (const Decl *D : DC->decls()) {
 178     const auto *SubDC = dyn_cast<DeclContext>(D);
 179     if (SubDC)
 180       if (const auto *FD = findFunctionInDeclContext(SubDC, LookupFnName))
 181         return FD;
 182
 183     const auto *ND = dyn_cast<FunctionDecl>(D);
 184     const FunctionDecl *ResultDecl;
 185     if (!ND || !ND->hasBody(ResultDecl))
 186       continue;
 187     if (getLookupName(ResultDecl) != LookupFnName)
 188       continue;
 189     return ResultDecl;
 190   }
 191   return nullptr;
 192 }
 193
 194 llvm::Expected<const FunctionDecl *>
 195 CrossTranslationUnitContext::getCrossTUDefinition(const FunctionDecl *FD,
 196                                                   StringRef CrossTUDir,
 197                                                   StringRef IndexName,
 198                                                   bool DisplayCTUProgress) {
 199   assert(FD && "FD is missing, bad call to this function!");
 200   assert(!FD->hasBody() && "FD has a definition in current translation unit!");
 201   ++NumGetCTUCalled;
 202   const std::string LookupFnName = getLookupName(FD);
 203   if (LookupFnName.empty())
 204     return llvm::make_error<IndexError>(
 205         index_error_code::failed_to_generate_usr);
 206   llvm::Expected<ASTUnit *> ASTUnitOrError =
 207       loadExternalAST(LookupFnName, CrossTUDir, IndexName, DisplayCTUProgress);
 208   if (!ASTUnitOrError)
 209     return ASTUnitOrError.takeError();
 210   ASTUnit *Unit = *ASTUnitOrError;
 211   assert(&Unit->getFileManager() ==
 212          &Unit->getASTContext().getSourceManager().getFileManager());
 213
 214   const llvm::Triple &TripleTo = Context.getTargetInfo().getTriple();
 215   const llvm::Triple &TripleFrom =
 216       Unit->getASTContext().getTargetInfo().getTriple();
 217   // The imported AST had been generated for a different target.
 218   // Some parts of the triple in the loaded ASTContext can be unknown while the
 219   // very same parts in the target ASTContext are known. Thus we check for the
 220   // known parts only.
 221   if (!hasEqualKnownFields(TripleTo, TripleFrom)) {
 222     // TODO: Pass the SourceLocation of the CallExpression for more precise
 223     // diagnostics.
 224     ++NumTripleMismatch;
 225     return llvm::make_error<IndexError>(index_error_code::triple_mismatch,
 226                                         Unit->getMainFileName(), TripleTo.str(),
 227                                         TripleFrom.str());
 228   }
 229
 230   const auto &LangTo = Context.getLangOpts();
 231   const auto &LangFrom = Unit->getASTContext().getLangOpts();
 232   // FIXME: Currenty we do not support CTU across C++ and C and across
 233   // different dialects of C++.
 234   if (LangTo.CPlusPlus != LangFrom.CPlusPlus) {
 235     ++NumLangMismatch;
 236     return llvm::make_error<IndexError>(index_error_code::lang_mismatch);
 237   }
 238
 239   TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
 240   if (const FunctionDecl *ResultDecl =
 241           findFunctionInDeclContext(TU, LookupFnName))
 242     return importDefinition(ResultDecl);
 243   return llvm::make_error<IndexError>(index_error_code::failed_import);
 244 }
 245
 246 void CrossTranslationUnitContext::emitCrossTUDiagnostics(const IndexError &IE) {
 247   switch (IE.getCode()) {
 248   case index_error_code::missing_index_file:
 249     Context.getDiagnostics().Report(diag::err_ctu_error_opening)
 250         << IE.getFileName();
 251     break;
 252   case index_error_code::invalid_index_format:
 253     Context.getDiagnostics().Report(diag::err_extdefmap_parsing)
 254         << IE.getFileName() << IE.getLineNum();
 255     break;
 256   case index_error_code::multiple_definitions:
 257     Context.getDiagnostics().Report(diag::err_multiple_def_index)
 258         << IE.getLineNum();
 259     break;
 260   case index_error_code::triple_mismatch:
 261     Context.getDiagnostics().Report(diag::warn_ctu_incompat_triple)
 262         << IE.getFileName() << IE.getTripleToName() << IE.getTripleFromName();
 263     break;
 264   default:
 265     break;
 266   }
 267 }
 268
 269 llvm::Expected<ASTUnit *> CrossTranslationUnitContext::loadExternalAST(
 270     StringRef LookupName, StringRef CrossTUDir, StringRef IndexName,
 271     bool DisplayCTUProgress) {
 272   // FIXME: The current implementation only supports loading functions with
 273   //        a lookup name from a single translation unit. If multiple
 274   //        translation units contains functions with the same lookup name an
 275   //        error will be returned.
 276   ASTUnit *Unit = nullptr;
 277   auto FnUnitCacheEntry = FunctionASTUnitMap.find(LookupName);
 278   if (FnUnitCacheEntry == FunctionASTUnitMap.end()) {
 279     if (FunctionFileMap.empty()) {
 280       SmallString<256> IndexFile = CrossTUDir;
 281       if (llvm::sys::path::is_absolute(IndexName))
 282         IndexFile = IndexName;
 283       else
 284         llvm::sys::path::append(IndexFile, IndexName);
 285       llvm::Expected<llvm::StringMap<std::string>> IndexOrErr =
 286           parseCrossTUIndex(IndexFile, CrossTUDir);
 287       if (IndexOrErr)
 288         FunctionFileMap = *IndexOrErr;
 289       else
 290         return IndexOrErr.takeError();
 291     }
 292
 293     auto It = FunctionFileMap.find(LookupName);
 294     if (It == FunctionFileMap.end()) {
 295       ++NumNotInOtherTU;
 296       return llvm::make_error<IndexError>(index_error_code::missing_definition);
 297     }
 298     StringRef ASTFileName = It->second;
 299     auto ASTCacheEntry = FileASTUnitMap.find(ASTFileName);
 300     if (ASTCacheEntry == FileASTUnitMap.end()) {
 301       IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 302       TextDiagnosticPrinter *DiagClient =
 303           new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
 304       IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
 305       IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
 306           new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient));
 307
 308       std::unique_ptr<ASTUnit> LoadedUnit(ASTUnit::LoadFromASTFile(
 309           ASTFileName, CI.getPCHContainerOperations()->getRawReader(),
 310           ASTUnit::LoadEverything, Diags, CI.getFileSystemOpts()));
 311       Unit = LoadedUnit.get();
 312       FileASTUnitMap[ASTFileName] = std::move(LoadedUnit);
 313       if (DisplayCTUProgress) {
 314         llvm::errs() << "CTU loaded AST file: "
 315                      << ASTFileName << "\n";
 316       }
 317     } else {
 318       Unit = ASTCacheEntry->second.get();
 319     }
 320     FunctionASTUnitMap[LookupName] = Unit;
 321   } else {
 322     Unit = FnUnitCacheEntry->second;
 323   }
 324   if (!Unit)
 325     return llvm::make_error<IndexError>(
 326         index_error_code::failed_to_get_external_ast);
 327   return Unit;
 328 }
 329
 330 llvm::Expected<const FunctionDecl *>
 331 CrossTranslationUnitContext::importDefinition(const FunctionDecl *FD) {
 332   assert(FD->hasBody() && "Functions to be imported should have body.");
 333
 334   ASTImporter &Importer = getOrCreateASTImporter(FD->getASTContext());
 335   auto *ToDecl =
 336       cast_or_null<FunctionDecl>(Importer.Import(const_cast<FunctionDecl *>(FD)));
 337   if (!ToDecl)
 338     return llvm::make_error<IndexError>(index_error_code::failed_import);
 339   assert(ToDecl->hasBody());
 340   assert(FD->hasBody() && "Functions already imported should have body.");
 341   ++NumGetCTUSuccess;
 342   return ToDecl;
 343 }
 344
 345 void CrossTranslationUnitContext::lazyInitLookupTable(
 346     TranslationUnitDecl *ToTU) {
 347   if (!LookupTable)
 348     LookupTable = llvm::make_unique<ASTImporterLookupTable>(*ToTU);
 349 }
 350
 351 ASTImporter &
 352 CrossTranslationUnitContext::getOrCreateASTImporter(ASTContext &From) {
 353   auto I = ASTUnitImporterMap.find(From.getTranslationUnitDecl());
 354   if (I != ASTUnitImporterMap.end())
 355     return *I->second;
 356   lazyInitLookupTable(Context.getTranslationUnitDecl());
 357   ASTImporter *NewImporter = new ASTImporter(
 358       Context, Context.getSourceManager().getFileManager(), From,
 359       From.getSourceManager().getFileManager(), false, LookupTable.get());
 360   ASTUnitImporterMap[From.getTranslationUnitDecl()].reset(NewImporter);
 361   return *NewImporter;
 362 }
 363
 364 } // namespace cross_tu
 365 } // namespace clang