mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 05:26:07 +00:00
20e9049509
Reland https://github.com/llvm/llvm-project/pull/83237 --- (Original comments) Currently all the specializations of a template (including instantiation, specialization and partial specializations) will be loaded at once if we want to instantiate another instance for the template, or find instantiation for the template, or just want to complete the redecl chain. This means basically we need to load every specializations for the template once the template declaration got loaded. This is bad since when we load a specialization, we need to load all of its template arguments. Then we have to deserialize a lot of unnecessary declarations. For example, ``` // M.cppm export module M; export template <class T> class A {}; export class ShouldNotBeLoaded {}; export class Temp { A<ShouldNotBeLoaded> AS; }; // use.cpp import M; A<int> a; ``` We have a specialization ` A<ShouldNotBeLoaded>` in `M.cppm` and we instantiate the template `A` in `use.cpp`. Then we will deserialize `ShouldNotBeLoaded` surprisingly when compiling `use.cpp`. And this patch tries to avoid that. Given that the templates are heavily used in C++, this is a pain point for the performance. This patch adds MultiOnDiskHashTable for specializations in the ASTReader. Then we will only deserialize the specializations with the same template arguments. We made that by using ODRHash for the template arguments as the key of the hash table. To review this patch, I think `ASTReaderDecl::AddLazySpecializations` may be a good entry point.
133 lines
4.0 KiB
C++
133 lines
4.0 KiB
C++
//===- ExternalASTSource.cpp - Abstract External AST Interface ------------===//
|
|
//
|
|
// 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 provides the default implementation of the ExternalASTSource
|
|
// interface, which enables construction of AST nodes from some external
|
|
// source.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ExternalASTSource.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/DeclarationName.h"
|
|
#include "clang/Basic/ASTSourceDescriptor.h"
|
|
#include "clang/Basic/IdentifierTable.h"
|
|
#include "clang/Basic/LLVM.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include <cstdint>
|
|
#include <optional>
|
|
|
|
using namespace clang;
|
|
|
|
char ExternalASTSource::ID;
|
|
|
|
ExternalASTSource::~ExternalASTSource() = default;
|
|
|
|
std::optional<ASTSourceDescriptor>
|
|
ExternalASTSource::getSourceDescriptor(unsigned ID) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
ExternalASTSource::ExtKind
|
|
ExternalASTSource::hasExternalDefinitions(const Decl *D) {
|
|
return EK_ReplyHazy;
|
|
}
|
|
|
|
void ExternalASTSource::FindFileRegionDecls(FileID File, unsigned Offset,
|
|
unsigned Length,
|
|
SmallVectorImpl<Decl *> &Decls) {}
|
|
|
|
void ExternalASTSource::CompleteRedeclChain(const Decl *D) {}
|
|
|
|
void ExternalASTSource::CompleteType(TagDecl *Tag) {}
|
|
|
|
void ExternalASTSource::CompleteType(ObjCInterfaceDecl *Class) {}
|
|
|
|
void ExternalASTSource::ReadComments() {}
|
|
|
|
void ExternalASTSource::StartedDeserializing() {}
|
|
|
|
void ExternalASTSource::FinishedDeserializing() {}
|
|
|
|
void ExternalASTSource::StartTranslationUnit(ASTConsumer *Consumer) {}
|
|
|
|
void ExternalASTSource::PrintStats() {}
|
|
|
|
bool ExternalASTSource::layoutRecordType(
|
|
const RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
|
|
llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
|
|
llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
|
|
llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets) {
|
|
return false;
|
|
}
|
|
|
|
Decl *ExternalASTSource::GetExternalDecl(GlobalDeclID ID) { return nullptr; }
|
|
|
|
Selector ExternalASTSource::GetExternalSelector(uint32_t ID) {
|
|
return Selector();
|
|
}
|
|
|
|
uint32_t ExternalASTSource::GetNumExternalSelectors() {
|
|
return 0;
|
|
}
|
|
|
|
Stmt *ExternalASTSource::GetExternalDeclStmt(uint64_t Offset) {
|
|
return nullptr;
|
|
}
|
|
|
|
CXXCtorInitializer **
|
|
ExternalASTSource::GetExternalCXXCtorInitializers(uint64_t Offset) {
|
|
return nullptr;
|
|
}
|
|
|
|
CXXBaseSpecifier *
|
|
ExternalASTSource::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
|
|
return nullptr;
|
|
}
|
|
|
|
bool
|
|
ExternalASTSource::FindExternalVisibleDeclsByName(const DeclContext *DC,
|
|
DeclarationName Name) {
|
|
return false;
|
|
}
|
|
|
|
bool ExternalASTSource::LoadExternalSpecializations(const Decl *D, bool) {
|
|
return false;
|
|
}
|
|
|
|
bool ExternalASTSource::LoadExternalSpecializations(
|
|
const Decl *D, ArrayRef<TemplateArgument>) {
|
|
return false;
|
|
}
|
|
|
|
void ExternalASTSource::completeVisibleDeclsMap(const DeclContext *DC) {}
|
|
|
|
void ExternalASTSource::FindExternalLexicalDecls(
|
|
const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
|
|
SmallVectorImpl<Decl *> &Result) {}
|
|
|
|
void ExternalASTSource::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {}
|
|
|
|
uint32_t ExternalASTSource::incrementGeneration(ASTContext &C) {
|
|
uint32_t OldGeneration = CurrentGeneration;
|
|
|
|
// Make sure the generation of the topmost external source for the context is
|
|
// incremented. That might not be us.
|
|
auto *P = C.getExternalSource();
|
|
if (P && P != this)
|
|
CurrentGeneration = P->incrementGeneration(C);
|
|
else {
|
|
// FIXME: Only bump the generation counter if the current generation number
|
|
// has been observed?
|
|
if (!++CurrentGeneration)
|
|
llvm::report_fatal_error("generation counter overflowed", false);
|
|
}
|
|
|
|
return OldGeneration;
|
|
}
|