From 401b39a736e7c139710f5fc7edcd672026139d6b Mon Sep 17 00:00:00 2001 From: Sebastian Redl Date: Tue, 24 Aug 2010 22:50:24 +0000 Subject: [PATCH] AST writer support for having specializations of templates from earlier in the chain. This ought to finish C++ chained PCH support. llvm-svn: 111986 --- clang/include/clang/Serialization/ASTWriter.h | 18 ++++++++++++++++++ clang/lib/Serialization/ASTWriter.cpp | 19 +++++++++++++++++++ clang/lib/Serialization/ASTWriterDecl.cpp | 14 +++++++++++--- clang/test/PCH/Inputs/chain-cxx1.h | 6 +++++- clang/test/PCH/Inputs/chain-cxx2.h | 12 ++++++++++++ clang/test/PCH/chain-cxx.cpp | 7 ++++++- 6 files changed, 71 insertions(+), 5 deletions(-) diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h index 6bdba097c9b5..b8bff27f57e3 100644 --- a/clang/include/clang/Serialization/ASTWriter.h +++ b/clang/include/clang/Serialization/ASTWriter.h @@ -217,6 +217,16 @@ private: llvm::SmallVector, 16> ReplacedDecls; + typedef llvm::SmallVector + AdditionalTemplateSpecializationsList; + typedef llvm::DenseMap + AdditionalTemplateSpecializationsMap; + + /// \brief Additional specializations (including partial) of templates that + /// were introduced after the template was serialized. + AdditionalTemplateSpecializationsMap AdditionalTemplateSpecializations; + /// \brief Statements that we've encountered while serializing a /// declaration or type. llvm::SmallVector StmtsToEmit; @@ -266,6 +276,7 @@ private: void WriteAttributeRecord(const AttrVec &Attrs); void WriteDeclUpdateBlock(); void WriteDeclContextVisibleUpdate(const DeclContext *DC); + void WriteAdditionalTemplateSpecializations(); unsigned ParmVarDeclAbbrev; unsigned DeclContextLexicalAbbrev; @@ -420,6 +431,13 @@ public: UpdatedNamespaces.insert(NS); } + /// \brief Record a template specialization or partial specialization of + /// a template from a previous PCH file. + void AddAdditionalTemplateSpecialization(serialization::DeclID Templ, + serialization::DeclID Spec) { + AdditionalTemplateSpecializations[Templ].push_back(Spec); + } + /// \brief Note that the identifier II occurs at the given offset /// within the identifier table. void SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset); diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 5c3e24a0a272..be181f44069b 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -2129,6 +2129,21 @@ void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); } +/// \brief Write ADDITIONAL_TEMPLATE_SPECIALIZATIONS blocks for all templates +/// that have new specializations in the current AST file. +void ASTWriter::WriteAdditionalTemplateSpecializations() { + RecordData Record; + for (AdditionalTemplateSpecializationsMap::iterator + I = AdditionalTemplateSpecializations.begin(), + E = AdditionalTemplateSpecializations.end(); + I != E; ++I) { + Record.clear(); + Record.push_back(I->first); + Record.insert(Record.end(), I->second.begin(), I->second.end()); + Stream.EmitRecord(ADDITIONAL_TEMPLATE_SPECIALIZATIONS, Record); + } +} + //===----------------------------------------------------------------------===// // General Serialization Routines //===----------------------------------------------------------------------===// @@ -2638,6 +2653,10 @@ void ASTWriter::WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls, I != E; ++I) WriteDeclContextVisibleUpdate(*I); + // Write the updates to C++ template specialization lists. + if (!AdditionalTemplateSpecializations.empty()) + WriteAdditionalTemplateSpecializations(); + Record.clear(); Record.push_back(NumStatements); Record.push_back(NumMacros); diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp index 3edb6302f8f7..413f544f4c1a 100644 --- a/clang/lib/Serialization/ASTWriterDecl.cpp +++ b/clang/lib/Serialization/ASTWriterDecl.cpp @@ -888,13 +888,21 @@ void ASTDeclWriter::VisitClassTemplateSpecializationDecl( llvm::PointerUnion InstFrom = D->getSpecializedTemplateOrPartial(); + Decl *InstFromD; if (InstFrom.is()) { - Writer.AddDeclRef(InstFrom.get(), Record); + InstFromD = InstFrom.get(); + Writer.AddDeclRef(InstFromD, Record); } else { - Writer.AddDeclRef(InstFrom.get(), - Record); + InstFromD = InstFrom.get(); + Writer.AddDeclRef(InstFromD, Record); Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); + InstFromD = cast(InstFromD)-> + getSpecializedTemplate(); } + // Is this a specialization of an already-serialized template? + if (InstFromD->getCanonicalDecl()->getPCHLevel() != 0) + Writer.AddAdditionalTemplateSpecialization(Writer.getDeclID(InstFromD), + Writer.getDeclID(D)); // Explicit info. Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); diff --git a/clang/test/PCH/Inputs/chain-cxx1.h b/clang/test/PCH/Inputs/chain-cxx1.h index 747bdbc7f427..7ea3ffb61c8f 100644 --- a/clang/test/PCH/Inputs/chain-cxx1.h +++ b/clang/test/PCH/Inputs/chain-cxx1.h @@ -12,4 +12,8 @@ namespace ns { } template -struct S {}; +struct S { typedef int G; }; + +// Partially specialize +template +struct S { typedef int H; }; diff --git a/clang/test/PCH/Inputs/chain-cxx2.h b/clang/test/PCH/Inputs/chain-cxx2.h index ff22e538d4d2..adc10fd83681 100644 --- a/clang/test/PCH/Inputs/chain-cxx2.h +++ b/clang/test/PCH/Inputs/chain-cxx2.h @@ -18,3 +18,15 @@ namespace ns { // Specialize template from primary template <> struct S { typedef int I; }; + +// Partially specialize +template +struct S { typedef int J; }; + +// Specialize previous partial specialization +template <> +struct S { typedef int K; }; + +// Specialize the partial specialization from this file +template <> +struct S { typedef int L; }; diff --git a/clang/test/PCH/chain-cxx.cpp b/clang/test/PCH/chain-cxx.cpp index 450a79182863..3e46214c70b8 100644 --- a/clang/test/PCH/chain-cxx.cpp +++ b/clang/test/PCH/chain-cxx.cpp @@ -19,5 +19,10 @@ void test() { ns::pg(); ns::g2(); - //typedef S::I J; + typedef S::G T1; + typedef S::H T2; + typedef S::I T3; + typedef S::J T4; + typedef S::K T5; + typedef S::L T6; }