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/Sema/Sema.h"
17 #include "clang/Sema/IdentifierResolver.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclContextInternals.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/DeclFriend.h"
23 #include "clang/AST/Expr.h"
24 #include "clang/AST/ExprCXX.h"
25 #include "clang/AST/Type.h"
26 #include "clang/AST/TypeLocVisitor.h"
27 #include "clang/Serialization/ASTReader.h"
28 #include "clang/Lex/MacroInfo.h"
29 #include "clang/Lex/PreprocessingRecord.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "clang/Lex/HeaderSearch.h"
32 #include "clang/Basic/FileManager.h"
33 #include "clang/Basic/FileSystemStatCache.h"
34 #include "clang/Basic/OnDiskHashTable.h"
35 #include "clang/Basic/SourceManager.h"
36 #include "clang/Basic/SourceManagerInternals.h"
37 #include "clang/Basic/TargetInfo.h"
38 #include "clang/Basic/Version.h"
39 #include "clang/Basic/VersionTuple.h"
40 #include "llvm/ADT/APFloat.h"
41 #include "llvm/ADT/APInt.h"
42 #include "llvm/ADT/StringExtras.h"
43 #include "llvm/Bitcode/BitstreamWriter.h"
44 #include "llvm/Support/FileSystem.h"
45 #include "llvm/Support/MemoryBuffer.h"
46 #include "llvm/Support/Path.h"
51 using namespace clang;
52 using namespace clang::serialization;
54 template <typename T, typename Allocator>
55 static StringRef data(const std::vector<T, Allocator> &v) {
56 if (v.empty()) return StringRef();
57 return StringRef(reinterpret_cast<const char*>(&v[0]),
58 sizeof(T) * v.size());
62 static StringRef data(const SmallVectorImpl<T> &v) {
63 return StringRef(reinterpret_cast<const char*>(v.data()),
64 sizeof(T) * v.size());
67 //===----------------------------------------------------------------------===//
69 //===----------------------------------------------------------------------===//
74 ASTWriter::RecordDataImpl &Record;
77 /// \brief Type code that corresponds to the record generated.
80 ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
81 : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { }
83 void VisitArrayType(const ArrayType *T);
84 void VisitFunctionType(const FunctionType *T);
85 void VisitTagType(const TagType *T);
87 #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T);
88 #define ABSTRACT_TYPE(Class, Base)
89 #include "clang/AST/TypeNodes.def"
93 void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
94 llvm_unreachable("Built-in types are never serialized");
97 void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
98 Writer.AddTypeRef(T->getElementType(), Record);
102 void ASTTypeWriter::VisitPointerType(const PointerType *T) {
103 Writer.AddTypeRef(T->getPointeeType(), Record);
107 void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
108 Writer.AddTypeRef(T->getPointeeType(), Record);
109 Code = TYPE_BLOCK_POINTER;
112 void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
113 Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
114 Record.push_back(T->isSpelledAsLValue());
115 Code = TYPE_LVALUE_REFERENCE;
118 void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
119 Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
120 Code = TYPE_RVALUE_REFERENCE;
123 void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) {
124 Writer.AddTypeRef(T->getPointeeType(), Record);
125 Writer.AddTypeRef(QualType(T->getClass(), 0), Record);
126 Code = TYPE_MEMBER_POINTER;
129 void ASTTypeWriter::VisitArrayType(const ArrayType *T) {
130 Writer.AddTypeRef(T->getElementType(), Record);
131 Record.push_back(T->getSizeModifier()); // FIXME: stable values
132 Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values
135 void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
137 Writer.AddAPInt(T->getSize(), Record);
138 Code = TYPE_CONSTANT_ARRAY;
141 void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
143 Code = TYPE_INCOMPLETE_ARRAY;
146 void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
148 Writer.AddSourceLocation(T->getLBracketLoc(), Record);
149 Writer.AddSourceLocation(T->getRBracketLoc(), Record);
150 Writer.AddStmt(T->getSizeExpr());
151 Code = TYPE_VARIABLE_ARRAY;
154 void ASTTypeWriter::VisitVectorType(const VectorType *T) {
155 Writer.AddTypeRef(T->getElementType(), Record);
156 Record.push_back(T->getNumElements());
157 Record.push_back(T->getVectorKind());
161 void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) {
163 Code = TYPE_EXT_VECTOR;
166 void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
167 Writer.AddTypeRef(T->getResultType(), Record);
168 FunctionType::ExtInfo C = T->getExtInfo();
169 Record.push_back(C.getNoReturn());
170 Record.push_back(C.getHasRegParm());
171 Record.push_back(C.getRegParm());
172 // FIXME: need to stabilize encoding of calling convention...
173 Record.push_back(C.getCC());
174 Record.push_back(C.getProducesResult());
177 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
178 VisitFunctionType(T);
179 Code = TYPE_FUNCTION_NO_PROTO;
182 void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) {
183 VisitFunctionType(T);
184 Record.push_back(T->getNumArgs());
185 for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I)
186 Writer.AddTypeRef(T->getArgType(I), Record);
187 Record.push_back(T->isVariadic());
188 Record.push_back(T->getTypeQuals());
189 Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
190 Record.push_back(T->getExceptionSpecType());
191 if (T->getExceptionSpecType() == EST_Dynamic) {
192 Record.push_back(T->getNumExceptions());
193 for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
194 Writer.AddTypeRef(T->getExceptionType(I), Record);
195 } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
196 Writer.AddStmt(T->getNoexceptExpr());
198 Code = TYPE_FUNCTION_PROTO;
201 void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
202 Writer.AddDeclRef(T->getDecl(), Record);
203 Code = TYPE_UNRESOLVED_USING;
206 void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
207 Writer.AddDeclRef(T->getDecl(), Record);
208 assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
209 Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
213 void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
214 Writer.AddStmt(T->getUnderlyingExpr());
215 Code = TYPE_TYPEOF_EXPR;
218 void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
219 Writer.AddTypeRef(T->getUnderlyingType(), Record);
223 void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
224 Writer.AddStmt(T->getUnderlyingExpr());
225 Code = TYPE_DECLTYPE;
228 void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
229 Writer.AddTypeRef(T->getBaseType(), Record);
230 Writer.AddTypeRef(T->getUnderlyingType(), Record);
231 Record.push_back(T->getUTTKind());
232 Code = TYPE_UNARY_TRANSFORM;
235 void ASTTypeWriter::VisitAutoType(const AutoType *T) {
236 Writer.AddTypeRef(T->getDeducedType(), Record);
240 void ASTTypeWriter::VisitTagType(const TagType *T) {
241 Record.push_back(T->isDependentType());
242 Writer.AddDeclRef(T->getDecl(), Record);
243 assert(!T->isBeingDefined() &&
244 "Cannot serialize in the middle of a type definition");
247 void ASTTypeWriter::VisitRecordType(const RecordType *T) {
252 void ASTTypeWriter::VisitEnumType(const EnumType *T) {
257 void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
258 Writer.AddTypeRef(T->getModifiedType(), Record);
259 Writer.AddTypeRef(T->getEquivalentType(), Record);
260 Record.push_back(T->getAttrKind());
261 Code = TYPE_ATTRIBUTED;
265 ASTTypeWriter::VisitSubstTemplateTypeParmType(
266 const SubstTemplateTypeParmType *T) {
267 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
268 Writer.AddTypeRef(T->getReplacementType(), Record);
269 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM;
273 ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
274 const SubstTemplateTypeParmPackType *T) {
275 Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
276 Writer.AddTemplateArgument(T->getArgumentPack(), Record);
277 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK;
281 ASTTypeWriter::VisitTemplateSpecializationType(
282 const TemplateSpecializationType *T) {
283 Record.push_back(T->isDependentType());
284 Writer.AddTemplateName(T->getTemplateName(), Record);
285 Record.push_back(T->getNumArgs());
286 for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end();
287 ArgI != ArgE; ++ArgI)
288 Writer.AddTemplateArgument(*ArgI, Record);
289 Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() :
290 T->isCanonicalUnqualified() ? QualType()
291 : T->getCanonicalTypeInternal(),
293 Code = TYPE_TEMPLATE_SPECIALIZATION;
297 ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
299 Writer.AddStmt(T->getSizeExpr());
300 Writer.AddSourceRange(T->getBracketsRange(), Record);
301 Code = TYPE_DEPENDENT_SIZED_ARRAY;
305 ASTTypeWriter::VisitDependentSizedExtVectorType(
306 const DependentSizedExtVectorType *T) {
307 // FIXME: Serialize this type (C++ only)
308 llvm_unreachable("Cannot serialize dependent sized extended vector types");
312 ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
313 Record.push_back(T->getDepth());
314 Record.push_back(T->getIndex());
315 Record.push_back(T->isParameterPack());
316 Writer.AddDeclRef(T->getDecl(), Record);
317 Code = TYPE_TEMPLATE_TYPE_PARM;
321 ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
322 Record.push_back(T->getKeyword());
323 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
324 Writer.AddIdentifierRef(T->getIdentifier(), Record);
325 Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
326 : T->getCanonicalTypeInternal(),
328 Code = TYPE_DEPENDENT_NAME;
332 ASTTypeWriter::VisitDependentTemplateSpecializationType(
333 const DependentTemplateSpecializationType *T) {
334 Record.push_back(T->getKeyword());
335 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
336 Writer.AddIdentifierRef(T->getIdentifier(), Record);
337 Record.push_back(T->getNumArgs());
338 for (DependentTemplateSpecializationType::iterator
339 I = T->begin(), E = T->end(); I != E; ++I)
340 Writer.AddTemplateArgument(*I, Record);
341 Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION;
344 void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
345 Writer.AddTypeRef(T->getPattern(), Record);
346 if (llvm::Optional<unsigned> NumExpansions = T->getNumExpansions())
347 Record.push_back(*NumExpansions + 1);
350 Code = TYPE_PACK_EXPANSION;
353 void ASTTypeWriter::VisitParenType(const ParenType *T) {
354 Writer.AddTypeRef(T->getInnerType(), Record);
358 void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
359 Record.push_back(T->getKeyword());
360 Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
361 Writer.AddTypeRef(T->getNamedType(), Record);
362 Code = TYPE_ELABORATED;
365 void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
366 Writer.AddDeclRef(T->getDecl(), Record);
367 Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
368 Code = TYPE_INJECTED_CLASS_NAME;
371 void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
372 Writer.AddDeclRef(T->getDecl(), Record);
373 Code = TYPE_OBJC_INTERFACE;
376 void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
377 Writer.AddTypeRef(T->getBaseType(), Record);
378 Record.push_back(T->getNumProtocols());
379 for (ObjCObjectType::qual_iterator I = T->qual_begin(),
380 E = T->qual_end(); I != E; ++I)
381 Writer.AddDeclRef(*I, Record);
382 Code = TYPE_OBJC_OBJECT;
386 ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
387 Writer.AddTypeRef(T->getPointeeType(), Record);
388 Code = TYPE_OBJC_OBJECT_POINTER;
392 ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
393 Writer.AddTypeRef(T->getValueType(), Record);
399 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
401 ASTWriter::RecordDataImpl &Record;
404 TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
405 : Writer(Writer), Record(Record) { }
407 #define ABSTRACT_TYPELOC(CLASS, PARENT)
408 #define TYPELOC(CLASS, PARENT) \
409 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
410 #include "clang/AST/TypeLocNodes.def"
412 void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
413 void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
418 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
421 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
422 Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
423 if (TL.needsExtraLocalData()) {
424 Record.push_back(TL.getWrittenTypeSpec());
425 Record.push_back(TL.getWrittenSignSpec());
426 Record.push_back(TL.getWrittenWidthSpec());
427 Record.push_back(TL.hasModeAttr());
430 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
431 Writer.AddSourceLocation(TL.getNameLoc(), Record);
433 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
434 Writer.AddSourceLocation(TL.getStarLoc(), Record);
436 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
437 Writer.AddSourceLocation(TL.getCaretLoc(), Record);
439 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
440 Writer.AddSourceLocation(TL.getAmpLoc(), Record);
442 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
443 Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record);
445 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
446 Writer.AddSourceLocation(TL.getStarLoc(), Record);
447 Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record);
449 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
450 Writer.AddSourceLocation(TL.getLBracketLoc(), Record);
451 Writer.AddSourceLocation(TL.getRBracketLoc(), Record);
452 Record.push_back(TL.getSizeExpr() ? 1 : 0);
453 if (TL.getSizeExpr())
454 Writer.AddStmt(TL.getSizeExpr());
456 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
457 VisitArrayTypeLoc(TL);
459 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
460 VisitArrayTypeLoc(TL);
462 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
463 VisitArrayTypeLoc(TL);
465 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
466 DependentSizedArrayTypeLoc TL) {
467 VisitArrayTypeLoc(TL);
469 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
470 DependentSizedExtVectorTypeLoc TL) {
471 Writer.AddSourceLocation(TL.getNameLoc(), Record);
473 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
474 Writer.AddSourceLocation(TL.getNameLoc(), Record);
476 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
477 Writer.AddSourceLocation(TL.getNameLoc(), Record);
479 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
480 Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
481 Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record);
482 Record.push_back(TL.getTrailingReturn());
483 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
484 Writer.AddDeclRef(TL.getArg(i), Record);
486 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
487 VisitFunctionTypeLoc(TL);
489 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
490 VisitFunctionTypeLoc(TL);
492 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
493 Writer.AddSourceLocation(TL.getNameLoc(), Record);
495 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
496 Writer.AddSourceLocation(TL.getNameLoc(), Record);
498 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
499 Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
500 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
501 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
503 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
504 Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
505 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
506 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
507 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
509 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
510 Writer.AddSourceLocation(TL.getNameLoc(), Record);
512 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
513 Writer.AddSourceLocation(TL.getKWLoc(), Record);
514 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
515 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
516 Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
518 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
519 Writer.AddSourceLocation(TL.getNameLoc(), Record);
521 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
522 Writer.AddSourceLocation(TL.getNameLoc(), Record);
524 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
525 Writer.AddSourceLocation(TL.getNameLoc(), Record);
527 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
528 Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
529 if (TL.hasAttrOperand()) {
530 SourceRange range = TL.getAttrOperandParensRange();
531 Writer.AddSourceLocation(range.getBegin(), Record);
532 Writer.AddSourceLocation(range.getEnd(), Record);
534 if (TL.hasAttrExprOperand()) {
535 Expr *operand = TL.getAttrExprOperand();
536 Record.push_back(operand ? 1 : 0);
537 if (operand) Writer.AddStmt(operand);
538 } else if (TL.hasAttrEnumOperand()) {
539 Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record);
542 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
543 Writer.AddSourceLocation(TL.getNameLoc(), Record);
545 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
546 SubstTemplateTypeParmTypeLoc TL) {
547 Writer.AddSourceLocation(TL.getNameLoc(), Record);
549 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
550 SubstTemplateTypeParmPackTypeLoc TL) {
551 Writer.AddSourceLocation(TL.getNameLoc(), Record);
553 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
554 TemplateSpecializationTypeLoc TL) {
555 Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
556 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
557 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
558 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
559 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
560 TL.getArgLoc(i).getLocInfo(), Record);
562 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
563 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
564 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
566 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
567 Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
568 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
570 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
571 Writer.AddSourceLocation(TL.getNameLoc(), Record);
573 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
574 Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
575 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
576 Writer.AddSourceLocation(TL.getNameLoc(), Record);
578 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
579 DependentTemplateSpecializationTypeLoc TL) {
580 Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
581 Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
582 Writer.AddSourceLocation(TL.getNameLoc(), Record);
583 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
584 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
585 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
586 Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
587 TL.getArgLoc(I).getLocInfo(), Record);
589 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
590 Writer.AddSourceLocation(TL.getEllipsisLoc(), Record);
592 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
593 Writer.AddSourceLocation(TL.getNameLoc(), Record);
595 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
596 Record.push_back(TL.hasBaseTypeAsWritten());
597 Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
598 Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
599 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
600 Writer.AddSourceLocation(TL.getProtocolLoc(i), Record);
602 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
603 Writer.AddSourceLocation(TL.getStarLoc(), Record);
605 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
606 Writer.AddSourceLocation(TL.getKWLoc(), Record);
607 Writer.AddSourceLocation(TL.getLParenLoc(), Record);
608 Writer.AddSourceLocation(TL.getRParenLoc(), Record);
611 //===----------------------------------------------------------------------===//
612 // ASTWriter Implementation
613 //===----------------------------------------------------------------------===//
615 static void EmitBlockID(unsigned ID, const char *Name,
616 llvm::BitstreamWriter &Stream,
617 ASTWriter::RecordDataImpl &Record) {
619 Record.push_back(ID);
620 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
622 // Emit the block name if present.
623 if (Name == 0 || Name[0] == 0) return;
626 Record.push_back(*Name++);
627 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
630 static void EmitRecordID(unsigned ID, const char *Name,
631 llvm::BitstreamWriter &Stream,
632 ASTWriter::RecordDataImpl &Record) {
634 Record.push_back(ID);
636 Record.push_back(*Name++);
637 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
640 static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
641 ASTWriter::RecordDataImpl &Record) {
642 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
644 RECORD(STMT_NULL_PTR);
646 RECORD(STMT_COMPOUND);
648 RECORD(STMT_DEFAULT);
656 RECORD(STMT_INDIRECT_GOTO);
657 RECORD(STMT_CONTINUE);
662 RECORD(EXPR_PREDEFINED);
663 RECORD(EXPR_DECL_REF);
664 RECORD(EXPR_INTEGER_LITERAL);
665 RECORD(EXPR_FLOATING_LITERAL);
666 RECORD(EXPR_IMAGINARY_LITERAL);
667 RECORD(EXPR_STRING_LITERAL);
668 RECORD(EXPR_CHARACTER_LITERAL);
670 RECORD(EXPR_UNARY_OPERATOR);
671 RECORD(EXPR_SIZEOF_ALIGN_OF);
672 RECORD(EXPR_ARRAY_SUBSCRIPT);
675 RECORD(EXPR_BINARY_OPERATOR);
676 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
677 RECORD(EXPR_CONDITIONAL_OPERATOR);
678 RECORD(EXPR_IMPLICIT_CAST);
679 RECORD(EXPR_CSTYLE_CAST);
680 RECORD(EXPR_COMPOUND_LITERAL);
681 RECORD(EXPR_EXT_VECTOR_ELEMENT);
682 RECORD(EXPR_INIT_LIST);
683 RECORD(EXPR_DESIGNATED_INIT);
684 RECORD(EXPR_IMPLICIT_VALUE_INIT);
686 RECORD(EXPR_ADDR_LABEL);
689 RECORD(EXPR_GNU_NULL);
690 RECORD(EXPR_SHUFFLE_VECTOR);
692 RECORD(EXPR_BLOCK_DECL_REF);
693 RECORD(EXPR_GENERIC_SELECTION);
694 RECORD(EXPR_OBJC_STRING_LITERAL);
695 RECORD(EXPR_OBJC_ENCODE);
696 RECORD(EXPR_OBJC_SELECTOR_EXPR);
697 RECORD(EXPR_OBJC_PROTOCOL_EXPR);
698 RECORD(EXPR_OBJC_IVAR_REF_EXPR);
699 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR);
700 RECORD(EXPR_OBJC_KVC_REF_EXPR);
701 RECORD(EXPR_OBJC_MESSAGE_EXPR);
702 RECORD(STMT_OBJC_FOR_COLLECTION);
703 RECORD(STMT_OBJC_CATCH);
704 RECORD(STMT_OBJC_FINALLY);
705 RECORD(STMT_OBJC_AT_TRY);
706 RECORD(STMT_OBJC_AT_SYNCHRONIZED);
707 RECORD(STMT_OBJC_AT_THROW);
708 RECORD(EXPR_CXX_OPERATOR_CALL);
709 RECORD(EXPR_CXX_CONSTRUCT);
710 RECORD(EXPR_CXX_STATIC_CAST);
711 RECORD(EXPR_CXX_DYNAMIC_CAST);
712 RECORD(EXPR_CXX_REINTERPRET_CAST);
713 RECORD(EXPR_CXX_CONST_CAST);
714 RECORD(EXPR_CXX_FUNCTIONAL_CAST);
715 RECORD(EXPR_CXX_BOOL_LITERAL);
716 RECORD(EXPR_CXX_NULL_PTR_LITERAL);
717 RECORD(EXPR_CXX_TYPEID_EXPR);
718 RECORD(EXPR_CXX_TYPEID_TYPE);
719 RECORD(EXPR_CXX_UUIDOF_EXPR);
720 RECORD(EXPR_CXX_UUIDOF_TYPE);
721 RECORD(EXPR_CXX_THIS);
722 RECORD(EXPR_CXX_THROW);
723 RECORD(EXPR_CXX_DEFAULT_ARG);
724 RECORD(EXPR_CXX_BIND_TEMPORARY);
725 RECORD(EXPR_CXX_SCALAR_VALUE_INIT);
726 RECORD(EXPR_CXX_NEW);
727 RECORD(EXPR_CXX_DELETE);
728 RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR);
729 RECORD(EXPR_EXPR_WITH_CLEANUPS);
730 RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER);
731 RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF);
732 RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT);
733 RECORD(EXPR_CXX_UNRESOLVED_MEMBER);
734 RECORD(EXPR_CXX_UNRESOLVED_LOOKUP);
735 RECORD(EXPR_CXX_UNARY_TYPE_TRAIT);
736 RECORD(EXPR_CXX_NOEXCEPT);
737 RECORD(EXPR_OPAQUE_VALUE);
738 RECORD(EXPR_BINARY_TYPE_TRAIT);
739 RECORD(EXPR_PACK_EXPANSION);
740 RECORD(EXPR_SIZEOF_PACK);
741 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK);
742 RECORD(EXPR_CUDA_KERNEL_CALL);
746 void ASTWriter::WriteBlockInfoBlock() {
748 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3);
750 #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
751 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
753 // AST Top-Level Block.
755 RECORD(ORIGINAL_FILE_NAME);
756 RECORD(ORIGINAL_FILE_ID);
759 RECORD(LANGUAGE_OPTIONS);
761 RECORD(IDENTIFIER_OFFSET);
762 RECORD(IDENTIFIER_TABLE);
763 RECORD(EXTERNAL_DEFINITIONS);
764 RECORD(SPECIAL_TYPES);
766 RECORD(TENTATIVE_DEFINITIONS);
767 RECORD(UNUSED_FILESCOPED_DECLS);
768 RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS);
769 RECORD(SELECTOR_OFFSETS);
771 RECORD(PP_COUNTER_VALUE);
772 RECORD(SOURCE_LOCATION_OFFSETS);
773 RECORD(SOURCE_LOCATION_PRELOADS);
775 RECORD(EXT_VECTOR_DECLS);
776 RECORD(VERSION_CONTROL_BRANCH_REVISION);
777 RECORD(PPD_ENTITIES_OFFSETS);
779 RECORD(REFERENCED_SELECTOR_POOL);
780 RECORD(TU_UPDATE_LEXICAL);
781 RECORD(REDECLS_UPDATE_LATEST);
782 RECORD(SEMA_DECL_REFS);
783 RECORD(WEAK_UNDECLARED_IDENTIFIERS);
784 RECORD(PENDING_IMPLICIT_INSTANTIATIONS);
785 RECORD(DECL_REPLACEMENTS);
786 RECORD(UPDATE_VISIBLE);
787 RECORD(DECL_UPDATE_OFFSETS);
788 RECORD(DECL_UPDATES);
789 RECORD(CXX_BASE_SPECIFIER_OFFSETS);
790 RECORD(DIAG_PRAGMA_MAPPINGS);
791 RECORD(CUDA_SPECIAL_DECL_REFS);
792 RECORD(HEADER_SEARCH_TABLE);
793 RECORD(ORIGINAL_PCH_DIR);
794 RECORD(FP_PRAGMA_OPTIONS);
795 RECORD(OPENCL_EXTENSIONS);
796 RECORD(DELEGATING_CTORS);
797 RECORD(FILE_SOURCE_LOCATION_OFFSETS);
798 RECORD(KNOWN_NAMESPACES);
799 RECORD(MODULE_OFFSET_MAP);
800 RECORD(SOURCE_MANAGER_LINE_TABLE);
802 // SourceManager Block.
803 BLOCK(SOURCE_MANAGER_BLOCK);
804 RECORD(SM_SLOC_FILE_ENTRY);
805 RECORD(SM_SLOC_BUFFER_ENTRY);
806 RECORD(SM_SLOC_BUFFER_BLOB);
807 RECORD(SM_SLOC_EXPANSION_ENTRY);
809 // Preprocessor Block.
810 BLOCK(PREPROCESSOR_BLOCK);
811 RECORD(PP_MACRO_OBJECT_LIKE);
812 RECORD(PP_MACRO_FUNCTION_LIKE);
815 // Decls and Types block.
816 BLOCK(DECLTYPES_BLOCK);
817 RECORD(TYPE_EXT_QUAL);
818 RECORD(TYPE_COMPLEX);
819 RECORD(TYPE_POINTER);
820 RECORD(TYPE_BLOCK_POINTER);
821 RECORD(TYPE_LVALUE_REFERENCE);
822 RECORD(TYPE_RVALUE_REFERENCE);
823 RECORD(TYPE_MEMBER_POINTER);
824 RECORD(TYPE_CONSTANT_ARRAY);
825 RECORD(TYPE_INCOMPLETE_ARRAY);
826 RECORD(TYPE_VARIABLE_ARRAY);
828 RECORD(TYPE_EXT_VECTOR);
829 RECORD(TYPE_FUNCTION_PROTO);
830 RECORD(TYPE_FUNCTION_NO_PROTO);
831 RECORD(TYPE_TYPEDEF);
832 RECORD(TYPE_TYPEOF_EXPR);
836 RECORD(TYPE_OBJC_INTERFACE);
837 RECORD(TYPE_OBJC_OBJECT);
838 RECORD(TYPE_OBJC_OBJECT_POINTER);
839 RECORD(TYPE_DECLTYPE);
840 RECORD(TYPE_ELABORATED);
841 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
842 RECORD(TYPE_UNRESOLVED_USING);
843 RECORD(TYPE_INJECTED_CLASS_NAME);
844 RECORD(TYPE_OBJC_OBJECT);
845 RECORD(TYPE_TEMPLATE_TYPE_PARM);
846 RECORD(TYPE_TEMPLATE_SPECIALIZATION);
847 RECORD(TYPE_DEPENDENT_NAME);
848 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
849 RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
851 RECORD(TYPE_PACK_EXPANSION);
852 RECORD(TYPE_ATTRIBUTED);
853 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
855 RECORD(DECL_TYPEDEF);
858 RECORD(DECL_ENUM_CONSTANT);
859 RECORD(DECL_FUNCTION);
860 RECORD(DECL_OBJC_METHOD);
861 RECORD(DECL_OBJC_INTERFACE);
862 RECORD(DECL_OBJC_PROTOCOL);
863 RECORD(DECL_OBJC_IVAR);
864 RECORD(DECL_OBJC_AT_DEFS_FIELD);
865 RECORD(DECL_OBJC_CLASS);
866 RECORD(DECL_OBJC_FORWARD_PROTOCOL);
867 RECORD(DECL_OBJC_CATEGORY);
868 RECORD(DECL_OBJC_CATEGORY_IMPL);
869 RECORD(DECL_OBJC_IMPLEMENTATION);
870 RECORD(DECL_OBJC_COMPATIBLE_ALIAS);
871 RECORD(DECL_OBJC_PROPERTY);
872 RECORD(DECL_OBJC_PROPERTY_IMPL);
875 RECORD(DECL_IMPLICIT_PARAM);
876 RECORD(DECL_PARM_VAR);
877 RECORD(DECL_FILE_SCOPE_ASM);
879 RECORD(DECL_CONTEXT_LEXICAL);
880 RECORD(DECL_CONTEXT_VISIBLE);
881 RECORD(DECL_NAMESPACE);
882 RECORD(DECL_NAMESPACE_ALIAS);
884 RECORD(DECL_USING_SHADOW);
885 RECORD(DECL_USING_DIRECTIVE);
886 RECORD(DECL_UNRESOLVED_USING_VALUE);
887 RECORD(DECL_UNRESOLVED_USING_TYPENAME);
888 RECORD(DECL_LINKAGE_SPEC);
889 RECORD(DECL_CXX_RECORD);
890 RECORD(DECL_CXX_METHOD);
891 RECORD(DECL_CXX_CONSTRUCTOR);
892 RECORD(DECL_CXX_DESTRUCTOR);
893 RECORD(DECL_CXX_CONVERSION);
894 RECORD(DECL_ACCESS_SPEC);
896 RECORD(DECL_FRIEND_TEMPLATE);
897 RECORD(DECL_CLASS_TEMPLATE);
898 RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
899 RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
900 RECORD(DECL_FUNCTION_TEMPLATE);
901 RECORD(DECL_TEMPLATE_TYPE_PARM);
902 RECORD(DECL_NON_TYPE_TEMPLATE_PARM);
903 RECORD(DECL_TEMPLATE_TEMPLATE_PARM);
904 RECORD(DECL_STATIC_ASSERT);
905 RECORD(DECL_CXX_BASE_SPECIFIERS);
906 RECORD(DECL_INDIRECTFIELD);
907 RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK);
909 // Statements and Exprs can occur in the Decls and Types block.
910 AddStmtsExprs(Stream, Record);
912 BLOCK(PREPROCESSOR_DETAIL_BLOCK);
913 RECORD(PPD_MACRO_EXPANSION);
914 RECORD(PPD_MACRO_DEFINITION);
915 RECORD(PPD_INCLUSION_DIRECTIVE);
922 /// \brief Adjusts the given filename to only write out the portion of the
923 /// filename that is not part of the system root directory.
925 /// \param Filename the file name to adjust.
927 /// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and
928 /// the returned filename will be adjusted by this system root.
930 /// \returns either the original filename (if it needs no adjustment) or the
931 /// adjusted filename (which points into the @p Filename parameter).
933 adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) {
934 assert(Filename && "No file name to adjust?");
936 if (isysroot.empty())
939 // Verify that the filename and the system root have the same prefix.
941 for (; Filename[Pos] && Pos < isysroot.size(); ++Pos)
942 if (Filename[Pos] != isysroot[Pos])
943 return Filename; // Prefixes don't match.
945 // We hit the end of the filename before we hit the end of the system root.
949 // If the file name has a '/' at the current position, skip over the '/'.
950 // We distinguish sysroot-based includes from absolute includes by the
951 // absence of '/' at the beginning of sysroot-based includes.
952 if (Filename[Pos] == '/')
955 return Filename + Pos;
958 /// \brief Write the AST metadata (e.g., i686-apple-darwin9).
959 void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot,
960 const std::string &OutputFile) {
961 using namespace llvm;
964 const TargetInfo &Target = Context.getTargetInfo();
965 BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev();
966 MetaAbbrev->Add(BitCodeAbbrevOp(METADATA));
967 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major
968 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor
969 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major
970 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor
971 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
972 MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Target triple
973 unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev);
976 Record.push_back(METADATA);
977 Record.push_back(VERSION_MAJOR);
978 Record.push_back(VERSION_MINOR);
979 Record.push_back(CLANG_VERSION_MAJOR);
980 Record.push_back(CLANG_VERSION_MINOR);
981 Record.push_back(!isysroot.empty());
982 const std::string &Triple = Target.getTriple().getTriple();
983 Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, Triple);
986 serialization::ModuleManager &Mgr = Chain->getModuleManager();
987 llvm::SmallVector<char, 128> ModulePaths;
990 for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end();
992 // Skip modules that weren't directly imported.
993 if (!(*M)->isDirectlyImported())
996 Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding
997 // FIXME: Write import location, once it matters.
998 // FIXME: This writes the absolute path for AST files we depend on.
999 const std::string &FileName = (*M)->FileName;
1000 Record.push_back(FileName.size());
1001 Record.append(FileName.begin(), FileName.end());
1003 Stream.EmitRecord(IMPORTS, Record);
1006 // Original file name and file ID
1007 SourceManager &SM = Context.getSourceManager();
1008 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1009 BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev();
1010 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME));
1011 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1012 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev);
1014 llvm::SmallString<128> MainFilePath(MainFile->getName());
1016 llvm::sys::fs::make_absolute(MainFilePath);
1018 const char *MainFileNameStr = MainFilePath.c_str();
1019 MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr,
1022 Record.push_back(ORIGINAL_FILE_NAME);
1023 Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr);
1026 Record.push_back(SM.getMainFileID().getOpaqueValue());
1027 Stream.EmitRecord(ORIGINAL_FILE_ID, Record);
1030 // Original PCH directory
1031 if (!OutputFile.empty() && OutputFile != "-") {
1032 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1033 Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
1034 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1035 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1037 llvm::SmallString<128> OutputPath(OutputFile);
1039 llvm::sys::fs::make_absolute(OutputPath);
1040 StringRef origDir = llvm::sys::path::parent_path(OutputPath);
1043 Record.push_back(ORIGINAL_PCH_DIR);
1044 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
1047 // Repository branch/version information.
1048 BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev();
1049 RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION));
1050 RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
1051 unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev);
1053 Record.push_back(VERSION_CONTROL_BRANCH_REVISION);
1054 Stream.EmitRecordWithBlob(RepoAbbrevCode, Record,
1055 getClangFullRepositoryVersion());
1058 /// \brief Write the LangOptions structure.
1059 void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
1061 #define LANGOPT(Name, Bits, Default, Description) \
1062 Record.push_back(LangOpts.Name);
1063 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1064 Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1065 #include "clang/Basic/LangOptions.def"
1066 Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
1069 //===----------------------------------------------------------------------===//
1070 // stat cache Serialization
1071 //===----------------------------------------------------------------------===//
1074 // Trait used for the on-disk hash table of stat cache results.
1075 class ASTStatCacheTrait {
1077 typedef const char * key_type;
1078 typedef key_type key_type_ref;
1080 typedef struct stat data_type;
1081 typedef const data_type &data_type_ref;
1083 static unsigned ComputeHash(const char *path) {
1084 return llvm::HashString(path);
1087 std::pair<unsigned,unsigned>
1088 EmitKeyDataLength(raw_ostream& Out, const char *path,
1089 data_type_ref Data) {
1090 unsigned StrLen = strlen(path);
1091 clang::io::Emit16(Out, StrLen);
1092 unsigned DataLen = 4 + 4 + 2 + 8 + 8;
1093 clang::io::Emit8(Out, DataLen);
1094 return std::make_pair(StrLen + 1, DataLen);
1097 void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) {
1098 Out.write(path, KeyLen);
1101 void EmitData(raw_ostream &Out, key_type_ref,
1102 data_type_ref Data, unsigned DataLen) {
1103 using namespace clang::io;
1104 uint64_t Start = Out.tell(); (void)Start;
1106 Emit32(Out, (uint32_t) Data.st_ino);
1107 Emit32(Out, (uint32_t) Data.st_dev);
1108 Emit16(Out, (uint16_t) Data.st_mode);
1109 Emit64(Out, (uint64_t) Data.st_mtime);
1110 Emit64(Out, (uint64_t) Data.st_size);
1112 assert(Out.tell() - Start == DataLen && "Wrong data length");
1115 } // end anonymous namespace
1117 /// \brief Write the stat() system call cache to the AST file.
1118 void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) {
1119 // Build the on-disk hash table containing information about every
1121 OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator;
1122 unsigned NumStatEntries = 0;
1123 for (MemorizeStatCalls::iterator Stat = StatCalls.begin(),
1124 StatEnd = StatCalls.end();
1125 Stat != StatEnd; ++Stat, ++NumStatEntries) {
1126 StringRef Filename = Stat->first();
1127 Generator.insert(Filename.data(), Stat->second);
1130 // Create the on-disk hash table in a buffer.
1131 llvm::SmallString<4096> StatCacheData;
1132 uint32_t BucketOffset;
1134 llvm::raw_svector_ostream Out(StatCacheData);
1135 // Make sure that no bucket is at offset 0
1136 clang::io::Emit32(Out, 0);
1137 BucketOffset = Generator.Emit(Out);
1140 // Create a blob abbreviation
1141 using namespace llvm;
1142 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1143 Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE));
1144 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1145 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1146 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1147 unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev);
1149 // Write the stat cache
1151 Record.push_back(STAT_CACHE);
1152 Record.push_back(BucketOffset);
1153 Record.push_back(NumStatEntries);
1154 Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str());
1157 //===----------------------------------------------------------------------===//
1158 // Source Manager Serialization
1159 //===----------------------------------------------------------------------===//
1161 /// \brief Create an abbreviation for the SLocEntry that refers to a
1163 static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
1164 using namespace llvm;
1165 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1166 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
1167 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1168 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1169 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1170 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1171 // FileEntry fields.
1172 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
1173 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
1174 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
1175 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1176 return Stream.EmitAbbrev(Abbrev);
1179 /// \brief Create an abbreviation for the SLocEntry that refers to a
1181 static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
1182 using namespace llvm;
1183 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1184 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
1185 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1186 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1187 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1188 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1189 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
1190 return Stream.EmitAbbrev(Abbrev);
1193 /// \brief Create an abbreviation for the SLocEntry that refers to a
1195 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
1196 using namespace llvm;
1197 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1198 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB));
1199 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
1200 return Stream.EmitAbbrev(Abbrev);
1203 /// \brief Create an abbreviation for the SLocEntry that refers to a macro
1205 static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
1206 using namespace llvm;
1207 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1208 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
1209 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1210 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
1211 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
1212 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
1213 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
1214 return Stream.EmitAbbrev(Abbrev);
1218 // Trait used for the on-disk hash table of header search information.
1219 class HeaderFileInfoTrait {
1223 // Keep track of the framework names we've used during serialization.
1224 SmallVector<char, 128> FrameworkStringData;
1225 llvm::StringMap<unsigned> FrameworkNameOffset;
1228 HeaderFileInfoTrait(ASTWriter &Writer, HeaderSearch &HS)
1229 : Writer(Writer), HS(HS) { }
1231 typedef const char *key_type;
1232 typedef key_type key_type_ref;
1234 typedef HeaderFileInfo data_type;
1235 typedef const data_type &data_type_ref;
1237 static unsigned ComputeHash(const char *path) {
1238 // The hash is based only on the filename portion of the key, so that the
1239 // reader can match based on filenames when symlinking or excess path
1240 // elements ("foo/../", "../") change the form of the name. However,
1241 // complete path is still the key.
1242 return llvm::HashString(llvm::sys::path::filename(path));
1245 std::pair<unsigned,unsigned>
1246 EmitKeyDataLength(raw_ostream& Out, const char *path,
1247 data_type_ref Data) {
1248 unsigned StrLen = strlen(path);
1249 clang::io::Emit16(Out, StrLen);
1250 unsigned DataLen = 1 + 2 + 4 + 4;
1251 clang::io::Emit8(Out, DataLen);
1252 return std::make_pair(StrLen + 1, DataLen);
1255 void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) {
1256 Out.write(path, KeyLen);
1259 void EmitData(raw_ostream &Out, key_type_ref,
1260 data_type_ref Data, unsigned DataLen) {
1261 using namespace clang::io;
1262 uint64_t Start = Out.tell(); (void)Start;
1264 unsigned char Flags = (Data.isImport << 5)
1265 | (Data.isPragmaOnce << 4)
1266 | (Data.DirInfo << 2)
1267 | (Data.Resolved << 1)
1268 | Data.IndexHeaderMapHeader;
1269 Emit8(Out, (uint8_t)Flags);
1270 Emit16(Out, (uint16_t) Data.NumIncludes);
1272 if (!Data.ControllingMacro)
1273 Emit32(Out, (uint32_t)Data.ControllingMacroID);
1275 Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro));
1277 unsigned Offset = 0;
1278 if (!Data.Framework.empty()) {
1279 // If this header refers into a framework, save the framework name.
1280 llvm::StringMap<unsigned>::iterator Pos
1281 = FrameworkNameOffset.find(Data.Framework);
1282 if (Pos == FrameworkNameOffset.end()) {
1283 Offset = FrameworkStringData.size() + 1;
1284 FrameworkStringData.append(Data.Framework.begin(),
1285 Data.Framework.end());
1286 FrameworkStringData.push_back(0);
1288 FrameworkNameOffset[Data.Framework] = Offset;
1290 Offset = Pos->second;
1292 Emit32(Out, Offset);
1294 assert(Out.tell() - Start == DataLen && "Wrong data length");
1297 const char *strings_begin() const { return FrameworkStringData.begin(); }
1298 const char *strings_end() const { return FrameworkStringData.end(); }
1300 } // end anonymous namespace
1302 /// \brief Write the header search block for the list of files that
1304 /// \param HS The header search structure to save.
1306 /// \param Chain Whether we're creating a chained AST file.
1307 void ASTWriter::WriteHeaderSearch(HeaderSearch &HS, StringRef isysroot) {
1308 SmallVector<const FileEntry *, 16> FilesByUID;
1309 HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
1311 if (FilesByUID.size() > HS.header_file_size())
1312 FilesByUID.resize(HS.header_file_size());
1314 HeaderFileInfoTrait GeneratorTrait(*this, HS);
1315 OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
1316 SmallVector<const char *, 4> SavedStrings;
1317 unsigned NumHeaderSearchEntries = 0;
1318 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
1319 const FileEntry *File = FilesByUID[UID];
1323 const HeaderFileInfo &HFI = HS.header_file_begin()[UID];
1324 if (HFI.External && Chain)
1327 // Turn the file name into an absolute path, if it isn't already.
1328 const char *Filename = File->getName();
1329 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1331 // If we performed any translation on the file name at all, we need to
1332 // save this string, since the generator will refer to it later.
1333 if (Filename != File->getName()) {
1334 Filename = strdup(Filename);
1335 SavedStrings.push_back(Filename);
1338 Generator.insert(Filename, HFI, GeneratorTrait);
1339 ++NumHeaderSearchEntries;
1342 // Create the on-disk hash table in a buffer.
1343 llvm::SmallString<4096> TableData;
1344 uint32_t BucketOffset;
1346 llvm::raw_svector_ostream Out(TableData);
1347 // Make sure that no bucket is at offset 0
1348 clang::io::Emit32(Out, 0);
1349 BucketOffset = Generator.Emit(Out, GeneratorTrait);
1352 // Create a blob abbreviation
1353 using namespace llvm;
1354 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1355 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
1356 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1357 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1358 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1359 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1360 unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev);
1362 // Write the header search table
1364 Record.push_back(HEADER_SEARCH_TABLE);
1365 Record.push_back(BucketOffset);
1366 Record.push_back(NumHeaderSearchEntries);
1367 Record.push_back(TableData.size());
1368 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
1369 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str());
1371 // Free all of the strings we had to duplicate.
1372 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
1373 free((void*)SavedStrings[I]);
1376 /// \brief Writes the block containing the serialized form of the
1379 /// TODO: We should probably use an on-disk hash table (stored in a
1380 /// blob), indexed based on the file name, so that we only create
1381 /// entries for files that we actually need. In the common case (no
1382 /// errors), we probably won't have to create file entries for any of
1383 /// the files in the AST.
1384 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
1385 const Preprocessor &PP,
1386 StringRef isysroot) {
1389 // Enter the source manager block.
1390 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3);
1392 // Abbreviations for the various kinds of source-location entries.
1393 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
1394 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
1395 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream);
1396 unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
1398 // Write out the source location entry table. We skip the first
1399 // entry, which is always the same dummy entry.
1400 std::vector<uint32_t> SLocEntryOffsets;
1401 // Write out the offsets of only source location file entries.
1402 // We will go through them in ASTReader::validateFileEntries().
1403 std::vector<uint32_t> SLocFileEntryOffsets;
1404 RecordData PreloadSLocs;
1405 SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
1406 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
1408 // Get this source location entry.
1409 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
1411 // Record the offset of this source-location entry.
1412 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
1414 // Figure out which record code to use.
1416 if (SLoc->isFile()) {
1417 if (SLoc->getFile().getContentCache()->OrigEntry) {
1418 Code = SM_SLOC_FILE_ENTRY;
1419 SLocFileEntryOffsets.push_back(Stream.GetCurrentBitNo());
1421 Code = SM_SLOC_BUFFER_ENTRY;
1423 Code = SM_SLOC_EXPANSION_ENTRY;
1425 Record.push_back(Code);
1427 // Starting offset of this entry within this module, so skip the dummy.
1428 Record.push_back(SLoc->getOffset() - 2);
1429 if (SLoc->isFile()) {
1430 const SrcMgr::FileInfo &File = SLoc->getFile();
1431 Record.push_back(File.getIncludeLoc().getRawEncoding());
1432 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
1433 Record.push_back(File.hasLineDirectives());
1435 const SrcMgr::ContentCache *Content = File.getContentCache();
1436 if (Content->OrigEntry) {
1437 assert(Content->OrigEntry == Content->ContentsEntry &&
1438 "Writing to AST an overriden file is not supported");
1440 // The source location entry is a file. The blob associated
1441 // with this entry is the file name.
1443 // Emit size/modification time for this file.
1444 Record.push_back(Content->OrigEntry->getSize());
1445 Record.push_back(Content->OrigEntry->getModificationTime());
1447 Record.push_back(File.NumCreatedFIDs);
1449 // Turn the file name into an absolute path, if it isn't already.
1450 const char *Filename = Content->OrigEntry->getName();
1451 llvm::SmallString<128> FilePath(Filename);
1453 // Ask the file manager to fixup the relative path for us. This will
1454 // honor the working directory.
1455 SourceMgr.getFileManager().FixupRelativePath(FilePath);
1457 // FIXME: This call to make_absolute shouldn't be necessary, the
1458 // call to FixupRelativePath should always return an absolute path.
1459 llvm::sys::fs::make_absolute(FilePath);
1460 Filename = FilePath.c_str();
1462 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1463 Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename);
1465 // The source location entry is a buffer. The blob associated
1466 // with this entry contains the contents of the buffer.
1468 // We add one to the size so that we capture the trailing NULL
1469 // that is required by llvm::MemoryBuffer::getMemBuffer (on
1470 // the reader side).
1471 const llvm::MemoryBuffer *Buffer
1472 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
1473 const char *Name = Buffer->getBufferIdentifier();
1474 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
1475 StringRef(Name, strlen(Name) + 1));
1477 Record.push_back(SM_SLOC_BUFFER_BLOB);
1478 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
1479 StringRef(Buffer->getBufferStart(),
1480 Buffer->getBufferSize() + 1));
1482 if (strcmp(Name, "<built-in>") == 0) {
1483 PreloadSLocs.push_back(SLocEntryOffsets.size());
1487 // The source location entry is a macro expansion.
1488 const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
1489 Record.push_back(Expansion.getSpellingLoc().getRawEncoding());
1490 Record.push_back(Expansion.getExpansionLocStart().getRawEncoding());
1491 Record.push_back(Expansion.isMacroArgExpansion() ? 0
1492 : Expansion.getExpansionLocEnd().getRawEncoding());
1494 // Compute the token length for this macro expansion.
1495 unsigned NextOffset = SourceMgr.getNextLocalOffset();
1497 NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
1498 Record.push_back(NextOffset - SLoc->getOffset() - 1);
1499 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
1505 if (SLocEntryOffsets.empty())
1508 // Write the source-location offsets table into the AST block. This
1509 // table is used for lazily loading source-location information.
1510 using namespace llvm;
1511 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1512 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
1513 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
1514 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
1515 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
1516 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
1519 Record.push_back(SOURCE_LOCATION_OFFSETS);
1520 Record.push_back(SLocEntryOffsets.size());
1521 Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy
1522 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets));
1524 Abbrev = new BitCodeAbbrev();
1525 Abbrev->Add(BitCodeAbbrevOp(FILE_SOURCE_LOCATION_OFFSETS));
1526 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
1527 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
1528 unsigned SLocFileOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
1531 Record.push_back(FILE_SOURCE_LOCATION_OFFSETS);
1532 Record.push_back(SLocFileEntryOffsets.size());
1533 Stream.EmitRecordWithBlob(SLocFileOffsetsAbbrev, Record,
1534 data(SLocFileEntryOffsets));
1536 // Write the source location entry preloads array, telling the AST
1537 // reader which source locations entries it should load eagerly.
1538 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
1540 // Write the line table. It depends on remapping working, so it must come
1541 // after the source location offsets.
1542 if (SourceMgr.hasLineTable()) {
1543 LineTableInfo &LineTable = SourceMgr.getLineTable();
1546 // Emit the file names
1547 Record.push_back(LineTable.getNumFilenames());
1548 for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) {
1549 // Emit the file name
1550 const char *Filename = LineTable.getFilename(I);
1551 Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1552 unsigned FilenameLen = Filename? strlen(Filename) : 0;
1553 Record.push_back(FilenameLen);
1555 Record.insert(Record.end(), Filename, Filename + FilenameLen);
1558 // Emit the line entries
1559 for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end();
1561 // Only emit entries for local files.
1566 Record.push_back(L->first);
1568 // Emit the line entries
1569 Record.push_back(L->second.size());
1570 for (std::vector<LineEntry>::iterator LE = L->second.begin(),
1571 LEEnd = L->second.end();
1572 LE != LEEnd; ++LE) {
1573 Record.push_back(LE->FileOffset);
1574 Record.push_back(LE->LineNo);
1575 Record.push_back(LE->FilenameID);
1576 Record.push_back((unsigned)LE->FileKind);
1577 Record.push_back(LE->IncludeOffset);
1580 Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record);
1584 //===----------------------------------------------------------------------===//
1585 // Preprocessor Serialization
1586 //===----------------------------------------------------------------------===//
1588 static int compareMacroDefinitions(const void *XPtr, const void *YPtr) {
1589 const std::pair<const IdentifierInfo *, MacroInfo *> &X =
1590 *(const std::pair<const IdentifierInfo *, MacroInfo *>*)XPtr;
1591 const std::pair<const IdentifierInfo *, MacroInfo *> &Y =
1592 *(const std::pair<const IdentifierInfo *, MacroInfo *>*)YPtr;
1593 return X.first->getName().compare(Y.first->getName());
1596 /// \brief Writes the block containing the serialized form of the
1599 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
1600 PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
1602 WritePreprocessorDetail(*PPRec);
1606 // If the preprocessor __COUNTER__ value has been bumped, remember it.
1607 if (PP.getCounterValue() != 0) {
1608 Record.push_back(PP.getCounterValue());
1609 Stream.EmitRecord(PP_COUNTER_VALUE, Record);
1613 // Enter the preprocessor block.
1614 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3);
1616 // If the AST file contains __DATE__ or __TIME__ emit a warning about this.
1617 // FIXME: use diagnostics subsystem for localization etc.
1618 if (PP.SawDateOrTime())
1619 fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n");
1622 // Loop over all the macro definitions that are live at the end of the file,
1623 // emitting each to the PP section.
1625 // Construct the list of macro definitions that need to be serialized.
1626 SmallVector<std::pair<const IdentifierInfo *, MacroInfo *>, 2>
1628 llvm::SmallPtrSet<const IdentifierInfo*, 4> MacroDefinitionsSeen;
1629 for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0),
1630 E = PP.macro_end(Chain == 0);
1632 if (!IsModule || I->second->isExported()) {
1633 MacroDefinitionsSeen.insert(I->first);
1634 MacrosToEmit.push_back(std::make_pair(I->first, I->second));
1638 // Sort the set of macro definitions that need to be serialized by the
1639 // name of the macro, to provide a stable ordering.
1640 llvm::array_pod_sort(MacrosToEmit.begin(), MacrosToEmit.end(),
1641 &compareMacroDefinitions);
1643 // Resolve any identifiers that defined macros at the time they were
1644 // deserialized, adding them to the list of macros to emit (if appropriate).
1645 for (unsigned I = 0, N = DeserializedMacroNames.size(); I != N; ++I) {
1646 IdentifierInfo *Name
1647 = const_cast<IdentifierInfo *>(DeserializedMacroNames[I]);
1648 if (Name->hasMacroDefinition() && MacroDefinitionsSeen.insert(Name))
1649 MacrosToEmit.push_back(std::make_pair(Name, PP.getMacroInfo(Name)));
1652 for (unsigned I = 0, N = MacrosToEmit.size(); I != N; ++I) {
1653 const IdentifierInfo *Name = MacrosToEmit[I].first;
1654 MacroInfo *MI = MacrosToEmit[I].second;
1658 // Don't emit builtin macros like __LINE__ to the AST file unless they have
1659 // been redefined by the header (in which case they are not isBuiltinMacro).
1660 // Also skip macros from a AST file if we're chaining.
1662 // FIXME: There is a (probably minor) optimization we could do here, if
1663 // the macro comes from the original PCH but the identifier comes from a
1664 // chained PCH, by storing the offset into the original PCH rather than
1665 // writing the macro definition a second time.
1666 if (MI->isBuiltinMacro() ||
1667 (Chain && Name->isFromAST() && MI->isFromAST() &&
1668 !MI->hasChangedAfterLoad()))
1671 AddIdentifierRef(Name, Record);
1672 MacroOffsets[Name] = Stream.GetCurrentBitNo();
1673 Record.push_back(MI->getDefinitionLoc().getRawEncoding());
1674 Record.push_back(MI->isUsed());
1675 AddSourceLocation(MI->getExportLocation(), Record);
1677 if (MI->isObjectLike()) {
1678 Code = PP_MACRO_OBJECT_LIKE;
1680 Code = PP_MACRO_FUNCTION_LIKE;
1682 Record.push_back(MI->isC99Varargs());
1683 Record.push_back(MI->isGNUVarargs());
1684 Record.push_back(MI->getNumArgs());
1685 for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
1687 AddIdentifierRef(*I, Record);
1690 // If we have a detailed preprocessing record, record the macro definition
1691 // ID that corresponds to this macro.
1693 Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
1695 Stream.EmitRecord(Code, Record);
1698 // Emit the tokens array.
1699 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
1700 // Note that we know that the preprocessor does not have any annotation
1701 // tokens in it because they are created by the parser, and thus can't be
1702 // in a macro definition.
1703 const Token &Tok = MI->getReplacementToken(TokNo);
1705 Record.push_back(Tok.getLocation().getRawEncoding());
1706 Record.push_back(Tok.getLength());
1708 // FIXME: When reading literal tokens, reconstruct the literal pointer if
1710 AddIdentifierRef(Tok.getIdentifierInfo(), Record);
1711 // FIXME: Should translate token kind to a stable encoding.
1712 Record.push_back(Tok.getKind());
1713 // FIXME: Should translate token flags to a stable encoding.
1714 Record.push_back(Tok.getFlags());
1716 Stream.EmitRecord(PP_TOKEN, Record);
1724 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
1725 if (PPRec.local_begin() == PPRec.local_end())
1728 SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
1730 // Enter the preprocessor block.
1731 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
1733 // If the preprocessor has a preprocessing record, emit it.
1734 unsigned NumPreprocessingRecords = 0;
1735 using namespace llvm;
1737 // Set up the abbreviation for
1738 unsigned InclusionAbbrev = 0;
1740 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1741 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
1742 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
1743 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
1744 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
1745 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1746 InclusionAbbrev = Stream.EmitAbbrev(Abbrev);
1749 unsigned FirstPreprocessorEntityID
1750 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
1751 + NUM_PREDEF_PP_ENTITY_IDS;
1752 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
1754 for (PreprocessingRecord::iterator E = PPRec.local_begin(),
1755 EEnd = PPRec.local_end();
1757 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
1760 PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(),
1761 Stream.GetCurrentBitNo()));
1763 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) {
1764 // Record this macro definition's ID.
1765 MacroDefinitions[MD] = NextPreprocessorEntityID;
1767 AddIdentifierRef(MD->getName(), Record);
1768 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
1772 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) {
1773 Record.push_back(ME->isBuiltinMacro());
1774 if (ME->isBuiltinMacro())
1775 AddIdentifierRef(ME->getName(), Record);
1777 Record.push_back(MacroDefinitions[ME->getDefinition()]);
1778 Stream.EmitRecord(PPD_MACRO_EXPANSION, Record);
1782 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) {
1783 Record.push_back(PPD_INCLUSION_DIRECTIVE);
1784 Record.push_back(ID->getFileName().size());
1785 Record.push_back(ID->wasInQuotes());
1786 Record.push_back(static_cast<unsigned>(ID->getKind()));
1787 llvm::SmallString<64> Buffer;
1788 Buffer += ID->getFileName();
1789 Buffer += ID->getFile()->getName();
1790 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
1794 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter");
1798 // Write the offsets table for the preprocessing record.
1799 if (NumPreprocessingRecords > 0) {
1800 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
1802 // Write the offsets table for identifier IDs.
1803 using namespace llvm;
1804 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1805 Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
1806 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
1807 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1808 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
1811 Record.push_back(PPD_ENTITIES_OFFSETS);
1812 Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS);
1813 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
1814 data(PreprocessedEntityOffsets));
1818 void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag) {
1820 for (DiagnosticsEngine::DiagStatePointsTy::const_iterator
1821 I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end();
1823 const DiagnosticsEngine::DiagStatePoint &point = *I;
1824 if (point.Loc.isInvalid())
1827 Record.push_back(point.Loc.getRawEncoding());
1828 for (DiagnosticsEngine::DiagState::const_iterator
1829 I = point.State->begin(), E = point.State->end(); I != E; ++I) {
1830 if (I->second.isPragma()) {
1831 Record.push_back(I->first);
1832 Record.push_back(I->second.getMapping());
1835 Record.push_back(-1); // mark the end of the diag/map pairs for this
1839 if (!Record.empty())
1840 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record);
1843 void ASTWriter::WriteCXXBaseSpecifiersOffsets() {
1844 if (CXXBaseSpecifiersOffsets.empty())
1849 // Create a blob abbreviation for the C++ base specifiers offsets.
1850 using namespace llvm;
1852 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1853 Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS));
1854 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
1855 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1856 unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
1858 // Write the base specifier offsets table.
1860 Record.push_back(CXX_BASE_SPECIFIER_OFFSETS);
1861 Record.push_back(CXXBaseSpecifiersOffsets.size());
1862 Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record,
1863 data(CXXBaseSpecifiersOffsets));
1866 //===----------------------------------------------------------------------===//
1867 // Type Serialization
1868 //===----------------------------------------------------------------------===//
1870 /// \brief Write the representation of a type to the AST stream.
1871 void ASTWriter::WriteType(QualType T) {
1872 TypeIdx &Idx = TypeIdxs[T];
1873 if (Idx.getIndex() == 0) // we haven't seen this type before.
1874 Idx = TypeIdx(NextTypeID++);
1876 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
1878 // Record the offset for this type.
1879 unsigned Index = Idx.getIndex() - FirstTypeID;
1880 if (TypeOffsets.size() == Index)
1881 TypeOffsets.push_back(Stream.GetCurrentBitNo());
1882 else if (TypeOffsets.size() < Index) {
1883 TypeOffsets.resize(Index + 1);
1884 TypeOffsets[Index] = Stream.GetCurrentBitNo();
1889 // Emit the type's representation.
1890 ASTTypeWriter W(*this, Record);
1892 if (T.hasLocalNonFastQualifiers()) {
1893 Qualifiers Qs = T.getLocalQualifiers();
1894 AddTypeRef(T.getLocalUnqualifiedType(), Record);
1895 Record.push_back(Qs.getAsOpaqueValue());
1896 W.Code = TYPE_EXT_QUAL;
1898 switch (T->getTypeClass()) {
1899 // For all of the concrete, non-dependent types, call the
1900 // appropriate visitor function.
1901 #define TYPE(Class, Base) \
1902 case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break;
1903 #define ABSTRACT_TYPE(Class, Base)
1904 #include "clang/AST/TypeNodes.def"
1908 // Emit the serialized record.
1909 Stream.EmitRecord(W.Code, Record);
1911 // Flush any expressions that were written as part of this type.
1915 //===----------------------------------------------------------------------===//
1916 // Declaration Serialization
1917 //===----------------------------------------------------------------------===//
1919 /// \brief Write the block containing all of the declaration IDs
1920 /// lexically declared within the given DeclContext.
1922 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
1923 /// bistream, or 0 if no block was written.
1924 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
1926 if (DC->decls_empty())
1929 uint64_t Offset = Stream.GetCurrentBitNo();
1931 Record.push_back(DECL_CONTEXT_LEXICAL);
1932 SmallVector<KindDeclIDPair, 64> Decls;
1933 for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
1935 Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D)));
1937 ++NumLexicalDeclContexts;
1938 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls));
1942 void ASTWriter::WriteTypeDeclOffsets() {
1943 using namespace llvm;
1946 // Write the type offsets array
1947 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1948 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
1949 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
1950 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
1951 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
1952 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
1954 Record.push_back(TYPE_OFFSET);
1955 Record.push_back(TypeOffsets.size());
1956 Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS);
1957 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets));
1959 // Write the declaration offsets array
1960 Abbrev = new BitCodeAbbrev();
1961 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
1962 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
1963 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
1964 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
1965 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
1967 Record.push_back(DECL_OFFSET);
1968 Record.push_back(DeclOffsets.size());
1969 Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS);
1970 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets));
1973 //===----------------------------------------------------------------------===//
1974 // Global Method Pool and Selector Serialization
1975 //===----------------------------------------------------------------------===//
1978 // Trait used for the on-disk hash table used in the method pool.
1979 class ASTMethodPoolTrait {
1983 typedef Selector key_type;
1984 typedef key_type key_type_ref;
1988 ObjCMethodList Instance, Factory;
1990 typedef const data_type& data_type_ref;
1992 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { }
1994 static unsigned ComputeHash(Selector Sel) {
1995 return serialization::ComputeHash(Sel);
1998 std::pair<unsigned,unsigned>
1999 EmitKeyDataLength(raw_ostream& Out, Selector Sel,
2000 data_type_ref Methods) {
2001 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
2002 clang::io::Emit16(Out, KeyLen);
2003 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
2004 for (const ObjCMethodList *Method = &Methods.Instance; Method;
2005 Method = Method->Next)
2008 for (const ObjCMethodList *Method = &Methods.Factory; Method;
2009 Method = Method->Next)
2012 clang::io::Emit16(Out, DataLen);
2013 return std::make_pair(KeyLen, DataLen);
2016 void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
2017 uint64_t Start = Out.tell();
2018 assert((Start >> 32) == 0 && "Selector key offset too large");
2019 Writer.SetSelectorOffset(Sel, Start);
2020 unsigned N = Sel.getNumArgs();
2021 clang::io::Emit16(Out, N);
2024 for (unsigned I = 0; I != N; ++I)
2025 clang::io::Emit32(Out,
2026 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
2029 void EmitData(raw_ostream& Out, key_type_ref,
2030 data_type_ref Methods, unsigned DataLen) {
2031 uint64_t Start = Out.tell(); (void)Start;
2032 clang::io::Emit32(Out, Methods.ID);
2033 unsigned NumInstanceMethods = 0;
2034 for (const ObjCMethodList *Method = &Methods.Instance; Method;
2035 Method = Method->Next)
2037 ++NumInstanceMethods;
2039 unsigned NumFactoryMethods = 0;
2040 for (const ObjCMethodList *Method = &Methods.Factory; Method;
2041 Method = Method->Next)
2043 ++NumFactoryMethods;
2045 clang::io::Emit16(Out, NumInstanceMethods);
2046 clang::io::Emit16(Out, NumFactoryMethods);
2047 for (const ObjCMethodList *Method = &Methods.Instance; Method;
2048 Method = Method->Next)
2050 clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
2051 for (const ObjCMethodList *Method = &Methods.Factory; Method;
2052 Method = Method->Next)
2054 clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
2056 assert(Out.tell() - Start == DataLen && "Data length is wrong");
2059 } // end anonymous namespace
2061 /// \brief Write ObjC data: selectors and the method pool.
2063 /// The method pool contains both instance and factory methods, stored
2064 /// in an on-disk hash table indexed by the selector. The hash table also
2065 /// contains an empty entry for every other selector known to Sema.
2066 void ASTWriter::WriteSelectors(Sema &SemaRef) {
2067 using namespace llvm;
2069 // Do we have to do anything at all?
2070 if (SemaRef.MethodPool.empty() && SelectorIDs.empty())
2072 unsigned NumTableEntries = 0;
2073 // Create and write out the blob that contains selectors and the method pool.
2075 OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
2076 ASTMethodPoolTrait Trait(*this);
2078 // Create the on-disk hash table representation. We walk through every
2079 // selector we've seen and look it up in the method pool.
2080 SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
2081 for (llvm::DenseMap<Selector, SelectorID>::iterator
2082 I = SelectorIDs.begin(), E = SelectorIDs.end();
2084 Selector S = I->first;
2085 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S);
2086 ASTMethodPoolTrait::data_type Data = {
2091 if (F != SemaRef.MethodPool.end()) {
2092 Data.Instance = F->second.first;
2093 Data.Factory = F->second.second;
2095 // Only write this selector if it's not in an existing AST or something
2097 if (Chain && I->second < FirstSelectorID) {
2098 // Selector already exists. Did it change?
2099 bool changed = false;
2100 for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method;
2102 if (!M->Method->isFromASTFile())
2105 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method;
2107 if (!M->Method->isFromASTFile())
2112 } else if (Data.Instance.Method || Data.Factory.Method) {
2113 // A new method pool entry.
2116 Generator.insert(S, Data, Trait);
2119 // Create the on-disk hash table in a buffer.
2120 llvm::SmallString<4096> MethodPool;
2121 uint32_t BucketOffset;
2123 ASTMethodPoolTrait Trait(*this);
2124 llvm::raw_svector_ostream Out(MethodPool);
2125 // Make sure that no bucket is at offset 0
2126 clang::io::Emit32(Out, 0);
2127 BucketOffset = Generator.Emit(Out, Trait);
2130 // Create a blob abbreviation
2131 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2132 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
2133 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2134 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2135 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2136 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev);
2138 // Write the method pool
2140 Record.push_back(METHOD_POOL);
2141 Record.push_back(BucketOffset);
2142 Record.push_back(NumTableEntries);
2143 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str());
2145 // Create a blob abbreviation for the selector table offsets.
2146 Abbrev = new BitCodeAbbrev();
2147 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
2148 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
2149 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2150 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2151 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2153 // Write the selector offsets table.
2155 Record.push_back(SELECTOR_OFFSETS);
2156 Record.push_back(SelectorOffsets.size());
2157 Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS);
2158 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
2159 data(SelectorOffsets));
2163 /// \brief Write the selectors referenced in @selector expression into AST file.
2164 void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
2165 using namespace llvm;
2166 if (SemaRef.ReferencedSelectors.empty())
2171 // Note: this writes out all references even for a dependent AST. But it is
2172 // very tricky to fix, and given that @selector shouldn't really appear in
2173 // headers, probably not worth it. It's not a correctness issue.
2174 for (DenseMap<Selector, SourceLocation>::iterator S =
2175 SemaRef.ReferencedSelectors.begin(),
2176 E = SemaRef.ReferencedSelectors.end(); S != E; ++S) {
2177 Selector Sel = (*S).first;
2178 SourceLocation Loc = (*S).second;
2179 AddSelectorRef(Sel, Record);
2180 AddSourceLocation(Loc, Record);
2182 Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record);
2185 //===----------------------------------------------------------------------===//
2186 // Identifier Table Serialization
2187 //===----------------------------------------------------------------------===//
2190 class ASTIdentifierTableTrait {
2195 /// \brief Determines whether this is an "interesting" identifier
2196 /// that needs a full IdentifierInfo structure written into the hash
2198 bool isInterestingIdentifier(IdentifierInfo *II, MacroInfo *&Macro) {
2199 if (II->isPoisoned() ||
2200 II->isExtensionToken() ||
2201 II->getObjCOrBuiltinID() ||
2202 II->getFETokenInfo<void>())
2205 return hasMacroDefinition(II, Macro);
2208 bool hasMacroDefinition(IdentifierInfo *II, MacroInfo *&Macro) {
2209 if (!II->hasMacroDefinition())
2212 if (Macro || (Macro = PP.getMacroInfo(II)))
2213 return !Macro->isBuiltinMacro() && (!IsModule || Macro->isExported());
2219 typedef IdentifierInfo* key_type;
2220 typedef key_type key_type_ref;
2222 typedef IdentID data_type;
2223 typedef data_type data_type_ref;
2225 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, bool IsModule)
2226 : Writer(Writer), PP(PP), IsModule(IsModule) { }
2228 static unsigned ComputeHash(const IdentifierInfo* II) {
2229 return llvm::HashString(II->getName());
2232 std::pair<unsigned,unsigned>
2233 EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) {
2234 unsigned KeyLen = II->getLength() + 1;
2235 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
2236 MacroInfo *Macro = 0;
2237 if (isInterestingIdentifier(II, Macro)) {
2238 DataLen += 2; // 2 bytes for builtin ID, flags
2239 if (hasMacroDefinition(II, Macro))
2241 for (IdentifierResolver::iterator D = IdentifierResolver::begin(II),
2242 DEnd = IdentifierResolver::end();
2244 DataLen += sizeof(DeclID);
2246 clang::io::Emit16(Out, DataLen);
2247 // We emit the key length after the data length so that every
2248 // string is preceded by a 16-bit length. This matches the PTH
2249 // format for storing identifiers.
2250 clang::io::Emit16(Out, KeyLen);
2251 return std::make_pair(KeyLen, DataLen);
2254 void EmitKey(raw_ostream& Out, const IdentifierInfo* II,
2256 // Record the location of the key data. This is used when generating
2257 // the mapping from persistent IDs to strings.
2258 Writer.SetIdentifierOffset(II, Out.tell());
2259 Out.write(II->getNameStart(), KeyLen);
2262 void EmitData(raw_ostream& Out, IdentifierInfo* II,
2263 IdentID ID, unsigned) {
2264 MacroInfo *Macro = 0;
2265 if (!isInterestingIdentifier(II, Macro)) {
2266 clang::io::Emit32(Out, ID << 1);
2270 clang::io::Emit32(Out, (ID << 1) | 0x01);
2272 bool HasMacroDefinition = hasMacroDefinition(II, Macro);
2273 Bits = (uint32_t)II->getObjCOrBuiltinID();
2274 Bits = (Bits << 1) | unsigned(HasMacroDefinition);
2275 Bits = (Bits << 1) | unsigned(II->isExtensionToken());
2276 Bits = (Bits << 1) | unsigned(II->isPoisoned());
2277 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
2278 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
2279 clang::io::Emit16(Out, Bits);
2281 if (HasMacroDefinition)
2282 clang::io::Emit32(Out, Writer.getMacroOffset(II));
2284 // Emit the declaration IDs in reverse order, because the
2285 // IdentifierResolver provides the declarations as they would be
2286 // visible (e.g., the function "stat" would come before the struct
2287 // "stat"), but IdentifierResolver::AddDeclToIdentifierChain()
2288 // adds declarations to the end of the list (so we need to see the
2289 // struct "status" before the function "status").
2290 // Only emit declarations that aren't from a chained PCH, though.
2291 SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II),
2292 IdentifierResolver::end());
2293 for (SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(),
2294 DEnd = Decls.rend();
2296 clang::io::Emit32(Out, Writer.getDeclID(*D));
2299 } // end anonymous namespace
2301 /// \brief Write the identifier table into the AST file.
2303 /// The identifier table consists of a blob containing string data
2304 /// (the actual identifiers themselves) and a separate "offsets" index
2305 /// that maps identifier IDs to locations within the blob.
2306 void ASTWriter::WriteIdentifierTable(Preprocessor &PP, bool IsModule) {
2307 using namespace llvm;
2309 // Create and write out the blob that contains the identifier
2312 OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
2313 ASTIdentifierTableTrait Trait(*this, PP, IsModule);
2315 // Look for any identifiers that were named while processing the
2316 // headers, but are otherwise not needed. We add these to the hash
2317 // table to enable checking of the predefines buffer in the case
2318 // where the user adds new macro definitions when building the AST
2320 for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
2321 IDEnd = PP.getIdentifierTable().end();
2323 getIdentifierRef(ID->second);
2325 // Create the on-disk hash table representation. We only store offsets
2326 // for identifiers that appear here for the first time.
2327 IdentifierOffsets.resize(NextIdentID - FirstIdentID);
2328 for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator
2329 ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end();
2330 ID != IDEnd; ++ID) {
2331 assert(ID->first && "NULL identifier in identifier table");
2332 if (!Chain || !ID->first->isFromAST())
2333 Generator.insert(const_cast<IdentifierInfo *>(ID->first), ID->second,
2337 // Create the on-disk hash table in a buffer.
2338 llvm::SmallString<4096> IdentifierTable;
2339 uint32_t BucketOffset;
2341 ASTIdentifierTableTrait Trait(*this, PP, IsModule);
2342 llvm::raw_svector_ostream Out(IdentifierTable);
2343 // Make sure that no bucket is at offset 0
2344 clang::io::Emit32(Out, 0);
2345 BucketOffset = Generator.Emit(Out, Trait);
2348 // Create a blob abbreviation
2349 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2350 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
2351 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2352 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2353 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev);
2355 // Write the identifier table
2357 Record.push_back(IDENTIFIER_TABLE);
2358 Record.push_back(BucketOffset);
2359 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
2362 // Write the offsets table for identifier IDs.
2363 BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2364 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
2365 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
2366 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2367 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2368 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2371 Record.push_back(IDENTIFIER_OFFSET);
2372 Record.push_back(IdentifierOffsets.size());
2373 Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS);
2374 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
2375 data(IdentifierOffsets));
2378 //===----------------------------------------------------------------------===//
2379 // DeclContext's Name Lookup Table Serialization
2380 //===----------------------------------------------------------------------===//
2383 // Trait used for the on-disk hash table used in the method pool.
2384 class ASTDeclContextNameLookupTrait {
2388 typedef DeclarationName key_type;
2389 typedef key_type key_type_ref;
2391 typedef DeclContext::lookup_result data_type;
2392 typedef const data_type& data_type_ref;
2394 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { }
2396 unsigned ComputeHash(DeclarationName Name) {
2397 llvm::FoldingSetNodeID ID;
2398 ID.AddInteger(Name.getNameKind());
2400 switch (Name.getNameKind()) {
2401 case DeclarationName::Identifier:
2402 ID.AddString(Name.getAsIdentifierInfo()->getName());
2404 case DeclarationName::ObjCZeroArgSelector:
2405 case DeclarationName::ObjCOneArgSelector:
2406 case DeclarationName::ObjCMultiArgSelector:
2407 ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector()));
2409 case DeclarationName::CXXConstructorName:
2410 case DeclarationName::CXXDestructorName:
2411 case DeclarationName::CXXConversionFunctionName:
2413 case DeclarationName::CXXOperatorName:
2414 ID.AddInteger(Name.getCXXOverloadedOperator());
2416 case DeclarationName::CXXLiteralOperatorName:
2417 ID.AddString(Name.getCXXLiteralIdentifier()->getName());
2418 case DeclarationName::CXXUsingDirective:
2422 return ID.ComputeHash();
2425 std::pair<unsigned,unsigned>
2426 EmitKeyDataLength(raw_ostream& Out, DeclarationName Name,
2427 data_type_ref Lookup) {
2428 unsigned KeyLen = 1;
2429 switch (Name.getNameKind()) {
2430 case DeclarationName::Identifier:
2431 case DeclarationName::ObjCZeroArgSelector:
2432 case DeclarationName::ObjCOneArgSelector:
2433 case DeclarationName::ObjCMultiArgSelector:
2434 case DeclarationName::CXXLiteralOperatorName:
2437 case DeclarationName::CXXOperatorName:
2440 case DeclarationName::CXXConstructorName:
2441 case DeclarationName::CXXDestructorName:
2442 case DeclarationName::CXXConversionFunctionName:
2443 case DeclarationName::CXXUsingDirective:
2446 clang::io::Emit16(Out, KeyLen);
2448 // 2 bytes for num of decls and 4 for each DeclID.
2449 unsigned DataLen = 2 + 4 * (Lookup.second - Lookup.first);
2450 clang::io::Emit16(Out, DataLen);
2452 return std::make_pair(KeyLen, DataLen);
2455 void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) {
2456 using namespace clang::io;
2458 assert(Name.getNameKind() < 0x100 && "Invalid name kind ?");
2459 Emit8(Out, Name.getNameKind());
2460 switch (Name.getNameKind()) {
2461 case DeclarationName::Identifier:
2462 Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
2464 case DeclarationName::ObjCZeroArgSelector:
2465 case DeclarationName::ObjCOneArgSelector:
2466 case DeclarationName::ObjCMultiArgSelector:
2467 Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector()));
2469 case DeclarationName::CXXOperatorName:
2470 assert(Name.getCXXOverloadedOperator() < 0x100 && "Invalid operator ?");
2471 Emit8(Out, Name.getCXXOverloadedOperator());
2473 case DeclarationName::CXXLiteralOperatorName:
2474 Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
2476 case DeclarationName::CXXConstructorName:
2477 case DeclarationName::CXXDestructorName:
2478 case DeclarationName::CXXConversionFunctionName:
2479 case DeclarationName::CXXUsingDirective:
2484 void EmitData(raw_ostream& Out, key_type_ref,
2485 data_type Lookup, unsigned DataLen) {
2486 uint64_t Start = Out.tell(); (void)Start;
2487 clang::io::Emit16(Out, Lookup.second - Lookup.first);
2488 for (; Lookup.first != Lookup.second; ++Lookup.first)
2489 clang::io::Emit32(Out, Writer.GetDeclRef(*Lookup.first));
2491 assert(Out.tell() - Start == DataLen && "Data length is wrong");
2494 } // end anonymous namespace
2496 /// \brief Write the block containing all of the declaration IDs
2497 /// visible from the given DeclContext.
2499 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
2500 /// bitstream, or 0 if no block was written.
2501 uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
2503 if (DC->getPrimaryContext() != DC)
2506 // Since there is no name lookup into functions or methods, don't bother to
2507 // build a visible-declarations table for these entities.
2508 if (DC->isFunctionOrMethod())
2511 // If not in C++, we perform name lookup for the translation unit via the
2512 // IdentifierInfo chains, don't bother to build a visible-declarations table.
2513 // FIXME: In C++ we need the visible declarations in order to "see" the
2514 // friend declarations, is there a way to do this without writing the table ?
2515 if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus)
2518 // Force the DeclContext to build a its name-lookup table.
2519 if (!DC->hasExternalVisibleStorage())
2520 DC->lookup(DeclarationName());
2522 // Serialize the contents of the mapping used for lookup. Note that,
2523 // although we have two very different code paths, the serialized
2524 // representation is the same for both cases: a declaration name,
2525 // followed by a size, followed by references to the visible
2526 // declarations that have that name.
2527 uint64_t Offset = Stream.GetCurrentBitNo();
2528 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
2529 if (!Map || Map->empty())
2532 OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
2533 ASTDeclContextNameLookupTrait Trait(*this);
2535 // Create the on-disk hash table representation.
2536 DeclarationName ConversionName;
2537 llvm::SmallVector<NamedDecl *, 4> ConversionDecls;
2538 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
2540 DeclarationName Name = D->first;
2541 DeclContext::lookup_result Result = D->second.getLookupResult();
2542 if (Result.first != Result.second) {
2543 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
2544 // Hash all conversion function names to the same name. The actual
2545 // type information in conversion function name is not used in the
2546 // key (since such type information is not stable across different
2547 // modules), so the intended effect is to coalesce all of the conversion
2548 // functions under a single key.
2549 if (!ConversionName)
2550 ConversionName = Name;
2551 ConversionDecls.append(Result.first, Result.second);
2555 Generator.insert(Name, Result, Trait);
2559 // Add the conversion functions
2560 if (!ConversionDecls.empty()) {
2561 Generator.insert(ConversionName,
2562 DeclContext::lookup_result(ConversionDecls.begin(),
2563 ConversionDecls.end()),
2567 // Create the on-disk hash table in a buffer.
2568 llvm::SmallString<4096> LookupTable;
2569 uint32_t BucketOffset;
2571 llvm::raw_svector_ostream Out(LookupTable);
2572 // Make sure that no bucket is at offset 0
2573 clang::io::Emit32(Out, 0);
2574 BucketOffset = Generator.Emit(Out, Trait);
2577 // Write the lookup table
2579 Record.push_back(DECL_CONTEXT_VISIBLE);
2580 Record.push_back(BucketOffset);
2581 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
2584 Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record);
2585 ++NumVisibleDeclContexts;
2589 /// \brief Write an UPDATE_VISIBLE block for the given context.
2591 /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
2592 /// DeclContext in a dependent AST file. As such, they only exist for the TU
2593 /// (in C++) and for namespaces.
2594 void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
2595 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
2596 if (!Map || Map->empty())
2599 OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
2600 ASTDeclContextNameLookupTrait Trait(*this);
2602 // Create the hash table.
2603 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
2605 DeclarationName Name = D->first;
2606 DeclContext::lookup_result Result = D->second.getLookupResult();
2607 // For any name that appears in this table, the results are complete, i.e.
2608 // they overwrite results from previous PCHs. Merging is always a mess.
2609 if (Result.first != Result.second)
2610 Generator.insert(Name, Result, Trait);
2613 // Create the on-disk hash table in a buffer.
2614 llvm::SmallString<4096> LookupTable;
2615 uint32_t BucketOffset;
2617 llvm::raw_svector_ostream Out(LookupTable);
2618 // Make sure that no bucket is at offset 0
2619 clang::io::Emit32(Out, 0);
2620 BucketOffset = Generator.Emit(Out, Trait);
2623 // Write the lookup table
2625 Record.push_back(UPDATE_VISIBLE);
2626 Record.push_back(getDeclID(cast<Decl>(DC)));
2627 Record.push_back(BucketOffset);
2628 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str());
2631 /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions.
2632 void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) {
2634 Record.push_back(Opts.fp_contract);
2635 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record);
2638 /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions.
2639 void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
2640 if (!SemaRef.Context.getLangOptions().OpenCL)
2643 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions();
2645 #define OPENCLEXT(nm) Record.push_back(Opts.nm);
2646 #include "clang/Basic/OpenCLExtensions.def"
2647 Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
2650 //===----------------------------------------------------------------------===//
2651 // General Serialization Routines
2652 //===----------------------------------------------------------------------===//
2654 /// \brief Write a record containing the given attributes.
2655 void ASTWriter::WriteAttributes(const AttrVec &Attrs, RecordDataImpl &Record) {
2656 Record.push_back(Attrs.size());
2657 for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){
2658 const Attr * A = *i;
2659 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
2660 AddSourceRange(A->getRange(), Record);
2662 #include "clang/Serialization/AttrPCHWrite.inc"
2667 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) {
2668 Record.push_back(Str.size());
2669 Record.insert(Record.end(), Str.begin(), Str.end());
2672 void ASTWriter::AddVersionTuple(const VersionTuple &Version,
2673 RecordDataImpl &Record) {
2674 Record.push_back(Version.getMajor());
2675 if (llvm::Optional<unsigned> Minor = Version.getMinor())
2676 Record.push_back(*Minor + 1);
2678 Record.push_back(0);
2679 if (llvm::Optional<unsigned> Subminor = Version.getSubminor())
2680 Record.push_back(*Subminor + 1);
2682 Record.push_back(0);
2685 /// \brief Note that the identifier II occurs at the given offset
2686 /// within the identifier table.
2687 void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
2688 IdentID ID = IdentifierIDs[II];
2689 // Only store offsets new to this AST file. Other identifier names are looked
2690 // up earlier in the chain and thus don't need an offset.
2691 if (ID >= FirstIdentID)
2692 IdentifierOffsets[ID - FirstIdentID] = Offset;
2695 /// \brief Note that the selector Sel occurs at the given offset
2696 /// within the method pool/selector table.
2697 void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
2698 unsigned ID = SelectorIDs[Sel];
2699 assert(ID && "Unknown selector");
2700 // Don't record offsets for selectors that are also available in a different
2702 if (ID < FirstSelectorID)
2704 SelectorOffsets[ID - FirstSelectorID] = Offset;
2707 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream)
2708 : Stream(Stream), Context(0), Chain(0), WritingAST(false),
2709 FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID),
2710 FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID),
2711 FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID),
2712 FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID),
2713 CollectedStmts(&StmtsToEmit),
2714 NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0),
2715 NumVisibleDeclContexts(0),
2716 NextCXXBaseSpecifiersID(1),
2717 DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0),
2718 DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0),
2719 DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0),
2720 DeclRecordAbbrev(0), IntegerLiteralAbbrev(0),
2721 DeclTypedefAbbrev(0),
2722 DeclVarAbbrev(0), DeclFieldAbbrev(0),
2723 DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0)
2727 void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls,
2728 const std::string &OutputFile,
2729 bool IsModule, StringRef isysroot) {
2732 // Emit the file header.
2733 Stream.Emit((unsigned)'C', 8);
2734 Stream.Emit((unsigned)'P', 8);
2735 Stream.Emit((unsigned)'C', 8);
2736 Stream.Emit((unsigned)'H', 8);
2738 WriteBlockInfoBlock();
2740 Context = &SemaRef.Context;
2741 WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile, IsModule);
2747 template<typename Vector>
2748 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
2749 ASTWriter::RecordData &Record) {
2750 for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end();
2752 Writer.AddDeclRef(*I, Record);
2756 void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
2758 const std::string &OutputFile, bool IsModule) {
2759 using namespace llvm;
2761 ASTContext &Context = SemaRef.Context;
2762 Preprocessor &PP = SemaRef.PP;
2764 // Set up predefined declaration IDs.
2765 DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID;
2766 if (Context.ObjCIdDecl)
2767 DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID;
2768 if (Context.ObjCSelDecl)
2769 DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID;
2770 if (Context.ObjCClassDecl)
2771 DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID;
2772 if (Context.Int128Decl)
2773 DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID;
2774 if (Context.UInt128Decl)
2775 DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID;
2776 if (Context.ObjCInstanceTypeDecl)
2777 DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID;
2780 // Make sure that we emit IdentifierInfos (and any attached
2781 // declarations) for builtins. We don't need to do this when we're
2782 // emitting chained PCH files, because all of the builtins will be
2783 // in the original PCH file.
2784 // FIXME: Modules won't like this at all.
2785 IdentifierTable &Table = PP.getIdentifierTable();
2786 SmallVector<const char *, 32> BuiltinNames;
2787 Context.BuiltinInfo.GetBuiltinNames(BuiltinNames,
2788 Context.getLangOptions().NoBuiltin);
2789 for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I)
2790 getIdentifierRef(&Table.get(BuiltinNames[I]));
2793 // Build a record containing all of the tentative definitions in this file, in
2794 // TentativeDefinitions order. Generally, this record will be empty for
2796 RecordData TentativeDefinitions;
2797 AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
2799 // Build a record containing all of the file scoped decls in this file.
2800 RecordData UnusedFileScopedDecls;
2801 AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls,
2802 UnusedFileScopedDecls);
2804 // Build a record containing all of the delegating constructors we still need
2806 RecordData DelegatingCtorDecls;
2807 AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls);
2809 // Write the set of weak, undeclared identifiers. We always write the
2810 // entire table, since later PCH files in a PCH chain are only interested in
2811 // the results at the end of the chain.
2812 RecordData WeakUndeclaredIdentifiers;
2813 if (!SemaRef.WeakUndeclaredIdentifiers.empty()) {
2814 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
2815 I = SemaRef.WeakUndeclaredIdentifiers.begin(),
2816 E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) {
2817 AddIdentifierRef(I->first, WeakUndeclaredIdentifiers);
2818 AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers);
2819 AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers);
2820 WeakUndeclaredIdentifiers.push_back(I->second.getUsed());
2824 // Build a record containing all of the locally-scoped external
2825 // declarations in this header file. Generally, this record will be
2827 RecordData LocallyScopedExternalDecls;
2828 // FIXME: This is filling in the AST file in densemap order which is
2830 for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
2831 TD = SemaRef.LocallyScopedExternalDecls.begin(),
2832 TDEnd = SemaRef.LocallyScopedExternalDecls.end();
2833 TD != TDEnd; ++TD) {
2834 if (!TD->second->isFromASTFile())
2835 AddDeclRef(TD->second, LocallyScopedExternalDecls);
2838 // Build a record containing all of the ext_vector declarations.
2839 RecordData ExtVectorDecls;
2840 AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls);
2842 // Build a record containing all of the VTable uses information.
2843 RecordData VTableUses;
2844 if (!SemaRef.VTableUses.empty()) {
2845 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
2846 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
2847 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
2848 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
2852 // Build a record containing all of dynamic classes declarations.
2853 RecordData DynamicClasses;
2854 AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses);
2856 // Build a record containing all of pending implicit instantiations.
2857 RecordData PendingInstantiations;
2858 for (std::deque<Sema::PendingImplicitInstantiation>::iterator
2859 I = SemaRef.PendingInstantiations.begin(),
2860 N = SemaRef.PendingInstantiations.end(); I != N; ++I) {
2861 AddDeclRef(I->first, PendingInstantiations);
2862 AddSourceLocation(I->second, PendingInstantiations);
2864 assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
2865 "There are local ones at end of translation unit!");
2867 // Build a record containing some declaration references.
2868 RecordData SemaDeclRefs;
2869 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) {
2870 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
2871 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
2874 RecordData CUDASpecialDeclRefs;
2875 if (Context.getcudaConfigureCallDecl()) {
2876 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs);
2879 // Build a record containing all of the known namespaces.
2880 RecordData KnownNamespaces;
2881 for (llvm::DenseMap<NamespaceDecl*, bool>::iterator
2882 I = SemaRef.KnownNamespaces.begin(),
2883 IEnd = SemaRef.KnownNamespaces.end();
2886 AddDeclRef(I->first, KnownNamespaces);
2889 // Write the remaining AST contents.
2891 Stream.EnterSubblock(AST_BLOCK_ID, 5);
2892 WriteMetadata(Context, isysroot, OutputFile);
2893 WriteLanguageOptions(Context.getLangOptions());
2894 if (StatCalls && isysroot.empty())
2895 WriteStatCache(*StatCalls);
2896 WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
2899 // Write the mapping information describing our module dependencies and how
2900 // each of those modules were mapped into our own offset/ID space, so that
2901 // the reader can build the appropriate mapping to its own offset/ID space.
2902 // The map consists solely of a blob with the following format:
2903 // *(module-name-len:i16 module-name:len*i8
2904 // source-location-offset:i32
2905 // identifier-id:i32
2906 // preprocessed-entity-id:i32
2907 // macro-definition-id:i32
2909 // declaration-id:i32
2910 // c++-base-specifiers-id:i32
2913 llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2914 Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
2915 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2916 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev);
2917 llvm::SmallString<2048> Buffer;
2919 llvm::raw_svector_ostream Out(Buffer);
2920 for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
2921 MEnd = Chain->ModuleMgr.end();
2923 StringRef FileName = (*M)->FileName;
2924 io::Emit16(Out, FileName.size());
2925 Out.write(FileName.data(), FileName.size());
2926 io::Emit32(Out, (*M)->SLocEntryBaseOffset);
2927 io::Emit32(Out, (*M)->BaseIdentifierID);
2928 io::Emit32(Out, (*M)->BasePreprocessedEntityID);
2929 io::Emit32(Out, (*M)->BaseSelectorID);
2930 io::Emit32(Out, (*M)->BaseDeclID);
2931 io::Emit32(Out, (*M)->BaseTypeIndex);
2935 Record.push_back(MODULE_OFFSET_MAP);
2936 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
2937 Buffer.data(), Buffer.size());
2940 // Create a lexical update block containing all of the declarations in the
2941 // translation unit that do not come from other AST files.
2942 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
2943 SmallVector<KindDeclIDPair, 64> NewGlobalDecls;
2944 for (DeclContext::decl_iterator I = TU->noload_decls_begin(),
2945 E = TU->noload_decls_end();
2947 if (!(*I)->isFromASTFile())
2948 NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I)));
2949 else if ((*I)->isChangedSinceDeserialization())
2950 (void)GetDeclRef(*I); // Make sure it's written, but don't record it.
2953 llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev();
2954 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
2955 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
2956 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv);
2958 Record.push_back(TU_UPDATE_LEXICAL);
2959 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
2960 data(NewGlobalDecls));
2962 // And a visible updates block for the translation unit.
2963 Abv = new llvm::BitCodeAbbrev();
2964 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
2965 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
2966 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32));
2967 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
2968 UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv);
2969 WriteDeclContextVisibleUpdate(TU);
2971 // If the translation unit has an anonymous namespace, and we don't already
2972 // have an update block for it, write it as an update block.
2973 if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
2974 ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
2975 if (Record.empty()) {
2976 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
2977 Record.push_back(reinterpret_cast<uint64_t>(NS));
2981 // Resolve any declaration pointers within the declaration updates block and
2982 // chained Objective-C categories block to declaration IDs.
2983 ResolveDeclUpdatesBlocks();
2984 ResolveChainedObjCCategories();
2986 // Form the record of special types.
2987 RecordData SpecialTypes;
2988 AddTypeRef(Context.getBuiltinVaListType(), SpecialTypes);
2989 AddTypeRef(Context.ObjCProtoType, SpecialTypes);
2990 AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
2991 AddTypeRef(Context.getFILEType(), SpecialTypes);
2992 AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
2993 AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
2994 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
2995 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
2996 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
2998 // Keep writing types and declarations until all types and
2999 // declarations have been written.
3000 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
3001 WriteDeclsBlockAbbrevs();
3002 for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(),
3003 E = DeclsToRewrite.end();
3005 DeclTypesToEmit.push(const_cast<Decl*>(*I));
3006 while (!DeclTypesToEmit.empty()) {
3007 DeclOrType DOT = DeclTypesToEmit.front();
3008 DeclTypesToEmit.pop();
3010 WriteType(DOT.getType());
3012 WriteDecl(Context, DOT.getDecl());
3016 WritePreprocessor(PP, IsModule);
3017 WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot);
3018 WriteSelectors(SemaRef);
3019 WriteReferencedSelectorsPool(SemaRef);
3020 WriteIdentifierTable(PP, IsModule);
3021 WriteFPPragmaOptions(SemaRef.getFPOptions());
3022 WriteOpenCLExtensions(SemaRef);
3024 WriteTypeDeclOffsets();
3025 WritePragmaDiagnosticMappings(Context.getDiagnostics());
3027 WriteCXXBaseSpecifiersOffsets();
3029 Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes);
3031 /// Build a record containing first declarations from a chained PCH and the
3032 /// most recent declarations in this AST that they point to.
3033 RecordData FirstLatestDeclIDs;
3034 for (FirstLatestDeclMap::iterator I = FirstLatestDecls.begin(),
3035 E = FirstLatestDecls.end();
3037 AddDeclRef(I->first, FirstLatestDeclIDs);
3038 AddDeclRef(I->second, FirstLatestDeclIDs);
3041 if (!FirstLatestDeclIDs.empty())
3042 Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs);
3044 // Write the record containing external, unnamed definitions.
3045 if (!ExternalDefinitions.empty())
3046 Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions);
3048 // Write the record containing tentative definitions.
3049 if (!TentativeDefinitions.empty())
3050 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
3052 // Write the record containing unused file scoped decls.
3053 if (!UnusedFileScopedDecls.empty())
3054 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
3056 // Write the record containing weak undeclared identifiers.
3057 if (!WeakUndeclaredIdentifiers.empty())
3058 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
3059 WeakUndeclaredIdentifiers);
3061 // Write the record containing locally-scoped external definitions.
3062 if (!LocallyScopedExternalDecls.empty())
3063 Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS,
3064 LocallyScopedExternalDecls);
3066 // Write the record containing ext_vector type names.
3067 if (!ExtVectorDecls.empty())
3068 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
3070 // Write the record containing VTable uses information.
3071 if (!VTableUses.empty())
3072 Stream.EmitRecord(VTABLE_USES, VTableUses);
3074 // Write the record containing dynamic classes declarations.
3075 if (!DynamicClasses.empty())
3076 Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses);
3078 // Write the record containing pending implicit instantiations.
3079 if (!PendingInstantiations.empty())
3080 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
3082 // Write the record containing declaration references of Sema.
3083 if (!SemaDeclRefs.empty())
3084 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
3086 // Write the record containing CUDA-specific declaration references.
3087 if (!CUDASpecialDeclRefs.empty())
3088 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs);
3090 // Write the delegating constructors.
3091 if (!DelegatingCtorDecls.empty())
3092 Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls);
3094 // Write the known namespaces.
3095 if (!KnownNamespaces.empty())
3096 Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces);
3098 // Write the visible updates to DeclContexts.
3099 for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator
3100 I = UpdatedDeclContexts.begin(),
3101 E = UpdatedDeclContexts.end();
3103 WriteDeclContextVisibleUpdate(*I);
3105 WriteDeclUpdatesBlocks();
3106 WriteDeclReplacementsBlock();
3107 WriteChainedObjCCategories();
3109 // Some simple statistics
3111 Record.push_back(NumStatements);
3112 Record.push_back(NumMacros);
3113 Record.push_back(NumLexicalDeclContexts);
3114 Record.push_back(NumVisibleDeclContexts);
3115 Stream.EmitRecord(STATISTICS, Record);
3119 /// \brief Go through the declaration update blocks and resolve declaration
3120 /// pointers into declaration IDs.
3121 void ASTWriter::ResolveDeclUpdatesBlocks() {
3122 for (DeclUpdateMap::iterator
3123 I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) {
3124 const Decl *D = I->first;
3125 UpdateRecord &URec = I->second;
3127 if (DeclsToRewrite.count(D))
3128 continue; // The decl will be written completely
3130 unsigned Idx = 0, N = URec.size();
3132 switch ((DeclUpdateKind)URec[Idx++]) {
3133 case UPD_CXX_SET_DEFINITIONDATA:
3134 case UPD_CXX_ADDED_IMPLICIT_MEMBER:
3135 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3136 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE:
3137 URec[Idx] = GetDeclRef(reinterpret_cast<Decl *>(URec[Idx]));
3141 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3149 void ASTWriter::WriteDeclUpdatesBlocks() {
3150 if (DeclUpdates.empty())
3153 RecordData OffsetsRecord;
3154 Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
3155 for (DeclUpdateMap::iterator
3156 I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) {
3157 const Decl *D = I->first;
3158 UpdateRecord &URec = I->second;
3160 if (DeclsToRewrite.count(D))
3161 continue; // The decl will be written completely,no need to store updates.
3163 uint64_t Offset = Stream.GetCurrentBitNo();
3164 Stream.EmitRecord(DECL_UPDATES, URec);
3166 OffsetsRecord.push_back(GetDeclRef(D));
3167 OffsetsRecord.push_back(Offset);
3170 Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord);
3173 void ASTWriter::WriteDeclReplacementsBlock() {
3174 if (ReplacedDecls.empty())
3178 for (SmallVector<std::pair<DeclID, uint64_t>, 16>::iterator
3179 I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) {
3180 Record.push_back(I->first);
3181 Record.push_back(I->second);
3183 Stream.EmitRecord(DECL_REPLACEMENTS, Record);
3186 void ASTWriter::ResolveChainedObjCCategories() {
3187 for (SmallVector<ChainedObjCCategoriesData, 16>::iterator
3188 I = LocalChainedObjCCategories.begin(),
3189 E = LocalChainedObjCCategories.end(); I != E; ++I) {
3190 ChainedObjCCategoriesData &Data = *I;
3191 Data.InterfaceID = GetDeclRef(Data.Interface);
3192 Data.TailCategoryID = GetDeclRef(Data.TailCategory);
3197 void ASTWriter::WriteChainedObjCCategories() {
3198 if (LocalChainedObjCCategories.empty())
3202 for (SmallVector<ChainedObjCCategoriesData, 16>::iterator
3203 I = LocalChainedObjCCategories.begin(),
3204 E = LocalChainedObjCCategories.end(); I != E; ++I) {
3205 ChainedObjCCategoriesData &Data = *I;
3206 serialization::DeclID
3207 HeadCatID = getDeclID(Data.Interface->getCategoryList());
3208 assert(HeadCatID != 0 && "Category not written ?");
3210 Record.push_back(Data.InterfaceID);
3211 Record.push_back(HeadCatID);
3212 Record.push_back(Data.TailCategoryID);
3214 Stream.EmitRecord(OBJC_CHAINED_CATEGORIES, Record);
3217 void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
3218 Record.push_back(Loc.getRawEncoding());
3221 void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
3222 AddSourceLocation(Range.getBegin(), Record);
3223 AddSourceLocation(Range.getEnd(), Record);
3226 void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) {
3227 Record.push_back(Value.getBitWidth());
3228 const uint64_t *Words = Value.getRawData();
3229 Record.append(Words, Words + Value.getNumWords());
3232 void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) {
3233 Record.push_back(Value.isUnsigned());
3234 AddAPInt(Value, Record);
3237 void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) {
3238 AddAPInt(Value.bitcastToAPInt(), Record);
3241 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
3242 Record.push_back(getIdentifierRef(II));
3245 IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
3249 IdentID &ID = IdentifierIDs[II];
3255 void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) {
3256 Record.push_back(getSelectorRef(SelRef));
3259 SelectorID ASTWriter::getSelectorRef(Selector Sel) {
3260 if (Sel.getAsOpaquePtr() == 0) {
3264 SelectorID &SID = SelectorIDs[Sel];
3265 if (SID == 0 && Chain) {
3266 // This might trigger a ReadSelector callback, which will set the ID for
3268 Chain->LoadSelector(Sel);
3271 SID = NextSelectorID++;
3276 void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) {
3277 AddDeclRef(Temp->getDestructor(), Record);
3280 void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases,
3281 CXXBaseSpecifier const *BasesEnd,
3282 RecordDataImpl &Record) {
3283 assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded");
3284 CXXBaseSpecifiersToWrite.push_back(
3285 QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID,
3287 Record.push_back(NextCXXBaseSpecifiersID++);
3290 void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
3291 const TemplateArgumentLocInfo &Arg,
3292 RecordDataImpl &Record) {
3294 case TemplateArgument::Expression:
3295 AddStmt(Arg.getAsExpr());
3297 case TemplateArgument::Type:
3298 AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record);
3300 case TemplateArgument::Template:
3301 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
3302 AddSourceLocation(Arg.getTemplateNameLoc(), Record);
3304 case TemplateArgument::TemplateExpansion:
3305 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
3306 AddSourceLocation(Arg.getTemplateNameLoc(), Record);
3307 AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record);
3309 case TemplateArgument::Null:
3310 case TemplateArgument::Integral:
3311 case TemplateArgument::Declaration:
3312 case TemplateArgument::Pack:
3317 void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
3318 RecordDataImpl &Record) {
3319 AddTemplateArgument(Arg.getArgument(), Record);
3321 if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
3322 bool InfoHasSameExpr
3323 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
3324 Record.push_back(InfoHasSameExpr);
3325 if (InfoHasSameExpr)
3326 return; // Avoid storing the same expr twice.
3328 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(),
3332 void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
3333 RecordDataImpl &Record) {
3335 AddTypeRef(QualType(), Record);
3339 AddTypeLoc(TInfo->getTypeLoc(), Record);
3342 void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) {
3343 AddTypeRef(TL.getType(), Record);
3345 TypeLocWriter TLW(*this, Record);
3346 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
3350 void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) {
3351 Record.push_back(GetOrCreateTypeID(T));
3354 TypeID ASTWriter::GetOrCreateTypeID( QualType T) {
3355 return MakeTypeID(*Context, T,
3356 std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this));
3359 TypeID ASTWriter::getTypeID(QualType T) const {
3360 return MakeTypeID(*Context, T,
3361 std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this));
3364 TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) {
3367 assert(!T.getLocalFastQualifiers());
3369 TypeIdx &Idx = TypeIdxs[T];
3370 if (Idx.getIndex() == 0) {
3371 // We haven't seen this type before. Assign it a new ID and put it
3372 // into the queue of types to emit.
3373 Idx = TypeIdx(NextTypeID++);
3374 DeclTypesToEmit.push(T);
3379 TypeIdx ASTWriter::getTypeIdx(QualType T) const {
3382 assert(!T.getLocalFastQualifiers());
3384 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3385 assert(I != TypeIdxs.end() && "Type not emitted!");
3389 void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) {
3390 Record.push_back(GetDeclRef(D));
3393 DeclID ASTWriter::GetDeclRef(const Decl *D) {
3394 assert(WritingAST && "Cannot request a declaration ID before AST writing");
3399 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
3400 DeclID &ID = DeclIDs[D];
3402 // We haven't seen this declaration before. Give it a new ID and
3403 // enqueue it in the list of declarations to emit.
3405 DeclTypesToEmit.push(const_cast<Decl *>(D));
3406 } else if (ID < FirstDeclID && D->isChangedSinceDeserialization()) {
3407 // We don't add it to the replacement collection here, because we don't
3408 // have the offset yet.
3409 DeclTypesToEmit.push(const_cast<Decl *>(D));
3410 // Reset the flag, so that we don't add this decl multiple times.
3411 const_cast<Decl *>(D)->setChangedSinceDeserialization(false);
3417 DeclID ASTWriter::getDeclID(const Decl *D) {
3421 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
3425 void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) {
3426 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc.
3427 Record.push_back(Name.getNameKind());
3428 switch (Name.getNameKind()) {
3429 case DeclarationName::Identifier:
3430 AddIdentifierRef(Name.getAsIdentifierInfo(), Record);
3433 case DeclarationName::ObjCZeroArgSelector:
3434 case DeclarationName::ObjCOneArgSelector:
3435 case DeclarationName::ObjCMultiArgSelector:
3436 AddSelectorRef(Name.getObjCSelector(), Record);
3439 case DeclarationName::CXXConstructorName:
3440 case DeclarationName::CXXDestructorName:
3441 case DeclarationName::CXXConversionFunctionName:
3442 AddTypeRef(Name.getCXXNameType(), Record);
3445 case DeclarationName::CXXOperatorName:
3446 Record.push_back(Name.getCXXOverloadedOperator());
3449 case DeclarationName::CXXLiteralOperatorName:
3450 AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record);
3453 case DeclarationName::CXXUsingDirective:
3454 // No extra data to emit
3459 void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
3460 DeclarationName Name, RecordDataImpl &Record) {
3461 switch (Name.getNameKind()) {
3462 case DeclarationName::CXXConstructorName:
3463 case DeclarationName::CXXDestructorName:
3464 case DeclarationName::CXXConversionFunctionName:
3465 AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record);
3468 case DeclarationName::CXXOperatorName:
3470 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc),
3473 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc),
3477 case DeclarationName::CXXLiteralOperatorName:
3479 SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc),
3483 case DeclarationName::Identifier:
3484 case DeclarationName::ObjCZeroArgSelector:
3485 case DeclarationName::ObjCOneArgSelector:
3486 case DeclarationName::ObjCMultiArgSelector:
3487 case DeclarationName::CXXUsingDirective:
3492 void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
3493 RecordDataImpl &Record) {
3494 AddDeclarationName(NameInfo.getName(), Record);
3495 AddSourceLocation(NameInfo.getLoc(), Record);
3496 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
3499 void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
3500 RecordDataImpl &Record) {
3501 AddNestedNameSpecifierLoc(Info.QualifierLoc, Record);
3502 Record.push_back(Info.NumTemplParamLists);
3503 for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i)
3504 AddTemplateParameterList(Info.TemplParamLists[i], Record);
3507 void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
3508 RecordDataImpl &Record) {
3509 // Nested name specifiers usually aren't too long. I think that 8 would
3510 // typically accommodate the vast majority.
3511 SmallVector<NestedNameSpecifier *, 8> NestedNames;
3513 // Push each of the NNS's onto a stack for serialization in reverse order.
3515 NestedNames.push_back(NNS);
3516 NNS = NNS->getPrefix();
3519 Record.push_back(NestedNames.size());
3520 while(!NestedNames.empty()) {
3521 NNS = NestedNames.pop_back_val();
3522 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
3523 Record.push_back(Kind);
3525 case NestedNameSpecifier::Identifier:
3526 AddIdentifierRef(NNS->getAsIdentifier(), Record);
3529 case NestedNameSpecifier::Namespace:
3530 AddDeclRef(NNS->getAsNamespace(), Record);
3533 case NestedNameSpecifier::NamespaceAlias:
3534 AddDeclRef(NNS->getAsNamespaceAlias(), Record);
3537 case NestedNameSpecifier::TypeSpec:
3538 case NestedNameSpecifier::TypeSpecWithTemplate:
3539 AddTypeRef(QualType(NNS->getAsType(), 0), Record);
3540 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
3543 case NestedNameSpecifier::Global:
3544 // Don't need to write an associated value.
3550 void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
3551 RecordDataImpl &Record) {
3552 // Nested name specifiers usually aren't too long. I think that 8 would
3553 // typically accommodate the vast majority.
3554 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
3556 // Push each of the nested-name-specifiers's onto a stack for
3557 // serialization in reverse order.
3559 NestedNames.push_back(NNS);
3560 NNS = NNS.getPrefix();
3563 Record.push_back(NestedNames.size());
3564 while(!NestedNames.empty()) {
3565 NNS = NestedNames.pop_back_val();
3566 NestedNameSpecifier::SpecifierKind Kind
3567 = NNS.getNestedNameSpecifier()->getKind();
3568 Record.push_back(Kind);
3570 case NestedNameSpecifier::Identifier:
3571 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record);
3572 AddSourceRange(NNS.getLocalSourceRange(), Record);
3575 case NestedNameSpecifier::Namespace:
3576 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record);
3577 AddSourceRange(NNS.getLocalSourceRange(), Record);
3580 case NestedNameSpecifier::NamespaceAlias:
3581 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record);
3582 AddSourceRange(NNS.getLocalSourceRange(), Record);
3585 case NestedNameSpecifier::TypeSpec:
3586 case NestedNameSpecifier::TypeSpecWithTemplate:
3587 Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
3588 AddTypeLoc(NNS.getTypeLoc(), Record);
3589 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
3592 case NestedNameSpecifier::Global:
3593 AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
3599 void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
3600 TemplateName::NameKind Kind = Name.getKind();
3601 Record.push_back(Kind);
3603 case TemplateName::Template:
3604 AddDeclRef(Name.getAsTemplateDecl(), Record);
3607 case TemplateName::OverloadedTemplate: {
3608 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate();
3609 Record.push_back(OvT->size());
3610 for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end();
3612 AddDeclRef(*I, Record);
3616 case TemplateName::QualifiedTemplate: {
3617 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
3618 AddNestedNameSpecifier(QualT->getQualifier(), Record);
3619 Record.push_back(QualT->hasTemplateKeyword());
3620 AddDeclRef(QualT->getTemplateDecl(), Record);
3624 case TemplateName::DependentTemplate: {
3625 DependentTemplateName *DepT = Name.getAsDependentTemplateName();
3626 AddNestedNameSpecifier(DepT->getQualifier(), Record);
3627 Record.push_back(DepT->isIdentifier());
3628 if (DepT->isIdentifier())
3629 AddIdentifierRef(DepT->getIdentifier(), Record);
3631 Record.push_back(DepT->getOperator());
3635 case TemplateName::SubstTemplateTemplateParm: {
3636 SubstTemplateTemplateParmStorage *subst
3637 = Name.getAsSubstTemplateTemplateParm();
3638 AddDeclRef(subst->getParameter(), Record);
3639 AddTemplateName(subst->getReplacement(), Record);
3643 case TemplateName::SubstTemplateTemplateParmPack: {
3644 SubstTemplateTemplateParmPackStorage *SubstPack
3645 = Name.getAsSubstTemplateTemplateParmPack();
3646 AddDeclRef(SubstPack->getParameterPack(), Record);
3647 AddTemplateArgument(SubstPack->getArgumentPack(), Record);
3653 void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
3654 RecordDataImpl &Record) {
3655 Record.push_back(Arg.getKind());
3656 switch (Arg.getKind()) {
3657 case TemplateArgument::Null:
3659 case TemplateArgument::Type:
3660 AddTypeRef(Arg.getAsType(), Record);
3662 case TemplateArgument::Declaration:
3663 AddDeclRef(Arg.getAsDecl(), Record);
3665 case TemplateArgument::Integral:
3666 AddAPSInt(*Arg.getAsIntegral(), Record);
3667 AddTypeRef(Arg.getIntegralType(), Record);
3669 case TemplateArgument::Template:
3670 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
3672 case TemplateArgument::TemplateExpansion:
3673 AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
3674 if (llvm::Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
3675 Record.push_back(*NumExpansions + 1);
3677 Record.push_back(0);
3679 case TemplateArgument::Expression:
3680 AddStmt(Arg.getAsExpr());
3682 case TemplateArgument::Pack:
3683 Record.push_back(Arg.pack_size());
3684 for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end();
3686 AddTemplateArgument(*I, Record);
3692 ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
3693 RecordDataImpl &Record) {
3694 assert(TemplateParams && "No TemplateParams!");
3695 AddSourceLocation(TemplateParams->getTemplateLoc(), Record);
3696 AddSourceLocation(TemplateParams->getLAngleLoc(), Record);
3697 AddSourceLocation(TemplateParams->getRAngleLoc(), Record);
3698 Record.push_back(TemplateParams->size());
3699 for (TemplateParameterList::const_iterator
3700 P = TemplateParams->begin(), PEnd = TemplateParams->end();
3702 AddDeclRef(*P, Record);
3705 /// \brief Emit a template argument list.
3707 ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
3708 RecordDataImpl &Record) {
3709 assert(TemplateArgs && "No TemplateArgs!");
3710 Record.push_back(TemplateArgs->size());
3711 for (int i=0, e = TemplateArgs->size(); i != e; ++i)
3712 AddTemplateArgument(TemplateArgs->get(i), Record);
3717 ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordDataImpl &Record) {
3718 Record.push_back(Set.size());
3719 for (UnresolvedSetImpl::const_iterator
3720 I = Set.begin(), E = Set.end(); I != E; ++I) {
3721 AddDeclRef(I.getDecl(), Record);
3722 Record.push_back(I.getAccess());
3726 void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
3727 RecordDataImpl &Record) {
3728 Record.push_back(Base.isVirtual());
3729 Record.push_back(Base.isBaseOfClass());
3730 Record.push_back(Base.getAccessSpecifierAsWritten());
3731 Record.push_back(Base.getInheritConstructors());
3732 AddTypeSourceInfo(Base.getTypeSourceInfo(), Record);
3733 AddSourceRange(Base.getSourceRange(), Record);
3734 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc()
3739 void ASTWriter::FlushCXXBaseSpecifiers() {
3741 for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) {
3744 // Record the offset of this base-specifier set.
3745 unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
3746 if (Index == CXXBaseSpecifiersOffsets.size())
3747 CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo());
3749 if (Index > CXXBaseSpecifiersOffsets.size())
3750 CXXBaseSpecifiersOffsets.resize(Index + 1);
3751 CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo();
3754 const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases,
3755 *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd;
3756 Record.push_back(BEnd - B);
3757 for (; B != BEnd; ++B)
3758 AddCXXBaseSpecifier(*B, Record);
3759 Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record);
3761 // Flush any expressions that were written as part of the base specifiers.
3765 CXXBaseSpecifiersToWrite.clear();
3768 void ASTWriter::AddCXXCtorInitializers(
3769 const CXXCtorInitializer * const *CtorInitializers,
3770 unsigned NumCtorInitializers,
3771 RecordDataImpl &Record) {
3772 Record.push_back(NumCtorInitializers);
3773 for (unsigned i=0; i != NumCtorInitializers; ++i) {
3774 const CXXCtorInitializer *Init = CtorInitializers[i];
3776 if (Init->isBaseInitializer()) {
3777 Record.push_back(CTOR_INITIALIZER_BASE);
3778 AddTypeSourceInfo(Init->getBaseClassInfo(), Record);
3779 Record.push_back(Init->isBaseVirtual());
3780 } else if (Init->isDelegatingInitializer()) {
3781 Record.push_back(CTOR_INITIALIZER_DELEGATING);
3782 AddDeclRef(Init->getTargetConstructor(), Record);
3783 } else if (Init->isMemberInitializer()){
3784 Record.push_back(CTOR_INITIALIZER_MEMBER);
3785 AddDeclRef(Init->getMember(), Record);
3787 Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
3788 AddDeclRef(Init->getIndirectMember(), Record);
3791 AddSourceLocation(Init->getMemberLocation(), Record);
3792 AddStmt(Init->getInit());
3793 AddSourceLocation(Init->getLParenLoc(), Record);
3794 AddSourceLocation(Init->getRParenLoc(), Record);
3795 Record.push_back(Init->isWritten());
3796 if (Init->isWritten()) {
3797 Record.push_back(Init->getSourceOrder());
3799 Record.push_back(Init->getNumArrayIndices());
3800 for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i)
3801 AddDeclRef(Init->getArrayIndex(i), Record);
3806 void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) {
3807 assert(D->DefinitionData);
3808 struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData;
3809 Record.push_back(Data.UserDeclaredConstructor);
3810 Record.push_back(Data.UserDeclaredCopyConstructor);
3811 Record.push_back(Data.UserDeclaredMoveConstructor);
3812 Record.push_back(Data.UserDeclaredCopyAssignment);
3813 Record.push_back(Data.UserDeclaredMoveAssignment);
3814 Record.push_back(Data.UserDeclaredDestructor);
3815 Record.push_back(Data.Aggregate);
3816 Record.push_back(Data.PlainOldData);
3817 Record.push_back(Data.Empty);
3818 Record.push_back(Data.Polymorphic);
3819 Record.push_back(Data.Abstract);
3820 Record.push_back(Data.IsStandardLayout);
3821 Record.push_back(Data.HasNoNonEmptyBases);
3822 Record.push_back(Data.HasPrivateFields);
3823 Record.push_back(Data.HasProtectedFields);
3824 Record.push_back(Data.HasPublicFields);
3825 Record.push_back(Data.HasMutableFields);
3826 Record.push_back(Data.HasTrivialDefaultConstructor);
3827 Record.push_back(Data.HasConstexprNonCopyMoveConstructor);
3828 Record.push_back(Data.HasTrivialCopyConstructor);
3829 Record.push_back(Data.HasTrivialMoveConstructor);
3830 Record.push_back(Data.HasTrivialCopyAssignment);
3831 Record.push_back(Data.HasTrivialMoveAssignment);
3832 Record.push_back(Data.HasTrivialDestructor);
3833 Record.push_back(Data.HasNonLiteralTypeFieldsOrBases);
3834 Record.push_back(Data.ComputedVisibleConversions);
3835 Record.push_back(Data.UserProvidedDefaultConstructor);
3836 Record.push_back(Data.DeclaredDefaultConstructor);
3837 Record.push_back(Data.DeclaredCopyConstructor);
3838 Record.push_back(Data.DeclaredMoveConstructor);
3839 Record.push_back(Data.DeclaredCopyAssignment);
3840 Record.push_back(Data.DeclaredMoveAssignment);
3841 Record.push_back(Data.DeclaredDestructor);
3842 Record.push_back(Data.FailedImplicitMoveConstructor);
3843 Record.push_back(Data.FailedImplicitMoveAssignment);
3845 Record.push_back(Data.NumBases);
3846 if (Data.NumBases > 0)
3847 AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases,
3850 // FIXME: Make VBases lazily computed when needed to avoid storing them.
3851 Record.push_back(Data.NumVBases);
3852 if (Data.NumVBases > 0)
3853 AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases,
3856 AddUnresolvedSet(Data.Conversions, Record);
3857 AddUnresolvedSet(Data.VisibleConversions, Record);
3858 // Data.Definition is the owning decl, no need to write it.
3859 AddDeclRef(Data.FirstFriend, Record);
3862 void ASTWriter::ReaderInitialized(ASTReader *Reader) {
3863 assert(Reader && "Cannot remove chain");
3864 assert((!Chain || Chain == Reader) && "Cannot replace chain");
3865 assert(FirstDeclID == NextDeclID &&
3866 FirstTypeID == NextTypeID &&
3867 FirstIdentID == NextIdentID &&
3868 FirstSelectorID == NextSelectorID &&
3869 "Setting chain after writing has started.");
3873 FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls();
3874 FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes();
3875 FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers();
3876 FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors();
3877 NextDeclID = FirstDeclID;
3878 NextTypeID = FirstTypeID;
3879 NextIdentID = FirstIdentID;
3880 NextSelectorID = FirstSelectorID;
3883 void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) {
3884 IdentifierIDs[II] = ID;
3885 if (II->hasMacroDefinition())
3886 DeserializedMacroNames.push_back(II);
3889 void ASTWriter::TypeRead(TypeIdx Idx, QualType T) {
3890 // Always take the highest-numbered type index. This copes with an interesting
3891 // case for chained AST writing where we schedule writing the type and then,
3892 // later, deserialize the type from another AST. In this case, we want to
3893 // keep the higher-numbered entry so that we can properly write it out to
3895 TypeIdx &StoredIdx = TypeIdxs[T];
3896 if (Idx.getIndex() >= StoredIdx.getIndex())
3900 void ASTWriter::DeclRead(DeclID ID, const Decl *D) {
3904 void ASTWriter::SelectorRead(SelectorID ID, Selector S) {
3905 SelectorIDs[S] = ID;
3908 void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID,
3909 MacroDefinition *MD) {
3910 assert(MacroDefinitions.find(MD) == MacroDefinitions.end());
3911 MacroDefinitions[MD] = ID;
3914 void ASTWriter::CompletedTagDefinition(const TagDecl *D) {
3915 assert(D->isCompleteDefinition());
3916 assert(!WritingAST && "Already writing the AST!");
3917 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
3918 // We are interested when a PCH decl is modified.
3919 if (RD->isFromASTFile()) {
3920 // A forward reference was mutated into a definition. Rewrite it.
3921 // FIXME: This happens during template instantiation, should we
3922 // have created a new definition decl instead ?
3926 for (CXXRecordDecl::redecl_iterator
3927 I = RD->redecls_begin(), E = RD->redecls_end(); I != E; ++I) {
3928 CXXRecordDecl *Redecl = cast<CXXRecordDecl>(*I);
3932 // We are interested when a PCH decl is modified.
3933 if (Redecl->isFromASTFile()) {
3934 UpdateRecord &Record = DeclUpdates[Redecl];
3935 Record.push_back(UPD_CXX_SET_DEFINITIONDATA);
3936 assert(Redecl->DefinitionData);
3937 assert(Redecl->DefinitionData->Definition == D);
3938 Record.push_back(reinterpret_cast<uint64_t>(D)); // the DefinitionDecl
3943 void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) {
3944 assert(!WritingAST && "Already writing the AST!");
3946 // TU and namespaces are handled elsewhere.
3947 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC))
3950 if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile()))
3951 return; // Not a source decl added to a DeclContext from PCH.
3953 AddUpdatedDeclContext(DC);
3956 void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) {
3957 assert(!WritingAST && "Already writing the AST!");
3958 assert(D->isImplicit());
3959 if (!(!D->isFromASTFile() && RD->isFromASTFile()))
3960 return; // Not a source member added to a class from PCH.
3961 if (!isa<CXXMethodDecl>(D))
3962 return; // We are interested in lazily declared implicit methods.
3964 // A decl coming from PCH was modified.
3965 assert(RD->isCompleteDefinition());
3966 UpdateRecord &Record = DeclUpdates[RD];
3967 Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER);
3968 Record.push_back(reinterpret_cast<uint64_t>(D));
3971 void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
3972 const ClassTemplateSpecializationDecl *D) {
3973 // The specializations set is kept in the canonical template.
3974 assert(!WritingAST && "Already writing the AST!");
3975 TD = TD->getCanonicalDecl();
3976 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
3977 return; // Not a source specialization added to a template from PCH.
3979 UpdateRecord &Record = DeclUpdates[TD];
3980 Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
3981 Record.push_back(reinterpret_cast<uint64_t>(D));
3984 void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
3985 const FunctionDecl *D) {
3986 // The specializations set is kept in the canonical template.
3987 assert(!WritingAST && "Already writing the AST!");
3988 TD = TD->getCanonicalDecl();
3989 if (!(!D->isFromASTFile() && TD->isFromASTFile()))
3990 return; // Not a source specialization added to a template from PCH.
3992 UpdateRecord &Record = DeclUpdates[TD];
3993 Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
3994 Record.push_back(reinterpret_cast<uint64_t>(D));
3997 void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) {
3998 assert(!WritingAST && "Already writing the AST!");
3999 if (!D->isFromASTFile())
4000 return; // Declaration not imported from PCH.
4002 // Implicit decl from a PCH was defined.
4003 // FIXME: Should implicit definition be a separate FunctionDecl?
4007 void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) {
4008 assert(!WritingAST && "Already writing the AST!");
4009 if (!D->isFromASTFile())
4012 // Since the actual instantiation is delayed, this really means that we need
4013 // to update the instantiation location.
4014 UpdateRecord &Record = DeclUpdates[D];
4015 Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER);
4017 D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record);
4020 void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
4021 const ObjCInterfaceDecl *IFD) {
4022 assert(!WritingAST && "Already writing the AST!");
4023 if (!IFD->isFromASTFile())
4024 return; // Declaration not imported from PCH.
4025 if (CatD->getNextClassCategory() &&
4026 !CatD->getNextClassCategory()->isFromASTFile())
4027 return; // We already recorded that the tail of a category chain should be
4028 // attached to an interface.
4030 ChainedObjCCategoriesData Data = { IFD, CatD, 0, 0 };
4031 LocalChainedObjCCategories.push_back(Data);