Hi Richard,
it looks like this commit has caused a 6% size regression when building a PCH
from OS X’s Cocoa.h. When comparing the llvm-bcanalyzer output for r265187 and
r265195 the most noticeable diff is in the DECLTYPES_BLOCK:
Block ID #11 (DECLTYPES_BLOCK):
Num Instances: 1
- Total Size: 50609331b/6326166.38B/1581541W
- Percent of file: 42.1507%
+ Total Size: 55982899b/6997862.38B/1749465W
+ Percent of file: 44.6289%
Num SubBlocks: 0
Num Abbrevs: 16
Num Records: 192517
- Percent Abbrevs: 40.5408%
+ Percent Abbrevs: 20.3540%
And it looks like the only part of the commit that was not obviously NFC is
also in ASTWriter::WriteDecl().
Could you please have a look?
Let me know if I can help provide any other diagnostics or testcases. Thanks,
Adrian
> On Apr 1, 2016, at 3:52 PM, Richard Smith via cfe-commits
> <cfe-commits@lists.llvm.org> wrote:
>
> Author: rsmith
> Date: Fri Apr 1 17:52:03 2016
> New Revision: 265195
>
> URL: http://llvm.org/viewvc/llvm-project?rev=265195&view=rev
> Log:
> [modules] Start moving the code for encoding AST records out of ASTWriter into
> a separate class. The goal is for this class to have a separate lifetime from
> the AST writer so that it can meaningfully track pending statement nodes and
> context for more compact encoding of various types.
>
> Modified:
> cfe/trunk/include/clang/Serialization/ASTWriter.h
> cfe/trunk/lib/Serialization/ASTWriter.cpp
> cfe/trunk/lib/Serialization/ASTWriterDecl.cpp
> cfe/trunk/lib/Serialization/ASTWriterStmt.cpp
>
> Modified: cfe/trunk/include/clang/Serialization/ASTWriter.h
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Serialization/ASTWriter.h?rev=265195&r1=265194&r2=265195&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Serialization/ASTWriter.h (original)
> +++ cfe/trunk/include/clang/Serialization/ASTWriter.h Fri Apr 1 17:52:03 2016
> @@ -90,6 +90,7 @@ public:
>
> friend class ASTDeclWriter;
> friend class ASTStmtWriter;
> + friend class ASTRecordWriter;
> private:
> /// \brief Map that provides the ID numbers of each type within the
> /// output stream, plus those deserialized from a chained PCH.
> @@ -523,7 +524,6 @@ private:
> void WriteReferencedSelectorsPool(Sema &SemaRef);
> void WriteIdentifierTable(Preprocessor &PP, IdentifierResolver &IdResolver,
> bool IsModule);
> - void WriteAttributes(ArrayRef<const Attr*> Attrs, RecordDataImpl &Record);
> void WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord);
> void WriteDeclContextVisibleUpdate(const DeclContext *DC);
> void WriteFPPragmaOptions(const FPOptions &Opts);
> @@ -555,7 +555,7 @@ private:
>
> void WriteDeclAbbrevs();
> void WriteDecl(ASTContext &Context, Decl *D);
> - void AddFunctionDefinition(const FunctionDecl *FD, RecordData &Record);
> + void AddFunctionDefinition(const FunctionDecl *FD, RecordDataImpl &Record);
>
> uint64_t WriteASTCore(Sema &SemaRef,
> StringRef isysroot, const std::string &OutputFile,
> @@ -684,6 +684,8 @@ public:
> /// declaration.
> serialization::DeclID getDeclID(const Decl *D);
>
> + void AddAttributes(ArrayRef<const Attr*> Attrs, RecordDataImpl &Record);
> +
> /// \brief Emit a declaration name.
> void AddDeclarationName(DeclarationName Name, RecordDataImpl &Record);
> void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
> @@ -864,6 +866,219 @@ public:
> const RecordDecl *Record) override;
> };
>
> +/// \brief An object for streaming information to a record.
> +class ASTRecordWriter {
> + ASTWriter *Writer;
> + ASTWriter::RecordDataImpl *Record;
> +
> +public:
> + /// Construct a ASTRecordWriter that uses the default encoding scheme.
> + ASTRecordWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
> + : Writer(&Writer), Record(&Record) {}
> +
> + /// Construct a ASTRecordWriter that uses the same encoding scheme as
> another
> + /// ASTRecordWriter.
> + ASTRecordWriter(ASTRecordWriter &Parent, ASTWriter::RecordDataImpl &Record)
> + : Writer(Parent.Writer), Record(&Record) {}
> +
> + /// \brief Extract the underlying record storage.
> + ASTWriter::RecordDataImpl &getRecordData() const { return *Record; }
> +
> + /// \brief Minimal vector-like interface.
> + /// @{
> + void push_back(uint64_t N) { Record->push_back(N); }
> + template<typename InputIterator>
> + void append(InputIterator begin, InputIterator end) {
> + Record->append(begin, end);
> + }
> + bool empty() const { return Record->empty(); }
> + size_t size() const { return Record->size(); }
> + uint64_t &operator[](size_t N) { return (*Record)[N]; }
> + /// @}
> +
> +
> + /// \brief Emit the record to the stream, and return its offset.
> + // FIXME: Allow record producers to suggest Abbrevs.
> + uint64_t Emit(unsigned Code, unsigned Abbrev = 0) {
> + uint64_t Offset = Writer->Stream.GetCurrentBitNo();
> + Writer->Stream.EmitRecord(Code, *Record);
> + return Offset;
> + }
> +
> +
> + /// \brief Emit a source location.
> + void AddSourceLocation(SourceLocation Loc) {
> + return Writer->AddSourceLocation(Loc, *Record);
> + }
> +
> + /// \brief Emit a source range.
> + void AddSourceRange(SourceRange Range) {
> + return Writer->AddSourceRange(Range, *Record);
> + }
> +
> + /// \brief Emit an integral value.
> + void AddAPInt(const llvm::APInt &Value) {
> + return Writer->AddAPInt(Value, *Record);
> + }
> +
> + /// \brief Emit a signed integral value.
> + void AddAPSInt(const llvm::APSInt &Value) {
> + return Writer->AddAPSInt(Value, *Record);
> + }
> +
> + /// \brief Emit a floating-point value.
> + void AddAPFloat(const llvm::APFloat &Value) {
> + return Writer->AddAPFloat(Value, *Record);
> + }
> +
> + /// \brief Emit a reference to an identifier.
> + void AddIdentifierRef(const IdentifierInfo *II) {
> + return Writer->AddIdentifierRef(II, *Record);
> + }
> +
> + /// \brief Emit a Selector (which is a smart pointer reference).
> + void AddSelectorRef(Selector S) {
> + return Writer->AddSelectorRef(S, *Record);
> + }
> +
> + /// \brief Emit a CXXTemporary.
> + void AddCXXTemporary(const CXXTemporary *Temp) {
> + return Writer->AddCXXTemporary(Temp, *Record);
> + }
> +
> + /// \brief Emit a set of C++ base specifiers.
> + void AddCXXBaseSpecifiersRef(const CXXBaseSpecifier *BasesBegin,
> + const CXXBaseSpecifier *BasesEnd) {
> + return Writer->AddCXXBaseSpecifiersRef(BasesBegin, BasesEnd, *Record);
> + }
> +
> + /// \brief Emit a reference to a type.
> + void AddTypeRef(QualType T) {
> + return Writer->AddTypeRef(T, *Record);
> + }
> +
> + /// \brief Emits a reference to a declarator info.
> + void AddTypeSourceInfo(TypeSourceInfo *TInfo) {
> + return Writer->AddTypeSourceInfo(TInfo, *Record);
> + }
> +
> + /// \brief Emits a template argument location info.
> + void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
> + const TemplateArgumentLocInfo &Arg) {
> + return Writer->AddTemplateArgumentLocInfo(Kind, Arg, *Record);
> + }
> +
> + /// \brief Emits a template argument location.
> + void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) {
> + return Writer->AddTemplateArgumentLoc(Arg, *Record);
> + }
> +
> + /// \brief Emits an AST template argument list info.
> + void AddASTTemplateArgumentListInfo(
> + const ASTTemplateArgumentListInfo *ASTTemplArgList) {
> + return Writer->AddASTTemplateArgumentListInfo(ASTTemplArgList, *Record);
> + }
> +
> + /// \brief Emit a reference to a declaration.
> + void AddDeclRef(const Decl *D) {
> + return Writer->AddDeclRef(D, *Record);
> + }
> +
> + void AddDeclarationName(DeclarationName Name) {
> + return Writer->AddDeclarationName(Name, *Record);
> + }
> +
> + void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
> + DeclarationName Name) {
> + return Writer->AddDeclarationNameLoc(DNLoc, Name, *Record);
> + }
> +
> + void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
> + return Writer->AddDeclarationNameInfo(NameInfo, *Record);
> + }
> +
> + void AddQualifierInfo(const QualifierInfo &Info) {
> + return Writer->AddQualifierInfo(Info, *Record);
> + }
> +
> + /// \brief Emit a nested name specifier.
> + void AddNestedNameSpecifier(NestedNameSpecifier *NNS) {
> + return Writer->AddNestedNameSpecifier(NNS, *Record);
> + }
> +
> + /// \brief Emit a nested name specifier with source-location information.
> + void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
> + return Writer->AddNestedNameSpecifierLoc(NNS, *Record);
> + }
> +
> + /// \brief Emit a template name.
> + void AddTemplateName(TemplateName Name) {
> + return Writer->AddTemplateName(Name, *Record);
> + }
> +
> + /// \brief Emit a template argument.
> + void AddTemplateArgument(const TemplateArgument &Arg) {
> + return Writer->AddTemplateArgument(Arg, *Record);
> + }
> +
> + /// \brief Emit a template parameter list.
> + void AddTemplateParameterList(const TemplateParameterList *TemplateParams)
> {
> + return Writer->AddTemplateParameterList(TemplateParams, *Record);
> + }
> +
> + /// \brief Emit a template argument list.
> + void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs) {
> + return Writer->AddTemplateArgumentList(TemplateArgs, *Record);
> + }
> +
> + /// \brief Emit a UnresolvedSet structure.
> + void AddUnresolvedSet(const ASTUnresolvedSet &Set) {
> + return Writer->AddUnresolvedSet(Set, *Record);
> + }
> +
> + /// \brief Emit a C++ base specifier.
> + void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) {
> + return Writer->AddCXXBaseSpecifier(Base, *Record);
> + }
> +
> + /// \brief Emit the ID for a CXXCtorInitializer array and register the
> array
> + /// for later serialization.
> + void AddCXXCtorInitializersRef(ArrayRef<CXXCtorInitializer *> Inits) {
> + return Writer->AddCXXCtorInitializersRef(Inits, *Record);
> + }
> +
> + /// \brief Emit a CXXCtorInitializer array.
> + void AddCXXCtorInitializers(const CXXCtorInitializer *const
> *CtorInitializers,
> + unsigned NumCtorInitializers) {
> + return Writer->AddCXXCtorInitializers(CtorInitializers,
> NumCtorInitializers,
> + *Record);
> + }
> +
> + void AddCXXDefinitionData(const CXXRecordDecl *D) {
> + return Writer->AddCXXDefinitionData(D, *Record);
> + }
> +
> + /// \brief Emit a string.
> + void AddString(StringRef Str) {
> + return Writer->AddString(Str, *Record);
> + }
> +
> + /// \brief Emit a path.
> + void AddPath(StringRef Path) {
> + return Writer->AddPath(Path, *Record);
> + }
> +
> + /// \brief Emit a version tuple.
> + void AddVersionTuple(const VersionTuple &Version) {
> + return Writer->AddVersionTuple(Version, *Record);
> + }
> +
> + /// \brief Emit a list of attributes.
> + void AddAttributes(ArrayRef<const Attr*> Attrs) {
> + return Writer->AddAttributes(Attrs, *Record);
> + }
> +};
> +
> /// \brief AST and semantic-analysis consumer that generates a
> /// precompiled header from the parsed source code.
> class PCHGenerator : public SemaConsumer {
>
> Modified: cfe/trunk/lib/Serialization/ASTWriter.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTWriter.cpp?rev=265195&r1=265194&r2=265195&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Serialization/ASTWriter.cpp (original)
> +++ cfe/trunk/lib/Serialization/ASTWriter.cpp Fri Apr 1 17:52:03 2016
> @@ -85,7 +85,7 @@ static StringRef bytes(const SmallVector
> namespace {
> class ASTTypeWriter {
> ASTWriter &Writer;
> - ASTWriter::RecordDataImpl &Record;
> + ASTRecordWriter Record;
>
> public:
> /// \brief Type code that corresponds to the record generated.
> @@ -94,7 +94,7 @@ namespace {
> unsigned AbbrevToUse;
>
> ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
> - : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { }
> + : Writer(Writer), Record(Writer, Record), Code(TYPE_EXT_QUAL) { }
>
> void VisitArrayType(const ArrayType *T);
> void VisitFunctionType(const FunctionType *T);
> @@ -111,57 +111,57 @@ void ASTTypeWriter::VisitBuiltinType(con
> }
>
> void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
> - Writer.AddTypeRef(T->getElementType(), Record);
> + Record.AddTypeRef(T->getElementType());
> Code = TYPE_COMPLEX;
> }
>
> void ASTTypeWriter::VisitPointerType(const PointerType *T) {
> - Writer.AddTypeRef(T->getPointeeType(), Record);
> + Record.AddTypeRef(T->getPointeeType());
> Code = TYPE_POINTER;
> }
>
> void ASTTypeWriter::VisitDecayedType(const DecayedType *T) {
> - Writer.AddTypeRef(T->getOriginalType(), Record);
> + Record.AddTypeRef(T->getOriginalType());
> Code = TYPE_DECAYED;
> }
>
> void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) {
> - Writer.AddTypeRef(T->getOriginalType(), Record);
> - Writer.AddTypeRef(T->getAdjustedType(), Record);
> + Record.AddTypeRef(T->getOriginalType());
> + Record.AddTypeRef(T->getAdjustedType());
> Code = TYPE_ADJUSTED;
> }
>
> void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
> - Writer.AddTypeRef(T->getPointeeType(), Record);
> + Record.AddTypeRef(T->getPointeeType());
> Code = TYPE_BLOCK_POINTER;
> }
>
> void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
> - Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
> + Record.AddTypeRef(T->getPointeeTypeAsWritten());
> Record.push_back(T->isSpelledAsLValue());
> Code = TYPE_LVALUE_REFERENCE;
> }
>
> void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
> - Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
> + Record.AddTypeRef(T->getPointeeTypeAsWritten());
> Code = TYPE_RVALUE_REFERENCE;
> }
>
> void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) {
> - Writer.AddTypeRef(T->getPointeeType(), Record);
> - Writer.AddTypeRef(QualType(T->getClass(), 0), Record);
> + Record.AddTypeRef(T->getPointeeType());
> + Record.AddTypeRef(QualType(T->getClass(), 0));
> Code = TYPE_MEMBER_POINTER;
> }
>
> void ASTTypeWriter::VisitArrayType(const ArrayType *T) {
> - Writer.AddTypeRef(T->getElementType(), Record);
> + Record.AddTypeRef(T->getElementType());
> Record.push_back(T->getSizeModifier()); // FIXME: stable values
> Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values
> }
>
> void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
> VisitArrayType(T);
> - Writer.AddAPInt(T->getSize(), Record);
> + Record.AddAPInt(T->getSize());
> Code = TYPE_CONSTANT_ARRAY;
> }
>
> @@ -172,14 +172,14 @@ void ASTTypeWriter::VisitIncompleteArray
>
> void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
> VisitArrayType(T);
> - Writer.AddSourceLocation(T->getLBracketLoc(), Record);
> - Writer.AddSourceLocation(T->getRBracketLoc(), Record);
> + Record.AddSourceLocation(T->getLBracketLoc());
> + Record.AddSourceLocation(T->getRBracketLoc());
> Writer.AddStmt(T->getSizeExpr());
> Code = TYPE_VARIABLE_ARRAY;
> }
>
> void ASTTypeWriter::VisitVectorType(const VectorType *T) {
> - Writer.AddTypeRef(T->getElementType(), Record);
> + Record.AddTypeRef(T->getElementType());
> Record.push_back(T->getNumElements());
> Record.push_back(T->getVectorKind());
> Code = TYPE_VECTOR;
> @@ -191,7 +191,7 @@ void ASTTypeWriter::VisitExtVectorType(c
> }
>
> void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
> - Writer.AddTypeRef(T->getReturnType(), Record);
> + Record.AddTypeRef(T->getReturnType());
> FunctionType::ExtInfo C = T->getExtInfo();
> Record.push_back(C.getNoReturn());
> Record.push_back(C.getHasRegParm());
> @@ -210,19 +210,19 @@ void ASTTypeWriter::VisitFunctionNoProto
> }
>
> static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T,
> - ASTWriter::RecordDataImpl &Record) {
> + ASTRecordWriter Record) {
> Record.push_back(T->getExceptionSpecType());
> if (T->getExceptionSpecType() == EST_Dynamic) {
> Record.push_back(T->getNumExceptions());
> for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
> - Writer.AddTypeRef(T->getExceptionType(I), Record);
> + Record.AddTypeRef(T->getExceptionType(I));
> } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
> Writer.AddStmt(T->getNoexceptExpr());
> } else if (T->getExceptionSpecType() == EST_Uninstantiated) {
> - Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
> - Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record);
> + Record.AddDeclRef(T->getExceptionSpecDecl());
> + Record.AddDeclRef(T->getExceptionSpecTemplate());
> } else if (T->getExceptionSpecType() == EST_Unevaluated) {
> - Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
> + Record.AddDeclRef(T->getExceptionSpecDecl());
> }
> }
>
> @@ -237,7 +237,7 @@ void ASTTypeWriter::VisitFunctionProtoTy
>
> Record.push_back(T->getNumParams());
> for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
> - Writer.AddTypeRef(T->getParamType(I), Record);
> + Record.AddTypeRef(T->getParamType(I));
>
> if (T->hasExtParameterInfos()) {
> for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
> @@ -253,14 +253,14 @@ void ASTTypeWriter::VisitFunctionProtoTy
> }
>
> void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
> - Writer.AddDeclRef(T->getDecl(), Record);
> + Record.AddDeclRef(T->getDecl());
> Code = TYPE_UNRESOLVED_USING;
> }
>
> void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
> - Writer.AddDeclRef(T->getDecl(), Record);
> + Record.AddDeclRef(T->getDecl());
> assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
> - Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
> + Record.AddTypeRef(T->getCanonicalTypeInternal());
> Code = TYPE_TYPEDEF;
> }
>
> @@ -270,25 +270,25 @@ void ASTTypeWriter::VisitTypeOfExprType(
> }
>
> void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
> - Writer.AddTypeRef(T->getUnderlyingType(), Record);
> + Record.AddTypeRef(T->getUnderlyingType());
> Code = TYPE_TYPEOF;
> }
>
> void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
> - Writer.AddTypeRef(T->getUnderlyingType(), Record);
> + Record.AddTypeRef(T->getUnderlyingType());
> Writer.AddStmt(T->getUnderlyingExpr());
> Code = TYPE_DECLTYPE;
> }
>
> void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
> - Writer.AddTypeRef(T->getBaseType(), Record);
> - Writer.AddTypeRef(T->getUnderlyingType(), Record);
> + Record.AddTypeRef(T->getBaseType());
> + Record.AddTypeRef(T->getUnderlyingType());
> Record.push_back(T->getUTTKind());
> Code = TYPE_UNARY_TRANSFORM;
> }
>
> void ASTTypeWriter::VisitAutoType(const AutoType *T) {
> - Writer.AddTypeRef(T->getDeducedType(), Record);
> + Record.AddTypeRef(T->getDeducedType());
> Record.push_back((unsigned)T->getKeyword());
> if (T->getDeducedType().isNull())
> Record.push_back(T->isDependentType());
> @@ -297,7 +297,7 @@ void ASTTypeWriter::VisitAutoType(const
>
> void ASTTypeWriter::VisitTagType(const TagType *T) {
> Record.push_back(T->isDependentType());
> - Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
> + Record.AddDeclRef(T->getDecl()->getCanonicalDecl());
> assert(!T->isBeingDefined() &&
> "Cannot serialize in the middle of a type definition");
> }
> @@ -313,8 +313,8 @@ void ASTTypeWriter::VisitEnumType(const
> }
>
> void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
> - Writer.AddTypeRef(T->getModifiedType(), Record);
> - Writer.AddTypeRef(T->getEquivalentType(), Record);
> + Record.AddTypeRef(T->getModifiedType());
> + Record.AddTypeRef(T->getEquivalentType());
> Record.push_back(T->getAttrKind());
> Code = TYPE_ATTRIBUTED;
> }
> @@ -322,16 +322,16 @@ void ASTTypeWriter::VisitAttributedType(
> void
> ASTTypeWriter::VisitSubstTemplateTypeParmType(
> const SubstTemplateTypeParmType *T) {
> - Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
> - Writer.AddTypeRef(T->getReplacementType(), Record);
> + Record.AddTypeRef(QualType(T->getReplacedParameter(), 0));
> + Record.AddTypeRef(T->getReplacementType());
> Code = TYPE_SUBST_TEMPLATE_TYPE_PARM;
> }
>
> void
> ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
> const SubstTemplateTypeParmPackType *T)
> {
> - Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
> - Writer.AddTemplateArgument(T->getArgumentPack(), Record);
> + Record.AddTypeRef(QualType(T->getReplacedParameter(), 0));
> + Record.AddTemplateArgument(T->getArgumentPack());
> Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK;
> }
>
> @@ -339,14 +339,14 @@ void
> ASTTypeWriter::VisitTemplateSpecializationType(
> const TemplateSpecializationType *T) {
> Record.push_back(T->isDependentType());
> - Writer.AddTemplateName(T->getTemplateName(), Record);
> + Record.AddTemplateName(T->getTemplateName());
> Record.push_back(T->getNumArgs());
> for (const auto &ArgI : *T)
> - Writer.AddTemplateArgument(ArgI, Record);
> - Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() :
> - T->isCanonicalUnqualified() ? QualType()
> - :
> T->getCanonicalTypeInternal(),
> - Record);
> + Record.AddTemplateArgument(ArgI);
> + Record.AddTypeRef(T->isTypeAlias() ? T->getAliasedType()
> + : T->isCanonicalUnqualified()
> + ? QualType()
> + : T->getCanonicalTypeInternal());
> Code = TYPE_TEMPLATE_SPECIALIZATION;
> }
>
> @@ -354,7 +354,7 @@ void
> ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T)
> {
> VisitArrayType(T);
> Writer.AddStmt(T->getSizeExpr());
> - Writer.AddSourceRange(T->getBracketsRange(), Record);
> + Record.AddSourceRange(T->getBracketsRange());
> Code = TYPE_DEPENDENT_SIZED_ARRAY;
> }
>
> @@ -370,18 +370,17 @@ ASTTypeWriter::VisitTemplateTypeParmType
> Record.push_back(T->getDepth());
> Record.push_back(T->getIndex());
> Record.push_back(T->isParameterPack());
> - Writer.AddDeclRef(T->getDecl(), Record);
> + Record.AddDeclRef(T->getDecl());
> Code = TYPE_TEMPLATE_TYPE_PARM;
> }
>
> void
> ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
> Record.push_back(T->getKeyword());
> - Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
> - Writer.AddIdentifierRef(T->getIdentifier(), Record);
> - Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
> - :
> T->getCanonicalTypeInternal(),
> - Record);
> + Record.AddNestedNameSpecifier(T->getQualifier());
> + Record.AddIdentifierRef(T->getIdentifier());
> + Record.AddTypeRef(
> + T->isCanonicalUnqualified() ? QualType() :
> T->getCanonicalTypeInternal());
> Code = TYPE_DEPENDENT_NAME;
> }
>
> @@ -389,16 +388,16 @@ void
> ASTTypeWriter::VisitDependentTemplateSpecializationType(
> const DependentTemplateSpecializationType *T)
> {
> Record.push_back(T->getKeyword());
> - Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
> - Writer.AddIdentifierRef(T->getIdentifier(), Record);
> + Record.AddNestedNameSpecifier(T->getQualifier());
> + Record.AddIdentifierRef(T->getIdentifier());
> Record.push_back(T->getNumArgs());
> for (const auto &I : *T)
> - Writer.AddTemplateArgument(I, Record);
> + Record.AddTemplateArgument(I);
> Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION;
> }
>
> void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
> - Writer.AddTypeRef(T->getPattern(), Record);
> + Record.AddTypeRef(T->getPattern());
> if (Optional<unsigned> NumExpansions = T->getNumExpansions())
> Record.push_back(*NumExpansions + 1);
> else
> @@ -407,55 +406,55 @@ void ASTTypeWriter::VisitPackExpansionTy
> }
>
> void ASTTypeWriter::VisitParenType(const ParenType *T) {
> - Writer.AddTypeRef(T->getInnerType(), Record);
> + Record.AddTypeRef(T->getInnerType());
> Code = TYPE_PAREN;
> }
>
> void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
> Record.push_back(T->getKeyword());
> - Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
> - Writer.AddTypeRef(T->getNamedType(), Record);
> + Record.AddNestedNameSpecifier(T->getQualifier());
> + Record.AddTypeRef(T->getNamedType());
> Code = TYPE_ELABORATED;
> }
>
> void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType
> *T) {
> - Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
> - Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
> + Record.AddDeclRef(T->getDecl()->getCanonicalDecl());
> + Record.AddTypeRef(T->getInjectedSpecializationType());
> Code = TYPE_INJECTED_CLASS_NAME;
> }
>
> void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
> - Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
> + Record.AddDeclRef(T->getDecl()->getCanonicalDecl());
> Code = TYPE_OBJC_INTERFACE;
> }
>
> void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
> - Writer.AddTypeRef(T->getBaseType(), Record);
> + Record.AddTypeRef(T->getBaseType());
> Record.push_back(T->getTypeArgsAsWritten().size());
> for (auto TypeArg : T->getTypeArgsAsWritten())
> - Writer.AddTypeRef(TypeArg, Record);
> + Record.AddTypeRef(TypeArg);
> Record.push_back(T->getNumProtocols());
> for (const auto *I : T->quals())
> - Writer.AddDeclRef(I, Record);
> + Record.AddDeclRef(I);
> Record.push_back(T->isKindOfTypeAsWritten());
> Code = TYPE_OBJC_OBJECT;
> }
>
> void
> ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
> - Writer.AddTypeRef(T->getPointeeType(), Record);
> + Record.AddTypeRef(T->getPointeeType());
> Code = TYPE_OBJC_OBJECT_POINTER;
> }
>
> void
> ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
> - Writer.AddTypeRef(T->getValueType(), Record);
> + Record.AddTypeRef(T->getValueType());
> Code = TYPE_ATOMIC;
> }
>
> void
> ASTTypeWriter::VisitPipeType(const PipeType *T) {
> - Writer.AddTypeRef(T->getElementType(), Record);
> + Record.AddTypeRef(T->getElementType());
> Code = TYPE_PIPE;
> }
>
> @@ -463,11 +462,11 @@ namespace {
>
> class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
> ASTWriter &Writer;
> - ASTWriter::RecordDataImpl &Record;
> + ASTRecordWriter Record;
>
> public:
> TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
> - : Writer(Writer), Record(Record) { }
> + : Writer(Writer), Record(Writer, Record) { }
>
> #define ABSTRACT_TYPELOC(CLASS, PARENT)
> #define TYPELOC(CLASS, PARENT) \
> @@ -484,7 +483,7 @@ void TypeLocWriter::VisitQualifiedTypeLo
> // nothing to do
> }
> void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
> + Record.AddSourceLocation(TL.getBuiltinLoc());
> if (TL.needsExtraLocalData()) {
> Record.push_back(TL.getWrittenTypeSpec());
> Record.push_back(TL.getWrittenSignSpec());
> @@ -493,10 +492,10 @@ void TypeLocWriter::VisitBuiltinTypeLoc(
> }
> }
> void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getStarLoc(), Record);
> + Record.AddSourceLocation(TL.getStarLoc());
> }
> void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
> // nothing to do
> @@ -505,21 +504,21 @@ void TypeLocWriter::VisitAdjustedTypeLoc
> // nothing to do
> }
> void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getCaretLoc(), Record);
> + Record.AddSourceLocation(TL.getCaretLoc());
> }
> void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getAmpLoc(), Record);
> + Record.AddSourceLocation(TL.getAmpLoc());
> }
> void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record);
> + Record.AddSourceLocation(TL.getAmpAmpLoc());
> }
> void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getStarLoc(), Record);
> - Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record);
> + Record.AddSourceLocation(TL.getStarLoc());
> + Record.AddTypeSourceInfo(TL.getClassTInfo());
> }
> void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getLBracketLoc(), Record);
> - Writer.AddSourceLocation(TL.getRBracketLoc(), Record);
> + Record.AddSourceLocation(TL.getLBracketLoc());
> + Record.AddSourceLocation(TL.getRBracketLoc());
> Record.push_back(TL.getSizeExpr() ? 1 : 0);
> if (TL.getSizeExpr())
> Writer.AddStmt(TL.getSizeExpr());
> @@ -539,21 +538,21 @@ void TypeLocWriter::VisitDependentSizedA
> }
> void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
> DependentSizedExtVectorTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
> - Writer.AddSourceLocation(TL.getLParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getRParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record);
> + Record.AddSourceLocation(TL.getLocalRangeBegin());
> + Record.AddSourceLocation(TL.getLParenLoc());
> + Record.AddSourceLocation(TL.getRParenLoc());
> + Record.AddSourceLocation(TL.getLocalRangeEnd());
> for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
> - Writer.AddDeclRef(TL.getParam(i), Record);
> + Record.AddDeclRef(TL.getParam(i));
> }
> void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
> VisitFunctionTypeLoc(TL);
> @@ -562,131 +561,131 @@ void TypeLocWriter::VisitFunctionNoProto
> VisitFunctionTypeLoc(TL);
> }
> void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
> - Writer.AddSourceLocation(TL.getLParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getRParenLoc(), Record);
> + Record.AddSourceLocation(TL.getTypeofLoc());
> + Record.AddSourceLocation(TL.getLParenLoc());
> + Record.AddSourceLocation(TL.getRParenLoc());
> }
> void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
> - Writer.AddSourceLocation(TL.getLParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getRParenLoc(), Record);
> - Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
> + Record.AddSourceLocation(TL.getTypeofLoc());
> + Record.AddSourceLocation(TL.getLParenLoc());
> + Record.AddSourceLocation(TL.getRParenLoc());
> + Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
> }
> void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getKWLoc(), Record);
> - Writer.AddSourceLocation(TL.getLParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getRParenLoc(), Record);
> - Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
> + Record.AddSourceLocation(TL.getKWLoc());
> + Record.AddSourceLocation(TL.getLParenLoc());
> + Record.AddSourceLocation(TL.getRParenLoc());
> + Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
> }
> void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
> + Record.AddSourceLocation(TL.getAttrNameLoc());
> if (TL.hasAttrOperand()) {
> SourceRange range = TL.getAttrOperandParensRange();
> - Writer.AddSourceLocation(range.getBegin(), Record);
> - Writer.AddSourceLocation(range.getEnd(), Record);
> + Record.AddSourceLocation(range.getBegin());
> + Record.AddSourceLocation(range.getEnd());
> }
> if (TL.hasAttrExprOperand()) {
> Expr *operand = TL.getAttrExprOperand();
> Record.push_back(operand ? 1 : 0);
> if (operand) Writer.AddStmt(operand);
> } else if (TL.hasAttrEnumOperand()) {
> - Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record);
> + Record.AddSourceLocation(TL.getAttrEnumOperandLoc());
> }
> }
> void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
> SubstTemplateTypeParmTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
> SubstTemplateTypeParmPackTypeLoc
> TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
> TemplateSpecializationTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
> - Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
> - Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
> - Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
> + Record.AddSourceLocation(TL.getTemplateKeywordLoc());
> + Record.AddSourceLocation(TL.getTemplateNameLoc());
> + Record.AddSourceLocation(TL.getLAngleLoc());
> + Record.AddSourceLocation(TL.getRAngleLoc());
> for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
> -
> Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
> - TL.getArgLoc(i).getLocInfo(), Record);
> +
> Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
> + TL.getArgLoc(i).getLocInfo());
> }
> void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getLParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getRParenLoc(), Record);
> + Record.AddSourceLocation(TL.getLParenLoc());
> + Record.AddSourceLocation(TL.getRParenLoc());
> }
> void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
> + Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
> + Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
> }
> void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc
> TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
> + Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
> DependentTemplateSpecializationTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
> - Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
> - Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
> - Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
> - Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
> + Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
> + Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
> + Record.AddSourceLocation(TL.getTemplateKeywordLoc());
> + Record.AddSourceLocation(TL.getTemplateNameLoc());
> + Record.AddSourceLocation(TL.getLAngleLoc());
> + Record.AddSourceLocation(TL.getRAngleLoc());
> for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
> -
> Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
> - TL.getArgLoc(I).getLocInfo(), Record);
> +
> Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
> + TL.getArgLoc(I).getLocInfo());
> }
> void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getEllipsisLoc(), Record);
> + Record.AddSourceLocation(TL.getEllipsisLoc());
> }
> void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getNameLoc(), Record);
> + Record.AddSourceLocation(TL.getNameLoc());
> }
> void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
> Record.push_back(TL.hasBaseTypeAsWritten());
> - Writer.AddSourceLocation(TL.getTypeArgsLAngleLoc(), Record);
> - Writer.AddSourceLocation(TL.getTypeArgsRAngleLoc(), Record);
> + Record.AddSourceLocation(TL.getTypeArgsLAngleLoc());
> + Record.AddSourceLocation(TL.getTypeArgsRAngleLoc());
> for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
> - Writer.AddTypeSourceInfo(TL.getTypeArgTInfo(i), Record);
> - Writer.AddSourceLocation(TL.getProtocolLAngleLoc(), Record);
> - Writer.AddSourceLocation(TL.getProtocolRAngleLoc(), Record);
> + Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i));
> + Record.AddSourceLocation(TL.getProtocolLAngleLoc());
> + Record.AddSourceLocation(TL.getProtocolRAngleLoc());
> for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
> - Writer.AddSourceLocation(TL.getProtocolLoc(i), Record);
> + Record.AddSourceLocation(TL.getProtocolLoc(i));
> }
> void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc
> TL) {
> - Writer.AddSourceLocation(TL.getStarLoc(), Record);
> + Record.AddSourceLocation(TL.getStarLoc());
> }
> void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getKWLoc(), Record);
> - Writer.AddSourceLocation(TL.getLParenLoc(), Record);
> - Writer.AddSourceLocation(TL.getRParenLoc(), Record);
> + Record.AddSourceLocation(TL.getKWLoc());
> + Record.AddSourceLocation(TL.getLParenLoc());
> + Record.AddSourceLocation(TL.getRParenLoc());
> }
> void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) {
> - Writer.AddSourceLocation(TL.getKWLoc(), Record);
> + Record.AddSourceLocation(TL.getKWLoc());
> }
>
> void ASTWriter::WriteTypeAbbrevs() {
> @@ -3989,9 +3988,9 @@ void ASTWriter::WriteModuleFileExtension
> // General Serialization Routines
> //===----------------------------------------------------------------------===//
>
> -/// \brief Write a record containing the given attributes.
> -void ASTWriter::WriteAttributes(ArrayRef<const Attr*> Attrs,
> - RecordDataImpl &Record) {
> +/// \brief Emit the list of attributes to the specified record.
> +void ASTWriter::AddAttributes(ArrayRef<const Attr *> Attrs,
> + RecordDataImpl &Record) {
> Record.push_back(Attrs.size());
> for (const auto *A : Attrs) {
> Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
> @@ -4656,11 +4655,18 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> const Decl *D = DeclUpdate.first;
>
> bool HasUpdatedBody = false;
> - RecordData Record;
> + RecordData RecordData;
> + ASTRecordWriter Record(*this, RecordData);
> for (auto &Update : DeclUpdate.second) {
> DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind();
>
> - Record.push_back(Kind);
> + // An updated body is emitted last, so that the reader doesn't need
> + // to skip over the lazy body to reach statements for other records.
> + if (Kind == UPD_CXX_ADDED_FUNCTION_DEFINITION)
> + HasUpdatedBody = true;
> + else
> + Record.push_back(Kind);
> +
> switch (Kind) {
> case UPD_CXX_ADDED_IMPLICIT_MEMBER:
> case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
> @@ -4670,14 +4676,10 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> break;
>
> case UPD_CXX_ADDED_FUNCTION_DEFINITION:
> - // An updated body is emitted last, so that the reader doesn't need
> - // to skip over the lazy body to reach statements for other records.
> - Record.pop_back();
> - HasUpdatedBody = true;
> break;
>
> case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
> - AddSourceLocation(Update.getLoc(), Record);
> + Record.AddSourceLocation(Update.getLoc());
> break;
>
> case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT:
> @@ -4688,7 +4690,7 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
> auto *RD = cast<CXXRecordDecl>(D);
> UpdatedDeclContexts.insert(RD->getPrimaryContext());
> - AddCXXDefinitionData(RD, Record);
> + Record.AddCXXDefinitionData(RD);
> Record.push_back(WriteDeclContextLexicalBlock(
> *Context, const_cast<CXXRecordDecl *>(RD)));
>
> @@ -4697,11 +4699,11 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> // to it referring to the template definition.
> if (auto *MSInfo = RD->getMemberSpecializationInfo()) {
> Record.push_back(MSInfo->getTemplateSpecializationKind());
> - AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
> } else {
> auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
> Record.push_back(Spec->getTemplateSpecializationKind());
> - AddSourceLocation(Spec->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(Spec->getPointOfInstantiation());
>
> // The instantiation might have been resolved to a partial
> // specialization. If so, record which one.
> @@ -4709,30 +4711,29 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> if (auto PartialSpec =
> From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) {
> Record.push_back(true);
> - AddDeclRef(PartialSpec, Record);
> - AddTemplateArgumentList(&Spec->getTemplateInstantiationArgs(),
> - Record);
> + Record.AddDeclRef(PartialSpec);
> + Record.AddTemplateArgumentList(
> + &Spec->getTemplateInstantiationArgs());
> } else {
> Record.push_back(false);
> }
> }
> Record.push_back(RD->getTagKind());
> - AddSourceLocation(RD->getLocation(), Record);
> - AddSourceLocation(RD->getLocStart(), Record);
> - AddSourceLocation(RD->getRBraceLoc(), Record);
> + Record.AddSourceLocation(RD->getLocation());
> + Record.AddSourceLocation(RD->getLocStart());
> + Record.AddSourceLocation(RD->getRBraceLoc());
>
> // Instantiation may change attributes; write them all out afresh.
> Record.push_back(D->hasAttrs());
> - if (Record.back())
> - WriteAttributes(llvm::makeArrayRef(D->getAttrs().begin(),
> - D->getAttrs().size()), Record);
> + if (D->hasAttrs())
> + Record.AddAttributes(D->getAttrs());
>
> // FIXME: Ensure we don't get here for explicit instantiations.
> break;
> }
>
> case UPD_CXX_RESOLVED_DTOR_DELETE:
> - AddDeclRef(Update.getDecl(), Record);
> + Record.AddDeclRef(Update.getDecl());
> break;
>
> case UPD_CXX_RESOLVED_EXCEPTION_SPEC:
> @@ -4755,8 +4756,8 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> break;
>
> case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
> - AddSourceRange(D->getAttr<OMPThreadPrivateDeclAttr>()->getRange(),
> - Record);
> + Record.AddSourceRange(
> + D->getAttr<OMPThreadPrivateDeclAttr>()->getRange());
> break;
>
> case UPD_DECL_EXPORTED:
> @@ -4764,7 +4765,7 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> break;
>
> case UPD_ADDED_ATTR_TO_RECORD:
> - WriteAttributes(llvm::makeArrayRef(Update.getAttr()), Record);
> + Record.AddAttributes(llvm::makeArrayRef(Update.getAttr()));
> break;
> }
> }
> @@ -4773,14 +4774,12 @@ void ASTWriter::WriteDeclUpdatesBlocks(R
> const auto *Def = cast<FunctionDecl>(D);
> Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION);
> Record.push_back(Def->isInlined());
> - AddSourceLocation(Def->getInnerLocStart(), Record);
> - AddFunctionDefinition(Def, Record);
> + Record.AddSourceLocation(Def->getInnerLocStart());
> + AddFunctionDefinition(Def, Record.getRecordData());
> }
>
> OffsetsRecord.push_back(GetDeclRef(D));
> - OffsetsRecord.push_back(Stream.GetCurrentBitNo());
> -
> - Stream.EmitRecord(DECL_UPDATES, Record);
> + OffsetsRecord.push_back(Record.Emit(DECL_UPDATES));
>
> FlushPendingAfterDecl();
> }
>
> Modified: cfe/trunk/lib/Serialization/ASTWriterDecl.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTWriterDecl.cpp?rev=265195&r1=265194&r2=265195&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Serialization/ASTWriterDecl.cpp (original)
> +++ cfe/trunk/lib/Serialization/ASTWriterDecl.cpp Fri Apr 1 17:52:03 2016
> @@ -32,18 +32,31 @@ using namespace serialization;
>
> namespace clang {
> class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
> -
> ASTWriter &Writer;
> ASTContext &Context;
> - typedef ASTWriter::RecordData RecordData;
> - RecordData &Record;
> + ASTRecordWriter Record;
>
> - public:
> serialization::DeclCode Code;
> unsigned AbbrevToUse;
>
> - ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record)
> - : Writer(Writer), Context(Context), Record(Record) {
> + public:
> + ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
> + ASTWriter::RecordDataImpl &Record)
> + : Writer(Writer), Context(Context), Record(Writer, Record),
> + Code((serialization::DeclCode)0), AbbrevToUse(0) {}
> +
> + uint64_t Emit(Decl *D) {
> + if (!Code)
> + llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
> + D->getDeclKindName() + "'");
> +
> + auto Offset = Record.Emit(Code, AbbrevToUse);
> +
> + // Flush any expressions, base specifiers, and ctor initializers that
> + // were written as part of this declaration.
> + Writer.FlushPendingAfterDecl();
> +
> + return Offset;
> }
>
> void Visit(Decl *D);
> @@ -152,10 +165,10 @@ namespace clang {
>
> Record.push_back(typeParams->size());
> for (auto typeParam : *typeParams) {
> - Writer.AddDeclRef(typeParam, Record);
> + Record.AddDeclRef(typeParam);
> }
> - Writer.AddSourceLocation(typeParams->getLAngleLoc(), Record);
> - Writer.AddSourceLocation(typeParams->getRAngleLoc(), Record);
> + Record.AddSourceLocation(typeParams->getLAngleLoc());
> + Record.AddSourceLocation(typeParams->getRAngleLoc());
> }
>
> void AddFunctionDefinition(const FunctionDecl *FD) {
> @@ -163,8 +176,8 @@ namespace clang {
> if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
> Record.push_back(CD->NumCtorInitializers);
> if (CD->NumCtorInitializers)
> - Writer.AddCXXCtorInitializersRef(
> - llvm::makeArrayRef(CD->init_begin(), CD->init_end()), Record);
> + Record.AddCXXCtorInitializersRef(
> + llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
> }
> Writer.AddStmt(FD->getBody());
> }
> @@ -182,7 +195,7 @@ namespace clang {
> Firsts[nullptr] = R;
> }
> for (const auto &F : Firsts)
> - Writer.AddDeclRef(F.second, Record);
> + Record.AddDeclRef(F.second);
> }
>
> /// Get the specialization decl from an entry in the specialization list.
> @@ -271,7 +284,7 @@ void ASTDeclWriter::Visit(Decl *D) {
> // abbreviation infrastructure requires that arrays are encoded last, so
> // we handle it here in the case of those classes derived from
> DeclaratorDecl
> if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
> - Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record);
> + Record.AddTypeSourceInfo(DD->getTypeSourceInfo());
> }
>
> // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
> @@ -285,16 +298,15 @@ void ASTDeclWriter::Visit(Decl *D) {
> }
>
> void ASTDeclWriter::VisitDecl(Decl *D) {
> - Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record);
> + Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
> if (D->getDeclContext() != D->getLexicalDeclContext())
> - Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()),
> Record);
> + Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
> else
> Record.push_back(0);
> Record.push_back(D->isInvalidDecl());
> Record.push_back(D->hasAttrs());
> if (D->hasAttrs())
> - Writer.WriteAttributes(llvm::makeArrayRef(D->getAttrs().begin(),
> - D->getAttrs().size()), Record);
> + Record.AddAttributes(D->getAttrs());
> Record.push_back(D->isImplicit());
> Record.push_back(D->isUsed(false));
> Record.push_back(D->isReferenced());
> @@ -328,9 +340,9 @@ void ASTDeclWriter::VisitPragmaCommentDe
> StringRef Arg = D->getArg();
> Record.push_back(Arg.size());
> VisitDecl(D);
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> + Record.AddSourceLocation(D->getLocStart());
> Record.push_back(D->getCommentKind());
> - Writer.AddString(Arg, Record);
> + Record.AddString(Arg);
> Code = serialization::DECL_PRAGMA_COMMENT;
> }
>
> @@ -340,9 +352,9 @@ void ASTDeclWriter::VisitPragmaDetectMis
> StringRef Value = D->getValue();
> Record.push_back(Name.size() + 1 + Value.size());
> VisitDecl(D);
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> - Writer.AddString(Name, Record);
> - Writer.AddString(Value, Record);
> + Record.AddSourceLocation(D->getLocStart());
> + Record.AddString(Name);
> + Record.AddString(Value);
> Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
> }
>
> @@ -352,7 +364,7 @@ void ASTDeclWriter::VisitTranslationUnit
>
> void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
> VisitDecl(D);
> - Writer.AddDeclarationName(D->getDeclName(), Record);
> + Record.AddDeclarationName(D->getDeclName());
> Record.push_back(needsAnonymousDeclarationNumber(D)
> ? Writer.getAnonymousDeclarationNumber(D)
> : 0);
> @@ -360,17 +372,17 @@ void ASTDeclWriter::VisitNamedDecl(Named
>
> void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> - Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
> + Record.AddSourceLocation(D->getLocStart());
> + Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
> }
>
> void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
> VisitRedeclarable(D);
> VisitTypeDecl(D);
> - Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
> + Record.AddTypeSourceInfo(D->getTypeSourceInfo());
> Record.push_back(D->isModed());
> if (D->isModed())
> - Writer.AddTypeRef(D->getUnderlyingType(), Record);
> + Record.AddTypeRef(D->getUnderlyingType());
> }
>
> void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
> @@ -391,7 +403,7 @@ void ASTDeclWriter::VisitTypedefDecl(Typ
>
> void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
> VisitTypedefNameDecl(D);
> - Writer.AddDeclRef(D->getDescribedAliasTemplate(), Record);
> + Record.AddDeclRef(D->getDescribedAliasTemplate());
> Code = serialization::DECL_TYPEALIAS;
> }
>
> @@ -405,15 +417,15 @@ void ASTDeclWriter::VisitTagDecl(TagDecl
> Record.push_back(D->isEmbeddedInDeclarator());
> Record.push_back(D->isFreeStanding());
> Record.push_back(D->isCompleteDefinitionRequired());
> - Writer.AddSourceLocation(D->getRBraceLoc(), Record);
> + Record.AddSourceLocation(D->getRBraceLoc());
>
> if (D->hasExtInfo()) {
> Record.push_back(1);
> - Writer.AddQualifierInfo(*D->getExtInfo(), Record);
> + Record.AddQualifierInfo(*D->getExtInfo());
> } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
> Record.push_back(2);
> - Writer.AddDeclRef(TD, Record);
> - Writer.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo(), Record);
> + Record.AddDeclRef(TD);
> + Record.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo());
> } else {
> Record.push_back(0);
> }
> @@ -421,21 +433,21 @@ void ASTDeclWriter::VisitTagDecl(TagDecl
>
> void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
> VisitTagDecl(D);
> - Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record);
> + Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
> if (!D->getIntegerTypeSourceInfo())
> - Writer.AddTypeRef(D->getIntegerType(), Record);
> - Writer.AddTypeRef(D->getPromotionType(), Record);
> + Record.AddTypeRef(D->getIntegerType());
> + Record.AddTypeRef(D->getPromotionType());
> Record.push_back(D->getNumPositiveBits());
> Record.push_back(D->getNumNegativeBits());
> Record.push_back(D->isScoped());
> Record.push_back(D->isScopedUsingClassTag());
> Record.push_back(D->isFixed());
> if (MemberSpecializationInfo *MemberInfo =
> D->getMemberSpecializationInfo()) {
> - Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
> + Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
> Record.push_back(MemberInfo->getTemplateSpecializationKind());
> - Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
> } else {
> - Writer.AddDeclRef(nullptr, Record);
> + Record.AddDeclRef(nullptr);
> }
>
> if (D->getDeclContext() == D->getLexicalDeclContext() &&
> @@ -489,7 +501,7 @@ void ASTDeclWriter::VisitRecordDecl(Reco
>
> void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddTypeRef(D->getType(), Record);
> + Record.AddTypeRef(D->getType());
> }
>
> void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
> @@ -497,23 +509,23 @@ void ASTDeclWriter::VisitEnumConstantDec
> Record.push_back(D->getInitExpr()? 1 : 0);
> if (D->getInitExpr())
> Writer.AddStmt(D->getInitExpr());
> - Writer.AddAPSInt(D->getInitVal(), Record);
> + Record.AddAPSInt(D->getInitVal());
>
> Code = serialization::DECL_ENUM_CONSTANT;
> }
>
> void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
> VisitValueDecl(D);
> - Writer.AddSourceLocation(D->getInnerLocStart(), Record);
> + Record.AddSourceLocation(D->getInnerLocStart());
> Record.push_back(D->hasExtInfo());
> if (D->hasExtInfo())
> - Writer.AddQualifierInfo(*D->getExtInfo(), Record);
> + Record.AddQualifierInfo(*D->getExtInfo());
> }
>
> void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
> VisitRedeclarable(D);
> VisitDeclaratorDecl(D);
> - Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
> + Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
> Record.push_back(D->getIdentifierNamespace());
>
> // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
> @@ -535,20 +547,20 @@ void ASTDeclWriter::VisitFunctionDecl(Fu
> Record.push_back(D->HasSkippedBody);
> Record.push_back(D->IsLateTemplateParsed);
> Record.push_back(D->getLinkageInternal());
> - Writer.AddSourceLocation(D->getLocEnd(), Record);
> + Record.AddSourceLocation(D->getLocEnd());
>
> Record.push_back(D->getTemplatedKind());
> switch (D->getTemplatedKind()) {
> case FunctionDecl::TK_NonTemplate:
> break;
> case FunctionDecl::TK_FunctionTemplate:
> - Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record);
> + Record.AddDeclRef(D->getDescribedFunctionTemplate());
> break;
> case FunctionDecl::TK_MemberSpecialization: {
> MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
> - Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record);
> + Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
> Record.push_back(MemberInfo->getTemplateSpecializationKind());
> - Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
> break;
> }
> case FunctionDecl::TK_FunctionTemplateSpecialization: {
> @@ -557,11 +569,11 @@ void ASTDeclWriter::VisitFunctionDecl(Fu
>
> RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
>
> - Writer.AddDeclRef(FTSInfo->getTemplate(), Record);
> + Record.AddDeclRef(FTSInfo->getTemplate());
> Record.push_back(FTSInfo->getTemplateSpecializationKind());
>
> // Template arguments.
> - Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record);
> + Record.AddTemplateArgumentList(FTSInfo->TemplateArguments);
>
> // Template args as written.
> Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
> @@ -569,20 +581,18 @@ void ASTDeclWriter::VisitFunctionDecl(Fu
> Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
> for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
> i!=e; ++i)
> -
> Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i],
> - Record);
> -
> Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc,
> - Record);
> -
> Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc,
> - Record);
> + Record.AddTemplateArgumentLoc(
> + (*FTSInfo->TemplateArgumentsAsWritten)[i]);
> +
> Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
> +
> Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
> }
>
> - Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
>
> if (D->isCanonicalDecl()) {
> // Write the template that contains the specializations set. We will
> // add a FunctionTemplateSpecializationInfo to it when reading.
> - Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record);
> + Record.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl());
> }
> break;
> }
> @@ -593,21 +603,21 @@ void ASTDeclWriter::VisitFunctionDecl(Fu
> // Templates.
> Record.push_back(DFTSInfo->getNumTemplates());
> for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
> - Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record);
> + Record.AddDeclRef(DFTSInfo->getTemplate(i));
>
> // Templates args.
> Record.push_back(DFTSInfo->getNumTemplateArgs());
> for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
> - Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record);
> - Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record);
> - Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record);
> + Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
> + Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
> + Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
> break;
> }
> }
>
> Record.push_back(D->param_size());
> for (auto P : D->params())
> - Writer.AddDeclRef(P, Record);
> + Record.AddDeclRef(P);
> Code = serialization::DECL_FUNCTION;
> }
>
> @@ -620,8 +630,8 @@ void ASTDeclWriter::VisitObjCMethodDecl(
> Record.push_back(HasBodyStuff);
> if (HasBodyStuff) {
> Writer.AddStmt(D->getBody());
> - Writer.AddDeclRef(D->getSelfDecl(), Record);
> - Writer.AddDeclRef(D->getCmdDecl(), Record);
> + Record.AddDeclRef(D->getSelfDecl());
> + Record.AddDeclRef(D->getCmdDecl());
> }
> Record.push_back(D->isInstanceMethod());
> Record.push_back(D->isVariadic());
> @@ -634,7 +644,7 @@ void ASTDeclWriter::VisitObjCMethodDecl(
> Record.push_back(D->HasRedeclaration);
> if (D->HasRedeclaration) {
> assert(Context.getObjCMethodRedeclaration(D));
> - Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record);
> + Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
> }
>
> // FIXME: stable encoding for @required/@optional
> @@ -642,19 +652,19 @@ void ASTDeclWriter::VisitObjCMethodDecl(
> // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
> Record.push_back(D->getObjCDeclQualifier());
> Record.push_back(D->hasRelatedResultType());
> - Writer.AddTypeRef(D->getReturnType(), Record);
> - Writer.AddTypeSourceInfo(D->getReturnTypeSourceInfo(), Record);
> - Writer.AddSourceLocation(D->getLocEnd(), Record);
> + Record.AddTypeRef(D->getReturnType());
> + Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
> + Record.AddSourceLocation(D->getLocEnd());
> Record.push_back(D->param_size());
> for (const auto *P : D->params())
> - Writer.AddDeclRef(P, Record);
> + Record.AddDeclRef(P);
>
> Record.push_back(D->SelLocsKind);
> unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
> SourceLocation *SelLocs = D->getStoredSelLocs();
> Record.push_back(NumStoredSelLocs);
> for (unsigned i = 0; i != NumStoredSelLocs; ++i)
> - Writer.AddSourceLocation(SelLocs[i], Record);
> + Record.AddSourceLocation(SelLocs[i]);
>
> Code = serialization::DECL_OBJC_METHOD;
> }
> @@ -663,23 +673,23 @@ void ASTDeclWriter::VisitObjCTypeParamDe
> VisitTypedefNameDecl(D);
> Record.push_back(D->Variance);
> Record.push_back(D->Index);
> - Writer.AddSourceLocation(D->VarianceLoc, Record);
> - Writer.AddSourceLocation(D->ColonLoc, Record);
> + Record.AddSourceLocation(D->VarianceLoc);
> + Record.AddSourceLocation(D->ColonLoc);
>
> Code = serialization::DECL_OBJC_TYPE_PARAM;
> }
>
> void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getAtStartLoc(), Record);
> - Writer.AddSourceRange(D->getAtEndRange(), Record);
> + Record.AddSourceLocation(D->getAtStartLoc());
> + Record.AddSourceRange(D->getAtEndRange());
> // Abstract class (no need to define a stable serialization::DECL code).
> }
>
> void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
> VisitRedeclarable(D);
> VisitObjCContainerDecl(D);
> - Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record);
> + Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
> AddObjCTypeParamList(D->TypeParamList);
>
> Record.push_back(D->isThisDeclarationADefinition());
> @@ -687,16 +697,16 @@ void ASTDeclWriter::VisitObjCInterfaceDe
> // Write the DefinitionData
> ObjCInterfaceDecl::DefinitionData &Data = D->data();
>
> - Writer.AddTypeSourceInfo(D->getSuperClassTInfo(), Record);
> - Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record);
> + Record.AddTypeSourceInfo(D->getSuperClassTInfo());
> + Record.AddSourceLocation(D->getEndOfDefinitionLoc());
> Record.push_back(Data.HasDesignatedInitializers);
>
> // Write out the protocols that are directly referenced by the @interface.
> Record.push_back(Data.ReferencedProtocols.size());
> for (const auto *P : D->protocols())
> - Writer.AddDeclRef(P, Record);
> + Record.AddDeclRef(P);
> for (const auto &PL : D->protocol_locs())
> - Writer.AddSourceLocation(PL, Record);
> + Record.AddSourceLocation(PL);
>
> // Write out the protocols that are transitively referenced.
> Record.push_back(Data.AllReferencedProtocols.size());
> @@ -704,7 +714,7 @@ void ASTDeclWriter::VisitObjCInterfaceDe
> P = Data.AllReferencedProtocols.begin(),
> PEnd = Data.AllReferencedProtocols.end();
> P != PEnd; ++P)
> - Writer.AddDeclRef(*P, Record);
> + Record.AddDeclRef(*P);
>
>
> if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
> @@ -749,9 +759,9 @@ void ASTDeclWriter::VisitObjCProtocolDec
> if (D->isThisDeclarationADefinition()) {
> Record.push_back(D->protocol_size());
> for (const auto *I : D->protocols())
> - Writer.AddDeclRef(I, Record);
> + Record.AddDeclRef(I);
> for (const auto &PL : D->protocol_locs())
> - Writer.AddSourceLocation(PL, Record);
> + Record.AddSourceLocation(PL);
> }
>
> Code = serialization::DECL_OBJC_PROTOCOL;
> @@ -764,78 +774,78 @@ void ASTDeclWriter::VisitObjCAtDefsField
>
> void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
> VisitObjCContainerDecl(D);
> - Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
> - Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
> - Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
> - Writer.AddDeclRef(D->getClassInterface(), Record);
> + Record.AddSourceLocation(D->getCategoryNameLoc());
> + Record.AddSourceLocation(D->getIvarLBraceLoc());
> + Record.AddSourceLocation(D->getIvarRBraceLoc());
> + Record.AddDeclRef(D->getClassInterface());
> AddObjCTypeParamList(D->TypeParamList);
> Record.push_back(D->protocol_size());
> for (const auto *I : D->protocols())
> - Writer.AddDeclRef(I, Record);
> + Record.AddDeclRef(I);
> for (const auto &PL : D->protocol_locs())
> - Writer.AddSourceLocation(PL, Record);
> + Record.AddSourceLocation(PL);
> Code = serialization::DECL_OBJC_CATEGORY;
> }
>
> void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddDeclRef(D->getClassInterface(), Record);
> + Record.AddDeclRef(D->getClassInterface());
> Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
> }
>
> void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getAtLoc(), Record);
> - Writer.AddSourceLocation(D->getLParenLoc(), Record);
> - Writer.AddTypeRef(D->getType(), Record);
> - Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record);
> + Record.AddSourceLocation(D->getAtLoc());
> + Record.AddSourceLocation(D->getLParenLoc());
> + Record.AddTypeRef(D->getType());
> + Record.AddTypeSourceInfo(D->getTypeSourceInfo());
> // FIXME: stable encoding
> Record.push_back((unsigned)D->getPropertyAttributes());
> Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
> // FIXME: stable encoding
> Record.push_back((unsigned)D->getPropertyImplementation());
> - Writer.AddDeclarationName(D->getGetterName(), Record);
> - Writer.AddDeclarationName(D->getSetterName(), Record);
> - Writer.AddDeclRef(D->getGetterMethodDecl(), Record);
> - Writer.AddDeclRef(D->getSetterMethodDecl(), Record);
> - Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
> + Record.AddDeclarationName(D->getGetterName());
> + Record.AddDeclarationName(D->getSetterName());
> + Record.AddDeclRef(D->getGetterMethodDecl());
> + Record.AddDeclRef(D->getSetterMethodDecl());
> + Record.AddDeclRef(D->getPropertyIvarDecl());
> Code = serialization::DECL_OBJC_PROPERTY;
> }
>
> void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
> VisitObjCContainerDecl(D);
> - Writer.AddDeclRef(D->getClassInterface(), Record);
> + Record.AddDeclRef(D->getClassInterface());
> // Abstract class (no need to define a stable serialization::DECL code).
> }
>
> void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
> VisitObjCImplDecl(D);
> - Writer.AddIdentifierRef(D->getIdentifier(), Record);
> - Writer.AddSourceLocation(D->getCategoryNameLoc(), Record);
> + Record.AddIdentifierRef(D->getIdentifier());
> + Record.AddSourceLocation(D->getCategoryNameLoc());
> Code = serialization::DECL_OBJC_CATEGORY_IMPL;
> }
>
> void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
> VisitObjCImplDecl(D);
> - Writer.AddDeclRef(D->getSuperClass(), Record);
> - Writer.AddSourceLocation(D->getSuperClassLoc(), Record);
> - Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record);
> - Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record);
> + Record.AddDeclRef(D->getSuperClass());
> + Record.AddSourceLocation(D->getSuperClassLoc());
> + Record.AddSourceLocation(D->getIvarLBraceLoc());
> + Record.AddSourceLocation(D->getIvarRBraceLoc());
> Record.push_back(D->hasNonZeroConstructors());
> Record.push_back(D->hasDestructors());
> Record.push_back(D->NumIvarInitializers);
> if (D->NumIvarInitializers)
> - Writer.AddCXXCtorInitializersRef(
> - llvm::makeArrayRef(D->init_begin(), D->init_end()), Record);
> + Record.AddCXXCtorInitializersRef(
> + llvm::makeArrayRef(D->init_begin(), D->init_end()));
> Code = serialization::DECL_OBJC_IMPLEMENTATION;
> }
>
> void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
> VisitDecl(D);
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> - Writer.AddDeclRef(D->getPropertyDecl(), Record);
> - Writer.AddDeclRef(D->getPropertyIvarDecl(), Record);
> - Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record);
> + Record.AddSourceLocation(D->getLocStart());
> + Record.AddDeclRef(D->getPropertyDecl());
> + Record.AddDeclRef(D->getPropertyIvarDecl());
> + Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
> Writer.AddStmt(D->getGetterCXXConstructor());
> Writer.AddStmt(D->getSetterCXXAssignment());
> Code = serialization::DECL_OBJC_PROPERTY_IMPL;
> @@ -849,15 +859,14 @@ void ASTDeclWriter::VisitFieldDecl(Field
> Record.push_back(0);
> } else if (D->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
> Record.push_back(D->InitStorage.getInt() + 1);
> - Writer.AddTypeRef(
> - QualType(static_cast<Type *>(D->InitStorage.getPointer()), 0),
> - Record);
> + Record.AddTypeRef(
> + QualType(static_cast<Type *>(D->InitStorage.getPointer()), 0));
> } else {
> Record.push_back(D->InitStorage.getInt() + 1);
> Writer.AddStmt(static_cast<Expr *>(D->InitStorage.getPointer()));
> }
> if (!D->getDeclName())
> - Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D),
> Record);
> + Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
>
> if (D->getDeclContext() == D->getLexicalDeclContext() &&
> !D->hasAttrs() &&
> @@ -880,8 +889,8 @@ void ASTDeclWriter::VisitFieldDecl(Field
>
> void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
> VisitDeclaratorDecl(D);
> - Writer.AddIdentifierRef(D->getGetterId(), Record);
> - Writer.AddIdentifierRef(D->getSetterId(), Record);
> + Record.AddIdentifierRef(D->getGetterId());
> + Record.AddIdentifierRef(D->getSetterId());
> Code = serialization::DECL_MS_PROPERTY;
> }
>
> @@ -890,7 +899,7 @@ void ASTDeclWriter::VisitIndirectFieldDe
> Record.push_back(D->getChainingSize());
>
> for (const auto *P : D->chain())
> - Writer.AddDeclRef(P, Record);
> + Record.AddDeclRef(P);
> Code = serialization::DECL_INDIRECTFIELD;
> }
>
> @@ -923,13 +932,13 @@ void ASTDeclWriter::VisitVarDecl(VarDecl
> };
> if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
> Record.push_back(VarTemplate);
> - Writer.AddDeclRef(TemplD, Record);
> + Record.AddDeclRef(TemplD);
> } else if (MemberSpecializationInfo *SpecInfo
> = D->getMemberSpecializationInfo()) {
> Record.push_back(StaticDataMemberSpecialization);
> - Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record);
> + Record.AddDeclRef(SpecInfo->getInstantiatedFrom());
> Record.push_back(SpecInfo->getTemplateSpecializationKind());
> - Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(SpecInfo->getPointOfInstantiation());
> } else {
> Record.push_back(VarNotTemplate);
> }
> @@ -1015,7 +1024,7 @@ void ASTDeclWriter::VisitParmVarDecl(Par
> void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
> VisitDecl(D);
> Writer.AddStmt(D->getAsmString());
> - Writer.AddSourceLocation(D->getRParenLoc(), Record);
> + Record.AddSourceLocation(D->getRParenLoc());
> Code = serialization::DECL_FILE_SCOPE_ASM;
> }
>
> @@ -1027,18 +1036,18 @@ void ASTDeclWriter::VisitEmptyDecl(Empty
> void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
> VisitDecl(D);
> Writer.AddStmt(D->getBody());
> - Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record);
> + Record.AddTypeSourceInfo(D->getSignatureAsWritten());
> Record.push_back(D->param_size());
> for (FunctionDecl::param_iterator P = D->param_begin(), PEnd =
> D->param_end();
> P != PEnd; ++P)
> - Writer.AddDeclRef(*P, Record);
> + Record.AddDeclRef(*P);
> Record.push_back(D->isVariadic());
> Record.push_back(D->blockMissingReturnType());
> Record.push_back(D->isConversionFromLambda());
> Record.push_back(D->capturesCXXThis());
> Record.push_back(D->getNumCaptures());
> for (const auto &capture : D->captures()) {
> - Writer.AddDeclRef(capture.getVariable(), Record);
> + Record.AddDeclRef(capture.getVariable());
>
> unsigned flags = 0;
> if (capture.isByRef()) flags |= 1;
> @@ -1059,21 +1068,21 @@ void ASTDeclWriter::VisitCapturedDecl(Ca
> Record.push_back(CD->isNothrow() ? 1 : 0);
> // Body is stored by VisitCapturedStmt.
> for (unsigned I = 0; I < CD->getNumParams(); ++I)
> - Writer.AddDeclRef(CD->getParam(I), Record);
> + Record.AddDeclRef(CD->getParam(I));
> Code = serialization::DECL_CAPTURED;
> }
>
> void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
> VisitDecl(D);
> Record.push_back(D->getLanguage());
> - Writer.AddSourceLocation(D->getExternLoc(), Record);
> - Writer.AddSourceLocation(D->getRBraceLoc(), Record);
> + Record.AddSourceLocation(D->getExternLoc());
> + Record.AddSourceLocation(D->getRBraceLoc());
> Code = serialization::DECL_LINKAGE_SPEC;
> }
>
> void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> + Record.AddSourceLocation(D->getLocStart());
> Code = serialization::DECL_LABEL;
> }
>
> @@ -1082,11 +1091,11 @@ void ASTDeclWriter::VisitNamespaceDecl(N
> VisitRedeclarable(D);
> VisitNamedDecl(D);
> Record.push_back(D->isInline());
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> - Writer.AddSourceLocation(D->getRBraceLoc(), Record);
> + Record.AddSourceLocation(D->getLocStart());
> + Record.AddSourceLocation(D->getRBraceLoc());
>
> if (D->isOriginalNamespace())
> - Writer.AddDeclRef(D->getAnonymousNamespace(), Record);
> + Record.AddDeclRef(D->getAnonymousNamespace());
> Code = serialization::DECL_NAMESPACE;
>
> if (Writer.hasChain() && D->isAnonymousNamespace() &&
> @@ -1107,56 +1116,56 @@ void ASTDeclWriter::VisitNamespaceDecl(N
> void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
> VisitRedeclarable(D);
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getNamespaceLoc(), Record);
> - Writer.AddSourceLocation(D->getTargetNameLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
> - Writer.AddDeclRef(D->getNamespace(), Record);
> + Record.AddSourceLocation(D->getNamespaceLoc());
> + Record.AddSourceLocation(D->getTargetNameLoc());
> + Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
> + Record.AddDeclRef(D->getNamespace());
> Code = serialization::DECL_NAMESPACE_ALIAS;
> }
>
> void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getUsingLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
> - Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
> - Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record);
> + Record.AddSourceLocation(D->getUsingLoc());
> + Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
> + Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
> + Record.AddDeclRef(D->FirstUsingShadow.getPointer());
> Record.push_back(D->hasTypename());
> - Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record);
> + Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
> Code = serialization::DECL_USING;
> }
>
> void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
> VisitRedeclarable(D);
> VisitNamedDecl(D);
> - Writer.AddDeclRef(D->getTargetDecl(), Record);
> - Writer.AddDeclRef(D->UsingOrNextShadow, Record);
> - Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record);
> + Record.AddDeclRef(D->getTargetDecl());
> + Record.AddDeclRef(D->UsingOrNextShadow);
> + Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
> Code = serialization::DECL_USING_SHADOW;
> }
>
> void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
> VisitNamedDecl(D);
> - Writer.AddSourceLocation(D->getUsingLoc(), Record);
> - Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record);
> - Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
> - Writer.AddDeclRef(D->getNominatedNamespace(), Record);
> - Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record);
> + Record.AddSourceLocation(D->getUsingLoc());
> + Record.AddSourceLocation(D->getNamespaceKeyLocation());
> + Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
> + Record.AddDeclRef(D->getNominatedNamespace());
> + Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
> Code = serialization::DECL_USING_DIRECTIVE;
> }
>
> void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl
> *D) {
> VisitValueDecl(D);
> - Writer.AddSourceLocation(D->getUsingLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
> - Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record);
> + Record.AddSourceLocation(D->getUsingLoc());
> + Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
> + Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
> Code = serialization::DECL_UNRESOLVED_USING_VALUE;
> }
>
> void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
> UnresolvedUsingTypenameDecl
> *D) {
> VisitTypeDecl(D);
> - Writer.AddSourceLocation(D->getTypenameLoc(), Record);
> - Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record);
> + Record.AddSourceLocation(D->getTypenameLoc());
> + Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
> Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
> }
>
> @@ -1168,25 +1177,25 @@ void ASTDeclWriter::VisitCXXRecordDecl(C
> };
> if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
> Record.push_back(CXXRecTemplate);
> - Writer.AddDeclRef(TemplD, Record);
> + Record.AddDeclRef(TemplD);
> } else if (MemberSpecializationInfo *MSInfo
> = D->getMemberSpecializationInfo()) {
> Record.push_back(CXXRecMemberSpecialization);
> - Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record);
> + Record.AddDeclRef(MSInfo->getInstantiatedFrom());
> Record.push_back(MSInfo->getTemplateSpecializationKind());
> - Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
> + Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
> } else {
> Record.push_back(CXXRecNotTemplate);
> }
>
> Record.push_back(D->isThisDeclarationADefinition());
> if (D->isThisDeclarationADefinition())
> - Writer.AddCXXDefinitionData(D, Record);
> + Record.AddCXXDefinitionData(D);
>
> // Store (what we currently believe to be) the key function to avoid
> // deserializing every method so we can compute it.
> if (D->IsCompleteDefinition)
> - Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record);
> + Record.AddDeclRef(Context.getCurrentKeyFunction(D));
>
> Code = serialization::DECL_CXX_RECORD;
> }
> @@ -1198,7 +1207,7 @@ void ASTDeclWriter::VisitCXXMethodDecl(C
> for (CXXMethodDecl::method_iterator
> I = D->begin_overridden_methods(), E = D->end_overridden_methods();
> I != E; ++I)
> - Writer.AddDeclRef(*I, Record);
> + Record.AddDeclRef(*I);
> } else {
> // We only need to record overridden methods once for the canonical decl.
> Record.push_back(0);
> @@ -1221,7 +1230,7 @@ void ASTDeclWriter::VisitCXXMethodDecl(C
> void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
> VisitCXXMethodDecl(D);
>
> - Writer.AddDeclRef(D->getInheritedConstructor(), Record);
> + Record.AddDeclRef(D->getInheritedConstructor());
> Record.push_back(D->IsExplicitSpecified);
>
> Code = serialization::DECL_CXX_CONSTRUCTOR;
> @@ -1230,7 +1239,7 @@ void ASTDeclWriter::VisitCXXConstructorD
> void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
> VisitCXXMethodDecl(D);
>
> - Writer.AddDeclRef(D->getOperatorDelete(), Record);
> + Record.AddDeclRef(D->getOperatorDelete());
>
> Code = serialization::DECL_CXX_DESTRUCTOR;
> }
> @@ -1247,11 +1256,11 @@ void ASTDeclWriter::VisitImportDecl(Impo
> ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
> Record.push_back(!IdentifierLocs.empty());
> if (IdentifierLocs.empty()) {
> - Writer.AddSourceLocation(D->getLocEnd(), Record);
> + Record.AddSourceLocation(D->getLocEnd());
> Record.push_back(1);
> } else {
> for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
> - Writer.AddSourceLocation(IdentifierLocs[I], Record);
> + Record.AddSourceLocation(IdentifierLocs[I]);
> Record.push_back(IdentifierLocs.size());
> }
> // Note: the number of source locations must always be the last element in
> @@ -1261,7 +1270,7 @@ void ASTDeclWriter::VisitImportDecl(Impo
>
> void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
> VisitDecl(D);
> - Writer.AddSourceLocation(D->getColonLoc(), Record);
> + Record.AddSourceLocation(D->getColonLoc());
> Code = serialization::DECL_ACCESS_SPEC;
> }
>
> @@ -1273,15 +1282,14 @@ void ASTDeclWriter::VisitFriendDecl(Frie
> bool hasFriendDecl = D->Friend.is<NamedDecl*>();
> Record.push_back(hasFriendDecl);
> if (hasFriendDecl)
> - Writer.AddDeclRef(D->getFriendDecl(), Record);
> + Record.AddDeclRef(D->getFriendDecl());
> else
> - Writer.AddTypeSourceInfo(D->getFriendType(), Record);
> + Record.AddTypeSourceInfo(D->getFriendType());
> for (unsigned i = 0; i < D->NumTPLists; ++i)
> - Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i),
> - Record);
> - Writer.AddDeclRef(D->getNextFriend(), Record);
> +
> Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
> + Record.AddDeclRef(D->getNextFriend());
> Record.push_back(D->UnsupportedFriend);
> - Writer.AddSourceLocation(D->FriendLoc, Record);
> + Record.AddSourceLocation(D->FriendLoc);
> Code = serialization::DECL_FRIEND;
> }
>
> @@ -1289,21 +1297,21 @@ void ASTDeclWriter::VisitFriendTemplateD
> VisitDecl(D);
> Record.push_back(D->getNumTemplateParameters());
> for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
> - Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record);
> + Record.AddTemplateParameterList(D->getTemplateParameterList(i));
> Record.push_back(D->getFriendDecl() != nullptr);
> if (D->getFriendDecl())
> - Writer.AddDeclRef(D->getFriendDecl(), Record);
> + Record.AddDeclRef(D->getFriendDecl());
> else
> - Writer.AddTypeSourceInfo(D->getFriendType(), Record);
> - Writer.AddSourceLocation(D->getFriendLoc(), Record);
> + Record.AddTypeSourceInfo(D->getFriendType());
> + Record.AddSourceLocation(D->getFriendLoc());
> Code = serialization::DECL_FRIEND_TEMPLATE;
> }
>
> void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
> VisitNamedDecl(D);
>
> - Writer.AddDeclRef(D->getTemplatedDecl(), Record);
> - Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
> + Record.AddDeclRef(D->getTemplatedDecl());
> + Record.AddTemplateParameterList(D->getTemplateParameters());
> }
>
> void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl
> *D) {
> @@ -1313,7 +1321,7 @@ void ASTDeclWriter::VisitRedeclarableTem
> // getCommonPtr() can be used while this is still initializing.
> if (D->isFirstDecl()) {
> // This declaration owns the 'common' pointer, so serialize that data now.
> - Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record);
> + Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
> if (D->getInstantiatedFromMemberTemplate())
> Record.push_back(D->isMemberSpecialization());
> }
> @@ -1340,28 +1348,27 @@ void ASTDeclWriter::VisitClassTemplateSp
> ClassTemplatePartialSpecializationDecl *> InstFrom
> = D->getSpecializedTemplateOrPartial();
> if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
> - Writer.AddDeclRef(InstFromD, Record);
> + Record.AddDeclRef(InstFromD);
> } else {
> - Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl
> *>(),
> - Record);
> - Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(),
> Record);
> + Record.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl
> *>());
> + Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
> }
>
> - Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
> - Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
> + Record.AddTemplateArgumentList(&D->getTemplateArgs());
> + Record.AddSourceLocation(D->getPointOfInstantiation());
> Record.push_back(D->getSpecializationKind());
> Record.push_back(D->isCanonicalDecl());
>
> if (D->isCanonicalDecl()) {
> // When reading, we'll add it to the folding set of the following
> template.
> - Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(),
> Record);
> + Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
> }
>
> // Explicit info.
> - Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
> + Record.AddTypeSourceInfo(D->getTypeAsWritten());
> if (D->getTypeAsWritten()) {
> - Writer.AddSourceLocation(D->getExternLoc(), Record);
> - Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
> + Record.AddSourceLocation(D->getExternLoc());
> + Record.AddSourceLocation(D->getTemplateKeywordLoc());
> }
>
> Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
> @@ -1371,12 +1378,12 @@ void ASTDeclWriter::VisitClassTemplatePa
> ClassTemplatePartialSpecializationDecl
> *D) {
> VisitClassTemplateSpecializationDecl(D);
>
> - Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
> - Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(),
> Record);
> + Record.AddTemplateParameterList(D->getTemplateParameters());
> + Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
>
> // These are read/set from/to the first declaration.
> if (D->getPreviousDecl() == nullptr) {
> - Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
> + Record.AddDeclRef(D->getInstantiatedFromMember());
> Record.push_back(D->isMemberSpecialization());
> }
>
> @@ -1400,28 +1407,27 @@ void ASTDeclWriter::VisitVarTemplateSpec
> llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl
> *>
> InstFrom = D->getSpecializedTemplateOrPartial();
> if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
> - Writer.AddDeclRef(InstFromD, Record);
> + Record.AddDeclRef(InstFromD);
> } else {
> - Writer.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>(),
> - Record);
> - Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(),
> Record);
> + Record.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl
> *>());
> + Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
> }
>
> // Explicit info.
> - Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record);
> + Record.AddTypeSourceInfo(D->getTypeAsWritten());
> if (D->getTypeAsWritten()) {
> - Writer.AddSourceLocation(D->getExternLoc(), Record);
> - Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record);
> + Record.AddSourceLocation(D->getExternLoc());
> + Record.AddSourceLocation(D->getTemplateKeywordLoc());
> }
>
> - Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record);
> - Writer.AddSourceLocation(D->getPointOfInstantiation(), Record);
> + Record.AddTemplateArgumentList(&D->getTemplateArgs());
> + Record.AddSourceLocation(D->getPointOfInstantiation());
> Record.push_back(D->getSpecializationKind());
> Record.push_back(D->isCanonicalDecl());
>
> if (D->isCanonicalDecl()) {
> // When reading, we'll add it to the folding set of the following
> template.
> - Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(),
> Record);
> + Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
> }
>
> Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
> @@ -1431,12 +1437,12 @@ void ASTDeclWriter::VisitVarTemplatePart
> VarTemplatePartialSpecializationDecl *D) {
> VisitVarTemplateSpecializationDecl(D);
>
> - Writer.AddTemplateParameterList(D->getTemplateParameters(), Record);
> - Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(),
> Record);
> + Record.AddTemplateParameterList(D->getTemplateParameters());
> + Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
>
> // These are read/set from/to the first declaration.
> if (D->getPreviousDecl() == nullptr) {
> - Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);
> + Record.AddDeclRef(D->getInstantiatedFromMember());
> Record.push_back(D->isMemberSpecialization());
> }
>
> @@ -1446,7 +1452,7 @@ void ASTDeclWriter::VisitVarTemplatePart
> void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
> ClassScopeFunctionSpecializationDecl *D) {
> VisitDecl(D);
> - Writer.AddDeclRef(D->getSpecialization(), Record);
> + Record.AddDeclRef(D->getSpecialization());
> Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
> }
>
> @@ -1468,7 +1474,7 @@ void ASTDeclWriter::VisitTemplateTypePar
> !D->defaultArgumentWasInherited();
> Record.push_back(OwnsDefaultArg);
> if (OwnsDefaultArg)
> - Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record);
> + Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
>
> Code = serialization::DECL_TEMPLATE_TYPE_PARM;
> }
> @@ -1487,8 +1493,8 @@ void ASTDeclWriter::VisitNonTypeTemplate
>
> if (D->isExpandedParameterPack()) {
> for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
> - Writer.AddTypeRef(D->getExpansionType(I), Record);
> - Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record);
> + Record.AddTypeRef(D->getExpansionType(I));
> + Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
> }
>
> Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
> @@ -1519,8 +1525,7 @@ void ASTDeclWriter::VisitTemplateTemplat
> if (D->isExpandedParameterPack()) {
> for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
> I != N; ++I)
> - Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I),
> - Record);
> + Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
> Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
> } else {
> // Rest of TemplateTemplateParmDecl.
> @@ -1529,7 +1534,7 @@ void ASTDeclWriter::VisitTemplateTemplat
> !D->defaultArgumentWasInherited();
> Record.push_back(OwnsDefaultArg);
> if (OwnsDefaultArg)
> - Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record);
> + Record.AddTemplateArgumentLoc(D->getDefaultArgument());
> Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
> }
> }
> @@ -1544,7 +1549,7 @@ void ASTDeclWriter::VisitStaticAssertDec
> Writer.AddStmt(D->getAssertExpr());
> Record.push_back(D->isFailed());
> Writer.AddStmt(D->getMessage());
> - Writer.AddSourceLocation(D->getRParenLoc(), Record);
> + Record.AddSourceLocation(D->getRParenLoc());
> Code = serialization::DECL_STATIC_ASSERT;
> }
>
> @@ -1601,7 +1606,7 @@ void ASTDeclWriter::VisitRedeclarable(Re
> assert(isRedeclarableDeclKind(DAsT->getKind()) &&
> "Not considered redeclarable?");
>
> - Writer.AddDeclRef(First, Record);
> + Record.AddDeclRef(First);
>
> // Write out a list of local redeclarations of this declaration if it's
> the
> // first local declaration in the chain.
> @@ -1619,24 +1624,23 @@ void ASTDeclWriter::VisitRedeclarable(Re
>
> // Collect the set of local redeclarations of this declaration, from
> // newest to oldest.
> - RecordData LocalRedecls;
> + ASTWriter::RecordData LocalRedecls;
> + ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
> for (const Decl *Prev = FirstLocal->getMostRecentDecl();
> Prev != FirstLocal; Prev = Prev->getPreviousDecl())
> if (!Prev->isFromASTFile())
> - Writer.AddDeclRef(Prev, LocalRedecls);
> + LocalRedeclWriter.AddDeclRef(Prev);
>
> // If we have any redecls, write them now as a separate record preceding
> // the declaration itself.
> if (LocalRedecls.empty())
> Record.push_back(0);
> else {
> - auto Start = Writer.Stream.GetCurrentBitNo();
> - Writer.Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedecls);
> - AddLocalOffset(Start);
> + AddLocalOffset(LocalRedeclWriter.Emit(LOCAL_REDECLARATIONS));
> }
> } else {
> Record.push_back(0);
> - Writer.AddDeclRef(FirstLocal, Record);
> + Record.AddDeclRef(FirstLocal);
> }
>
> // Make sure that we serialize both the previous and the most-recent
> @@ -1663,10 +1667,10 @@ void ASTDeclWriter::VisitOMPThreadPrivat
>
> void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
> VisitValueDecl(D);
> - Writer.AddSourceLocation(D->getLocStart(), Record);
> + Record.AddSourceLocation(D->getLocStart());
> Writer.AddStmt(D->getCombiner());
> Writer.AddStmt(D->getInitializer());
> - Writer.AddDeclRef(D->getPrevDeclInScope(), Record);
> + Record.AddDeclRef(D->getPrevDeclInScope());
> Code = serialization::DECL_OMP_DECLARE_REDUCTION;
> }
>
> @@ -2146,9 +2150,6 @@ void ASTWriter::WriteDecl(ASTContext &Co
> // Switch case IDs are per Decl.
> ClearSwitchCaseIDs();
>
> - RecordData Record;
> - ASTDeclWriter W(*this, Context, Record);
> -
> // Determine the ID for this declaration.
> serialization::DeclID ID;
> assert(!D->isFromASTFile() && "should not be emitting imported decl");
> @@ -2173,38 +2174,34 @@ void ASTWriter::WriteDecl(ASTContext &Co
> VisibleOffset = WriteDeclContextVisibleBlock(Context, DC);
> }
>
> + RecordData Record;
> + ASTDeclWriter W(*this, Context, Record);
> +
> // Build a record for this declaration
> - Record.clear();
> - W.Code = (serialization::DeclCode)0;
> - W.AbbrevToUse = 0;
> W.Visit(D);
> if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset);
>
> - unsigned Index = ID - FirstDeclID;
> + // Emit this declaration to the bitstream.
> + uint64_t Offset = W.Emit(D);
>
> // Record the offset for this declaration
> SourceLocation Loc = D->getLocation();
> + unsigned Index = ID - FirstDeclID;
> if (DeclOffsets.size() == Index)
> - DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo()));
> + DeclOffsets.push_back(DeclOffset(Loc, Offset));
> else if (DeclOffsets.size() < Index) {
> + // FIXME: Can/should this happen?
> DeclOffsets.resize(Index+1);
> DeclOffsets[Index].setLocation(Loc);
> - DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo();
> + DeclOffsets[Index].BitOffset = Offset;
> + } else {
> + llvm_unreachable("declarations should be emitted in ID order");
> }
>
> SourceManager &SM = Context.getSourceManager();
> if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
> associateDeclWithFile(D, ID);
>
> - if (!W.Code)
> - llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
> - D->getDeclKindName() + "'");
> - Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
> -
> - // Flush any expressions, base specifiers, and ctor initializers that
> - // were written as part of this declaration.
> - FlushPendingAfterDecl();
> -
> // Note declarations that should be deserialized eagerly so that we can add
> // them to a record in the AST file later.
> if (isRequiredDecl(D, Context, WritingModule))
> @@ -2212,7 +2209,7 @@ void ASTWriter::WriteDecl(ASTContext &Co
> }
>
> void ASTWriter::AddFunctionDefinition(const FunctionDecl *FD,
> - RecordData &Record) {
> + RecordDataImpl &Record) {
> ClearSwitchCaseIDs();
>
> ASTDeclWriter W(*this, FD->getASTContext(), Record);
>
> Modified: cfe/trunk/lib/Serialization/ASTWriterStmt.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTWriterStmt.cpp?rev=265195&r1=265194&r2=265195&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Serialization/ASTWriterStmt.cpp (original)
> +++ cfe/trunk/lib/Serialization/ASTWriterStmt.cpp Fri Apr 1 17:52:03 2016
> @@ -112,7 +112,7 @@ void ASTStmtWriter::VisitLabelStmt(Label
> void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
> VisitStmt(S);
> Record.push_back(S->getAttrs().size());
> - Writer.WriteAttributes(S->getAttrs(), Record);
> + Writer.AddAttributes(S->getAttrs(), Record);
> Writer.AddStmt(S->getSubStmt());
> Writer.AddSourceLocation(S->getAttrLoc(), Record);
> Code = serialization::STMT_ATTRIBUTED;
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits@lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
