dnrops
/
clang
mirror of https://github.com/microsoft/clang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[modules] Continue factoring encoding of AST records out of ASTWriter. 

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@265518 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Richard Smith 2016-04-06 06:26:08 +00:00
parent 04f331168c
commit e8c1d1f15d
6 changed files with 995 additions and 1103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/clang/AST/DeclCXX.h
View File

@ -1714,6 +1714,7 @@ public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTRecordWriter;
friend class ASTReader;
friend class ASTWriter;
};

184
include/clang/Serialization/ASTWriter.h
View File

@ -90,6 +90,7 @@ public:
friend class ASTDeclWriter;
friend class ASTStmtWriter;
friend class ASTTypeWriter;
friend class ASTRecordWriter;
private:
/// \brief Map that provides the ID numbers of each type within the
@ -391,14 +392,6 @@ private:
/// redeclaration chains.
llvm::DenseMap<const Decl *, const Decl *> FirstLocalDeclCache;
/// \brief Statements that we've encountered while serializing a
/// declaration or type.
SmallVector<Stmt *, 16> StmtsToEmit;
/// \brief Statements collection to use for ASTWriter::AddStmt().
/// It will point to StmtsToEmit unless it is overriden.
SmallVector<Stmt *, 16> *CollectedStmts;
/// \brief Mapping from SwitchCase statements to IDs.
llvm::DenseMap<SwitchCase *, unsigned> SwitchCaseIDs;
@ -555,7 +548,6 @@ private:
void WriteDeclAbbrevs();
void WriteDecl(ASTContext &Context, Decl *D);
void AddFunctionDefinition(const FunctionDecl *FD, RecordDataImpl &Record);
uint64_t WriteASTCore(Sema &SemaRef,
StringRef isysroot, const std::string &OutputFile,
@ -649,26 +641,6 @@ public:
/// \brief Determine the type ID of an already-emitted type.
serialization::TypeID getTypeID(QualType T) const;
/// \brief Emits a reference to a declarator info.
void AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordDataImpl &Record);
/// \brief Emits a type with source-location information.
void AddTypeLoc(TypeLoc TL, RecordDataImpl &Record);
/// \brief Emits a template argument location info.
void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
const TemplateArgumentLocInfo &Arg,
RecordDataImpl &Record);
/// \brief Emits a template argument location.
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
RecordDataImpl &Record);
/// \brief Emits an AST template argument list info.
void AddASTTemplateArgumentListInfo(
const ASTTemplateArgumentListInfo *ASTTemplArgList,
RecordDataImpl &Record);
/// \brief Find the first local declaration of a given local redeclarable
/// decl.
const Decl *getFirstLocalDecl(const Decl *D);
@ -684,59 +656,26 @@ 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,
DeclarationName Name, RecordDataImpl &Record);
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
RecordDataImpl &Record);
unsigned getAnonymousDeclarationNumber(const NamedDecl *D);
void AddQualifierInfo(const QualifierInfo &Info, RecordDataImpl &Record);
unsigned getAnonymousDeclarationNumber(const NamedDecl *D);
/// \brief Emit a nested name specifier.
void AddNestedNameSpecifier(NestedNameSpecifier *NNS, RecordDataImpl &Record);
/// \brief Emit a nested name specifier with source-location information.
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
RecordDataImpl &Record);
/// \brief Emit a template name.
void AddTemplateName(TemplateName Name, RecordDataImpl &Record);
/// \brief Emit a template argument.
void AddTemplateArgument(const TemplateArgument &Arg, RecordDataImpl &Record);
/// \brief Emit a template parameter list.
void AddTemplateParameterList(const TemplateParameterList *TemplateParams,
RecordDataImpl &Record);
/// \brief Emit a template argument list.
void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
RecordDataImpl &Record);
/// \brief Emit a UnresolvedSet structure.
void AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record);
/// \brief Emit a C++ base specifier.
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
RecordDataImpl &Record);
/// \brief Emit the ID for a CXXCtorInitializer array and register the array
/// for later serialization.
void AddCXXCtorInitializersRef(ArrayRef<CXXCtorInitializer *> Inits,
RecordDataImpl &Record);
/// \brief Emit a CXXCtorInitializer array.
void AddCXXCtorInitializers(
const CXXCtorInitializer * const *CtorInitializers,
unsigned NumCtorInitializers,
RecordDataImpl &Record);
void AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record);
/// \brief Add a string to the given record.
void AddString(StringRef Str, RecordDataImpl &Record);
@ -771,22 +710,6 @@ public:
/// within the method pool/selector table.
void SetSelectorOffset(Selector Sel, uint32_t Offset);
/// \brief Add the given statement or expression to the queue of
/// statements to emit.
///
/// This routine should be used when emitting types and declarations
/// that have expressions as part of their formulation. Once the
/// type or declaration has been written, call FlushStmts() to write
/// the corresponding statements just after the type or
/// declaration.
void AddStmt(Stmt *S) {
CollectedStmts->push_back(S);
}
/// \brief Flush all of the statements and expressions that have
/// been added to the queue via AddStmt().
void FlushStmts();
/// \brief Flush all of the C++ base specifier sets that have been added
/// via \c AddCXXBaseSpecifiersRef().
void FlushCXXBaseSpecifiers();
@ -798,7 +721,6 @@ public:
/// \brief Flush all pending records that are tacked onto the end of
/// decl and decl update records.
void FlushPendingAfterDecl() {
FlushStmts();
FlushCXXBaseSpecifiers();
FlushCXXCtorInitializers();
}
@ -871,6 +793,15 @@ class ASTRecordWriter {
ASTWriter *Writer;
ASTWriter::RecordDataImpl *Record;
/// \brief Statements that we've encountered while serializing a
/// declaration or type.
SmallVector<Stmt *, 16> StmtsToEmit;
/// \brief Flush all of the statements and expressions that have
/// been added to the queue via AddStmt().
void FlushStmts();
void FlushSubStmts();
public:
/// Construct a ASTRecordWriter that uses the default encoding scheme.
ASTRecordWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
@ -896,15 +827,37 @@ public:
uint64_t &operator[](size_t N) { return (*Record)[N]; }
/// @}
/// \brief Emit the record to the stream, and return its offset.
/// \brief Emit the record to the stream, followed by its substatements, 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);
Writer->Stream.EmitRecord(Code, *Record, Abbrev);
FlushStmts();
return Offset;
}
/// \brief Emit the record to the stream, preceded by its substatements.
uint64_t EmitStmt(unsigned Code, unsigned Abbrev = 0) {
FlushSubStmts();
Writer->Stream.EmitRecord(Code, *Record, Abbrev);
return Writer->Stream.GetCurrentBitNo();
}
/// \brief Add the given statement or expression to the queue of
/// statements to emit.
///
/// This routine should be used when emitting types and declarations
/// that have expressions as part of their formulation. Once the
/// type or declaration has been written, Emit() will write
/// the corresponding statements just after the record.
void AddStmt(Stmt *S) {
StmtsToEmit.push_back(S);
}
/// \brief Add a definition for the given function to the queue of statements
/// to emit.
void AddFunctionDefinition(const FunctionDecl *FD);
/// \brief Emit a source location.
void AddSourceLocation(SourceLocation Loc) {
@ -958,26 +911,21 @@ public:
}
/// \brief Emits a reference to a declarator info.
void AddTypeSourceInfo(TypeSourceInfo *TInfo) {
return Writer->AddTypeSourceInfo(TInfo, *Record);
}
void AddTypeSourceInfo(TypeSourceInfo *TInfo);
/// \brief Emits a type with source-location information.
void AddTypeLoc(TypeLoc TL);
/// \brief Emits a template argument location info.
void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
const TemplateArgumentLocInfo &Arg) {
return Writer->AddTemplateArgumentLocInfo(Kind, Arg, *Record);
}
const TemplateArgumentLocInfo &Arg);
/// \brief Emits a template argument location.
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) {
return Writer->AddTemplateArgumentLoc(Arg, *Record);
}
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg);
/// \brief Emits an AST template argument list info.
void AddASTTemplateArgumentListInfo(
const ASTTemplateArgumentListInfo *ASTTemplArgList) {
return Writer->AddASTTemplateArgumentListInfo(ASTTemplArgList, *Record);
}
const ASTTemplateArgumentListInfo *ASTTemplArgList);
/// \brief Emit a reference to a declaration.
void AddDeclRef(const Decl *D) {
@ -989,17 +937,10 @@ public:
}
void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
DeclarationName Name) {
return Writer->AddDeclarationNameLoc(DNLoc, Name, *Record);
}
DeclarationName Name);
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
return Writer->AddDeclarationNameInfo(NameInfo, *Record);
}
void AddQualifierInfo(const QualifierInfo &Info) {
return Writer->AddQualifierInfo(Info, *Record);
}
void AddQualifierInfo(const QualifierInfo &Info);
/// \brief Emit a nested name specifier.
void AddNestedNameSpecifier(NestedNameSpecifier *NNS) {
@ -1007,19 +948,13 @@ public:
}
/// \brief Emit a nested name specifier with source-location information.
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
return Writer->AddNestedNameSpecifierLoc(NNS, *Record);
}
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
/// \brief Emit a template name.
void AddTemplateName(TemplateName Name) {
return Writer->AddTemplateName(Name, *Record);
}
void AddTemplateName(TemplateName Name);
/// \brief Emit a template argument.
void AddTemplateArgument(const TemplateArgument &Arg) {
return Writer->AddTemplateArgument(Arg, *Record);
}
void AddTemplateArgument(const TemplateArgument &Arg);
/// \brief Emit a template parameter list.
void AddTemplateParameterList(const TemplateParameterList *TemplateParams) {
@ -1027,9 +962,7 @@ public:
}
/// \brief Emit a template argument list.
void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs) {
return Writer->AddTemplateArgumentList(TemplateArgs, *Record);
}
void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs);
/// \brief Emit a UnresolvedSet structure.
void AddUnresolvedSet(const ASTUnresolvedSet &Set) {
@ -1037,9 +970,7 @@ public:
}
/// \brief Emit a C++ base specifier.
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) {
return Writer->AddCXXBaseSpecifier(Base, *Record);
}
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base);
/// \brief Emit the ID for a CXXCtorInitializer array and register the array
/// for later serialization.
@ -1049,14 +980,9 @@ public:
/// \brief Emit a CXXCtorInitializer array.
void AddCXXCtorInitializers(const CXXCtorInitializer *const *CtorInitializers,
unsigned NumCtorInitializers) {
return Writer->AddCXXCtorInitializers(CtorInitializers, NumCtorInitializers,
*Record);
}
unsigned NumCtorInitializers);
void AddCXXDefinitionData(const CXXRecordDecl *D) {
return Writer->AddCXXDefinitionData(D, *Record);
}
void AddCXXDefinitionData(const CXXRecordDecl *D);
/// \brief Emit a string.
void AddString(StringRef Str) {
@ -1074,9 +1000,7 @@ public:
}
/// \brief Emit a list of attributes.
void AddAttributes(ArrayRef<const Attr*> Attrs) {
return Writer->AddAttributes(Attrs, *Record);
}
void AddAttributes(ArrayRef<const Attr*> Attrs);
};
/// \brief AST and semantic-analysis consumer that generates a

