1 //===--- ASTWriter.cpp - AST File Writer ----------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file defines the ASTWriter class, which writes AST files.
11 //
12 //===----------------------------------------------------------------------===//
13 
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"
47 #include <algorithm>
48 #include <cstdio>
49 #include <string.h>
50 #include <utility>
51 using namespace clang;
52 using namespace clang::serialization;
53 
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());
59 }
60 
61 template <typename T>
62 static StringRef data(const SmallVectorImpl<T> &v) {
63   return StringRef(reinterpret_cast<const char*>(v.data()),
64                          sizeof(T) * v.size());
65 }
66 
67 //===----------------------------------------------------------------------===//
68 // Type serialization
69 //===----------------------------------------------------------------------===//
70 
71 namespace {
72   class ASTTypeWriter {
73     ASTWriter &Writer;
74     ASTWriter::RecordDataImpl &Record;
75 
76   public:
77     /// \brief Type code that corresponds to the record generated.
78     TypeCode Code;
79 
80     ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
81       : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { }
82 
83     void VisitArrayType(const ArrayType *T);
84     void VisitFunctionType(const FunctionType *T);
85     void VisitTagType(const TagType *T);
86 
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"
90   };
91 }
92 
93 void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
94   llvm_unreachable("Built-in types are never serialized");
95 }
96 
97 void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
98   Writer.AddTypeRef(T->getElementType(), Record);
99   Code = TYPE_COMPLEX;
100 }
101 
102 void ASTTypeWriter::VisitPointerType(const PointerType *T) {
103   Writer.AddTypeRef(T->getPointeeType(), Record);
104   Code = TYPE_POINTER;
105 }
106 
107 void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
108   Writer.AddTypeRef(T->getPointeeType(), Record);
109   Code = TYPE_BLOCK_POINTER;
110 }
111 
112 void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
113   Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
114   Record.push_back(T->isSpelledAsLValue());
115   Code = TYPE_LVALUE_REFERENCE;
116 }
117 
118 void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
119   Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
120   Code = TYPE_RVALUE_REFERENCE;
121 }
122 
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;
127 }
128 
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
133 }
134 
135 void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
136   VisitArrayType(T);
137   Writer.AddAPInt(T->getSize(), Record);
138   Code = TYPE_CONSTANT_ARRAY;
139 }
140 
141 void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
142   VisitArrayType(T);
143   Code = TYPE_INCOMPLETE_ARRAY;
144 }
145 
146 void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
147   VisitArrayType(T);
148   Writer.AddSourceLocation(T->getLBracketLoc(), Record);
149   Writer.AddSourceLocation(T->getRBracketLoc(), Record);
150   Writer.AddStmt(T->getSizeExpr());
151   Code = TYPE_VARIABLE_ARRAY;
152 }
153 
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());
158   Code = TYPE_VECTOR;
159 }
160 
161 void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) {
162   VisitVectorType(T);
163   Code = TYPE_EXT_VECTOR;
164 }
165 
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());
175 }
176 
177 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
178   VisitFunctionType(T);
179   Code = TYPE_FUNCTION_NO_PROTO;
180 }
181 
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->hasTrailingReturn());
189   Record.push_back(T->getTypeQuals());
190   Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
191   Record.push_back(T->getExceptionSpecType());
192   if (T->getExceptionSpecType() == EST_Dynamic) {
193     Record.push_back(T->getNumExceptions());
194     for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
195       Writer.AddTypeRef(T->getExceptionType(I), Record);
196   } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
197     Writer.AddStmt(T->getNoexceptExpr());
198   } else if (T->getExceptionSpecType() == EST_Uninstantiated) {
199     Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
200     Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record);
201   } else if (T->getExceptionSpecType() == EST_Unevaluated) {
202     Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
203   }
204   Code = TYPE_FUNCTION_PROTO;
205 }
206 
207 void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
208   Writer.AddDeclRef(T->getDecl(), Record);
209   Code = TYPE_UNRESOLVED_USING;
210 }
211 
212 void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
213   Writer.AddDeclRef(T->getDecl(), Record);
214   assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
215   Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
216   Code = TYPE_TYPEDEF;
217 }
218 
219 void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
220   Writer.AddStmt(T->getUnderlyingExpr());
221   Code = TYPE_TYPEOF_EXPR;
222 }
223 
224 void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
225   Writer.AddTypeRef(T->getUnderlyingType(), Record);
226   Code = TYPE_TYPEOF;
227 }
228 
229 void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
230   Writer.AddTypeRef(T->getUnderlyingType(), Record);
231   Writer.AddStmt(T->getUnderlyingExpr());
232   Code = TYPE_DECLTYPE;
233 }
234 
235 void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
236   Writer.AddTypeRef(T->getBaseType(), Record);
237   Writer.AddTypeRef(T->getUnderlyingType(), Record);
238   Record.push_back(T->getUTTKind());
239   Code = TYPE_UNARY_TRANSFORM;
240 }
241 
242 void ASTTypeWriter::VisitAutoType(const AutoType *T) {
243   Writer.AddTypeRef(T->getDeducedType(), Record);
244   Code = TYPE_AUTO;
245 }
246 
247 void ASTTypeWriter::VisitTagType(const TagType *T) {
248   Record.push_back(T->isDependentType());
249   Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
250   assert(!T->isBeingDefined() &&
251          "Cannot serialize in the middle of a type definition");
252 }
253 
254 void ASTTypeWriter::VisitRecordType(const RecordType *T) {
255   VisitTagType(T);
256   Code = TYPE_RECORD;
257 }
258 
259 void ASTTypeWriter::VisitEnumType(const EnumType *T) {
260   VisitTagType(T);
261   Code = TYPE_ENUM;
262 }
263 
264 void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
265   Writer.AddTypeRef(T->getModifiedType(), Record);
266   Writer.AddTypeRef(T->getEquivalentType(), Record);
267   Record.push_back(T->getAttrKind());
268   Code = TYPE_ATTRIBUTED;
269 }
270 
271 void
272 ASTTypeWriter::VisitSubstTemplateTypeParmType(
273                                         const SubstTemplateTypeParmType *T) {
274   Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
275   Writer.AddTypeRef(T->getReplacementType(), Record);
276   Code = TYPE_SUBST_TEMPLATE_TYPE_PARM;
277 }
278 
279 void
280 ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
281                                       const SubstTemplateTypeParmPackType *T) {
282   Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
283   Writer.AddTemplateArgument(T->getArgumentPack(), Record);
284   Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK;
285 }
286 
287 void
288 ASTTypeWriter::VisitTemplateSpecializationType(
289                                        const TemplateSpecializationType *T) {
290   Record.push_back(T->isDependentType());
291   Writer.AddTemplateName(T->getTemplateName(), Record);
292   Record.push_back(T->getNumArgs());
293   for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end();
294          ArgI != ArgE; ++ArgI)
295     Writer.AddTemplateArgument(*ArgI, Record);
296   Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() :
297                     T->isCanonicalUnqualified() ? QualType()
298                                                 : T->getCanonicalTypeInternal(),
299                     Record);
300   Code = TYPE_TEMPLATE_SPECIALIZATION;
301 }
302 
303 void
304 ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
305   VisitArrayType(T);
306   Writer.AddStmt(T->getSizeExpr());
307   Writer.AddSourceRange(T->getBracketsRange(), Record);
308   Code = TYPE_DEPENDENT_SIZED_ARRAY;
309 }
310 
311 void
312 ASTTypeWriter::VisitDependentSizedExtVectorType(
313                                         const DependentSizedExtVectorType *T) {
314   // FIXME: Serialize this type (C++ only)
315   llvm_unreachable("Cannot serialize dependent sized extended vector types");
316 }
317 
318 void
319 ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
320   Record.push_back(T->getDepth());
321   Record.push_back(T->getIndex());
322   Record.push_back(T->isParameterPack());
323   Writer.AddDeclRef(T->getDecl(), Record);
324   Code = TYPE_TEMPLATE_TYPE_PARM;
325 }
326 
327 void
328 ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
329   Record.push_back(T->getKeyword());
330   Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
331   Writer.AddIdentifierRef(T->getIdentifier(), Record);
332   Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
333                                                 : T->getCanonicalTypeInternal(),
334                     Record);
335   Code = TYPE_DEPENDENT_NAME;
336 }
337 
338 void
339 ASTTypeWriter::VisitDependentTemplateSpecializationType(
340                                 const DependentTemplateSpecializationType *T) {
341   Record.push_back(T->getKeyword());
342   Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
343   Writer.AddIdentifierRef(T->getIdentifier(), Record);
344   Record.push_back(T->getNumArgs());
345   for (DependentTemplateSpecializationType::iterator
346          I = T->begin(), E = T->end(); I != E; ++I)
347     Writer.AddTemplateArgument(*I, Record);
348   Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION;
349 }
350 
351 void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
352   Writer.AddTypeRef(T->getPattern(), Record);
353   if (llvm::Optional<unsigned> NumExpansions = T->getNumExpansions())
354     Record.push_back(*NumExpansions + 1);
355   else
356     Record.push_back(0);
357   Code = TYPE_PACK_EXPANSION;
358 }
359 
360 void ASTTypeWriter::VisitParenType(const ParenType *T) {
361   Writer.AddTypeRef(T->getInnerType(), Record);
362   Code = TYPE_PAREN;
363 }
364 
365 void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
366   Record.push_back(T->getKeyword());
367   Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
368   Writer.AddTypeRef(T->getNamedType(), Record);
369   Code = TYPE_ELABORATED;
370 }
371 
372 void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
373   Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
374   Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
375   Code = TYPE_INJECTED_CLASS_NAME;
376 }
377 
378 void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
379   Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record);
380   Code = TYPE_OBJC_INTERFACE;
381 }
382 
383 void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
384   Writer.AddTypeRef(T->getBaseType(), Record);
385   Record.push_back(T->getNumProtocols());
386   for (ObjCObjectType::qual_iterator I = T->qual_begin(),
387        E = T->qual_end(); I != E; ++I)
388     Writer.AddDeclRef(*I, Record);
389   Code = TYPE_OBJC_OBJECT;
390 }
391 
392 void
393 ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
394   Writer.AddTypeRef(T->getPointeeType(), Record);
395   Code = TYPE_OBJC_OBJECT_POINTER;
396 }
397 
398 void
399 ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
400   Writer.AddTypeRef(T->getValueType(), Record);
401   Code = TYPE_ATOMIC;
402 }
403 
404 namespace {
405 
406 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
407   ASTWriter &Writer;
408   ASTWriter::RecordDataImpl &Record;
409 
410 public:
411   TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
412     : Writer(Writer), Record(Record) { }
413 
414 #define ABSTRACT_TYPELOC(CLASS, PARENT)
415 #define TYPELOC(CLASS, PARENT) \
416     void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
417 #include "clang/AST/TypeLocNodes.def"
418 
419   void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
420   void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
421 };
422 
423 }
424 
425 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
426   // nothing to do
427 }
428 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
429   Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
430   if (TL.needsExtraLocalData()) {
431     Record.push_back(TL.getWrittenTypeSpec());
432     Record.push_back(TL.getWrittenSignSpec());
433     Record.push_back(TL.getWrittenWidthSpec());
434     Record.push_back(TL.hasModeAttr());
435   }
436 }
437 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
438   Writer.AddSourceLocation(TL.getNameLoc(), Record);
439 }
440 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
441   Writer.AddSourceLocation(TL.getStarLoc(), Record);
442 }
443 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
444   Writer.AddSourceLocation(TL.getCaretLoc(), Record);
445 }
446 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
447   Writer.AddSourceLocation(TL.getAmpLoc(), Record);
448 }
449 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
450   Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record);
451 }
452 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
453   Writer.AddSourceLocation(TL.getStarLoc(), Record);
454   Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record);
455 }
456 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
457   Writer.AddSourceLocation(TL.getLBracketLoc(), Record);
458   Writer.AddSourceLocation(TL.getRBracketLoc(), Record);
459   Record.push_back(TL.getSizeExpr() ? 1 : 0);
460   if (TL.getSizeExpr())
461     Writer.AddStmt(TL.getSizeExpr());
462 }
463 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
464   VisitArrayTypeLoc(TL);
465 }
466 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
467   VisitArrayTypeLoc(TL);
468 }
469 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
470   VisitArrayTypeLoc(TL);
471 }
472 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
473                                             DependentSizedArrayTypeLoc TL) {
474   VisitArrayTypeLoc(TL);
475 }
476 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
477                                         DependentSizedExtVectorTypeLoc TL) {
478   Writer.AddSourceLocation(TL.getNameLoc(), Record);
479 }
480 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
481   Writer.AddSourceLocation(TL.getNameLoc(), Record);
482 }
483 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
484   Writer.AddSourceLocation(TL.getNameLoc(), Record);
485 }
486 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
487   Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
488   Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record);
489   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
490     Writer.AddDeclRef(TL.getArg(i), Record);
491 }
492 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
493   VisitFunctionTypeLoc(TL);
494 }
495 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
496   VisitFunctionTypeLoc(TL);
497 }
498 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
499   Writer.AddSourceLocation(TL.getNameLoc(), Record);
500 }
501 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
502   Writer.AddSourceLocation(TL.getNameLoc(), Record);
503 }
504 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
505   Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
506   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
507   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
508 }
509 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
510   Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
511   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
512   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
513   Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
514 }
515 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
516   Writer.AddSourceLocation(TL.getNameLoc(), Record);
517 }
518 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
519   Writer.AddSourceLocation(TL.getKWLoc(), Record);
520   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
521   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
522   Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
523 }
524 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
525   Writer.AddSourceLocation(TL.getNameLoc(), Record);
526 }
527 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
528   Writer.AddSourceLocation(TL.getNameLoc(), Record);
529 }
530 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
531   Writer.AddSourceLocation(TL.getNameLoc(), Record);
532 }
533 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
534   Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
535   if (TL.hasAttrOperand()) {
536     SourceRange range = TL.getAttrOperandParensRange();
537     Writer.AddSourceLocation(range.getBegin(), Record);
538     Writer.AddSourceLocation(range.getEnd(), Record);
539   }
540   if (TL.hasAttrExprOperand()) {
541     Expr *operand = TL.getAttrExprOperand();
542     Record.push_back(operand ? 1 : 0);
543     if (operand) Writer.AddStmt(operand);
544   } else if (TL.hasAttrEnumOperand()) {
545     Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record);
546   }
547 }
548 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
549   Writer.AddSourceLocation(TL.getNameLoc(), Record);
550 }
551 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
552                                             SubstTemplateTypeParmTypeLoc TL) {
553   Writer.AddSourceLocation(TL.getNameLoc(), Record);
554 }
555 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
556                                           SubstTemplateTypeParmPackTypeLoc TL) {
557   Writer.AddSourceLocation(TL.getNameLoc(), Record);
558 }
559 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
560                                            TemplateSpecializationTypeLoc TL) {
561   Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
562   Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
563   Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
564   Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
565   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
566     Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
567                                       TL.getArgLoc(i).getLocInfo(), Record);
568 }
569 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
570   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
571   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
572 }
573 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
574   Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
575   Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
576 }
577 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
578   Writer.AddSourceLocation(TL.getNameLoc(), Record);
579 }
580 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
581   Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
582   Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
583   Writer.AddSourceLocation(TL.getNameLoc(), Record);
584 }
585 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
586        DependentTemplateSpecializationTypeLoc TL) {
587   Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
588   Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
589   Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
590   Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
591   Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
592   Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
593   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
594     Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
595                                       TL.getArgLoc(I).getLocInfo(), Record);
596 }
597 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
598   Writer.AddSourceLocation(TL.getEllipsisLoc(), Record);
599 }
600 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
601   Writer.AddSourceLocation(TL.getNameLoc(), Record);
602 }
603 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
604   Record.push_back(TL.hasBaseTypeAsWritten());
605   Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
606   Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
607   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
608     Writer.AddSourceLocation(TL.getProtocolLoc(i), Record);
609 }
610 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
611   Writer.AddSourceLocation(TL.getStarLoc(), Record);
612 }
613 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
614   Writer.AddSourceLocation(TL.getKWLoc(), Record);
615   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
616   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
617 }
618 
619 //===----------------------------------------------------------------------===//
620 // ASTWriter Implementation
621 //===----------------------------------------------------------------------===//
622 
623 static void EmitBlockID(unsigned ID, const char *Name,
624                         llvm::BitstreamWriter &Stream,
625                         ASTWriter::RecordDataImpl &Record) {
626   Record.clear();
627   Record.push_back(ID);
628   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
629 
630   // Emit the block name if present.
631   if (Name == 0 || Name[0] == 0) return;
632   Record.clear();
633   while (*Name)
634     Record.push_back(*Name++);
635   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
636 }
637 
638 static void EmitRecordID(unsigned ID, const char *Name,
639                          llvm::BitstreamWriter &Stream,
640                          ASTWriter::RecordDataImpl &Record) {
641   Record.clear();
642   Record.push_back(ID);
643   while (*Name)
644     Record.push_back(*Name++);
645   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
646 }
647 
648 static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
649                           ASTWriter::RecordDataImpl &Record) {
650 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
651   RECORD(STMT_STOP);
652   RECORD(STMT_NULL_PTR);
653   RECORD(STMT_NULL);
654   RECORD(STMT_COMPOUND);
655   RECORD(STMT_CASE);
656   RECORD(STMT_DEFAULT);
657   RECORD(STMT_LABEL);
658   RECORD(STMT_ATTRIBUTED);
659   RECORD(STMT_IF);
660   RECORD(STMT_SWITCH);
661   RECORD(STMT_WHILE);
662   RECORD(STMT_DO);
663   RECORD(STMT_FOR);
664   RECORD(STMT_GOTO);
665   RECORD(STMT_INDIRECT_GOTO);
666   RECORD(STMT_CONTINUE);
667   RECORD(STMT_BREAK);
668   RECORD(STMT_RETURN);
669   RECORD(STMT_DECL);
670   RECORD(STMT_GCCASM);
671   RECORD(STMT_MSASM);
672   RECORD(EXPR_PREDEFINED);
673   RECORD(EXPR_DECL_REF);
674   RECORD(EXPR_INTEGER_LITERAL);
675   RECORD(EXPR_FLOATING_LITERAL);
676   RECORD(EXPR_IMAGINARY_LITERAL);
677   RECORD(EXPR_STRING_LITERAL);
678   RECORD(EXPR_CHARACTER_LITERAL);
679   RECORD(EXPR_PAREN);
680   RECORD(EXPR_UNARY_OPERATOR);
681   RECORD(EXPR_SIZEOF_ALIGN_OF);
682   RECORD(EXPR_ARRAY_SUBSCRIPT);
683   RECORD(EXPR_CALL);
684   RECORD(EXPR_MEMBER);
685   RECORD(EXPR_BINARY_OPERATOR);
686   RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
687   RECORD(EXPR_CONDITIONAL_OPERATOR);
688   RECORD(EXPR_IMPLICIT_CAST);
689   RECORD(EXPR_CSTYLE_CAST);
690   RECORD(EXPR_COMPOUND_LITERAL);
691   RECORD(EXPR_EXT_VECTOR_ELEMENT);
692   RECORD(EXPR_INIT_LIST);
693   RECORD(EXPR_DESIGNATED_INIT);
694   RECORD(EXPR_IMPLICIT_VALUE_INIT);
695   RECORD(EXPR_VA_ARG);
696   RECORD(EXPR_ADDR_LABEL);
697   RECORD(EXPR_STMT);
698   RECORD(EXPR_CHOOSE);
699   RECORD(EXPR_GNU_NULL);
700   RECORD(EXPR_SHUFFLE_VECTOR);
701   RECORD(EXPR_BLOCK);
702   RECORD(EXPR_GENERIC_SELECTION);
703   RECORD(EXPR_OBJC_STRING_LITERAL);
704   RECORD(EXPR_OBJC_BOXED_EXPRESSION);
705   RECORD(EXPR_OBJC_ARRAY_LITERAL);
706   RECORD(EXPR_OBJC_DICTIONARY_LITERAL);
707   RECORD(EXPR_OBJC_ENCODE);
708   RECORD(EXPR_OBJC_SELECTOR_EXPR);
709   RECORD(EXPR_OBJC_PROTOCOL_EXPR);
710   RECORD(EXPR_OBJC_IVAR_REF_EXPR);
711   RECORD(EXPR_OBJC_PROPERTY_REF_EXPR);
712   RECORD(EXPR_OBJC_KVC_REF_EXPR);
713   RECORD(EXPR_OBJC_MESSAGE_EXPR);
714   RECORD(STMT_OBJC_FOR_COLLECTION);
715   RECORD(STMT_OBJC_CATCH);
716   RECORD(STMT_OBJC_FINALLY);
717   RECORD(STMT_OBJC_AT_TRY);
718   RECORD(STMT_OBJC_AT_SYNCHRONIZED);
719   RECORD(STMT_OBJC_AT_THROW);
720   RECORD(EXPR_OBJC_BOOL_LITERAL);
721   RECORD(EXPR_CXX_OPERATOR_CALL);
722   RECORD(EXPR_CXX_CONSTRUCT);
723   RECORD(EXPR_CXX_STATIC_CAST);
724   RECORD(EXPR_CXX_DYNAMIC_CAST);
725   RECORD(EXPR_CXX_REINTERPRET_CAST);
726   RECORD(EXPR_CXX_CONST_CAST);
727   RECORD(EXPR_CXX_FUNCTIONAL_CAST);
728   RECORD(EXPR_USER_DEFINED_LITERAL);
729   RECORD(EXPR_CXX_BOOL_LITERAL);
730   RECORD(EXPR_CXX_NULL_PTR_LITERAL);
731   RECORD(EXPR_CXX_TYPEID_EXPR);
732   RECORD(EXPR_CXX_TYPEID_TYPE);
733   RECORD(EXPR_CXX_UUIDOF_EXPR);
734   RECORD(EXPR_CXX_UUIDOF_TYPE);
735   RECORD(EXPR_CXX_THIS);
736   RECORD(EXPR_CXX_THROW);
737   RECORD(EXPR_CXX_DEFAULT_ARG);
738   RECORD(EXPR_CXX_BIND_TEMPORARY);
739   RECORD(EXPR_CXX_SCALAR_VALUE_INIT);
740   RECORD(EXPR_CXX_NEW);
741   RECORD(EXPR_CXX_DELETE);
742   RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR);
743   RECORD(EXPR_EXPR_WITH_CLEANUPS);
744   RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER);
745   RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF);
746   RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT);
747   RECORD(EXPR_CXX_UNRESOLVED_MEMBER);
748   RECORD(EXPR_CXX_UNRESOLVED_LOOKUP);
749   RECORD(EXPR_CXX_UNARY_TYPE_TRAIT);
750   RECORD(EXPR_CXX_NOEXCEPT);
751   RECORD(EXPR_OPAQUE_VALUE);
752   RECORD(EXPR_BINARY_TYPE_TRAIT);
753   RECORD(EXPR_PACK_EXPANSION);
754   RECORD(EXPR_SIZEOF_PACK);
755   RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK);
756   RECORD(EXPR_CUDA_KERNEL_CALL);
757 #undef RECORD
758 }
759 
760 void ASTWriter::WriteBlockInfoBlock() {
761   RecordData Record;
762   Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3);
763 
764 #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
765 #define RECORD(X) EmitRecordID(X, #X, Stream, Record)
766 
767   // AST Top-Level Block.
768   BLOCK(AST_BLOCK);
769   RECORD(ORIGINAL_FILE_NAME);
770   RECORD(ORIGINAL_FILE_ID);
771   RECORD(TYPE_OFFSET);
772   RECORD(DECL_OFFSET);
773   RECORD(LANGUAGE_OPTIONS);
774   RECORD(METADATA);
775   RECORD(IDENTIFIER_OFFSET);
776   RECORD(IDENTIFIER_TABLE);
777   RECORD(EXTERNAL_DEFINITIONS);
778   RECORD(SPECIAL_TYPES);
779   RECORD(STATISTICS);
780   RECORD(TENTATIVE_DEFINITIONS);
781   RECORD(UNUSED_FILESCOPED_DECLS);
782   RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS);
783   RECORD(SELECTOR_OFFSETS);
784   RECORD(METHOD_POOL);
785   RECORD(PP_COUNTER_VALUE);
786   RECORD(SOURCE_LOCATION_OFFSETS);
787   RECORD(SOURCE_LOCATION_PRELOADS);
788   RECORD(STAT_CACHE);
789   RECORD(EXT_VECTOR_DECLS);
790   RECORD(VERSION_CONTROL_BRANCH_REVISION);
791   RECORD(PPD_ENTITIES_OFFSETS);
792   RECORD(IMPORTS);
793   RECORD(REFERENCED_SELECTOR_POOL);
794   RECORD(TU_UPDATE_LEXICAL);
795   RECORD(LOCAL_REDECLARATIONS_MAP);
796   RECORD(SEMA_DECL_REFS);
797   RECORD(WEAK_UNDECLARED_IDENTIFIERS);
798   RECORD(PENDING_IMPLICIT_INSTANTIATIONS);
799   RECORD(DECL_REPLACEMENTS);
800   RECORD(UPDATE_VISIBLE);
801   RECORD(DECL_UPDATE_OFFSETS);
802   RECORD(DECL_UPDATES);
803   RECORD(CXX_BASE_SPECIFIER_OFFSETS);
804   RECORD(DIAG_PRAGMA_MAPPINGS);
805   RECORD(CUDA_SPECIAL_DECL_REFS);
806   RECORD(HEADER_SEARCH_TABLE);
807   RECORD(ORIGINAL_PCH_DIR);
808   RECORD(FP_PRAGMA_OPTIONS);
809   RECORD(OPENCL_EXTENSIONS);
810   RECORD(DELEGATING_CTORS);
811   RECORD(FILE_SOURCE_LOCATION_OFFSETS);
812   RECORD(KNOWN_NAMESPACES);
813   RECORD(MODULE_OFFSET_MAP);
814   RECORD(SOURCE_MANAGER_LINE_TABLE);
815   RECORD(OBJC_CATEGORIES_MAP);
816   RECORD(FILE_SORTED_DECLS);
817   RECORD(IMPORTED_MODULES);
818   RECORD(MERGED_DECLARATIONS);
819   RECORD(LOCAL_REDECLARATIONS);
820   RECORD(OBJC_CATEGORIES);
821 
822   // SourceManager Block.
823   BLOCK(SOURCE_MANAGER_BLOCK);
824   RECORD(SM_SLOC_FILE_ENTRY);
825   RECORD(SM_SLOC_BUFFER_ENTRY);
826   RECORD(SM_SLOC_BUFFER_BLOB);
827   RECORD(SM_SLOC_EXPANSION_ENTRY);
828 
829   // Preprocessor Block.
830   BLOCK(PREPROCESSOR_BLOCK);
831   RECORD(PP_MACRO_OBJECT_LIKE);
832   RECORD(PP_MACRO_FUNCTION_LIKE);
833   RECORD(PP_TOKEN);
834 
835   // Decls and Types block.
836   BLOCK(DECLTYPES_BLOCK);
837   RECORD(TYPE_EXT_QUAL);
838   RECORD(TYPE_COMPLEX);
839   RECORD(TYPE_POINTER);
840   RECORD(TYPE_BLOCK_POINTER);
841   RECORD(TYPE_LVALUE_REFERENCE);
842   RECORD(TYPE_RVALUE_REFERENCE);
843   RECORD(TYPE_MEMBER_POINTER);
844   RECORD(TYPE_CONSTANT_ARRAY);
845   RECORD(TYPE_INCOMPLETE_ARRAY);
846   RECORD(TYPE_VARIABLE_ARRAY);
847   RECORD(TYPE_VECTOR);
848   RECORD(TYPE_EXT_VECTOR);
849   RECORD(TYPE_FUNCTION_PROTO);
850   RECORD(TYPE_FUNCTION_NO_PROTO);
851   RECORD(TYPE_TYPEDEF);
852   RECORD(TYPE_TYPEOF_EXPR);
853   RECORD(TYPE_TYPEOF);
854   RECORD(TYPE_RECORD);
855   RECORD(TYPE_ENUM);
856   RECORD(TYPE_OBJC_INTERFACE);
857   RECORD(TYPE_OBJC_OBJECT);
858   RECORD(TYPE_OBJC_OBJECT_POINTER);
859   RECORD(TYPE_DECLTYPE);
860   RECORD(TYPE_ELABORATED);
861   RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
862   RECORD(TYPE_UNRESOLVED_USING);
863   RECORD(TYPE_INJECTED_CLASS_NAME);
864   RECORD(TYPE_OBJC_OBJECT);
865   RECORD(TYPE_TEMPLATE_TYPE_PARM);
866   RECORD(TYPE_TEMPLATE_SPECIALIZATION);
867   RECORD(TYPE_DEPENDENT_NAME);
868   RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
869   RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
870   RECORD(TYPE_PAREN);
871   RECORD(TYPE_PACK_EXPANSION);
872   RECORD(TYPE_ATTRIBUTED);
873   RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
874   RECORD(TYPE_ATOMIC);
875   RECORD(DECL_TYPEDEF);
876   RECORD(DECL_ENUM);
877   RECORD(DECL_RECORD);
878   RECORD(DECL_ENUM_CONSTANT);
879   RECORD(DECL_FUNCTION);
880   RECORD(DECL_OBJC_METHOD);
881   RECORD(DECL_OBJC_INTERFACE);
882   RECORD(DECL_OBJC_PROTOCOL);
883   RECORD(DECL_OBJC_IVAR);
884   RECORD(DECL_OBJC_AT_DEFS_FIELD);
885   RECORD(DECL_OBJC_CATEGORY);
886   RECORD(DECL_OBJC_CATEGORY_IMPL);
887   RECORD(DECL_OBJC_IMPLEMENTATION);
888   RECORD(DECL_OBJC_COMPATIBLE_ALIAS);
889   RECORD(DECL_OBJC_PROPERTY);
890   RECORD(DECL_OBJC_PROPERTY_IMPL);
891   RECORD(DECL_FIELD);
892   RECORD(DECL_VAR);
893   RECORD(DECL_IMPLICIT_PARAM);
894   RECORD(DECL_PARM_VAR);
895   RECORD(DECL_FILE_SCOPE_ASM);
896   RECORD(DECL_BLOCK);
897   RECORD(DECL_CONTEXT_LEXICAL);
898   RECORD(DECL_CONTEXT_VISIBLE);
899   RECORD(DECL_NAMESPACE);
900   RECORD(DECL_NAMESPACE_ALIAS);
901   RECORD(DECL_USING);
902   RECORD(DECL_USING_SHADOW);
903   RECORD(DECL_USING_DIRECTIVE);
904   RECORD(DECL_UNRESOLVED_USING_VALUE);
905   RECORD(DECL_UNRESOLVED_USING_TYPENAME);
906   RECORD(DECL_LINKAGE_SPEC);
907   RECORD(DECL_CXX_RECORD);
908   RECORD(DECL_CXX_METHOD);
909   RECORD(DECL_CXX_CONSTRUCTOR);
910   RECORD(DECL_CXX_DESTRUCTOR);
911   RECORD(DECL_CXX_CONVERSION);
912   RECORD(DECL_ACCESS_SPEC);
913   RECORD(DECL_FRIEND);
914   RECORD(DECL_FRIEND_TEMPLATE);
915   RECORD(DECL_CLASS_TEMPLATE);
916   RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
917   RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
918   RECORD(DECL_FUNCTION_TEMPLATE);
919   RECORD(DECL_TEMPLATE_TYPE_PARM);
920   RECORD(DECL_NON_TYPE_TEMPLATE_PARM);
921   RECORD(DECL_TEMPLATE_TEMPLATE_PARM);
922   RECORD(DECL_STATIC_ASSERT);
923   RECORD(DECL_CXX_BASE_SPECIFIERS);
924   RECORD(DECL_INDIRECTFIELD);
925   RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK);
926 
927   // Statements and Exprs can occur in the Decls and Types block.
928   AddStmtsExprs(Stream, Record);
929 
930   BLOCK(PREPROCESSOR_DETAIL_BLOCK);
931   RECORD(PPD_MACRO_EXPANSION);
932   RECORD(PPD_MACRO_DEFINITION);
933   RECORD(PPD_INCLUSION_DIRECTIVE);
934 
935 #undef RECORD
936 #undef BLOCK
937   Stream.ExitBlock();
938 }
939 
940 /// \brief Adjusts the given filename to only write out the portion of the
941 /// filename that is not part of the system root directory.
942 ///
943 /// \param Filename the file name to adjust.
944 ///
945 /// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and
946 /// the returned filename will be adjusted by this system root.
947 ///
948 /// \returns either the original filename (if it needs no adjustment) or the
949 /// adjusted filename (which points into the @p Filename parameter).
950 static const char *
951 adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) {
952   assert(Filename && "No file name to adjust?");
953 
954   if (isysroot.empty())
955     return Filename;
956 
957   // Verify that the filename and the system root have the same prefix.
958   unsigned Pos = 0;
959   for (; Filename[Pos] && Pos < isysroot.size(); ++Pos)
960     if (Filename[Pos] != isysroot[Pos])
961       return Filename; // Prefixes don't match.
962 
963   // We hit the end of the filename before we hit the end of the system root.
964   if (!Filename[Pos])
965     return Filename;
966 
967   // If the file name has a '/' at the current position, skip over the '/'.
968   // We distinguish sysroot-based includes from absolute includes by the
969   // absence of '/' at the beginning of sysroot-based includes.
970   if (Filename[Pos] == '/')
971     ++Pos;
972 
973   return Filename + Pos;
974 }
975 
976 /// \brief Write the AST metadata (e.g., i686-apple-darwin9).
977 void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot,
978                               const std::string &OutputFile) {
979   using namespace llvm;
980 
981   // Metadata
982   const TargetInfo &Target = Context.getTargetInfo();
983   BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev();
984   MetaAbbrev->Add(BitCodeAbbrevOp(METADATA));
985   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major
986   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor
987   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major
988   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor
989   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
990   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Has errors
991   MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Target triple
992   unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev);
993 
994   RecordData Record;
995   Record.push_back(METADATA);
996   Record.push_back(VERSION_MAJOR);
997   Record.push_back(VERSION_MINOR);
998   Record.push_back(CLANG_VERSION_MAJOR);
999   Record.push_back(CLANG_VERSION_MINOR);
1000   Record.push_back(!isysroot.empty());
1001   Record.push_back(ASTHasCompilerErrors);
1002   const std::string &Triple = Target.getTriple().getTriple();
1003   Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, Triple);
1004 
1005   if (Chain) {
1006     serialization::ModuleManager &Mgr = Chain->getModuleManager();
1007     llvm::SmallVector<char, 128> ModulePaths;
1008     Record.clear();
1009 
1010     for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end();
1011          M != MEnd; ++M) {
1012       // Skip modules that weren't directly imported.
1013       if (!(*M)->isDirectlyImported())
1014         continue;
1015 
1016       Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding
1017       // FIXME: Write import location, once it matters.
1018       // FIXME: This writes the absolute path for AST files we depend on.
1019       const std::string &FileName = (*M)->FileName;
1020       Record.push_back(FileName.size());
1021       Record.append(FileName.begin(), FileName.end());
1022     }
1023     Stream.EmitRecord(IMPORTS, Record);
1024   }
1025 
1026   // Original file name and file ID
1027   SourceManager &SM = Context.getSourceManager();
1028   if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
1029     BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev();
1030     FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME));
1031     FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1032     unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev);
1033 
1034     SmallString<128> MainFilePath(MainFile->getName());
1035 
1036     llvm::sys::fs::make_absolute(MainFilePath);
1037 
1038     const char *MainFileNameStr = MainFilePath.c_str();
1039     MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr,
1040                                                       isysroot);
1041     RecordData Record;
1042     Record.push_back(ORIGINAL_FILE_NAME);
1043     Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr);
1044 
1045     Record.clear();
1046     Record.push_back(SM.getMainFileID().getOpaqueValue());
1047     Stream.EmitRecord(ORIGINAL_FILE_ID, Record);
1048   }
1049 
1050   // Original PCH directory
1051   if (!OutputFile.empty() && OutputFile != "-") {
1052     BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1053     Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
1054     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1055     unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
1056 
1057     SmallString<128> OutputPath(OutputFile);
1058 
1059     llvm::sys::fs::make_absolute(OutputPath);
1060     StringRef origDir = llvm::sys::path::parent_path(OutputPath);
1061 
1062     RecordData Record;
1063     Record.push_back(ORIGINAL_PCH_DIR);
1064     Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
1065   }
1066 
1067   // Repository branch/version information.
1068   BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev();
1069   RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION));
1070   RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
1071   unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev);
1072   Record.clear();
1073   Record.push_back(VERSION_CONTROL_BRANCH_REVISION);
1074   Stream.EmitRecordWithBlob(RepoAbbrevCode, Record,
1075                             getClangFullRepositoryVersion());
1076 }
1077 
1078 /// \brief Write the LangOptions structure.
1079 void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
1080   RecordData Record;
1081 #define LANGOPT(Name, Bits, Default, Description) \
1082   Record.push_back(LangOpts.Name);
1083 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
1084   Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
1085 #include "clang/Basic/LangOptions.def"
1086 
1087   Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind());
1088   AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record);
1089 
1090   Record.push_back(LangOpts.CurrentModule.size());
1091   Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end());
1092   Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
1093 }
1094 
1095 //===----------------------------------------------------------------------===//
1096 // stat cache Serialization
1097 //===----------------------------------------------------------------------===//
1098 
1099 namespace {
1100 // Trait used for the on-disk hash table of stat cache results.
1101 class ASTStatCacheTrait {
1102 public:
1103   typedef const char * key_type;
1104   typedef key_type key_type_ref;
1105 
1106   typedef struct stat data_type;
1107   typedef const data_type &data_type_ref;
1108 
1109   static unsigned ComputeHash(const char *path) {
1110     return llvm::HashString(path);
1111   }
1112 
1113   std::pair<unsigned,unsigned>
1114     EmitKeyDataLength(raw_ostream& Out, const char *path,
1115                       data_type_ref Data) {
1116     unsigned StrLen = strlen(path);
1117     clang::io::Emit16(Out, StrLen);
1118     unsigned DataLen = 4 + 4 + 2 + 8 + 8;
1119     clang::io::Emit8(Out, DataLen);
1120     return std::make_pair(StrLen + 1, DataLen);
1121   }
1122 
1123   void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) {
1124     Out.write(path, KeyLen);
1125   }
1126 
1127   void EmitData(raw_ostream &Out, key_type_ref,
1128                 data_type_ref Data, unsigned DataLen) {
1129     using namespace clang::io;
1130     uint64_t Start = Out.tell(); (void)Start;
1131 
1132     Emit32(Out, (uint32_t) Data.st_ino);
1133     Emit32(Out, (uint32_t) Data.st_dev);
1134     Emit16(Out, (uint16_t) Data.st_mode);
1135     Emit64(Out, (uint64_t) Data.st_mtime);
1136     Emit64(Out, (uint64_t) Data.st_size);
1137 
1138     assert(Out.tell() - Start == DataLen && "Wrong data length");
1139   }
1140 };
1141 } // end anonymous namespace
1142 
1143 /// \brief Write the stat() system call cache to the AST file.
1144 void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) {
1145   // Build the on-disk hash table containing information about every
1146   // stat() call.
1147   OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator;
1148   unsigned NumStatEntries = 0;
1149   for (MemorizeStatCalls::iterator Stat = StatCalls.begin(),
1150                                 StatEnd = StatCalls.end();
1151        Stat != StatEnd; ++Stat, ++NumStatEntries) {
1152     StringRef Filename = Stat->first();
1153     Generator.insert(Filename.data(), Stat->second);
1154   }
1155 
1156   // Create the on-disk hash table in a buffer.
1157   SmallString<4096> StatCacheData;
1158   uint32_t BucketOffset;
1159   {
1160     llvm::raw_svector_ostream Out(StatCacheData);
1161     // Make sure that no bucket is at offset 0
1162     clang::io::Emit32(Out, 0);
1163     BucketOffset = Generator.Emit(Out);
1164   }
1165 
1166   // Create a blob abbreviation
1167   using namespace llvm;
1168   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1169   Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE));
1170   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1171   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1172   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1173   unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev);
1174 
1175   // Write the stat cache
1176   RecordData Record;
1177   Record.push_back(STAT_CACHE);
1178   Record.push_back(BucketOffset);
1179   Record.push_back(NumStatEntries);
1180   Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str());
1181 }
1182 
1183 //===----------------------------------------------------------------------===//
1184 // Source Manager Serialization
1185 //===----------------------------------------------------------------------===//
1186 
1187 /// \brief Create an abbreviation for the SLocEntry that refers to a
1188 /// file.
1189 static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
1190   using namespace llvm;
1191   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1192   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
1193   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1194   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1195   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1196   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1197   // FileEntry fields.
1198   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
1199   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
1200   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // BufferOverridden
1201   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
1202   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex
1203   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls
1204   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
1205   return Stream.EmitAbbrev(Abbrev);
1206 }
1207 
1208 /// \brief Create an abbreviation for the SLocEntry that refers to a
1209 /// buffer.
1210 static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
1211   using namespace llvm;
1212   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1213   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
1214   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1215   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
1216   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
1217   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
1218   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
1219   return Stream.EmitAbbrev(Abbrev);
1220 }
1221 
1222 /// \brief Create an abbreviation for the SLocEntry that refers to a
1223 /// buffer's blob.
1224 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
1225   using namespace llvm;
1226   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1227   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB));
1228   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
1229   return Stream.EmitAbbrev(Abbrev);
1230 }
1231 
1232 /// \brief Create an abbreviation for the SLocEntry that refers to a macro
1233 /// expansion.
1234 static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) {
1235   using namespace llvm;
1236   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1237   Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY));
1238   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
1239   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
1240   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
1241   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
1242   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
1243   return Stream.EmitAbbrev(Abbrev);
1244 }
1245 
1246 namespace {
1247   // Trait used for the on-disk hash table of header search information.
1248   class HeaderFileInfoTrait {
1249     ASTWriter &Writer;
1250 
1251     // Keep track of the framework names we've used during serialization.
1252     SmallVector<char, 128> FrameworkStringData;
1253     llvm::StringMap<unsigned> FrameworkNameOffset;
1254 
1255   public:
1256     HeaderFileInfoTrait(ASTWriter &Writer)
1257       : Writer(Writer) { }
1258 
1259     typedef const char *key_type;
1260     typedef key_type key_type_ref;
1261 
1262     typedef HeaderFileInfo data_type;
1263     typedef const data_type &data_type_ref;
1264 
1265     static unsigned ComputeHash(const char *path) {
1266       // The hash is based only on the filename portion of the key, so that the
1267       // reader can match based on filenames when symlinking or excess path
1268       // elements ("foo/../", "../") change the form of the name. However,
1269       // complete path is still the key.
1270       return llvm::HashString(llvm::sys::path::filename(path));
1271     }
1272 
1273     std::pair<unsigned,unsigned>
1274     EmitKeyDataLength(raw_ostream& Out, const char *path,
1275                       data_type_ref Data) {
1276       unsigned StrLen = strlen(path);
1277       clang::io::Emit16(Out, StrLen);
1278       unsigned DataLen = 1 + 2 + 4 + 4;
1279       clang::io::Emit8(Out, DataLen);
1280       return std::make_pair(StrLen + 1, DataLen);
1281     }
1282 
1283     void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) {
1284       Out.write(path, KeyLen);
1285     }
1286 
1287     void EmitData(raw_ostream &Out, key_type_ref,
1288                   data_type_ref Data, unsigned DataLen) {
1289       using namespace clang::io;
1290       uint64_t Start = Out.tell(); (void)Start;
1291 
1292       unsigned char Flags = (Data.isImport << 5)
1293                           | (Data.isPragmaOnce << 4)
1294                           | (Data.DirInfo << 2)
1295                           | (Data.Resolved << 1)
1296                           | Data.IndexHeaderMapHeader;
1297       Emit8(Out, (uint8_t)Flags);
1298       Emit16(Out, (uint16_t) Data.NumIncludes);
1299 
1300       if (!Data.ControllingMacro)
1301         Emit32(Out, (uint32_t)Data.ControllingMacroID);
1302       else
1303         Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro));
1304 
1305       unsigned Offset = 0;
1306       if (!Data.Framework.empty()) {
1307         // If this header refers into a framework, save the framework name.
1308         llvm::StringMap<unsigned>::iterator Pos
1309           = FrameworkNameOffset.find(Data.Framework);
1310         if (Pos == FrameworkNameOffset.end()) {
1311           Offset = FrameworkStringData.size() + 1;
1312           FrameworkStringData.append(Data.Framework.begin(),
1313                                      Data.Framework.end());
1314           FrameworkStringData.push_back(0);
1315 
1316           FrameworkNameOffset[Data.Framework] = Offset;
1317         } else
1318           Offset = Pos->second;
1319       }
1320       Emit32(Out, Offset);
1321 
1322       assert(Out.tell() - Start == DataLen && "Wrong data length");
1323     }
1324 
1325     const char *strings_begin() const { return FrameworkStringData.begin(); }
1326     const char *strings_end() const { return FrameworkStringData.end(); }
1327   };
1328 } // end anonymous namespace
1329 
1330 /// \brief Write the header search block for the list of files that
1331 ///
1332 /// \param HS The header search structure to save.
1333 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) {
1334   SmallVector<const FileEntry *, 16> FilesByUID;
1335   HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
1336 
1337   if (FilesByUID.size() > HS.header_file_size())
1338     FilesByUID.resize(HS.header_file_size());
1339 
1340   HeaderFileInfoTrait GeneratorTrait(*this);
1341   OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
1342   SmallVector<const char *, 4> SavedStrings;
1343   unsigned NumHeaderSearchEntries = 0;
1344   for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
1345     const FileEntry *File = FilesByUID[UID];
1346     if (!File)
1347       continue;
1348 
1349     // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo
1350     // from the external source if it was not provided already.
1351     const HeaderFileInfo &HFI = HS.getFileInfo(File);
1352     if (HFI.External && Chain)
1353       continue;
1354 
1355     // Turn the file name into an absolute path, if it isn't already.
1356     const char *Filename = File->getName();
1357     Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1358 
1359     // If we performed any translation on the file name at all, we need to
1360     // save this string, since the generator will refer to it later.
1361     if (Filename != File->getName()) {
1362       Filename = strdup(Filename);
1363       SavedStrings.push_back(Filename);
1364     }
1365 
1366     Generator.insert(Filename, HFI, GeneratorTrait);
1367     ++NumHeaderSearchEntries;
1368   }
1369 
1370   // Create the on-disk hash table in a buffer.
1371   SmallString<4096> TableData;
1372   uint32_t BucketOffset;
1373   {
1374     llvm::raw_svector_ostream Out(TableData);
1375     // Make sure that no bucket is at offset 0
1376     clang::io::Emit32(Out, 0);
1377     BucketOffset = Generator.Emit(Out, GeneratorTrait);
1378   }
1379 
1380   // Create a blob abbreviation
1381   using namespace llvm;
1382   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1383   Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
1384   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1385   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1386   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
1387   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1388   unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev);
1389 
1390   // Write the header search table
1391   RecordData Record;
1392   Record.push_back(HEADER_SEARCH_TABLE);
1393   Record.push_back(BucketOffset);
1394   Record.push_back(NumHeaderSearchEntries);
1395   Record.push_back(TableData.size());
1396   TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
1397   Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str());
1398 
1399   // Free all of the strings we had to duplicate.
1400   for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
1401     free((void*)SavedStrings[I]);
1402 }
1403 
1404 /// \brief Writes the block containing the serialized form of the
1405 /// source manager.
1406 ///
1407 /// TODO: We should probably use an on-disk hash table (stored in a
1408 /// blob), indexed based on the file name, so that we only create
1409 /// entries for files that we actually need. In the common case (no
1410 /// errors), we probably won't have to create file entries for any of
1411 /// the files in the AST.
1412 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
1413                                         const Preprocessor &PP,
1414                                         StringRef isysroot) {
1415   RecordData Record;
1416 
1417   // Enter the source manager block.
1418   Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3);
1419 
1420   // Abbreviations for the various kinds of source-location entries.
1421   unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
1422   unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
1423   unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream);
1424   unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream);
1425 
1426   // Write out the source location entry table. We skip the first
1427   // entry, which is always the same dummy entry.
1428   std::vector<uint32_t> SLocEntryOffsets;
1429   // Write out the offsets of only source location file entries.
1430   // We will go through them in ASTReader::validateFileEntries().
1431   std::vector<uint32_t> SLocFileEntryOffsets;
1432   RecordData PreloadSLocs;
1433   SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
1434   for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
1435        I != N; ++I) {
1436     // Get this source location entry.
1437     const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
1438 
1439     // Record the offset of this source-location entry.
1440     SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
1441 
1442     // Figure out which record code to use.
1443     unsigned Code;
1444     if (SLoc->isFile()) {
1445       const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
1446       if (Cache->OrigEntry) {
1447         Code = SM_SLOC_FILE_ENTRY;
1448         SLocFileEntryOffsets.push_back(Stream.GetCurrentBitNo());
1449       } else
1450         Code = SM_SLOC_BUFFER_ENTRY;
1451     } else
1452       Code = SM_SLOC_EXPANSION_ENTRY;
1453     Record.clear();
1454     Record.push_back(Code);
1455 
1456     // Starting offset of this entry within this module, so skip the dummy.
1457     Record.push_back(SLoc->getOffset() - 2);
1458     if (SLoc->isFile()) {
1459       const SrcMgr::FileInfo &File = SLoc->getFile();
1460       Record.push_back(File.getIncludeLoc().getRawEncoding());
1461       Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
1462       Record.push_back(File.hasLineDirectives());
1463 
1464       const SrcMgr::ContentCache *Content = File.getContentCache();
1465       if (Content->OrigEntry) {
1466         assert(Content->OrigEntry == Content->ContentsEntry &&
1467                "Writing to AST an overridden file is not supported");
1468 
1469         // The source location entry is a file. The blob associated
1470         // with this entry is the file name.
1471 
1472         // Emit size/modification time for this file.
1473         Record.push_back(Content->OrigEntry->getSize());
1474         Record.push_back(Content->OrigEntry->getModificationTime());
1475         Record.push_back(Content->BufferOverridden);
1476         Record.push_back(File.NumCreatedFIDs);
1477 
1478         FileDeclIDsTy::iterator FDI = FileDeclIDs.find(SLoc);
1479         if (FDI != FileDeclIDs.end()) {
1480           Record.push_back(FDI->second->FirstDeclIndex);
1481           Record.push_back(FDI->second->DeclIDs.size());
1482         } else {
1483           Record.push_back(0);
1484           Record.push_back(0);
1485         }
1486 
1487         // Turn the file name into an absolute path, if it isn't already.
1488         const char *Filename = Content->OrigEntry->getName();
1489         SmallString<128> FilePath(Filename);
1490 
1491         // Ask the file manager to fixup the relative path for us. This will
1492         // honor the working directory.
1493         SourceMgr.getFileManager().FixupRelativePath(FilePath);
1494 
1495         // FIXME: This call to make_absolute shouldn't be necessary, the
1496         // call to FixupRelativePath should always return an absolute path.
1497         llvm::sys::fs::make_absolute(FilePath);
1498         Filename = FilePath.c_str();
1499 
1500         Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1501         Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename);
1502 
1503         if (Content->BufferOverridden) {
1504           Record.clear();
1505           Record.push_back(SM_SLOC_BUFFER_BLOB);
1506           const llvm::MemoryBuffer *Buffer
1507             = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
1508           Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
1509                                     StringRef(Buffer->getBufferStart(),
1510                                               Buffer->getBufferSize() + 1));
1511         }
1512       } else {
1513         // The source location entry is a buffer. The blob associated
1514         // with this entry contains the contents of the buffer.
1515 
1516         // We add one to the size so that we capture the trailing NULL
1517         // that is required by llvm::MemoryBuffer::getMemBuffer (on
1518         // the reader side).
1519         const llvm::MemoryBuffer *Buffer
1520           = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
1521         const char *Name = Buffer->getBufferIdentifier();
1522         Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
1523                                   StringRef(Name, strlen(Name) + 1));
1524         Record.clear();
1525         Record.push_back(SM_SLOC_BUFFER_BLOB);
1526         Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
1527                                   StringRef(Buffer->getBufferStart(),
1528                                                   Buffer->getBufferSize() + 1));
1529 
1530         if (strcmp(Name, "<built-in>") == 0) {
1531           PreloadSLocs.push_back(SLocEntryOffsets.size());
1532         }
1533       }
1534     } else {
1535       // The source location entry is a macro expansion.
1536       const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
1537       Record.push_back(Expansion.getSpellingLoc().getRawEncoding());
1538       Record.push_back(Expansion.getExpansionLocStart().getRawEncoding());
1539       Record.push_back(Expansion.isMacroArgExpansion() ? 0
1540                              : Expansion.getExpansionLocEnd().getRawEncoding());
1541 
1542       // Compute the token length for this macro expansion.
1543       unsigned NextOffset = SourceMgr.getNextLocalOffset();
1544       if (I + 1 != N)
1545         NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset();
1546       Record.push_back(NextOffset - SLoc->getOffset() - 1);
1547       Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record);
1548     }
1549   }
1550 
1551   Stream.ExitBlock();
1552 
1553   if (SLocEntryOffsets.empty())
1554     return;
1555 
1556   // Write the source-location offsets table into the AST block. This
1557   // table is used for lazily loading source-location information.
1558   using namespace llvm;
1559   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1560   Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
1561   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
1562   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
1563   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
1564   unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
1565 
1566   Record.clear();
1567   Record.push_back(SOURCE_LOCATION_OFFSETS);
1568   Record.push_back(SLocEntryOffsets.size());
1569   Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy
1570   Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets));
1571 
1572   Abbrev = new BitCodeAbbrev();
1573   Abbrev->Add(BitCodeAbbrevOp(FILE_SOURCE_LOCATION_OFFSETS));
1574   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
1575   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
1576   unsigned SLocFileOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
1577 
1578   Record.clear();
1579   Record.push_back(FILE_SOURCE_LOCATION_OFFSETS);
1580   Record.push_back(SLocFileEntryOffsets.size());
1581   Stream.EmitRecordWithBlob(SLocFileOffsetsAbbrev, Record,
1582                             data(SLocFileEntryOffsets));
1583 
1584   // Write the source location entry preloads array, telling the AST
1585   // reader which source locations entries it should load eagerly.
1586   Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
1587 
1588   // Write the line table. It depends on remapping working, so it must come
1589   // after the source location offsets.
1590   if (SourceMgr.hasLineTable()) {
1591     LineTableInfo &LineTable = SourceMgr.getLineTable();
1592 
1593     Record.clear();
1594     // Emit the file names
1595     Record.push_back(LineTable.getNumFilenames());
1596     for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) {
1597       // Emit the file name
1598       const char *Filename = LineTable.getFilename(I);
1599       Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
1600       unsigned FilenameLen = Filename? strlen(Filename) : 0;
1601       Record.push_back(FilenameLen);
1602       if (FilenameLen)
1603         Record.insert(Record.end(), Filename, Filename + FilenameLen);
1604     }
1605 
1606     // Emit the line entries
1607     for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end();
1608          L != LEnd; ++L) {
1609       // Only emit entries for local files.
1610       if (L->first.ID < 0)
1611         continue;
1612 
1613       // Emit the file ID
1614       Record.push_back(L->first.ID);
1615 
1616       // Emit the line entries
1617       Record.push_back(L->second.size());
1618       for (std::vector<LineEntry>::iterator LE = L->second.begin(),
1619                                          LEEnd = L->second.end();
1620            LE != LEEnd; ++LE) {
1621         Record.push_back(LE->FileOffset);
1622         Record.push_back(LE->LineNo);
1623         Record.push_back(LE->FilenameID);
1624         Record.push_back((unsigned)LE->FileKind);
1625         Record.push_back(LE->IncludeOffset);
1626       }
1627     }
1628     Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record);
1629   }
1630 }
1631 
1632 //===----------------------------------------------------------------------===//
1633 // Preprocessor Serialization
1634 //===----------------------------------------------------------------------===//
1635 
1636 static int compareMacroDefinitions(const void *XPtr, const void *YPtr) {
1637   const std::pair<const IdentifierInfo *, MacroInfo *> &X =
1638     *(const std::pair<const IdentifierInfo *, MacroInfo *>*)XPtr;
1639   const std::pair<const IdentifierInfo *, MacroInfo *> &Y =
1640     *(const std::pair<const IdentifierInfo *, MacroInfo *>*)YPtr;
1641   return X.first->getName().compare(Y.first->getName());
1642 }
1643 
1644 /// \brief Writes the block containing the serialized form of the
1645 /// preprocessor.
1646 ///
1647 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
1648   PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
1649   if (PPRec)
1650     WritePreprocessorDetail(*PPRec);
1651 
1652   RecordData Record;
1653 
1654   // If the preprocessor __COUNTER__ value has been bumped, remember it.
1655   if (PP.getCounterValue() != 0) {
1656     Record.push_back(PP.getCounterValue());
1657     Stream.EmitRecord(PP_COUNTER_VALUE, Record);
1658     Record.clear();
1659   }
1660 
1661   // Enter the preprocessor block.
1662   Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3);
1663 
1664   // If the AST file contains __DATE__ or __TIME__ emit a warning about this.
1665   // FIXME: use diagnostics subsystem for localization etc.
1666   if (PP.SawDateOrTime())
1667     fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n");
1668 
1669 
1670   // Loop over all the macro definitions that are live at the end of the file,
1671   // emitting each to the PP section.
1672 
1673   // Construct the list of macro definitions that need to be serialized.
1674   SmallVector<std::pair<const IdentifierInfo *, MacroInfo *>, 2>
1675     MacrosToEmit;
1676   llvm::SmallPtrSet<const IdentifierInfo*, 4> MacroDefinitionsSeen;
1677   for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0),
1678                                     E = PP.macro_end(Chain == 0);
1679        I != E; ++I) {
1680     if (!IsModule || I->second->isPublic()) {
1681       MacroDefinitionsSeen.insert(I->first);
1682       MacrosToEmit.push_back(std::make_pair(I->first, I->second));
1683     }
1684   }
1685 
1686   // Sort the set of macro definitions that need to be serialized by the
1687   // name of the macro, to provide a stable ordering.
1688   llvm::array_pod_sort(MacrosToEmit.begin(), MacrosToEmit.end(),
1689                        &compareMacroDefinitions);
1690 
1691   // Resolve any identifiers that defined macros at the time they were
1692   // deserialized, adding them to the list of macros to emit (if appropriate).
1693   for (unsigned I = 0, N = DeserializedMacroNames.size(); I != N; ++I) {
1694     IdentifierInfo *Name
1695       = const_cast<IdentifierInfo *>(DeserializedMacroNames[I]);
1696     if (Name->hadMacroDefinition() && MacroDefinitionsSeen.insert(Name))
1697       MacrosToEmit.push_back(std::make_pair(Name, PP.getMacroInfo(Name)));
1698   }
1699 
1700   for (unsigned I = 0, N = MacrosToEmit.size(); I != N; ++I) {
1701     const IdentifierInfo *Name = MacrosToEmit[I].first;
1702     MacroInfo *MI = MacrosToEmit[I].second;
1703     if (!MI)
1704       continue;
1705 
1706     // History of macro definitions for this identifier in chronological order.
1707     SmallVector<MacroInfo*, 8> MacroHistory;
1708     while (MI) {
1709       MacroHistory.push_back(MI);
1710       MI = MI->getPreviousDefinition();
1711     }
1712 
1713     while (!MacroHistory.empty()) {
1714       MI = MacroHistory.pop_back_val();
1715 
1716       // Don't emit builtin macros like __LINE__ to the AST file unless they
1717       // have been redefined by the header (in which case they are not
1718       // isBuiltinMacro).
1719       // Also skip macros from a AST file if we're chaining.
1720 
1721       // FIXME: There is a (probably minor) optimization we could do here, if
1722       // the macro comes from the original PCH but the identifier comes from a
1723       // chained PCH, by storing the offset into the original PCH rather than
1724       // writing the macro definition a second time.
1725       if (MI->isBuiltinMacro() ||
1726           (Chain &&
1727            Name->isFromAST() && !Name->hasChangedSinceDeserialization() &&
1728            MI->isFromAST() && !MI->hasChangedAfterLoad()))
1729         continue;
1730 
1731       AddIdentifierRef(Name, Record);
1732       MacroOffsets[Name] = Stream.GetCurrentBitNo();
1733       AddSourceLocation(MI->getDefinitionLoc(), Record);
1734       AddSourceLocation(MI->getUndefLoc(), Record);
1735       Record.push_back(MI->isUsed());
1736       Record.push_back(MI->isPublic());
1737       AddSourceLocation(MI->getVisibilityLocation(), Record);
1738       unsigned Code;
1739       if (MI->isObjectLike()) {
1740         Code = PP_MACRO_OBJECT_LIKE;
1741       } else {
1742         Code = PP_MACRO_FUNCTION_LIKE;
1743 
1744         Record.push_back(MI->isC99Varargs());
1745         Record.push_back(MI->isGNUVarargs());
1746         Record.push_back(MI->getNumArgs());
1747         for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
1748              I != E; ++I)
1749           AddIdentifierRef(*I, Record);
1750       }
1751 
1752       // If we have a detailed preprocessing record, record the macro definition
1753       // ID that corresponds to this macro.
1754       if (PPRec)
1755         Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
1756 
1757       Stream.EmitRecord(Code, Record);
1758       Record.clear();
1759 
1760       // Emit the tokens array.
1761       for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
1762         // Note that we know that the preprocessor does not have any annotation
1763         // tokens in it because they are created by the parser, and thus can't
1764         // be in a macro definition.
1765         const Token &Tok = MI->getReplacementToken(TokNo);
1766 
1767         Record.push_back(Tok.getLocation().getRawEncoding());
1768         Record.push_back(Tok.getLength());
1769 
1770         // FIXME: When reading literal tokens, reconstruct the literal pointer
1771         // if it is needed.
1772         AddIdentifierRef(Tok.getIdentifierInfo(), Record);
1773         // FIXME: Should translate token kind to a stable encoding.
1774         Record.push_back(Tok.getKind());
1775         // FIXME: Should translate token flags to a stable encoding.
1776         Record.push_back(Tok.getFlags());
1777 
1778         Stream.EmitRecord(PP_TOKEN, Record);
1779         Record.clear();
1780       }
1781       ++NumMacros;
1782     }
1783   }
1784   Stream.ExitBlock();
1785 }
1786 
1787 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
1788   if (PPRec.local_begin() == PPRec.local_end())
1789     return;
1790 
1791   SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
1792 
1793   // Enter the preprocessor block.
1794   Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
1795 
1796   // If the preprocessor has a preprocessing record, emit it.
1797   unsigned NumPreprocessingRecords = 0;
1798   using namespace llvm;
1799 
1800   // Set up the abbreviation for
1801   unsigned InclusionAbbrev = 0;
1802   {
1803     BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1804     Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
1805     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
1806     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
1807     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
1808     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1809     InclusionAbbrev = Stream.EmitAbbrev(Abbrev);
1810   }
1811 
1812   unsigned FirstPreprocessorEntityID
1813     = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
1814     + NUM_PREDEF_PP_ENTITY_IDS;
1815   unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
1816   RecordData Record;
1817   for (PreprocessingRecord::iterator E = PPRec.local_begin(),
1818                                   EEnd = PPRec.local_end();
1819        E != EEnd;
1820        (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
1821     Record.clear();
1822 
1823     PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(),
1824                                                      Stream.GetCurrentBitNo()));
1825 
1826     if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) {
1827       // Record this macro definition's ID.
1828       MacroDefinitions[MD] = NextPreprocessorEntityID;
1829 
1830       AddIdentifierRef(MD->getName(), Record);
1831       Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
1832       continue;
1833     }
1834 
1835     if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) {
1836       Record.push_back(ME->isBuiltinMacro());
1837       if (ME->isBuiltinMacro())
1838         AddIdentifierRef(ME->getName(), Record);
1839       else
1840         Record.push_back(MacroDefinitions[ME->getDefinition()]);
1841       Stream.EmitRecord(PPD_MACRO_EXPANSION, Record);
1842       continue;
1843     }
1844 
1845     if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) {
1846       Record.push_back(PPD_INCLUSION_DIRECTIVE);
1847       Record.push_back(ID->getFileName().size());
1848       Record.push_back(ID->wasInQuotes());
1849       Record.push_back(static_cast<unsigned>(ID->getKind()));
1850       SmallString<64> Buffer;
1851       Buffer += ID->getFileName();
1852       // Check that the FileEntry is not null because it was not resolved and
1853       // we create a PCH even with compiler errors.
1854       if (ID->getFile())
1855         Buffer += ID->getFile()->getName();
1856       Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
1857       continue;
1858     }
1859 
1860     llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter");
1861   }
1862   Stream.ExitBlock();
1863 
1864   // Write the offsets table for the preprocessing record.
1865   if (NumPreprocessingRecords > 0) {
1866     assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords);
1867 
1868     // Write the offsets table for identifier IDs.
1869     using namespace llvm;
1870     BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1871     Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
1872     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
1873     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
1874     unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
1875 
1876     Record.clear();
1877     Record.push_back(PPD_ENTITIES_OFFSETS);
1878     Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS);
1879     Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
1880                               data(PreprocessedEntityOffsets));
1881   }
1882 }
1883 
1884 unsigned ASTWriter::getSubmoduleID(Module *Mod) {
1885   llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod);
1886   if (Known != SubmoduleIDs.end())
1887     return Known->second;
1888 
1889   return SubmoduleIDs[Mod] = NextSubmoduleID++;
1890 }
1891 
1892 /// \brief Compute the number of modules within the given tree (including the
1893 /// given module).
1894 static unsigned getNumberOfModules(Module *Mod) {
1895   unsigned ChildModules = 0;
1896   for (Module::submodule_iterator Sub = Mod->submodule_begin(),
1897                                SubEnd = Mod->submodule_end();
1898        Sub != SubEnd; ++Sub)
1899     ChildModules += getNumberOfModules(*Sub);
1900 
1901   return ChildModules + 1;
1902 }
1903 
1904 void ASTWriter::WriteSubmodules(Module *WritingModule) {
1905   // Determine the dependencies of our module and each of it's submodules.
1906   // FIXME: This feels like it belongs somewhere else, but there are no
1907   // other consumers of this information.
1908   SourceManager &SrcMgr = PP->getSourceManager();
1909   ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
1910   for (ASTContext::import_iterator I = Context->local_import_begin(),
1911                                 IEnd = Context->local_import_end();
1912        I != IEnd; ++I) {
1913     if (Module *ImportedFrom
1914           = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(),
1915                                                          SrcMgr))) {
1916       ImportedFrom->Imports.push_back(I->getImportedModule());
1917     }
1918   }
1919 
1920   // Enter the submodule description block.
1921   Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
1922 
1923   // Write the abbreviations needed for the submodules block.
1924   using namespace llvm;
1925   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
1926   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
1927   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
1928   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
1929   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
1930   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
1931   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
1932   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
1933   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
1934   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
1935   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1936   unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev);
1937 
1938   Abbrev = new BitCodeAbbrev();
1939   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER));
1940   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1941   unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev);
1942 
1943   Abbrev = new BitCodeAbbrev();
1944   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER));
1945   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1946   unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev);
1947 
1948   Abbrev = new BitCodeAbbrev();
1949   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR));
1950   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
1951   unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev);
1952 
1953   Abbrev = new BitCodeAbbrev();
1954   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES));
1955   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature
1956   unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev);
1957 
1958   // Write the submodule metadata block.
1959   RecordData Record;
1960   Record.push_back(getNumberOfModules(WritingModule));
1961   Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS);
1962   Stream.EmitRecord(SUBMODULE_METADATA, Record);
1963 
1964   // Write all of the submodules.
1965   std::queue<Module *> Q;
1966   Q.push(WritingModule);
1967   while (!Q.empty()) {
1968     Module *Mod = Q.front();
1969     Q.pop();
1970     unsigned ID = getSubmoduleID(Mod);
1971 
1972     // Emit the definition of the block.
1973     Record.clear();
1974     Record.push_back(SUBMODULE_DEFINITION);
1975     Record.push_back(ID);
1976     if (Mod->Parent) {
1977       assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?");
1978       Record.push_back(SubmoduleIDs[Mod->Parent]);
1979     } else {
1980       Record.push_back(0);
1981     }
1982     Record.push_back(Mod->IsFramework);
1983     Record.push_back(Mod->IsExplicit);
1984     Record.push_back(Mod->IsSystem);
1985     Record.push_back(Mod->InferSubmodules);
1986     Record.push_back(Mod->InferExplicitSubmodules);
1987     Record.push_back(Mod->InferExportWildcard);
1988     Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name);
1989 
1990     // Emit the requirements.
1991     for (unsigned I = 0, N = Mod->Requires.size(); I != N; ++I) {
1992       Record.clear();
1993       Record.push_back(SUBMODULE_REQUIRES);
1994       Stream.EmitRecordWithBlob(RequiresAbbrev, Record,
1995                                 Mod->Requires[I].data(),
1996                                 Mod->Requires[I].size());
1997     }
1998 
1999     // Emit the umbrella header, if there is one.
2000     if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) {
2001       Record.clear();
2002       Record.push_back(SUBMODULE_UMBRELLA_HEADER);
2003       Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record,
2004                                 UmbrellaHeader->getName());
2005     } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) {
2006       Record.clear();
2007       Record.push_back(SUBMODULE_UMBRELLA_DIR);
2008       Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record,
2009                                 UmbrellaDir->getName());
2010     }
2011 
2012     // Emit the headers.
2013     for (unsigned I = 0, N = Mod->Headers.size(); I != N; ++I) {
2014       Record.clear();
2015       Record.push_back(SUBMODULE_HEADER);
2016       Stream.EmitRecordWithBlob(HeaderAbbrev, Record,
2017                                 Mod->Headers[I]->getName());
2018     }
2019 
2020     // Emit the imports.
2021     if (!Mod->Imports.empty()) {
2022       Record.clear();
2023       for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) {
2024         unsigned ImportedID = getSubmoduleID(Mod->Imports[I]);
2025         assert(ImportedID && "Unknown submodule!");
2026         Record.push_back(ImportedID);
2027       }
2028       Stream.EmitRecord(SUBMODULE_IMPORTS, Record);
2029     }
2030 
2031     // Emit the exports.
2032     if (!Mod->Exports.empty()) {
2033       Record.clear();
2034       for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) {
2035         if (Module *Exported = Mod->Exports[I].getPointer()) {
2036           unsigned ExportedID = SubmoduleIDs[Exported];
2037           assert(ExportedID > 0 && "Unknown submodule ID?");
2038           Record.push_back(ExportedID);
2039         } else {
2040           Record.push_back(0);
2041         }
2042 
2043         Record.push_back(Mod->Exports[I].getInt());
2044       }
2045       Stream.EmitRecord(SUBMODULE_EXPORTS, Record);
2046     }
2047 
2048     // Queue up the submodules of this module.
2049     for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2050                                  SubEnd = Mod->submodule_end();
2051          Sub != SubEnd; ++Sub)
2052       Q.push(*Sub);
2053   }
2054 
2055   Stream.ExitBlock();
2056 
2057   assert((NextSubmoduleID - FirstSubmoduleID
2058             == getNumberOfModules(WritingModule)) && "Wrong # of submodules");
2059 }
2060 
2061 serialization::SubmoduleID
2062 ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) {
2063   if (Loc.isInvalid() || !WritingModule)
2064     return 0; // No submodule
2065 
2066   // Find the module that owns this location.
2067   ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
2068   Module *OwningMod
2069     = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager()));
2070   if (!OwningMod)
2071     return 0;
2072 
2073   // Check whether this submodule is part of our own module.
2074   if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule))
2075     return 0;
2076 
2077   return getSubmoduleID(OwningMod);
2078 }
2079 
2080 void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag) {
2081   RecordData Record;
2082   for (DiagnosticsEngine::DiagStatePointsTy::const_iterator
2083          I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end();
2084          I != E; ++I) {
2085     const DiagnosticsEngine::DiagStatePoint &point = *I;
2086     if (point.Loc.isInvalid())
2087       continue;
2088 
2089     Record.push_back(point.Loc.getRawEncoding());
2090     for (DiagnosticsEngine::DiagState::const_iterator
2091            I = point.State->begin(), E = point.State->end(); I != E; ++I) {
2092       if (I->second.isPragma()) {
2093         Record.push_back(I->first);
2094         Record.push_back(I->second.getMapping());
2095       }
2096     }
2097     Record.push_back(-1); // mark the end of the diag/map pairs for this
2098                           // location.
2099   }
2100 
2101   if (!Record.empty())
2102     Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record);
2103 }
2104 
2105 void ASTWriter::WriteCXXBaseSpecifiersOffsets() {
2106   if (CXXBaseSpecifiersOffsets.empty())
2107     return;
2108 
2109   RecordData Record;
2110 
2111   // Create a blob abbreviation for the C++ base specifiers offsets.
2112   using namespace llvm;
2113 
2114   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2115   Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS));
2116   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
2117   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2118   unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2119 
2120   // Write the base specifier offsets table.
2121   Record.clear();
2122   Record.push_back(CXX_BASE_SPECIFIER_OFFSETS);
2123   Record.push_back(CXXBaseSpecifiersOffsets.size());
2124   Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record,
2125                             data(CXXBaseSpecifiersOffsets));
2126 }
2127 
2128 //===----------------------------------------------------------------------===//
2129 // Type Serialization
2130 //===----------------------------------------------------------------------===//
2131 
2132 /// \brief Write the representation of a type to the AST stream.
2133 void ASTWriter::WriteType(QualType T) {
2134   TypeIdx &Idx = TypeIdxs[T];
2135   if (Idx.getIndex() == 0) // we haven't seen this type before.
2136     Idx = TypeIdx(NextTypeID++);
2137 
2138   assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
2139 
2140   // Record the offset for this type.
2141   unsigned Index = Idx.getIndex() - FirstTypeID;
2142   if (TypeOffsets.size() == Index)
2143     TypeOffsets.push_back(Stream.GetCurrentBitNo());
2144   else if (TypeOffsets.size() < Index) {
2145     TypeOffsets.resize(Index + 1);
2146     TypeOffsets[Index] = Stream.GetCurrentBitNo();
2147   }
2148 
2149   RecordData Record;
2150 
2151   // Emit the type's representation.
2152   ASTTypeWriter W(*this, Record);
2153 
2154   if (T.hasLocalNonFastQualifiers()) {
2155     Qualifiers Qs = T.getLocalQualifiers();
2156     AddTypeRef(T.getLocalUnqualifiedType(), Record);
2157     Record.push_back(Qs.getAsOpaqueValue());
2158     W.Code = TYPE_EXT_QUAL;
2159   } else {
2160     switch (T->getTypeClass()) {
2161       // For all of the concrete, non-dependent types, call the
2162       // appropriate visitor function.
2163 #define TYPE(Class, Base) \
2164     case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break;
2165 #define ABSTRACT_TYPE(Class, Base)
2166 #include "clang/AST/TypeNodes.def"
2167     }
2168   }
2169 
2170   // Emit the serialized record.
2171   Stream.EmitRecord(W.Code, Record);
2172 
2173   // Flush any expressions that were written as part of this type.
2174   FlushStmts();
2175 }
2176 
2177 //===----------------------------------------------------------------------===//
2178 // Declaration Serialization
2179 //===----------------------------------------------------------------------===//
2180 
2181 /// \brief Write the block containing all of the declaration IDs
2182 /// lexically declared within the given DeclContext.
2183 ///
2184 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
2185 /// bistream, or 0 if no block was written.
2186 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
2187                                                  DeclContext *DC) {
2188   if (DC->decls_empty())
2189     return 0;
2190 
2191   uint64_t Offset = Stream.GetCurrentBitNo();
2192   RecordData Record;
2193   Record.push_back(DECL_CONTEXT_LEXICAL);
2194   SmallVector<KindDeclIDPair, 64> Decls;
2195   for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
2196          D != DEnd; ++D)
2197     Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D)));
2198 
2199   ++NumLexicalDeclContexts;
2200   Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls));
2201   return Offset;
2202 }
2203 
2204 void ASTWriter::WriteTypeDeclOffsets() {
2205   using namespace llvm;
2206   RecordData Record;
2207 
2208   // Write the type offsets array
2209   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2210   Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
2211   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
2212   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
2213   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
2214   unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2215   Record.clear();
2216   Record.push_back(TYPE_OFFSET);
2217   Record.push_back(TypeOffsets.size());
2218   Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS);
2219   Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets));
2220 
2221   // Write the declaration offsets array
2222   Abbrev = new BitCodeAbbrev();
2223   Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
2224   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
2225   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
2226   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
2227   unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2228   Record.clear();
2229   Record.push_back(DECL_OFFSET);
2230   Record.push_back(DeclOffsets.size());
2231   Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS);
2232   Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets));
2233 }
2234 
2235 void ASTWriter::WriteFileDeclIDsMap() {
2236   using namespace llvm;
2237   RecordData Record;
2238 
2239   // Join the vectors of DeclIDs from all files.
2240   SmallVector<DeclID, 256> FileSortedIDs;
2241   for (FileDeclIDsTy::iterator
2242          FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) {
2243     DeclIDInFileInfo &Info = *FI->second;
2244     Info.FirstDeclIndex = FileSortedIDs.size();
2245     for (LocDeclIDsTy::iterator
2246            DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI)
2247       FileSortedIDs.push_back(DI->second);
2248   }
2249 
2250   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2251   Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS));
2252   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2253   unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
2254   Record.push_back(FILE_SORTED_DECLS);
2255   Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs));
2256 }
2257 
2258 void ASTWriter::WriteComments() {
2259   Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3);
2260   ArrayRef<RawComment *> RawComments = Context->Comments.getComments();
2261   RecordData Record;
2262   for (ArrayRef<RawComment *>::iterator I = RawComments.begin(),
2263                                         E = RawComments.end();
2264        I != E; ++I) {
2265     Record.clear();
2266     AddSourceRange((*I)->getSourceRange(), Record);
2267     Record.push_back((*I)->getKind());
2268     Record.push_back((*I)->isTrailingComment());
2269     Record.push_back((*I)->isAlmostTrailingComment());
2270     Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record);
2271   }
2272   Stream.ExitBlock();
2273 }
2274 
2275 //===----------------------------------------------------------------------===//
2276 // Global Method Pool and Selector Serialization
2277 //===----------------------------------------------------------------------===//
2278 
2279 namespace {
2280 // Trait used for the on-disk hash table used in the method pool.
2281 class ASTMethodPoolTrait {
2282   ASTWriter &Writer;
2283 
2284 public:
2285   typedef Selector key_type;
2286   typedef key_type key_type_ref;
2287 
2288   struct data_type {
2289     SelectorID ID;
2290     ObjCMethodList Instance, Factory;
2291   };
2292   typedef const data_type& data_type_ref;
2293 
2294   explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { }
2295 
2296   static unsigned ComputeHash(Selector Sel) {
2297     return serialization::ComputeHash(Sel);
2298   }
2299 
2300   std::pair<unsigned,unsigned>
2301     EmitKeyDataLength(raw_ostream& Out, Selector Sel,
2302                       data_type_ref Methods) {
2303     unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
2304     clang::io::Emit16(Out, KeyLen);
2305     unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
2306     for (const ObjCMethodList *Method = &Methods.Instance; Method;
2307          Method = Method->Next)
2308       if (Method->Method)
2309         DataLen += 4;
2310     for (const ObjCMethodList *Method = &Methods.Factory; Method;
2311          Method = Method->Next)
2312       if (Method->Method)
2313         DataLen += 4;
2314     clang::io::Emit16(Out, DataLen);
2315     return std::make_pair(KeyLen, DataLen);
2316   }
2317 
2318   void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
2319     uint64_t Start = Out.tell();
2320     assert((Start >> 32) == 0 && "Selector key offset too large");
2321     Writer.SetSelectorOffset(Sel, Start);
2322     unsigned N = Sel.getNumArgs();
2323     clang::io::Emit16(Out, N);
2324     if (N == 0)
2325       N = 1;
2326     for (unsigned I = 0; I != N; ++I)
2327       clang::io::Emit32(Out,
2328                     Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
2329   }
2330 
2331   void EmitData(raw_ostream& Out, key_type_ref,
2332                 data_type_ref Methods, unsigned DataLen) {
2333     uint64_t Start = Out.tell(); (void)Start;
2334     clang::io::Emit32(Out, Methods.ID);
2335     unsigned NumInstanceMethods = 0;
2336     for (const ObjCMethodList *Method = &Methods.Instance; Method;
2337          Method = Method->Next)
2338       if (Method->Method)
2339         ++NumInstanceMethods;
2340 
2341     unsigned NumFactoryMethods = 0;
2342     for (const ObjCMethodList *Method = &Methods.Factory; Method;
2343          Method = Method->Next)
2344       if (Method->Method)
2345         ++NumFactoryMethods;
2346 
2347     clang::io::Emit16(Out, NumInstanceMethods);
2348     clang::io::Emit16(Out, NumFactoryMethods);
2349     for (const ObjCMethodList *Method = &Methods.Instance; Method;
2350          Method = Method->Next)
2351       if (Method->Method)
2352         clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
2353     for (const ObjCMethodList *Method = &Methods.Factory; Method;
2354          Method = Method->Next)
2355       if (Method->Method)
2356         clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
2357 
2358     assert(Out.tell() - Start == DataLen && "Data length is wrong");
2359   }
2360 };
2361 } // end anonymous namespace
2362 
2363 /// \brief Write ObjC data: selectors and the method pool.
2364 ///
2365 /// The method pool contains both instance and factory methods, stored
2366 /// in an on-disk hash table indexed by the selector. The hash table also
2367 /// contains an empty entry for every other selector known to Sema.
2368 void ASTWriter::WriteSelectors(Sema &SemaRef) {
2369   using namespace llvm;
2370 
2371   // Do we have to do anything at all?
2372   if (SemaRef.MethodPool.empty() && SelectorIDs.empty())
2373     return;
2374   unsigned NumTableEntries = 0;
2375   // Create and write out the blob that contains selectors and the method pool.
2376   {
2377     OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
2378     ASTMethodPoolTrait Trait(*this);
2379 
2380     // Create the on-disk hash table representation. We walk through every
2381     // selector we've seen and look it up in the method pool.
2382     SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
2383     for (llvm::DenseMap<Selector, SelectorID>::iterator
2384              I = SelectorIDs.begin(), E = SelectorIDs.end();
2385          I != E; ++I) {
2386       Selector S = I->first;
2387       Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S);
2388       ASTMethodPoolTrait::data_type Data = {
2389         I->second,
2390         ObjCMethodList(),
2391         ObjCMethodList()
2392       };
2393       if (F != SemaRef.MethodPool.end()) {
2394         Data.Instance = F->second.first;
2395         Data.Factory = F->second.second;
2396       }
2397       // Only write this selector if it's not in an existing AST or something
2398       // changed.
2399       if (Chain && I->second < FirstSelectorID) {
2400         // Selector already exists. Did it change?
2401         bool changed = false;
2402         for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method;
2403              M = M->Next) {
2404           if (!M->Method->isFromASTFile())
2405             changed = true;
2406         }
2407         for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method;
2408              M = M->Next) {
2409           if (!M->Method->isFromASTFile())
2410             changed = true;
2411         }
2412         if (!changed)
2413           continue;
2414       } else if (Data.Instance.Method || Data.Factory.Method) {
2415         // A new method pool entry.
2416         ++NumTableEntries;
2417       }
2418       Generator.insert(S, Data, Trait);
2419     }
2420 
2421     // Create the on-disk hash table in a buffer.
2422     SmallString<4096> MethodPool;
2423     uint32_t BucketOffset;
2424     {
2425       ASTMethodPoolTrait Trait(*this);
2426       llvm::raw_svector_ostream Out(MethodPool);
2427       // Make sure that no bucket is at offset 0
2428       clang::io::Emit32(Out, 0);
2429       BucketOffset = Generator.Emit(Out, Trait);
2430     }
2431 
2432     // Create a blob abbreviation
2433     BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2434     Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
2435     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2436     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2437     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2438     unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev);
2439 
2440     // Write the method pool
2441     RecordData Record;
2442     Record.push_back(METHOD_POOL);
2443     Record.push_back(BucketOffset);
2444     Record.push_back(NumTableEntries);
2445     Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str());
2446 
2447     // Create a blob abbreviation for the selector table offsets.
2448     Abbrev = new BitCodeAbbrev();
2449     Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
2450     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
2451     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2452     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2453     unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2454 
2455     // Write the selector offsets table.
2456     Record.clear();
2457     Record.push_back(SELECTOR_OFFSETS);
2458     Record.push_back(SelectorOffsets.size());
2459     Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS);
2460     Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
2461                               data(SelectorOffsets));
2462   }
2463 }
2464 
2465 /// \brief Write the selectors referenced in @selector expression into AST file.
2466 void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
2467   using namespace llvm;
2468   if (SemaRef.ReferencedSelectors.empty())
2469     return;
2470 
2471   RecordData Record;
2472 
2473   // Note: this writes out all references even for a dependent AST. But it is
2474   // very tricky to fix, and given that @selector shouldn't really appear in
2475   // headers, probably not worth it. It's not a correctness issue.
2476   for (DenseMap<Selector, SourceLocation>::iterator S =
2477        SemaRef.ReferencedSelectors.begin(),
2478        E = SemaRef.ReferencedSelectors.end(); S != E; ++S) {
2479     Selector Sel = (*S).first;
2480     SourceLocation Loc = (*S).second;
2481     AddSelectorRef(Sel, Record);
2482     AddSourceLocation(Loc, Record);
2483   }
2484   Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record);
2485 }
2486 
2487 //===----------------------------------------------------------------------===//
2488 // Identifier Table Serialization
2489 //===----------------------------------------------------------------------===//
2490 
2491 namespace {
2492 class ASTIdentifierTableTrait {
2493   ASTWriter &Writer;
2494   Preprocessor &PP;
2495   IdentifierResolver &IdResolver;
2496   bool IsModule;
2497 
2498   /// \brief Determines whether this is an "interesting" identifier
2499   /// that needs a full IdentifierInfo structure written into the hash
2500   /// table.
2501   bool isInterestingIdentifier(IdentifierInfo *II, MacroInfo *&Macro) {
2502     if (II->isPoisoned() ||
2503         II->isExtensionToken() ||
2504         II->getObjCOrBuiltinID() ||
2505         II->hasRevertedTokenIDToIdentifier() ||
2506         II->getFETokenInfo<void>())
2507       return true;
2508 
2509     return hadMacroDefinition(II, Macro);
2510   }
2511 
2512   bool hadMacroDefinition(IdentifierInfo *II, MacroInfo *&Macro) {
2513     if (!II->hadMacroDefinition())
2514       return false;
2515 
2516     if (Macro || (Macro = PP.getMacroInfoHistory(II)))
2517       return !Macro->isBuiltinMacro() && (!IsModule || Macro->isPublic());
2518 
2519     return false;
2520   }
2521 
2522 public:
2523   typedef IdentifierInfo* key_type;
2524   typedef key_type  key_type_ref;
2525 
2526   typedef IdentID data_type;
2527   typedef data_type data_type_ref;
2528 
2529   ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP,
2530                           IdentifierResolver &IdResolver, bool IsModule)
2531     : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { }
2532 
2533   static unsigned ComputeHash(const IdentifierInfo* II) {
2534     return llvm::HashString(II->getName());
2535   }
2536 
2537   std::pair<unsigned,unsigned>
2538   EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) {
2539     unsigned KeyLen = II->getLength() + 1;
2540     unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
2541     MacroInfo *Macro = 0;
2542     if (isInterestingIdentifier(II, Macro)) {
2543       DataLen += 2; // 2 bytes for builtin ID
2544       DataLen += 2; // 2 bytes for flags
2545       if (hadMacroDefinition(II, Macro))
2546         DataLen += 8;
2547 
2548       for (IdentifierResolver::iterator D = IdResolver.begin(II),
2549                                      DEnd = IdResolver.end();
2550            D != DEnd; ++D)
2551         DataLen += sizeof(DeclID);
2552     }
2553     clang::io::Emit16(Out, DataLen);
2554     // We emit the key length after the data length so that every
2555     // string is preceded by a 16-bit length. This matches the PTH
2556     // format for storing identifiers.
2557     clang::io::Emit16(Out, KeyLen);
2558     return std::make_pair(KeyLen, DataLen);
2559   }
2560 
2561   void EmitKey(raw_ostream& Out, const IdentifierInfo* II,
2562                unsigned KeyLen) {
2563     // Record the location of the key data.  This is used when generating
2564     // the mapping from persistent IDs to strings.
2565     Writer.SetIdentifierOffset(II, Out.tell());
2566     Out.write(II->getNameStart(), KeyLen);
2567   }
2568 
2569   void EmitData(raw_ostream& Out, IdentifierInfo* II,
2570                 IdentID ID, unsigned) {
2571     MacroInfo *Macro = 0;
2572     if (!isInterestingIdentifier(II, Macro)) {
2573       clang::io::Emit32(Out, ID << 1);
2574       return;
2575     }
2576 
2577     clang::io::Emit32(Out, (ID << 1) | 0x01);
2578     uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID();
2579     assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader.");
2580     clang::io::Emit16(Out, Bits);
2581     Bits = 0;
2582     bool HadMacroDefinition = hadMacroDefinition(II, Macro);
2583     bool HasMacroDefinition = HadMacroDefinition && II->hasMacroDefinition();
2584     Bits = (Bits << 1) | unsigned(HasMacroDefinition);
2585     Bits = (Bits << 1) | unsigned(HadMacroDefinition);
2586     Bits = (Bits << 1) | unsigned(II->isExtensionToken());
2587     Bits = (Bits << 1) | unsigned(II->isPoisoned());
2588     Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
2589     Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
2590     clang::io::Emit16(Out, Bits);
2591 
2592     if (HadMacroDefinition) {
2593       clang::io::Emit32(Out, Writer.getMacroOffset(II));
2594       clang::io::Emit32(Out,
2595         Writer.inferSubmoduleIDFromLocation(Macro->getDefinitionLoc()));
2596     }
2597 
2598     // Emit the declaration IDs in reverse order, because the
2599     // IdentifierResolver provides the declarations as they would be
2600     // visible (e.g., the function "stat" would come before the struct
2601     // "stat"), but the ASTReader adds declarations to the end of the list
2602     // (so we need to see the struct "status" before the function "status").
2603     // Only emit declarations that aren't from a chained PCH, though.
2604     SmallVector<Decl *, 16> Decls(IdResolver.begin(II),
2605                                   IdResolver.end());
2606     for (SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(),
2607                                                 DEnd = Decls.rend();
2608          D != DEnd; ++D)
2609       clang::io::Emit32(Out, Writer.getDeclID(*D));
2610   }
2611 };
2612 } // end anonymous namespace
2613 
2614 /// \brief Write the identifier table into the AST file.
2615 ///
2616 /// The identifier table consists of a blob containing string data
2617 /// (the actual identifiers themselves) and a separate "offsets" index
2618 /// that maps identifier IDs to locations within the blob.
2619 void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
2620                                      IdentifierResolver &IdResolver,
2621                                      bool IsModule) {
2622   using namespace llvm;
2623 
2624   // Create and write out the blob that contains the identifier
2625   // strings.
2626   {
2627     OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
2628     ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
2629 
2630     // Look for any identifiers that were named while processing the
2631     // headers, but are otherwise not needed. We add these to the hash
2632     // table to enable checking of the predefines buffer in the case
2633     // where the user adds new macro definitions when building the AST
2634     // file.
2635     for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
2636                                 IDEnd = PP.getIdentifierTable().end();
2637          ID != IDEnd; ++ID)
2638       getIdentifierRef(ID->second);
2639 
2640     // Create the on-disk hash table representation. We only store offsets
2641     // for identifiers that appear here for the first time.
2642     IdentifierOffsets.resize(NextIdentID - FirstIdentID);
2643     for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator
2644            ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end();
2645          ID != IDEnd; ++ID) {
2646       assert(ID->first && "NULL identifier in identifier table");
2647       if (!Chain || !ID->first->isFromAST() ||
2648           ID->first->hasChangedSinceDeserialization())
2649         Generator.insert(const_cast<IdentifierInfo *>(ID->first), ID->second,
2650                          Trait);
2651     }
2652 
2653     // Create the on-disk hash table in a buffer.
2654     SmallString<4096> IdentifierTable;
2655     uint32_t BucketOffset;
2656     {
2657       ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
2658       llvm::raw_svector_ostream Out(IdentifierTable);
2659       // Make sure that no bucket is at offset 0
2660       clang::io::Emit32(Out, 0);
2661       BucketOffset = Generator.Emit(Out, Trait);
2662     }
2663 
2664     // Create a blob abbreviation
2665     BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2666     Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
2667     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
2668     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2669     unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev);
2670 
2671     // Write the identifier table
2672     RecordData Record;
2673     Record.push_back(IDENTIFIER_TABLE);
2674     Record.push_back(BucketOffset);
2675     Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
2676   }
2677 
2678   // Write the offsets table for identifier IDs.
2679   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
2680   Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
2681   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
2682   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
2683   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2684   unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
2685 
2686   RecordData Record;
2687   Record.push_back(IDENTIFIER_OFFSET);
2688   Record.push_back(IdentifierOffsets.size());
2689   Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS);
2690   Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
2691                             data(IdentifierOffsets));
2692 }
2693 
2694 //===----------------------------------------------------------------------===//
2695 // DeclContext's Name Lookup Table Serialization
2696 //===----------------------------------------------------------------------===//
2697 
2698 namespace {
2699 // Trait used for the on-disk hash table used in the method pool.
2700 class ASTDeclContextNameLookupTrait {
2701   ASTWriter &Writer;
2702 
2703 public:
2704   typedef DeclarationName key_type;
2705   typedef key_type key_type_ref;
2706 
2707   typedef DeclContext::lookup_result data_type;
2708   typedef const data_type& data_type_ref;
2709 
2710   explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { }
2711 
2712   unsigned ComputeHash(DeclarationName Name) {
2713     llvm::FoldingSetNodeID ID;
2714     ID.AddInteger(Name.getNameKind());
2715 
2716     switch (Name.getNameKind()) {
2717     case DeclarationName::Identifier:
2718       ID.AddString(Name.getAsIdentifierInfo()->getName());
2719       break;
2720     case DeclarationName::ObjCZeroArgSelector:
2721     case DeclarationName::ObjCOneArgSelector:
2722     case DeclarationName::ObjCMultiArgSelector:
2723       ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector()));
2724       break;
2725     case DeclarationName::CXXConstructorName:
2726     case DeclarationName::CXXDestructorName:
2727     case DeclarationName::CXXConversionFunctionName:
2728       break;
2729     case DeclarationName::CXXOperatorName:
2730       ID.AddInteger(Name.getCXXOverloadedOperator());
2731       break;
2732     case DeclarationName::CXXLiteralOperatorName:
2733       ID.AddString(Name.getCXXLiteralIdentifier()->getName());
2734     case DeclarationName::CXXUsingDirective:
2735       break;
2736     }
2737 
2738     return ID.ComputeHash();
2739   }
2740 
2741   std::pair<unsigned,unsigned>
2742     EmitKeyDataLength(raw_ostream& Out, DeclarationName Name,
2743                       data_type_ref Lookup) {
2744     unsigned KeyLen = 1;
2745     switch (Name.getNameKind()) {
2746     case DeclarationName::Identifier:
2747     case DeclarationName::ObjCZeroArgSelector:
2748     case DeclarationName::ObjCOneArgSelector:
2749     case DeclarationName::ObjCMultiArgSelector:
2750     case DeclarationName::CXXLiteralOperatorName:
2751       KeyLen += 4;
2752       break;
2753     case DeclarationName::CXXOperatorName:
2754       KeyLen += 1;
2755       break;
2756     case DeclarationName::CXXConstructorName:
2757     case DeclarationName::CXXDestructorName:
2758     case DeclarationName::CXXConversionFunctionName:
2759     case DeclarationName::CXXUsingDirective:
2760       break;
2761     }
2762     clang::io::Emit16(Out, KeyLen);
2763 
2764     // 2 bytes for num of decls and 4 for each DeclID.
2765     unsigned DataLen = 2 + 4 * (Lookup.second - Lookup.first);
2766     clang::io::Emit16(Out, DataLen);
2767 
2768     return std::make_pair(KeyLen, DataLen);
2769   }
2770 
2771   void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) {
2772     using namespace clang::io;
2773 
2774     Emit8(Out, Name.getNameKind());
2775     switch (Name.getNameKind()) {
2776     case DeclarationName::Identifier:
2777       Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
2778       return;
2779     case DeclarationName::ObjCZeroArgSelector:
2780     case DeclarationName::ObjCOneArgSelector:
2781     case DeclarationName::ObjCMultiArgSelector:
2782       Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector()));
2783       return;
2784     case DeclarationName::CXXOperatorName:
2785       assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS &&
2786              "Invalid operator?");
2787       Emit8(Out, Name.getCXXOverloadedOperator());
2788       return;
2789     case DeclarationName::CXXLiteralOperatorName:
2790       Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
2791       return;
2792     case DeclarationName::CXXConstructorName:
2793     case DeclarationName::CXXDestructorName:
2794     case DeclarationName::CXXConversionFunctionName:
2795     case DeclarationName::CXXUsingDirective:
2796       return;
2797     }
2798 
2799     llvm_unreachable("Invalid name kind?");
2800   }
2801 
2802   void EmitData(raw_ostream& Out, key_type_ref,
2803                 data_type Lookup, unsigned DataLen) {
2804     uint64_t Start = Out.tell(); (void)Start;
2805     clang::io::Emit16(Out, Lookup.second - Lookup.first);
2806     for (; Lookup.first != Lookup.second; ++Lookup.first)
2807       clang::io::Emit32(Out, Writer.GetDeclRef(*Lookup.first));
2808 
2809     assert(Out.tell() - Start == DataLen && "Data length is wrong");
2810   }
2811 };
2812 } // end anonymous namespace
2813 
2814 /// \brief Write the block containing all of the declaration IDs
2815 /// visible from the given DeclContext.
2816 ///
2817 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
2818 /// bitstream, or 0 if no block was written.
2819 uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
2820                                                  DeclContext *DC) {
2821   if (DC->getPrimaryContext() != DC)
2822     return 0;
2823 
2824   // Since there is no name lookup into functions or methods, don't bother to
2825   // build a visible-declarations table for these entities.
2826   if (DC->isFunctionOrMethod())
2827     return 0;
2828 
2829   // If not in C++, we perform name lookup for the translation unit via the
2830   // IdentifierInfo chains, don't bother to build a visible-declarations table.
2831   // FIXME: In C++ we need the visible declarations in order to "see" the
2832   // friend declarations, is there a way to do this without writing the table ?
2833   if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus)
2834     return 0;
2835 
2836   // Serialize the contents of the mapping used for lookup. Note that,
2837   // although we have two very different code paths, the serialized
2838   // representation is the same for both cases: a declaration name,
2839   // followed by a size, followed by references to the visible
2840   // declarations that have that name.
2841   uint64_t Offset = Stream.GetCurrentBitNo();
2842   StoredDeclsMap *Map = DC->buildLookup();
2843   if (!Map || Map->empty())
2844     return 0;
2845 
2846   OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
2847   ASTDeclContextNameLookupTrait Trait(*this);
2848 
2849   // Create the on-disk hash table representation.
2850   DeclarationName ConversionName;
2851   llvm::SmallVector<NamedDecl *, 4> ConversionDecls;
2852   for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
2853        D != DEnd; ++D) {
2854     DeclarationName Name = D->first;
2855     DeclContext::lookup_result Result = D->second.getLookupResult();
2856     if (Result.first != Result.second) {
2857       if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
2858         // Hash all conversion function names to the same name. The actual
2859         // type information in conversion function name is not used in the
2860         // key (since such type information is not stable across different
2861         // modules), so the intended effect is to coalesce all of the conversion
2862         // functions under a single key.
2863         if (!ConversionName)
2864           ConversionName = Name;
2865         ConversionDecls.append(Result.first, Result.second);
2866         continue;
2867       }
2868 
2869       Generator.insert(Name, Result, Trait);
2870     }
2871   }
2872 
2873   // Add the conversion functions
2874   if (!ConversionDecls.empty()) {
2875     Generator.insert(ConversionName,
2876                      DeclContext::lookup_result(ConversionDecls.begin(),
2877                                                 ConversionDecls.end()),
2878                      Trait);
2879   }
2880 
2881   // Create the on-disk hash table in a buffer.
2882   SmallString<4096> LookupTable;
2883   uint32_t BucketOffset;
2884   {
2885     llvm::raw_svector_ostream Out(LookupTable);
2886     // Make sure that no bucket is at offset 0
2887     clang::io::Emit32(Out, 0);
2888     BucketOffset = Generator.Emit(Out, Trait);
2889   }
2890 
2891   // Write the lookup table
2892   RecordData Record;
2893   Record.push_back(DECL_CONTEXT_VISIBLE);
2894   Record.push_back(BucketOffset);
2895   Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
2896                             LookupTable.str());
2897 
2898   Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record);
2899   ++NumVisibleDeclContexts;
2900   return Offset;
2901 }
2902 
2903 /// \brief Write an UPDATE_VISIBLE block for the given context.
2904 ///
2905 /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
2906 /// DeclContext in a dependent AST file. As such, they only exist for the TU
2907 /// (in C++), for namespaces, and for classes with forward-declared unscoped
2908 /// enumeration members (in C++11).
2909 void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
2910   StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
2911   if (!Map || Map->empty())
2912     return;
2913 
2914   OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
2915   ASTDeclContextNameLookupTrait Trait(*this);
2916 
2917   // Create the hash table.
2918   for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
2919        D != DEnd; ++D) {
2920     DeclarationName Name = D->first;
2921     DeclContext::lookup_result Result = D->second.getLookupResult();
2922     // For any name that appears in this table, the results are complete, i.e.
2923     // they overwrite results from previous PCHs. Merging is always a mess.
2924     if (Result.first != Result.second)
2925       Generator.insert(Name, Result, Trait);
2926   }
2927 
2928   // Create the on-disk hash table in a buffer.
2929   SmallString<4096> LookupTable;
2930   uint32_t BucketOffset;
2931   {
2932     llvm::raw_svector_ostream Out(LookupTable);
2933     // Make sure that no bucket is at offset 0
2934     clang::io::Emit32(Out, 0);
2935     BucketOffset = Generator.Emit(Out, Trait);
2936   }
2937 
2938   // Write the lookup table
2939   RecordData Record;
2940   Record.push_back(UPDATE_VISIBLE);
2941   Record.push_back(getDeclID(cast<Decl>(DC)));
2942   Record.push_back(BucketOffset);
2943   Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str());
2944 }
2945 
2946 /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions.
2947 void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) {
2948   RecordData Record;
2949   Record.push_back(Opts.fp_contract);
2950   Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record);
2951 }
2952 
2953 /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions.
2954 void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
2955   if (!SemaRef.Context.getLangOpts().OpenCL)
2956     return;
2957 
2958   const OpenCLOptions &Opts = SemaRef.getOpenCLOptions();
2959   RecordData Record;
2960 #define OPENCLEXT(nm)  Record.push_back(Opts.nm);
2961 #include "clang/Basic/OpenCLExtensions.def"
2962   Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
2963 }
2964 
2965 void ASTWriter::WriteRedeclarations() {
2966   RecordData LocalRedeclChains;
2967   SmallVector<serialization::LocalRedeclarationsInfo, 2> LocalRedeclsMap;
2968 
2969   for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) {
2970     Decl *First = Redeclarations[I];
2971     assert(First->getPreviousDecl() == 0 && "Not the first declaration?");
2972 
2973     Decl *MostRecent = First->getMostRecentDecl();
2974 
2975     // If we only have a single declaration, there is no point in storing
2976     // a redeclaration chain.
2977     if (First == MostRecent)
2978       continue;
2979 
2980     unsigned Offset = LocalRedeclChains.size();
2981     unsigned Size = 0;
2982     LocalRedeclChains.push_back(0); // Placeholder for the size.
2983 
2984     // Collect the set of local redeclarations of this declaration.
2985     for (Decl *Prev = MostRecent; Prev != First;
2986          Prev = Prev->getPreviousDecl()) {
2987       if (!Prev->isFromASTFile()) {
2988         AddDeclRef(Prev, LocalRedeclChains);
2989         ++Size;
2990       }
2991     }
2992     LocalRedeclChains[Offset] = Size;
2993 
2994     // Reverse the set of local redeclarations, so that we store them in
2995     // order (since we found them in reverse order).
2996     std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end());
2997 
2998     // Add the mapping from the first ID to the set of local declarations.
2999     LocalRedeclarationsInfo Info = { getDeclID(First), Offset };
3000     LocalRedeclsMap.push_back(Info);
3001 
3002     assert(N == Redeclarations.size() &&
3003            "Deserialized a declaration we shouldn't have");
3004   }
3005 
3006   if (LocalRedeclChains.empty())
3007     return;
3008 
3009   // Sort the local redeclarations map by the first declaration ID,
3010   // since the reader will be performing binary searches on this information.
3011   llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end());
3012 
3013   // Emit the local redeclarations map.
3014   using namespace llvm;
3015   llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3016   Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP));
3017   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
3018   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3019   unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
3020 
3021   RecordData Record;
3022   Record.push_back(LOCAL_REDECLARATIONS_MAP);
3023   Record.push_back(LocalRedeclsMap.size());
3024   Stream.EmitRecordWithBlob(AbbrevID, Record,
3025     reinterpret_cast<char*>(LocalRedeclsMap.data()),
3026     LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo));
3027 
3028   // Emit the redeclaration chains.
3029   Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains);
3030 }
3031 
3032 void ASTWriter::WriteObjCCategories() {
3033   llvm::SmallVector<ObjCCategoriesInfo, 2> CategoriesMap;
3034   RecordData Categories;
3035 
3036   for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
3037     unsigned Size = 0;
3038     unsigned StartIndex = Categories.size();
3039 
3040     ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I];
3041 
3042     // Allocate space for the size.
3043     Categories.push_back(0);
3044 
3045     // Add the categories.
3046     for (ObjCCategoryDecl *Cat = Class->getCategoryList();
3047          Cat; Cat = Cat->getNextClassCategory(), ++Size) {
3048       assert(getDeclID(Cat) != 0 && "Bogus category");
3049       AddDeclRef(Cat, Categories);
3050     }
3051 
3052     // Update the size.
3053     Categories[StartIndex] = Size;
3054 
3055     // Record this interface -> category map.
3056     ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex };
3057     CategoriesMap.push_back(CatInfo);
3058   }
3059 
3060   // Sort the categories map by the definition ID, since the reader will be
3061   // performing binary searches on this information.
3062   llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
3063 
3064   // Emit the categories map.
3065   using namespace llvm;
3066   llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3067   Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP));
3068   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
3069   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3070   unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
3071 
3072   RecordData Record;
3073   Record.push_back(OBJC_CATEGORIES_MAP);
3074   Record.push_back(CategoriesMap.size());
3075   Stream.EmitRecordWithBlob(AbbrevID, Record,
3076                             reinterpret_cast<char*>(CategoriesMap.data()),
3077                             CategoriesMap.size() * sizeof(ObjCCategoriesInfo));
3078 
3079   // Emit the category lists.
3080   Stream.EmitRecord(OBJC_CATEGORIES, Categories);
3081 }
3082 
3083 void ASTWriter::WriteMergedDecls() {
3084   if (!Chain || Chain->MergedDecls.empty())
3085     return;
3086 
3087   RecordData Record;
3088   for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(),
3089                                         IEnd = Chain->MergedDecls.end();
3090        I != IEnd; ++I) {
3091     DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID()
3092                                               : getDeclID(I->first);
3093     assert(CanonID && "Merged declaration not known?");
3094 
3095     Record.push_back(CanonID);
3096     Record.push_back(I->second.size());
3097     Record.append(I->second.begin(), I->second.end());
3098   }
3099   Stream.EmitRecord(MERGED_DECLARATIONS, Record);
3100 }
3101 
3102 //===----------------------------------------------------------------------===//
3103 // General Serialization Routines
3104 //===----------------------------------------------------------------------===//
3105 
3106 /// \brief Write a record containing the given attributes.
3107 void ASTWriter::WriteAttributes(ArrayRef<const Attr*> Attrs,
3108                                 RecordDataImpl &Record) {
3109   Record.push_back(Attrs.size());
3110   for (ArrayRef<const Attr *>::iterator i = Attrs.begin(),
3111                                         e = Attrs.end(); i != e; ++i){
3112     const Attr *A = *i;
3113     Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
3114     AddSourceRange(A->getRange(), Record);
3115 
3116 #include "clang/Serialization/AttrPCHWrite.inc"
3117 
3118   }
3119 }
3120 
3121 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) {
3122   Record.push_back(Str.size());
3123   Record.insert(Record.end(), Str.begin(), Str.end());
3124 }
3125 
3126 void ASTWriter::AddVersionTuple(const VersionTuple &Version,
3127                                 RecordDataImpl &Record) {
3128   Record.push_back(Version.getMajor());
3129   if (llvm::Optional<unsigned> Minor = Version.getMinor())
3130     Record.push_back(*Minor + 1);
3131   else
3132     Record.push_back(0);
3133   if (llvm::Optional<unsigned> Subminor = Version.getSubminor())
3134     Record.push_back(*Subminor + 1);
3135   else
3136     Record.push_back(0);
3137 }
3138 
3139 /// \brief Note that the identifier II occurs at the given offset
3140 /// within the identifier table.
3141 void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
3142   IdentID ID = IdentifierIDs[II];
3143   // Only store offsets new to this AST file. Other identifier names are looked
3144   // up earlier in the chain and thus don't need an offset.
3145   if (ID >= FirstIdentID)
3146     IdentifierOffsets[ID - FirstIdentID] = Offset;
3147 }
3148 
3149 /// \brief Note that the selector Sel occurs at the given offset
3150 /// within the method pool/selector table.
3151 void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
3152   unsigned ID = SelectorIDs[Sel];
3153   assert(ID && "Unknown selector");
3154   // Don't record offsets for selectors that are also available in a different
3155   // file.
3156   if (ID < FirstSelectorID)
3157     return;
3158   SelectorOffsets[ID - FirstSelectorID] = Offset;
3159 }
3160 
3161 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream)
3162   : Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0),
3163     WritingAST(false), DoneWritingDeclsAndTypes(false),
3164     ASTHasCompilerErrors(false),
3165     FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID),
3166     FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID),
3167     FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID),
3168     FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS),
3169     NextSubmoduleID(FirstSubmoduleID),
3170     FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID),
3171     CollectedStmts(&StmtsToEmit),
3172     NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0),
3173     NumVisibleDeclContexts(0),
3174     NextCXXBaseSpecifiersID(1),
3175     DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0),
3176     DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0),
3177     DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0),
3178     DeclRecordAbbrev(0), IntegerLiteralAbbrev(0),
3179     DeclTypedefAbbrev(0),
3180     DeclVarAbbrev(0), DeclFieldAbbrev(0),
3181     DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0)
3182 {
3183 }
3184 
3185 ASTWriter::~ASTWriter() {
3186   for (FileDeclIDsTy::iterator
3187          I = FileDeclIDs.begin(), E = FileDeclIDs.end(); I != E; ++I)
3188     delete I->second;
3189 }
3190 
3191 void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls,
3192                          const std::string &OutputFile,
3193                          Module *WritingModule, StringRef isysroot,
3194                          bool hasErrors) {
3195   WritingAST = true;
3196 
3197   ASTHasCompilerErrors = hasErrors;
3198 
3199   // Emit the file header.
3200   Stream.Emit((unsigned)'C', 8);
3201   Stream.Emit((unsigned)'P', 8);
3202   Stream.Emit((unsigned)'C', 8);
3203   Stream.Emit((unsigned)'H', 8);
3204 
3205   WriteBlockInfoBlock();
3206 
3207   Context = &SemaRef.Context;
3208   PP = &SemaRef.PP;
3209   this->WritingModule = WritingModule;
3210   WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile, WritingModule);
3211   Context = 0;
3212   PP = 0;
3213   this->WritingModule = 0;
3214 
3215   WritingAST = false;
3216 }
3217 
3218 template<typename Vector>
3219 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
3220                                ASTWriter::RecordData &Record) {
3221   for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end();
3222        I != E; ++I)  {
3223     Writer.AddDeclRef(*I, Record);
3224   }
3225 }
3226 
3227 void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
3228                              StringRef isysroot,
3229                              const std::string &OutputFile,
3230                              Module *WritingModule) {
3231   using namespace llvm;
3232 
3233   // Make sure that the AST reader knows to finalize itself.
3234   if (Chain)
3235     Chain->finalizeForWriting();
3236 
3237   ASTContext &Context = SemaRef.Context;
3238   Preprocessor &PP = SemaRef.PP;
3239 
3240   // Set up predefined declaration IDs.
3241   DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID;
3242   if (Context.ObjCIdDecl)
3243     DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID;
3244   if (Context.ObjCSelDecl)
3245     DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID;
3246   if (Context.ObjCClassDecl)
3247     DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID;
3248   if (Context.ObjCProtocolClassDecl)
3249     DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID;
3250   if (Context.Int128Decl)
3251     DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID;
3252   if (Context.UInt128Decl)
3253     DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID;
3254   if (Context.ObjCInstanceTypeDecl)
3255     DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID;
3256   if (Context.BuiltinVaListDecl)
3257     DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID;
3258 
3259   if (!Chain) {
3260     // Make sure that we emit IdentifierInfos (and any attached
3261     // declarations) for builtins. We don't need to do this when we're
3262     // emitting chained PCH files, because all of the builtins will be
3263     // in the original PCH file.
3264     // FIXME: Modules won't like this at all.
3265     IdentifierTable &Table = PP.getIdentifierTable();
3266     SmallVector<const char *, 32> BuiltinNames;
3267     Context.BuiltinInfo.GetBuiltinNames(BuiltinNames,
3268                                         Context.getLangOpts().NoBuiltin);
3269     for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I)
3270       getIdentifierRef(&Table.get(BuiltinNames[I]));
3271   }
3272 
3273   // If there are any out-of-date identifiers, bring them up to date.
3274   if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) {
3275     for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
3276                                 IDEnd = PP.getIdentifierTable().end();
3277          ID != IDEnd; ++ID)
3278       if (ID->second->isOutOfDate())
3279         ExtSource->updateOutOfDateIdentifier(*ID->second);
3280   }
3281 
3282   // Build a record containing all of the tentative definitions in this file, in
3283   // TentativeDefinitions order.  Generally, this record will be empty for
3284   // headers.
3285   RecordData TentativeDefinitions;
3286   AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
3287 
3288   // Build a record containing all of the file scoped decls in this file.
3289   RecordData UnusedFileScopedDecls;
3290   AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls,
3291                      UnusedFileScopedDecls);
3292 
3293   // Build a record containing all of the delegating constructors we still need
3294   // to resolve.
3295   RecordData DelegatingCtorDecls;
3296   AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls);
3297 
3298   // Write the set of weak, undeclared identifiers. We always write the
3299   // entire table, since later PCH files in a PCH chain are only interested in
3300   // the results at the end of the chain.
3301   RecordData WeakUndeclaredIdentifiers;
3302   if (!SemaRef.WeakUndeclaredIdentifiers.empty()) {
3303     for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
3304          I = SemaRef.WeakUndeclaredIdentifiers.begin(),
3305          E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) {
3306       AddIdentifierRef(I->first, WeakUndeclaredIdentifiers);
3307       AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers);
3308       AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers);
3309       WeakUndeclaredIdentifiers.push_back(I->second.getUsed());
3310     }
3311   }
3312 
3313   // Build a record containing all of the locally-scoped external
3314   // declarations in this header file. Generally, this record will be
3315   // empty.
3316   RecordData LocallyScopedExternalDecls;
3317   // FIXME: This is filling in the AST file in densemap order which is
3318   // nondeterminstic!
3319   for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
3320          TD = SemaRef.LocallyScopedExternalDecls.begin(),
3321          TDEnd = SemaRef.LocallyScopedExternalDecls.end();
3322        TD != TDEnd; ++TD) {
3323     if (!TD->second->isFromASTFile())
3324       AddDeclRef(TD->second, LocallyScopedExternalDecls);
3325   }
3326 
3327   // Build a record containing all of the ext_vector declarations.
3328   RecordData ExtVectorDecls;
3329   AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls);
3330 
3331   // Build a record containing all of the VTable uses information.
3332   RecordData VTableUses;
3333   if (!SemaRef.VTableUses.empty()) {
3334     for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
3335       AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
3336       AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
3337       VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
3338     }
3339   }
3340 
3341   // Build a record containing all of dynamic classes declarations.
3342   RecordData DynamicClasses;
3343   AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses);
3344 
3345   // Build a record containing all of pending implicit instantiations.
3346   RecordData PendingInstantiations;
3347   for (std::deque<Sema::PendingImplicitInstantiation>::iterator
3348          I = SemaRef.PendingInstantiations.begin(),
3349          N = SemaRef.PendingInstantiations.end(); I != N; ++I) {
3350     AddDeclRef(I->first, PendingInstantiations);
3351     AddSourceLocation(I->second, PendingInstantiations);
3352   }
3353   assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
3354          "There are local ones at end of translation unit!");
3355 
3356   // Build a record containing some declaration references.
3357   RecordData SemaDeclRefs;
3358   if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) {
3359     AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
3360     AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
3361   }
3362 
3363   RecordData CUDASpecialDeclRefs;
3364   if (Context.getcudaConfigureCallDecl()) {
3365     AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs);
3366   }
3367 
3368   // Build a record containing all of the known namespaces.
3369   RecordData KnownNamespaces;
3370   for (llvm::DenseMap<NamespaceDecl*, bool>::iterator
3371             I = SemaRef.KnownNamespaces.begin(),
3372          IEnd = SemaRef.KnownNamespaces.end();
3373        I != IEnd; ++I) {
3374     if (!I->second)
3375       AddDeclRef(I->first, KnownNamespaces);
3376   }
3377 
3378   // Write the remaining AST contents.
3379   RecordData Record;
3380   Stream.EnterSubblock(AST_BLOCK_ID, 5);
3381   WriteMetadata(Context, isysroot, OutputFile);
3382   WriteLanguageOptions(Context.getLangOpts());
3383   if (StatCalls && isysroot.empty())
3384     WriteStatCache(*StatCalls);
3385 
3386   // Create a lexical update block containing all of the declarations in the
3387   // translation unit that do not come from other AST files.
3388   const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
3389   SmallVector<KindDeclIDPair, 64> NewGlobalDecls;
3390   for (DeclContext::decl_iterator I = TU->noload_decls_begin(),
3391                                   E = TU->noload_decls_end();
3392        I != E; ++I) {
3393     if (!(*I)->isFromASTFile())
3394       NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I)));
3395   }
3396 
3397   llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev();
3398   Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
3399   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
3400   unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv);
3401   Record.clear();
3402   Record.push_back(TU_UPDATE_LEXICAL);
3403   Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
3404                             data(NewGlobalDecls));
3405 
3406   // And a visible updates block for the translation unit.
3407   Abv = new llvm::BitCodeAbbrev();
3408   Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
3409   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
3410   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32));
3411   Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
3412   UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv);
3413   WriteDeclContextVisibleUpdate(TU);
3414 
3415   // If the translation unit has an anonymous namespace, and we don't already
3416   // have an update block for it, write it as an update block.
3417   if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
3418     ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
3419     if (Record.empty()) {
3420       Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
3421       Record.push_back(reinterpret_cast<uint64_t>(NS));
3422     }
3423   }
3424 
3425   // Make sure visible decls, added to DeclContexts previously loaded from
3426   // an AST file, are registered for serialization.
3427   for (SmallVector<const Decl *, 16>::iterator
3428          I = UpdatingVisibleDecls.begin(),
3429          E = UpdatingVisibleDecls.end(); I != E; ++I) {
3430     GetDeclRef(*I);
3431   }
3432 
3433   // Resolve any declaration pointers within the declaration updates block.
3434   ResolveDeclUpdatesBlocks();
3435 
3436   // Form the record of special types.
3437   RecordData SpecialTypes;
3438   AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
3439   AddTypeRef(Context.getFILEType(), SpecialTypes);
3440   AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
3441   AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
3442   AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
3443   AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
3444   AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
3445   AddTypeRef(Context.getucontext_tType(), SpecialTypes);
3446 
3447   // Keep writing types and declarations until all types and
3448   // declarations have been written.
3449   Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
3450   WriteDeclsBlockAbbrevs();
3451   for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(),
3452                                   E = DeclsToRewrite.end();
3453        I != E; ++I)
3454     DeclTypesToEmit.push(const_cast<Decl*>(*I));
3455   while (!DeclTypesToEmit.empty()) {
3456     DeclOrType DOT = DeclTypesToEmit.front();
3457     DeclTypesToEmit.pop();
3458     if (DOT.isType())
3459       WriteType(DOT.getType());
3460     else
3461       WriteDecl(Context, DOT.getDecl());
3462   }
3463   Stream.ExitBlock();
3464 
3465   DoneWritingDeclsAndTypes = true;
3466 
3467   WriteFileDeclIDsMap();
3468   WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
3469   WriteComments();
3470 
3471   if (Chain) {
3472     // Write the mapping information describing our module dependencies and how
3473     // each of those modules were mapped into our own offset/ID space, so that
3474     // the reader can build the appropriate mapping to its own offset/ID space.
3475     // The map consists solely of a blob with the following format:
3476     // *(module-name-len:i16 module-name:len*i8
3477     //   source-location-offset:i32
3478     //   identifier-id:i32
3479     //   preprocessed-entity-id:i32
3480     //   macro-definition-id:i32
3481     //   submodule-id:i32
3482     //   selector-id:i32
3483     //   declaration-id:i32
3484     //   c++-base-specifiers-id:i32
3485     //   type-id:i32)
3486     //
3487     llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
3488     Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
3489     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
3490     unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev);
3491     SmallString<2048> Buffer;
3492     {
3493       llvm::raw_svector_ostream Out(Buffer);
3494       for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
3495                                            MEnd = Chain->ModuleMgr.end();
3496            M != MEnd; ++M) {
3497         StringRef FileName = (*M)->FileName;
3498         io::Emit16(Out, FileName.size());
3499         Out.write(FileName.data(), FileName.size());
3500         io::Emit32(Out, (*M)->SLocEntryBaseOffset);
3501         io::Emit32(Out, (*M)->BaseIdentifierID);
3502         io::Emit32(Out, (*M)->BasePreprocessedEntityID);
3503         io::Emit32(Out, (*M)->BaseSubmoduleID);
3504         io::Emit32(Out, (*M)->BaseSelectorID);
3505         io::Emit32(Out, (*M)->BaseDeclID);
3506         io::Emit32(Out, (*M)->BaseTypeIndex);
3507       }
3508     }
3509     Record.clear();
3510     Record.push_back(MODULE_OFFSET_MAP);
3511     Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
3512                               Buffer.data(), Buffer.size());
3513   }
3514   WritePreprocessor(PP, WritingModule != 0);
3515   WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot);
3516   WriteSelectors(SemaRef);
3517   WriteReferencedSelectorsPool(SemaRef);
3518   WriteIdentifierTable(PP, SemaRef.IdResolver, WritingModule != 0);
3519   WriteFPPragmaOptions(SemaRef.getFPOptions());
3520   WriteOpenCLExtensions(SemaRef);
3521 
3522   WriteTypeDeclOffsets();
3523   WritePragmaDiagnosticMappings(Context.getDiagnostics());
3524 
3525   WriteCXXBaseSpecifiersOffsets();
3526 
3527   // If we're emitting a module, write out the submodule information.
3528   if (WritingModule)
3529     WriteSubmodules(WritingModule);
3530 
3531   Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes);
3532 
3533   // Write the record containing external, unnamed definitions.
3534   if (!ExternalDefinitions.empty())
3535     Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions);
3536 
3537   // Write the record containing tentative definitions.
3538   if (!TentativeDefinitions.empty())
3539     Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
3540 
3541   // Write the record containing unused file scoped decls.
3542   if (!UnusedFileScopedDecls.empty())
3543     Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
3544 
3545   // Write the record containing weak undeclared identifiers.
3546   if (!WeakUndeclaredIdentifiers.empty())
3547     Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
3548                       WeakUndeclaredIdentifiers);
3549 
3550   // Write the record containing locally-scoped external definitions.
3551   if (!LocallyScopedExternalDecls.empty())
3552     Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS,
3553                       LocallyScopedExternalDecls);
3554 
3555   // Write the record containing ext_vector type names.
3556   if (!ExtVectorDecls.empty())
3557     Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
3558 
3559   // Write the record containing VTable uses information.
3560   if (!VTableUses.empty())
3561     Stream.EmitRecord(VTABLE_USES, VTableUses);
3562 
3563   // Write the record containing dynamic classes declarations.
3564   if (!DynamicClasses.empty())
3565     Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses);
3566 
3567   // Write the record containing pending implicit instantiations.
3568   if (!PendingInstantiations.empty())
3569     Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
3570 
3571   // Write the record containing declaration references of Sema.
3572   if (!SemaDeclRefs.empty())
3573     Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
3574 
3575   // Write the record containing CUDA-specific declaration references.
3576   if (!CUDASpecialDeclRefs.empty())
3577     Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs);
3578 
3579   // Write the delegating constructors.
3580   if (!DelegatingCtorDecls.empty())
3581     Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls);
3582 
3583   // Write the known namespaces.
3584   if (!KnownNamespaces.empty())
3585     Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces);
3586 
3587   // Write the visible updates to DeclContexts.
3588   for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator
3589        I = UpdatedDeclContexts.begin(),
3590        E = UpdatedDeclContexts.end();
3591        I != E; ++I)
3592     WriteDeclContextVisibleUpdate(*I);
3593 
3594   if (!WritingModule) {
3595     // Write the submodules that were imported, if any.
3596     RecordData ImportedModules;
3597     for (ASTContext::import_iterator I = Context.local_import_begin(),
3598                                   IEnd = Context.local_import_end();
3599          I != IEnd; ++I) {
3600       assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
3601       ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]);
3602     }
3603     if (!ImportedModules.empty()) {
3604       // Sort module IDs.
3605       llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end());
3606 
3607       // Unique module IDs.
3608       ImportedModules.erase(std::unique(ImportedModules.begin(),
3609                                         ImportedModules.end()),
3610                             ImportedModules.end());
3611 
3612       Stream.EmitRecord(IMPORTED_MODULES, ImportedModules);
3613     }
3614   }
3615 
3616   WriteDeclUpdatesBlocks();
3617   WriteDeclReplacementsBlock();
3618   WriteMergedDecls();
3619   WriteRedeclarations();
3620   WriteObjCCategories();
3621 
3622   // Some simple statistics
3623   Record.clear();
3624   Record.push_back(NumStatements);
3625   Record.push_back(NumMacros);
3626   Record.push_back(NumLexicalDeclContexts);
3627   Record.push_back(NumVisibleDeclContexts);
3628   Stream.EmitRecord(STATISTICS, Record);
3629   Stream.ExitBlock();
3630 }
3631 
3632 /// \brief Go through the declaration update blocks and resolve declaration
3633 /// pointers into declaration IDs.
3634 void ASTWriter::ResolveDeclUpdatesBlocks() {
3635   for (DeclUpdateMap::iterator
3636        I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) {
3637     const Decl *D = I->first;
3638     UpdateRecord &URec = I->second;
3639 
3640     if (isRewritten(D))
3641       continue; // The decl will be written completely
3642 
3643     unsigned Idx = 0, N = URec.size();
3644     while (Idx < N) {
3645       switch ((DeclUpdateKind)URec[Idx++]) {
3646       case UPD_CXX_ADDED_IMPLICIT_MEMBER:
3647       case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3648       case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE:
3649         URec[Idx] = GetDeclRef(reinterpret_cast<Decl *>(URec[Idx]));
3650         ++Idx;
3651         break;
3652 
3653       case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3654         ++Idx;
3655         break;
3656       }
3657     }
3658   }
3659 }
3660 
3661 void ASTWriter::WriteDeclUpdatesBlocks() {
3662   if (DeclUpdates.empty())
3663     return;
3664 
3665   RecordData OffsetsRecord;
3666   Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
3667   for (DeclUpdateMap::iterator
3668          I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) {
3669     const Decl *D = I->first;
3670     UpdateRecord &URec = I->second;
3671 
3672     if (isRewritten(D))
3673       continue; // The decl will be written completely,no need to store updates.
3674 
3675     uint64_t Offset = Stream.GetCurrentBitNo();
3676     Stream.EmitRecord(DECL_UPDATES, URec);
3677 
3678     OffsetsRecord.push_back(GetDeclRef(D));
3679     OffsetsRecord.push_back(Offset);
3680   }
3681   Stream.ExitBlock();
3682   Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord);
3683 }
3684 
3685 void ASTWriter::WriteDeclReplacementsBlock() {
3686   if (ReplacedDecls.empty())
3687     return;
3688 
3689   RecordData Record;
3690   for (SmallVector<ReplacedDeclInfo, 16>::iterator
3691            I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) {
3692     Record.push_back(I->ID);
3693     Record.push_back(I->Offset);
3694     Record.push_back(I->Loc);
3695   }
3696   Stream.EmitRecord(DECL_REPLACEMENTS, Record);
3697 }
3698 
3699 void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
3700   Record.push_back(Loc.getRawEncoding());
3701 }
3702 
3703 void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
3704   AddSourceLocation(Range.getBegin(), Record);
3705   AddSourceLocation(Range.getEnd(), Record);
3706 }
3707 
3708 void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) {
3709   Record.push_back(Value.getBitWidth());
3710   const uint64_t *Words = Value.getRawData();
3711   Record.append(Words, Words + Value.getNumWords());
3712 }
3713 
3714 void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) {
3715   Record.push_back(Value.isUnsigned());
3716   AddAPInt(Value, Record);
3717 }
3718 
3719 void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) {
3720   AddAPInt(Value.bitcastToAPInt(), Record);
3721 }
3722 
3723 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
3724   Record.push_back(getIdentifierRef(II));
3725 }
3726 
3727 IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
3728   if (II == 0)
3729     return 0;
3730 
3731   IdentID &ID = IdentifierIDs[II];
3732   if (ID == 0)
3733     ID = NextIdentID++;
3734   return ID;
3735 }
3736 
3737 void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) {
3738   Record.push_back(getSelectorRef(SelRef));
3739 }
3740 
3741 SelectorID ASTWriter::getSelectorRef(Selector Sel) {
3742   if (Sel.getAsOpaquePtr() == 0) {
3743     return 0;
3744   }
3745 
3746   SelectorID &SID = SelectorIDs[Sel];
3747   if (SID == 0 && Chain) {
3748     // This might trigger a ReadSelector callback, which will set the ID for
3749     // this selector.
3750     Chain->LoadSelector(Sel);
3751   }
3752   if (SID == 0) {
3753     SID = NextSelectorID++;
3754   }
3755   return SID;
3756 }
3757 
3758 void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) {
3759   AddDeclRef(Temp->getDestructor(), Record);
3760 }
3761 
3762 void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases,
3763                                       CXXBaseSpecifier const *BasesEnd,
3764                                         RecordDataImpl &Record) {
3765   assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded");
3766   CXXBaseSpecifiersToWrite.push_back(
3767                                 QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID,
3768                                                         Bases, BasesEnd));
3769   Record.push_back(NextCXXBaseSpecifiersID++);
3770 }
3771 
3772 void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
3773                                            const TemplateArgumentLocInfo &Arg,
3774                                            RecordDataImpl &Record) {
3775   switch (Kind) {
3776   case TemplateArgument::Expression:
3777     AddStmt(Arg.getAsExpr());
3778     break;
3779   case TemplateArgument::Type:
3780     AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record);
3781     break;
3782   case TemplateArgument::Template:
3783     AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
3784     AddSourceLocation(Arg.getTemplateNameLoc(), Record);
3785     break;
3786   case TemplateArgument::TemplateExpansion:
3787     AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
3788     AddSourceLocation(Arg.getTemplateNameLoc(), Record);
3789     AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record);
3790     break;
3791   case TemplateArgument::Null:
3792   case TemplateArgument::Integral:
3793   case TemplateArgument::Declaration:
3794   case TemplateArgument::NullPtr:
3795   case TemplateArgument::Pack:
3796     // FIXME: Is this right?
3797     break;
3798   }
3799 }
3800 
3801 void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
3802                                        RecordDataImpl &Record) {
3803   AddTemplateArgument(Arg.getArgument(), Record);
3804 
3805   if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
3806     bool InfoHasSameExpr
3807       = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
3808     Record.push_back(InfoHasSameExpr);
3809     if (InfoHasSameExpr)
3810       return; // Avoid storing the same expr twice.
3811   }
3812   AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(),
3813                              Record);
3814 }
3815 
3816 void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
3817                                   RecordDataImpl &Record) {
3818   if (TInfo == 0) {
3819     AddTypeRef(QualType(), Record);
3820     return;
3821   }
3822 
3823   AddTypeLoc(TInfo->getTypeLoc(), Record);
3824 }
3825 
3826 void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) {
3827   AddTypeRef(TL.getType(), Record);
3828 
3829   TypeLocWriter TLW(*this, Record);
3830   for (; !TL.isNull(); TL = TL.getNextTypeLoc())
3831     TLW.Visit(TL);
3832 }
3833 
3834 void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) {
3835   Record.push_back(GetOrCreateTypeID(T));
3836 }
3837 
3838 TypeID ASTWriter::GetOrCreateTypeID( QualType T) {
3839   return MakeTypeID(*Context, T,
3840               std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this));
3841 }
3842 
3843 TypeID ASTWriter::getTypeID(QualType T) const {
3844   return MakeTypeID(*Context, T,
3845               std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this));
3846 }
3847 
3848 TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) {
3849   if (T.isNull())
3850     return TypeIdx();
3851   assert(!T.getLocalFastQualifiers());
3852 
3853   TypeIdx &Idx = TypeIdxs[T];
3854   if (Idx.getIndex() == 0) {
3855     if (DoneWritingDeclsAndTypes) {
3856       assert(0 && "New type seen after serializing all the types to emit!");
3857       return TypeIdx();
3858     }
3859 
3860     // We haven't seen this type before. Assign it a new ID and put it
3861     // into the queue of types to emit.
3862     Idx = TypeIdx(NextTypeID++);
3863     DeclTypesToEmit.push(T);
3864   }
3865   return Idx;
3866 }
3867 
3868 TypeIdx ASTWriter::getTypeIdx(QualType T) const {
3869   if (T.isNull())
3870     return TypeIdx();
3871   assert(!T.getLocalFastQualifiers());
3872 
3873   TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3874   assert(I != TypeIdxs.end() && "Type not emitted!");
3875   return I->second;
3876 }
3877 
3878 void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) {
3879   Record.push_back(GetDeclRef(D));
3880 }
3881 
3882 DeclID ASTWriter::GetDeclRef(const Decl *D) {
3883   assert(WritingAST && "Cannot request a declaration ID before AST writing");
3884 
3885   if (D == 0) {
3886     return 0;
3887   }
3888 
3889   // If D comes from an AST file, its declaration ID is already known and
3890   // fixed.
3891   if (D->isFromASTFile())
3892     return D->getGlobalID();
3893 
3894   assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
3895   DeclID &ID = DeclIDs[D];
3896   if (ID == 0) {
3897     if (DoneWritingDeclsAndTypes) {
3898       assert(0 && "New decl seen after serializing all the decls to emit!");
3899       return 0;
3900     }
3901 
3902     // We haven't seen this declaration before. Give it a new ID and
3903     // enqueue it in the list of declarations to emit.
3904     ID = NextDeclID++;
3905     DeclTypesToEmit.push(const_cast<Decl *>(D));
3906   }
3907 
3908   return ID;
3909 }
3910 
3911 DeclID ASTWriter::getDeclID(const Decl *D) {
3912   if (D == 0)
3913     return 0;
3914 
3915   // If D comes from an AST file, its declaration ID is already known and
3916   // fixed.
3917   if (D->isFromASTFile())
3918     return D->getGlobalID();
3919 
3920   assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
3921   return DeclIDs[D];
3922 }
3923 
3924 static inline bool compLocDecl(std::pair<unsigned, serialization::DeclID> L,
3925                                std::pair<unsigned, serialization::DeclID> R) {
3926   return L.first < R.first;
3927 }
3928 
3929 void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) {
3930   assert(ID);
3931   assert(D);
3932 
3933   SourceLocation Loc = D->getLocation();
3934   if (Loc.isInvalid())
3935     return;
3936 
3937   // We only keep track of the file-level declarations of each file.
3938   if (!D->getLexicalDeclContext()->isFileContext())
3939     return;
3940   // FIXME: ParmVarDecls that are part of a function type of a parameter of
3941   // a function/objc method, should not have TU as lexical context.
3942   if (isa<ParmVarDecl>(D))
3943     return;
3944 
3945   SourceManager &SM = Context->getSourceManager();
3946   SourceLocation FileLoc = SM.getFileLoc(Loc);
3947   assert(SM.isLocalSourceLocation(FileLoc));
3948   FileID FID;
3949   unsigned Offset;
3950   llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
3951   if (FID.isInvalid())
3952     return;
3953   const SrcMgr::SLocEntry *Entry = &SM.getSLocEntry(FID);
3954   assert(Entry->isFile());
3955 
3956   DeclIDInFileInfo *&Info = FileDeclIDs[Entry];
3957   if (!Info)
3958     Info = new DeclIDInFileInfo();
3959 
3960   std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID);
3961   LocDeclIDsTy &Decls = Info->DeclIDs;
3962 
3963   if (Decls.empty() || Decls.back().first <= Offset) {
3964     Decls.push_back(LocDecl);
3965     return;
3966   }
3967 
3968   LocDeclIDsTy::iterator
3969     I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, compLocDecl);
3970 
3971   Decls.insert(I, LocDecl);
3972 }
3973 
3974 void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) {
3975   // FIXME: Emit a stable enum for NameKind.  0 = Identifier etc.
3976   Record.push_back(Name.getNameKind());
3977   switch (Name.getNameKind()) {
3978   case DeclarationName::Identifier:
3979     AddIdentifierRef(Name.getAsIdentifierInfo(), Record);
3980     break;
3981 
3982   case DeclarationName::ObjCZeroArgSelector:
3983   case DeclarationName::ObjCOneArgSelector:
3984   case DeclarationName::ObjCMultiArgSelector:
3985     AddSelectorRef(Name.getObjCSelector(), Record);
3986     break;
3987 
3988   case DeclarationName::CXXConstructorName:
3989   case DeclarationName::CXXDestructorName:
3990   case DeclarationName::CXXConversionFunctionName:
3991     AddTypeRef(Name.getCXXNameType(), Record);
3992     break;
3993 
3994   case DeclarationName::CXXOperatorName:
3995     Record.push_back(Name.getCXXOverloadedOperator());
3996     break;
3997 
3998   case DeclarationName::CXXLiteralOperatorName:
3999     AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record);
4000     break;
4001 
4002   case DeclarationName::CXXUsingDirective:
4003     // No extra data to emit
4004     break;
4005   }
4006 }
4007 
4008 void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
4009                                      DeclarationName Name, RecordDataImpl &Record) {
4010   switch (Name.getNameKind()) {
4011   case DeclarationName::CXXConstructorName:
4012   case DeclarationName::CXXDestructorName:
4013   case DeclarationName::CXXConversionFunctionName:
4014     AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record);
4015     break;
4016 
4017   case DeclarationName::CXXOperatorName:
4018     AddSourceLocation(
4019        SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc),
4020        Record);
4021     AddSourceLocation(
4022         SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc),
4023         Record);
4024     break;
4025 
4026   case DeclarationName::CXXLiteralOperatorName:
4027     AddSourceLocation(
4028      SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc),
4029      Record);
4030     break;
4031 
4032   case DeclarationName::Identifier:
4033   case DeclarationName::ObjCZeroArgSelector:
4034   case DeclarationName::ObjCOneArgSelector:
4035   case DeclarationName::ObjCMultiArgSelector:
4036   case DeclarationName::CXXUsingDirective:
4037     break;
4038   }
4039 }
4040 
4041 void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
4042                                        RecordDataImpl &Record) {
4043   AddDeclarationName(NameInfo.getName(), Record);
4044   AddSourceLocation(NameInfo.getLoc(), Record);
4045   AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
4046 }
4047 
4048 void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
4049                                  RecordDataImpl &Record) {
4050   AddNestedNameSpecifierLoc(Info.QualifierLoc, Record);
4051   Record.push_back(Info.NumTemplParamLists);
4052   for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i)
4053     AddTemplateParameterList(Info.TemplParamLists[i], Record);
4054 }
4055 
4056 void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
4057                                        RecordDataImpl &Record) {
4058   // Nested name specifiers usually aren't too long. I think that 8 would
4059   // typically accommodate the vast majority.
4060   SmallVector<NestedNameSpecifier *, 8> NestedNames;
4061 
4062   // Push each of the NNS's onto a stack for serialization in reverse order.
4063   while (NNS) {
4064     NestedNames.push_back(NNS);
4065     NNS = NNS->getPrefix();
4066   }
4067 
4068   Record.push_back(NestedNames.size());
4069   while(!NestedNames.empty()) {
4070     NNS = NestedNames.pop_back_val();
4071     NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
4072     Record.push_back(Kind);
4073     switch (Kind) {
4074     case NestedNameSpecifier::Identifier:
4075       AddIdentifierRef(NNS->getAsIdentifier(), Record);
4076       break;
4077 
4078     case NestedNameSpecifier::Namespace:
4079       AddDeclRef(NNS->getAsNamespace(), Record);
4080       break;
4081 
4082     case NestedNameSpecifier::NamespaceAlias:
4083       AddDeclRef(NNS->getAsNamespaceAlias(), Record);
4084       break;
4085 
4086     case NestedNameSpecifier::TypeSpec:
4087     case NestedNameSpecifier::TypeSpecWithTemplate:
4088       AddTypeRef(QualType(NNS->getAsType(), 0), Record);
4089       Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
4090       break;
4091 
4092     case NestedNameSpecifier::Global:
4093       // Don't need to write an associated value.
4094       break;
4095     }
4096   }
4097 }
4098 
4099 void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
4100                                           RecordDataImpl &Record) {
4101   // Nested name specifiers usually aren't too long. I think that 8 would
4102   // typically accommodate the vast majority.
4103   SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
4104 
4105   // Push each of the nested-name-specifiers's onto a stack for
4106   // serialization in reverse order.
4107   while (NNS) {
4108     NestedNames.push_back(NNS);
4109     NNS = NNS.getPrefix();
4110   }
4111 
4112   Record.push_back(NestedNames.size());
4113   while(!NestedNames.empty()) {
4114     NNS = NestedNames.pop_back_val();
4115     NestedNameSpecifier::SpecifierKind Kind
4116       = NNS.getNestedNameSpecifier()->getKind();
4117     Record.push_back(Kind);
4118     switch (Kind) {
4119     case NestedNameSpecifier::Identifier:
4120       AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record);
4121       AddSourceRange(NNS.getLocalSourceRange(), Record);
4122       break;
4123 
4124     case NestedNameSpecifier::Namespace:
4125       AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record);
4126       AddSourceRange(NNS.getLocalSourceRange(), Record);
4127       break;
4128 
4129     case NestedNameSpecifier::NamespaceAlias:
4130       AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record);
4131       AddSourceRange(NNS.getLocalSourceRange(), Record);
4132       break;
4133 
4134     case NestedNameSpecifier::TypeSpec:
4135     case NestedNameSpecifier::TypeSpecWithTemplate:
4136       Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
4137       AddTypeLoc(NNS.getTypeLoc(), Record);
4138       AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
4139       break;
4140 
4141     case NestedNameSpecifier::Global:
4142       AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
4143       break;
4144     }
4145   }
4146 }
4147 
4148 void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
4149   TemplateName::NameKind Kind = Name.getKind();
4150   Record.push_back(Kind);
4151   switch (Kind) {
4152   case TemplateName::Template:
4153     AddDeclRef(Name.getAsTemplateDecl(), Record);
4154     break;
4155 
4156   case TemplateName::OverloadedTemplate: {
4157     OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate();
4158     Record.push_back(OvT->size());
4159     for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end();
4160            I != E; ++I)
4161       AddDeclRef(*I, Record);
4162     break;
4163   }
4164 
4165   case TemplateName::QualifiedTemplate: {
4166     QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
4167     AddNestedNameSpecifier(QualT->getQualifier(), Record);
4168     Record.push_back(QualT->hasTemplateKeyword());
4169     AddDeclRef(QualT->getTemplateDecl(), Record);
4170     break;
4171   }
4172 
4173   case TemplateName::DependentTemplate: {
4174     DependentTemplateName *DepT = Name.getAsDependentTemplateName();
4175     AddNestedNameSpecifier(DepT->getQualifier(), Record);
4176     Record.push_back(DepT->isIdentifier());
4177     if (DepT->isIdentifier())
4178       AddIdentifierRef(DepT->getIdentifier(), Record);
4179     else
4180       Record.push_back(DepT->getOperator());
4181     break;
4182   }
4183 
4184   case TemplateName::SubstTemplateTemplateParm: {
4185     SubstTemplateTemplateParmStorage *subst
4186       = Name.getAsSubstTemplateTemplateParm();
4187     AddDeclRef(subst->getParameter(), Record);
4188     AddTemplateName(subst->getReplacement(), Record);
4189     break;
4190   }
4191 
4192   case TemplateName::SubstTemplateTemplateParmPack: {
4193     SubstTemplateTemplateParmPackStorage *SubstPack
4194       = Name.getAsSubstTemplateTemplateParmPack();
4195     AddDeclRef(SubstPack->getParameterPack(), Record);
4196     AddTemplateArgument(SubstPack->getArgumentPack(), Record);
4197     break;
4198   }
4199   }
4200 }
4201 
4202 void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
4203                                     RecordDataImpl &Record) {
4204   Record.push_back(Arg.getKind());
4205   switch (Arg.getKind()) {
4206   case TemplateArgument::Null:
4207     break;
4208   case TemplateArgument::Type:
4209     AddTypeRef(Arg.getAsType(), Record);
4210     break;
4211   case TemplateArgument::Declaration:
4212     AddDeclRef(Arg.getAsDecl(), Record);
4213     Record.push_back(Arg.isDeclForReferenceParam());
4214     break;
4215   case TemplateArgument::NullPtr:
4216     AddTypeRef(Arg.getNullPtrType(), Record);
4217     break;
4218   case TemplateArgument::Integral:
4219     AddAPSInt(Arg.getAsIntegral(), Record);
4220     AddTypeRef(Arg.getIntegralType(), Record);
4221     break;
4222   case TemplateArgument::Template:
4223     AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
4224     break;
4225   case TemplateArgument::TemplateExpansion:
4226     AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
4227     if (llvm::Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
4228       Record.push_back(*NumExpansions + 1);
4229     else
4230       Record.push_back(0);
4231     break;
4232   case TemplateArgument::Expression:
4233     AddStmt(Arg.getAsExpr());
4234     break;
4235   case TemplateArgument::Pack:
4236     Record.push_back(Arg.pack_size());
4237     for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end();
4238            I != E; ++I)
4239       AddTemplateArgument(*I, Record);
4240     break;
4241   }
4242 }
4243 
4244 void
4245 ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
4246                                     RecordDataImpl &Record) {
4247   assert(TemplateParams && "No TemplateParams!");
4248   AddSourceLocation(TemplateParams->getTemplateLoc(), Record);
4249   AddSourceLocation(TemplateParams->getLAngleLoc(), Record);
4250   AddSourceLocation(TemplateParams->getRAngleLoc(), Record);
4251   Record.push_back(TemplateParams->size());
4252   for (TemplateParameterList::const_iterator
4253          P = TemplateParams->begin(), PEnd = TemplateParams->end();
4254          P != PEnd; ++P)
4255     AddDeclRef(*P, Record);
4256 }
4257 
4258 /// \brief Emit a template argument list.
4259 void
4260 ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
4261                                    RecordDataImpl &Record) {
4262   assert(TemplateArgs && "No TemplateArgs!");
4263   Record.push_back(TemplateArgs->size());
4264   for (int i=0, e = TemplateArgs->size(); i != e; ++i)
4265     AddTemplateArgument(TemplateArgs->get(i), Record);
4266 }
4267 
4268 
4269 void
4270 ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordDataImpl &Record) {
4271   Record.push_back(Set.size());
4272   for (UnresolvedSetImpl::const_iterator
4273          I = Set.begin(), E = Set.end(); I != E; ++I) {
4274     AddDeclRef(I.getDecl(), Record);
4275     Record.push_back(I.getAccess());
4276   }
4277 }
4278 
4279 void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
4280                                     RecordDataImpl &Record) {
4281   Record.push_back(Base.isVirtual());
4282   Record.push_back(Base.isBaseOfClass());
4283   Record.push_back(Base.getAccessSpecifierAsWritten());
4284   Record.push_back(Base.getInheritConstructors());
4285   AddTypeSourceInfo(Base.getTypeSourceInfo(), Record);
4286   AddSourceRange(Base.getSourceRange(), Record);
4287   AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc()
4288                                           : SourceLocation(),
4289                     Record);
4290 }
4291 
4292 void ASTWriter::FlushCXXBaseSpecifiers() {
4293   RecordData Record;
4294   for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) {
4295     Record.clear();
4296 
4297     // Record the offset of this base-specifier set.
4298     unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
4299     if (Index == CXXBaseSpecifiersOffsets.size())
4300       CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo());
4301     else {
4302       if (Index > CXXBaseSpecifiersOffsets.size())
4303         CXXBaseSpecifiersOffsets.resize(Index + 1);
4304       CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo();
4305     }
4306 
4307     const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases,
4308                         *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd;
4309     Record.push_back(BEnd - B);
4310     for (; B != BEnd; ++B)
4311       AddCXXBaseSpecifier(*B, Record);
4312     Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record);
4313 
4314     // Flush any expressions that were written as part of the base specifiers.
4315     FlushStmts();
4316   }
4317 
4318   CXXBaseSpecifiersToWrite.clear();
4319 }
4320 
4321 void ASTWriter::AddCXXCtorInitializers(
4322                              const CXXCtorInitializer * const *CtorInitializers,
4323                              unsigned NumCtorInitializers,
4324                              RecordDataImpl &Record) {
4325   Record.push_back(NumCtorInitializers);
4326   for (unsigned i=0; i != NumCtorInitializers; ++i) {
4327     const CXXCtorInitializer *Init = CtorInitializers[i];
4328 
4329     if (Init->isBaseInitializer()) {
4330       Record.push_back(CTOR_INITIALIZER_BASE);
4331       AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
4332       Record.push_back(Init->isBaseVirtual());
4333     } else if (Init->isDelegatingInitializer()) {
4334       Record.push_back(CTOR_INITIALIZER_DELEGATING);
4335       AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
4336     } else if (Init->isMemberInitializer()){
4337       Record.push_back(CTOR_INITIALIZER_MEMBER);
4338       AddDeclRef(Init->getMember(), Record);
4339     } else {
4340       Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
4341       AddDeclRef(Init->getIndirectMember(), Record);
4342     }
4343 
4344     AddSourceLocation(Init->getMemberLocation(), Record);
4345     AddStmt(Init->getInit());
4346     AddSourceLocation(Init->getLParenLoc(), Record);
4347     AddSourceLocation(Init->getRParenLoc(), Record);
4348     Record.push_back(Init->isWritten());
4349     if (Init->isWritten()) {
4350       Record.push_back(Init->getSourceOrder());
4351     } else {
4352       Record.push_back(Init->getNumArrayIndices());
4353       for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i)
4354         AddDeclRef(Init->getArrayIndex(i), Record);
4355     }
4356   }
4357 }
4358 
4359 void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) {
4360   assert(D->DefinitionData);
4361   struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData;
4362   Record.push_back(Data.IsLambda);
4363   Record.push_back(Data.UserDeclaredConstructor);
4364   Record.push_back(Data.UserDeclaredCopyConstructor);
4365   Record.push_back(Data.UserDeclaredMoveConstructor);
4366   Record.push_back(Data.UserDeclaredCopyAssignment);
4367   Record.push_back(Data.UserDeclaredMoveAssignment);
4368   Record.push_back(Data.UserDeclaredDestructor);
4369   Record.push_back(Data.Aggregate);
4370   Record.push_back(Data.PlainOldData);
4371   Record.push_back(Data.Empty);
4372   Record.push_back(Data.Polymorphic);
4373   Record.push_back(Data.Abstract);
4374   Record.push_back(Data.IsStandardLayout);
4375   Record.push_back(Data.HasNoNonEmptyBases);
4376   Record.push_back(Data.HasPrivateFields);
4377   Record.push_back(Data.HasProtectedFields);
4378   Record.push_back(Data.HasPublicFields);
4379   Record.push_back(Data.HasMutableFields);
4380   Record.push_back(Data.HasOnlyCMembers);
4381   Record.push_back(Data.HasInClassInitializer);
4382   Record.push_back(Data.HasTrivialDefaultConstructor);
4383   Record.push_back(Data.HasConstexprNonCopyMoveConstructor);
4384   Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr);
4385   Record.push_back(Data.HasConstexprDefaultConstructor);
4386   Record.push_back(Data.HasTrivialCopyConstructor);
4387   Record.push_back(Data.HasTrivialMoveConstructor);
4388   Record.push_back(Data.HasTrivialCopyAssignment);
4389   Record.push_back(Data.HasTrivialMoveAssignment);
4390   Record.push_back(Data.HasTrivialDestructor);
4391   Record.push_back(Data.HasIrrelevantDestructor);
4392   Record.push_back(Data.HasNonLiteralTypeFieldsOrBases);
4393   Record.push_back(Data.ComputedVisibleConversions);
4394   Record.push_back(Data.UserProvidedDefaultConstructor);
4395   Record.push_back(Data.DeclaredDefaultConstructor);
4396   Record.push_back(Data.DeclaredCopyConstructor);
4397   Record.push_back(Data.DeclaredMoveConstructor);
4398   Record.push_back(Data.DeclaredCopyAssignment);
4399   Record.push_back(Data.DeclaredMoveAssignment);
4400   Record.push_back(Data.DeclaredDestructor);
4401   Record.push_back(Data.FailedImplicitMoveConstructor);
4402   Record.push_back(Data.FailedImplicitMoveAssignment);
4403   // IsLambda bit is already saved.
4404 
4405   Record.push_back(Data.NumBases);
4406   if (Data.NumBases > 0)
4407     AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases,
4408                             Record);
4409 
4410   // FIXME: Make VBases lazily computed when needed to avoid storing them.
4411   Record.push_back(Data.NumVBases);
4412   if (Data.NumVBases > 0)
4413     AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases,
4414                             Record);
4415 
4416   AddUnresolvedSet(Data.Conversions, Record);
4417   AddUnresolvedSet(Data.VisibleConversions, Record);
4418   // Data.Definition is the owning decl, no need to write it.
4419   AddDeclRef(Data.FirstFriend, Record);
4420 
4421   // Add lambda-specific data.
4422   if (Data.IsLambda) {
4423     CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData();
4424     Record.push_back(Lambda.Dependent);
4425     Record.push_back(Lambda.NumCaptures);
4426     Record.push_back(Lambda.NumExplicitCaptures);
4427     Record.push_back(Lambda.ManglingNumber);
4428     AddDeclRef(Lambda.ContextDecl, Record);
4429     AddTypeSourceInfo(Lambda.MethodTyInfo, Record);
4430     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
4431       LambdaExpr::Capture &Capture = Lambda.Captures[I];
4432       AddSourceLocation(Capture.getLocation(), Record);
4433       Record.push_back(Capture.isImplicit());
4434       Record.push_back(Capture.getCaptureKind()); // FIXME: stable!
4435       VarDecl *Var = Capture.capturesVariable()? Capture.getCapturedVar() : 0;
4436       AddDeclRef(Var, Record);
4437       AddSourceLocation(Capture.isPackExpansion()? Capture.getEllipsisLoc()
4438                                                  : SourceLocation(),
4439                         Record);
4440     }
4441   }
4442 }
4443 
4444 void ASTWriter::ReaderInitialized(ASTReader *Reader) {
4445   assert(Reader && "Cannot remove chain");
4446   assert((!Chain || Chain == Reader) && "Cannot replace chain");
4447   assert(FirstDeclID == NextDeclID &&
4448          FirstTypeID == NextTypeID &&
4449          FirstIdentID == NextIdentID &&
4450          FirstSubmoduleID == NextSubmoduleID &&
4451          FirstSelectorID == NextSelectorID &&
4452          "Setting chain after writing has started.");
4453 
4454   Chain = Reader;
4455 
4456   FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls();
4457   FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes();
4458   FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers();
4459   FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules();
4460   FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors();
4461   NextDeclID = FirstDeclID;
4462   NextTypeID = FirstTypeID;
4463   NextIdentID = FirstIdentID;
4464   NextSelectorID = FirstSelectorID;
4465   NextSubmoduleID = FirstSubmoduleID;
4466 }
4467 
4468 void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) {
4469   IdentifierIDs[II] = ID;
4470   if (II->hadMacroDefinition())
4471     DeserializedMacroNames.push_back(II);
4472 }
4473 
4474 void ASTWriter::TypeRead(TypeIdx Idx, QualType T) {
4475   // Always take the highest-numbered type index. This copes with an interesting
4476   // case for chained AST writing where we schedule writing the type and then,
4477   // later, deserialize the type from another AST. In this case, we want to
4478   // keep the higher-numbered entry so that we can properly write it out to
4479   // the AST file.
4480   TypeIdx &StoredIdx = TypeIdxs[T];
4481   if (Idx.getIndex() >= StoredIdx.getIndex())
4482     StoredIdx = Idx;
4483 }
4484 
4485 void ASTWriter::SelectorRead(SelectorID ID, Selector S) {
4486   SelectorIDs[S] = ID;
4487 }
4488 
4489 void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID,
4490                                     MacroDefinition *MD) {
4491   assert(MacroDefinitions.find(MD) == MacroDefinitions.end());
4492   MacroDefinitions[MD] = ID;
4493 }
4494 
4495 void ASTWriter::MacroVisible(IdentifierInfo *II) {
4496   DeserializedMacroNames.push_back(II);
4497 }
4498 
4499 void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) {
4500   assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end());
4501   SubmoduleIDs[Mod] = ID;
4502 }
4503 
4504 void ASTWriter::CompletedTagDefinition(const TagDecl *D) {
4505   assert(D->isCompleteDefinition());
4506   assert(!WritingAST && "Already writing the AST!");
4507   if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
4508     // We are interested when a PCH decl is modified.
4509     if (RD->isFromASTFile()) {
4510       // A forward reference was mutated into a definition. Rewrite it.
4511       // FIXME: This happens during template instantiation, should we
4512       // have created a new definition decl instead ?
4513       RewriteDecl(RD);
4514     }
4515   }
4516 }
4517 void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) {
4518   assert(!WritingAST && "Already writing the AST!");
4519 
4520   // TU and namespaces are handled elsewhere.
4521   if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC))
4522     return;
4523 
4524   if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile()))
4525     return; // Not a source decl added to a DeclContext from PCH.
4526 
4527   AddUpdatedDeclContext(DC);
4528   UpdatingVisibleDecls.push_back(D);
4529 }
4530 
4531 void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) {
4532   assert(!WritingAST && "Already writing the AST!");
4533   assert(D->isImplicit());
4534   if (!(!D->isFromASTFile() && RD->isFromASTFile()))
4535     return; // Not a source member added to a class from PCH.
4536   if (!isa<CXXMethodDecl>(D))
4537     return; // We are interested in lazily declared implicit methods.
4538 
4539   // A decl coming from PCH was modified.
4540   assert(RD->isCompleteDefinition());
4541   UpdateRecord &Record = DeclUpdates[RD];
4542   Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER);
4543   Record.push_back(reinterpret_cast<uint64_t>(D));
4544 }
4545 
4546 void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
4547                                      const ClassTemplateSpecializationDecl *D) {
4548   // The specializations set is kept in the canonical template.
4549   assert(!WritingAST && "Already writing the AST!");
4550   TD = TD->getCanonicalDecl();
4551   if (!(!D->isFromASTFile() && TD->isFromASTFile()))
4552     return; // Not a source specialization added to a template from PCH.
4553 
4554   UpdateRecord &Record = DeclUpdates[TD];
4555   Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
4556   Record.push_back(reinterpret_cast<uint64_t>(D));
4557 }
4558 
4559 void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
4560                                                const FunctionDecl *D) {
4561   // The specializations set is kept in the canonical template.
4562   assert(!WritingAST && "Already writing the AST!");
4563   TD = TD->getCanonicalDecl();
4564   if (!(!D->isFromASTFile() && TD->isFromASTFile()))
4565     return; // Not a source specialization added to a template from PCH.
4566 
4567   UpdateRecord &Record = DeclUpdates[TD];
4568   Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
4569   Record.push_back(reinterpret_cast<uint64_t>(D));
4570 }
4571 
4572 void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) {
4573   assert(!WritingAST && "Already writing the AST!");
4574   if (!D->isFromASTFile())
4575     return; // Declaration not imported from PCH.
4576 
4577   // Implicit decl from a PCH was defined.
4578   // FIXME: Should implicit definition be a separate FunctionDecl?
4579   RewriteDecl(D);
4580 }
4581 
4582 void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) {
4583   assert(!WritingAST && "Already writing the AST!");
4584   if (!D->isFromASTFile())
4585     return;
4586 
4587   // Since the actual instantiation is delayed, this really means that we need
4588   // to update the instantiation location.
4589   UpdateRecord &Record = DeclUpdates[D];
4590   Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER);
4591   AddSourceLocation(
4592       D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record);
4593 }
4594 
4595 void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
4596                                              const ObjCInterfaceDecl *IFD) {
4597   assert(!WritingAST && "Already writing the AST!");
4598   if (!IFD->isFromASTFile())
4599     return; // Declaration not imported from PCH.
4600 
4601   assert(IFD->getDefinition() && "Category on a class without a definition?");
4602   ObjCClassesWithCategories.insert(
4603     const_cast<ObjCInterfaceDecl *>(IFD->getDefinition()));
4604 }
4605 
4606 
4607 void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop,
4608                                           const ObjCPropertyDecl *OrigProp,
4609                                           const ObjCCategoryDecl *ClassExt) {
4610   const ObjCInterfaceDecl *D = ClassExt->getClassInterface();
4611   if (!D)
4612     return;
4613 
4614   assert(!WritingAST && "Already writing the AST!");
4615   if (!D->isFromASTFile())
4616     return; // Declaration not imported from PCH.
4617 
4618   RewriteDecl(D);
4619 }
4620