contrib/llvm/tools/clang/lib/Serialization/ASTWriter.cpp

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