540
lib/Serialization/ASTWriter.cpp
View File

@ -82,19 +82,42 @@ static StringRef bytes(const SmallVectorImpl<T> &v) {
// Type serialization
//===----------------------------------------------------------------------===//
namespace {
namespace clang {
class ASTTypeWriter {
ASTWriter &Writer;
ASTRecordWriter Record;
public:
/// \brief Type code that corresponds to the record generated.
TypeCode Code;
/// \brief Abbreviation to use for the record, if any.
unsigned AbbrevToUse;
public:
ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
: Writer(Writer), Record(Writer, Record), Code(TYPE_EXT_QUAL) { }
: Writer(Writer), Record(Writer, Record), Code((TypeCode)0), AbbrevToUse(0) { }
uint64_t Emit() {
return Record.Emit(Code, AbbrevToUse);
}
void Visit(QualType T) {
if (T.hasLocalNonFastQualifiers()) {
Qualifiers Qs = T.getLocalQualifiers();
Record.AddTypeRef(T.getLocalUnqualifiedType());
Record.push_back(Qs.getAsOpaqueValue());
Code = TYPE_EXT_QUAL;
AbbrevToUse = Writer.TypeExtQualAbbrev;
} else {
switch (T->getTypeClass()) {
// For all of the concrete, non-dependent types, call the
// appropriate visitor function.
#define TYPE(Class, Base) \
case Type::Class: Visit##Class##Type(cast<Class##Type>(T)); break;
#define ABSTRACT_TYPE(Class, Base)
#include "clang/AST/TypeNodes.def"
}
}
}
void VisitArrayType(const ArrayType *T);
void VisitFunctionType(const FunctionType *T);
@ -104,7 +127,7 @@ namespace {
#define ABSTRACT_TYPE(Class, Base)
#include "clang/AST/TypeNodes.def"
};
} // end anonymous namespace
} // end namespace clang
void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
llvm_unreachable("Built-in types are never serialized");
@ -174,7 +197,7 @@ void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
VisitArrayType(T);
Record.AddSourceLocation(T->getLBracketLoc());
Record.AddSourceLocation(T->getRBracketLoc());
Writer.AddStmt(T->getSizeExpr());
Record.AddStmt(T->getSizeExpr());
Code = TYPE_VARIABLE_ARRAY;
}
@ -209,15 +232,15 @@ void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
Code = TYPE_FUNCTION_NO_PROTO;
}
static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T,
ASTRecordWriter Record) {
static void addExceptionSpec(const FunctionProtoType *T,
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)
Record.AddTypeRef(T->getExceptionType(I));
} else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
Writer.AddStmt(T->getNoexceptExpr());
Record.AddStmt(T->getNoexceptExpr());
} else if (T->getExceptionSpecType() == EST_Uninstantiated) {
Record.AddDeclRef(T->getExceptionSpecDecl());
Record.AddDeclRef(T->getExceptionSpecTemplate());
@ -233,7 +256,7 @@ void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) {
Record.push_back(T->hasTrailingReturn());
Record.push_back(T->getTypeQuals());
Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
addExceptionSpec(Writer, T, Record);
addExceptionSpec(T, Record);
Record.push_back(T->getNumParams());
for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
@ -265,7 +288,7 @@ void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
}
void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
Writer.AddStmt(T->getUnderlyingExpr());
Record.AddStmt(T->getUnderlyingExpr());
Code = TYPE_TYPEOF_EXPR;
}
@ -276,7 +299,7 @@ void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
Record.AddTypeRef(T->getUnderlyingType());
Writer.AddStmt(T->getUnderlyingExpr());
Record.AddStmt(T->getUnderlyingExpr());
Code = TYPE_DECLTYPE;
}
@ -353,7 +376,7 @@ ASTTypeWriter::VisitTemplateSpecializationType(
void
ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
VisitArrayType(T);
Writer.AddStmt(T->getSizeExpr());
Record.AddStmt(T->getSizeExpr());
Record.AddSourceRange(T->getBracketsRange());
Code = TYPE_DEPENDENT_SIZED_ARRAY;
}
@ -461,12 +484,11 @@ ASTTypeWriter::VisitPipeType(const PipeType *T) {
namespace {
class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
ASTWriter &Writer;
ASTRecordWriter Record;
ASTRecordWriter &Record;
public:
TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
: Writer(Writer), Record(Writer, Record) { }
TypeLocWriter(ASTRecordWriter &Record)
: Record(Record) { }
#define ABSTRACT_TYPELOC(CLASS, PARENT)
#define TYPELOC(CLASS, PARENT) \
@ -521,7 +543,7 @@ void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
Record.AddSourceLocation(TL.getRBracketLoc());
Record.push_back(TL.getSizeExpr() ? 1 : 0);
if (TL.getSizeExpr())
Writer.AddStmt(TL.getSizeExpr());
Record.AddStmt(TL.getSizeExpr());
}
void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
@ -605,7 +627,7 @@ void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
if (TL.hasAttrExprOperand()) {
Expr *operand = TL.getAttrExprOperand();
Record.push_back(operand ? 1 : 0);
if (operand) Writer.AddStmt(operand);
if (operand) Record.AddStmt(operand);
} else if (TL.hasAttrEnumOperand()) {
Record.AddSourceLocation(TL.getAttrEnumOperandLoc());
}
@ -2743,43 +2765,23 @@ void ASTWriter::WriteType(QualType T) {
assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
// Record the offset for this type.
unsigned Index = Idx.getIndex() - FirstTypeID;
if (TypeOffsets.size() == Index)
TypeOffsets.push_back(Stream.GetCurrentBitNo());
else if (TypeOffsets.size() < Index) {
TypeOffsets.resize(Index + 1);
TypeOffsets[Index] = Stream.GetCurrentBitNo();
}
RecordData Record;
// Emit the type's representation.
ASTTypeWriter W(*this, Record);
W.AbbrevToUse = 0;
W.Visit(T);
uint64_t Offset = W.Emit();
if (T.hasLocalNonFastQualifiers()) {
Qualifiers Qs = T.getLocalQualifiers();
AddTypeRef(T.getLocalUnqualifiedType(), Record);
Record.push_back(Qs.getAsOpaqueValue());
W.Code = TYPE_EXT_QUAL;
W.AbbrevToUse = TypeExtQualAbbrev;
// Record the offset for this type.
unsigned Index = Idx.getIndex() - FirstTypeID;
if (TypeOffsets.size() == Index)
TypeOffsets.push_back(Offset);
else if (TypeOffsets.size() < Index) {
TypeOffsets.resize(Index + 1);
TypeOffsets[Index] = Offset;
} else {
switch (T->getTypeClass()) {
// For all of the concrete, non-dependent types, call the
// appropriate visitor function.
#define TYPE(Class, Base) \
case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break;
#define ABSTRACT_TYPE(Class, Base)
#include "clang/AST/TypeNodes.def"
}
llvm_unreachable("Types emitted in wrong order");
}
// Emit the serialized record.
Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
// Flush any expressions that were written as part of this type.
FlushStmts();
}
//===----------------------------------------------------------------------===//
@ -3989,12 +3991,12 @@ void ASTWriter::WriteModuleFileExtension(Sema &SemaRef,
//===----------------------------------------------------------------------===//
/// \brief Emit the list of attributes to the specified record.
void ASTWriter::AddAttributes(ArrayRef<const Attr *> Attrs,
RecordDataImpl &Record) {
void ASTRecordWriter::AddAttributes(ArrayRef<const Attr *> Attrs) {
auto &Record = *this;
Record.push_back(Attrs.size());
for (const auto *A : Attrs) {
Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
AddSourceRange(A->getRange(), Record);
Record.AddSourceRange(A->getRange());
#include "clang/Serialization/AttrPCHWrite.inc"
@ -4099,7 +4101,7 @@ ASTWriter::ASTWriter(
NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS),
NextSubmoduleID(FirstSubmoduleID),
FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID),
CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0),
NumStatements(0), NumMacros(0),
NumLexicalDeclContexts(0), NumVisibleDeclContexts(0),
NextCXXBaseSpecifiersID(1), NextCXXCtorInitializersID(1),
TypeExtQualAbbrev(0), TypeFunctionProtoAbbrev(0), DeclParmVarAbbrev(0),
@ -4683,8 +4685,8 @@ void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
break;
case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT:
AddStmt(const_cast<Expr*>(
cast<ParmVarDecl>(Update.getDecl())->getDefaultArg()));
Record.AddStmt(const_cast<Expr *>(
cast<ParmVarDecl>(Update.getDecl())->getDefaultArg()));
break;
case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
@ -4738,7 +4740,6 @@ void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
case UPD_CXX_RESOLVED_EXCEPTION_SPEC:
addExceptionSpec(
*this,
cast<FunctionDecl>(D)->getType()->castAs<FunctionProtoType>(),
Record);
break;
@ -4775,7 +4776,7 @@ void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION);
Record.push_back(Def->isInlined());
Record.AddSourceLocation(Def->getInnerLocStart());
AddFunctionDefinition(Def, Record.getRecordData());
Record.AddFunctionDefinition(Def);
}
OffsetsRecord.push_back(GetDeclRef(D));
@ -4897,24 +4898,23 @@ void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases,
Record.push_back(NextCXXBaseSpecifiersID++);
}
void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
const TemplateArgumentLocInfo &Arg,
RecordDataImpl &Record) {
void ASTRecordWriter::AddTemplateArgumentLocInfo(
TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) {
switch (Kind) {
case TemplateArgument::Expression:
AddStmt(Arg.getAsExpr());
break;
case TemplateArgument::Type:
AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record);
AddTypeSourceInfo(Arg.getAsTypeSourceInfo());
break;
case TemplateArgument::Template:
AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
AddSourceLocation(Arg.getTemplateNameLoc(), Record);
AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc());
AddSourceLocation(Arg.getTemplateNameLoc());
break;
case TemplateArgument::TemplateExpansion:
AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
AddSourceLocation(Arg.getTemplateNameLoc(), Record);
AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record);
AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc());
AddSourceLocation(Arg.getTemplateNameLoc());
AddSourceLocation(Arg.getTemplateEllipsisLoc());
break;
case TemplateArgument::Null:
case TemplateArgument::Integral:
@ -4926,35 +4926,32 @@ void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
}
}
void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
RecordDataImpl &Record) {
AddTemplateArgument(Arg.getArgument(), Record);
void ASTRecordWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) {
AddTemplateArgument(Arg.getArgument());
if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
bool InfoHasSameExpr
= Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
Record.push_back(InfoHasSameExpr);
Record->push_back(InfoHasSameExpr);
if (InfoHasSameExpr)
return; // Avoid storing the same expr twice.
}
AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(),
Record);
AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo());
}
void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
RecordDataImpl &Record) {
void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) {
if (!TInfo) {
AddTypeRef(QualType(), Record);
AddTypeRef(QualType());
return;
}
AddTypeLoc(TInfo->getTypeLoc(), Record);
AddTypeLoc(TInfo->getTypeLoc());
}
void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) {
AddTypeRef(TL.getType(), Record);
void ASTRecordWriter::AddTypeLoc(TypeLoc TL) {
AddTypeRef(TL.getType());
TypeLocWriter TLW(*this, Record);
TypeLocWriter TLW(*this);
for (; !TL.isNull(); TL = TL.getNextTypeLoc())
TLW.Visit(TL);
}
@ -5144,28 +5141,25 @@ unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) {
return It->second;
}
void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
DeclarationName Name, RecordDataImpl &Record) {
void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
DeclarationName Name) {
switch (Name.getNameKind()) {
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record);
AddTypeSourceInfo(DNLoc.NamedType.TInfo);
break;
case DeclarationName::CXXOperatorName:
AddSourceLocation(SourceLocation::getFromRawEncoding(
DNLoc.CXXOperatorName.BeginOpNameLoc));
AddSourceLocation(
SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc),
Record);
AddSourceLocation(
SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc),
Record);
SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc));
break;
case DeclarationName::CXXLiteralOperatorName:
AddSourceLocation(
SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc),
Record);
AddSourceLocation(SourceLocation::getFromRawEncoding(
DNLoc.CXXLiteralOperatorName.OpNameLoc));
break;
case DeclarationName::Identifier:
@ -5177,19 +5171,18 @@ void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
}
}
void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
RecordDataImpl &Record) {
AddDeclarationName(NameInfo.getName(), Record);
AddSourceLocation(NameInfo.getLoc(), Record);
AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
void ASTRecordWriter::AddDeclarationNameInfo(
const DeclarationNameInfo &NameInfo) {
AddDeclarationName(NameInfo.getName());
AddSourceLocation(NameInfo.getLoc());
AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName());
}
void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
RecordDataImpl &Record) {
AddNestedNameSpecifierLoc(Info.QualifierLoc, Record);
Record.push_back(Info.NumTemplParamLists);
void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info) {
AddNestedNameSpecifierLoc(Info.QualifierLoc);
Record->push_back(Info.NumTemplParamLists);
for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i)
AddTemplateParameterList(Info.TemplParamLists[i], Record);
AddTemplateParameterList(Info.TemplParamLists[i]);
}
void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
@ -5239,8 +5232,7 @@ void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
}
}
void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
RecordDataImpl &Record) {
void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
// Nested name specifiers usually aren't too long. I think that 8 would
// typically accommodate the vast majority.
SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
@ -5252,137 +5244,136 @@ void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
NNS = NNS.getPrefix();
}
Record.push_back(NestedNames.size());
Record->push_back(NestedNames.size());
while(!NestedNames.empty()) {
NNS = NestedNames.pop_back_val();
NestedNameSpecifier::SpecifierKind Kind
= NNS.getNestedNameSpecifier()->getKind();
Record.push_back(Kind);
Record->push_back(Kind);
switch (Kind) {
case NestedNameSpecifier::Identifier:
AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier());
AddSourceRange(NNS.getLocalSourceRange());
break;
case NestedNameSpecifier::Namespace:
AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace());
AddSourceRange(NNS.getLocalSourceRange());
break;
case NestedNameSpecifier::NamespaceAlias:
AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias());
AddSourceRange(NNS.getLocalSourceRange());
break;
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
AddTypeLoc(NNS.getTypeLoc(), Record);
AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
AddTypeLoc(NNS.getTypeLoc());
AddSourceLocation(NNS.getLocalSourceRange().getEnd());
break;
case NestedNameSpecifier::Global:
AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
AddSourceLocation(NNS.getLocalSourceRange().getEnd());
break;
case NestedNameSpecifier::Super:
AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl());
AddSourceRange(NNS.getLocalSourceRange());
break;
}
}
}
void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
void ASTRecordWriter::AddTemplateName(TemplateName Name) {
TemplateName::NameKind Kind = Name.getKind();
Record.push_back(Kind);
Record->push_back(Kind);
switch (Kind) {
case TemplateName::Template:
AddDeclRef(Name.getAsTemplateDecl(), Record);
AddDeclRef(Name.getAsTemplateDecl());
break;
case TemplateName::OverloadedTemplate: {
OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate();
Record.push_back(OvT->size());
Record->push_back(OvT->size());
for (const auto &I : *OvT)
AddDeclRef(I, Record);
AddDeclRef(I);
break;
}
case TemplateName::QualifiedTemplate: {
QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
AddNestedNameSpecifier(QualT->getQualifier(), Record);
Record.push_back(QualT->hasTemplateKeyword());
AddDeclRef(QualT->getTemplateDecl(), Record);
AddNestedNameSpecifier(QualT->getQualifier());
Record->push_back(QualT->hasTemplateKeyword());
AddDeclRef(QualT->getTemplateDecl());
break;
}
case TemplateName::DependentTemplate: {
DependentTemplateName *DepT = Name.getAsDependentTemplateName();
AddNestedNameSpecifier(DepT->getQualifier(), Record);
Record.push_back(DepT->isIdentifier());
AddNestedNameSpecifier(DepT->getQualifier());
Record->push_back(DepT->isIdentifier());
if (DepT->isIdentifier())
AddIdentifierRef(DepT->getIdentifier(), Record);
AddIdentifierRef(DepT->getIdentifier());
else
Record.push_back(DepT->getOperator());
Record->push_back(DepT->getOperator());
break;
}
case TemplateName::SubstTemplateTemplateParm: {
SubstTemplateTemplateParmStorage *subst
= Name.getAsSubstTemplateTemplateParm();
AddDeclRef(subst->getParameter(), Record);
AddTemplateName(subst->getReplacement(), Record);
AddDeclRef(subst->getParameter());
AddTemplateName(subst->getReplacement());
break;
}
case TemplateName::SubstTemplateTemplateParmPack: {
SubstTemplateTemplateParmPackStorage *SubstPack
= Name.getAsSubstTemplateTemplateParmPack();
AddDeclRef(SubstPack->getParameterPack(), Record);
AddTemplateArgument(SubstPack->getArgumentPack(), Record);
AddDeclRef(SubstPack->getParameterPack());
AddTemplateArgument(SubstPack->getArgumentPack());
break;
}
}
}
void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
RecordDataImpl &Record) {
Record.push_back(Arg.getKind());
void ASTRecordWriter::AddTemplateArgument(const TemplateArgument &Arg) {
Record->push_back(Arg.getKind());
switch (Arg.getKind()) {
case TemplateArgument::Null:
break;
case TemplateArgument::Type:
AddTypeRef(Arg.getAsType(), Record);
AddTypeRef(Arg.getAsType());
break;
case TemplateArgument::Declaration:
AddDeclRef(Arg.getAsDecl(), Record);
AddTypeRef(Arg.getParamTypeForDecl(), Record);
AddDeclRef(Arg.getAsDecl());
AddTypeRef(Arg.getParamTypeForDecl());
break;
case TemplateArgument::NullPtr:
AddTypeRef(Arg.getNullPtrType(), Record);
AddTypeRef(Arg.getNullPtrType());
break;
case TemplateArgument::Integral:
AddAPSInt(Arg.getAsIntegral(), Record);
AddTypeRef(Arg.getIntegralType(), Record);
AddAPSInt(Arg.getAsIntegral());
AddTypeRef(Arg.getIntegralType());
break;
case TemplateArgument::Template:
AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
AddTemplateName(Arg.getAsTemplateOrTemplatePattern());
break;
case TemplateArgument::TemplateExpansion:
AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
AddTemplateName(Arg.getAsTemplateOrTemplatePattern());
if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
Record.push_back(*NumExpansions + 1);
Record->push_back(*NumExpansions + 1);
else
Record.push_back(0);
Record->push_back(0);
break;
case TemplateArgument::Expression:
AddStmt(Arg.getAsExpr());
break;
case TemplateArgument::Pack:
Record.push_back(Arg.pack_size());
Record->push_back(Arg.pack_size());
for (const auto &P : Arg.pack_elements())
AddTemplateArgument(P, Record);
AddTemplateArgument(P);
break;
}
}
@ -5400,25 +5391,23 @@ ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
}
/// \brief Emit a template argument list.
void
ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
RecordDataImpl &Record) {
void ASTRecordWriter::AddTemplateArgumentList(
const TemplateArgumentList *TemplateArgs) {
assert(TemplateArgs && "No TemplateArgs!");
Record.push_back(TemplateArgs->size());
Record->push_back(TemplateArgs->size());
for (int i=0, e = TemplateArgs->size(); i != e; ++i)
AddTemplateArgument(TemplateArgs->get(i), Record);
AddTemplateArgument(TemplateArgs->get(i));
}
void
ASTWriter::AddASTTemplateArgumentListInfo
(const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) {
void ASTRecordWriter::AddASTTemplateArgumentListInfo(
const ASTTemplateArgumentListInfo *ASTTemplArgList) {
assert(ASTTemplArgList && "No ASTTemplArgList!");
AddSourceLocation(ASTTemplArgList->LAngleLoc, Record);
AddSourceLocation(ASTTemplArgList->RAngleLoc, Record);
Record.push_back(ASTTemplArgList->NumTemplateArgs);
AddSourceLocation(ASTTemplArgList->LAngleLoc);
AddSourceLocation(ASTTemplArgList->RAngleLoc);
Record->push_back(ASTTemplArgList->NumTemplateArgs);
const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs();
for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i)
AddTemplateArgumentLoc(TemplArgs[i], Record);
AddTemplateArgumentLoc(TemplArgs[i]);
}
void
@ -5431,17 +5420,16 @@ ASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record)
}
}
void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
RecordDataImpl &Record) {
Record.push_back(Base.isVirtual());
Record.push_back(Base.isBaseOfClass());
Record.push_back(Base.getAccessSpecifierAsWritten());
Record.push_back(Base.getInheritConstructors());
AddTypeSourceInfo(Base.getTypeSourceInfo(), Record);
AddSourceRange(Base.getSourceRange(), Record);
// FIXME: Move this out of the main ASTRecordWriter interface.
void ASTRecordWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) {
Record->push_back(Base.isVirtual());
Record->push_back(Base.isBaseOfClass());
Record->push_back(Base.getAccessSpecifierAsWritten());
Record->push_back(Base.getInheritConstructors());
AddTypeSourceInfo(Base.getTypeSourceInfo());
AddSourceRange(Base.getSourceRange());
AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc()
: SourceLocation(),
Record);
: SourceLocation());
}
void ASTWriter::FlushCXXBaseSpecifiers() {
@ -5449,26 +5437,30 @@ void ASTWriter::FlushCXXBaseSpecifiers() {
unsigned N = CXXBaseSpecifiersToWrite.size();
for (unsigned I = 0; I != N; ++I) {
Record.clear();
// Record the offset of this base-specifier set.
unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
if (Index == CXXBaseSpecifiersOffsets.size())
CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo());
else {
if (Index > CXXBaseSpecifiersOffsets.size())
CXXBaseSpecifiersOffsets.resize(Index + 1);
CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo();
}
const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases,
*BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd;
Record.push_back(BEnd - B);
// Write the base specifier set.
ASTRecordWriter Writer(*this, Record);
Writer.push_back(BEnd - B);
for (; B != BEnd; ++B)
AddCXXBaseSpecifier(*B, Record);
Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record);
Writer.AddCXXBaseSpecifier(*B);
uint64_t Offset = Writer.Emit(serialization::DECL_CXX_BASE_SPECIFIERS);
// Flush any expressions that were written as part of the base specifiers.
FlushStmts();
// Record the offset of this base-specifier set.
//
// FIXME: We don't need an indirect lookup table for these; instead, write
// the base specifier record prior to the decl record and store its offset
// from the decl record rather than its ID.
unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
if (Index == CXXBaseSpecifiersOffsets.size())
CXXBaseSpecifiersOffsets.push_back(Offset);
else {
if (Index > CXXBaseSpecifiersOffsets.size())
CXXBaseSpecifiersOffsets.resize(Index + 1);
CXXBaseSpecifiersOffsets[Index] = Offset;
}
}
assert(N == CXXBaseSpecifiersToWrite.size() &&
@ -5476,40 +5468,40 @@ void ASTWriter::FlushCXXBaseSpecifiers() {
CXXBaseSpecifiersToWrite.clear();
}
void ASTWriter::AddCXXCtorInitializers(
const CXXCtorInitializer * const *CtorInitializers,
unsigned NumCtorInitializers,
RecordDataImpl &Record) {
Record.push_back(NumCtorInitializers);
// FIXME: Move this out of the main ASTRecordWriter interface.
void ASTRecordWriter::AddCXXCtorInitializers(
const CXXCtorInitializer *const *CtorInitializers,
unsigned NumCtorInitializers) {
Record->push_back(NumCtorInitializers);
for (unsigned i=0; i != NumCtorInitializers; ++i) {
const CXXCtorInitializer *Init = CtorInitializers[i];
if (Init->isBaseInitializer()) {
Record.push_back(CTOR_INITIALIZER_BASE);
AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
Record.push_back(Init->isBaseVirtual());
Record->push_back(CTOR_INITIALIZER_BASE);
AddTypeSourceInfo(Init->getTypeSourceInfo());
Record->push_back(Init->isBaseVirtual());
} else if (Init->isDelegatingInitializer()) {
Record.push_back(CTOR_INITIALIZER_DELEGATING);
AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
Record->push_back(CTOR_INITIALIZER_DELEGATING);
AddTypeSourceInfo(Init->getTypeSourceInfo());
} else if (Init->isMemberInitializer()){
Record.push_back(CTOR_INITIALIZER_MEMBER);
AddDeclRef(Init->getMember(), Record);
Record->push_back(CTOR_INITIALIZER_MEMBER);
AddDeclRef(Init->getMember());
} else {
Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
AddDeclRef(Init->getIndirectMember(), Record);
Record->push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
AddDeclRef(Init->getIndirectMember());
}
AddSourceLocation(Init->getMemberLocation(), Record);
AddSourceLocation(Init->getMemberLocation());
AddStmt(Init->getInit());
AddSourceLocation(Init->getLParenLoc(), Record);
AddSourceLocation(Init->getRParenLoc(), Record);
Record.push_back(Init->isWritten());
AddSourceLocation(Init->getLParenLoc());
AddSourceLocation(Init->getRParenLoc());
Record->push_back(Init->isWritten());
if (Init->isWritten()) {
Record.push_back(Init->getSourceOrder());
Record->push_back(Init->getSourceOrder());
} else {
Record.push_back(Init->getNumArrayIndices());
Record->push_back(Init->getNumArrayIndices());
for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i)
AddDeclRef(Init->getArrayIndex(i), Record);
AddDeclRef(Init->getArrayIndex(i));
}
}
}
@ -5522,21 +5514,19 @@ void ASTWriter::FlushCXXCtorInitializers() {
for (auto &Init : CXXCtorInitializersToWrite) {
Record.clear();
ASTRecordWriter Writer(*this, Record);
Writer.AddCXXCtorInitializers(Init.Inits.data(), Init.Inits.size());
uint64_t Offset = Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS);
// Record the offset of this mem-initializer list.
unsigned Index = Init.ID - 1;
if (Index == CXXCtorInitializersOffsets.size())
CXXCtorInitializersOffsets.push_back(Stream.GetCurrentBitNo());
CXXCtorInitializersOffsets.push_back(Offset);
else {
if (Index > CXXCtorInitializersOffsets.size())
CXXCtorInitializersOffsets.resize(Index + 1);
CXXCtorInitializersOffsets[Index] = Stream.GetCurrentBitNo();
CXXCtorInitializersOffsets[Index] = Offset;
}
AddCXXCtorInitializers(Init.Inits.data(), Init.Inits.size(), Record);
Stream.EmitRecord(serialization::DECL_CXX_CTOR_INITIALIZERS, Record);
// Flush any expressions that were written as part of the initializers.
FlushStmts();
}
assert(N == CXXCtorInitializersToWrite.size() &&
@ -5544,82 +5534,81 @@ void ASTWriter::FlushCXXCtorInitializers() {
CXXCtorInitializersToWrite.clear();
}
void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) {
void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) {
auto &Data = D->data();
Record.push_back(Data.IsLambda);
Record.push_back(Data.UserDeclaredConstructor);
Record.push_back(Data.UserDeclaredSpecialMembers);
Record.push_back(Data.Aggregate);
Record.push_back(Data.PlainOldData);
Record.push_back(Data.Empty);
Record.push_back(Data.Polymorphic);
Record.push_back(Data.Abstract);
Record.push_back(Data.IsStandardLayout);
Record.push_back(Data.HasNoNonEmptyBases);
Record.push_back(Data.HasPrivateFields);
Record.push_back(Data.HasProtectedFields);
Record.push_back(Data.HasPublicFields);
Record.push_back(Data.HasMutableFields);
Record.push_back(Data.HasVariantMembers);
Record.push_back(Data.HasOnlyCMembers);
Record.push_back(Data.HasInClassInitializer);
Record.push_back(Data.HasUninitializedReferenceMember);
Record.push_back(Data.HasUninitializedFields);
Record.push_back(Data.NeedOverloadResolutionForMoveConstructor);
Record.push_back(Data.NeedOverloadResolutionForMoveAssignment);
Record.push_back(Data.NeedOverloadResolutionForDestructor);
Record.push_back(Data.DefaultedMoveConstructorIsDeleted);
Record.push_back(Data.DefaultedMoveAssignmentIsDeleted);
Record.push_back(Data.DefaultedDestructorIsDeleted);
Record.push_back(Data.HasTrivialSpecialMembers);
Record.push_back(Data.DeclaredNonTrivialSpecialMembers);
Record.push_back(Data.HasIrrelevantDestructor);
Record.push_back(Data.HasConstexprNonCopyMoveConstructor);
Record.push_back(Data.HasDefaultedDefaultConstructor);
Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr);
Record.push_back(Data.HasConstexprDefaultConstructor);
Record.push_back(Data.HasNonLiteralTypeFieldsOrBases);
Record.push_back(Data.ComputedVisibleConversions);
Record.push_back(Data.UserProvidedDefaultConstructor);
Record.push_back(Data.DeclaredSpecialMembers);
Record.push_back(Data.ImplicitCopyConstructorHasConstParam);
Record.push_back(Data.ImplicitCopyAssignmentHasConstParam);
Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam);
Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam);
Record->push_back(Data.IsLambda);
Record->push_back(Data.UserDeclaredConstructor);
Record->push_back(Data.UserDeclaredSpecialMembers);
Record->push_back(Data.Aggregate);
Record->push_back(Data.PlainOldData);
Record->push_back(Data.Empty);
Record->push_back(Data.Polymorphic);
Record->push_back(Data.Abstract);
Record->push_back(Data.IsStandardLayout);
Record->push_back(Data.HasNoNonEmptyBases);
Record->push_back(Data.HasPrivateFields);
Record->push_back(Data.HasProtectedFields);
Record->push_back(Data.HasPublicFields);
Record->push_back(Data.HasMutableFields);
Record->push_back(Data.HasVariantMembers);
Record->push_back(Data.HasOnlyCMembers);
Record->push_back(Data.HasInClassInitializer);
Record->push_back(Data.HasUninitializedReferenceMember);
Record->push_back(Data.HasUninitializedFields);
Record->push_back(Data.NeedOverloadResolutionForMoveConstructor);
Record->push_back(Data.NeedOverloadResolutionForMoveAssignment);
Record->push_back(Data.NeedOverloadResolutionForDestructor);
Record->push_back(Data.DefaultedMoveConstructorIsDeleted);
Record->push_back(Data.DefaultedMoveAssignmentIsDeleted);
Record->push_back(Data.DefaultedDestructorIsDeleted);
Record->push_back(Data.HasTrivialSpecialMembers);
Record->push_back(Data.DeclaredNonTrivialSpecialMembers);
Record->push_back(Data.HasIrrelevantDestructor);
Record->push_back(Data.HasConstexprNonCopyMoveConstructor);
Record->push_back(Data.HasDefaultedDefaultConstructor);
Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr);
Record->push_back(Data.HasConstexprDefaultConstructor);
Record->push_back(Data.HasNonLiteralTypeFieldsOrBases);
Record->push_back(Data.ComputedVisibleConversions);
Record->push_back(Data.UserProvidedDefaultConstructor);
Record->push_back(Data.DeclaredSpecialMembers);
Record->push_back(Data.ImplicitCopyConstructorHasConstParam);
Record->push_back(Data.ImplicitCopyAssignmentHasConstParam);
Record->push_back(Data.HasDeclaredCopyConstructorWithConstParam);
Record->push_back(Data.HasDeclaredCopyAssignmentWithConstParam);
// IsLambda bit is already saved.
Record.push_back(Data.NumBases);
Record->push_back(Data.NumBases);
if (Data.NumBases > 0)
AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases,
Record);
AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases);
// FIXME: Make VBases lazily computed when needed to avoid storing them.
Record.push_back(Data.NumVBases);
Record->push_back(Data.NumVBases);
if (Data.NumVBases > 0)
AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases,
Record);
AddCXXBaseSpecifiersRef(Data.getVBases(),
Data.getVBases() + Data.NumVBases);
AddUnresolvedSet(Data.Conversions.get(*Context), Record);
AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record);
AddUnresolvedSet(Data.Conversions.get(*Writer->Context));
AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context));
// Data.Definition is the owning decl, no need to write it.
AddDeclRef(D->getFirstFriend(), Record);
AddDeclRef(D->getFirstFriend());
// Add lambda-specific data.
if (Data.IsLambda) {
auto &Lambda = D->getLambdaData();
Record.push_back(Lambda.Dependent);
Record.push_back(Lambda.IsGenericLambda);
Record.push_back(Lambda.CaptureDefault);
Record.push_back(Lambda.NumCaptures);
Record.push_back(Lambda.NumExplicitCaptures);
Record.push_back(Lambda.ManglingNumber);
AddDeclRef(Lambda.ContextDecl, Record);
AddTypeSourceInfo(Lambda.MethodTyInfo, Record);
Record->push_back(Lambda.Dependent);
Record->push_back(Lambda.IsGenericLambda);
Record->push_back(Lambda.CaptureDefault);
Record->push_back(Lambda.NumCaptures);
Record->push_back(Lambda.NumExplicitCaptures);
Record->push_back(Lambda.ManglingNumber);
AddDeclRef(Lambda.ContextDecl);
AddTypeSourceInfo(Lambda.MethodTyInfo);
for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
const LambdaCapture &Capture = Lambda.Captures[I];
AddSourceLocation(Capture.getLocation(), Record);
Record.push_back(Capture.isImplicit());
Record.push_back(Capture.getCaptureKind());
AddSourceLocation(Capture.getLocation());
Record->push_back(Capture.isImplicit());
Record->push_back(Capture.getCaptureKind());
switch (Capture.getCaptureKind()) {
case LCK_StarThis:
case LCK_This:
@ -5629,10 +5618,9 @@ void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Rec
case LCK_ByRef:
VarDecl *Var =
Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr;
AddDeclRef(Var, Record);
AddDeclRef(Var);
AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc()
: SourceLocation(),
Record);
: SourceLocation());
break;
}
}

