[CTU] Refactor threshold checking

[gamesh411]

Incremental change

[gamesh411]

Incremental change

[gamesh411]

Incremental change

[gamesh411]

Incremental change

[gamesh411]

Incremental change

clang/include/clang/CrossTU/CrossTranslationUnit.h

public:
   /// Emit diagnostics for the user for potential configuration errors.
   void emitCrossTUDiagnostics(const IndexError &IE);
 
 private:
   bool checkThresholdReached() const;
   llvm::Error lazyInitCTUIndex(StringRef CrossTUDir, StringRef IndexName);
   ASTUnit *getCachedASTUnitForName(StringRef LookupName) const;
   std::unique_ptr<ASTUnit> loadFromASTFile(StringRef ASTFileName) const;
+  ASTUnit *loadFromASTFileCached(StringRef LookupName, StringRef ASTFileName);
   llvm::Expected<std::string>
   getASTFileNameForLookup(StringRef LookupName) const;
 
   void lazyInitImporterSharedSt(TranslationUnitDecl *ToTU);
   ASTImporter &getOrCreateASTImporter(ASTContext &From);
   template <typename T>
-  llvm::Expected<const T *> getCrossTUDefinitionImpl(const T *D,
-                                                     StringRef CrossTUDir,
-                                                     StringRef IndexName,
-                                                     bool DisplayCTUProgress);
+  llvm::Expected<const T *>
+  getCrossTUDefinitionImpl(const T *D, StringRef CrossTUDir,
+                           StringRef IndexName, bool DisplayCTUProgress);
   template <typename T>
-  const T *findDefInDeclContext(const DeclContext *DC,
-                                StringRef LookupName);
+  const T *findDefInDeclContext(const DeclContext *DC, StringRef LookupName);
   template <typename T>
   llvm::Expected<const T *> importDefinitionImpl(const T *D);
 
   llvm::StringMap<std::unique_ptr<clang::ASTUnit>> FileASTUnitMap;
   llvm::StringMap<clang::ASTUnit *> NameASTUnitMap;
   llvm::StringMap<std::string> NameFileMap;
   llvm::DenseMap<TranslationUnitDecl *, std::unique_ptr<ASTImporter>>
       ASTUnitImporterMap;

clang/lib/CrossTU/CrossTranslationUnit.cpp

 #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/ADT/Triple.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 {
bool hasEqualKnownFields(const llvm::Triple &Lhs, const llvm::Triple &Rhs) {
   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())
+  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())
llvm::Expected<const T *> CrossTranslationUnitContext::getCrossTUDefinitionImpl(
   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 std::string LookupName = getLookupName(D);
   if (LookupName.empty())
     return llvm::make_error<IndexError>(
         index_error_code::failed_to_generate_usr);
-  llvm::Expected<ASTUnit *> ASTUnitOrError = loadExternalAST(
-      LookupName, CrossTUDir, IndexName, DisplayCTUProgress);
+  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 =
CrossTranslationUnitContext::getASTFileNameForLookup(
   if (NameFileMapEntry != NameFileMap.end()) {
     return NameFileMapEntry->second;
   } else {
     ++NumNotInOtherTU;
     return llvm::make_error<IndexError>(index_error_code::missing_definition);
   }
 }
 
+ASTUnit *
+CrossTranslationUnitContext::loadFromASTFileCached(StringRef LookupName,
+                                                   StringRef ASTFileName) {
+  ASTUnit *Unit = nullptr;
+
+  auto ASTCacheEntry = FileASTUnitMap.find(ASTFileName);
+  if (ASTCacheEntry == FileASTUnitMap.end()) {
+    // Load the ASTUnit from the pre-dumped AST file specified by ASTFileName.
+    std::unique_ptr<ASTUnit> LoadedUnit = loadFromASTFile(ASTFileName);
+    Unit = LoadedUnit.get();
+    FileASTUnitMap[ASTFileName] = std::move(LoadedUnit);
+  } else {
+    Unit = ASTCacheEntry->second.get();
+  }
+  NameASTUnitMap[LookupName] = Unit;
+
+  return Unit;
+}
+
 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.
 
llvm::Expected<ASTUnit *> CrossTranslationUnitContext::loadExternalAST(
   // Lazily initialize the mapping from function names to AST files.
   if (llvm::Error InitFailed = lazyInitCTUIndex(CrossTUDir, IndexName))
     return std::move(InitFailed);
 
   llvm::Expected<std::string> ASTFileName = getASTFileNameForLookup(LookupName);
   if (!ASTFileName)
     return ASTFileName.takeError();
 
-  auto ASTCacheEntry = FileASTUnitMap.find(*ASTFileName);
-  if (ASTCacheEntry == FileASTUnitMap.end()) {
-    // Load the ASTUnit from the pre-dumped AST file specified by ASTFileName.
-  std::unique_ptr<ASTUnit> LoadedUnit = loadFromASTFile(*ASTFileName);
-    Unit = LoadedUnit.get();
-    FileASTUnitMap[*ASTFileName] = std::move(LoadedUnit);
+  // Try to load from ASTFile but use cache for both file and function names.
+  Unit = loadFromASTFileCached(LookupName, *ASTFileName);
+
+  if (Unit) {
     ++NumASTLoaded;
     if (DisplayCTUProgress) {
       llvm::errs() << "CTU loaded AST file: " << *ASTFileName << "\n";
     }
+    return Unit;
   } else {
-    Unit = ASTCacheEntry->second.get();
-  }
-  NameASTUnitMap[LookupName] = Unit;
-
-  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) {
   assert(hasBodyOrInit(D) && "Decls to be imported should have body or init.");
 
   ASTImporter &Importer = getOrCreateASTImporter(D->getASTContext());
   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;
-                      }
-                    });
+    handleAllErrors(ToDeclOrError.takeError(), [&](const ImportError &IE) {
     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;
 }