diff options
Diffstat (limited to 'clang/lib/CrossTU/CrossTranslationUnit.cpp')
| -rw-r--r-- | clang/lib/CrossTU/CrossTranslationUnit.cpp | 588 |
1 files changed, 588 insertions, 0 deletions
diff --git a/clang/lib/CrossTU/CrossTranslationUnit.cpp b/clang/lib/CrossTU/CrossTranslationUnit.cpp new file mode 100644 index 000000000000..7391d7132daf --- /dev/null +++ b/clang/lib/CrossTU/CrossTranslationUnit.cpp @@ -0,0 +1,588 @@ +//===--- CrossTranslationUnit.cpp - -----------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file implements the CrossTranslationUnit interface. +// +//===----------------------------------------------------------------------===// +#include "clang/CrossTU/CrossTranslationUnit.h" +#include "clang/AST/ASTImporter.h" +#include "clang/AST/Decl.h" +#include "clang/Basic/TargetInfo.h" +#include "clang/CrossTU/CrossTUDiagnostic.h" +#include "clang/Frontend/ASTUnit.h" +#include "clang/Frontend/CompilerInstance.h" +#include "clang/Frontend/TextDiagnosticPrinter.h" +#include "clang/Index/USRGeneration.h" +#include "llvm/ADT/Triple.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/raw_ostream.h" +#include <fstream> +#include <sstream> + +namespace clang { +namespace cross_tu { + +namespace { + +#define DEBUG_TYPE "CrossTranslationUnit" +STATISTIC(NumGetCTUCalled, "The # of getCTUDefinition function called"); +STATISTIC( + NumNotInOtherTU, + "The # of getCTUDefinition called but the function is not in any other TU"); +STATISTIC(NumGetCTUSuccess, + "The # of getCTUDefinition successfully returned the " + "requested function's body"); +STATISTIC(NumUnsupportedNodeFound, "The # of imports when the ASTImporter " + "encountered an unsupported AST Node"); +STATISTIC(NumNameConflicts, "The # of imports when the ASTImporter " + "encountered an ODR error"); +STATISTIC(NumTripleMismatch, "The # of triple mismatches"); +STATISTIC(NumLangMismatch, "The # of language mismatches"); +STATISTIC(NumLangDialectMismatch, "The # of language dialect mismatches"); +STATISTIC(NumASTLoadThresholdReached, + "The # of ASTs not loaded because of threshold"); + +// Same as Triple's equality operator, but we check a field only if that is +// known in both instances. +bool hasEqualKnownFields(const llvm::Triple &Lhs, const llvm::Triple &Rhs) { + using llvm::Triple; + if (Lhs.getArch() != Triple::UnknownArch && + Rhs.getArch() != Triple::UnknownArch && Lhs.getArch() != Rhs.getArch()) + return false; + if (Lhs.getSubArch() != Triple::NoSubArch && + Rhs.getSubArch() != Triple::NoSubArch && + Lhs.getSubArch() != Rhs.getSubArch()) + return false; + if (Lhs.getVendor() != Triple::UnknownVendor && + Rhs.getVendor() != Triple::UnknownVendor && + Lhs.getVendor() != Rhs.getVendor()) + return false; + if (!Lhs.isOSUnknown() && !Rhs.isOSUnknown() && + Lhs.getOS() != Rhs.getOS()) + return false; + if (Lhs.getEnvironment() != Triple::UnknownEnvironment && + Rhs.getEnvironment() != Triple::UnknownEnvironment && + Lhs.getEnvironment() != Rhs.getEnvironment()) + return false; + if (Lhs.getObjectFormat() != Triple::UnknownObjectFormat && + Rhs.getObjectFormat() != Triple::UnknownObjectFormat && + Lhs.getObjectFormat() != Rhs.getObjectFormat()) + return false; + return true; +} + +// FIXME: This class is will be removed after the transition to llvm::Error. +class IndexErrorCategory : public std::error_category { +public: + const char *name() const noexcept override { return "clang.index"; } + + std::string message(int Condition) const override { + switch (static_cast<index_error_code>(Condition)) { + case index_error_code::unspecified: + return "An unknown error has occurred."; + case index_error_code::missing_index_file: + return "The index file is missing."; + case index_error_code::invalid_index_format: + return "Invalid index file format."; + case index_error_code::multiple_definitions: + return "Multiple definitions in the index file."; + case index_error_code::missing_definition: + return "Missing definition from the index file."; + case index_error_code::failed_import: + return "Failed to import the definition."; + case index_error_code::failed_to_get_external_ast: + return "Failed to load external AST source."; + case index_error_code::failed_to_generate_usr: + return "Failed to generate USR."; + case index_error_code::triple_mismatch: + return "Triple mismatch"; + case index_error_code::lang_mismatch: + return "Language mismatch"; + case index_error_code::lang_dialect_mismatch: + return "Language dialect mismatch"; + case index_error_code::load_threshold_reached: + return "Load threshold reached"; + } + llvm_unreachable("Unrecognized index_error_code."); + } +}; + +static llvm::ManagedStatic<IndexErrorCategory> Category; +} // end anonymous namespace + +char IndexError::ID; + +void IndexError::log(raw_ostream &OS) const { + OS << Category->message(static_cast<int>(Code)) << '\n'; +} + +std::error_code IndexError::convertToErrorCode() const { + return std::error_code(static_cast<int>(Code), *Category); +} + +llvm::Expected<llvm::StringMap<std::string>> +parseCrossTUIndex(StringRef IndexPath, StringRef CrossTUDir) { + std::ifstream ExternalMapFile(IndexPath); + if (!ExternalMapFile) + return llvm::make_error<IndexError>(index_error_code::missing_index_file, + IndexPath.str()); + + llvm::StringMap<std::string> Result; + std::string Line; + unsigned LineNo = 1; + while (std::getline(ExternalMapFile, Line)) { + const size_t Pos = Line.find(" "); + if (Pos > 0 && Pos != std::string::npos) { + StringRef LineRef{Line}; + StringRef LookupName = LineRef.substr(0, Pos); + if (Result.count(LookupName)) + return llvm::make_error<IndexError>( + index_error_code::multiple_definitions, IndexPath.str(), LineNo); + StringRef FileName = LineRef.substr(Pos + 1); + SmallString<256> FilePath = CrossTUDir; + llvm::sys::path::append(FilePath, FileName); + Result[LookupName] = FilePath.str().str(); + } else + return llvm::make_error<IndexError>( + index_error_code::invalid_index_format, IndexPath.str(), LineNo); + LineNo++; + } + return Result; +} + +std::string +createCrossTUIndexString(const llvm::StringMap<std::string> &Index) { + std::ostringstream Result; + for (const auto &E : Index) + Result << E.getKey().str() << " " << E.getValue() << '\n'; + return Result.str(); +} + +bool containsConst(const VarDecl *VD, const ASTContext &ACtx) { + CanQualType CT = ACtx.getCanonicalType(VD->getType()); + if (!CT.isConstQualified()) { + const RecordType *RTy = CT->getAs<RecordType>(); + if (!RTy || !RTy->hasConstFields()) + return false; + } + return true; +} + +static bool hasBodyOrInit(const FunctionDecl *D, const FunctionDecl *&DefD) { + return D->hasBody(DefD); +} +static bool hasBodyOrInit(const VarDecl *D, const VarDecl *&DefD) { + return D->getAnyInitializer(DefD); +} +template <typename T> static bool hasBodyOrInit(const T *D) { + const T *Unused; + return hasBodyOrInit(D, Unused); +} + +CrossTranslationUnitContext::CrossTranslationUnitContext(CompilerInstance &CI) + : Context(CI.getASTContext()), ASTStorage(CI) {} + +CrossTranslationUnitContext::~CrossTranslationUnitContext() {} + +llvm::Optional<std::string> +CrossTranslationUnitContext::getLookupName(const NamedDecl *ND) { + SmallString<128> DeclUSR; + bool Ret = index::generateUSRForDecl(ND, DeclUSR); + if (Ret) + return {}; + return std::string(DeclUSR.str()); +} + +/// Recursively visits the decls of a DeclContext, and returns one with the +/// given USR. +template <typename T> +const T * +CrossTranslationUnitContext::findDefInDeclContext(const DeclContext *DC, + StringRef LookupName) { + assert(DC && "Declaration Context must not be null"); + for (const Decl *D : DC->decls()) { + const auto *SubDC = dyn_cast<DeclContext>(D); + if (SubDC) + if (const auto *ND = findDefInDeclContext<T>(SubDC, LookupName)) + return ND; + + const auto *ND = dyn_cast<T>(D); + const T *ResultDecl; + if (!ND || !hasBodyOrInit(ND, ResultDecl)) + continue; + llvm::Optional<std::string> ResultLookupName = getLookupName(ResultDecl); + if (!ResultLookupName || *ResultLookupName != LookupName) + continue; + return ResultDecl; + } + return nullptr; +} + +template <typename T> +llvm::Expected<const T *> CrossTranslationUnitContext::getCrossTUDefinitionImpl( + const T *D, StringRef CrossTUDir, StringRef IndexName, + bool DisplayCTUProgress) { + assert(D && "D is missing, bad call to this function!"); + assert(!hasBodyOrInit(D) && + "D has a body or init in current translation unit!"); + ++NumGetCTUCalled; + const llvm::Optional<std::string> LookupName = getLookupName(D); + if (!LookupName) + return llvm::make_error<IndexError>( + index_error_code::failed_to_generate_usr); + llvm::Expected<ASTUnit *> ASTUnitOrError = + loadExternalAST(*LookupName, CrossTUDir, IndexName, DisplayCTUProgress); + if (!ASTUnitOrError) + return ASTUnitOrError.takeError(); + ASTUnit *Unit = *ASTUnitOrError; + assert(&Unit->getFileManager() == + &Unit->getASTContext().getSourceManager().getFileManager()); + + const llvm::Triple &TripleTo = Context.getTargetInfo().getTriple(); + const llvm::Triple &TripleFrom = + Unit->getASTContext().getTargetInfo().getTriple(); + // The imported AST had been generated for a different target. + // Some parts of the triple in the loaded ASTContext can be unknown while the + // very same parts in the target ASTContext are known. Thus we check for the + // known parts only. + if (!hasEqualKnownFields(TripleTo, TripleFrom)) { + // TODO: Pass the SourceLocation of the CallExpression for more precise + // diagnostics. + ++NumTripleMismatch; + return llvm::make_error<IndexError>(index_error_code::triple_mismatch, + Unit->getMainFileName(), TripleTo.str(), + TripleFrom.str()); + } + + const auto &LangTo = Context.getLangOpts(); + const auto &LangFrom = Unit->getASTContext().getLangOpts(); + + // FIXME: Currenty we do not support CTU across C++ and C and across + // different dialects of C++. + if (LangTo.CPlusPlus != LangFrom.CPlusPlus) { + ++NumLangMismatch; + return llvm::make_error<IndexError>(index_error_code::lang_mismatch); + } + + // If CPP dialects are different then return with error. + // + // Consider this STL code: + // template<typename _Alloc> + // struct __alloc_traits + // #if __cplusplus >= 201103L + // : std::allocator_traits<_Alloc> + // #endif + // { // ... + // }; + // This class template would create ODR errors during merging the two units, + // since in one translation unit the class template has a base class, however + // in the other unit it has none. + if (LangTo.CPlusPlus11 != LangFrom.CPlusPlus11 || + LangTo.CPlusPlus14 != LangFrom.CPlusPlus14 || + LangTo.CPlusPlus17 != LangFrom.CPlusPlus17 || + LangTo.CPlusPlus2a != LangFrom.CPlusPlus2a) { + ++NumLangDialectMismatch; + return llvm::make_error<IndexError>( + index_error_code::lang_dialect_mismatch); + } + + TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl(); + if (const T *ResultDecl = findDefInDeclContext<T>(TU, *LookupName)) + return importDefinition(ResultDecl, Unit); + return llvm::make_error<IndexError>(index_error_code::failed_import); +} + +llvm::Expected<const FunctionDecl *> +CrossTranslationUnitContext::getCrossTUDefinition(const FunctionDecl *FD, + StringRef CrossTUDir, + StringRef IndexName, + bool DisplayCTUProgress) { + return getCrossTUDefinitionImpl(FD, CrossTUDir, IndexName, + DisplayCTUProgress); +} + +llvm::Expected<const VarDecl *> +CrossTranslationUnitContext::getCrossTUDefinition(const VarDecl *VD, + StringRef CrossTUDir, + StringRef IndexName, + bool DisplayCTUProgress) { + return getCrossTUDefinitionImpl(VD, CrossTUDir, IndexName, + DisplayCTUProgress); +} + +void CrossTranslationUnitContext::emitCrossTUDiagnostics(const IndexError &IE) { + switch (IE.getCode()) { + case index_error_code::missing_index_file: + Context.getDiagnostics().Report(diag::err_ctu_error_opening) + << IE.getFileName(); + break; + case index_error_code::invalid_index_format: + Context.getDiagnostics().Report(diag::err_extdefmap_parsing) + << IE.getFileName() << IE.getLineNum(); + break; + case index_error_code::multiple_definitions: + Context.getDiagnostics().Report(diag::err_multiple_def_index) + << IE.getLineNum(); + break; + case index_error_code::triple_mismatch: + Context.getDiagnostics().Report(diag::warn_ctu_incompat_triple) + << IE.getFileName() << IE.getTripleToName() << IE.getTripleFromName(); + break; + default: + break; + } +} + +CrossTranslationUnitContext::ASTFileLoader::ASTFileLoader( + const CompilerInstance &CI) + : CI(CI) {} + +std::unique_ptr<ASTUnit> +CrossTranslationUnitContext::ASTFileLoader::operator()(StringRef ASTFilePath) { + // Load AST from ast-dump. + IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); + TextDiagnosticPrinter *DiagClient = + new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts); + IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); + IntrusiveRefCntPtr<DiagnosticsEngine> Diags( + new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient)); + + return ASTUnit::LoadFromASTFile( + ASTFilePath, CI.getPCHContainerOperations()->getRawReader(), + ASTUnit::LoadEverything, Diags, CI.getFileSystemOpts()); +} + +CrossTranslationUnitContext::ASTUnitStorage::ASTUnitStorage( + const CompilerInstance &CI) + : FileAccessor(CI), LoadGuard(const_cast<CompilerInstance &>(CI) + .getAnalyzerOpts() + ->CTUImportThreshold) {} + +llvm::Expected<ASTUnit *> +CrossTranslationUnitContext::ASTUnitStorage::getASTUnitForFile( + StringRef FileName, bool DisplayCTUProgress) { + // Try the cache first. + auto ASTCacheEntry = FileASTUnitMap.find(FileName); + if (ASTCacheEntry == FileASTUnitMap.end()) { + + // Do not load if the limit is reached. + if (!LoadGuard) { + ++NumASTLoadThresholdReached; + return llvm::make_error<IndexError>( + index_error_code::load_threshold_reached); + } + + // Load the ASTUnit from the pre-dumped AST file specified by ASTFileName. + std::unique_ptr<ASTUnit> LoadedUnit = FileAccessor(FileName); + + // Need the raw pointer and the unique_ptr as well. + ASTUnit *Unit = LoadedUnit.get(); + + // Update the cache. + FileASTUnitMap[FileName] = std::move(LoadedUnit); + + LoadGuard.indicateLoadSuccess(); + + if (DisplayCTUProgress) + llvm::errs() << "CTU loaded AST file: " << FileName << "\n"; + + return Unit; + + } else { + // Found in the cache. + return ASTCacheEntry->second.get(); + } +} + +llvm::Expected<ASTUnit *> +CrossTranslationUnitContext::ASTUnitStorage::getASTUnitForFunction( + StringRef FunctionName, StringRef CrossTUDir, StringRef IndexName, + bool DisplayCTUProgress) { + // Try the cache first. + auto ASTCacheEntry = NameASTUnitMap.find(FunctionName); + if (ASTCacheEntry == NameASTUnitMap.end()) { + // Load the ASTUnit from the pre-dumped AST file specified by ASTFileName. + + // Ensure that the Index is loaded, as we need to search in it. + if (llvm::Error IndexLoadError = + ensureCTUIndexLoaded(CrossTUDir, IndexName)) + return std::move(IndexLoadError); + + // Check if there is and entry in the index for the function. + if (!NameFileMap.count(FunctionName)) { + ++NumNotInOtherTU; + return llvm::make_error<IndexError>(index_error_code::missing_definition); + } + + // Search in the index for the filename where the definition of FuncitonName + // resides. + if (llvm::Expected<ASTUnit *> FoundForFile = + getASTUnitForFile(NameFileMap[FunctionName], DisplayCTUProgress)) { + + // Update the cache. + NameASTUnitMap[FunctionName] = *FoundForFile; + return *FoundForFile; + + } else { + return FoundForFile.takeError(); + } + } else { + // Found in the cache. + return ASTCacheEntry->second; + } +} + +llvm::Expected<std::string> +CrossTranslationUnitContext::ASTUnitStorage::getFileForFunction( + StringRef FunctionName, StringRef CrossTUDir, StringRef IndexName) { + if (llvm::Error IndexLoadError = ensureCTUIndexLoaded(CrossTUDir, IndexName)) + return std::move(IndexLoadError); + return NameFileMap[FunctionName]; +} + +llvm::Error CrossTranslationUnitContext::ASTUnitStorage::ensureCTUIndexLoaded( + StringRef CrossTUDir, StringRef IndexName) { + // Dont initialize if the map is filled. + if (!NameFileMap.empty()) + return llvm::Error::success(); + + // Get the absolute path to the index file. + SmallString<256> IndexFile = CrossTUDir; + if (llvm::sys::path::is_absolute(IndexName)) + IndexFile = IndexName; + else + llvm::sys::path::append(IndexFile, IndexName); + + if (auto IndexMapping = parseCrossTUIndex(IndexFile, CrossTUDir)) { + // Initialize member map. + NameFileMap = *IndexMapping; + return llvm::Error::success(); + } else { + // Error while parsing CrossTU index file. + return IndexMapping.takeError(); + }; +} + +llvm::Expected<ASTUnit *> CrossTranslationUnitContext::loadExternalAST( + StringRef LookupName, StringRef CrossTUDir, StringRef IndexName, + bool DisplayCTUProgress) { + // FIXME: The current implementation only supports loading decls with + // a lookup name from a single translation unit. If multiple + // translation units contains decls with the same lookup name an + // error will be returned. + + // Try to get the value from the heavily cached storage. + llvm::Expected<ASTUnit *> Unit = ASTStorage.getASTUnitForFunction( + LookupName, CrossTUDir, IndexName, DisplayCTUProgress); + + if (!Unit) + return Unit.takeError(); + + // Check whether the backing pointer of the Expected is a nullptr. + if (!*Unit) + return llvm::make_error<IndexError>( + index_error_code::failed_to_get_external_ast); + + return Unit; +} + +template <typename T> +llvm::Expected<const T *> +CrossTranslationUnitContext::importDefinitionImpl(const T *D, ASTUnit *Unit) { + assert(hasBodyOrInit(D) && "Decls to be imported should have body or init."); + + assert(&D->getASTContext() == &Unit->getASTContext() && + "ASTContext of Decl and the unit should match."); + ASTImporter &Importer = getOrCreateASTImporter(Unit); + + auto ToDeclOrError = Importer.Import(D); + if (!ToDeclOrError) { + handleAllErrors(ToDeclOrError.takeError(), + [&](const ImportError &IE) { + switch (IE.Error) { + case ImportError::NameConflict: + ++NumNameConflicts; + break; + case ImportError::UnsupportedConstruct: + ++NumUnsupportedNodeFound; + break; + case ImportError::Unknown: + llvm_unreachable("Unknown import error happened."); + break; + } + }); + return llvm::make_error<IndexError>(index_error_code::failed_import); + } + auto *ToDecl = cast<T>(*ToDeclOrError); + assert(hasBodyOrInit(ToDecl) && "Imported Decl should have body or init."); + ++NumGetCTUSuccess; + + return ToDecl; +} + +llvm::Expected<const FunctionDecl *> +CrossTranslationUnitContext::importDefinition(const FunctionDecl *FD, + ASTUnit *Unit) { + return importDefinitionImpl(FD, Unit); +} + +llvm::Expected<const VarDecl *> +CrossTranslationUnitContext::importDefinition(const VarDecl *VD, + ASTUnit *Unit) { + return importDefinitionImpl(VD, Unit); +} + +void CrossTranslationUnitContext::lazyInitImporterSharedSt( + TranslationUnitDecl *ToTU) { + if (!ImporterSharedSt) + ImporterSharedSt = std::make_shared<ASTImporterSharedState>(*ToTU); +} + +ASTImporter & +CrossTranslationUnitContext::getOrCreateASTImporter(ASTUnit *Unit) { + ASTContext &From = Unit->getASTContext(); + + auto I = ASTUnitImporterMap.find(From.getTranslationUnitDecl()); + if (I != ASTUnitImporterMap.end()) + return *I->second; + lazyInitImporterSharedSt(Context.getTranslationUnitDecl()); + ASTImporter *NewImporter = new ASTImporter( + Context, Context.getSourceManager().getFileManager(), From, + From.getSourceManager().getFileManager(), false, ImporterSharedSt); + NewImporter->setFileIDImportHandler([this, Unit](FileID ToID, FileID FromID) { + assert(ImportedFileIDs.find(ToID) == ImportedFileIDs.end() && + "FileID already imported, should not happen."); + ImportedFileIDs[ToID] = std::make_pair(FromID, Unit); + }); + ASTUnitImporterMap[From.getTranslationUnitDecl()].reset(NewImporter); + return *NewImporter; +} + +llvm::Optional<std::pair<SourceLocation, ASTUnit *>> +CrossTranslationUnitContext::getImportedFromSourceLocation( + const clang::SourceLocation &ToLoc) const { + const SourceManager &SM = Context.getSourceManager(); + auto DecToLoc = SM.getDecomposedLoc(ToLoc); + + auto I = ImportedFileIDs.find(DecToLoc.first); + if (I == ImportedFileIDs.end()) + return {}; + + FileID FromID = I->second.first; + clang::ASTUnit *Unit = I->second.second; + SourceLocation FromLoc = + Unit->getSourceManager().getComposedLoc(FromID, DecToLoc.second); + + return std::make_pair(FromLoc, Unit); +} + +} // namespace cross_tu +} // namespace clang |