64
lib/Serialization/ASTWriterDecl.cpp
View File

@ -171,17 +171,6 @@ namespace clang {
Record.AddSourceLocation(typeParams->getRAngleLoc());
}
void AddFunctionDefinition(const FunctionDecl *FD) {
assert(FD->doesThisDeclarationHaveABody());
if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
Record.push_back(CD->NumCtorInitializers);
if (CD->NumCtorInitializers)
Record.AddCXXCtorInitializersRef(
llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
}
Writer.AddStmt(FD->getBody());
}
/// Add to the record the first declaration from each module file that
/// provides a declaration of D. The intent is to provide a sufficient
/// set such that reloading this set will load all current redeclarations.
@ -293,7 +282,7 @@ void ASTDeclWriter::Visit(Decl *D) {
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Record.push_back(FD->doesThisDeclarationHaveABody());
if (FD->doesThisDeclarationHaveABody())
AddFunctionDefinition(FD);
Record.AddFunctionDefinition(FD);
}
}
@ -508,7 +497,7 @@ void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
VisitValueDecl(D);
Record.push_back(D->getInitExpr()? 1 : 0);
if (D->getInitExpr())
Writer.AddStmt(D->getInitExpr());
Record.AddStmt(D->getInitExpr());
Record.AddAPSInt(D->getInitVal());
Code = serialization::DECL_ENUM_CONSTANT;
@ -629,7 +618,7 @@ void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
D->getSelfDecl() != nullptr || D->getCmdDecl() != nullptr;
Record.push_back(HasBodyStuff);
if (HasBodyStuff) {
Writer.AddStmt(D->getBody());
Record.AddStmt(D->getBody());
Record.AddDeclRef(D->getSelfDecl());
Record.AddDeclRef(D->getCmdDecl());
}
@ -846,8 +835,8 @@ void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
Record.AddDeclRef(D->getPropertyDecl());
Record.AddDeclRef(D->getPropertyIvarDecl());
Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
Writer.AddStmt(D->getGetterCXXConstructor());
Writer.AddStmt(D->getSetterCXXAssignment());
Record.AddStmt(D->getGetterCXXConstructor());
Record.AddStmt(D->getSetterCXXAssignment());
Code = serialization::DECL_OBJC_PROPERTY_IMPL;
}
@ -863,7 +852,7 @@ void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
QualType(static_cast<Type *>(D->InitStorage.getPointer()), 0));
} else {
Record.push_back(D->InitStorage.getInt() + 1);
Writer.AddStmt(static_cast<Expr *>(D->InitStorage.getPointer()));
Record.AddStmt(static_cast<Expr *>(D->InitStorage.getPointer()));
}
if (!D->getDeclName())
Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
@ -922,7 +911,7 @@ void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
if (D->getInit()) {
Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
Writer.AddStmt(D->getInit());
Record.AddStmt(D->getInit());
} else {
Record.push_back(0);
}
@ -984,7 +973,7 @@ void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
Record.push_back(D->hasInheritedDefaultArg());
Record.push_back(D->hasUninstantiatedDefaultArg());
if (D->hasUninstantiatedDefaultArg())
Writer.AddStmt(D->getUninstantiatedDefaultArg());
Record.AddStmt(D->getUninstantiatedDefaultArg());
Code = serialization::DECL_PARM_VAR;
assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
@ -1023,7 +1012,7 @@ void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
VisitDecl(D);
Writer.AddStmt(D->getAsmString());
Record.AddStmt(D->getAsmString());
Record.AddSourceLocation(D->getRParenLoc());
Code = serialization::DECL_FILE_SCOPE_ASM;
}
@ -1035,7 +1024,7 @@ void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
VisitDecl(D);
Writer.AddStmt(D->getBody());
Record.AddStmt(D->getBody());
Record.AddTypeSourceInfo(D->getSignatureAsWritten());
Record.push_back(D->param_size());
for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
@ -1055,7 +1044,7 @@ void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
if (capture.hasCopyExpr()) flags |= 4;
Record.push_back(flags);
if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr());
if (capture.hasCopyExpr()) Record.AddStmt(capture.getCopyExpr());
}
Code = serialization::DECL_BLOCK;
@ -1505,7 +1494,7 @@ void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
!D->defaultArgumentWasInherited();
Record.push_back(OwnsDefaultArg);
if (OwnsDefaultArg)
Writer.AddStmt(D->getDefaultArgument());
Record.AddStmt(D->getDefaultArgument());
Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
}
}
@ -1546,9 +1535,9 @@ void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
VisitDecl(D);
Writer.AddStmt(D->getAssertExpr());
Record.AddStmt(D->getAssertExpr());
Record.push_back(D->isFailed());
Writer.AddStmt(D->getMessage());
Record.AddStmt(D->getMessage());
Record.AddSourceLocation(D->getRParenLoc());
Code = serialization::DECL_STATIC_ASSERT;
}
@ -1661,15 +1650,15 @@ void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
Record.push_back(D->varlist_size());
VisitDecl(D);
for (auto *I : D->varlists())
Writer.AddStmt(I);
Record.AddStmt(I);
Code = serialization::DECL_OMP_THREADPRIVATE;
}
void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
VisitValueDecl(D);
Record.AddSourceLocation(D->getLocStart());
Writer.AddStmt(D->getCombiner());
Writer.AddStmt(D->getInitializer());
Record.AddStmt(D->getCombiner());
Record.AddStmt(D->getInitializer());
Record.AddDeclRef(D->getPrevDeclInScope());
Code = serialization::DECL_OMP_DECLARE_REDUCTION;
}
@ -2147,9 +2136,6 @@ static bool isRequiredDecl(const Decl *D, ASTContext &Context,
}
void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
// Switch case IDs are per Decl.
ClearSwitchCaseIDs();
// Determine the ID for this declaration.
serialization::DeclID ID;
assert(!D->isFromASTFile() && "should not be emitting imported decl");
@ -2208,10 +2194,16 @@ void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
EagerlyDeserializedDecls.push_back(ID);
}
void ASTWriter::AddFunctionDefinition(const FunctionDecl *FD,
RecordDataImpl &Record) {
ClearSwitchCaseIDs();
void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
// Switch case IDs are per function body.
Writer->ClearSwitchCaseIDs();
ASTDeclWriter W(*this, FD->getASTContext(), Record);
W.AddFunctionDefinition(FD);
assert(FD->doesThisDeclarationHaveABody());
if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
Record->push_back(CD->getNumCtorInitializers());
if (CD->getNumCtorInitializers())
AddCXXCtorInitializersRef(
llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
}
AddStmt(FD->getBody());
}

