1 //===--- ASTWriter.cpp - AST File Writer ----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ASTWriter class, which writes AST files.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Serialization/ASTWriter.h"
15 #include "ASTCommon.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclContextInternals.h"
19 #include "clang/AST/DeclFriend.h"
20 #include "clang/AST/DeclLookups.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/Type.h"
25 #include "clang/AST/TypeLocVisitor.h"
26 #include "clang/Basic/DiagnosticOptions.h"
27 #include "clang/Basic/FileManager.h"
28 #include "clang/Basic/FileSystemStatCache.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/SourceManagerInternals.h"
31 #include "clang/Basic/TargetInfo.h"
32 #include "clang/Basic/TargetOptions.h"
33 #include "clang/Basic/Version.h"
34 #include "clang/Basic/VersionTuple.h"
35 #include "clang/Lex/HeaderSearch.h"
36 #include "clang/Lex/HeaderSearchOptions.h"
37 #include "clang/Lex/MacroInfo.h"
38 #include "clang/Lex/PreprocessingRecord.h"
39 #include "clang/Lex/Preprocessor.h"
40 #include "clang/Lex/PreprocessorOptions.h"
41 #include "clang/Sema/IdentifierResolver.h"
42 #include "clang/Sema/Sema.h"
43 #include "clang/Serialization/ASTReader.h"
44 #include "llvm/ADT/APFloat.h"
45 #include "llvm/ADT/APInt.h"
46 #include "llvm/ADT/Hashing.h"
47 #include "llvm/ADT/StringExtras.h"
48 #include "llvm/Bitcode/BitstreamWriter.h"
49 #include "llvm/Support/EndianStream.h"
50 #include "llvm/Support/FileSystem.h"
51 #include "llvm/Support/MemoryBuffer.h"
52 #include "llvm/Support/OnDiskHashTable.h"
53 #include "llvm/Support/Path.h"
54 #include "llvm/Support/Process.h"
59 using namespace clang;
60 using namespace clang::serialization;
62 template <typename T, typename Allocator>
63 static StringRef bytes(const std::vector<T, Allocator> &v) {
64 if (v.empty()) return StringRef();
65 return StringRef(reinterpret_cast<const char*>(&v[0]),
66 sizeof(T) * v.size());
70 static StringRef bytes(const SmallVectorImpl<T> &v) {
71 return StringRef(reinterpret_cast<const char*>(v.data()),
72 sizeof(T) * v.size());
75 //===----------------------------------------------------------------------===//
77 //===----------------------------------------------------------------------===//
82 ASTWriter::RecordDataImpl &Record;
85 /// \brief Type code that corresponds to the record generated.
87 /// \brief Abbreviation to use for the record, if any.
90 ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
91 : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { }
93 void VisitArrayType(const ArrayType *T);
94 void VisitFunctionType(const FunctionType *T);
95 void VisitTagType(const TagType *T);
97 #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T);
98 #define ABSTRACT_TYPE(Class, Base)
99 #include "clang/AST/TypeNodes.def"
103 void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
104 llvm_unreachable("Built-in types are never serialized");
107 void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
108 Writer.AddTypeRef(T->getElementType(), Record);
112 void ASTTypeWriter::VisitPointerType(const PointerType *T) {
113 Writer.AddTypeRef(T->getPointeeType(), Record);
117 void ASTTypeWriter::VisitDecayedType(const DecayedType *T) {
118 Writer.AddTypeRef(T->getOriginalType(), Record);
122 void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) {
123 Writer.AddTypeRef(T->getOriginalType(), Record);
124 Writer.AddTypeRef(T->getAdjustedType(), Record);
125 Code = TYPE_ADJUSTED;
128 void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
129 Writer.AddTypeRef(T->getPointeeType(), Record);
130 Code = TYPE_BLOCK_POINTER;
133 void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
134 Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
135 Record.push_back(T->isSpelledAsLValue());
136 Code = TYPE_LVALUE_REFERENCE;
139 void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
140 Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
141 Code = TYPE_RVALUE_REFERENCE;
144 void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) {
145 Writer.AddTypeRef(T->getPointeeType(), Record);
146 Writer.AddTypeRef(QualType(T->getClass(), 0), Record);
147 Code = TYPE_MEMBER_POINTER;
150 void ASTTypeWriter::VisitArrayType(const ArrayType *T) {
151 Writer.AddTypeRef(T->getElementType(), Record);
152 Record.push_back(T->getSizeModifier()); // FIXME: stable values
153 Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values
156 void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
158 Writer.AddAPInt(T->getSize(), Record);
159 Code = TYPE_CONSTANT_ARRAY;
162 void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
164 Code = TYPE_INCOMPLETE_ARRAY;
167 void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
169 Writer.AddSourceLocation(T->getLBracketLoc(), Record);
170 Writer.AddSourceLocation(T->getRBracketLoc(), Record);
171 Writer.AddStmt(T->getSizeExpr());
172 Code = TYPE_VARIABLE_ARRAY;
175 void ASTTypeWriter::VisitVectorType(const VectorType *T) {
176 Writer.AddTypeRef(T->getElementType(), Record);
177 Record.push_back(T->getNumElements());
178 Record.push_back(T->getVectorKind());
182 void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) {
184 Code = TYPE_EXT_VECTOR;
187 void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
188 Writer.AddTypeRef(T->getReturnType(), Record);
189 FunctionType::ExtInfo C = T->getExtInfo();
190 Record.push_back(C.getNoReturn());
191 Record.push_back(C.getHasRegParm());
192 Record.push_back(C.getRegParm());
193 // FIXME: need to stabilize encoding of calling convention...
194 Record.push_back(C.getCC());
195 Record.push_back(C.getProducesResult());
197 if (C.getHasRegParm() || C.getRegParm() || C.getProducesResult())
201 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
202 VisitFunctionType(T);
203 Code = TYPE_FUNCTION_NO_PROTO;
206 static void addExceptionSpec(ASTWriter &Writer, const FunctionProtoType *T,
207 ASTWriter::RecordDataImpl &Record) {
208 Record.push_back(T->getExceptionSpecType());
209 if (T->getExceptionSpecType() == EST_Dynamic) {
210 Record.push_back(T->getNumExceptions());
211 for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
212 Writer.AddTypeRef(T->getExceptionType(I), Record);
213 } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
214 Writer.AddStmt(T->getNoexceptExpr());
215 } else if (T->getExceptionSpecType() == EST_Uninstantiated) {
216 Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
217 Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record);
218 } else if (T->getExceptionSpecType() == EST_Unevaluated) {
219 Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
223 void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) {
224 VisitFunctionType(T);
226 Record.push_back(T->isVariadic());
227 Record.push_back(T->hasTrailingReturn());
228 Record.push_back(T->getTypeQuals());
229 Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
230 addExceptionSpec(Writer, T, Record);
232 Record.push_back(T->getNumParams());
233 for (unsigned I = 0, N = T->getNumParams(); I != N; ++I)
234 Writer.AddTypeRef(T->getParamType(I), Record);
236 if (T->isVariadic() || T->hasTrailingReturn() || T->getTypeQuals() ||
237 T->getRefQualifier() || T->getExceptionSpecType() != EST_None)
240 Code = TYPE_FUNCTION_PROTO;
243 void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
244 Writer.AddDeclRef(T->getDecl(), Record);
245 Code = TYPE_UNRESOLVED_USING;
248 void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
249 Writer.AddDeclRef(T->getDecl(), Record);
250 assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
251 Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
255 void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
256 Writer.AddStmt(T->getUnderlyingExpr());
257 Code = TYPE_TYPEOF_EXPR;
260 void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
261 Writer.AddTypeRef(T->getUnderlyingType(), Record);
265 void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
266 Writer.AddTypeRef(T->getUnderlyingType(), Record);
267 Writer.AddStmt(T->getUnderlyingExpr());
268 Code = TYPE_DECLTYPE;
271 void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
272 Writer.AddTypeRef(T->getBaseType(), Record);
273 Writer.AddTypeRef(T->getUnderlyingType(), Record);
274 Record.push_back(T->getUTTKind());
275 Code = TYPE_UNARY_TRANSFORM;
278 void ASTTypeWriter::VisitAutoType(const AutoType *T) {
279 Writer.AddTypeRef(T->getDeducedType(), Record);
280 Record.push_back(T->isDecltypeAuto());
281 if (T->getDeducedType().isNull())
282 Record.push_back(T->isDependentType());
286 void ASTTypeWriter::VisitTagType(const TagType *T) {
287 Record.push_back(T->isDependentType());
288 Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
289 assert(!T->isBeingDefined() &&
290 "Cannot serialize in the middle of a type definition");
293 void ASTTypeWriter::VisitRecordType(const RecordType *T) {
298 void ASTTypeWriter::VisitEnumType(const EnumType *T) {
303 void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
304 Writer.AddTypeRef(T->getModifiedType(), Record);
305 Writer.AddTypeRef(T->getEquivalentType(), Record);
306 Record.push_back(T->getAttrKind());
307 Code = TYPE_ATTRIBUTED;
311 ASTTypeWriter::VisitSubstTemplateTypeParmType(
312 const SubstTemplateTypeParmType *T) {
313 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
314 Writer.AddTypeRef(T->getReplacementType(), Record);
315 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM;
319 ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
320 const SubstTemplateTypeParmPackType *T) {
321 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
322 Writer.AddTemplateArgument(T->getArgumentPack(), Record);
323 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK;
327 ASTTypeWriter::VisitTemplateSpecializationType(
328 const TemplateSpecializationType *T) {
329 Record.push_back(T->isDependentType());
330 Writer.AddTemplateName(T->getTemplateName(), Record);
331 Record.push_back(T->getNumArgs());
332 for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end();
333 ArgI != ArgE; ++ArgI)
334 Writer.AddTemplateArgument(*ArgI, Record);
335 Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() :
336 T->isCanonicalUnqualified() ? QualType()
337 : T->getCanonicalTypeInternal(),
339 Code = TYPE_TEMPLATE_SPECIALIZATION;
343 ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
345 Writer.AddStmt(T->getSizeExpr());
346 Writer.AddSourceRange(T->getBracketsRange(), Record);
347 Code = TYPE_DEPENDENT_SIZED_ARRAY;
351 ASTTypeWriter::VisitDependentSizedExtVectorType(
352 const DependentSizedExtVectorType *T) {
353 // FIXME: Serialize this type (C++ only)
354 llvm_unreachable("Cannot serialize dependent sized extended vector types");
358 ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
359 Record.push_back(T->getDepth());
360 Record.push_back(T->getIndex());
361 Record.push_back(T->isParameterPack());
362 Writer.AddDeclRef(T->getDecl(), Record);
363 Code = TYPE_TEMPLATE_TYPE_PARM;
367 ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
368 Record.push_back(T->getKeyword());
369 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
370 Writer.AddIdentifierRef(T->getIdentifier(), Record);
371 Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
372 : T->getCanonicalTypeInternal(),
374 Code = TYPE_DEPENDENT_NAME;
378 ASTTypeWriter::VisitDependentTemplateSpecializationType(
379 const DependentTemplateSpecializationType *T) {
380 Record.push_back(T->getKeyword());
381 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
382 Writer.AddIdentifierRef(T->getIdentifier(), Record);
383 Record.push_back(T->getNumArgs());
384 for (DependentTemplateSpecializationType::iterator
385 I = T->begin(), E = T->end(); I != E; ++I)
386 Writer.AddTemplateArgument(*I, Record);
387 Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION;
390 void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
391 Writer.AddTypeRef(T->getPattern(), Record);
392 if (Optional<unsigned> NumExpansions = T->getNumExpansions())
393 Record.push_back(*NumExpansions + 1);
396 Code = TYPE_PACK_EXPANSION;
399 void ASTTypeWriter::VisitParenType(const ParenType *T) {
400 Writer.AddTypeRef(T->getInnerType(), Record);
404 void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
405 Record.push_back(T->getKeyword());
406 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
407 Writer.AddTypeRef(T->getNamedType(), Record);
408 Code = TYPE_ELABORATED;
411 void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
412 Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
413 Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
414 Code = TYPE_INJECTED_CLASS_NAME;
417 void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
418 Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
419 Code = TYPE_OBJC_INTERFACE;
422 void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
423 Writer.AddTypeRef(T->getBaseType(), Record);
424 Record.push_back(T->getTypeArgsAsWritten().size());
425 for (auto TypeArg : T->getTypeArgsAsWritten())
426 Writer.AddTypeRef(TypeArg, Record);
427 Record.push_back(T->getNumProtocols());
428 for (const auto *I : T->quals())
429 Writer.AddDeclRef(I, Record);
430 Record.push_back(T->isKindOfTypeAsWritten());
431 Code = TYPE_OBJC_OBJECT;
435 ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
436 Writer.AddTypeRef(T->getPointeeType(), Record);
437 Code = TYPE_OBJC_OBJECT_POINTER;
441 ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
442 Writer.AddTypeRef(T->getValueType(), Record);
448 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
450 ASTWriter::RecordDataImpl &Record;
453 TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
454 : Writer(Writer), Record(Record) { }
456 #define ABSTRACT_TYPELOC(CLASS, PARENT)
457 #define TYPELOC(CLASS, PARENT) \
458 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
459 #include "clang/AST/TypeLocNodes.def"
461 void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
462 void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
467 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
470 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
471 Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
472 if (TL.needsExtraLocalData()) {
473 Record.push_back(TL.getWrittenTypeSpec());
474 Record.push_back(TL.getWrittenSignSpec());
475 Record.push_back(TL.getWrittenWidthSpec());
476 Record.push_back(TL.hasModeAttr());
479 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
480 Writer.AddSourceLocation(TL.getNameLoc(), Record);
482 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
483 Writer.AddSourceLocation(TL.getStarLoc(), Record);
485 void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
488 void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
491 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
492 Writer.AddSourceLocation(TL.getCaretLoc(), Record);
494 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
495 Writer.AddSourceLocation(TL.getAmpLoc(), Record);
497 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
498 Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record);
500 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
501 Writer.AddSourceLocation(TL.getStarLoc(), Record);
502 Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record);
504 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
505 Writer.AddSourceLocation(TL.getLBracketLoc(), Record);
506 Writer.AddSourceLocation(TL.getRBracketLoc(), Record);
507 Record.push_back(TL.getSizeExpr() ? 1 : 0);
508 if (TL.getSizeExpr())
509 Writer.AddStmt(TL.getSizeExpr());
511 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
512 VisitArrayTypeLoc(TL);
514 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
515 VisitArrayTypeLoc(TL);
517 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
518 VisitArrayTypeLoc(TL);
520 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
521 DependentSizedArrayTypeLoc TL) {
522 VisitArrayTypeLoc(TL);
524 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
525 DependentSizedExtVectorTypeLoc TL) {
526 Writer.AddSourceLocation(TL.getNameLoc(), Record);
528 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
529 Writer.AddSourceLocation(TL.getNameLoc(), Record);
531 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
532 Writer.AddSourceLocation(TL.getNameLoc(), Record);
534 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
535 Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
536 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
537 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
538 Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record);
539 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
540 Writer.AddDeclRef(TL.getParam(i), Record);
542 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
543 VisitFunctionTypeLoc(TL);
545 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
546 VisitFunctionTypeLoc(TL);
548 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
549 Writer.AddSourceLocation(TL.getNameLoc(), Record);
551 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
552 Writer.AddSourceLocation(TL.getNameLoc(), Record);
554 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
555 Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
556 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
557 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
559 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
560 Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
561 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
562 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
563 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
565 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
566 Writer.AddSourceLocation(TL.getNameLoc(), Record);
568 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
569 Writer.AddSourceLocation(TL.getKWLoc(), Record);
570 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
571 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
572 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
574 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
575 Writer.AddSourceLocation(TL.getNameLoc(), Record);
577 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
578 Writer.AddSourceLocation(TL.getNameLoc(), Record);
580 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
581 Writer.AddSourceLocation(TL.getNameLoc(), Record);
583 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
584 Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
585 if (TL.hasAttrOperand()) {
586 SourceRange range = TL.getAttrOperandParensRange();
587 Writer.AddSourceLocation(range.getBegin(), Record);
588 Writer.AddSourceLocation(range.getEnd(), Record);
590 if (TL.hasAttrExprOperand()) {
591 Expr *operand = TL.getAttrExprOperand();
592 Record.push_back(operand ? 1 : 0);
593 if (operand) Writer.AddStmt(operand);
594 } else if (TL.hasAttrEnumOperand()) {
595 Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record);
598 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
599 Writer.AddSourceLocation(TL.getNameLoc(), Record);
601 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
602 SubstTemplateTypeParmTypeLoc TL) {
603 Writer.AddSourceLocation(TL.getNameLoc(), Record);
605 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
606 SubstTemplateTypeParmPackTypeLoc TL) {
607 Writer.AddSourceLocation(TL.getNameLoc(), Record);
609 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
610 TemplateSpecializationTypeLoc TL) {
611 Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
612 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
613 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
614 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
615 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
616 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
617 TL.getArgLoc(i).getLocInfo(), Record);
619 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
620 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
621 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
623 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
624 Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
625 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
627 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
628 Writer.AddSourceLocation(TL.getNameLoc(), Record);
630 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
631 Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
632 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
633 Writer.AddSourceLocation(TL.getNameLoc(), Record);
635 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
636 DependentTemplateSpecializationTypeLoc TL) {
637 Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
638 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
639 Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
640 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
641 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
642 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
643 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
644 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
645 TL.getArgLoc(I).getLocInfo(), Record);
647 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
648 Writer.AddSourceLocation(TL.getEllipsisLoc(), Record);
650 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
651 Writer.AddSourceLocation(TL.getNameLoc(), Record);
653 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
654 Record.push_back(TL.hasBaseTypeAsWritten());
655 Writer.AddSourceLocation(TL.getTypeArgsLAngleLoc(), Record);
656 Writer.AddSourceLocation(TL.getTypeArgsRAngleLoc(), Record);
657 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
658 Writer.AddTypeSourceInfo(TL.getTypeArgTInfo(i), Record);
659 Writer.AddSourceLocation(TL.getProtocolLAngleLoc(), Record);
660 Writer.AddSourceLocation(TL.getProtocolRAngleLoc(), Record);
661 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
662 Writer.AddSourceLocation(TL.getProtocolLoc(i), Record);
664 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
665 Writer.AddSourceLocation(TL.getStarLoc(), Record);
667 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
668 Writer.AddSourceLocation(TL.getKWLoc(), Record);
669 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
670 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
673 void ASTWriter::WriteTypeAbbrevs() {
674 using namespace llvm;
678 // Abbreviation for TYPE_EXT_QUAL
679 Abv = new BitCodeAbbrev();
680 Abv->Add(BitCodeAbbrevOp(serialization::TYPE_EXT_QUAL));
681 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
682 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Quals
683 TypeExtQualAbbrev = Stream.EmitAbbrev(Abv);
685 // Abbreviation for TYPE_FUNCTION_PROTO
686 Abv = new BitCodeAbbrev();
687 Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO));
689 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ReturnType
690 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn
691 Abv->Add(BitCodeAbbrevOp(0)); // HasRegParm
692 Abv->Add(BitCodeAbbrevOp(0)); // RegParm
693 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC
694 Abv->Add(BitCodeAbbrevOp(0)); // ProducesResult
696 Abv->Add(BitCodeAbbrevOp(0)); // IsVariadic
697 Abv->Add(BitCodeAbbrevOp(0)); // HasTrailingReturn
698 Abv->Add(BitCodeAbbrevOp(0)); // TypeQuals
699 Abv->Add(BitCodeAbbrevOp(0)); // RefQualifier
700 Abv->Add(BitCodeAbbrevOp(EST_None)); // ExceptionSpec
701 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumParams
702 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
703 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Params
704 TypeFunctionProtoAbbrev = Stream.EmitAbbrev(Abv);
707 //===----------------------------------------------------------------------===//
708 // ASTWriter Implementation
709 //===----------------------------------------------------------------------===//
711 static void EmitBlockID(unsigned ID, const char *Name,
712 llvm::BitstreamWriter &Stream,
713 ASTWriter::RecordDataImpl &Record) {
715 Record.push_back(ID);
716 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
718 // Emit the block name if present.
719 if (!Name || Name[0] == 0)
723 Record.push_back(*Name++);
724 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
727 static void EmitRecordID(unsigned ID, const char *Name,
728 llvm::BitstreamWriter &Stream,
729 ASTWriter::RecordDataImpl &Record) {
731 Record.push_back(ID);
733 Record.push_back(*Name++);
734 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
737 static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
738 ASTWriter::RecordDataImpl &Record) {
739 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
741 RECORD(STMT_NULL_PTR);
742 RECORD(STMT_REF_PTR);
744 RECORD(STMT_COMPOUND);
746 RECORD(STMT_DEFAULT);
748 RECORD(STMT_ATTRIBUTED);
755 RECORD(STMT_INDIRECT_GOTO);
756 RECORD(STMT_CONTINUE);
762 RECORD(EXPR_PREDEFINED);
763 RECORD(EXPR_DECL_REF);
764 RECORD(EXPR_INTEGER_LITERAL);
765 RECORD(EXPR_FLOATING_LITERAL);
766 RECORD(EXPR_IMAGINARY_LITERAL);
767 RECORD(EXPR_STRING_LITERAL);
768 RECORD(EXPR_CHARACTER_LITERAL);
770 RECORD(EXPR_PAREN_LIST);
771 RECORD(EXPR_UNARY_OPERATOR);
772 RECORD(EXPR_SIZEOF_ALIGN_OF);
773 RECORD(EXPR_ARRAY_SUBSCRIPT);
776 RECORD(EXPR_BINARY_OPERATOR);
777 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
778 RECORD(EXPR_CONDITIONAL_OPERATOR);
779 RECORD(EXPR_IMPLICIT_CAST);
780 RECORD(EXPR_CSTYLE_CAST);
781 RECORD(EXPR_COMPOUND_LITERAL);
782 RECORD(EXPR_EXT_VECTOR_ELEMENT);
783 RECORD(EXPR_INIT_LIST);
784 RECORD(EXPR_DESIGNATED_INIT);
785 RECORD(EXPR_DESIGNATED_INIT_UPDATE);
786 RECORD(EXPR_IMPLICIT_VALUE_INIT);
787 RECORD(EXPR_NO_INIT);
789 RECORD(EXPR_ADDR_LABEL);
792 RECORD(EXPR_GNU_NULL);
793 RECORD(EXPR_SHUFFLE_VECTOR);
795 RECORD(EXPR_GENERIC_SELECTION);
796 RECORD(EXPR_OBJC_STRING_LITERAL);
797 RECORD(EXPR_OBJC_BOXED_EXPRESSION);
798 RECORD(EXPR_OBJC_ARRAY_LITERAL);
799 RECORD(EXPR_OBJC_DICTIONARY_LITERAL);
800 RECORD(EXPR_OBJC_ENCODE);
801 RECORD(EXPR_OBJC_SELECTOR_EXPR);
802 RECORD(EXPR_OBJC_PROTOCOL_EXPR);
803 RECORD(EXPR_OBJC_IVAR_REF_EXPR);
804 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR);
805 RECORD(EXPR_OBJC_KVC_REF_EXPR);
806 RECORD(EXPR_OBJC_MESSAGE_EXPR);
807 RECORD(STMT_OBJC_FOR_COLLECTION);
808 RECORD(STMT_OBJC_CATCH);
809 RECORD(STMT_OBJC_FINALLY);
810 RECORD(STMT_OBJC_AT_TRY);
811 RECORD(STMT_OBJC_AT_SYNCHRONIZED);
812 RECORD(STMT_OBJC_AT_THROW);
813 RECORD(EXPR_OBJC_BOOL_LITERAL);
814 RECORD(STMT_CXX_CATCH);
815 RECORD(STMT_CXX_TRY);
816 RECORD(STMT_CXX_FOR_RANGE);
817 RECORD(EXPR_CXX_OPERATOR_CALL);
818 RECORD(EXPR_CXX_MEMBER_CALL);
819 RECORD(EXPR_CXX_CONSTRUCT);
820 RECORD(EXPR_CXX_TEMPORARY_OBJECT);
821 RECORD(EXPR_CXX_STATIC_CAST);
822 RECORD(EXPR_CXX_DYNAMIC_CAST);
823 RECORD(EXPR_CXX_REINTERPRET_CAST);
824 RECORD(EXPR_CXX_CONST_CAST);
825 RECORD(EXPR_CXX_FUNCTIONAL_CAST);
826 RECORD(EXPR_USER_DEFINED_LITERAL);
827 RECORD(EXPR_CXX_STD_INITIALIZER_LIST);
828 RECORD(EXPR_CXX_BOOL_LITERAL);
829 RECORD(EXPR_CXX_NULL_PTR_LITERAL);
830 RECORD(EXPR_CXX_TYPEID_EXPR);
831 RECORD(EXPR_CXX_TYPEID_TYPE);
832 RECORD(EXPR_CXX_THIS);
833 RECORD(EXPR_CXX_THROW);
834 RECORD(EXPR_CXX_DEFAULT_ARG);
835 RECORD(EXPR_CXX_DEFAULT_INIT);
836 RECORD(EXPR_CXX_BIND_TEMPORARY);
837 RECORD(EXPR_CXX_SCALAR_VALUE_INIT);
838 RECORD(EXPR_CXX_NEW);
839 RECORD(EXPR_CXX_DELETE);
840 RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR);
841 RECORD(EXPR_EXPR_WITH_CLEANUPS);
842 RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER);
843 RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF);
844 RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT);
845 RECORD(EXPR_CXX_UNRESOLVED_MEMBER);
846 RECORD(EXPR_CXX_UNRESOLVED_LOOKUP);
847 RECORD(EXPR_CXX_EXPRESSION_TRAIT);
848 RECORD(EXPR_CXX_NOEXCEPT);
849 RECORD(EXPR_OPAQUE_VALUE);
850 RECORD(EXPR_BINARY_CONDITIONAL_OPERATOR);
851 RECORD(EXPR_TYPE_TRAIT);
852 RECORD(EXPR_ARRAY_TYPE_TRAIT);
853 RECORD(EXPR_PACK_EXPANSION);
854 RECORD(EXPR_SIZEOF_PACK);
855 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM);
856 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK);
857 RECORD(EXPR_FUNCTION_PARM_PACK);
858 RECORD(EXPR_MATERIALIZE_TEMPORARY);
859 RECORD(EXPR_CUDA_KERNEL_CALL);
860 RECORD(EXPR_CXX_UUIDOF_EXPR);
861 RECORD(EXPR_CXX_UUIDOF_TYPE);
866 void ASTWriter::WriteBlockInfoBlock() {
868 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3);
870 #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
871 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
874 BLOCK(CONTROL_BLOCK);
878 RECORD(MODULE_MAP_FILE);
880 RECORD(KNOWN_MODULE_FILES);
881 RECORD(LANGUAGE_OPTIONS);
882 RECORD(TARGET_OPTIONS);
883 RECORD(ORIGINAL_FILE);
884 RECORD(ORIGINAL_PCH_DIR);
885 RECORD(ORIGINAL_FILE_ID);
886 RECORD(INPUT_FILE_OFFSETS);
887 RECORD(DIAGNOSTIC_OPTIONS);
888 RECORD(FILE_SYSTEM_OPTIONS);
889 RECORD(HEADER_SEARCH_OPTIONS);
890 RECORD(PREPROCESSOR_OPTIONS);
892 BLOCK(INPUT_FILES_BLOCK);
895 // AST Top-Level Block.
899 RECORD(IDENTIFIER_OFFSET);
900 RECORD(IDENTIFIER_TABLE);
901 RECORD(EAGERLY_DESERIALIZED_DECLS);
902 RECORD(SPECIAL_TYPES);
904 RECORD(TENTATIVE_DEFINITIONS);
905 RECORD(UNUSED_FILESCOPED_DECLS);
906 RECORD(SELECTOR_OFFSETS);
908 RECORD(PP_COUNTER_VALUE);
909 RECORD(SOURCE_LOCATION_OFFSETS);
910 RECORD(SOURCE_LOCATION_PRELOADS);
911 RECORD(EXT_VECTOR_DECLS);
912 RECORD(PPD_ENTITIES_OFFSETS);
913 RECORD(REFERENCED_SELECTOR_POOL);
914 RECORD(TU_UPDATE_LEXICAL);
915 RECORD(LOCAL_REDECLARATIONS_MAP);
916 RECORD(SEMA_DECL_REFS);
917 RECORD(WEAK_UNDECLARED_IDENTIFIERS);
918 RECORD(PENDING_IMPLICIT_INSTANTIATIONS);
919 RECORD(DECL_REPLACEMENTS);
920 RECORD(UPDATE_VISIBLE);
921 RECORD(DECL_UPDATE_OFFSETS);
922 RECORD(DECL_UPDATES);
923 RECORD(CXX_BASE_SPECIFIER_OFFSETS);
924 RECORD(DIAG_PRAGMA_MAPPINGS);
925 RECORD(CUDA_SPECIAL_DECL_REFS);
926 RECORD(HEADER_SEARCH_TABLE);
927 RECORD(FP_PRAGMA_OPTIONS);
928 RECORD(OPENCL_EXTENSIONS);
929 RECORD(DELEGATING_CTORS);
930 RECORD(KNOWN_NAMESPACES);
931 RECORD(UNDEFINED_BUT_USED);
932 RECORD(MODULE_OFFSET_MAP);
933 RECORD(SOURCE_MANAGER_LINE_TABLE);
934 RECORD(OBJC_CATEGORIES_MAP);
935 RECORD(FILE_SORTED_DECLS);
936 RECORD(IMPORTED_MODULES);
937 RECORD(LOCAL_REDECLARATIONS);
938 RECORD(OBJC_CATEGORIES);
939 RECORD(MACRO_OFFSET);
940 RECORD(LATE_PARSED_TEMPLATE);
941 RECORD(OPTIMIZE_PRAGMA_OPTIONS);
943 // SourceManager Block.
944 BLOCK(SOURCE_MANAGER_BLOCK);
945 RECORD(SM_SLOC_FILE_ENTRY);
946 RECORD(SM_SLOC_BUFFER_ENTRY);
947 RECORD(SM_SLOC_BUFFER_BLOB);
948 RECORD(SM_SLOC_EXPANSION_ENTRY);
950 // Preprocessor Block.
951 BLOCK(PREPROCESSOR_BLOCK);
952 RECORD(PP_MACRO_DIRECTIVE_HISTORY);
953 RECORD(PP_MACRO_FUNCTION_LIKE);
954 RECORD(PP_MACRO_OBJECT_LIKE);
955 RECORD(PP_MODULE_MACRO);
958 // Decls and Types block.
959 BLOCK(DECLTYPES_BLOCK);
960 RECORD(TYPE_EXT_QUAL);
961 RECORD(TYPE_COMPLEX);
962 RECORD(TYPE_POINTER);
963 RECORD(TYPE_BLOCK_POINTER);
964 RECORD(TYPE_LVALUE_REFERENCE);
965 RECORD(TYPE_RVALUE_REFERENCE);
966 RECORD(TYPE_MEMBER_POINTER);
967 RECORD(TYPE_CONSTANT_ARRAY);
968 RECORD(TYPE_INCOMPLETE_ARRAY);
969 RECORD(TYPE_VARIABLE_ARRAY);
971 RECORD(TYPE_EXT_VECTOR);
972 RECORD(TYPE_FUNCTION_NO_PROTO);
973 RECORD(TYPE_FUNCTION_PROTO);
974 RECORD(TYPE_TYPEDEF);
975 RECORD(TYPE_TYPEOF_EXPR);
979 RECORD(TYPE_OBJC_INTERFACE);
980 RECORD(TYPE_OBJC_OBJECT_POINTER);
981 RECORD(TYPE_DECLTYPE);
982 RECORD(TYPE_ELABORATED);
983 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
984 RECORD(TYPE_UNRESOLVED_USING);
985 RECORD(TYPE_INJECTED_CLASS_NAME);
986 RECORD(TYPE_OBJC_OBJECT);
987 RECORD(TYPE_TEMPLATE_TYPE_PARM);
988 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
989 RECORD(TYPE_DEPENDENT_NAME);
990 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
991 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
993 RECORD(TYPE_PACK_EXPANSION);
994 RECORD(TYPE_ATTRIBUTED);
995 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
997 RECORD(TYPE_UNARY_TRANSFORM);
999 RECORD(TYPE_DECAYED);
1000 RECORD(TYPE_ADJUSTED);
1001 RECORD(DECL_TYPEDEF);
1002 RECORD(DECL_TYPEALIAS);
1004 RECORD(DECL_RECORD);
1005 RECORD(DECL_ENUM_CONSTANT);
1006 RECORD(DECL_FUNCTION);
1007 RECORD(DECL_OBJC_METHOD);
1008 RECORD(DECL_OBJC_INTERFACE);
1009 RECORD(DECL_OBJC_PROTOCOL);
1010 RECORD(DECL_OBJC_IVAR);
1011 RECORD(DECL_OBJC_AT_DEFS_FIELD);
1012 RECORD(DECL_OBJC_CATEGORY);
1013 RECORD(DECL_OBJC_CATEGORY_IMPL);
1014 RECORD(DECL_OBJC_IMPLEMENTATION);
1015 RECORD(DECL_OBJC_COMPATIBLE_ALIAS);
1016 RECORD(DECL_OBJC_PROPERTY);
1017 RECORD(DECL_OBJC_PROPERTY_IMPL);
1019 RECORD(DECL_MS_PROPERTY);
1021 RECORD(DECL_IMPLICIT_PARAM);
1022 RECORD(DECL_PARM_VAR);
1023 RECORD(DECL_FILE_SCOPE_ASM);
1025 RECORD(DECL_CONTEXT_LEXICAL);
1026 RECORD(DECL_CONTEXT_VISIBLE);
1027 RECORD(DECL_NAMESPACE);
1028 RECORD(DECL_NAMESPACE_ALIAS);
1030 RECORD(DECL_USING_SHADOW);
1031 RECORD(DECL_USING_DIRECTIVE);
1032 RECORD(DECL_UNRESOLVED_USING_VALUE);
1033 RECORD(DECL_UNRESOLVED_USING_TYPENAME);
1034 RECORD(DECL_LINKAGE_SPEC);
1035 RECORD(DECL_CXX_RECORD);
1036 RECORD(DECL_CXX_METHOD);
1037 RECORD(DECL_CXX_CONSTRUCTOR);
1038 RECORD(DECL_CXX_DESTRUCTOR);
1039 RECORD(DECL_CXX_CONVERSION);
1040 RECORD(DECL_ACCESS_SPEC);
1041 RECORD(DECL_FRIEND);
1042 RECORD(DECL_FRIEND_TEMPLATE);
1043 RECORD(DECL_CLASS_TEMPLATE);
1044 RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
1045 RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
1046 RECORD(DECL_VAR_TEMPLATE);
1047 RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION);
1048 RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION);
1049 RECORD(DECL_FUNCTION_TEMPLATE);
1050 RECORD(DECL_TEMPLATE_TYPE_PARM);
1051 RECORD(DECL_NON_TYPE_TEMPLATE_PARM);
1052 RECORD(DECL_TEMPLATE_TEMPLATE_PARM);
1053 RECORD(DECL_STATIC_ASSERT);
1054 RECORD(DECL_CXX_BASE_SPECIFIERS);
1055 RECORD(DECL_INDIRECTFIELD);
1056 RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK);
1058 // Statements and Exprs can occur in the Decls and Types block.
1059 AddStmtsExprs(Stream, Record);
1061 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
1062 RECORD(PPD_MACRO_EXPANSION);
1063 RECORD(PPD_MACRO_DEFINITION);
1064 RECORD(PPD_INCLUSION_DIRECTIVE);
1071 /// \brief Prepares a path for being written to an AST file by converting it
1072 /// to an absolute path and removing nested './'s.
1074 /// \return \c true if the path was changed.
1075 static bool cleanPathForOutput(FileManager &FileMgr,
1076 SmallVectorImpl<char> &Path) {
1077 bool Changed = false;
1079 if (!llvm::sys::path::is_absolute(StringRef(Path.data(), Path.size()))) {
1080 llvm::sys::fs::make_absolute(Path);
1084 return Changed | FileMgr.removeDotPaths(Path);
1087 /// \brief Adjusts the given filename to only write out the portion of the
1088 /// filename that is not part of the system root directory.
1090 /// \param Filename the file name to adjust.
1092 /// \param BaseDir When non-NULL, the PCH file is a relocatable AST file and
1093 /// the returned filename will be adjusted by this root directory.
1095 /// \returns either the original filename (if it needs no adjustment) or the
1096 /// adjusted filename (which points into the @p Filename parameter).
1098 adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir) {
1099 assert(Filename && "No file name to adjust?");
1101 if (BaseDir.empty())
1104 // Verify that the filename and the system root have the same prefix.
1106 for (; Filename[Pos] && Pos < BaseDir.size(); ++Pos)
1107 if (Filename[Pos] != BaseDir[Pos])
1108 return Filename; // Prefixes don't match.
1110 // We hit the end of the filename before we hit the end of the system root.
1114 // If there's not a path separator at the end of the base directory nor
1115 // immediately after it, then this isn't within the base directory.
1116 if (!llvm::sys::path::is_separator(Filename[Pos])) {
1117 if (!llvm::sys::path::is_separator(BaseDir.back()))
1120 // If the file name has a '/' at the current position, skip over the '/'.
1121 // We distinguish relative paths from absolute paths by the
1122 // absence of '/' at the beginning of relative paths.
1124 // FIXME: This is wrong. We distinguish them by asking if the path is
1125 // absolute, which isn't the same thing. And there might be multiple '/'s
1126 // in a row. Use a better mechanism to indicate whether we have emitted an
1127 // absolute or relative path.
1131 return Filename + Pos;
1134 static ASTFileSignature getSignature() {
1136 if (ASTFileSignature S = llvm::sys::Process::GetRandomNumber())
1138 // Rely on GetRandomNumber to eventually return non-zero...
1142 /// \brief Write the control block.
1143 void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context,
1145 const std::string &OutputFile) {
1146 using namespace llvm;
1147 Stream.EnterSubblock(CONTROL_BLOCK_ID, 5);
1151 BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev();
1152 MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA));
1153 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major
1154 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor
1155 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj.
1156 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min.
1157 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
1158 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors
1159 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
1160 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev);
1161 Record.push_back(METADATA);
1162 Record.push_back(VERSION_MAJOR);
1163 Record.push_back(VERSION_MINOR);
1164 Record.push_back(CLANG_VERSION_MAJOR);
1165 Record.push_back(CLANG_VERSION_MINOR);
1166 assert((!WritingModule || isysroot.empty()) &&
1167 "writing module as a relocatable PCH?");
1168 Record.push_back(!isysroot.empty());
1169 Record.push_back(ASTHasCompilerErrors);
1170 Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record,
1171 getClangFullRepositoryVersion());
1173 if (WritingModule) {
1174 // For implicit modules we output a signature that we can use to ensure
1175 // duplicate module builds don't collide in the cache as their output order
1176 // is non-deterministic.
1177 // FIXME: Remove this when output is deterministic.
1178 if (Context.getLangOpts().ImplicitModules) {
1180 Record.push_back(getSignature());
1181 Stream.EmitRecord(SIGNATURE, Record);
1185 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1186 Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME));
1187 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1188 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1190 Record.push_back(MODULE_NAME);
1191 Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name);
1194 if (WritingModule && WritingModule->Directory) {
1195 // Module directory.
1196 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1197 Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY));
1198 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory
1199 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1201 Record.push_back(MODULE_DIRECTORY);
1203 SmallString<128> BaseDir(WritingModule->Directory->getName());
1204 cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir);
1205 Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir);
1207 // Write out all other paths relative to the base directory if possible.
1208 BaseDirectory.assign(BaseDir.begin(), BaseDir.end());
1209 } else if (!isysroot.empty()) {
1210 // Write out paths relative to the sysroot if possible.
1211 BaseDirectory = isysroot;
1215 if (WritingModule) {
1218 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
1220 // Primary module map file.
1221 AddPath(Map.getModuleMapFileForUniquing(WritingModule)->getName(), Record);
1223 // Additional module map files.
1224 if (auto *AdditionalModMaps =
1225 Map.getAdditionalModuleMapFiles(WritingModule)) {
1226 Record.push_back(AdditionalModMaps->size());
1227 for (const FileEntry *F : *AdditionalModMaps)
1228 AddPath(F->getName(), Record);
1230 Record.push_back(0);
1233 Stream.EmitRecord(MODULE_MAP_FILE, Record);
1238 serialization::ModuleManager &Mgr = Chain->getModuleManager();
1241 for (auto *M : Mgr) {
1242 // Skip modules that weren't directly imported.
1243 if (!M->isDirectlyImported())
1246 Record.push_back((unsigned)M->Kind); // FIXME: Stable encoding
1247 AddSourceLocation(M->ImportLoc, Record);
1248 Record.push_back(M->File->getSize());
1249 Record.push_back(M->File->getModificationTime());
1250 Record.push_back(M->Signature);
1251 AddPath(M->FileName, Record);
1253 Stream.EmitRecord(IMPORTS, Record);
1255 // Also emit a list of known module files that were not imported,
1256 // but are made available by this module.
1257 // FIXME: Should we also include a signature here?
1259 for (auto *E : Mgr.getAdditionalKnownModuleFiles())
1260 AddPath(E->getName(), Record);
1261 if (!Record.empty())
1262 Stream.EmitRecord(KNOWN_MODULE_FILES, Record);
1265 // Language options.
1267 const LangOptions &LangOpts = Context.getLangOpts();
1268 #define LANGOPT(Name, Bits, Default, Description) \
1269 Record.push_back(LangOpts.Name);
1270 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1271 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1272 #include "clang/Basic/LangOptions.def"
1273 #define SANITIZER(NAME, ID) \
1274 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID));
1275 #include "clang/Basic/Sanitizers.def"
1277 Record.push_back(LangOpts.ModuleFeatures.size());
1278 for (StringRef Feature : LangOpts.ModuleFeatures)
1279 AddString(Feature, Record);
1281 Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind());
1282 AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record);
1284 AddString(LangOpts.CurrentModule, Record);
1287 Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size());
1288 for (CommentOptions::BlockCommandNamesTy::const_iterator
1289 I = LangOpts.CommentOpts.BlockCommandNames.begin(),
1290 IEnd = LangOpts.CommentOpts.BlockCommandNames.end();
1292 AddString(*I, Record);
1294 Record.push_back(LangOpts.CommentOpts.ParseAllComments);
1296 Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
1300 const TargetInfo &Target = Context.getTargetInfo();
1301 const TargetOptions &TargetOpts = Target.getTargetOpts();
1302 AddString(TargetOpts.Triple, Record);
1303 AddString(TargetOpts.CPU, Record);
1304 AddString(TargetOpts.ABI, Record);
1305 Record.push_back(TargetOpts.FeaturesAsWritten.size());
1306 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) {
1307 AddString(TargetOpts.FeaturesAsWritten[I], Record);
1309 Record.push_back(TargetOpts.Features.size());
1310 for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) {
1311 AddString(TargetOpts.Features[I], Record);
1313 Stream.EmitRecord(TARGET_OPTIONS, Record);
1315 // Diagnostic options.
1317 const DiagnosticOptions &DiagOpts
1318 = Context.getDiagnostics().getDiagnosticOptions();
1319 #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
1320 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
1321 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
1322 #include "clang/Basic/DiagnosticOptions.def"
1323 Record.push_back(DiagOpts.Warnings.size());
1324 for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I)
1325 AddString(DiagOpts.Warnings[I], Record);
1326 Record.push_back(DiagOpts.Remarks.size());
1327 for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I)
1328 AddString(DiagOpts.Remarks[I], Record);
1329 // Note: we don't serialize the log or serialization file names, because they
1330 // are generally transient files and will almost always be overridden.
1331 Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record);
1333 // File system options.
1335 const FileSystemOptions &FSOpts
1336 = Context.getSourceManager().getFileManager().getFileSystemOptions();
1337 AddString(FSOpts.WorkingDir, Record);
1338 Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record);
1340 // Header search options.
1342 const HeaderSearchOptions &HSOpts
1343 = PP.getHeaderSearchInfo().getHeaderSearchOpts();
1344 AddString(HSOpts.Sysroot, Record);
1347 Record.push_back(HSOpts.UserEntries.size());
1348 for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
1349 const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I];
1350 AddString(Entry.Path, Record);
1351 Record.push_back(static_cast<unsigned>(Entry.Group));
1352 Record.push_back(Entry.IsFramework);
1353 Record.push_back(Entry.IgnoreSysRoot);
1356 // System header prefixes.
1357 Record.push_back(HSOpts.SystemHeaderPrefixes.size());
1358 for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
1359 AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record);
1360 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
1363 AddString(HSOpts.ResourceDir, Record);
1364 AddString(HSOpts.ModuleCachePath, Record);
1365 AddString(HSOpts.ModuleUserBuildPath, Record);
1366 Record.push_back(HSOpts.DisableModuleHash);
1367 Record.push_back(HSOpts.UseBuiltinIncludes);
1368 Record.push_back(HSOpts.UseStandardSystemIncludes);
1369 Record.push_back(HSOpts.UseStandardCXXIncludes);
1370 Record.push_back(HSOpts.UseLibcxx);
1371 // Write out the specific module cache path that contains the module files.
1372 AddString(PP.getHeaderSearchInfo().getModuleCachePath(), Record);
1373 Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record);
1375 // Preprocessor options.
1377 const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts();
1379 // Macro definitions.
1380 Record.push_back(PPOpts.Macros.size());
1381 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
1382 AddString(PPOpts.Macros[I].first, Record);
1383 Record.push_back(PPOpts.Macros[I].second);
1387 Record.push_back(PPOpts.Includes.size());
1388 for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I)
1389 AddString(PPOpts.Includes[I], Record);
1392 Record.push_back(PPOpts.MacroIncludes.size());
1393 for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I)
1394 AddString(PPOpts.MacroIncludes[I], Record);
1396 Record.push_back(PPOpts.UsePredefines);
1397 // Detailed record is important since it is used for the module cache hash.
1398 Record.push_back(PPOpts.DetailedRecord);
1399 AddString(PPOpts.ImplicitPCHInclude, Record);
1400 AddString(PPOpts.ImplicitPTHInclude, Record);
1401 Record.push_back(static_cast<unsigned>(PPOpts.ObjCXXARCStandardLibrary));
1402 Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record);
1404 // Original file name and file ID
1405 SourceManager &SM = Context.getSourceManager();
1406 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1407 BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev();
1408 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE));
1409 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID
1410 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1411 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev);
1414 Record.push_back(ORIGINAL_FILE);
1415 Record.push_back(SM.getMainFileID().getOpaqueValue());
1416 EmitRecordWithPath(FileAbbrevCode, Record, MainFile->getName());
1420 Record.push_back(SM.getMainFileID().getOpaqueValue());
1421 Stream.EmitRecord(ORIGINAL_FILE_ID, Record);
1423 // Original PCH directory
1424 if (!OutputFile.empty() && OutputFile != "-") {
1425 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1426 Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
1427 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1428 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1430 SmallString<128> OutputPath(OutputFile);
1432 llvm::sys::fs::make_absolute(OutputPath);
1433 StringRef origDir = llvm::sys::path::parent_path(OutputPath);
1436 Record.push_back(ORIGINAL_PCH_DIR);
1437 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
1440 WriteInputFiles(Context.SourceMgr,
1441 PP.getHeaderSearchInfo().getHeaderSearchOpts(),
1442 PP.getLangOpts().Modules);
1447 /// \brief An input file.
1448 struct InputFileEntry {
1449 const FileEntry *File;
1451 bool BufferOverridden;
1455 void ASTWriter::WriteInputFiles(SourceManager &SourceMgr,
1456 HeaderSearchOptions &HSOpts,
1458 using namespace llvm;
1459 Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4);
1462 // Create input-file abbreviation.
1463 BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev();
1464 IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE));
1465 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
1466 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
1467 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
1468 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden
1469 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1470 unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev);
1472 // Get all ContentCache objects for files, sorted by whether the file is a
1473 // system one or not. System files go at the back, users files at the front.
1474 std::deque<InputFileEntry> SortedFiles;
1475 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
1476 // Get this source location entry.
1477 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
1478 assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc);
1480 // We only care about file entries that were not overridden.
1481 if (!SLoc->isFile())
1483 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
1484 if (!Cache->OrigEntry)
1487 InputFileEntry Entry;
1488 Entry.File = Cache->OrigEntry;
1489 Entry.IsSystemFile = Cache->IsSystemFile;
1490 Entry.BufferOverridden = Cache->BufferOverridden;
1491 if (Cache->IsSystemFile)
1492 SortedFiles.push_back(Entry);
1494 SortedFiles.push_front(Entry);
1497 unsigned UserFilesNum = 0;
1498 // Write out all of the input files.
1499 std::vector<uint64_t> InputFileOffsets;
1500 for (std::deque<InputFileEntry>::iterator
1501 I = SortedFiles.begin(), E = SortedFiles.end(); I != E; ++I) {
1502 const InputFileEntry &Entry = *I;
1504 uint32_t &InputFileID = InputFileIDs[Entry.File];
1505 if (InputFileID != 0)
1506 continue; // already recorded this file.
1508 // Record this entry's offset.
1509 InputFileOffsets.push_back(Stream.GetCurrentBitNo());
1511 InputFileID = InputFileOffsets.size();
1513 if (!Entry.IsSystemFile)
1517 Record.push_back(INPUT_FILE);
1518 Record.push_back(InputFileOffsets.size());
1520 // Emit size/modification time for this file.
1521 Record.push_back(Entry.File->getSize());
1522 Record.push_back(Entry.File->getModificationTime());
1524 // Whether this file was overridden.
1525 Record.push_back(Entry.BufferOverridden);
1527 EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName());
1532 // Create input file offsets abbreviation.
1533 BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev();
1534 OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS));
1535 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files
1536 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system
1538 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array
1539 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev);
1541 // Write input file offsets.
1543 Record.push_back(INPUT_FILE_OFFSETS);
1544 Record.push_back(InputFileOffsets.size());
1545 Record.push_back(UserFilesNum);
1546 Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, bytes(InputFileOffsets));
1549 //===----------------------------------------------------------------------===//
1550 // Source Manager Serialization
1551 //===----------------------------------------------------------------------===//
1553 /// \brief Create an abbreviation for the SLocEntry that refers to a
1555 static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
1556 using namespace llvm;
1557 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1558 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
1559 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1560 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1561 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1562 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1563 // FileEntry fields.
1564 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID
1565 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
1566 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex
1567 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls
1568 return Stream.EmitAbbrev(Abbrev);
1571 /// \brief Create an abbreviation for the SLocEntry that refers to a
1573 static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
1574 using namespace llvm;
1575 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1576 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
1577 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1578 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1579 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1580 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1581 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
1582 return Stream.EmitAbbrev(Abbrev);
1585 /// \brief Create an abbreviation for the SLocEntry that refers to a
1587 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
1588 using namespace llvm;
1589 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1590 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB));
1591 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
1592 return Stream.EmitAbbrev(Abbrev);
1595 /// \brief Create an abbreviation for the SLocEntry that refers to a macro
1597 static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
1598 using namespace llvm;
1599 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1600 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
1601 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1602 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
1603 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
1604 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
1605 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
1606 return Stream.EmitAbbrev(Abbrev);
1610 // Trait used for the on-disk hash table of header search information.
1611 class HeaderFileInfoTrait {
1613 const HeaderSearch &HS;
1615 // Keep track of the framework names we've used during serialization.
1616 SmallVector<char, 128> FrameworkStringData;
1617 llvm::StringMap<unsigned> FrameworkNameOffset;
1620 HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS)
1621 : Writer(Writer), HS(HS) { }
1624 const FileEntry *FE;
1625 const char *Filename;
1627 typedef const key_type &key_type_ref;
1629 typedef HeaderFileInfo data_type;
1630 typedef const data_type &data_type_ref;
1631 typedef unsigned hash_value_type;
1632 typedef unsigned offset_type;
1634 static hash_value_type ComputeHash(key_type_ref key) {
1635 // The hash is based only on size/time of the file, so that the reader can
1636 // match even when symlinking or excess path elements ("foo/../", "../")
1637 // change the form of the name. However, complete path is still the key.
1639 // FIXME: Using the mtime here will cause problems for explicit module
1641 return llvm::hash_combine(key.FE->getSize(),
1642 key.FE->getModificationTime());
1645 std::pair<unsigned,unsigned>
1646 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
1647 using namespace llvm::support;
1648 endian::Writer<little> Writer(Out);
1649 unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8;
1650 Writer.write<uint16_t>(KeyLen);
1651 unsigned DataLen = 1 + 2 + 4 + 4;
1652 if (Data.isModuleHeader)
1654 Writer.write<uint8_t>(DataLen);
1655 return std::make_pair(KeyLen, DataLen);
1658 void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
1659 using namespace llvm::support;
1660 endian::Writer<little> LE(Out);
1661 LE.write<uint64_t>(key.FE->getSize());
1663 LE.write<uint64_t>(key.FE->getModificationTime());
1665 Out.write(key.Filename, KeyLen);
1668 void EmitData(raw_ostream &Out, key_type_ref key,
1669 data_type_ref Data, unsigned DataLen) {
1670 using namespace llvm::support;
1671 endian::Writer<little> LE(Out);
1672 uint64_t Start = Out.tell(); (void)Start;
1674 unsigned char Flags = (Data.HeaderRole << 6)
1675 | (Data.isImport << 5)
1676 | (Data.isPragmaOnce << 4)
1677 | (Data.DirInfo << 2)
1678 | (Data.Resolved << 1)
1679 | Data.IndexHeaderMapHeader;
1680 LE.write<uint8_t>(Flags);
1681 LE.write<uint16_t>(Data.NumIncludes);
1683 if (!Data.ControllingMacro)
1684 LE.write<uint32_t>(Data.ControllingMacroID);
1686 LE.write<uint32_t>(Writer.getIdentifierRef(Data.ControllingMacro));
1688 unsigned Offset = 0;
1689 if (!Data.Framework.empty()) {
1690 // If this header refers into a framework, save the framework name.
1691 llvm::StringMap<unsigned>::iterator Pos
1692 = FrameworkNameOffset.find(Data.Framework);
1693 if (Pos == FrameworkNameOffset.end()) {
1694 Offset = FrameworkStringData.size() + 1;
1695 FrameworkStringData.append(Data.Framework.begin(),
1696 Data.Framework.end());
1697 FrameworkStringData.push_back(0);
1699 FrameworkNameOffset[Data.Framework] = Offset;
1701 Offset = Pos->second;
1703 LE.write<uint32_t>(Offset);
1705 if (Data.isModuleHeader) {
1706 Module *Mod = HS.findModuleForHeader(key.FE).getModule();
1707 LE.write<uint32_t>(Writer.getExistingSubmoduleID(Mod));
1710 assert(Out.tell() - Start == DataLen && "Wrong data length");
1713 const char *strings_begin() const { return FrameworkStringData.begin(); }
1714 const char *strings_end() const { return FrameworkStringData.end(); }
1716 } // end anonymous namespace
1718 /// \brief Write the header search block for the list of files that
1720 /// \param HS The header search structure to save.
1721 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) {
1722 SmallVector<const FileEntry *, 16> FilesByUID;
1723 HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
1725 if (FilesByUID.size() > HS.header_file_size())
1726 FilesByUID.resize(HS.header_file_size());
1728 HeaderFileInfoTrait GeneratorTrait(*this, HS);
1729 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
1730 SmallVector<const char *, 4> SavedStrings;
1731 unsigned NumHeaderSearchEntries = 0;
1732 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
1733 const FileEntry *File = FilesByUID[UID];
1737 // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo
1738 // from the external source if it was not provided already.
1740 if (!HS.tryGetFileInfo(File, HFI) ||
1741 (HFI.External && Chain) ||
1742 (HFI.isModuleHeader && !HFI.isCompilingModuleHeader))
1745 // Massage the file path into an appropriate form.
1746 const char *Filename = File->getName();
1747 SmallString<128> FilenameTmp(Filename);
1748 if (PreparePathForOutput(FilenameTmp)) {
1749 // If we performed any translation on the file name at all, we need to
1750 // save this string, since the generator will refer to it later.
1751 Filename = strdup(FilenameTmp.c_str());
1752 SavedStrings.push_back(Filename);
1755 HeaderFileInfoTrait::key_type key = { File, Filename };
1756 Generator.insert(key, HFI, GeneratorTrait);
1757 ++NumHeaderSearchEntries;
1760 // Create the on-disk hash table in a buffer.
1761 SmallString<4096> TableData;
1762 uint32_t BucketOffset;
1764 using namespace llvm::support;
1765 llvm::raw_svector_ostream Out(TableData);
1766 // Make sure that no bucket is at offset 0
1767 endian::Writer<little>(Out).write<uint32_t>(0);
1768 BucketOffset = Generator.Emit(Out, GeneratorTrait);
1771 // Create a blob abbreviation
1772 using namespace llvm;
1773 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1774 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
1775 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1776 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1777 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1778 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1779 unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev);
1781 // Write the header search table
1783 Record.push_back(HEADER_SEARCH_TABLE);
1784 Record.push_back(BucketOffset);
1785 Record.push_back(NumHeaderSearchEntries);
1786 Record.push_back(TableData.size());
1787 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
1788 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData);
1790 // Free all of the strings we had to duplicate.
1791 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
1792 free(const_cast<char *>(SavedStrings[I]));
1795 /// \brief Writes the block containing the serialized form of the
1798 /// TODO: We should probably use an on-disk hash table (stored in a
1799 /// blob), indexed based on the file name, so that we only create
1800 /// entries for files that we actually need. In the common case (no
1801 /// errors), we probably won't have to create file entries for any of
1802 /// the files in the AST.
1803 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
1804 const Preprocessor &PP) {
1807 // Enter the source manager block.
1808 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3);
1810 // Abbreviations for the various kinds of source-location entries.
1811 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
1812 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
1813 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream);
1814 unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
1816 // Write out the source location entry table. We skip the first
1817 // entry, which is always the same dummy entry.
1818 std::vector<uint32_t> SLocEntryOffsets;
1819 RecordData PreloadSLocs;
1820 SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
1821 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
1823 // Get this source location entry.
1824 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
1825 FileID FID = FileID::get(I);
1826 assert(&SourceMgr.getSLocEntry(FID) == SLoc);
1828 // Record the offset of this source-location entry.
1829 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
1831 // Figure out which record code to use.
1833 if (SLoc->isFile()) {
1834 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
1835 if (Cache->OrigEntry) {
1836 Code = SM_SLOC_FILE_ENTRY;
1838 Code = SM_SLOC_BUFFER_ENTRY;
1840 Code = SM_SLOC_EXPANSION_ENTRY;
1842 Record.push_back(Code);
1844 // Starting offset of this entry within this module, so skip the dummy.
1845 Record.push_back(SLoc->getOffset() - 2);
1846 if (SLoc->isFile()) {
1847 const SrcMgr::FileInfo &File = SLoc->getFile();
1848 Record.push_back(File.getIncludeLoc().getRawEncoding());
1849 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
1850 Record.push_back(File.hasLineDirectives());
1852 const SrcMgr::ContentCache *Content = File.getContentCache();
1853 if (Content->OrigEntry) {
1854 assert(Content->OrigEntry == Content->ContentsEntry &&
1855 "Writing to AST an overridden file is not supported");
1857 // The source location entry is a file. Emit input file ID.
1858 assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry");
1859 Record.push_back(InputFileIDs[Content->OrigEntry]);
1861 Record.push_back(File.NumCreatedFIDs);
1863 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
1864 if (FDI != FileDeclIDs.end()) {
1865 Record.push_back(FDI->second->FirstDeclIndex);
1866 Record.push_back(FDI->second->DeclIDs.size());
1868 Record.push_back(0);
1869 Record.push_back(0);
1872 Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record);
1874 if (Content->BufferOverridden) {
1876 Record.push_back(SM_SLOC_BUFFER_BLOB);
1877 const llvm::MemoryBuffer *Buffer
1878 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
1879 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
1880 StringRef(Buffer->getBufferStart(),
1881 Buffer->getBufferSize() + 1));
1884 // The source location entry is a buffer. The blob associated
1885 // with this entry contains the contents of the buffer.
1887 // We add one to the size so that we capture the trailing NULL
1888 // that is required by llvm::MemoryBuffer::getMemBuffer (on
1889 // the reader side).
1890 const llvm::MemoryBuffer *Buffer
1891 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
1892 const char *Name = Buffer->getBufferIdentifier();
1893 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
1894 StringRef(Name, strlen(Name) + 1));
1896 Record.push_back(SM_SLOC_BUFFER_BLOB);
1897 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
1898 StringRef(Buffer->getBufferStart(),
1899 Buffer->getBufferSize() + 1));
1901 if (strcmp(Name, "<built-in>") == 0) {
1902 PreloadSLocs.push_back(SLocEntryOffsets.size());
1906 // The source location entry is a macro expansion.
1907 const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
1908 Record.push_back(Expansion.getSpellingLoc().getRawEncoding());
1909 Record.push_back(Expansion.getExpansionLocStart().getRawEncoding());
1910 Record.push_back(Expansion.isMacroArgExpansion() ? 0
1911 : Expansion.getExpansionLocEnd().getRawEncoding());
1913 // Compute the token length for this macro expansion.
1914 unsigned NextOffset = SourceMgr.getNextLocalOffset();
1916 NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
1917 Record.push_back(NextOffset - SLoc->getOffset() - 1);
1918 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
1924 if (SLocEntryOffsets.empty())
1927 // Write the source-location offsets table into the AST block. This
1928 // table is used for lazily loading source-location information.
1929 using namespace llvm;
1930 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1931 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
1932 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
1933 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
1934 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
1935 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
1938 Record.push_back(SOURCE_LOCATION_OFFSETS);
1939 Record.push_back(SLocEntryOffsets.size());
1940 Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy
1941 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, bytes(SLocEntryOffsets));
1943 // Write the source location entry preloads array, telling the AST
1944 // reader which source locations entries it should load eagerly.
1945 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
1947 // Write the line table. It depends on remapping working, so it must come
1948 // after the source location offsets.
1949 if (SourceMgr.hasLineTable()) {
1950 LineTableInfo &LineTable = SourceMgr.getLineTable();
1953 // Emit the file names.
1954 Record.push_back(LineTable.getNumFilenames());
1955 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I)
1956 AddPath(LineTable.getFilename(I), Record);
1958 // Emit the line entries
1959 for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end();
1961 // Only emit entries for local files.
1962 if (L->first.ID < 0)
1966 Record.push_back(L->first.ID);
1968 // Emit the line entries
1969 Record.push_back(L->second.size());
1970 for (std::vector<LineEntry>::iterator LE = L->second.begin(),
1971 LEEnd = L->second.end();
1972 LE != LEEnd; ++LE) {
1973 Record.push_back(LE->FileOffset);
1974 Record.push_back(LE->LineNo);
1975 Record.push_back(LE->FilenameID);
1976 Record.push_back((unsigned)LE->FileKind);
1977 Record.push_back(LE->IncludeOffset);
1980 Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record);
1984 //===----------------------------------------------------------------------===//
1985 // Preprocessor Serialization
1986 //===----------------------------------------------------------------------===//
1988 static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule,
1989 const Preprocessor &PP) {
1990 if (MacroInfo *MI = MD->getMacroInfo())
1991 if (MI->isBuiltinMacro())
1995 SourceLocation Loc = MD->getLocation();
1996 if (Loc.isInvalid())
1998 if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID())
2005 /// \brief Writes the block containing the serialized form of the
2008 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
2009 PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
2011 WritePreprocessorDetail(*PPRec);
2014 RecordData ModuleMacroRecord;
2016 // If the preprocessor __COUNTER__ value has been bumped, remember it.
2017 if (PP.getCounterValue() != 0) {
2018 Record.push_back(PP.getCounterValue());
2019 Stream.EmitRecord(PP_COUNTER_VALUE, Record);
2023 // Enter the preprocessor block.
2024 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3);
2026 // If the AST file contains __DATE__ or __TIME__ emit a warning about this.
2027 // FIXME: use diagnostics subsystem for localization etc.
2028 if (PP.SawDateOrTime())
2029 fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n");
2032 // Loop over all the macro directives that are live at the end of the file,
2033 // emitting each to the PP section.
2035 // Construct the list of identifiers with macro directives that need to be
2037 SmallVector<const IdentifierInfo *, 128> MacroIdentifiers;
2038 for (auto &Id : PP.getIdentifierTable())
2039 if (Id.second->hadMacroDefinition() &&
2040 (!Id.second->isFromAST() ||
2041 Id.second->hasChangedSinceDeserialization()))
2042 MacroIdentifiers.push_back(Id.second);
2043 // Sort the set of macro definitions that need to be serialized by the
2044 // name of the macro, to provide a stable ordering.
2045 std::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(),
2046 llvm::less_ptr<IdentifierInfo>());
2048 // Emit the macro directives as a list and associate the offset with the
2049 // identifier they belong to.
2050 for (const IdentifierInfo *Name : MacroIdentifiers) {
2051 MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name);
2052 auto StartOffset = Stream.GetCurrentBitNo();
2054 // Emit the macro directives in reverse source order.
2055 for (; MD; MD = MD->getPrevious()) {
2056 // Once we hit an ignored macro, we're done: the rest of the chain
2057 // will all be ignored macros.
2058 if (shouldIgnoreMacro(MD, IsModule, PP))
2061 AddSourceLocation(MD->getLocation(), Record);
2062 Record.push_back(MD->getKind());
2063 if (auto *DefMD = dyn_cast<DefMacroDirective>(MD)) {
2064 Record.push_back(getMacroRef(DefMD->getInfo(), Name));
2065 } else if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
2066 Record.push_back(VisMD->isPublic());
2070 // Write out any exported module macros.
2071 bool EmittedModuleMacros = false;
2073 auto Leafs = PP.getLeafModuleMacros(Name);
2074 SmallVector<ModuleMacro*, 8> Worklist(Leafs.begin(), Leafs.end());
2075 llvm::DenseMap<ModuleMacro*, unsigned> Visits;
2076 while (!Worklist.empty()) {
2077 auto *Macro = Worklist.pop_back_val();
2079 // Emit a record indicating this submodule exports this macro.
2080 ModuleMacroRecord.push_back(
2081 getSubmoduleID(Macro->getOwningModule()));
2082 ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name));
2083 for (auto *M : Macro->overrides())
2084 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule()));
2086 Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord);
2087 ModuleMacroRecord.clear();
2089 // Enqueue overridden macros once we've visited all their ancestors.
2090 for (auto *M : Macro->overrides())
2091 if (++Visits[M] == M->getNumOverridingMacros())
2092 Worklist.push_back(M);
2094 EmittedModuleMacros = true;
2098 if (Record.empty() && !EmittedModuleMacros)
2101 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2102 Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record);
2106 /// \brief Offsets of each of the macros into the bitstream, indexed by
2107 /// the local macro ID
2109 /// For each identifier that is associated with a macro, this map
2110 /// provides the offset into the bitstream where that macro is
2112 std::vector<uint32_t> MacroOffsets;
2114 for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
2115 const IdentifierInfo *Name = MacroInfosToEmit[I].Name;
2116 MacroInfo *MI = MacroInfosToEmit[I].MI;
2117 MacroID ID = MacroInfosToEmit[I].ID;
2119 if (ID < FirstMacroID) {
2120 assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?");
2124 // Record the local offset of this macro.
2125 unsigned Index = ID - FirstMacroID;
2126 if (Index == MacroOffsets.size())
2127 MacroOffsets.push_back(Stream.GetCurrentBitNo());
2129 if (Index > MacroOffsets.size())
2130 MacroOffsets.resize(Index + 1);
2132 MacroOffsets[Index] = Stream.GetCurrentBitNo();
2135 AddIdentifierRef(Name, Record);
2136 Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc()));
2137 AddSourceLocation(MI->getDefinitionLoc(), Record);
2138 AddSourceLocation(MI->getDefinitionEndLoc(), Record);
2139 Record.push_back(MI->isUsed());
2140 Record.push_back(MI->isUsedForHeaderGuard());
2142 if (MI->isObjectLike()) {
2143 Code = PP_MACRO_OBJECT_LIKE;
2145 Code = PP_MACRO_FUNCTION_LIKE;
2147 Record.push_back(MI->isC99Varargs());
2148 Record.push_back(MI->isGNUVarargs());
2149 Record.push_back(MI->hasCommaPasting());
2150 Record.push_back(MI->getNumArgs());
2151 for (const IdentifierInfo *Arg : MI->args())
2152 AddIdentifierRef(Arg, Record);
2155 // If we have a detailed preprocessing record, record the macro definition
2156 // ID that corresponds to this macro.
2158 Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
2160 Stream.EmitRecord(Code, Record);
2163 // Emit the tokens array.
2164 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
2165 // Note that we know that the preprocessor does not have any annotation
2166 // tokens in it because they are created by the parser, and thus can't
2167 // be in a macro definition.
2168 const Token &Tok = MI->getReplacementToken(TokNo);
2169 AddToken(Tok, Record);
2170 Stream.EmitRecord(PP_TOKEN, Record);
2178 // Write the offsets table for macro IDs.
2179 using namespace llvm;
2180 auto *Abbrev = new BitCodeAbbrev();
2181 Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET));
2182 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros
2183 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2184 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2186 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2188 Record.push_back(MACRO_OFFSET);
2189 Record.push_back(MacroOffsets.size());
2190 Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS);
2191 Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record,
2192 bytes(MacroOffsets));
2195 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
2196 if (PPRec.local_begin() == PPRec.local_end())
2199 SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
2201 // Enter the preprocessor block.
2202 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
2204 // If the preprocessor has a preprocessing record, emit it.
2205 unsigned NumPreprocessingRecords = 0;
2206 using namespace llvm;
2208 // Set up the abbreviation for
2209 unsigned InclusionAbbrev = 0;
2211 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2212 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
2213 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
2214 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
2215 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
2216 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module
2217 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2218 InclusionAbbrev = Stream.EmitAbbrev(Abbrev);
2221 unsigned FirstPreprocessorEntityID
2222 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
2223 + NUM_PREDEF_PP_ENTITY_IDS;
2224 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
2226 for (PreprocessingRecord::iterator E = PPRec.local_begin(),
2227 EEnd = PPRec.local_end();
2229 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
2232 PreprocessedEntityOffsets.push_back(
2233 PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo()));
2235 if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(*E)) {
2236 // Record this macro definition's ID.
2237 MacroDefinitions[MD] = NextPreprocessorEntityID;
2239 AddIdentifierRef(MD->getName(), Record);
2240 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
2244 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) {
2245 Record.push_back(ME->isBuiltinMacro());
2246 if (ME->isBuiltinMacro())
2247 AddIdentifierRef(ME->getName(), Record);
2249 Record.push_back(MacroDefinitions[ME->getDefinition()]);
2250 Stream.EmitRecord(PPD_MACRO_EXPANSION, Record);
2254 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) {
2255 Record.push_back(PPD_INCLUSION_DIRECTIVE);
2256 Record.push_back(ID->getFileName().size());
2257 Record.push_back(ID->wasInQuotes());
2258 Record.push_back(static_cast<unsigned>(ID->getKind()));
2259 Record.push_back(ID->importedModule());
2260 SmallString<64> Buffer;
2261 Buffer += ID->getFileName();
2262 // Check that the FileEntry is not null because it was not resolved and
2263 // we create a PCH even with compiler errors.
2265 Buffer += ID->getFile()->getName();
2266 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
2270 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter");
2274 // Write the offsets table for the preprocessing record.
2275 if (NumPreprocessingRecords > 0) {
2276 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
2278 // Write the offsets table for identifier IDs.
2279 using namespace llvm;
2280 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2281 Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
2282 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
2283 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2284 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2287 Record.push_back(PPD_ENTITIES_OFFSETS);
2288 Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS);
2289 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
2290 bytes(PreprocessedEntityOffsets));
2294 unsigned ASTWriter::getSubmoduleID(Module *Mod) {
2295 llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod);
2296 if (Known != SubmoduleIDs.end())
2297 return Known->second;
2299 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2302 unsigned ASTWriter::getExistingSubmoduleID(Module *Mod) const {
2306 llvm::DenseMap<Module *, unsigned>::const_iterator
2307 Known = SubmoduleIDs.find(Mod);
2308 if (Known != SubmoduleIDs.end())
2309 return Known->second;
2314 /// \brief Compute the number of modules within the given tree (including the
2316 static unsigned getNumberOfModules(Module *Mod) {
2317 unsigned ChildModules = 0;
2318 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2319 SubEnd = Mod->submodule_end();
2320 Sub != SubEnd; ++Sub)
2321 ChildModules += getNumberOfModules(*Sub);
2323 return ChildModules + 1;
2326 void ASTWriter::WriteSubmodules(Module *WritingModule) {
2327 // Enter the submodule description block.
2328 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/5);
2330 // Write the abbreviations needed for the submodules block.
2331 using namespace llvm;
2332 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2333 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
2334 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
2335 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
2336 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
2337 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
2338 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
2339 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC
2340 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
2341 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
2342 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
2343 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh...
2344 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2345 unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev);
2347 Abbrev = new BitCodeAbbrev();
2348 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER));
2349 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2350 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev);
2352 Abbrev = new BitCodeAbbrev();
2353 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER));
2354 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2355 unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2357 Abbrev = new BitCodeAbbrev();
2358 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER));
2359 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2360 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2362 Abbrev = new BitCodeAbbrev();
2363 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR));
2364 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2365 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev);
2367 Abbrev = new BitCodeAbbrev();
2368 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES));
2369 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State
2370 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature
2371 unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev);
2373 Abbrev = new BitCodeAbbrev();
2374 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER));
2375 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2376 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2378 Abbrev = new BitCodeAbbrev();
2379 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER));
2380 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2381 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2383 Abbrev = new BitCodeAbbrev();
2384 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER));
2385 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2386 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2388 Abbrev = new BitCodeAbbrev();
2389 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER));
2390 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2391 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
2393 Abbrev = new BitCodeAbbrev();
2394 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY));
2395 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
2396 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
2397 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev);
2399 Abbrev = new BitCodeAbbrev();
2400 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO));
2401 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name
2402 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev);
2404 Abbrev = new BitCodeAbbrev();
2405 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT));
2406 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module
2407 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message
2408 unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev);
2410 // Write the submodule metadata block.
2412 Record.push_back(getNumberOfModules(WritingModule));
2413 Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS);
2414 Stream.EmitRecord(SUBMODULE_METADATA, Record);
2416 // Write all of the submodules.
2417 std::queue<Module *> Q;
2418 Q.push(WritingModule);
2419 while (!Q.empty()) {
2420 Module *Mod = Q.front();
2422 unsigned ID = getSubmoduleID(Mod);
2424 // Emit the definition of the block.
2426 Record.push_back(SUBMODULE_DEFINITION);
2427 Record.push_back(ID);
2429 assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?");
2430 Record.push_back(SubmoduleIDs[Mod->Parent]);
2432 Record.push_back(0);
2434 Record.push_back(Mod->IsFramework);
2435 Record.push_back(Mod->IsExplicit);
2436 Record.push_back(Mod->IsSystem);
2437 Record.push_back(Mod->IsExternC);
2438 Record.push_back(Mod->InferSubmodules);
2439 Record.push_back(Mod->InferExplicitSubmodules);
2440 Record.push_back(Mod->InferExportWildcard);
2441 Record.push_back(Mod->ConfigMacrosExhaustive);
2442 Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name);
2444 // Emit the requirements.
2445 for (unsigned I = 0, N = Mod->Requirements.size(); I != N; ++I) {
2447 Record.push_back(SUBMODULE_REQUIRES);
2448 Record.push_back(Mod->Requirements[I].second);
2449 Stream.EmitRecordWithBlob(RequiresAbbrev, Record,
2450 Mod->Requirements[I].first);
2453 // Emit the umbrella header, if there is one.
2454 if (auto UmbrellaHeader = Mod->getUmbrellaHeader()) {
2456 Record.push_back(SUBMODULE_UMBRELLA_HEADER);
2457 Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record,
2458 UmbrellaHeader.NameAsWritten);
2459 } else if (auto UmbrellaDir = Mod->getUmbrellaDir()) {
2461 Record.push_back(SUBMODULE_UMBRELLA_DIR);
2462 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record,
2463 UmbrellaDir.NameAsWritten);
2466 // Emit the headers.
2468 unsigned RecordKind;
2470 Module::HeaderKind HeaderKind;
2472 {SUBMODULE_HEADER, HeaderAbbrev, Module::HK_Normal},
2473 {SUBMODULE_TEXTUAL_HEADER, TextualHeaderAbbrev, Module::HK_Textual},
2474 {SUBMODULE_PRIVATE_HEADER, PrivateHeaderAbbrev, Module::HK_Private},
2475 {SUBMODULE_PRIVATE_TEXTUAL_HEADER, PrivateTextualHeaderAbbrev,
2476 Module::HK_PrivateTextual},
2477 {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, Module::HK_Excluded}
2479 for (auto &HL : HeaderLists) {
2481 Record.push_back(HL.RecordKind);
2482 for (auto &H : Mod->Headers[HL.HeaderKind])
2483 Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten);
2486 // Emit the top headers.
2488 auto TopHeaders = Mod->getTopHeaders(PP->getFileManager());
2490 Record.push_back(SUBMODULE_TOPHEADER);
2491 for (auto *H : TopHeaders)
2492 Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName());
2495 // Emit the imports.
2496 if (!Mod->Imports.empty()) {
2498 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) {
2499 unsigned ImportedID = getSubmoduleID(Mod->Imports[I]);
2500 assert(ImportedID && "Unknown submodule!");
2501 Record.push_back(ImportedID);
2503 Stream.EmitRecord(SUBMODULE_IMPORTS, Record);
2506 // Emit the exports.
2507 if (!Mod->Exports.empty()) {
2509 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) {
2510 if (Module *Exported = Mod->Exports[I].getPointer()) {
2511 unsigned ExportedID = getSubmoduleID(Exported);
2512 Record.push_back(ExportedID);
2514 Record.push_back(0);
2517 Record.push_back(Mod->Exports[I].getInt());
2519 Stream.EmitRecord(SUBMODULE_EXPORTS, Record);
2522 //FIXME: How do we emit the 'use'd modules? They may not be submodules.
2523 // Might be unnecessary as use declarations are only used to build the
2526 // Emit the link libraries.
2527 for (unsigned I = 0, N = Mod->LinkLibraries.size(); I != N; ++I) {
2529 Record.push_back(SUBMODULE_LINK_LIBRARY);
2530 Record.push_back(Mod->LinkLibraries[I].IsFramework);
2531 Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record,
2532 Mod->LinkLibraries[I].Library);
2535 // Emit the conflicts.
2536 for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) {
2538 Record.push_back(SUBMODULE_CONFLICT);
2539 unsigned OtherID = getSubmoduleID(Mod->Conflicts[I].Other);
2540 assert(OtherID && "Unknown submodule!");
2541 Record.push_back(OtherID);
2542 Stream.EmitRecordWithBlob(ConflictAbbrev, Record,
2543 Mod->Conflicts[I].Message);
2546 // Emit the configuration macros.
2547 for (unsigned I = 0, N = Mod->ConfigMacros.size(); I != N; ++I) {
2549 Record.push_back(SUBMODULE_CONFIG_MACRO);
2550 Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record,
2551 Mod->ConfigMacros[I]);
2554 // Queue up the submodules of this module.
2555 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2556 SubEnd = Mod->submodule_end();
2557 Sub != SubEnd; ++Sub)
2563 // FIXME: This can easily happen, if we have a reference to a submodule that
2564 // did not result in us loading a module file for that submodule. For
2565 // instance, a cross-top-level-module 'conflict' declaration will hit this.
2566 assert((NextSubmoduleID - FirstSubmoduleID ==
2567 getNumberOfModules(WritingModule)) &&
2568 "Wrong # of submodules; found a reference to a non-local, "
2569 "non-imported submodule?");
2572 serialization::SubmoduleID
2573 ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) {
2574 if (Loc.isInvalid() || !WritingModule)
2575 return 0; // No submodule
2577 // Find the module that owns this location.
2578 ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
2580 = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager()));
2584 // Check whether this submodule is part of our own module.
2585 if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule))
2588 return getSubmoduleID(OwningMod);
2591 void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag,
2593 // Make sure set diagnostic pragmas don't affect the translation unit that
2594 // imports the module.
2595 // FIXME: Make diagnostic pragma sections work properly with modules.
2599 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
2601 unsigned CurrID = 0;
2602 DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one.
2604 for (DiagnosticsEngine::DiagStatePointsTy::const_iterator
2605 I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end();
2607 const DiagnosticsEngine::DiagStatePoint &point = *I;
2608 if (point.Loc.isInvalid())
2611 Record.push_back(point.Loc.getRawEncoding());
2612 unsigned &DiagStateID = DiagStateIDMap[point.State];
2613 Record.push_back(DiagStateID);
2615 if (DiagStateID == 0) {
2616 DiagStateID = ++CurrID;
2617 for (DiagnosticsEngine::DiagState::const_iterator
2618 I = point.State->begin(), E = point.State->end(); I != E; ++I) {
2619 if (I->second.isPragma()) {
2620 Record.push_back(I->first);
2621 Record.push_back((unsigned)I->second.getSeverity());
2624 Record.push_back(-1); // mark the end of the diag/map pairs for this
2629 if (!Record.empty())
2630 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record);
2633 void ASTWriter::WriteCXXCtorInitializersOffsets() {
2634 if (CXXCtorInitializersOffsets.empty())
2639 // Create a blob abbreviation for the C++ ctor initializer offsets.
2640 using namespace llvm;
2642 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2643 Abbrev->Add(BitCodeAbbrevOp(CXX_CTOR_INITIALIZERS_OFFSETS));
2644 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
2645 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2646 unsigned CtorInitializersOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2648 // Write the base specifier offsets table.
2650 Record.push_back(CXX_CTOR_INITIALIZERS_OFFSETS);
2651 Record.push_back(CXXCtorInitializersOffsets.size());
2652 Stream.EmitRecordWithBlob(CtorInitializersOffsetAbbrev, Record,
2653 bytes(CXXCtorInitializersOffsets));
2656 void ASTWriter::WriteCXXBaseSpecifiersOffsets() {
2657 if (CXXBaseSpecifiersOffsets.empty())
2662 // Create a blob abbreviation for the C++ base specifiers offsets.
2663 using namespace llvm;
2665 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2666 Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS));
2667 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
2668 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2669 unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2671 // Write the base specifier offsets table.
2673 Record.push_back(CXX_BASE_SPECIFIER_OFFSETS);
2674 Record.push_back(CXXBaseSpecifiersOffsets.size());
2675 Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record,
2676 bytes(CXXBaseSpecifiersOffsets));
2679 //===----------------------------------------------------------------------===//
2680 // Type Serialization
2681 //===----------------------------------------------------------------------===//
2683 /// \brief Write the representation of a type to the AST stream.
2684 void ASTWriter::WriteType(QualType T) {
2685 TypeIdx &Idx = TypeIdxs[T];
2686 if (Idx.getIndex() == 0) // we haven't seen this type before.
2687 Idx = TypeIdx(NextTypeID++);
2689 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
2691 // Record the offset for this type.
2692 unsigned Index = Idx.getIndex() - FirstTypeID;
2693 if (TypeOffsets.size() == Index)
2694 TypeOffsets.push_back(Stream.GetCurrentBitNo());
2695 else if (TypeOffsets.size() < Index) {
2696 TypeOffsets.resize(Index + 1);
2697 TypeOffsets[Index] = Stream.GetCurrentBitNo();
2702 // Emit the type's representation.
2703 ASTTypeWriter W(*this, Record);
2706 if (T.hasLocalNonFastQualifiers()) {
2707 Qualifiers Qs = T.getLocalQualifiers();
2708 AddTypeRef(T.getLocalUnqualifiedType(), Record);
2709 Record.push_back(Qs.getAsOpaqueValue());
2710 W.Code = TYPE_EXT_QUAL;
2711 W.AbbrevToUse = TypeExtQualAbbrev;
2713 switch (T->getTypeClass()) {
2714 // For all of the concrete, non-dependent types, call the
2715 // appropriate visitor function.
2716 #define TYPE(Class, Base) \
2717 case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break;
2718 #define ABSTRACT_TYPE(Class, Base)
2719 #include "clang/AST/TypeNodes.def"
2723 // Emit the serialized record.
2724 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse);
2726 // Flush any expressions that were written as part of this type.
2730 //===----------------------------------------------------------------------===//
2731 // Declaration Serialization
2732 //===----------------------------------------------------------------------===//
2734 /// \brief Write the block containing all of the declaration IDs
2735 /// lexically declared within the given DeclContext.
2737 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
2738 /// bistream, or 0 if no block was written.
2739 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
2741 if (DC->decls_empty())
2744 uint64_t Offset = Stream.GetCurrentBitNo();
2746 Record.push_back(DECL_CONTEXT_LEXICAL);
2747 SmallVector<KindDeclIDPair, 64> Decls;
2748 for (const auto *D : DC->decls())
2749 Decls.push_back(std::make_pair(D->getKind(), GetDeclRef(D)));
2751 ++NumLexicalDeclContexts;
2752 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, bytes(Decls));
2756 void ASTWriter::WriteTypeDeclOffsets() {
2757 using namespace llvm;
2760 // Write the type offsets array
2761 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2762 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
2763 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
2764 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
2765 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
2766 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2768 Record.push_back(TYPE_OFFSET);
2769 Record.push_back(TypeOffsets.size());
2770 Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS);
2771 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, bytes(TypeOffsets));
2773 // Write the declaration offsets array
2774 Abbrev = new BitCodeAbbrev();
2775 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
2776 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
2777 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
2778 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
2779 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2781 Record.push_back(DECL_OFFSET);
2782 Record.push_back(DeclOffsets.size());
2783 Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS);
2784 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, bytes(DeclOffsets));
2787 void ASTWriter::WriteFileDeclIDsMap() {
2788 using namespace llvm;
2791 SmallVector<std::pair<FileID, DeclIDInFileInfo *>, 64> SortedFileDeclIDs(
2792 FileDeclIDs.begin(), FileDeclIDs.end());
2793 std::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(),
2794 llvm::less_first());
2796 // Join the vectors of DeclIDs from all files.
2797 SmallVector<DeclID, 256> FileGroupedDeclIDs;
2798 for (auto &FileDeclEntry : SortedFileDeclIDs) {
2799 DeclIDInFileInfo &Info = *FileDeclEntry.second;
2800 Info.FirstDeclIndex = FileGroupedDeclIDs.size();
2801 for (auto &LocDeclEntry : Info.DeclIDs)
2802 FileGroupedDeclIDs.push_back(LocDeclEntry.second);
2805 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2806 Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS));
2807 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2808 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2809 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
2810 Record.push_back(FILE_SORTED_DECLS);
2811 Record.push_back(FileGroupedDeclIDs.size());
2812 Stream.EmitRecordWithBlob(AbbrevCode, Record, bytes(FileGroupedDeclIDs));
2815 void ASTWriter::WriteComments() {
2816 Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3);
2817 ArrayRef<RawComment *> RawComments = Context->Comments.getComments();
2819 for (ArrayRef<RawComment *>::iterator I = RawComments.begin(),
2820 E = RawComments.end();
2823 AddSourceRange((*I)->getSourceRange(), Record);
2824 Record.push_back((*I)->getKind());
2825 Record.push_back((*I)->isTrailingComment());
2826 Record.push_back((*I)->isAlmostTrailingComment());
2827 Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record);
2832 //===----------------------------------------------------------------------===//
2833 // Global Method Pool and Selector Serialization
2834 //===----------------------------------------------------------------------===//
2837 // Trait used for the on-disk hash table used in the method pool.
2838 class ASTMethodPoolTrait {
2842 typedef Selector key_type;
2843 typedef key_type key_type_ref;
2847 ObjCMethodList Instance, Factory;
2849 typedef const data_type& data_type_ref;
2851 typedef unsigned hash_value_type;
2852 typedef unsigned offset_type;
2854 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { }
2856 static hash_value_type ComputeHash(Selector Sel) {
2857 return serialization::ComputeHash(Sel);
2860 std::pair<unsigned,unsigned>
2861 EmitKeyDataLength(raw_ostream& Out, Selector Sel,
2862 data_type_ref Methods) {
2863 using namespace llvm::support;
2864 endian::Writer<little> LE(Out);
2865 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
2866 LE.write<uint16_t>(KeyLen);
2867 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
2868 for (const ObjCMethodList *Method = &Methods.Instance; Method;
2869 Method = Method->getNext())
2870 if (Method->getMethod())
2872 for (const ObjCMethodList *Method = &Methods.Factory; Method;
2873 Method = Method->getNext())
2874 if (Method->getMethod())
2876 LE.write<uint16_t>(DataLen);
2877 return std::make_pair(KeyLen, DataLen);
2880 void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
2881 using namespace llvm::support;
2882 endian::Writer<little> LE(Out);
2883 uint64_t Start = Out.tell();
2884 assert((Start >> 32) == 0 && "Selector key offset too large");
2885 Writer.SetSelectorOffset(Sel, Start);
2886 unsigned N = Sel.getNumArgs();
2887 LE.write<uint16_t>(N);
2890 for (unsigned I = 0; I != N; ++I)
2892 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
2895 void EmitData(raw_ostream& Out, key_type_ref,
2896 data_type_ref Methods, unsigned DataLen) {
2897 using namespace llvm::support;
2898 endian::Writer<little> LE(Out);
2899 uint64_t Start = Out.tell(); (void)Start;
2900 LE.write<uint32_t>(Methods.ID);
2901 unsigned NumInstanceMethods = 0;
2902 for (const ObjCMethodList *Method = &Methods.Instance; Method;
2903 Method = Method->getNext())
2904 if (Method->getMethod())
2905 ++NumInstanceMethods;
2907 unsigned NumFactoryMethods = 0;
2908 for (const ObjCMethodList *Method = &Methods.Factory; Method;
2909 Method = Method->getNext())
2910 if (Method->getMethod())
2911 ++NumFactoryMethods;
2913 unsigned InstanceBits = Methods.Instance.getBits();
2914 assert(InstanceBits < 4);
2915 unsigned InstanceHasMoreThanOneDeclBit =
2916 Methods.Instance.hasMoreThanOneDecl();
2917 unsigned FullInstanceBits = (NumInstanceMethods << 3) |
2918 (InstanceHasMoreThanOneDeclBit << 2) |
2920 unsigned FactoryBits = Methods.Factory.getBits();
2921 assert(FactoryBits < 4);
2922 unsigned FactoryHasMoreThanOneDeclBit =
2923 Methods.Factory.hasMoreThanOneDecl();
2924 unsigned FullFactoryBits = (NumFactoryMethods << 3) |
2925 (FactoryHasMoreThanOneDeclBit << 2) |
2927 LE.write<uint16_t>(FullInstanceBits);
2928 LE.write<uint16_t>(FullFactoryBits);
2929 for (const ObjCMethodList *Method = &Methods.Instance; Method;
2930 Method = Method->getNext())
2931 if (Method->getMethod())
2932 LE.write<uint32_t>(Writer.getDeclID(Method->getMethod()));
2933 for (const ObjCMethodList *Method = &Methods.Factory; Method;
2934 Method = Method->getNext())
2935 if (Method->getMethod())
2936 LE.write<uint32_t>(Writer.getDeclID(Method->getMethod()));
2938 assert(Out.tell() - Start == DataLen && "Data length is wrong");
2941 } // end anonymous namespace
2943 /// \brief Write ObjC data: selectors and the method pool.
2945 /// The method pool contains both instance and factory methods, stored
2946 /// in an on-disk hash table indexed by the selector. The hash table also
2947 /// contains an empty entry for every other selector known to Sema.
2948 void ASTWriter::WriteSelectors(Sema &SemaRef) {
2949 using namespace llvm;
2951 // Do we have to do anything at all?
2952 if (SemaRef.MethodPool.empty() && SelectorIDs.empty())
2954 unsigned NumTableEntries = 0;
2955 // Create and write out the blob that contains selectors and the method pool.
2957 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
2958 ASTMethodPoolTrait Trait(*this);
2960 // Create the on-disk hash table representation. We walk through every
2961 // selector we've seen and look it up in the method pool.
2962 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
2963 for (auto &SelectorAndID : SelectorIDs) {
2964 Selector S = SelectorAndID.first;
2965 SelectorID ID = SelectorAndID.second;
2966 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S);
2967 ASTMethodPoolTrait::data_type Data = {
2972 if (F != SemaRef.MethodPool.end()) {
2973 Data.Instance = F->second.first;
2974 Data.Factory = F->second.second;
2976 // Only write this selector if it's not in an existing AST or something
2978 if (Chain && ID < FirstSelectorID) {
2979 // Selector already exists. Did it change?
2980 bool changed = false;
2981 for (ObjCMethodList *M = &Data.Instance;
2982 !changed && M && M->getMethod(); M = M->getNext()) {
2983 if (!M->getMethod()->isFromASTFile())
2986 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->getMethod();
2988 if (!M->getMethod()->isFromASTFile())
2993 } else if (Data.Instance.getMethod() || Data.Factory.getMethod()) {
2994 // A new method pool entry.
2997 Generator.insert(S, Data, Trait);
3000 // Create the on-disk hash table in a buffer.
3001 SmallString<4096> MethodPool;
3002 uint32_t BucketOffset;
3004 using namespace llvm::support;
3005 ASTMethodPoolTrait Trait(*this);
3006 llvm::raw_svector_ostream Out(MethodPool);
3007 // Make sure that no bucket is at offset 0
3008 endian::Writer<little>(Out).write<uint32_t>(0);
3009 BucketOffset = Generator.Emit(Out, Trait);
3012 // Create a blob abbreviation
3013 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3014 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
3015 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3016 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3017 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3018 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev);
3020 // Write the method pool
3022 Record.push_back(METHOD_POOL);
3023 Record.push_back(BucketOffset);
3024 Record.push_back(NumTableEntries);
3025 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool);
3027 // Create a blob abbreviation for the selector table offsets.
3028 Abbrev = new BitCodeAbbrev();
3029 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
3030 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
3031 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
3032 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3033 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
3035 // Write the selector offsets table.
3037 Record.push_back(SELECTOR_OFFSETS);
3038 Record.push_back(SelectorOffsets.size());
3039 Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS);
3040 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
3041 bytes(SelectorOffsets));
3045 /// \brief Write the selectors referenced in @selector expression into AST file.
3046 void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
3047 using namespace llvm;
3048 if (SemaRef.ReferencedSelectors.empty())
3053 // Note: this writes out all references even for a dependent AST. But it is
3054 // very tricky to fix, and given that @selector shouldn't really appear in
3055 // headers, probably not worth it. It's not a correctness issue.
3056 for (auto &SelectorAndLocation : SemaRef.ReferencedSelectors) {
3057 Selector Sel = SelectorAndLocation.first;
3058 SourceLocation Loc = SelectorAndLocation.second;
3059 AddSelectorRef(Sel, Record);
3060 AddSourceLocation(Loc, Record);
3062 Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record);
3065 //===----------------------------------------------------------------------===//
3066 // Identifier Table Serialization
3067 //===----------------------------------------------------------------------===//
3069 /// Determine the declaration that should be put into the name lookup table to
3070 /// represent the given declaration in this module. This is usually D itself,
3071 /// but if D was imported and merged into a local declaration, we want the most
3072 /// recent local declaration instead. The chosen declaration will be the most
3073 /// recent declaration in any module that imports this one.
3074 static NamedDecl *getDeclForLocalLookup(const LangOptions &LangOpts,
3076 if (!LangOpts.Modules || !D->isFromASTFile())
3079 if (Decl *Redecl = D->getPreviousDecl()) {
3080 // For Redeclarable decls, a prior declaration might be local.
3081 for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
3082 if (!Redecl->isFromASTFile())
3083 return cast<NamedDecl>(Redecl);
3084 // If we find a decl from a (chained-)PCH stop since we won't find a
3086 if (D->getOwningModuleID() == 0)
3089 } else if (Decl *First = D->getCanonicalDecl()) {
3090 // For Mergeable decls, the first decl might be local.
3091 if (!First->isFromASTFile())
3092 return cast<NamedDecl>(First);
3095 // All declarations are imported. Our most recent declaration will also be
3096 // the most recent one in anyone who imports us.
3101 class ASTIdentifierTableTrait {
3104 IdentifierResolver &IdResolver;
3106 /// \brief Determines whether this is an "interesting" identifier that needs a
3107 /// full IdentifierInfo structure written into the hash table. Notably, this
3108 /// doesn't check whether the name has macros defined; use PublicMacroIterator
3110 bool isInterestingIdentifier(IdentifierInfo *II, uint64_t MacroOffset) {
3113 II->isExtensionToken() ||
3114 II->getObjCOrBuiltinID() ||
3115 II->hasRevertedTokenIDToIdentifier() ||
3116 II->getFETokenInfo<void>())
3123 typedef IdentifierInfo* key_type;
3124 typedef key_type key_type_ref;
3126 typedef IdentID data_type;
3127 typedef data_type data_type_ref;
3129 typedef unsigned hash_value_type;
3130 typedef unsigned offset_type;
3132 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP,
3133 IdentifierResolver &IdResolver)
3134 : Writer(Writer), PP(PP), IdResolver(IdResolver) {}
3136 static hash_value_type ComputeHash(const IdentifierInfo* II) {
3137 return llvm::HashString(II->getName());
3140 std::pair<unsigned,unsigned>
3141 EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) {
3142 unsigned KeyLen = II->getLength() + 1;
3143 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
3144 auto MacroOffset = Writer.getMacroDirectivesOffset(II);
3145 if (isInterestingIdentifier(II, MacroOffset)) {
3146 DataLen += 2; // 2 bytes for builtin ID
3147 DataLen += 2; // 2 bytes for flags
3149 DataLen += 4; // MacroDirectives offset.
3151 for (IdentifierResolver::iterator D = IdResolver.begin(II),
3152 DEnd = IdResolver.end();
3156 using namespace llvm::support;
3157 endian::Writer<little> LE(Out);
3159 assert((uint16_t)DataLen == DataLen && (uint16_t)KeyLen == KeyLen);
3160 LE.write<uint16_t>(DataLen);
3161 // We emit the key length after the data length so that every
3162 // string is preceded by a 16-bit length. This matches the PTH
3163 // format for storing identifiers.
3164 LE.write<uint16_t>(KeyLen);
3165 return std::make_pair(KeyLen, DataLen);
3168 void EmitKey(raw_ostream& Out, const IdentifierInfo* II,
3170 // Record the location of the key data. This is used when generating
3171 // the mapping from persistent IDs to strings.
3172 Writer.SetIdentifierOffset(II, Out.tell());
3173 Out.write(II->getNameStart(), KeyLen);
3176 void EmitData(raw_ostream& Out, IdentifierInfo* II,
3177 IdentID ID, unsigned) {
3178 using namespace llvm::support;
3179 endian::Writer<little> LE(Out);
3181 auto MacroOffset = Writer.getMacroDirectivesOffset(II);
3182 if (!isInterestingIdentifier(II, MacroOffset)) {
3183 LE.write<uint32_t>(ID << 1);
3187 LE.write<uint32_t>((ID << 1) | 0x01);
3188 uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID();
3189 assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader.");
3190 LE.write<uint16_t>(Bits);
3192 bool HadMacroDefinition = MacroOffset != 0;
3193 Bits = (Bits << 1) | unsigned(HadMacroDefinition);
3194 Bits = (Bits << 1) | unsigned(II->isExtensionToken());
3195 Bits = (Bits << 1) | unsigned(II->isPoisoned());
3196 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
3197 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
3198 LE.write<uint16_t>(Bits);
3200 if (HadMacroDefinition)
3201 LE.write<uint32_t>(MacroOffset);
3203 // Emit the declaration IDs in reverse order, because the
3204 // IdentifierResolver provides the declarations as they would be
3205 // visible (e.g., the function "stat" would come before the struct
3206 // "stat"), but the ASTReader adds declarations to the end of the list
3207 // (so we need to see the struct "stat" before the function "stat").
3208 // Only emit declarations that aren't from a chained PCH, though.
3209 SmallVector<NamedDecl *, 16> Decls(IdResolver.begin(II), IdResolver.end());
3210 for (SmallVectorImpl<NamedDecl *>::reverse_iterator D = Decls.rbegin(),
3211 DEnd = Decls.rend();
3214 Writer.getDeclID(getDeclForLocalLookup(PP.getLangOpts(), *D)));
3217 } // end anonymous namespace
3219 /// \brief Write the identifier table into the AST file.
3221 /// The identifier table consists of a blob containing string data
3222 /// (the actual identifiers themselves) and a separate "offsets" index
3223 /// that maps identifier IDs to locations within the blob.
3224 void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
3225 IdentifierResolver &IdResolver,
3227 using namespace llvm;
3229 // Create and write out the blob that contains the identifier
3232 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
3233 ASTIdentifierTableTrait Trait(*this, PP, IdResolver);
3235 // Look for any identifiers that were named while processing the
3236 // headers, but are otherwise not needed. We add these to the hash
3237 // table to enable checking of the predefines buffer in the case
3238 // where the user adds new macro definitions when building the AST
3240 SmallVector<const IdentifierInfo *, 128> IIs;
3241 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
3242 IDEnd = PP.getIdentifierTable().end();
3244 IIs.push_back(ID->second);
3245 // Sort the identifiers lexicographically before getting them references so
3246 // that their order is stable.
3247 std::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
3248 for (const IdentifierInfo *II : IIs)
3249 getIdentifierRef(II);
3251 // Create the on-disk hash table representation. We only store offsets
3252 // for identifiers that appear here for the first time.
3253 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
3254 for (auto IdentIDPair : IdentifierIDs) {
3255 IdentifierInfo *II = const_cast<IdentifierInfo *>(IdentIDPair.first);
3256 IdentID ID = IdentIDPair.second;
3257 assert(II && "NULL identifier in identifier table");
3258 if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization())
3259 Generator.insert(II, ID, Trait);
3262 // Create the on-disk hash table in a buffer.
3263 SmallString<4096> IdentifierTable;
3264 uint32_t BucketOffset;
3266 using namespace llvm::support;
3267 llvm::raw_svector_ostream Out(IdentifierTable);
3268 // Make sure that no bucket is at offset 0
3269 endian::Writer<little>(Out).write<uint32_t>(0);
3270 BucketOffset = Generator.Emit(Out, Trait);
3273 // Create a blob abbreviation
3274 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3275 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
3276 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
3277 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3278 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev);
3280 // Write the identifier table
3282 Record.push_back(IDENTIFIER_TABLE);
3283 Record.push_back(BucketOffset);
3284 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable);
3287 // Write the offsets table for identifier IDs.
3288 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3289 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
3290 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
3291 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
3292 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3293 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
3296 for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
3297 assert(IdentifierOffsets[I] && "Missing identifier offset?");
3301 Record.push_back(IDENTIFIER_OFFSET);
3302 Record.push_back(IdentifierOffsets.size());
3303 Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS);
3304 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
3305 bytes(IdentifierOffsets));
3308 //===----------------------------------------------------------------------===//
3309 // DeclContext's Name Lookup Table Serialization
3310 //===----------------------------------------------------------------------===//
3313 // Trait used for the on-disk hash table used in the method pool.
3314 class ASTDeclContextNameLookupTrait {
3318 typedef DeclarationName key_type;
3319 typedef key_type key_type_ref;
3321 typedef DeclContext::lookup_result data_type;
3322 typedef const data_type& data_type_ref;
3324 typedef unsigned hash_value_type;
3325 typedef unsigned offset_type;
3327 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { }
3329 hash_value_type ComputeHash(DeclarationName Name) {
3330 llvm::FoldingSetNodeID ID;
3331 ID.AddInteger(Name.getNameKind());
3333 switch (Name.getNameKind()) {
3334 case DeclarationName::Identifier:
3335 ID.AddString(Name.getAsIdentifierInfo()->getName());
3337 case DeclarationName::ObjCZeroArgSelector:
3338 case DeclarationName::ObjCOneArgSelector:
3339 case DeclarationName::ObjCMultiArgSelector:
3340 ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector()));
3342 case DeclarationName::CXXConstructorName:
3343 case DeclarationName::CXXDestructorName:
3344 case DeclarationName::CXXConversionFunctionName:
3346 case DeclarationName::CXXOperatorName:
3347 ID.AddInteger(Name.getCXXOverloadedOperator());
3349 case DeclarationName::CXXLiteralOperatorName:
3350 ID.AddString(Name.getCXXLiteralIdentifier()->getName());
3351 case DeclarationName::CXXUsingDirective:
3355 return ID.ComputeHash();
3358 std::pair<unsigned,unsigned>
3359 EmitKeyDataLength(raw_ostream& Out, DeclarationName Name,
3360 data_type_ref Lookup) {
3361 using namespace llvm::support;
3362 endian::Writer<little> LE(Out);
3363 unsigned KeyLen = 1;
3364 switch (Name.getNameKind()) {
3365 case DeclarationName::Identifier:
3366 case DeclarationName::ObjCZeroArgSelector:
3367 case DeclarationName::ObjCOneArgSelector:
3368 case DeclarationName::ObjCMultiArgSelector:
3369 case DeclarationName::CXXLiteralOperatorName:
3372 case DeclarationName::CXXOperatorName:
3375 case DeclarationName::CXXConstructorName:
3376 case DeclarationName::CXXDestructorName:
3377 case DeclarationName::CXXConversionFunctionName:
3378 case DeclarationName::CXXUsingDirective:
3381 LE.write<uint16_t>(KeyLen);
3383 // 2 bytes for num of decls and 4 for each DeclID.
3384 unsigned DataLen = 2 + 4 * Lookup.size();
3385 LE.write<uint16_t>(DataLen);
3387 return std::make_pair(KeyLen, DataLen);
3390 void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) {
3391 using namespace llvm::support;
3392 endian::Writer<little> LE(Out);
3393 LE.write<uint8_t>(Name.getNameKind());
3394 switch (Name.getNameKind()) {
3395 case DeclarationName::Identifier:
3396 LE.write<uint32_t>(Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
3398 case DeclarationName::ObjCZeroArgSelector:
3399 case DeclarationName::ObjCOneArgSelector:
3400 case DeclarationName::ObjCMultiArgSelector:
3401 LE.write<uint32_t>(Writer.getSelectorRef(Name.getObjCSelector()));
3403 case DeclarationName::CXXOperatorName:
3404 assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS &&
3405 "Invalid operator?");
3406 LE.write<uint8_t>(Name.getCXXOverloadedOperator());
3408 case DeclarationName::CXXLiteralOperatorName:
3409 LE.write<uint32_t>(Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
3411 case DeclarationName::CXXConstructorName:
3412 case DeclarationName::CXXDestructorName:
3413 case DeclarationName::CXXConversionFunctionName:
3414 case DeclarationName::CXXUsingDirective:
3418 llvm_unreachable("Invalid name kind?");
3421 void EmitData(raw_ostream& Out, key_type_ref,
3422 data_type Lookup, unsigned DataLen) {
3423 using namespace llvm::support;
3424 endian::Writer<little> LE(Out);
3425 uint64_t Start = Out.tell(); (void)Start;
3426 LE.write<uint16_t>(Lookup.size());
3427 for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end();
3430 Writer.GetDeclRef(getDeclForLocalLookup(Writer.getLangOpts(), *I)));
3432 assert(Out.tell() - Start == DataLen && "Data length is wrong");
3435 } // end anonymous namespace
3437 bool ASTWriter::isLookupResultExternal(StoredDeclsList &Result,
3439 return Result.hasExternalDecls() && DC->NeedToReconcileExternalVisibleStorage;
3442 bool ASTWriter::isLookupResultEntirelyExternal(StoredDeclsList &Result,
3444 for (auto *D : Result.getLookupResult())
3445 if (!getDeclForLocalLookup(getLangOpts(), D)->isFromASTFile())
3452 ASTWriter::GenerateNameLookupTable(const DeclContext *ConstDC,
3453 llvm::SmallVectorImpl<char> &LookupTable) {
3454 assert(!ConstDC->HasLazyLocalLexicalLookups &&
3455 !ConstDC->HasLazyExternalLexicalLookups &&
3456 "must call buildLookups first");
3458 // FIXME: We need to build the lookups table, which is logically const.
3459 DeclContext *DC = const_cast<DeclContext*>(ConstDC);
3460 assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table");
3462 // Create the on-disk hash table representation.
3463 llvm::OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait>
3465 ASTDeclContextNameLookupTrait Trait(*this);
3467 // The first step is to collect the declaration names which we need to
3468 // serialize into the name lookup table, and to collect them in a stable
3470 SmallVector<DeclarationName, 16> Names;
3472 // We also build up small sets of the constructor and conversion function
3473 // names which are visible.
3474 llvm::SmallSet<DeclarationName, 8> ConstructorNameSet, ConversionNameSet;
3476 for (auto &Lookup : *DC->buildLookup()) {
3477 auto &Name = Lookup.first;
3478 auto &Result = Lookup.second;
3480 // If there are no local declarations in our lookup result, we don't
3481 // need to write an entry for the name at all unless we're rewriting
3482 // the decl context. If we can't write out a lookup set without
3483 // performing more deserialization, just skip this entry.
3484 if (isLookupResultExternal(Result, DC) && !isRewritten(cast<Decl>(DC)) &&
3485 isLookupResultEntirelyExternal(Result, DC))
3488 // We also skip empty results. If any of the results could be external and
3489 // the currently available results are empty, then all of the results are
3490 // external and we skip it above. So the only way we get here with an empty
3491 // results is when no results could have been external *and* we have
3492 // external results.
3494 // FIXME: While we might want to start emitting on-disk entries for negative
3495 // lookups into a decl context as an optimization, today we *have* to skip
3496 // them because there are names with empty lookup results in decl contexts
3497 // which we can't emit in any stable ordering: we lookup constructors and
3498 // conversion functions in the enclosing namespace scope creating empty
3499 // results for them. This in almost certainly a bug in Clang's name lookup,
3500 // but that is likely to be hard or impossible to fix and so we tolerate it
3501 // here by omitting lookups with empty results.
3502 if (Lookup.second.getLookupResult().empty())
3505 switch (Lookup.first.getNameKind()) {
3507 Names.push_back(Lookup.first);
3510 case DeclarationName::CXXConstructorName:
3511 assert(isa<CXXRecordDecl>(DC) &&
3512 "Cannot have a constructor name outside of a class!");
3513 ConstructorNameSet.insert(Name);
3516 case DeclarationName::CXXConversionFunctionName:
3517 assert(isa<CXXRecordDecl>(DC) &&
3518 "Cannot have a conversion function name outside of a class!");
3519 ConversionNameSet.insert(Name);
3524 // Sort the names into a stable order.
3525 std::sort(Names.begin(), Names.end());
3527 if (auto *D = dyn_cast<CXXRecordDecl>(DC)) {
3528 // We need to establish an ordering of constructor and conversion function
3529 // names, and they don't have an intrinsic ordering.
3531 // First we try the easy case by forming the current context's constructor
3532 // name and adding that name first. This is a very useful optimization to
3533 // avoid walking the lexical declarations in many cases, and it also
3534 // handles the only case where a constructor name can come from some other
3535 // lexical context -- when that name is an implicit constructor merged from
3536 // another declaration in the redecl chain. Any non-implicit constructor or
3537 // conversion function which doesn't occur in all the lexical contexts
3538 // would be an ODR violation.
3539 auto ImplicitCtorName = Context->DeclarationNames.getCXXConstructorName(
3540 Context->getCanonicalType(Context->getRecordType(D)));
3541 if (ConstructorNameSet.erase(ImplicitCtorName))
3542 Names.push_back(ImplicitCtorName);
3544 // If we still have constructors or conversion functions, we walk all the
3545 // names in the decl and add the constructors and conversion functions
3546 // which are visible in the order they lexically occur within the context.
3547 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty())
3548 for (Decl *ChildD : cast<CXXRecordDecl>(DC)->decls())
3549 if (auto *ChildND = dyn_cast<NamedDecl>(ChildD)) {
3550 auto Name = ChildND->getDeclName();
3551 switch (Name.getNameKind()) {
3555 case DeclarationName::CXXConstructorName:
3556 if (ConstructorNameSet.erase(Name))
3557 Names.push_back(Name);
3560 case DeclarationName::CXXConversionFunctionName:
3561 if (ConversionNameSet.erase(Name))
3562 Names.push_back(Name);
3566 if (ConstructorNameSet.empty() && ConversionNameSet.empty())
3570 assert(ConstructorNameSet.empty() && "Failed to find all of the visible "
3571 "constructors by walking all the "
3572 "lexical members of the context.");
3573 assert(ConversionNameSet.empty() && "Failed to find all of the visible "
3574 "conversion functions by walking all "
3575 "the lexical members of the context.");
3578 // Next we need to do a lookup with each name into this decl context to fully
3579 // populate any results from external sources. We don't actually use the
3580 // results of these lookups because we only want to use the results after all
3581 // results have been loaded and the pointers into them will be stable.
3582 for (auto &Name : Names)
3585 // Now we need to insert the results for each name into the hash table. For
3586 // constructor names and conversion function names, we actually need to merge
3587 // all of the results for them into one list of results each and insert
3589 SmallVector<NamedDecl *, 8> ConstructorDecls;
3590 SmallVector<NamedDecl *, 8> ConversionDecls;
3592 // Now loop over the names, either inserting them or appending for the two
3594 for (auto &Name : Names) {
3595 DeclContext::lookup_result Result = DC->noload_lookup(Name);
3597 switch (Name.getNameKind()) {
3599 Generator.insert(Name, Result, Trait);
3602 case DeclarationName::CXXConstructorName:
3603 ConstructorDecls.append(Result.begin(), Result.end());
3606 case DeclarationName::CXXConversionFunctionName:
3607 ConversionDecls.append(Result.begin(), Result.end());
3612 // Handle our two special cases if we ended up having any. We arbitrarily use
3613 // the first declaration's name here because the name itself isn't part of
3614 // the key, only the kind of name is used.
3615 if (!ConstructorDecls.empty())
3616 Generator.insert(ConstructorDecls.front()->getDeclName(),
3617 DeclContext::lookup_result(ConstructorDecls), Trait);
3618 if (!ConversionDecls.empty())
3619 Generator.insert(ConversionDecls.front()->getDeclName(),
3620 DeclContext::lookup_result(ConversionDecls), Trait);
3622 // Create the on-disk hash table in a buffer.
3623 llvm::raw_svector_ostream Out(LookupTable);
3624 // Make sure that no bucket is at offset 0
3625 using namespace llvm::support;
3626 endian::Writer<little>(Out).write<uint32_t>(0);
3627 return Generator.Emit(Out, Trait);
3630 /// \brief Write the block containing all of the declaration IDs
3631 /// visible from the given DeclContext.
3633 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
3634 /// bitstream, or 0 if no block was written.
3635 uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
3637 // If we imported a key declaration of this namespace, write the visible
3638 // lookup results as an update record for it rather than including them
3639 // on this declaration. We will only look at key declarations on reload.
3640 if (isa<NamespaceDecl>(DC) && Chain &&
3641 Chain->getKeyDeclaration(cast<Decl>(DC))->isFromASTFile()) {
3642 // Only do this once, for the first local declaration of the namespace.
3643 for (NamespaceDecl *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev;
3644 Prev = Prev->getPreviousDecl())
3645 if (!Prev->isFromASTFile())
3648 // Note that we need to emit an update record for the primary context.
3649 UpdatedDeclContexts.insert(DC->getPrimaryContext());
3651 // Make sure all visible decls are written. They will be recorded later. We
3652 // do this using a side data structure so we can sort the names into
3653 // a deterministic order.
3654 StoredDeclsMap *Map = DC->getPrimaryContext()->buildLookup();
3655 SmallVector<std::pair<DeclarationName, DeclContext::lookup_result>, 16>
3658 LookupResults.reserve(Map->size());
3659 for (auto &Entry : *Map)
3660 LookupResults.push_back(
3661 std::make_pair(Entry.first, Entry.second.getLookupResult()));
3664 std::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first());
3665 for (auto &NameAndResult : LookupResults) {
3666 DeclarationName Name = NameAndResult.first;
3667 DeclContext::lookup_result Result = NameAndResult.second;
3668 if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
3669 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
3670 // We have to work around a name lookup bug here where negative lookup
3671 // results for these names get cached in namespace lookup tables (these
3672 // names should never be looked up in a namespace).
3673 assert(Result.empty() && "Cannot have a constructor or conversion "
3674 "function name in a namespace!");
3678 for (NamedDecl *ND : Result)
3679 if (!ND->isFromASTFile())
3686 if (DC->getPrimaryContext() != DC)
3689 // Skip contexts which don't support name lookup.
3690 if (!DC->isLookupContext())
3693 // If not in C++, we perform name lookup for the translation unit via the
3694 // IdentifierInfo chains, don't bother to build a visible-declarations table.
3695 if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus)
3698 // Serialize the contents of the mapping used for lookup. Note that,
3699 // although we have two very different code paths, the serialized
3700 // representation is the same for both cases: a declaration name,
3701 // followed by a size, followed by references to the visible
3702 // declarations that have that name.
3703 uint64_t Offset = Stream.GetCurrentBitNo();
3704 StoredDeclsMap *Map = DC->buildLookup();
3705 if (!Map || Map->empty())
3708 // Create the on-disk hash table in a buffer.
3709 SmallString<4096> LookupTable;
3710 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable);
3712 // Write the lookup table
3714 Record.push_back(DECL_CONTEXT_VISIBLE);
3715 Record.push_back(BucketOffset);
3716 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
3718 ++NumVisibleDeclContexts;
3722 /// \brief Write an UPDATE_VISIBLE block for the given context.
3724 /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
3725 /// DeclContext in a dependent AST file. As such, they only exist for the TU
3726 /// (in C++), for namespaces, and for classes with forward-declared unscoped
3727 /// enumeration members (in C++11).
3728 void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
3729 StoredDeclsMap *Map = DC->getLookupPtr();
3730 if (!Map || Map->empty())
3733 // Create the on-disk hash table in a buffer.
3734 SmallString<4096> LookupTable;
3735 uint32_t BucketOffset = GenerateNameLookupTable(DC, LookupTable);
3737 // If we're updating a namespace, select a key declaration as the key for the
3738 // update record; those are the only ones that will be checked on reload.
3739 if (isa<NamespaceDecl>(DC))
3740 DC = cast<DeclContext>(Chain->getKeyDeclaration(cast<Decl>(DC)));
3742 // Write the lookup table
3744 Record.push_back(UPDATE_VISIBLE);
3745 Record.push_back(getDeclID(cast<Decl>(DC)));
3746 Record.push_back(BucketOffset);
3747 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable);
3750 /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions.
3751 void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) {
3753 Record.push_back(Opts.fp_contract);
3754 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record);
3757 /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions.
3758 void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
3759 if (!SemaRef.Context.getLangOpts().OpenCL)
3762 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions();
3764 #define OPENCLEXT(nm) Record.push_back(Opts.nm);
3765 #include "clang/Basic/OpenCLExtensions.def"
3766 Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
3769 void ASTWriter::WriteRedeclarations() {
3770 RecordData LocalRedeclChains;
3771 SmallVector<serialization::LocalRedeclarationsInfo, 2> LocalRedeclsMap;
3773 for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) {
3774 const Decl *Key = Redeclarations[I];
3775 assert((Chain ? Chain->getKeyDeclaration(Key) == Key
3776 : Key->isFirstDecl()) &&
3777 "not the key declaration");
3779 const Decl *First = Key->getCanonicalDecl();
3780 const Decl *MostRecent = First->getMostRecentDecl();
3782 assert((getDeclID(First) >= NUM_PREDEF_DECL_IDS || First == Key) &&
3783 "should not have imported key decls for predefined decl");
3785 // If we only have a single declaration, there is no point in storing
3786 // a redeclaration chain.
3787 if (First == MostRecent)
3790 unsigned Offset = LocalRedeclChains.size();
3792 LocalRedeclChains.push_back(0); // Placeholder for the size.
3794 // Collect the set of local redeclarations of this declaration.
3795 for (const Decl *Prev = MostRecent; Prev;
3796 Prev = Prev->getPreviousDecl()) {
3797 if (!Prev->isFromASTFile() && Prev != Key) {
3798 AddDeclRef(Prev, LocalRedeclChains);
3803 LocalRedeclChains[Offset] = Size;
3805 // Reverse the set of local redeclarations, so that we store them in
3806 // order (since we found them in reverse order).
3807 std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end());
3809 // Add the mapping from the first ID from the AST to the set of local
3811 LocalRedeclarationsInfo Info = { getDeclID(Key), Offset };
3812 LocalRedeclsMap.push_back(Info);
3814 assert(N == Redeclarations.size() &&
3815 "Deserialized a declaration we shouldn't have");
3818 if (LocalRedeclChains.empty())
3821 // Sort the local redeclarations map by the first declaration ID,
3822 // since the reader will be performing binary searches on this information.
3823 llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end());
3825 // Emit the local redeclarations map.
3826 using namespace llvm;
3827 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3828 Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP));
3829 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
3830 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3831 unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
3834 Record.push_back(LOCAL_REDECLARATIONS_MAP);
3835 Record.push_back(LocalRedeclsMap.size());
3836 Stream.EmitRecordWithBlob(AbbrevID, Record,
3837 reinterpret_cast<char*>(LocalRedeclsMap.data()),
3838 LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo));
3840 // Emit the redeclaration chains.
3841 Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains);
3844 void ASTWriter::WriteObjCCategories() {
3845 SmallVector<ObjCCategoriesInfo, 2> CategoriesMap;
3846 RecordData Categories;
3848 for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
3850 unsigned StartIndex = Categories.size();
3852 ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I];
3854 // Allocate space for the size.
3855 Categories.push_back(0);
3857 // Add the categories.
3858 for (ObjCInterfaceDecl::known_categories_iterator
3859 Cat = Class->known_categories_begin(),
3860 CatEnd = Class->known_categories_end();
3861 Cat != CatEnd; ++Cat, ++Size) {
3862 assert(getDeclID(*Cat) != 0 && "Bogus category");
3863 AddDeclRef(*Cat, Categories);
3867 Categories[StartIndex] = Size;
3869 // Record this interface -> category map.
3870 ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex };
3871 CategoriesMap.push_back(CatInfo);
3874 // Sort the categories map by the definition ID, since the reader will be
3875 // performing binary searches on this information.
3876 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
3878 // Emit the categories map.
3879 using namespace llvm;
3880 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3881 Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP));
3882 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
3883 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3884 unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
3887 Record.push_back(OBJC_CATEGORIES_MAP);
3888 Record.push_back(CategoriesMap.size());
3889 Stream.EmitRecordWithBlob(AbbrevID, Record,
3890 reinterpret_cast<char*>(CategoriesMap.data()),
3891 CategoriesMap.size() * sizeof(ObjCCategoriesInfo));
3893 // Emit the category lists.
3894 Stream.EmitRecord(OBJC_CATEGORIES, Categories);
3897 void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) {
3898 Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap;
3904 for (auto LPTMapEntry : LPTMap) {
3905 const FunctionDecl *FD = LPTMapEntry.first;
3906 LateParsedTemplate *LPT = LPTMapEntry.second;
3907 AddDeclRef(FD, Record);
3908 AddDeclRef(LPT->D, Record);
3909 Record.push_back(LPT->Toks.size());
3911 for (CachedTokens::iterator TokIt = LPT->Toks.begin(),
3912 TokEnd = LPT->Toks.end();
3913 TokIt != TokEnd; ++TokIt) {
3914 AddToken(*TokIt, Record);
3917 Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record);
3920 /// \brief Write the state of 'pragma clang optimize' at the end of the module.
3921 void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) {
3923 SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation();
3924 AddSourceLocation(PragmaLoc, Record);
3925 Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record);
3928 //===----------------------------------------------------------------------===//
3929 // General Serialization Routines
3930 //===----------------------------------------------------------------------===//
3932 /// \brief Write a record containing the given attributes.
3933 void ASTWriter::WriteAttributes(ArrayRef<const Attr*> Attrs,
3934 RecordDataImpl &Record) {
3935 Record.push_back(Attrs.size());
3936 for (ArrayRef<const Attr *>::iterator i = Attrs.begin(),
3937 e = Attrs.end(); i != e; ++i){
3939 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
3940 AddSourceRange(A->getRange(), Record);
3942 #include "clang/Serialization/AttrPCHWrite.inc"
3947 void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) {
3948 AddSourceLocation(Tok.getLocation(), Record);
3949 Record.push_back(Tok.getLength());
3951 // FIXME: When reading literal tokens, reconstruct the literal pointer
3953 AddIdentifierRef(Tok.getIdentifierInfo(), Record);
3954 // FIXME: Should translate token kind to a stable encoding.
3955 Record.push_back(Tok.getKind());
3956 // FIXME: Should translate token flags to a stable encoding.
3957 Record.push_back(Tok.getFlags());
3960 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) {
3961 Record.push_back(Str.size());
3962 Record.insert(Record.end(), Str.begin(), Str.end());
3965 bool ASTWriter::PreparePathForOutput(SmallVectorImpl<char> &Path) {
3966 assert(Context && "should have context when outputting path");
3969 cleanPathForOutput(Context->getSourceManager().getFileManager(), Path);
3971 // Remove a prefix to make the path relative, if relevant.
3972 const char *PathBegin = Path.data();
3973 const char *PathPtr =
3974 adjustFilenameForRelocatableAST(PathBegin, BaseDirectory);
3975 if (PathPtr != PathBegin) {
3976 Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin));
3983 void ASTWriter::AddPath(StringRef Path, RecordDataImpl &Record) {
3984 SmallString<128> FilePath(Path);
3985 PreparePathForOutput(FilePath);
3986 AddString(FilePath, Record);
3989 void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataImpl &Record,
3991 SmallString<128> FilePath(Path);
3992 PreparePathForOutput(FilePath);
3993 Stream.EmitRecordWithBlob(Abbrev, Record, FilePath);
3996 void ASTWriter::AddVersionTuple(const VersionTuple &Version,
3997 RecordDataImpl &Record) {
3998 Record.push_back(Version.getMajor());
3999 if (Optional<unsigned> Minor = Version.getMinor())
4000 Record.push_back(*Minor + 1);
4002 Record.push_back(0);
4003 if (Optional<unsigned> Subminor = Version.getSubminor())
4004 Record.push_back(*Subminor + 1);
4006 Record.push_back(0);
4009 /// \brief Note that the identifier II occurs at the given offset
4010 /// within the identifier table.
4011 void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
4012 IdentID ID = IdentifierIDs[II];
4013 // Only store offsets new to this AST file. Other identifier names are looked
4014 // up earlier in the chain and thus don't need an offset.
4015 if (ID >= FirstIdentID)
4016 IdentifierOffsets[ID - FirstIdentID] = Offset;
4019 /// \brief Note that the selector Sel occurs at the given offset
4020 /// within the method pool/selector table.
4021 void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
4022 unsigned ID = SelectorIDs[Sel];
4023 assert(ID && "Unknown selector");
4024 // Don't record offsets for selectors that are also available in a different
4026 if (ID < FirstSelectorID)
4028 SelectorOffsets[ID - FirstSelectorID] = Offset;
4031 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream)
4032 : Stream(Stream), Context(nullptr), PP(nullptr), Chain(nullptr),
4033 WritingModule(nullptr), WritingAST(false),
4034 DoneWritingDeclsAndTypes(false), ASTHasCompilerErrors(false),
4035 FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID),
4036 FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID),
4037 FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID),
4038 FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID),
4039 FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS),
4040 NextSubmoduleID(FirstSubmoduleID),
4041 FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID),
4042 CollectedStmts(&StmtsToEmit), NumStatements(0), NumMacros(0),
4043 NumLexicalDeclContexts(0), NumVisibleDeclContexts(0),
4044 NextCXXBaseSpecifiersID(1), NextCXXCtorInitializersID(1),
4045 TypeExtQualAbbrev(0),
4046 TypeFunctionProtoAbbrev(0), DeclParmVarAbbrev(0),
4047 DeclContextLexicalAbbrev(0), DeclContextVisibleLookupAbbrev(0),
4048 UpdateVisibleAbbrev(0), DeclRecordAbbrev(0), DeclTypedefAbbrev(0),
4049 DeclVarAbbrev(0), DeclFieldAbbrev(0), DeclEnumAbbrev(0),
4050 DeclObjCIvarAbbrev(0), DeclCXXMethodAbbrev(0), DeclRefExprAbbrev(0),
4051 CharacterLiteralAbbrev(0), IntegerLiteralAbbrev(0),
4052 ExprImplicitCastAbbrev(0) {}
4054 ASTWriter::~ASTWriter() {
4055 llvm::DeleteContainerSeconds(FileDeclIDs);
4058 const LangOptions &ASTWriter::getLangOpts() const {
4059 assert(WritingAST && "can't determine lang opts when not writing AST");
4060 return Context->getLangOpts();
4063 void ASTWriter::WriteAST(Sema &SemaRef,
4064 const std::string &OutputFile,
4065 Module *WritingModule, StringRef isysroot,
4069 ASTHasCompilerErrors = hasErrors;
4071 // Emit the file header.
4072 Stream.Emit((unsigned)'C', 8);
4073 Stream.Emit((unsigned)'P', 8);
4074 Stream.Emit((unsigned)'C', 8);
4075 Stream.Emit((unsigned)'H', 8);
4077 WriteBlockInfoBlock();
4079 Context = &SemaRef.Context;
4081 this->WritingModule = WritingModule;
4082 WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule);
4085 this->WritingModule = nullptr;
4086 this->BaseDirectory.clear();
4091 template<typename Vector>
4092 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
4093 ASTWriter::RecordData &Record) {
4094 for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end();
4096 Writer.AddDeclRef(*I, Record);
4100 void ASTWriter::WriteASTCore(Sema &SemaRef,
4102 const std::string &OutputFile,
4103 Module *WritingModule) {
4104 using namespace llvm;
4106 bool isModule = WritingModule != nullptr;
4108 // Make sure that the AST reader knows to finalize itself.
4110 Chain->finalizeForWriting();
4112 ASTContext &Context = SemaRef.Context;
4113 Preprocessor &PP = SemaRef.PP;
4115 // Set up predefined declaration IDs.
4116 auto RegisterPredefDecl = [&] (Decl *D, PredefinedDeclIDs ID) {
4118 assert(D->isCanonicalDecl() && "predefined decl is not canonical");
4120 if (D->getMostRecentDecl() != D)
4121 Redeclarations.push_back(D);
4124 RegisterPredefDecl(Context.getTranslationUnitDecl(),
4125 PREDEF_DECL_TRANSLATION_UNIT_ID);
4126 RegisterPredefDecl(Context.ObjCIdDecl, PREDEF_DECL_OBJC_ID_ID);
4127 RegisterPredefDecl(Context.ObjCSelDecl, PREDEF_DECL_OBJC_SEL_ID);
4128 RegisterPredefDecl(Context.ObjCClassDecl, PREDEF_DECL_OBJC_CLASS_ID);
4129 RegisterPredefDecl(Context.ObjCProtocolClassDecl,
4130 PREDEF_DECL_OBJC_PROTOCOL_ID);
4131 RegisterPredefDecl(Context.Int128Decl, PREDEF_DECL_INT_128_ID);
4132 RegisterPredefDecl(Context.UInt128Decl, PREDEF_DECL_UNSIGNED_INT_128_ID);
4133 RegisterPredefDecl(Context.ObjCInstanceTypeDecl,
4134 PREDEF_DECL_OBJC_INSTANCETYPE_ID);
4135 RegisterPredefDecl(Context.BuiltinVaListDecl, PREDEF_DECL_BUILTIN_VA_LIST_ID);
4136 RegisterPredefDecl(Context.ExternCContext, PREDEF_DECL_EXTERN_C_CONTEXT_ID);
4138 // Build a record containing all of the tentative definitions in this file, in
4139 // TentativeDefinitions order. Generally, this record will be empty for
4141 RecordData TentativeDefinitions;
4142 AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
4144 // Build a record containing all of the file scoped decls in this file.
4145 RecordData UnusedFileScopedDecls;
4147 AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls,
4148 UnusedFileScopedDecls);
4150 // Build a record containing all of the delegating constructors we still need
4152 RecordData DelegatingCtorDecls;
4154 AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls);
4156 // Write the set of weak, undeclared identifiers. We always write the
4157 // entire table, since later PCH files in a PCH chain are only interested in
4158 // the results at the end of the chain.
4159 RecordData WeakUndeclaredIdentifiers;
4160 for (auto &WeakUndeclaredIdentifier : SemaRef.WeakUndeclaredIdentifiers) {
4161 IdentifierInfo *II = WeakUndeclaredIdentifier.first;
4162 WeakInfo &WI = WeakUndeclaredIdentifier.second;
4163 AddIdentifierRef(II, WeakUndeclaredIdentifiers);
4164 AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers);
4165 AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers);
4166 WeakUndeclaredIdentifiers.push_back(WI.getUsed());
4169 // Build a record containing all of the ext_vector declarations.
4170 RecordData ExtVectorDecls;
4171 AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls);
4173 // Build a record containing all of the VTable uses information.
4174 RecordData VTableUses;
4175 if (!SemaRef.VTableUses.empty()) {
4176 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
4177 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
4178 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
4179 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
4183 // Build a record containing all of the UnusedLocalTypedefNameCandidates.
4184 RecordData UnusedLocalTypedefNameCandidates;
4185 for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates)
4186 AddDeclRef(TD, UnusedLocalTypedefNameCandidates);
4188 // Build a record containing all of pending implicit instantiations.
4189 RecordData PendingInstantiations;
4190 for (std::deque<Sema::PendingImplicitInstantiation>::iterator
4191 I = SemaRef.PendingInstantiations.begin(),
4192 N = SemaRef.PendingInstantiations.end(); I != N; ++I) {
4193 AddDeclRef(I->first, PendingInstantiations);
4194 AddSourceLocation(I->second, PendingInstantiations);
4196 assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
4197 "There are local ones at end of translation unit!");
4199 // Build a record containing some declaration references.
4200 RecordData SemaDeclRefs;
4201 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) {
4202 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
4203 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
4206 RecordData CUDASpecialDeclRefs;
4207 if (Context.getcudaConfigureCallDecl()) {
4208 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs);
4211 // Build a record containing all of the known namespaces.
4212 RecordData KnownNamespaces;
4213 for (llvm::MapVector<NamespaceDecl*, bool>::iterator
4214 I = SemaRef.KnownNamespaces.begin(),
4215 IEnd = SemaRef.KnownNamespaces.end();
4218 AddDeclRef(I->first, KnownNamespaces);
4221 // Build a record of all used, undefined objects that require definitions.
4222 RecordData UndefinedButUsed;
4224 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
4225 SemaRef.getUndefinedButUsed(Undefined);
4226 for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
4227 I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
4228 AddDeclRef(I->first, UndefinedButUsed);
4229 AddSourceLocation(I->second, UndefinedButUsed);
4232 // Build a record containing all delete-expressions that we would like to
4233 // analyze later in AST.
4234 RecordData DeleteExprsToAnalyze;
4236 for (const auto &DeleteExprsInfo :
4237 SemaRef.getMismatchingDeleteExpressions()) {
4238 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze);
4239 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size());
4240 for (const auto &DeleteLoc : DeleteExprsInfo.second) {
4241 AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze);
4242 DeleteExprsToAnalyze.push_back(DeleteLoc.second);
4246 // Write the control block
4247 WriteControlBlock(PP, Context, isysroot, OutputFile);
4249 // Write the remaining AST contents.
4251 Stream.EnterSubblock(AST_BLOCK_ID, 5);
4253 // This is so that older clang versions, before the introduction
4254 // of the control block, can read and reject the newer PCH format.
4256 Record.push_back(VERSION_MAJOR);
4257 Stream.EmitRecord(METADATA_OLD_FORMAT, Record);
4259 // Create a lexical update block containing all of the declarations in the
4260 // translation unit that do not come from other AST files.
4261 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
4262 SmallVector<KindDeclIDPair, 64> NewGlobalDecls;
4263 for (const auto *I : TU->noload_decls()) {
4264 if (!I->isFromASTFile())
4265 NewGlobalDecls.push_back(std::make_pair(I->getKind(), GetDeclRef(I)));
4268 llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev();
4269 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
4270 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4271 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv);
4273 Record.push_back(TU_UPDATE_LEXICAL);
4274 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
4275 bytes(NewGlobalDecls));
4277 // And a visible updates block for the translation unit.
4278 Abv = new llvm::BitCodeAbbrev();
4279 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
4280 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
4281 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32));
4282 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
4283 UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv);
4284 WriteDeclContextVisibleUpdate(TU);
4286 // If we have any extern "C" names, write out a visible update for them.
4287 if (Context.ExternCContext)
4288 WriteDeclContextVisibleUpdate(Context.ExternCContext);
4290 // If the translation unit has an anonymous namespace, and we don't already
4291 // have an update block for it, write it as an update block.
4292 // FIXME: Why do we not do this if there's already an update block?
4293 if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
4294 ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
4296 Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS));
4299 // Add update records for all mangling numbers and static local numbers.
4300 // These aren't really update records, but this is a convenient way of
4301 // tagging this rare extra data onto the declarations.
4302 for (const auto &Number : Context.MangleNumbers)
4303 if (!Number.first->isFromASTFile())
4304 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER,
4306 for (const auto &Number : Context.StaticLocalNumbers)
4307 if (!Number.first->isFromASTFile())
4308 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER,
4311 // Make sure visible decls, added to DeclContexts previously loaded from
4312 // an AST file, are registered for serialization.
4313 for (SmallVectorImpl<const Decl *>::iterator
4314 I = UpdatingVisibleDecls.begin(),
4315 E = UpdatingVisibleDecls.end(); I != E; ++I) {
4319 // Make sure all decls associated with an identifier are registered for
4321 llvm::SmallVector<const IdentifierInfo*, 256> IIs;
4322 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
4323 IDEnd = PP.getIdentifierTable().end();
4324 ID != IDEnd; ++ID) {
4325 const IdentifierInfo *II = ID->second;
4326 if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization())
4329 // Sort the identifiers to visit based on their name.
4330 std::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>());
4331 for (const IdentifierInfo *II : IIs) {
4332 for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II),
4333 DEnd = SemaRef.IdResolver.end();
4339 // Form the record of special types.
4340 RecordData SpecialTypes;
4341 AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
4342 AddTypeRef(Context.getFILEType(), SpecialTypes);
4343 AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
4344 AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
4345 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
4346 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
4347 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
4348 AddTypeRef(Context.getucontext_tType(), SpecialTypes);
4351 // Write the mapping information describing our module dependencies and how
4352 // each of those modules were mapped into our own offset/ID space, so that
4353 // the reader can build the appropriate mapping to its own offset/ID space.
4354 // The map consists solely of a blob with the following format:
4355 // *(module-name-len:i16 module-name:len*i8
4356 // source-location-offset:i32
4357 // identifier-id:i32
4358 // preprocessed-entity-id:i32
4359 // macro-definition-id:i32
4362 // declaration-id:i32
4363 // c++-base-specifiers-id:i32
4366 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
4367 Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
4368 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
4369 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev);
4370 SmallString<2048> Buffer;
4372 llvm::raw_svector_ostream Out(Buffer);
4373 for (ModuleFile *M : Chain->ModuleMgr) {
4374 using namespace llvm::support;
4375 endian::Writer<little> LE(Out);
4376 StringRef FileName = M->FileName;
4377 LE.write<uint16_t>(FileName.size());
4378 Out.write(FileName.data(), FileName.size());
4380 // Note: if a base ID was uint max, it would not be possible to load
4381 // another module after it or have more than one entity inside it.
4382 uint32_t None = std::numeric_limits<uint32_t>::max();
4384 auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) {
4385 assert(BaseID < std::numeric_limits<uint32_t>::max() && "base id too high");
4387 LE.write<uint32_t>(BaseID);
4389 LE.write<uint32_t>(None);
4392 // These values should be unique within a chain, since they will be read
4393 // as keys into ContinuousRangeMaps.
4394 writeBaseIDOrNone(M->SLocEntryBaseOffset, M->LocalNumSLocEntries);
4395 writeBaseIDOrNone(M->BaseIdentifierID, M->LocalNumIdentifiers);
4396 writeBaseIDOrNone(M->BaseMacroID, M->LocalNumMacros);
4397 writeBaseIDOrNone(M->BasePreprocessedEntityID,
4398 M->NumPreprocessedEntities);
4399 writeBaseIDOrNone(M->BaseSubmoduleID, M->LocalNumSubmodules);
4400 writeBaseIDOrNone(M->BaseSelectorID, M->LocalNumSelectors);
4401 writeBaseIDOrNone(M->BaseDeclID, M->LocalNumDecls);
4402 writeBaseIDOrNone(M->BaseTypeIndex, M->LocalNumTypes);
4406 Record.push_back(MODULE_OFFSET_MAP);
4407 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
4408 Buffer.data(), Buffer.size());
4411 RecordData DeclUpdatesOffsetsRecord;
4413 // Keep writing types, declarations, and declaration update records
4414 // until we've emitted all of them.
4415 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, /*bits for abbreviations*/5);
4418 for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(),
4419 E = DeclsToRewrite.end();
4421 DeclTypesToEmit.push(const_cast<Decl*>(*I));
4423 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord);
4424 while (!DeclTypesToEmit.empty()) {
4425 DeclOrType DOT = DeclTypesToEmit.front();
4426 DeclTypesToEmit.pop();
4428 WriteType(DOT.getType());
4430 WriteDecl(Context, DOT.getDecl());
4432 } while (!DeclUpdates.empty());
4435 DoneWritingDeclsAndTypes = true;
4437 // These things can only be done once we've written out decls and types.
4438 WriteTypeDeclOffsets();
4439 if (!DeclUpdatesOffsetsRecord.empty())
4440 Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord);
4441 WriteCXXBaseSpecifiersOffsets();
4442 WriteCXXCtorInitializersOffsets();
4443 WriteFileDeclIDsMap();
4444 WriteSourceManagerBlock(Context.getSourceManager(), PP);
4447 WritePreprocessor(PP, isModule);
4448 WriteHeaderSearch(PP.getHeaderSearchInfo());
4449 WriteSelectors(SemaRef);
4450 WriteReferencedSelectorsPool(SemaRef);
4451 WriteIdentifierTable(PP, SemaRef.IdResolver, isModule);
4452 WriteFPPragmaOptions(SemaRef.getFPOptions());
4453 WriteOpenCLExtensions(SemaRef);
4454 WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule);
4456 // If we're emitting a module, write out the submodule information.
4458 WriteSubmodules(WritingModule);
4460 Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes);
4462 // Write the record containing external, unnamed definitions.
4463 if (!EagerlyDeserializedDecls.empty())
4464 Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls);
4466 // Write the record containing tentative definitions.
4467 if (!TentativeDefinitions.empty())
4468 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
4470 // Write the record containing unused file scoped decls.
4471 if (!UnusedFileScopedDecls.empty())
4472 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
4474 // Write the record containing weak undeclared identifiers.
4475 if (!WeakUndeclaredIdentifiers.empty())
4476 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
4477 WeakUndeclaredIdentifiers);
4479 // Write the record containing ext_vector type names.
4480 if (!ExtVectorDecls.empty())
4481 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
4483 // Write the record containing VTable uses information.
4484 if (!VTableUses.empty())
4485 Stream.EmitRecord(VTABLE_USES, VTableUses);
4487 // Write the record containing potentially unused local typedefs.
4488 if (!UnusedLocalTypedefNameCandidates.empty())
4489 Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES,
4490 UnusedLocalTypedefNameCandidates);
4492 // Write the record containing pending implicit instantiations.
4493 if (!PendingInstantiations.empty())
4494 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
4496 // Write the record containing declaration references of Sema.
4497 if (!SemaDeclRefs.empty())
4498 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
4500 // Write the record containing CUDA-specific declaration references.
4501 if (!CUDASpecialDeclRefs.empty())
4502 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs);
4504 // Write the delegating constructors.
4505 if (!DelegatingCtorDecls.empty())
4506 Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls);
4508 // Write the known namespaces.
4509 if (!KnownNamespaces.empty())
4510 Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces);
4512 // Write the undefined internal functions and variables, and inline functions.
4513 if (!UndefinedButUsed.empty())
4514 Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed);
4516 if (!DeleteExprsToAnalyze.empty())
4517 Stream.EmitRecord(DELETE_EXPRS_TO_ANALYZE, DeleteExprsToAnalyze);
4519 // Write the visible updates to DeclContexts.
4520 for (auto *DC : UpdatedDeclContexts)
4521 WriteDeclContextVisibleUpdate(DC);
4523 if (!WritingModule) {
4524 // Write the submodules that were imported, if any.
4528 ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {}
4530 llvm::SmallVector<ModuleInfo, 64> Imports;
4531 for (const auto *I : Context.local_imports()) {
4532 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
4533 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
4534 I->getImportedModule()));
4537 if (!Imports.empty()) {
4538 auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) {
4541 auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) {
4542 return A.ID == B.ID;
4545 // Sort and deduplicate module IDs.
4546 std::sort(Imports.begin(), Imports.end(), Cmp);
4547 Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq),
4550 RecordData ImportedModules;
4551 for (const auto &Import : Imports) {
4552 ImportedModules.push_back(Import.ID);
4553 // FIXME: If the module has macros imported then later has declarations
4554 // imported, this location won't be the right one as a location for the
4555 // declaration imports.
4556 AddSourceLocation(PP.getModuleImportLoc(Import.M), ImportedModules);
4559 Stream.EmitRecord(IMPORTED_MODULES, ImportedModules);
4563 WriteDeclReplacementsBlock();
4564 WriteRedeclarations();
4565 WriteObjCCategories();
4566 WriteLateParsedTemplates(SemaRef);
4568 WriteOptimizePragmaOptions(SemaRef);
4570 // Some simple statistics
4572 Record.push_back(NumStatements);
4573 Record.push_back(NumMacros);
4574 Record.push_back(NumLexicalDeclContexts);
4575 Record.push_back(NumVisibleDeclContexts);
4576 Stream.EmitRecord(STATISTICS, Record);
4580 void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) {
4581 if (DeclUpdates.empty())
4584 DeclUpdateMap LocalUpdates;
4585 LocalUpdates.swap(DeclUpdates);
4587 for (auto &DeclUpdate : LocalUpdates) {
4588 const Decl *D = DeclUpdate.first;
4590 continue; // The decl will be written completely,no need to store updates.
4592 bool HasUpdatedBody = false;
4594 for (auto &Update : DeclUpdate.second) {
4595 DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind();
4597 Record.push_back(Kind);
4599 case UPD_CXX_ADDED_IMPLICIT_MEMBER:
4600 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
4601 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE:
4602 assert(Update.getDecl() && "no decl to add?");
4603 Record.push_back(GetDeclRef(Update.getDecl()));
4606 case UPD_CXX_ADDED_FUNCTION_DEFINITION:
4607 // An updated body is emitted last, so that the reader doesn't need
4608 // to skip over the lazy body to reach statements for other records.
4610 HasUpdatedBody = true;
4613 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
4614 AddSourceLocation(Update.getLoc(), Record);
4617 case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
4618 auto *RD = cast<CXXRecordDecl>(D);
4619 UpdatedDeclContexts.insert(RD->getPrimaryContext());
4620 AddCXXDefinitionData(RD, Record);
4621 Record.push_back(WriteDeclContextLexicalBlock(
4622 *Context, const_cast<CXXRecordDecl *>(RD)));
4624 // This state is sometimes updated by template instantiation, when we
4625 // switch from the specialization referring to the template declaration
4626 // to it referring to the template definition.
4627 if (auto *MSInfo = RD->getMemberSpecializationInfo()) {
4628 Record.push_back(MSInfo->getTemplateSpecializationKind());
4629 AddSourceLocation(MSInfo->getPointOfInstantiation(), Record);
4631 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
4632 Record.push_back(Spec->getTemplateSpecializationKind());
4633 AddSourceLocation(Spec->getPointOfInstantiation(), Record);
4635 // The instantiation might have been resolved to a partial
4636 // specialization. If so, record which one.
4637 auto From = Spec->getInstantiatedFrom();
4638 if (auto PartialSpec =
4639 From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) {
4640 Record.push_back(true);
4641 AddDeclRef(PartialSpec, Record);
4642 AddTemplateArgumentList(&Spec->getTemplateInstantiationArgs(),
4645 Record.push_back(false);
4648 Record.push_back(RD->getTagKind());
4649 AddSourceLocation(RD->getLocation(), Record);
4650 AddSourceLocation(RD->getLocStart(), Record);
4651 AddSourceLocation(RD->getRBraceLoc(), Record);
4653 // Instantiation may change attributes; write them all out afresh.
4654 Record.push_back(D->hasAttrs());
4656 WriteAttributes(llvm::makeArrayRef(D->getAttrs().begin(),
4657 D->getAttrs().size()), Record);
4659 // FIXME: Ensure we don't get here for explicit instantiations.
4663 case UPD_CXX_RESOLVED_DTOR_DELETE:
4664 AddDeclRef(Update.getDecl(), Record);
4667 case UPD_CXX_RESOLVED_EXCEPTION_SPEC:
4670 cast<FunctionDecl>(D)->getType()->castAs<FunctionProtoType>(),
4674 case UPD_CXX_DEDUCED_RETURN_TYPE:
4675 Record.push_back(GetOrCreateTypeID(Update.getType()));
4678 case UPD_DECL_MARKED_USED:
4681 case UPD_MANGLING_NUMBER:
4682 case UPD_STATIC_LOCAL_NUMBER:
4683 Record.push_back(Update.getNumber());
4686 case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
4687 AddSourceRange(D->getAttr<OMPThreadPrivateDeclAttr>()->getRange(),
4691 case UPD_DECL_EXPORTED:
4692 Record.push_back(getSubmoduleID(Update.getModule()));
4695 case UPD_ADDED_ATTR_TO_RECORD:
4696 WriteAttributes(llvm::makeArrayRef(Update.getAttr()), Record);
4701 if (HasUpdatedBody) {
4702 const FunctionDecl *Def = cast<FunctionDecl>(D);
4703 Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION);
4704 Record.push_back(Def->isInlined());
4705 AddSourceLocation(Def->getInnerLocStart(), Record);
4706 AddFunctionDefinition(Def, Record);
4709 OffsetsRecord.push_back(GetDeclRef(D));
4710 OffsetsRecord.push_back(Stream.GetCurrentBitNo());
4712 Stream.EmitRecord(DECL_UPDATES, Record);
4714 FlushPendingAfterDecl();
4718 void ASTWriter::WriteDeclReplacementsBlock() {
4719 if (ReplacedDecls.empty())
4723 for (SmallVectorImpl<ReplacedDeclInfo>::iterator
4724 I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) {
4725 Record.push_back(I->ID);
4726 Record.push_back(I->Offset);
4727 Record.push_back(I->Loc);
4729 Stream.EmitRecord(DECL_REPLACEMENTS, Record);
4732 void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
4733 Record.push_back(Loc.getRawEncoding());
4736 void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
4737 AddSourceLocation(Range.getBegin(), Record);
4738 AddSourceLocation(Range.getEnd(), Record);
4741 void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) {
4742 Record.push_back(Value.getBitWidth());
4743 const uint64_t *Words = Value.getRawData();
4744 Record.append(Words, Words + Value.getNumWords());
4747 void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) {
4748 Record.push_back(Value.isUnsigned());
4749 AddAPInt(Value, Record);
4752 void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) {
4753 AddAPInt(Value.bitcastToAPInt(), Record);
4756 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
4757 Record.push_back(getIdentifierRef(II));
4760 IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
4764 IdentID &ID = IdentifierIDs[II];
4770 MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) {
4771 // Don't emit builtin macros like __LINE__ to the AST file unless they
4772 // have been redefined by the header (in which case they are not
4774 if (!MI || MI->isBuiltinMacro())
4777 MacroID &ID = MacroIDs[MI];
4780 MacroInfoToEmitData Info = { Name, MI, ID };
4781 MacroInfosToEmit.push_back(Info);
4786 MacroID ASTWriter::getMacroID(MacroInfo *MI) {
4787 if (!MI || MI->isBuiltinMacro())
4790 assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!");
4791 return MacroIDs[MI];
4794 uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) {
4795 return IdentMacroDirectivesOffsetMap.lookup(Name);
4798 void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) {
4799 Record.push_back(getSelectorRef(SelRef));
4802 SelectorID ASTWriter::getSelectorRef(Selector Sel) {
4803 if (Sel.getAsOpaquePtr() == nullptr) {
4807 SelectorID SID = SelectorIDs[Sel];
4808 if (SID == 0 && Chain) {
4809 // This might trigger a ReadSelector callback, which will set the ID for
4811 Chain->LoadSelector(Sel);
4812 SID = SelectorIDs[Sel];
4815 SID = NextSelectorID++;
4816 SelectorIDs[Sel] = SID;
4821 void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) {
4822 AddDeclRef(Temp->getDestructor(), Record);
4825 void ASTWriter::AddCXXCtorInitializersRef(ArrayRef<CXXCtorInitializer *> Inits,
4826 RecordDataImpl &Record) {
4827 assert(!Inits.empty() && "Empty ctor initializer sets are not recorded");
4828 CXXCtorInitializersToWrite.push_back(
4829 QueuedCXXCtorInitializers(NextCXXCtorInitializersID, Inits));
4830 Record.push_back(NextCXXCtorInitializersID++);
4833 void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases,
4834 CXXBaseSpecifier const *BasesEnd,
4835 RecordDataImpl &Record) {
4836 assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded");
4837 CXXBaseSpecifiersToWrite.push_back(
4838 QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID,
4840 Record.push_back(NextCXXBaseSpecifiersID++);
4843 void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
4844 const TemplateArgumentLocInfo &Arg,
4845 RecordDataImpl &Record) {
4847 case TemplateArgument::Expression:
4848 AddStmt(Arg.getAsExpr());
4850 case TemplateArgument::Type:
4851 AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record);
4853 case TemplateArgument::Template:
4854 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
4855 AddSourceLocation(Arg.getTemplateNameLoc(), Record);
4857 case TemplateArgument::TemplateExpansion:
4858 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
4859 AddSourceLocation(Arg.getTemplateNameLoc(), Record);
4860 AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record);
4862 case TemplateArgument::Null:
4863 case TemplateArgument::Integral:
4864 case TemplateArgument::Declaration:
4865 case TemplateArgument::NullPtr:
4866 case TemplateArgument::Pack:
4867 // FIXME: Is this right?
4872 void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
4873 RecordDataImpl &Record) {
4874 AddTemplateArgument(Arg.getArgument(), Record);
4876 if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
4877 bool InfoHasSameExpr
4878 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
4879 Record.push_back(InfoHasSameExpr);
4880 if (InfoHasSameExpr)
4881 return; // Avoid storing the same expr twice.
4883 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(),
4887 void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
4888 RecordDataImpl &Record) {
4890 AddTypeRef(QualType(), Record);
4894 AddTypeLoc(TInfo->getTypeLoc(), Record);
4897 void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) {
4898 AddTypeRef(TL.getType(), Record);
4900 TypeLocWriter TLW(*this, Record);
4901 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
4905 void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) {
4906 Record.push_back(GetOrCreateTypeID(T));
4909 TypeID ASTWriter::GetOrCreateTypeID(QualType T) {
4911 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx {
4914 assert(!T.getLocalFastQualifiers());
4916 TypeIdx &Idx = TypeIdxs[T];
4917 if (Idx.getIndex() == 0) {
4918 if (DoneWritingDeclsAndTypes) {
4919 assert(0 && "New type seen after serializing all the types to emit!");
4923 // We haven't seen this type before. Assign it a new ID and put it
4924 // into the queue of types to emit.
4925 Idx = TypeIdx(NextTypeID++);
4926 DeclTypesToEmit.push(T);
4932 TypeID ASTWriter::getTypeID(QualType T) const {
4934 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx {
4937 assert(!T.getLocalFastQualifiers());
4939 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
4940 assert(I != TypeIdxs.end() && "Type not emitted!");
4945 void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) {
4946 Record.push_back(GetDeclRef(D));
4949 DeclID ASTWriter::GetDeclRef(const Decl *D) {
4950 assert(WritingAST && "Cannot request a declaration ID before AST writing");
4956 // If D comes from an AST file, its declaration ID is already known and
4958 if (D->isFromASTFile())
4959 return D->getGlobalID();
4961 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
4962 DeclID &ID = DeclIDs[D];
4964 if (DoneWritingDeclsAndTypes) {
4965 assert(0 && "New decl seen after serializing all the decls to emit!");
4969 // We haven't seen this declaration before. Give it a new ID and
4970 // enqueue it in the list of declarations to emit.
4972 DeclTypesToEmit.push(const_cast<Decl *>(D));
4978 DeclID ASTWriter::getDeclID(const Decl *D) {
4982 // If D comes from an AST file, its declaration ID is already known and
4984 if (D->isFromASTFile())
4985 return D->getGlobalID();
4987 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
4991 void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) {
4995 SourceLocation Loc = D->getLocation();
4996 if (Loc.isInvalid())
4999 // We only keep track of the file-level declarations of each file.
5000 if (!D->getLexicalDeclContext()->isFileContext())
5002 // FIXME: ParmVarDecls that are part of a function type of a parameter of
5003 // a function/objc method, should not have TU as lexical context.
5004 if (isa<ParmVarDecl>(D))
5007 SourceManager &SM = Context->getSourceManager();
5008 SourceLocation FileLoc = SM.getFileLoc(Loc);
5009 assert(SM.isLocalSourceLocation(FileLoc));
5012 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
5013 if (FID.isInvalid())
5015 assert(SM.getSLocEntry(FID).isFile());
5017 DeclIDInFileInfo *&Info = FileDeclIDs[FID];
5019 Info = new DeclIDInFileInfo();
5021 std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID);
5022 LocDeclIDsTy &Decls = Info->DeclIDs;
5024 if (Decls.empty() || Decls.back().first <= Offset) {
5025 Decls.push_back(LocDecl);
5029 LocDeclIDsTy::iterator I =
5030 std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first());
5032 Decls.insert(I, LocDecl);
5035 void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) {
5036 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc.
5037 Record.push_back(Name.getNameKind());
5038 switch (Name.getNameKind()) {
5039 case DeclarationName::Identifier:
5040 AddIdentifierRef(Name.getAsIdentifierInfo(), Record);
5043 case DeclarationName::ObjCZeroArgSelector:
5044 case DeclarationName::ObjCOneArgSelector:
5045 case DeclarationName::ObjCMultiArgSelector:
5046 AddSelectorRef(Name.getObjCSelector(), Record);
5049 case DeclarationName::CXXConstructorName:
5050 case DeclarationName::CXXDestructorName:
5051 case DeclarationName::CXXConversionFunctionName:
5052 AddTypeRef(Name.getCXXNameType(), Record);
5055 case DeclarationName::CXXOperatorName:
5056 Record.push_back(Name.getCXXOverloadedOperator());
5059 case DeclarationName::CXXLiteralOperatorName:
5060 AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record);
5063 case DeclarationName::CXXUsingDirective:
5064 // No extra data to emit
5069 unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) {
5070 assert(needsAnonymousDeclarationNumber(D) &&
5071 "expected an anonymous declaration");
5073 // Number the anonymous declarations within this context, if we've not
5075 auto It = AnonymousDeclarationNumbers.find(D);
5076 if (It == AnonymousDeclarationNumbers.end()) {
5077 auto *DC = D->getLexicalDeclContext();
5078 numberAnonymousDeclsWithin(DC, [&](const NamedDecl *ND, unsigned Number) {
5079 AnonymousDeclarationNumbers[ND] = Number;
5082 It = AnonymousDeclarationNumbers.find(D);
5083 assert(It != AnonymousDeclarationNumbers.end() &&
5084 "declaration not found within its lexical context");
5090 void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
5091 DeclarationName Name, RecordDataImpl &Record) {
5092 switch (Name.getNameKind()) {
5093 case DeclarationName::CXXConstructorName:
5094 case DeclarationName::CXXDestructorName:
5095 case DeclarationName::CXXConversionFunctionName:
5096 AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record);
5099 case DeclarationName::CXXOperatorName:
5101 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc),
5104 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc),
5108 case DeclarationName::CXXLiteralOperatorName:
5110 SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc),
5114 case DeclarationName::Identifier:
5115 case DeclarationName::ObjCZeroArgSelector:
5116 case DeclarationName::ObjCOneArgSelector:
5117 case DeclarationName::ObjCMultiArgSelector:
5118 case DeclarationName::CXXUsingDirective:
5123 void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
5124 RecordDataImpl &Record) {
5125 AddDeclarationName(NameInfo.getName(), Record);
5126 AddSourceLocation(NameInfo.getLoc(), Record);
5127 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
5130 void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
5131 RecordDataImpl &Record) {
5132 AddNestedNameSpecifierLoc(Info.QualifierLoc, Record);
5133 Record.push_back(Info.NumTemplParamLists);
5134 for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i)
5135 AddTemplateParameterList(Info.TemplParamLists[i], Record);
5138 void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
5139 RecordDataImpl &Record) {
5140 // Nested name specifiers usually aren't too long. I think that 8 would
5141 // typically accommodate the vast majority.
5142 SmallVector<NestedNameSpecifier *, 8> NestedNames;
5144 // Push each of the NNS's onto a stack for serialization in reverse order.
5146 NestedNames.push_back(NNS);
5147 NNS = NNS->getPrefix();
5150 Record.push_back(NestedNames.size());
5151 while(!NestedNames.empty()) {
5152 NNS = NestedNames.pop_back_val();
5153 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
5154 Record.push_back(Kind);
5156 case NestedNameSpecifier::Identifier:
5157 AddIdentifierRef(NNS->getAsIdentifier(), Record);
5160 case NestedNameSpecifier::Namespace:
5161 AddDeclRef(NNS->getAsNamespace(), Record);
5164 case NestedNameSpecifier::NamespaceAlias:
5165 AddDeclRef(NNS->getAsNamespaceAlias(), Record);
5168 case NestedNameSpecifier::TypeSpec:
5169 case NestedNameSpecifier::TypeSpecWithTemplate:
5170 AddTypeRef(QualType(NNS->getAsType(), 0), Record);
5171 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
5174 case NestedNameSpecifier::Global:
5175 // Don't need to write an associated value.
5178 case NestedNameSpecifier::Super:
5179 AddDeclRef(NNS->getAsRecordDecl(), Record);
5185 void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
5186 RecordDataImpl &Record) {
5187 // Nested name specifiers usually aren't too long. I think that 8 would
5188 // typically accommodate the vast majority.
5189 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
5191 // Push each of the nested-name-specifiers's onto a stack for
5192 // serialization in reverse order.
5194 NestedNames.push_back(NNS);
5195 NNS = NNS.getPrefix();
5198 Record.push_back(NestedNames.size());
5199 while(!NestedNames.empty()) {
5200 NNS = NestedNames.pop_back_val();
5201 NestedNameSpecifier::SpecifierKind Kind
5202 = NNS.getNestedNameSpecifier()->getKind();
5203 Record.push_back(Kind);
5205 case NestedNameSpecifier::Identifier:
5206 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record);
5207 AddSourceRange(NNS.getLocalSourceRange(), Record);
5210 case NestedNameSpecifier::Namespace:
5211 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record);
5212 AddSourceRange(NNS.getLocalSourceRange(), Record);
5215 case NestedNameSpecifier::NamespaceAlias:
5216 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record);
5217 AddSourceRange(NNS.getLocalSourceRange(), Record);
5220 case NestedNameSpecifier::TypeSpec:
5221 case NestedNameSpecifier::TypeSpecWithTemplate:
5222 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
5223 AddTypeLoc(NNS.getTypeLoc(), Record);
5224 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
5227 case NestedNameSpecifier::Global:
5228 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
5231 case NestedNameSpecifier::Super:
5232 AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl(), Record);
5233 AddSourceRange(NNS.getLocalSourceRange(), Record);
5239 void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
5240 TemplateName::NameKind Kind = Name.getKind();
5241 Record.push_back(Kind);
5243 case TemplateName::Template:
5244 AddDeclRef(Name.getAsTemplateDecl(), Record);
5247 case TemplateName::OverloadedTemplate: {
5248 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate();
5249 Record.push_back(OvT->size());
5250 for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end();
5252 AddDeclRef(*I, Record);
5256 case TemplateName::QualifiedTemplate: {
5257 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
5258 AddNestedNameSpecifier(QualT->getQualifier(), Record);
5259 Record.push_back(QualT->hasTemplateKeyword());
5260 AddDeclRef(QualT->getTemplateDecl(), Record);
5264 case TemplateName::DependentTemplate: {
5265 DependentTemplateName *DepT = Name.getAsDependentTemplateName();
5266 AddNestedNameSpecifier(DepT->getQualifier(), Record);
5267 Record.push_back(DepT->isIdentifier());
5268 if (DepT->isIdentifier())
5269 AddIdentifierRef(DepT->getIdentifier(), Record);
5271 Record.push_back(DepT->getOperator());
5275 case TemplateName::SubstTemplateTemplateParm: {
5276 SubstTemplateTemplateParmStorage *subst
5277 = Name.getAsSubstTemplateTemplateParm();
5278 AddDeclRef(subst->getParameter(), Record);
5279 AddTemplateName(subst->getReplacement(), Record);
5283 case TemplateName::SubstTemplateTemplateParmPack: {
5284 SubstTemplateTemplateParmPackStorage *SubstPack
5285 = Name.getAsSubstTemplateTemplateParmPack();
5286 AddDeclRef(SubstPack->getParameterPack(), Record);
5287 AddTemplateArgument(SubstPack->getArgumentPack(), Record);
5293 void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
5294 RecordDataImpl &Record) {
5295 Record.push_back(Arg.getKind());
5296 switch (Arg.getKind()) {
5297 case TemplateArgument::Null:
5299 case TemplateArgument::Type:
5300 AddTypeRef(Arg.getAsType(), Record);
5302 case TemplateArgument::Declaration:
5303 AddDeclRef(Arg.getAsDecl(), Record);
5304 AddTypeRef(Arg.getParamTypeForDecl(), Record);
5306 case TemplateArgument::NullPtr:
5307 AddTypeRef(Arg.getNullPtrType(), Record);
5309 case TemplateArgument::Integral:
5310 AddAPSInt(Arg.getAsIntegral(), Record);
5311 AddTypeRef(Arg.getIntegralType(), Record);
5313 case TemplateArgument::Template:
5314 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
5316 case TemplateArgument::TemplateExpansion:
5317 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
5318 if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
5319 Record.push_back(*NumExpansions + 1);
5321 Record.push_back(0);
5323 case TemplateArgument::Expression:
5324 AddStmt(Arg.getAsExpr());
5326 case TemplateArgument::Pack:
5327 Record.push_back(Arg.pack_size());
5328 for (const auto &P : Arg.pack_elements())
5329 AddTemplateArgument(P, Record);
5335 ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
5336 RecordDataImpl &Record) {
5337 assert(TemplateParams && "No TemplateParams!");
5338 AddSourceLocation(TemplateParams->getTemplateLoc(), Record);
5339 AddSourceLocation(TemplateParams->getLAngleLoc(), Record);
5340 AddSourceLocation(TemplateParams->getRAngleLoc(), Record);
5341 Record.push_back(TemplateParams->size());
5342 for (TemplateParameterList::const_iterator
5343 P = TemplateParams->begin(), PEnd = TemplateParams->end();
5345 AddDeclRef(*P, Record);
5348 /// \brief Emit a template argument list.
5350 ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
5351 RecordDataImpl &Record) {
5352 assert(TemplateArgs && "No TemplateArgs!");
5353 Record.push_back(TemplateArgs->size());
5354 for (int i=0, e = TemplateArgs->size(); i != e; ++i)
5355 AddTemplateArgument(TemplateArgs->get(i), Record);
5359 ASTWriter::AddASTTemplateArgumentListInfo
5360 (const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) {
5361 assert(ASTTemplArgList && "No ASTTemplArgList!");
5362 AddSourceLocation(ASTTemplArgList->LAngleLoc, Record);
5363 AddSourceLocation(ASTTemplArgList->RAngleLoc, Record);
5364 Record.push_back(ASTTemplArgList->NumTemplateArgs);
5365 const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs();
5366 for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i)
5367 AddTemplateArgumentLoc(TemplArgs[i], Record);
5371 ASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record) {
5372 Record.push_back(Set.size());
5373 for (ASTUnresolvedSet::const_iterator
5374 I = Set.begin(), E = Set.end(); I != E; ++I) {
5375 AddDeclRef(I.getDecl(), Record);
5376 Record.push_back(I.getAccess());
5380 void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
5381 RecordDataImpl &Record) {
5382 Record.push_back(Base.isVirtual());
5383 Record.push_back(Base.isBaseOfClass());
5384 Record.push_back(Base.getAccessSpecifierAsWritten());
5385 Record.push_back(Base.getInheritConstructors());
5386 AddTypeSourceInfo(Base.getTypeSourceInfo(), Record);
5387 AddSourceRange(Base.getSourceRange(), Record);
5388 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc()
5393 void ASTWriter::FlushCXXBaseSpecifiers() {
5395 unsigned N = CXXBaseSpecifiersToWrite.size();
5396 for (unsigned I = 0; I != N; ++I) {
5399 // Record the offset of this base-specifier set.
5400 unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
5401 if (Index == CXXBaseSpecifiersOffsets.size())
5402 CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo());
5404 if (Index > CXXBaseSpecifiersOffsets.size())
5405 CXXBaseSpecifiersOffsets.resize(Index + 1);
5406 CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo();
5409 const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases,
5410 *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd;
5411 Record.push_back(BEnd - B);
5412 for (; B != BEnd; ++B)
5413 AddCXXBaseSpecifier(*B, Record);
5414 Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record);
5416 // Flush any expressions that were written as part of the base specifiers.
5420 assert(N == CXXBaseSpecifiersToWrite.size() &&
5421 "added more base specifiers while writing base specifiers");
5422 CXXBaseSpecifiersToWrite.clear();
5425 void ASTWriter::AddCXXCtorInitializers(
5426 const CXXCtorInitializer * const *CtorInitializers,
5427 unsigned NumCtorInitializers,
5428 RecordDataImpl &Record) {
5429 Record.push_back(NumCtorInitializers);
5430 for (unsigned i=0; i != NumCtorInitializers; ++i) {
5431 const CXXCtorInitializer *Init = CtorInitializers[i];
5433 if (Init->isBaseInitializer()) {
5434 Record.push_back(CTOR_INITIALIZER_BASE);
5435 AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
5436 Record.push_back(Init->isBaseVirtual());
5437 } else if (Init->isDelegatingInitializer()) {
5438 Record.push_back(CTOR_INITIALIZER_DELEGATING);
5439 AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
5440 } else if (Init->isMemberInitializer()){
5441 Record.push_back(CTOR_INITIALIZER_MEMBER);
5442 AddDeclRef(Init->getMember(), Record);
5444 Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
5445 AddDeclRef(Init->getIndirectMember(), Record);
5448 AddSourceLocation(Init->getMemberLocation(), Record);
5449 AddStmt(Init->getInit());
5450 AddSourceLocation(Init->getLParenLoc(), Record);
5451 AddSourceLocation(Init->getRParenLoc(), Record);
5452 Record.push_back(Init->isWritten());
5453 if (Init->isWritten()) {
5454 Record.push_back(Init->getSourceOrder());
5456 Record.push_back(Init->getNumArrayIndices());
5457 for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i)
5458 AddDeclRef(Init->getArrayIndex(i), Record);
5463 void ASTWriter::FlushCXXCtorInitializers() {
5466 unsigned N = CXXCtorInitializersToWrite.size();
5467 (void)N; // Silence unused warning in non-assert builds.
5468 for (auto &Init : CXXCtorInitializersToWrite) {
5471 // Record the offset of this mem-initializer list.
5472 unsigned Index = Init.ID - 1;
5473 if (Index == CXXCtorInitializersOffsets.size())
5474 CXXCtorInitializersOffsets.push_back(Stream.GetCurrentBitNo());
5476 if (Index > CXXCtorInitializersOffsets.size())
5477 CXXCtorInitializersOffsets.resize(Index + 1);
5478 CXXCtorInitializersOffsets[Index] = Stream.GetCurrentBitNo();
5481 AddCXXCtorInitializers(Init.Inits.data(), Init.Inits.size(), Record);
5482 Stream.EmitRecord(serialization::DECL_CXX_CTOR_INITIALIZERS, Record);
5484 // Flush any expressions that were written as part of the initializers.
5488 assert(N == CXXCtorInitializersToWrite.size() &&
5489 "added more ctor initializers while writing ctor initializers");
5490 CXXCtorInitializersToWrite.clear();
5493 void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) {
5494 auto &Data = D->data();
5495 Record.push_back(Data.IsLambda);
5496 Record.push_back(Data.UserDeclaredConstructor);
5497 Record.push_back(Data.UserDeclaredSpecialMembers);
5498 Record.push_back(Data.Aggregate);
5499 Record.push_back(Data.PlainOldData);
5500 Record.push_back(Data.Empty);
5501 Record.push_back(Data.Polymorphic);
5502 Record.push_back(Data.Abstract);
5503 Record.push_back(Data.IsStandardLayout);
5504 Record.push_back(Data.HasNoNonEmptyBases);
5505 Record.push_back(Data.HasPrivateFields);
5506 Record.push_back(Data.HasProtectedFields);
5507 Record.push_back(Data.HasPublicFields);
5508 Record.push_back(Data.HasMutableFields);
5509 Record.push_back(Data.HasVariantMembers);
5510 Record.push_back(Data.HasOnlyCMembers);
5511 Record.push_back(Data.HasInClassInitializer);
5512 Record.push_back(Data.HasUninitializedReferenceMember);
5513 Record.push_back(Data.NeedOverloadResolutionForMoveConstructor);
5514 Record.push_back(Data.NeedOverloadResolutionForMoveAssignment);
5515 Record.push_back(Data.NeedOverloadResolutionForDestructor);
5516 Record.push_back(Data.DefaultedMoveConstructorIsDeleted);
5517 Record.push_back(Data.DefaultedMoveAssignmentIsDeleted);
5518 Record.push_back(Data.DefaultedDestructorIsDeleted);
5519 Record.push_back(Data.HasTrivialSpecialMembers);
5520 Record.push_back(Data.DeclaredNonTrivialSpecialMembers);
5521 Record.push_back(Data.HasIrrelevantDestructor);
5522 Record.push_back(Data.HasConstexprNonCopyMoveConstructor);
5523 Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr);
5524 Record.push_back(Data.HasConstexprDefaultConstructor);
5525 Record.push_back(Data.HasNonLiteralTypeFieldsOrBases);
5526 Record.push_back(Data.ComputedVisibleConversions);
5527 Record.push_back(Data.UserProvidedDefaultConstructor);
5528 Record.push_back(Data.DeclaredSpecialMembers);
5529 Record.push_back(Data.ImplicitCopyConstructorHasConstParam);
5530 Record.push_back(Data.ImplicitCopyAssignmentHasConstParam);
5531 Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam);
5532 Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam);
5533 // IsLambda bit is already saved.
5535 Record.push_back(Data.NumBases);
5536 if (Data.NumBases > 0)
5537 AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases,
5540 // FIXME: Make VBases lazily computed when needed to avoid storing them.
5541 Record.push_back(Data.NumVBases);
5542 if (Data.NumVBases > 0)
5543 AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases,
5546 AddUnresolvedSet(Data.Conversions.get(*Context), Record);
5547 AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record);
5548 // Data.Definition is the owning decl, no need to write it.
5549 AddDeclRef(D->getFirstFriend(), Record);
5551 // Add lambda-specific data.
5552 if (Data.IsLambda) {
5553 auto &Lambda = D->getLambdaData();
5554 Record.push_back(Lambda.Dependent);
5555 Record.push_back(Lambda.IsGenericLambda);
5556 Record.push_back(Lambda.CaptureDefault);
5557 Record.push_back(Lambda.NumCaptures);
5558 Record.push_back(Lambda.NumExplicitCaptures);
5559 Record.push_back(Lambda.ManglingNumber);
5560 AddDeclRef(Lambda.ContextDecl, Record);
5561 AddTypeSourceInfo(Lambda.MethodTyInfo, Record);
5562 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
5563 const LambdaCapture &Capture = Lambda.Captures[I];
5564 AddSourceLocation(Capture.getLocation(), Record);
5565 Record.push_back(Capture.isImplicit());
5566 Record.push_back(Capture.getCaptureKind());
5567 switch (Capture.getCaptureKind()) {
5574 Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr;
5575 AddDeclRef(Var, Record);
5576 AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc()
5585 void ASTWriter::ReaderInitialized(ASTReader *Reader) {
5586 assert(Reader && "Cannot remove chain");
5587 assert((!Chain || Chain == Reader) && "Cannot replace chain");
5588 assert(FirstDeclID == NextDeclID &&
5589 FirstTypeID == NextTypeID &&
5590 FirstIdentID == NextIdentID &&
5591 FirstMacroID == NextMacroID &&
5592 FirstSubmoduleID == NextSubmoduleID &&
5593 FirstSelectorID == NextSelectorID &&
5594 "Setting chain after writing has started.");
5598 // Note, this will get called multiple times, once one the reader starts up
5599 // and again each time it's done reading a PCH or module.
5600 FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls();
5601 FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes();
5602 FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers();
5603 FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros();
5604 FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules();
5605 FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors();
5606 NextDeclID = FirstDeclID;
5607 NextTypeID = FirstTypeID;
5608 NextIdentID = FirstIdentID;
5609 NextMacroID = FirstMacroID;
5610 NextSelectorID = FirstSelectorID;
5611 NextSubmoduleID = FirstSubmoduleID;
5614 void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) {
5615 // Always keep the highest ID. See \p TypeRead() for more information.
5616 IdentID &StoredID = IdentifierIDs[II];
5621 void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) {
5622 // Always keep the highest ID. See \p TypeRead() for more information.
5623 MacroID &StoredID = MacroIDs[MI];
5628 void ASTWriter::TypeRead(TypeIdx Idx, QualType T) {
5629 // Always take the highest-numbered type index. This copes with an interesting
5630 // case for chained AST writing where we schedule writing the type and then,
5631 // later, deserialize the type from another AST. In this case, we want to
5632 // keep the higher-numbered entry so that we can properly write it out to
5634 TypeIdx &StoredIdx = TypeIdxs[T];
5635 if (Idx.getIndex() >= StoredIdx.getIndex())
5639 void ASTWriter::SelectorRead(SelectorID ID, Selector S) {
5640 // Always keep the highest ID. See \p TypeRead() for more information.
5641 SelectorID &StoredID = SelectorIDs[S];
5646 void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID,
5647 MacroDefinitionRecord *MD) {
5648 assert(MacroDefinitions.find(MD) == MacroDefinitions.end());
5649 MacroDefinitions[MD] = ID;
5652 void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) {
5653 assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end());
5654 SubmoduleIDs[Mod] = ID;
5657 void ASTWriter::CompletedTagDefinition(const TagDecl *D) {
5658 assert(D->isCompleteDefinition());
5659 assert(!WritingAST && "Already writing the AST!");
5660 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
5661 // We are interested when a PCH decl is modified.
5662 if (RD->isFromASTFile()) {
5663 // A forward reference was mutated into a definition. Rewrite it.
5664 // FIXME: This happens during template instantiation, should we
5665 // have created a new definition decl instead ?
5666 assert(isTemplateInstantiation(RD->getTemplateSpecializationKind()) &&
5667 "completed a tag from another module but not by instantiation?");
5668 DeclUpdates[RD].push_back(
5669 DeclUpdate(UPD_CXX_INSTANTIATED_CLASS_DEFINITION));
5674 void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) {
5675 // TU and namespaces are handled elsewhere.
5676 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC))
5679 if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile()))
5680 return; // Not a source decl added to a DeclContext from PCH.
5682 assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!");
5683 assert(!WritingAST && "Already writing the AST!");
5684 UpdatedDeclContexts.insert(DC);
5685 UpdatingVisibleDecls.push_back(D);
5688 void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) {
5689 assert(D->isImplicit());
5690 if (!(!D->isFromASTFile() && RD->isFromASTFile()))
5691 return; // Not a source member added to a class from PCH.
5692 if (!isa<CXXMethodDecl>(D))
5693 return; // We are interested in lazily declared implicit methods.
5695 // A decl coming from PCH was modified.
5696 assert(RD->isCompleteDefinition());
5697 assert(!WritingAST && "Already writing the AST!");
5698 DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D));
5701 void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
5702 const ClassTemplateSpecializationDecl *D) {
5703 // The specializations set is kept in the canonical template.
5704 TD = TD->getCanonicalDecl();
5705 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
5706 return; // Not a source specialization added to a template from PCH.
5708 assert(!WritingAST && "Already writing the AST!");
5709 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION,
5713 void ASTWriter::AddedCXXTemplateSpecialization(
5714 const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) {
5715 // The specializations set is kept in the canonical template.
5716 TD = TD->getCanonicalDecl();
5717 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
5718 return; // Not a source specialization added to a template from PCH.
5720 assert(!WritingAST && "Already writing the AST!");
5721 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION,
5725 void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
5726 const FunctionDecl *D) {
5727 // The specializations set is kept in the canonical template.
5728 TD = TD->getCanonicalDecl();
5729 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
5730 return; // Not a source specialization added to a template from PCH.
5732 assert(!WritingAST && "Already writing the AST!");
5733 DeclUpdates[TD].push_back(DeclUpdate(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION,
5737 void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) {
5738 assert(!DoneWritingDeclsAndTypes && "Already done writing updates!");
5740 Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) {
5741 // If we don't already know the exception specification for this redecl
5742 // chain, add an update record for it.
5743 if (isUnresolvedExceptionSpec(cast<FunctionDecl>(D)
5745 ->castAs<FunctionProtoType>()
5746 ->getExceptionSpecType()))
5747 DeclUpdates[D].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC);
5751 void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) {
5752 assert(!WritingAST && "Already writing the AST!");
5754 Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) {
5755 DeclUpdates[D].push_back(
5756 DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType));
5760 void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD,
5761 const FunctionDecl *Delete) {
5762 assert(!WritingAST && "Already writing the AST!");
5763 assert(Delete && "Not given an operator delete");
5765 Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) {
5766 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_RESOLVED_DTOR_DELETE, Delete));
5770 void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) {
5771 assert(!WritingAST && "Already writing the AST!");
5772 if (!D->isFromASTFile())
5773 return; // Declaration not imported from PCH.
5775 // Implicit function decl from a PCH was defined.
5776 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION));
5779 void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) {
5780 assert(!WritingAST && "Already writing the AST!");
5781 if (!D->isFromASTFile())
5784 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION));
5787 void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) {
5788 assert(!WritingAST && "Already writing the AST!");
5789 if (!D->isFromASTFile())
5792 // Since the actual instantiation is delayed, this really means that we need
5793 // to update the instantiation location.
5794 DeclUpdates[D].push_back(
5795 DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER,
5796 D->getMemberSpecializationInfo()->getPointOfInstantiation()));
5799 void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
5800 const ObjCInterfaceDecl *IFD) {
5801 assert(!WritingAST && "Already writing the AST!");
5802 if (!IFD->isFromASTFile())
5803 return; // Declaration not imported from PCH.
5805 assert(IFD->getDefinition() && "Category on a class without a definition?");
5806 ObjCClassesWithCategories.insert(
5807 const_cast<ObjCInterfaceDecl *>(IFD->getDefinition()));
5811 void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop,
5812 const ObjCPropertyDecl *OrigProp,
5813 const ObjCCategoryDecl *ClassExt) {
5814 const ObjCInterfaceDecl *D = ClassExt->getClassInterface();
5818 assert(!WritingAST && "Already writing the AST!");
5819 if (!D->isFromASTFile())
5820 return; // Declaration not imported from PCH.
5825 void ASTWriter::DeclarationMarkedUsed(const Decl *D) {
5826 assert(!WritingAST && "Already writing the AST!");
5827 if (!D->isFromASTFile())
5830 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED));
5833 void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(const Decl *D) {
5834 assert(!WritingAST && "Already writing the AST!");
5835 if (!D->isFromASTFile())
5838 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_THREADPRIVATE));
5841 void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) {
5842 assert(!WritingAST && "Already writing the AST!");
5843 assert(D->isHidden() && "expected a hidden declaration");
5844 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M));
5847 void ASTWriter::AddedAttributeToRecord(const Attr *Attr,
5848 const RecordDecl *Record) {
5849 assert(!WritingAST && "Already writing the AST!");
5850 if (!Record->isFromASTFile())
5852 DeclUpdates[Record].push_back(DeclUpdate(UPD_ADDED_ATTR_TO_RECORD, Attr));