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