1284
lib/Serialization/ASTWriterStmt.cpp
View File

File diff suppressed because it is too large Load Diff

25
utils/TableGen/ClangAttrEmitter.cpp
View File

@ -87,16 +87,13 @@ static std::string ReadPCHRecord(StringRef type) {
// Assumes that the way to get the value is SA->getname()
static std::string WritePCHRecord(StringRef type, StringRef name) {
return StringSwitch<std::string>(type)
.EndsWith("Decl *", "AddDeclRef(" + std::string(name) +
", Record);\n")
.Case("TypeSourceInfo *",
"AddTypeSourceInfo(" + std::string(name) + ", Record);\n")
return "Record." + StringSwitch<std::string>(type)
.EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
.Case("TypeSourceInfo *", "AddTypeSourceInfo(" + std::string(name) + ");\n")
.Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
.Case("IdentifierInfo *",
"AddIdentifierRef(" + std::string(name) + ", Record);\n")
.Case("StringRef", "AddString(" + std::string(name) + ", Record);\n")
.Default("Record.push_back(" + std::string(name) + ");\n");
.Case("IdentifierInfo *", "AddIdentifierRef(" + std::string(name) + ");\n")
.Case("StringRef", "AddString(" + std::string(name) + ");\n")
.Default("push_back(" + std::string(name) + ");\n");
}
// Normalize attribute name by removing leading and trailing
@ -371,7 +368,7 @@ namespace {
OS << getLowerName();
}
void writePCHWrite(raw_ostream &OS) const override {
OS << " AddString(SA->get" << getUpperName() << "(), Record);\n";
OS << " Record.AddString(SA->get" << getUpperName() << "());\n";
}
void writeValue(raw_ostream &OS) const override {
OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
@ -487,10 +484,10 @@ namespace {
void writePCHWrite(raw_ostream &OS) const override {
OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
OS << " if (SA->is" << getUpperName() << "Expr())\n";
OS << " AddStmt(SA->get" << getUpperName() << "Expr());\n";
OS << " Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
OS << " else\n";
OS << " AddTypeSourceInfo(SA->get" << getUpperName()
<< "Type(), Record);\n";
OS << " Record.AddTypeSourceInfo(SA->get" << getUpperName()
<< "Type());\n";
}
void writeValue(raw_ostream &OS) const override {
OS << "\";\n";
@ -887,7 +884,7 @@ namespace {
OS << getLowerName();
}
void writePCHWrite(raw_ostream &OS) const override {
OS << " AddVersionTuple(SA->get" << getUpperName() << "(), Record);\n";
OS << " Record.AddVersionTuple(SA->get" << getUpperName() << "());\n";
}
void writeValue(raw_ostream &OS) const override {
OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";