1212795Sdim//===--- ASTWriter.cpp - AST File Writer ----------------------------------===// 2212795Sdim// 3212795Sdim// The LLVM Compiler Infrastructure 4212795Sdim// 5212795Sdim// This file is distributed under the University of Illinois Open Source 6212795Sdim// License. See LICENSE.TXT for details. 7212795Sdim// 8212795Sdim//===----------------------------------------------------------------------===// 9212795Sdim// 10212795Sdim// This file defines the ASTWriter class, which writes AST files. 11212795Sdim// 12212795Sdim//===----------------------------------------------------------------------===// 13212795Sdim 14212795Sdim#include "clang/Serialization/ASTWriter.h" 15212795Sdim#include "ASTCommon.h" 16212795Sdim#include "clang/AST/ASTContext.h" 17212795Sdim#include "clang/AST/Decl.h" 18212795Sdim#include "clang/AST/DeclContextInternals.h" 19252723Sdim#include "clang/AST/DeclFriend.h" 20212795Sdim#include "clang/AST/DeclTemplate.h" 21212795Sdim#include "clang/AST/Expr.h" 22212795Sdim#include "clang/AST/ExprCXX.h" 23212795Sdim#include "clang/AST/Type.h" 24212795Sdim#include "clang/AST/TypeLocVisitor.h" 25212795Sdim#include "clang/Basic/FileManager.h" 26218893Sdim#include "clang/Basic/FileSystemStatCache.h" 27212795Sdim#include "clang/Basic/OnDiskHashTable.h" 28212795Sdim#include "clang/Basic/SourceManager.h" 29212795Sdim#include "clang/Basic/SourceManagerInternals.h" 30212795Sdim#include "clang/Basic/TargetInfo.h" 31245431Sdim#include "clang/Basic/TargetOptions.h" 32212795Sdim#include "clang/Basic/Version.h" 33221345Sdim#include "clang/Basic/VersionTuple.h" 34252723Sdim#include "clang/Lex/HeaderSearch.h" 35252723Sdim#include "clang/Lex/HeaderSearchOptions.h" 36252723Sdim#include "clang/Lex/MacroInfo.h" 37252723Sdim#include "clang/Lex/PreprocessingRecord.h" 38252723Sdim#include "clang/Lex/Preprocessor.h" 39252723Sdim#include "clang/Lex/PreprocessorOptions.h" 40252723Sdim#include "clang/Sema/IdentifierResolver.h" 41252723Sdim#include "clang/Sema/Sema.h" 42252723Sdim#include "clang/Serialization/ASTReader.h" 43212795Sdim#include "llvm/ADT/APFloat.h" 44212795Sdim#include "llvm/ADT/APInt.h" 45252723Sdim#include "llvm/ADT/Hashing.h" 46212795Sdim#include "llvm/ADT/StringExtras.h" 47212795Sdim#include "llvm/Bitcode/BitstreamWriter.h" 48218893Sdim#include "llvm/Support/FileSystem.h" 49212795Sdim#include "llvm/Support/MemoryBuffer.h" 50218893Sdim#include "llvm/Support/Path.h" 51226890Sdim#include <algorithm> 52212795Sdim#include <cstdio> 53218893Sdim#include <string.h> 54226890Sdim#include <utility> 55212795Sdimusing namespace clang; 56212795Sdimusing namespace clang::serialization; 57212795Sdim 58212795Sdimtemplate <typename T, typename Allocator> 59226890Sdimstatic StringRef data(const std::vector<T, Allocator> &v) { 60226890Sdim if (v.empty()) return StringRef(); 61226890Sdim return StringRef(reinterpret_cast<const char*>(&v[0]), 62221345Sdim sizeof(T) * v.size()); 63212795Sdim} 64221345Sdim 65221345Sdimtemplate <typename T> 66226890Sdimstatic StringRef data(const SmallVectorImpl<T> &v) { 67226890Sdim return StringRef(reinterpret_cast<const char*>(v.data()), 68221345Sdim sizeof(T) * v.size()); 69212795Sdim} 70212795Sdim 71212795Sdim//===----------------------------------------------------------------------===// 72212795Sdim// Type serialization 73212795Sdim//===----------------------------------------------------------------------===// 74212795Sdim 75212795Sdimnamespace { 76212795Sdim class ASTTypeWriter { 77212795Sdim ASTWriter &Writer; 78218893Sdim ASTWriter::RecordDataImpl &Record; 79212795Sdim 80212795Sdim public: 81212795Sdim /// \brief Type code that corresponds to the record generated. 82212795Sdim TypeCode Code; 83212795Sdim 84218893Sdim ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 85212795Sdim : Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { } 86212795Sdim 87212795Sdim void VisitArrayType(const ArrayType *T); 88212795Sdim void VisitFunctionType(const FunctionType *T); 89212795Sdim void VisitTagType(const TagType *T); 90212795Sdim 91212795Sdim#define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); 92212795Sdim#define ABSTRACT_TYPE(Class, Base) 93212795Sdim#include "clang/AST/TypeNodes.def" 94212795Sdim }; 95212795Sdim} 96212795Sdim 97212795Sdimvoid ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { 98226890Sdim llvm_unreachable("Built-in types are never serialized"); 99212795Sdim} 100212795Sdim 101212795Sdimvoid ASTTypeWriter::VisitComplexType(const ComplexType *T) { 102212795Sdim Writer.AddTypeRef(T->getElementType(), Record); 103212795Sdim Code = TYPE_COMPLEX; 104212795Sdim} 105212795Sdim 106212795Sdimvoid ASTTypeWriter::VisitPointerType(const PointerType *T) { 107212795Sdim Writer.AddTypeRef(T->getPointeeType(), Record); 108212795Sdim Code = TYPE_POINTER; 109212795Sdim} 110212795Sdim 111263509Sdimvoid ASTTypeWriter::VisitDecayedType(const DecayedType *T) { 112263509Sdim Writer.AddTypeRef(T->getOriginalType(), Record); 113263509Sdim Code = TYPE_DECAYED; 114263509Sdim} 115263509Sdim 116212795Sdimvoid ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { 117212795Sdim Writer.AddTypeRef(T->getPointeeType(), Record); 118212795Sdim Code = TYPE_BLOCK_POINTER; 119212795Sdim} 120212795Sdim 121212795Sdimvoid ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { 122221345Sdim Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); 123221345Sdim Record.push_back(T->isSpelledAsLValue()); 124212795Sdim Code = TYPE_LVALUE_REFERENCE; 125212795Sdim} 126212795Sdim 127212795Sdimvoid ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { 128221345Sdim Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record); 129212795Sdim Code = TYPE_RVALUE_REFERENCE; 130212795Sdim} 131212795Sdim 132212795Sdimvoid ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { 133212795Sdim Writer.AddTypeRef(T->getPointeeType(), Record); 134212795Sdim Writer.AddTypeRef(QualType(T->getClass(), 0), Record); 135212795Sdim Code = TYPE_MEMBER_POINTER; 136212795Sdim} 137212795Sdim 138212795Sdimvoid ASTTypeWriter::VisitArrayType(const ArrayType *T) { 139212795Sdim Writer.AddTypeRef(T->getElementType(), Record); 140212795Sdim Record.push_back(T->getSizeModifier()); // FIXME: stable values 141212795Sdim Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values 142212795Sdim} 143212795Sdim 144212795Sdimvoid ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { 145212795Sdim VisitArrayType(T); 146212795Sdim Writer.AddAPInt(T->getSize(), Record); 147212795Sdim Code = TYPE_CONSTANT_ARRAY; 148212795Sdim} 149212795Sdim 150212795Sdimvoid ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 151212795Sdim VisitArrayType(T); 152212795Sdim Code = TYPE_INCOMPLETE_ARRAY; 153212795Sdim} 154212795Sdim 155212795Sdimvoid ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { 156212795Sdim VisitArrayType(T); 157212795Sdim Writer.AddSourceLocation(T->getLBracketLoc(), Record); 158212795Sdim Writer.AddSourceLocation(T->getRBracketLoc(), Record); 159212795Sdim Writer.AddStmt(T->getSizeExpr()); 160212795Sdim Code = TYPE_VARIABLE_ARRAY; 161212795Sdim} 162212795Sdim 163212795Sdimvoid ASTTypeWriter::VisitVectorType(const VectorType *T) { 164212795Sdim Writer.AddTypeRef(T->getElementType(), Record); 165212795Sdim Record.push_back(T->getNumElements()); 166218893Sdim Record.push_back(T->getVectorKind()); 167212795Sdim Code = TYPE_VECTOR; 168212795Sdim} 169212795Sdim 170212795Sdimvoid ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { 171212795Sdim VisitVectorType(T); 172212795Sdim Code = TYPE_EXT_VECTOR; 173212795Sdim} 174212795Sdim 175212795Sdimvoid ASTTypeWriter::VisitFunctionType(const FunctionType *T) { 176212795Sdim Writer.AddTypeRef(T->getResultType(), Record); 177212795Sdim FunctionType::ExtInfo C = T->getExtInfo(); 178212795Sdim Record.push_back(C.getNoReturn()); 179221345Sdim Record.push_back(C.getHasRegParm()); 180212795Sdim Record.push_back(C.getRegParm()); 181212795Sdim // FIXME: need to stabilize encoding of calling convention... 182212795Sdim Record.push_back(C.getCC()); 183224145Sdim Record.push_back(C.getProducesResult()); 184212795Sdim} 185212795Sdim 186212795Sdimvoid ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 187212795Sdim VisitFunctionType(T); 188212795Sdim Code = TYPE_FUNCTION_NO_PROTO; 189212795Sdim} 190212795Sdim 191212795Sdimvoid ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { 192212795Sdim VisitFunctionType(T); 193212795Sdim Record.push_back(T->getNumArgs()); 194212795Sdim for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I) 195212795Sdim Writer.AddTypeRef(T->getArgType(I), Record); 196212795Sdim Record.push_back(T->isVariadic()); 197235633Sdim Record.push_back(T->hasTrailingReturn()); 198212795Sdim Record.push_back(T->getTypeQuals()); 199218893Sdim Record.push_back(static_cast<unsigned>(T->getRefQualifier())); 200221345Sdim Record.push_back(T->getExceptionSpecType()); 201221345Sdim if (T->getExceptionSpecType() == EST_Dynamic) { 202221345Sdim Record.push_back(T->getNumExceptions()); 203221345Sdim for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) 204221345Sdim Writer.AddTypeRef(T->getExceptionType(I), Record); 205221345Sdim } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { 206221345Sdim Writer.AddStmt(T->getNoexceptExpr()); 207236144Sdim } else if (T->getExceptionSpecType() == EST_Uninstantiated) { 208236144Sdim Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); 209236144Sdim Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record); 210245431Sdim } else if (T->getExceptionSpecType() == EST_Unevaluated) { 211245431Sdim Writer.AddDeclRef(T->getExceptionSpecDecl(), Record); 212221345Sdim } 213212795Sdim Code = TYPE_FUNCTION_PROTO; 214212795Sdim} 215212795Sdim 216212795Sdimvoid ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { 217212795Sdim Writer.AddDeclRef(T->getDecl(), Record); 218212795Sdim Code = TYPE_UNRESOLVED_USING; 219212795Sdim} 220212795Sdim 221212795Sdimvoid ASTTypeWriter::VisitTypedefType(const TypedefType *T) { 222212795Sdim Writer.AddDeclRef(T->getDecl(), Record); 223212795Sdim assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); 224212795Sdim Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record); 225212795Sdim Code = TYPE_TYPEDEF; 226212795Sdim} 227212795Sdim 228212795Sdimvoid ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { 229212795Sdim Writer.AddStmt(T->getUnderlyingExpr()); 230212795Sdim Code = TYPE_TYPEOF_EXPR; 231212795Sdim} 232212795Sdim 233212795Sdimvoid ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { 234212795Sdim Writer.AddTypeRef(T->getUnderlyingType(), Record); 235212795Sdim Code = TYPE_TYPEOF; 236212795Sdim} 237212795Sdim 238212795Sdimvoid ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { 239235633Sdim Writer.AddTypeRef(T->getUnderlyingType(), Record); 240212795Sdim Writer.AddStmt(T->getUnderlyingExpr()); 241212795Sdim Code = TYPE_DECLTYPE; 242212795Sdim} 243212795Sdim 244223017Sdimvoid ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) { 245223017Sdim Writer.AddTypeRef(T->getBaseType(), Record); 246223017Sdim Writer.AddTypeRef(T->getUnderlyingType(), Record); 247223017Sdim Record.push_back(T->getUTTKind()); 248223017Sdim Code = TYPE_UNARY_TRANSFORM; 249223017Sdim} 250223017Sdim 251218893Sdimvoid ASTTypeWriter::VisitAutoType(const AutoType *T) { 252218893Sdim Writer.AddTypeRef(T->getDeducedType(), Record); 253252723Sdim Record.push_back(T->isDecltypeAuto()); 254252723Sdim if (T->getDeducedType().isNull()) 255252723Sdim Record.push_back(T->isDependentType()); 256218893Sdim Code = TYPE_AUTO; 257218893Sdim} 258218893Sdim 259212795Sdimvoid ASTTypeWriter::VisitTagType(const TagType *T) { 260212795Sdim Record.push_back(T->isDependentType()); 261235633Sdim Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); 262212795Sdim assert(!T->isBeingDefined() && 263212795Sdim "Cannot serialize in the middle of a type definition"); 264212795Sdim} 265212795Sdim 266212795Sdimvoid ASTTypeWriter::VisitRecordType(const RecordType *T) { 267212795Sdim VisitTagType(T); 268212795Sdim Code = TYPE_RECORD; 269212795Sdim} 270212795Sdim 271212795Sdimvoid ASTTypeWriter::VisitEnumType(const EnumType *T) { 272212795Sdim VisitTagType(T); 273212795Sdim Code = TYPE_ENUM; 274212795Sdim} 275212795Sdim 276218893Sdimvoid ASTTypeWriter::VisitAttributedType(const AttributedType *T) { 277218893Sdim Writer.AddTypeRef(T->getModifiedType(), Record); 278218893Sdim Writer.AddTypeRef(T->getEquivalentType(), Record); 279218893Sdim Record.push_back(T->getAttrKind()); 280218893Sdim Code = TYPE_ATTRIBUTED; 281218893Sdim} 282218893Sdim 283212795Sdimvoid 284212795SdimASTTypeWriter::VisitSubstTemplateTypeParmType( 285212795Sdim const SubstTemplateTypeParmType *T) { 286212795Sdim Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 287212795Sdim Writer.AddTypeRef(T->getReplacementType(), Record); 288212795Sdim Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; 289212795Sdim} 290212795Sdim 291212795Sdimvoid 292218893SdimASTTypeWriter::VisitSubstTemplateTypeParmPackType( 293218893Sdim const SubstTemplateTypeParmPackType *T) { 294218893Sdim Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record); 295218893Sdim Writer.AddTemplateArgument(T->getArgumentPack(), Record); 296218893Sdim Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; 297218893Sdim} 298218893Sdim 299218893Sdimvoid 300212795SdimASTTypeWriter::VisitTemplateSpecializationType( 301212795Sdim const TemplateSpecializationType *T) { 302212795Sdim Record.push_back(T->isDependentType()); 303212795Sdim Writer.AddTemplateName(T->getTemplateName(), Record); 304212795Sdim Record.push_back(T->getNumArgs()); 305212795Sdim for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end(); 306212795Sdim ArgI != ArgE; ++ArgI) 307212795Sdim Writer.AddTemplateArgument(*ArgI, Record); 308223017Sdim Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() : 309223017Sdim T->isCanonicalUnqualified() ? QualType() 310212795Sdim : T->getCanonicalTypeInternal(), 311212795Sdim Record); 312212795Sdim Code = TYPE_TEMPLATE_SPECIALIZATION; 313212795Sdim} 314212795Sdim 315212795Sdimvoid 316212795SdimASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { 317212795Sdim VisitArrayType(T); 318212795Sdim Writer.AddStmt(T->getSizeExpr()); 319212795Sdim Writer.AddSourceRange(T->getBracketsRange(), Record); 320212795Sdim Code = TYPE_DEPENDENT_SIZED_ARRAY; 321212795Sdim} 322212795Sdim 323212795Sdimvoid 324212795SdimASTTypeWriter::VisitDependentSizedExtVectorType( 325212795Sdim const DependentSizedExtVectorType *T) { 326212795Sdim // FIXME: Serialize this type (C++ only) 327226890Sdim llvm_unreachable("Cannot serialize dependent sized extended vector types"); 328212795Sdim} 329212795Sdim 330212795Sdimvoid 331212795SdimASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 332212795Sdim Record.push_back(T->getDepth()); 333212795Sdim Record.push_back(T->getIndex()); 334212795Sdim Record.push_back(T->isParameterPack()); 335221345Sdim Writer.AddDeclRef(T->getDecl(), Record); 336212795Sdim Code = TYPE_TEMPLATE_TYPE_PARM; 337212795Sdim} 338212795Sdim 339212795Sdimvoid 340212795SdimASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { 341212795Sdim Record.push_back(T->getKeyword()); 342212795Sdim Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 343212795Sdim Writer.AddIdentifierRef(T->getIdentifier(), Record); 344212795Sdim Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType() 345212795Sdim : T->getCanonicalTypeInternal(), 346212795Sdim Record); 347212795Sdim Code = TYPE_DEPENDENT_NAME; 348212795Sdim} 349212795Sdim 350212795Sdimvoid 351212795SdimASTTypeWriter::VisitDependentTemplateSpecializationType( 352212795Sdim const DependentTemplateSpecializationType *T) { 353212795Sdim Record.push_back(T->getKeyword()); 354212795Sdim Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 355212795Sdim Writer.AddIdentifierRef(T->getIdentifier(), Record); 356212795Sdim Record.push_back(T->getNumArgs()); 357212795Sdim for (DependentTemplateSpecializationType::iterator 358212795Sdim I = T->begin(), E = T->end(); I != E; ++I) 359212795Sdim Writer.AddTemplateArgument(*I, Record); 360212795Sdim Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; 361212795Sdim} 362212795Sdim 363218893Sdimvoid ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { 364218893Sdim Writer.AddTypeRef(T->getPattern(), Record); 365252723Sdim if (Optional<unsigned> NumExpansions = T->getNumExpansions()) 366218893Sdim Record.push_back(*NumExpansions + 1); 367218893Sdim else 368218893Sdim Record.push_back(0); 369218893Sdim Code = TYPE_PACK_EXPANSION; 370218893Sdim} 371218893Sdim 372218893Sdimvoid ASTTypeWriter::VisitParenType(const ParenType *T) { 373218893Sdim Writer.AddTypeRef(T->getInnerType(), Record); 374218893Sdim Code = TYPE_PAREN; 375218893Sdim} 376218893Sdim 377212795Sdimvoid ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { 378212795Sdim Record.push_back(T->getKeyword()); 379212795Sdim Writer.AddNestedNameSpecifier(T->getQualifier(), Record); 380212795Sdim Writer.AddTypeRef(T->getNamedType(), Record); 381212795Sdim Code = TYPE_ELABORATED; 382212795Sdim} 383212795Sdim 384212795Sdimvoid ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { 385235633Sdim Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); 386212795Sdim Writer.AddTypeRef(T->getInjectedSpecializationType(), Record); 387212795Sdim Code = TYPE_INJECTED_CLASS_NAME; 388212795Sdim} 389212795Sdim 390212795Sdimvoid ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 391235633Sdim Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), Record); 392212795Sdim Code = TYPE_OBJC_INTERFACE; 393212795Sdim} 394212795Sdim 395212795Sdimvoid ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { 396212795Sdim Writer.AddTypeRef(T->getBaseType(), Record); 397212795Sdim Record.push_back(T->getNumProtocols()); 398212795Sdim for (ObjCObjectType::qual_iterator I = T->qual_begin(), 399212795Sdim E = T->qual_end(); I != E; ++I) 400212795Sdim Writer.AddDeclRef(*I, Record); 401212795Sdim Code = TYPE_OBJC_OBJECT; 402212795Sdim} 403212795Sdim 404212795Sdimvoid 405212795SdimASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 406212795Sdim Writer.AddTypeRef(T->getPointeeType(), Record); 407212795Sdim Code = TYPE_OBJC_OBJECT_POINTER; 408212795Sdim} 409212795Sdim 410226890Sdimvoid 411226890SdimASTTypeWriter::VisitAtomicType(const AtomicType *T) { 412226890Sdim Writer.AddTypeRef(T->getValueType(), Record); 413226890Sdim Code = TYPE_ATOMIC; 414226890Sdim} 415226890Sdim 416212795Sdimnamespace { 417212795Sdim 418212795Sdimclass TypeLocWriter : public TypeLocVisitor<TypeLocWriter> { 419212795Sdim ASTWriter &Writer; 420218893Sdim ASTWriter::RecordDataImpl &Record; 421212795Sdim 422212795Sdimpublic: 423218893Sdim TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 424212795Sdim : Writer(Writer), Record(Record) { } 425212795Sdim 426212795Sdim#define ABSTRACT_TYPELOC(CLASS, PARENT) 427212795Sdim#define TYPELOC(CLASS, PARENT) \ 428212795Sdim void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 429212795Sdim#include "clang/AST/TypeLocNodes.def" 430212795Sdim 431212795Sdim void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); 432212795Sdim void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); 433212795Sdim}; 434212795Sdim 435212795Sdim} 436212795Sdim 437212795Sdimvoid TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 438212795Sdim // nothing to do 439212795Sdim} 440212795Sdimvoid TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 441212795Sdim Writer.AddSourceLocation(TL.getBuiltinLoc(), Record); 442212795Sdim if (TL.needsExtraLocalData()) { 443212795Sdim Record.push_back(TL.getWrittenTypeSpec()); 444212795Sdim Record.push_back(TL.getWrittenSignSpec()); 445212795Sdim Record.push_back(TL.getWrittenWidthSpec()); 446212795Sdim Record.push_back(TL.hasModeAttr()); 447212795Sdim } 448212795Sdim} 449212795Sdimvoid TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { 450212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 451212795Sdim} 452212795Sdimvoid TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { 453212795Sdim Writer.AddSourceLocation(TL.getStarLoc(), Record); 454212795Sdim} 455263509Sdimvoid TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) { 456263509Sdim // nothing to do 457263509Sdim} 458212795Sdimvoid TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 459212795Sdim Writer.AddSourceLocation(TL.getCaretLoc(), Record); 460212795Sdim} 461212795Sdimvoid TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 462212795Sdim Writer.AddSourceLocation(TL.getAmpLoc(), Record); 463212795Sdim} 464212795Sdimvoid TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 465212795Sdim Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record); 466212795Sdim} 467212795Sdimvoid TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 468212795Sdim Writer.AddSourceLocation(TL.getStarLoc(), Record); 469221345Sdim Writer.AddTypeSourceInfo(TL.getClassTInfo(), Record); 470212795Sdim} 471212795Sdimvoid TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { 472212795Sdim Writer.AddSourceLocation(TL.getLBracketLoc(), Record); 473212795Sdim Writer.AddSourceLocation(TL.getRBracketLoc(), Record); 474212795Sdim Record.push_back(TL.getSizeExpr() ? 1 : 0); 475212795Sdim if (TL.getSizeExpr()) 476212795Sdim Writer.AddStmt(TL.getSizeExpr()); 477212795Sdim} 478212795Sdimvoid TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 479212795Sdim VisitArrayTypeLoc(TL); 480212795Sdim} 481212795Sdimvoid TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 482212795Sdim VisitArrayTypeLoc(TL); 483212795Sdim} 484212795Sdimvoid TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 485212795Sdim VisitArrayTypeLoc(TL); 486212795Sdim} 487212795Sdimvoid TypeLocWriter::VisitDependentSizedArrayTypeLoc( 488212795Sdim DependentSizedArrayTypeLoc TL) { 489212795Sdim VisitArrayTypeLoc(TL); 490212795Sdim} 491212795Sdimvoid TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( 492212795Sdim DependentSizedExtVectorTypeLoc TL) { 493212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 494212795Sdim} 495212795Sdimvoid TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { 496212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 497212795Sdim} 498212795Sdimvoid TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 499212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 500212795Sdim} 501212795Sdimvoid TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 502221345Sdim Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record); 503245431Sdim Writer.AddSourceLocation(TL.getLParenLoc(), Record); 504245431Sdim Writer.AddSourceLocation(TL.getRParenLoc(), Record); 505221345Sdim Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record); 506212795Sdim for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 507212795Sdim Writer.AddDeclRef(TL.getArg(i), Record); 508212795Sdim} 509212795Sdimvoid TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 510212795Sdim VisitFunctionTypeLoc(TL); 511212795Sdim} 512212795Sdimvoid TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 513212795Sdim VisitFunctionTypeLoc(TL); 514212795Sdim} 515212795Sdimvoid TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 516212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 517212795Sdim} 518212795Sdimvoid TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 519212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 520212795Sdim} 521212795Sdimvoid TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 522212795Sdim Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 523212795Sdim Writer.AddSourceLocation(TL.getLParenLoc(), Record); 524212795Sdim Writer.AddSourceLocation(TL.getRParenLoc(), Record); 525212795Sdim} 526212795Sdimvoid TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 527212795Sdim Writer.AddSourceLocation(TL.getTypeofLoc(), Record); 528212795Sdim Writer.AddSourceLocation(TL.getLParenLoc(), Record); 529212795Sdim Writer.AddSourceLocation(TL.getRParenLoc(), Record); 530212795Sdim Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); 531212795Sdim} 532212795Sdimvoid TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 533212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 534212795Sdim} 535223017Sdimvoid TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 536223017Sdim Writer.AddSourceLocation(TL.getKWLoc(), Record); 537223017Sdim Writer.AddSourceLocation(TL.getLParenLoc(), Record); 538223017Sdim Writer.AddSourceLocation(TL.getRParenLoc(), Record); 539223017Sdim Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record); 540223017Sdim} 541218893Sdimvoid TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { 542218893Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 543218893Sdim} 544212795Sdimvoid TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { 545212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 546212795Sdim} 547212795Sdimvoid TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { 548212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 549212795Sdim} 550218893Sdimvoid TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 551218893Sdim Writer.AddSourceLocation(TL.getAttrNameLoc(), Record); 552218893Sdim if (TL.hasAttrOperand()) { 553218893Sdim SourceRange range = TL.getAttrOperandParensRange(); 554218893Sdim Writer.AddSourceLocation(range.getBegin(), Record); 555218893Sdim Writer.AddSourceLocation(range.getEnd(), Record); 556218893Sdim } 557218893Sdim if (TL.hasAttrExprOperand()) { 558218893Sdim Expr *operand = TL.getAttrExprOperand(); 559218893Sdim Record.push_back(operand ? 1 : 0); 560218893Sdim if (operand) Writer.AddStmt(operand); 561218893Sdim } else if (TL.hasAttrEnumOperand()) { 562218893Sdim Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), Record); 563218893Sdim } 564218893Sdim} 565212795Sdimvoid TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 566212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 567212795Sdim} 568212795Sdimvoid TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( 569212795Sdim SubstTemplateTypeParmTypeLoc TL) { 570212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 571212795Sdim} 572218893Sdimvoid TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( 573218893Sdim SubstTemplateTypeParmPackTypeLoc TL) { 574218893Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 575218893Sdim} 576212795Sdimvoid TypeLocWriter::VisitTemplateSpecializationTypeLoc( 577212795Sdim TemplateSpecializationTypeLoc TL) { 578235633Sdim Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); 579212795Sdim Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); 580212795Sdim Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 581212795Sdim Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 582212795Sdim for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 583212795Sdim Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), 584212795Sdim TL.getArgLoc(i).getLocInfo(), Record); 585212795Sdim} 586218893Sdimvoid TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { 587218893Sdim Writer.AddSourceLocation(TL.getLParenLoc(), Record); 588218893Sdim Writer.AddSourceLocation(TL.getRParenLoc(), Record); 589218893Sdim} 590212795Sdimvoid TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 591235633Sdim Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); 592221345Sdim Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 593212795Sdim} 594212795Sdimvoid TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 595212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 596212795Sdim} 597212795Sdimvoid TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 598235633Sdim Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); 599221345Sdim Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 600212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 601212795Sdim} 602212795Sdimvoid TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( 603212795Sdim DependentTemplateSpecializationTypeLoc TL) { 604235633Sdim Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record); 605221345Sdim Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record); 606235633Sdim Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record); 607235633Sdim Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record); 608212795Sdim Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 609212795Sdim Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 610212795Sdim for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 611212795Sdim Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), 612212795Sdim TL.getArgLoc(I).getLocInfo(), Record); 613212795Sdim} 614218893Sdimvoid TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 615218893Sdim Writer.AddSourceLocation(TL.getEllipsisLoc(), Record); 616218893Sdim} 617212795Sdimvoid TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 618212795Sdim Writer.AddSourceLocation(TL.getNameLoc(), Record); 619212795Sdim} 620212795Sdimvoid TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 621212795Sdim Record.push_back(TL.hasBaseTypeAsWritten()); 622212795Sdim Writer.AddSourceLocation(TL.getLAngleLoc(), Record); 623212795Sdim Writer.AddSourceLocation(TL.getRAngleLoc(), Record); 624212795Sdim for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 625212795Sdim Writer.AddSourceLocation(TL.getProtocolLoc(i), Record); 626212795Sdim} 627212795Sdimvoid TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 628212795Sdim Writer.AddSourceLocation(TL.getStarLoc(), Record); 629212795Sdim} 630226890Sdimvoid TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 631226890Sdim Writer.AddSourceLocation(TL.getKWLoc(), Record); 632226890Sdim Writer.AddSourceLocation(TL.getLParenLoc(), Record); 633226890Sdim Writer.AddSourceLocation(TL.getRParenLoc(), Record); 634226890Sdim} 635212795Sdim 636212795Sdim//===----------------------------------------------------------------------===// 637212795Sdim// ASTWriter Implementation 638212795Sdim//===----------------------------------------------------------------------===// 639212795Sdim 640212795Sdimstatic void EmitBlockID(unsigned ID, const char *Name, 641212795Sdim llvm::BitstreamWriter &Stream, 642218893Sdim ASTWriter::RecordDataImpl &Record) { 643212795Sdim Record.clear(); 644212795Sdim Record.push_back(ID); 645212795Sdim Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); 646212795Sdim 647212795Sdim // Emit the block name if present. 648212795Sdim if (Name == 0 || Name[0] == 0) return; 649212795Sdim Record.clear(); 650212795Sdim while (*Name) 651212795Sdim Record.push_back(*Name++); 652212795Sdim Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); 653212795Sdim} 654212795Sdim 655212795Sdimstatic void EmitRecordID(unsigned ID, const char *Name, 656212795Sdim llvm::BitstreamWriter &Stream, 657218893Sdim ASTWriter::RecordDataImpl &Record) { 658212795Sdim Record.clear(); 659212795Sdim Record.push_back(ID); 660212795Sdim while (*Name) 661212795Sdim Record.push_back(*Name++); 662212795Sdim Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); 663212795Sdim} 664212795Sdim 665212795Sdimstatic void AddStmtsExprs(llvm::BitstreamWriter &Stream, 666218893Sdim ASTWriter::RecordDataImpl &Record) { 667212795Sdim#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 668212795Sdim RECORD(STMT_STOP); 669212795Sdim RECORD(STMT_NULL_PTR); 670212795Sdim RECORD(STMT_NULL); 671212795Sdim RECORD(STMT_COMPOUND); 672212795Sdim RECORD(STMT_CASE); 673212795Sdim RECORD(STMT_DEFAULT); 674212795Sdim RECORD(STMT_LABEL); 675235633Sdim RECORD(STMT_ATTRIBUTED); 676212795Sdim RECORD(STMT_IF); 677212795Sdim RECORD(STMT_SWITCH); 678212795Sdim RECORD(STMT_WHILE); 679212795Sdim RECORD(STMT_DO); 680212795Sdim RECORD(STMT_FOR); 681212795Sdim RECORD(STMT_GOTO); 682212795Sdim RECORD(STMT_INDIRECT_GOTO); 683212795Sdim RECORD(STMT_CONTINUE); 684212795Sdim RECORD(STMT_BREAK); 685212795Sdim RECORD(STMT_RETURN); 686212795Sdim RECORD(STMT_DECL); 687245431Sdim RECORD(STMT_GCCASM); 688245431Sdim RECORD(STMT_MSASM); 689212795Sdim RECORD(EXPR_PREDEFINED); 690212795Sdim RECORD(EXPR_DECL_REF); 691212795Sdim RECORD(EXPR_INTEGER_LITERAL); 692212795Sdim RECORD(EXPR_FLOATING_LITERAL); 693212795Sdim RECORD(EXPR_IMAGINARY_LITERAL); 694212795Sdim RECORD(EXPR_STRING_LITERAL); 695212795Sdim RECORD(EXPR_CHARACTER_LITERAL); 696212795Sdim RECORD(EXPR_PAREN); 697212795Sdim RECORD(EXPR_UNARY_OPERATOR); 698212795Sdim RECORD(EXPR_SIZEOF_ALIGN_OF); 699212795Sdim RECORD(EXPR_ARRAY_SUBSCRIPT); 700212795Sdim RECORD(EXPR_CALL); 701212795Sdim RECORD(EXPR_MEMBER); 702212795Sdim RECORD(EXPR_BINARY_OPERATOR); 703212795Sdim RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); 704212795Sdim RECORD(EXPR_CONDITIONAL_OPERATOR); 705212795Sdim RECORD(EXPR_IMPLICIT_CAST); 706212795Sdim RECORD(EXPR_CSTYLE_CAST); 707212795Sdim RECORD(EXPR_COMPOUND_LITERAL); 708212795Sdim RECORD(EXPR_EXT_VECTOR_ELEMENT); 709212795Sdim RECORD(EXPR_INIT_LIST); 710212795Sdim RECORD(EXPR_DESIGNATED_INIT); 711212795Sdim RECORD(EXPR_IMPLICIT_VALUE_INIT); 712212795Sdim RECORD(EXPR_VA_ARG); 713212795Sdim RECORD(EXPR_ADDR_LABEL); 714212795Sdim RECORD(EXPR_STMT); 715212795Sdim RECORD(EXPR_CHOOSE); 716212795Sdim RECORD(EXPR_GNU_NULL); 717212795Sdim RECORD(EXPR_SHUFFLE_VECTOR); 718212795Sdim RECORD(EXPR_BLOCK); 719221345Sdim RECORD(EXPR_GENERIC_SELECTION); 720212795Sdim RECORD(EXPR_OBJC_STRING_LITERAL); 721245431Sdim RECORD(EXPR_OBJC_BOXED_EXPRESSION); 722235633Sdim RECORD(EXPR_OBJC_ARRAY_LITERAL); 723235633Sdim RECORD(EXPR_OBJC_DICTIONARY_LITERAL); 724212795Sdim RECORD(EXPR_OBJC_ENCODE); 725212795Sdim RECORD(EXPR_OBJC_SELECTOR_EXPR); 726212795Sdim RECORD(EXPR_OBJC_PROTOCOL_EXPR); 727212795Sdim RECORD(EXPR_OBJC_IVAR_REF_EXPR); 728212795Sdim RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); 729212795Sdim RECORD(EXPR_OBJC_KVC_REF_EXPR); 730212795Sdim RECORD(EXPR_OBJC_MESSAGE_EXPR); 731212795Sdim RECORD(STMT_OBJC_FOR_COLLECTION); 732212795Sdim RECORD(STMT_OBJC_CATCH); 733212795Sdim RECORD(STMT_OBJC_FINALLY); 734212795Sdim RECORD(STMT_OBJC_AT_TRY); 735212795Sdim RECORD(STMT_OBJC_AT_SYNCHRONIZED); 736212795Sdim RECORD(STMT_OBJC_AT_THROW); 737235633Sdim RECORD(EXPR_OBJC_BOOL_LITERAL); 738212795Sdim RECORD(EXPR_CXX_OPERATOR_CALL); 739212795Sdim RECORD(EXPR_CXX_CONSTRUCT); 740212795Sdim RECORD(EXPR_CXX_STATIC_CAST); 741212795Sdim RECORD(EXPR_CXX_DYNAMIC_CAST); 742212795Sdim RECORD(EXPR_CXX_REINTERPRET_CAST); 743212795Sdim RECORD(EXPR_CXX_CONST_CAST); 744212795Sdim RECORD(EXPR_CXX_FUNCTIONAL_CAST); 745235633Sdim RECORD(EXPR_USER_DEFINED_LITERAL); 746263509Sdim RECORD(EXPR_CXX_STD_INITIALIZER_LIST); 747212795Sdim RECORD(EXPR_CXX_BOOL_LITERAL); 748212795Sdim RECORD(EXPR_CXX_NULL_PTR_LITERAL); 749218893Sdim RECORD(EXPR_CXX_TYPEID_EXPR); 750218893Sdim RECORD(EXPR_CXX_TYPEID_TYPE); 751218893Sdim RECORD(EXPR_CXX_UUIDOF_EXPR); 752218893Sdim RECORD(EXPR_CXX_UUIDOF_TYPE); 753218893Sdim RECORD(EXPR_CXX_THIS); 754218893Sdim RECORD(EXPR_CXX_THROW); 755218893Sdim RECORD(EXPR_CXX_DEFAULT_ARG); 756218893Sdim RECORD(EXPR_CXX_BIND_TEMPORARY); 757218893Sdim RECORD(EXPR_CXX_SCALAR_VALUE_INIT); 758218893Sdim RECORD(EXPR_CXX_NEW); 759218893Sdim RECORD(EXPR_CXX_DELETE); 760218893Sdim RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); 761218893Sdim RECORD(EXPR_EXPR_WITH_CLEANUPS); 762218893Sdim RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); 763218893Sdim RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); 764218893Sdim RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); 765218893Sdim RECORD(EXPR_CXX_UNRESOLVED_MEMBER); 766218893Sdim RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); 767218893Sdim RECORD(EXPR_CXX_UNARY_TYPE_TRAIT); 768218893Sdim RECORD(EXPR_CXX_NOEXCEPT); 769218893Sdim RECORD(EXPR_OPAQUE_VALUE); 770218893Sdim RECORD(EXPR_BINARY_TYPE_TRAIT); 771218893Sdim RECORD(EXPR_PACK_EXPANSION); 772218893Sdim RECORD(EXPR_SIZEOF_PACK); 773218893Sdim RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); 774218893Sdim RECORD(EXPR_CUDA_KERNEL_CALL); 775212795Sdim#undef RECORD 776212795Sdim} 777212795Sdim 778212795Sdimvoid ASTWriter::WriteBlockInfoBlock() { 779212795Sdim RecordData Record; 780212795Sdim Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); 781212795Sdim 782212795Sdim#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) 783212795Sdim#define RECORD(X) EmitRecordID(X, #X, Stream, Record) 784212795Sdim 785245431Sdim // Control Block. 786245431Sdim BLOCK(CONTROL_BLOCK); 787245431Sdim RECORD(METADATA); 788245431Sdim RECORD(IMPORTS); 789245431Sdim RECORD(LANGUAGE_OPTIONS); 790245431Sdim RECORD(TARGET_OPTIONS); 791245431Sdim RECORD(ORIGINAL_FILE); 792245431Sdim RECORD(ORIGINAL_PCH_DIR); 793252723Sdim RECORD(ORIGINAL_FILE_ID); 794245431Sdim RECORD(INPUT_FILE_OFFSETS); 795245431Sdim RECORD(DIAGNOSTIC_OPTIONS); 796245431Sdim RECORD(FILE_SYSTEM_OPTIONS); 797245431Sdim RECORD(HEADER_SEARCH_OPTIONS); 798245431Sdim RECORD(PREPROCESSOR_OPTIONS); 799245431Sdim 800245431Sdim BLOCK(INPUT_FILES_BLOCK); 801245431Sdim RECORD(INPUT_FILE); 802245431Sdim 803212795Sdim // AST Top-Level Block. 804212795Sdim BLOCK(AST_BLOCK); 805212795Sdim RECORD(TYPE_OFFSET); 806212795Sdim RECORD(DECL_OFFSET); 807212795Sdim RECORD(IDENTIFIER_OFFSET); 808212795Sdim RECORD(IDENTIFIER_TABLE); 809212795Sdim RECORD(EXTERNAL_DEFINITIONS); 810212795Sdim RECORD(SPECIAL_TYPES); 811212795Sdim RECORD(STATISTICS); 812212795Sdim RECORD(TENTATIVE_DEFINITIONS); 813212795Sdim RECORD(UNUSED_FILESCOPED_DECLS); 814252723Sdim RECORD(LOCALLY_SCOPED_EXTERN_C_DECLS); 815212795Sdim RECORD(SELECTOR_OFFSETS); 816212795Sdim RECORD(METHOD_POOL); 817212795Sdim RECORD(PP_COUNTER_VALUE); 818212795Sdim RECORD(SOURCE_LOCATION_OFFSETS); 819212795Sdim RECORD(SOURCE_LOCATION_PRELOADS); 820212795Sdim RECORD(EXT_VECTOR_DECLS); 821226890Sdim RECORD(PPD_ENTITIES_OFFSETS); 822212795Sdim RECORD(REFERENCED_SELECTOR_POOL); 823218893Sdim RECORD(TU_UPDATE_LEXICAL); 824235633Sdim RECORD(LOCAL_REDECLARATIONS_MAP); 825218893Sdim RECORD(SEMA_DECL_REFS); 826218893Sdim RECORD(WEAK_UNDECLARED_IDENTIFIERS); 827218893Sdim RECORD(PENDING_IMPLICIT_INSTANTIATIONS); 828218893Sdim RECORD(DECL_REPLACEMENTS); 829218893Sdim RECORD(UPDATE_VISIBLE); 830218893Sdim RECORD(DECL_UPDATE_OFFSETS); 831218893Sdim RECORD(DECL_UPDATES); 832218893Sdim RECORD(CXX_BASE_SPECIFIER_OFFSETS); 833218893Sdim RECORD(DIAG_PRAGMA_MAPPINGS); 834218893Sdim RECORD(CUDA_SPECIAL_DECL_REFS); 835218893Sdim RECORD(HEADER_SEARCH_TABLE); 836218893Sdim RECORD(FP_PRAGMA_OPTIONS); 837218893Sdim RECORD(OPENCL_EXTENSIONS); 838223017Sdim RECORD(DELEGATING_CTORS); 839224145Sdim RECORD(KNOWN_NAMESPACES); 840252723Sdim RECORD(UNDEFINED_BUT_USED); 841226890Sdim RECORD(MODULE_OFFSET_MAP); 842226890Sdim RECORD(SOURCE_MANAGER_LINE_TABLE); 843235633Sdim RECORD(OBJC_CATEGORIES_MAP); 844235633Sdim RECORD(FILE_SORTED_DECLS); 845235633Sdim RECORD(IMPORTED_MODULES); 846235633Sdim RECORD(MERGED_DECLARATIONS); 847235633Sdim RECORD(LOCAL_REDECLARATIONS); 848235633Sdim RECORD(OBJC_CATEGORIES); 849245431Sdim RECORD(MACRO_OFFSET); 850252723Sdim RECORD(MACRO_TABLE); 851263509Sdim RECORD(LATE_PARSED_TEMPLATE); 852235633Sdim 853212795Sdim // SourceManager Block. 854212795Sdim BLOCK(SOURCE_MANAGER_BLOCK); 855212795Sdim RECORD(SM_SLOC_FILE_ENTRY); 856212795Sdim RECORD(SM_SLOC_BUFFER_ENTRY); 857212795Sdim RECORD(SM_SLOC_BUFFER_BLOB); 858224145Sdim RECORD(SM_SLOC_EXPANSION_ENTRY); 859212795Sdim 860212795Sdim // Preprocessor Block. 861212795Sdim BLOCK(PREPROCESSOR_BLOCK); 862212795Sdim RECORD(PP_MACRO_OBJECT_LIKE); 863212795Sdim RECORD(PP_MACRO_FUNCTION_LIKE); 864212795Sdim RECORD(PP_TOKEN); 865212795Sdim 866212795Sdim // Decls and Types block. 867212795Sdim BLOCK(DECLTYPES_BLOCK); 868212795Sdim RECORD(TYPE_EXT_QUAL); 869212795Sdim RECORD(TYPE_COMPLEX); 870212795Sdim RECORD(TYPE_POINTER); 871212795Sdim RECORD(TYPE_BLOCK_POINTER); 872212795Sdim RECORD(TYPE_LVALUE_REFERENCE); 873212795Sdim RECORD(TYPE_RVALUE_REFERENCE); 874212795Sdim RECORD(TYPE_MEMBER_POINTER); 875212795Sdim RECORD(TYPE_CONSTANT_ARRAY); 876212795Sdim RECORD(TYPE_INCOMPLETE_ARRAY); 877212795Sdim RECORD(TYPE_VARIABLE_ARRAY); 878212795Sdim RECORD(TYPE_VECTOR); 879212795Sdim RECORD(TYPE_EXT_VECTOR); 880212795Sdim RECORD(TYPE_FUNCTION_PROTO); 881212795Sdim RECORD(TYPE_FUNCTION_NO_PROTO); 882212795Sdim RECORD(TYPE_TYPEDEF); 883212795Sdim RECORD(TYPE_TYPEOF_EXPR); 884212795Sdim RECORD(TYPE_TYPEOF); 885212795Sdim RECORD(TYPE_RECORD); 886212795Sdim RECORD(TYPE_ENUM); 887212795Sdim RECORD(TYPE_OBJC_INTERFACE); 888212795Sdim RECORD(TYPE_OBJC_OBJECT); 889212795Sdim RECORD(TYPE_OBJC_OBJECT_POINTER); 890218893Sdim RECORD(TYPE_DECLTYPE); 891218893Sdim RECORD(TYPE_ELABORATED); 892218893Sdim RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); 893218893Sdim RECORD(TYPE_UNRESOLVED_USING); 894218893Sdim RECORD(TYPE_INJECTED_CLASS_NAME); 895218893Sdim RECORD(TYPE_OBJC_OBJECT); 896218893Sdim RECORD(TYPE_TEMPLATE_TYPE_PARM); 897218893Sdim RECORD(TYPE_TEMPLATE_SPECIALIZATION); 898218893Sdim RECORD(TYPE_DEPENDENT_NAME); 899218893Sdim RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); 900218893Sdim RECORD(TYPE_DEPENDENT_SIZED_ARRAY); 901218893Sdim RECORD(TYPE_PAREN); 902218893Sdim RECORD(TYPE_PACK_EXPANSION); 903218893Sdim RECORD(TYPE_ATTRIBUTED); 904218893Sdim RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); 905226890Sdim RECORD(TYPE_ATOMIC); 906212795Sdim RECORD(DECL_TYPEDEF); 907212795Sdim RECORD(DECL_ENUM); 908212795Sdim RECORD(DECL_RECORD); 909212795Sdim RECORD(DECL_ENUM_CONSTANT); 910212795Sdim RECORD(DECL_FUNCTION); 911212795Sdim RECORD(DECL_OBJC_METHOD); 912212795Sdim RECORD(DECL_OBJC_INTERFACE); 913212795Sdim RECORD(DECL_OBJC_PROTOCOL); 914212795Sdim RECORD(DECL_OBJC_IVAR); 915212795Sdim RECORD(DECL_OBJC_AT_DEFS_FIELD); 916212795Sdim RECORD(DECL_OBJC_CATEGORY); 917212795Sdim RECORD(DECL_OBJC_CATEGORY_IMPL); 918212795Sdim RECORD(DECL_OBJC_IMPLEMENTATION); 919212795Sdim RECORD(DECL_OBJC_COMPATIBLE_ALIAS); 920212795Sdim RECORD(DECL_OBJC_PROPERTY); 921212795Sdim RECORD(DECL_OBJC_PROPERTY_IMPL); 922212795Sdim RECORD(DECL_FIELD); 923252723Sdim RECORD(DECL_MS_PROPERTY); 924212795Sdim RECORD(DECL_VAR); 925212795Sdim RECORD(DECL_IMPLICIT_PARAM); 926212795Sdim RECORD(DECL_PARM_VAR); 927212795Sdim RECORD(DECL_FILE_SCOPE_ASM); 928212795Sdim RECORD(DECL_BLOCK); 929212795Sdim RECORD(DECL_CONTEXT_LEXICAL); 930212795Sdim RECORD(DECL_CONTEXT_VISIBLE); 931218893Sdim RECORD(DECL_NAMESPACE); 932218893Sdim RECORD(DECL_NAMESPACE_ALIAS); 933218893Sdim RECORD(DECL_USING); 934218893Sdim RECORD(DECL_USING_SHADOW); 935218893Sdim RECORD(DECL_USING_DIRECTIVE); 936218893Sdim RECORD(DECL_UNRESOLVED_USING_VALUE); 937218893Sdim RECORD(DECL_UNRESOLVED_USING_TYPENAME); 938218893Sdim RECORD(DECL_LINKAGE_SPEC); 939218893Sdim RECORD(DECL_CXX_RECORD); 940218893Sdim RECORD(DECL_CXX_METHOD); 941218893Sdim RECORD(DECL_CXX_CONSTRUCTOR); 942218893Sdim RECORD(DECL_CXX_DESTRUCTOR); 943218893Sdim RECORD(DECL_CXX_CONVERSION); 944218893Sdim RECORD(DECL_ACCESS_SPEC); 945218893Sdim RECORD(DECL_FRIEND); 946218893Sdim RECORD(DECL_FRIEND_TEMPLATE); 947218893Sdim RECORD(DECL_CLASS_TEMPLATE); 948218893Sdim RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); 949218893Sdim RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); 950263509Sdim RECORD(DECL_VAR_TEMPLATE); 951263509Sdim RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION); 952263509Sdim RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION); 953218893Sdim RECORD(DECL_FUNCTION_TEMPLATE); 954218893Sdim RECORD(DECL_TEMPLATE_TYPE_PARM); 955218893Sdim RECORD(DECL_NON_TYPE_TEMPLATE_PARM); 956218893Sdim RECORD(DECL_TEMPLATE_TEMPLATE_PARM); 957218893Sdim RECORD(DECL_STATIC_ASSERT); 958218893Sdim RECORD(DECL_CXX_BASE_SPECIFIERS); 959218893Sdim RECORD(DECL_INDIRECTFIELD); 960218893Sdim RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); 961218893Sdim 962223017Sdim // Statements and Exprs can occur in the Decls and Types block. 963223017Sdim AddStmtsExprs(Stream, Record); 964223017Sdim 965218893Sdim BLOCK(PREPROCESSOR_DETAIL_BLOCK); 966224145Sdim RECORD(PPD_MACRO_EXPANSION); 967218893Sdim RECORD(PPD_MACRO_DEFINITION); 968218893Sdim RECORD(PPD_INCLUSION_DIRECTIVE); 969218893Sdim 970212795Sdim#undef RECORD 971212795Sdim#undef BLOCK 972212795Sdim Stream.ExitBlock(); 973212795Sdim} 974212795Sdim 975212795Sdim/// \brief Adjusts the given filename to only write out the portion of the 976212795Sdim/// filename that is not part of the system root directory. 977212795Sdim/// 978212795Sdim/// \param Filename the file name to adjust. 979212795Sdim/// 980212795Sdim/// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and 981212795Sdim/// the returned filename will be adjusted by this system root. 982212795Sdim/// 983212795Sdim/// \returns either the original filename (if it needs no adjustment) or the 984212795Sdim/// adjusted filename (which points into the @p Filename parameter). 985212795Sdimstatic const char * 986226890SdimadjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) { 987212795Sdim assert(Filename && "No file name to adjust?"); 988212795Sdim 989226890Sdim if (isysroot.empty()) 990212795Sdim return Filename; 991212795Sdim 992212795Sdim // Verify that the filename and the system root have the same prefix. 993212795Sdim unsigned Pos = 0; 994226890Sdim for (; Filename[Pos] && Pos < isysroot.size(); ++Pos) 995212795Sdim if (Filename[Pos] != isysroot[Pos]) 996212795Sdim return Filename; // Prefixes don't match. 997212795Sdim 998212795Sdim // We hit the end of the filename before we hit the end of the system root. 999212795Sdim if (!Filename[Pos]) 1000212795Sdim return Filename; 1001212795Sdim 1002212795Sdim // If the file name has a '/' at the current position, skip over the '/'. 1003212795Sdim // We distinguish sysroot-based includes from absolute includes by the 1004212795Sdim // absence of '/' at the beginning of sysroot-based includes. 1005212795Sdim if (Filename[Pos] == '/') 1006212795Sdim ++Pos; 1007212795Sdim 1008212795Sdim return Filename + Pos; 1009212795Sdim} 1010212795Sdim 1011245431Sdim/// \brief Write the control block. 1012245431Sdimvoid ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context, 1013245431Sdim StringRef isysroot, 1014245431Sdim const std::string &OutputFile) { 1015212795Sdim using namespace llvm; 1016245431Sdim Stream.EnterSubblock(CONTROL_BLOCK_ID, 5); 1017245431Sdim RecordData Record; 1018245431Sdim 1019212795Sdim // Metadata 1020245431Sdim BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev(); 1021245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA)); 1022245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major 1023245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor 1024245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj. 1025245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min. 1026245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable 1027245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors 1028245431Sdim MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag 1029245431Sdim unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev); 1030226890Sdim Record.push_back(METADATA); 1031212795Sdim Record.push_back(VERSION_MAJOR); 1032212795Sdim Record.push_back(VERSION_MINOR); 1033212795Sdim Record.push_back(CLANG_VERSION_MAJOR); 1034212795Sdim Record.push_back(CLANG_VERSION_MINOR); 1035226890Sdim Record.push_back(!isysroot.empty()); 1036235633Sdim Record.push_back(ASTHasCompilerErrors); 1037245431Sdim Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, 1038245431Sdim getClangFullRepositoryVersion()); 1039212795Sdim 1040245431Sdim // Imports 1041226890Sdim if (Chain) { 1042226890Sdim serialization::ModuleManager &Mgr = Chain->getModuleManager(); 1043252723Sdim SmallVector<char, 128> ModulePaths; 1044226890Sdim Record.clear(); 1045226890Sdim 1046226890Sdim for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end(); 1047226890Sdim M != MEnd; ++M) { 1048226890Sdim // Skip modules that weren't directly imported. 1049226890Sdim if (!(*M)->isDirectlyImported()) 1050226890Sdim continue; 1051226890Sdim 1052226890Sdim Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding 1053252723Sdim AddSourceLocation((*M)->ImportLoc, Record); 1054252723Sdim Record.push_back((*M)->File->getSize()); 1055252723Sdim Record.push_back((*M)->File->getModificationTime()); 1056226890Sdim // FIXME: This writes the absolute path for AST files we depend on. 1057226890Sdim const std::string &FileName = (*M)->FileName; 1058226890Sdim Record.push_back(FileName.size()); 1059226890Sdim Record.append(FileName.begin(), FileName.end()); 1060226890Sdim } 1061226890Sdim Stream.EmitRecord(IMPORTS, Record); 1062226890Sdim } 1063226890Sdim 1064245431Sdim // Language options. 1065245431Sdim Record.clear(); 1066245431Sdim const LangOptions &LangOpts = Context.getLangOpts(); 1067245431Sdim#define LANGOPT(Name, Bits, Default, Description) \ 1068245431Sdim Record.push_back(LangOpts.Name); 1069245431Sdim#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 1070245431Sdim Record.push_back(static_cast<unsigned>(LangOpts.get##Name())); 1071245431Sdim#include "clang/Basic/LangOptions.def" 1072252723Sdim#define SANITIZER(NAME, ID) Record.push_back(LangOpts.Sanitize.ID); 1073252723Sdim#include "clang/Basic/Sanitizers.def" 1074245431Sdim 1075245431Sdim Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); 1076245431Sdim AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); 1077245431Sdim 1078245431Sdim Record.push_back(LangOpts.CurrentModule.size()); 1079245431Sdim Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end()); 1080252723Sdim 1081252723Sdim // Comment options. 1082252723Sdim Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); 1083252723Sdim for (CommentOptions::BlockCommandNamesTy::const_iterator 1084252723Sdim I = LangOpts.CommentOpts.BlockCommandNames.begin(), 1085252723Sdim IEnd = LangOpts.CommentOpts.BlockCommandNames.end(); 1086252723Sdim I != IEnd; ++I) { 1087252723Sdim AddString(*I, Record); 1088252723Sdim } 1089252723Sdim Record.push_back(LangOpts.CommentOpts.ParseAllComments); 1090252723Sdim 1091245431Sdim Stream.EmitRecord(LANGUAGE_OPTIONS, Record); 1092245431Sdim 1093245431Sdim // Target options. 1094245431Sdim Record.clear(); 1095245431Sdim const TargetInfo &Target = Context.getTargetInfo(); 1096245431Sdim const TargetOptions &TargetOpts = Target.getTargetOpts(); 1097245431Sdim AddString(TargetOpts.Triple, Record); 1098245431Sdim AddString(TargetOpts.CPU, Record); 1099245431Sdim AddString(TargetOpts.ABI, Record); 1100245431Sdim AddString(TargetOpts.CXXABI, Record); 1101245431Sdim AddString(TargetOpts.LinkerVersion, Record); 1102245431Sdim Record.push_back(TargetOpts.FeaturesAsWritten.size()); 1103245431Sdim for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { 1104245431Sdim AddString(TargetOpts.FeaturesAsWritten[I], Record); 1105245431Sdim } 1106245431Sdim Record.push_back(TargetOpts.Features.size()); 1107245431Sdim for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { 1108245431Sdim AddString(TargetOpts.Features[I], Record); 1109245431Sdim } 1110245431Sdim Stream.EmitRecord(TARGET_OPTIONS, Record); 1111245431Sdim 1112245431Sdim // Diagnostic options. 1113245431Sdim Record.clear(); 1114245431Sdim const DiagnosticOptions &DiagOpts 1115245431Sdim = Context.getDiagnostics().getDiagnosticOptions(); 1116245431Sdim#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name); 1117245431Sdim#define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 1118245431Sdim Record.push_back(static_cast<unsigned>(DiagOpts.get##Name())); 1119245431Sdim#include "clang/Basic/DiagnosticOptions.def" 1120245431Sdim Record.push_back(DiagOpts.Warnings.size()); 1121245431Sdim for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I) 1122245431Sdim AddString(DiagOpts.Warnings[I], Record); 1123245431Sdim // Note: we don't serialize the log or serialization file names, because they 1124245431Sdim // are generally transient files and will almost always be overridden. 1125245431Sdim Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record); 1126245431Sdim 1127245431Sdim // File system options. 1128245431Sdim Record.clear(); 1129245431Sdim const FileSystemOptions &FSOpts 1130245431Sdim = Context.getSourceManager().getFileManager().getFileSystemOptions(); 1131245431Sdim AddString(FSOpts.WorkingDir, Record); 1132245431Sdim Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record); 1133245431Sdim 1134245431Sdim // Header search options. 1135245431Sdim Record.clear(); 1136245431Sdim const HeaderSearchOptions &HSOpts 1137245431Sdim = PP.getHeaderSearchInfo().getHeaderSearchOpts(); 1138245431Sdim AddString(HSOpts.Sysroot, Record); 1139245431Sdim 1140245431Sdim // Include entries. 1141245431Sdim Record.push_back(HSOpts.UserEntries.size()); 1142245431Sdim for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) { 1143245431Sdim const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I]; 1144245431Sdim AddString(Entry.Path, Record); 1145245431Sdim Record.push_back(static_cast<unsigned>(Entry.Group)); 1146245431Sdim Record.push_back(Entry.IsFramework); 1147245431Sdim Record.push_back(Entry.IgnoreSysRoot); 1148245431Sdim } 1149245431Sdim 1150245431Sdim // System header prefixes. 1151245431Sdim Record.push_back(HSOpts.SystemHeaderPrefixes.size()); 1152245431Sdim for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) { 1153245431Sdim AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record); 1154245431Sdim Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader); 1155245431Sdim } 1156245431Sdim 1157245431Sdim AddString(HSOpts.ResourceDir, Record); 1158245431Sdim AddString(HSOpts.ModuleCachePath, Record); 1159245431Sdim Record.push_back(HSOpts.DisableModuleHash); 1160245431Sdim Record.push_back(HSOpts.UseBuiltinIncludes); 1161245431Sdim Record.push_back(HSOpts.UseStandardSystemIncludes); 1162245431Sdim Record.push_back(HSOpts.UseStandardCXXIncludes); 1163245431Sdim Record.push_back(HSOpts.UseLibcxx); 1164245431Sdim Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record); 1165245431Sdim 1166245431Sdim // Preprocessor options. 1167245431Sdim Record.clear(); 1168245431Sdim const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts(); 1169245431Sdim 1170245431Sdim // Macro definitions. 1171245431Sdim Record.push_back(PPOpts.Macros.size()); 1172245431Sdim for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { 1173245431Sdim AddString(PPOpts.Macros[I].first, Record); 1174245431Sdim Record.push_back(PPOpts.Macros[I].second); 1175245431Sdim } 1176245431Sdim 1177245431Sdim // Includes 1178245431Sdim Record.push_back(PPOpts.Includes.size()); 1179245431Sdim for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I) 1180245431Sdim AddString(PPOpts.Includes[I], Record); 1181245431Sdim 1182245431Sdim // Macro includes 1183245431Sdim Record.push_back(PPOpts.MacroIncludes.size()); 1184245431Sdim for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I) 1185245431Sdim AddString(PPOpts.MacroIncludes[I], Record); 1186245431Sdim 1187245431Sdim Record.push_back(PPOpts.UsePredefines); 1188252723Sdim // Detailed record is important since it is used for the module cache hash. 1189252723Sdim Record.push_back(PPOpts.DetailedRecord); 1190245431Sdim AddString(PPOpts.ImplicitPCHInclude, Record); 1191245431Sdim AddString(PPOpts.ImplicitPTHInclude, Record); 1192245431Sdim Record.push_back(static_cast<unsigned>(PPOpts.ObjCXXARCStandardLibrary)); 1193245431Sdim Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record); 1194245431Sdim 1195223017Sdim // Original file name and file ID 1196212795Sdim SourceManager &SM = Context.getSourceManager(); 1197212795Sdim if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 1198212795Sdim BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev(); 1199245431Sdim FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE)); 1200245431Sdim FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID 1201212795Sdim FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1202212795Sdim unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); 1203212795Sdim 1204235633Sdim SmallString<128> MainFilePath(MainFile->getName()); 1205212795Sdim 1206218893Sdim llvm::sys::fs::make_absolute(MainFilePath); 1207212795Sdim 1208212795Sdim const char *MainFileNameStr = MainFilePath.c_str(); 1209212795Sdim MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, 1210212795Sdim isysroot); 1211223017Sdim Record.clear(); 1212245431Sdim Record.push_back(ORIGINAL_FILE); 1213223017Sdim Record.push_back(SM.getMainFileID().getOpaqueValue()); 1214245431Sdim Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr); 1215212795Sdim } 1216212795Sdim 1217252723Sdim Record.clear(); 1218252723Sdim Record.push_back(SM.getMainFileID().getOpaqueValue()); 1219252723Sdim Stream.EmitRecord(ORIGINAL_FILE_ID, Record); 1220252723Sdim 1221218893Sdim // Original PCH directory 1222218893Sdim if (!OutputFile.empty() && OutputFile != "-") { 1223218893Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1224218893Sdim Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); 1225218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1226218893Sdim unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 1227218893Sdim 1228235633Sdim SmallString<128> OutputPath(OutputFile); 1229218893Sdim 1230218893Sdim llvm::sys::fs::make_absolute(OutputPath); 1231218893Sdim StringRef origDir = llvm::sys::path::parent_path(OutputPath); 1232218893Sdim 1233218893Sdim RecordData Record; 1234218893Sdim Record.push_back(ORIGINAL_PCH_DIR); 1235218893Sdim Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); 1236218893Sdim } 1237218893Sdim 1238252723Sdim WriteInputFiles(Context.SourceMgr, 1239252723Sdim PP.getHeaderSearchInfo().getHeaderSearchOpts(), 1240263509Sdim isysroot, 1241263509Sdim PP.getLangOpts().Modules); 1242245431Sdim Stream.ExitBlock(); 1243212795Sdim} 1244212795Sdim 1245252723Sdimnamespace { 1246252723Sdim /// \brief An input file. 1247252723Sdim struct InputFileEntry { 1248252723Sdim const FileEntry *File; 1249252723Sdim bool IsSystemFile; 1250252723Sdim bool BufferOverridden; 1251252723Sdim }; 1252252723Sdim} 1253252723Sdim 1254252723Sdimvoid ASTWriter::WriteInputFiles(SourceManager &SourceMgr, 1255252723Sdim HeaderSearchOptions &HSOpts, 1256263509Sdim StringRef isysroot, 1257263509Sdim bool Modules) { 1258245431Sdim using namespace llvm; 1259245431Sdim Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4); 1260212795Sdim RecordData Record; 1261235633Sdim 1262245431Sdim // Create input-file abbreviation. 1263245431Sdim BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev(); 1264245431Sdim IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE)); 1265245431Sdim IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID 1266245431Sdim IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size 1267245431Sdim IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time 1268245431Sdim IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden 1269245431Sdim IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1270245431Sdim unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev); 1271245431Sdim 1272252723Sdim // Get all ContentCache objects for files, sorted by whether the file is a 1273252723Sdim // system one or not. System files go at the back, users files at the front. 1274252723Sdim std::deque<InputFileEntry> SortedFiles; 1275245431Sdim for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { 1276245431Sdim // Get this source location entry. 1277245431Sdim const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); 1278245431Sdim assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc); 1279245431Sdim 1280245431Sdim // We only care about file entries that were not overridden. 1281245431Sdim if (!SLoc->isFile()) 1282245431Sdim continue; 1283245431Sdim const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); 1284245431Sdim if (!Cache->OrigEntry) 1285245431Sdim continue; 1286245431Sdim 1287252723Sdim InputFileEntry Entry; 1288252723Sdim Entry.File = Cache->OrigEntry; 1289252723Sdim Entry.IsSystemFile = Cache->IsSystemFile; 1290252723Sdim Entry.BufferOverridden = Cache->BufferOverridden; 1291252723Sdim if (Cache->IsSystemFile) 1292252723Sdim SortedFiles.push_back(Entry); 1293252723Sdim else 1294252723Sdim SortedFiles.push_front(Entry); 1295252723Sdim } 1296252723Sdim 1297252723Sdim // If we have an isysroot for a Darwin SDK, include its SDKSettings.plist in 1298252723Sdim // the set of (non-system) input files. This is simple heuristic for 1299252723Sdim // detecting whether the system headers may have changed, because it is too 1300252723Sdim // expensive to stat() all of the system headers. 1301252723Sdim FileManager &FileMgr = SourceMgr.getFileManager(); 1302252723Sdim if (!HSOpts.Sysroot.empty() && !Chain) { 1303252723Sdim llvm::SmallString<128> SDKSettingsFileName(HSOpts.Sysroot); 1304252723Sdim llvm::sys::path::append(SDKSettingsFileName, "SDKSettings.plist"); 1305252723Sdim if (const FileEntry *SDKSettingsFile = FileMgr.getFile(SDKSettingsFileName)) { 1306252723Sdim InputFileEntry Entry = { SDKSettingsFile, false, false }; 1307252723Sdim SortedFiles.push_front(Entry); 1308252723Sdim } 1309252723Sdim } 1310252723Sdim 1311263509Sdim // Add the compiler's own module.map in the set of (non-system) input files. 1312263509Sdim // This is a simple heuristic for detecting whether the compiler's headers 1313263509Sdim // have changed, because we don't want to stat() all of them. 1314263509Sdim if (Modules && !Chain) { 1315263509Sdim SmallString<128> P = StringRef(HSOpts.ResourceDir); 1316263509Sdim llvm::sys::path::append(P, "include"); 1317263509Sdim llvm::sys::path::append(P, "module.map"); 1318263509Sdim if (const FileEntry *ModuleMapFile = FileMgr.getFile(P)) { 1319263509Sdim InputFileEntry Entry = { ModuleMapFile, false, false }; 1320263509Sdim SortedFiles.push_front(Entry); 1321263509Sdim } 1322263509Sdim } 1323263509Sdim 1324252723Sdim unsigned UserFilesNum = 0; 1325252723Sdim // Write out all of the input files. 1326252723Sdim std::vector<uint32_t> InputFileOffsets; 1327252723Sdim for (std::deque<InputFileEntry>::iterator 1328252723Sdim I = SortedFiles.begin(), E = SortedFiles.end(); I != E; ++I) { 1329252723Sdim const InputFileEntry &Entry = *I; 1330252723Sdim 1331252723Sdim uint32_t &InputFileID = InputFileIDs[Entry.File]; 1332252723Sdim if (InputFileID != 0) 1333252723Sdim continue; // already recorded this file. 1334252723Sdim 1335245431Sdim // Record this entry's offset. 1336245431Sdim InputFileOffsets.push_back(Stream.GetCurrentBitNo()); 1337245431Sdim 1338252723Sdim InputFileID = InputFileOffsets.size(); 1339252723Sdim 1340252723Sdim if (!Entry.IsSystemFile) 1341252723Sdim ++UserFilesNum; 1342252723Sdim 1343245431Sdim Record.clear(); 1344245431Sdim Record.push_back(INPUT_FILE); 1345245431Sdim Record.push_back(InputFileOffsets.size()); 1346245431Sdim 1347245431Sdim // Emit size/modification time for this file. 1348252723Sdim Record.push_back(Entry.File->getSize()); 1349252723Sdim Record.push_back(Entry.File->getModificationTime()); 1350245431Sdim 1351245431Sdim // Whether this file was overridden. 1352252723Sdim Record.push_back(Entry.BufferOverridden); 1353245431Sdim 1354245431Sdim // Turn the file name into an absolute path, if it isn't already. 1355252723Sdim const char *Filename = Entry.File->getName(); 1356245431Sdim SmallString<128> FilePath(Filename); 1357245431Sdim 1358245431Sdim // Ask the file manager to fixup the relative path for us. This will 1359245431Sdim // honor the working directory. 1360252723Sdim FileMgr.FixupRelativePath(FilePath); 1361245431Sdim 1362245431Sdim // FIXME: This call to make_absolute shouldn't be necessary, the 1363245431Sdim // call to FixupRelativePath should always return an absolute path. 1364245431Sdim llvm::sys::fs::make_absolute(FilePath); 1365245431Sdim Filename = FilePath.c_str(); 1366245431Sdim 1367245431Sdim Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1368245431Sdim 1369245431Sdim Stream.EmitRecordWithBlob(IFAbbrevCode, Record, Filename); 1370245431Sdim } 1371252723Sdim 1372245431Sdim Stream.ExitBlock(); 1373245431Sdim 1374245431Sdim // Create input file offsets abbreviation. 1375245431Sdim BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev(); 1376245431Sdim OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS)); 1377245431Sdim OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files 1378252723Sdim OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system 1379252723Sdim // input files 1380245431Sdim OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array 1381245431Sdim unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev); 1382245431Sdim 1383245431Sdim // Write input file offsets. 1384245431Sdim Record.clear(); 1385245431Sdim Record.push_back(INPUT_FILE_OFFSETS); 1386245431Sdim Record.push_back(InputFileOffsets.size()); 1387252723Sdim Record.push_back(UserFilesNum); 1388245431Sdim Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, data(InputFileOffsets)); 1389212795Sdim} 1390212795Sdim 1391212795Sdim//===----------------------------------------------------------------------===// 1392212795Sdim// Source Manager Serialization 1393212795Sdim//===----------------------------------------------------------------------===// 1394212795Sdim 1395212795Sdim/// \brief Create an abbreviation for the SLocEntry that refers to a 1396212795Sdim/// file. 1397212795Sdimstatic unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { 1398212795Sdim using namespace llvm; 1399212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1400212795Sdim Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); 1401212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1402212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1403212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1404212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1405212795Sdim // FileEntry fields. 1406245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID 1407226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs 1408235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex 1409235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls 1410212795Sdim return Stream.EmitAbbrev(Abbrev); 1411212795Sdim} 1412212795Sdim 1413212795Sdim/// \brief Create an abbreviation for the SLocEntry that refers to a 1414212795Sdim/// buffer. 1415212795Sdimstatic unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { 1416212795Sdim using namespace llvm; 1417212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1418212795Sdim Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); 1419212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1420212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1421212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1422212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1423212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob 1424212795Sdim return Stream.EmitAbbrev(Abbrev); 1425212795Sdim} 1426212795Sdim 1427212795Sdim/// \brief Create an abbreviation for the SLocEntry that refers to a 1428212795Sdim/// buffer's blob. 1429212795Sdimstatic unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { 1430212795Sdim using namespace llvm; 1431212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1432212795Sdim Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB)); 1433212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob 1434212795Sdim return Stream.EmitAbbrev(Abbrev); 1435212795Sdim} 1436212795Sdim 1437224145Sdim/// \brief Create an abbreviation for the SLocEntry that refers to a macro 1438224145Sdim/// expansion. 1439224145Sdimstatic unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { 1440212795Sdim using namespace llvm; 1441212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1442224145Sdim Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); 1443212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1444212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location 1445212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location 1446212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location 1447212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length 1448212795Sdim return Stream.EmitAbbrev(Abbrev); 1449212795Sdim} 1450212795Sdim 1451218893Sdimnamespace { 1452218893Sdim // Trait used for the on-disk hash table of header search information. 1453218893Sdim class HeaderFileInfoTrait { 1454218893Sdim ASTWriter &Writer; 1455252723Sdim const HeaderSearch &HS; 1456218893Sdim 1457226890Sdim // Keep track of the framework names we've used during serialization. 1458226890Sdim SmallVector<char, 128> FrameworkStringData; 1459226890Sdim llvm::StringMap<unsigned> FrameworkNameOffset; 1460226890Sdim 1461218893Sdim public: 1462252723Sdim HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) 1463252723Sdim : Writer(Writer), HS(HS) { } 1464218893Sdim 1465252723Sdim struct key_type { 1466252723Sdim const FileEntry *FE; 1467252723Sdim const char *Filename; 1468252723Sdim }; 1469252723Sdim typedef const key_type &key_type_ref; 1470218893Sdim 1471218893Sdim typedef HeaderFileInfo data_type; 1472218893Sdim typedef const data_type &data_type_ref; 1473218893Sdim 1474252723Sdim static unsigned ComputeHash(key_type_ref key) { 1475252723Sdim // The hash is based only on size/time of the file, so that the reader can 1476252723Sdim // match even when symlinking or excess path elements ("foo/../", "../") 1477252723Sdim // change the form of the name. However, complete path is still the key. 1478252723Sdim return llvm::hash_combine(key.FE->getSize(), 1479252723Sdim key.FE->getModificationTime()); 1480218893Sdim } 1481218893Sdim 1482218893Sdim std::pair<unsigned,unsigned> 1483252723Sdim EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) { 1484252723Sdim unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8; 1485252723Sdim clang::io::Emit16(Out, KeyLen); 1486226890Sdim unsigned DataLen = 1 + 2 + 4 + 4; 1487252723Sdim if (Data.isModuleHeader) 1488252723Sdim DataLen += 4; 1489218893Sdim clang::io::Emit8(Out, DataLen); 1490252723Sdim return std::make_pair(KeyLen, DataLen); 1491218893Sdim } 1492218893Sdim 1493252723Sdim void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) { 1494252723Sdim clang::io::Emit64(Out, key.FE->getSize()); 1495252723Sdim KeyLen -= 8; 1496252723Sdim clang::io::Emit64(Out, key.FE->getModificationTime()); 1497252723Sdim KeyLen -= 8; 1498252723Sdim Out.write(key.Filename, KeyLen); 1499218893Sdim } 1500218893Sdim 1501252723Sdim void EmitData(raw_ostream &Out, key_type_ref key, 1502218893Sdim data_type_ref Data, unsigned DataLen) { 1503218893Sdim using namespace clang::io; 1504218893Sdim uint64_t Start = Out.tell(); (void)Start; 1505218893Sdim 1506263509Sdim unsigned char Flags = (Data.HeaderRole << 6) 1507263509Sdim | (Data.isImport << 5) 1508226890Sdim | (Data.isPragmaOnce << 4) 1509226890Sdim | (Data.DirInfo << 2) 1510226890Sdim | (Data.Resolved << 1) 1511226890Sdim | Data.IndexHeaderMapHeader; 1512218893Sdim Emit8(Out, (uint8_t)Flags); 1513218893Sdim Emit16(Out, (uint16_t) Data.NumIncludes); 1514218893Sdim 1515218893Sdim if (!Data.ControllingMacro) 1516218893Sdim Emit32(Out, (uint32_t)Data.ControllingMacroID); 1517218893Sdim else 1518218893Sdim Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro)); 1519226890Sdim 1520226890Sdim unsigned Offset = 0; 1521226890Sdim if (!Data.Framework.empty()) { 1522226890Sdim // If this header refers into a framework, save the framework name. 1523226890Sdim llvm::StringMap<unsigned>::iterator Pos 1524226890Sdim = FrameworkNameOffset.find(Data.Framework); 1525226890Sdim if (Pos == FrameworkNameOffset.end()) { 1526226890Sdim Offset = FrameworkStringData.size() + 1; 1527226890Sdim FrameworkStringData.append(Data.Framework.begin(), 1528226890Sdim Data.Framework.end()); 1529226890Sdim FrameworkStringData.push_back(0); 1530226890Sdim 1531226890Sdim FrameworkNameOffset[Data.Framework] = Offset; 1532226890Sdim } else 1533226890Sdim Offset = Pos->second; 1534226890Sdim } 1535226890Sdim Emit32(Out, Offset); 1536252723Sdim 1537252723Sdim if (Data.isModuleHeader) { 1538263509Sdim Module *Mod = HS.findModuleForHeader(key.FE).getModule(); 1539252723Sdim Emit32(Out, Writer.getExistingSubmoduleID(Mod)); 1540252723Sdim } 1541252723Sdim 1542218893Sdim assert(Out.tell() - Start == DataLen && "Wrong data length"); 1543218893Sdim } 1544226890Sdim 1545226890Sdim const char *strings_begin() const { return FrameworkStringData.begin(); } 1546226890Sdim const char *strings_end() const { return FrameworkStringData.end(); } 1547218893Sdim }; 1548218893Sdim} // end anonymous namespace 1549218893Sdim 1550218893Sdim/// \brief Write the header search block for the list of files that 1551218893Sdim/// 1552218893Sdim/// \param HS The header search structure to save. 1553235633Sdimvoid ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) { 1554226890Sdim SmallVector<const FileEntry *, 16> FilesByUID; 1555218893Sdim HS.getFileMgr().GetUniqueIDMapping(FilesByUID); 1556218893Sdim 1557218893Sdim if (FilesByUID.size() > HS.header_file_size()) 1558218893Sdim FilesByUID.resize(HS.header_file_size()); 1559218893Sdim 1560252723Sdim HeaderFileInfoTrait GeneratorTrait(*this, HS); 1561218893Sdim OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator; 1562226890Sdim SmallVector<const char *, 4> SavedStrings; 1563218893Sdim unsigned NumHeaderSearchEntries = 0; 1564218893Sdim for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { 1565218893Sdim const FileEntry *File = FilesByUID[UID]; 1566218893Sdim if (!File) 1567218893Sdim continue; 1568218893Sdim 1569235633Sdim // Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo 1570235633Sdim // from the external source if it was not provided already. 1571235633Sdim const HeaderFileInfo &HFI = HS.getFileInfo(File); 1572218893Sdim if (HFI.External && Chain) 1573218893Sdim continue; 1574263509Sdim if (HFI.isModuleHeader && !HFI.isCompilingModuleHeader) 1575263509Sdim continue; 1576218893Sdim 1577218893Sdim // Turn the file name into an absolute path, if it isn't already. 1578218893Sdim const char *Filename = File->getName(); 1579218893Sdim Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1580218893Sdim 1581218893Sdim // If we performed any translation on the file name at all, we need to 1582218893Sdim // save this string, since the generator will refer to it later. 1583218893Sdim if (Filename != File->getName()) { 1584218893Sdim Filename = strdup(Filename); 1585218893Sdim SavedStrings.push_back(Filename); 1586218893Sdim } 1587218893Sdim 1588252723Sdim HeaderFileInfoTrait::key_type key = { File, Filename }; 1589252723Sdim Generator.insert(key, HFI, GeneratorTrait); 1590218893Sdim ++NumHeaderSearchEntries; 1591218893Sdim } 1592218893Sdim 1593218893Sdim // Create the on-disk hash table in a buffer. 1594235633Sdim SmallString<4096> TableData; 1595218893Sdim uint32_t BucketOffset; 1596218893Sdim { 1597218893Sdim llvm::raw_svector_ostream Out(TableData); 1598218893Sdim // Make sure that no bucket is at offset 0 1599218893Sdim clang::io::Emit32(Out, 0); 1600218893Sdim BucketOffset = Generator.Emit(Out, GeneratorTrait); 1601218893Sdim } 1602218893Sdim 1603218893Sdim // Create a blob abbreviation 1604218893Sdim using namespace llvm; 1605218893Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1606218893Sdim Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); 1607218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1608218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1609226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1610218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1611218893Sdim unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); 1612218893Sdim 1613226890Sdim // Write the header search table 1614218893Sdim RecordData Record; 1615218893Sdim Record.push_back(HEADER_SEARCH_TABLE); 1616218893Sdim Record.push_back(BucketOffset); 1617218893Sdim Record.push_back(NumHeaderSearchEntries); 1618226890Sdim Record.push_back(TableData.size()); 1619226890Sdim TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); 1620218893Sdim Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str()); 1621218893Sdim 1622218893Sdim // Free all of the strings we had to duplicate. 1623218893Sdim for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) 1624252723Sdim free(const_cast<char *>(SavedStrings[I])); 1625218893Sdim} 1626218893Sdim 1627212795Sdim/// \brief Writes the block containing the serialized form of the 1628212795Sdim/// source manager. 1629212795Sdim/// 1630212795Sdim/// TODO: We should probably use an on-disk hash table (stored in a 1631212795Sdim/// blob), indexed based on the file name, so that we only create 1632212795Sdim/// entries for files that we actually need. In the common case (no 1633212795Sdim/// errors), we probably won't have to create file entries for any of 1634212795Sdim/// the files in the AST. 1635212795Sdimvoid ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, 1636212795Sdim const Preprocessor &PP, 1637226890Sdim StringRef isysroot) { 1638212795Sdim RecordData Record; 1639212795Sdim 1640212795Sdim // Enter the source manager block. 1641212795Sdim Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3); 1642212795Sdim 1643212795Sdim // Abbreviations for the various kinds of source-location entries. 1644212795Sdim unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); 1645212795Sdim unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); 1646212795Sdim unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); 1647224145Sdim unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); 1648212795Sdim 1649212795Sdim // Write out the source location entry table. We skip the first 1650212795Sdim // entry, which is always the same dummy entry. 1651212795Sdim std::vector<uint32_t> SLocEntryOffsets; 1652212795Sdim RecordData PreloadSLocs; 1653226890Sdim SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); 1654226890Sdim for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); 1655212795Sdim I != N; ++I) { 1656212795Sdim // Get this source location entry. 1657226890Sdim const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); 1658245431Sdim FileID FID = FileID::get(I); 1659245431Sdim assert(&SourceMgr.getSLocEntry(FID) == SLoc); 1660212795Sdim 1661212795Sdim // Record the offset of this source-location entry. 1662212795Sdim SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); 1663212795Sdim 1664212795Sdim // Figure out which record code to use. 1665212795Sdim unsigned Code; 1666212795Sdim if (SLoc->isFile()) { 1667235633Sdim const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); 1668235633Sdim if (Cache->OrigEntry) { 1669212795Sdim Code = SM_SLOC_FILE_ENTRY; 1670223017Sdim } else 1671212795Sdim Code = SM_SLOC_BUFFER_ENTRY; 1672212795Sdim } else 1673224145Sdim Code = SM_SLOC_EXPANSION_ENTRY; 1674212795Sdim Record.clear(); 1675212795Sdim Record.push_back(Code); 1676212795Sdim 1677226890Sdim // Starting offset of this entry within this module, so skip the dummy. 1678226890Sdim Record.push_back(SLoc->getOffset() - 2); 1679212795Sdim if (SLoc->isFile()) { 1680212795Sdim const SrcMgr::FileInfo &File = SLoc->getFile(); 1681212795Sdim Record.push_back(File.getIncludeLoc().getRawEncoding()); 1682212795Sdim Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding 1683212795Sdim Record.push_back(File.hasLineDirectives()); 1684212795Sdim 1685212795Sdim const SrcMgr::ContentCache *Content = File.getContentCache(); 1686221345Sdim if (Content->OrigEntry) { 1687221345Sdim assert(Content->OrigEntry == Content->ContentsEntry && 1688235633Sdim "Writing to AST an overridden file is not supported"); 1689221345Sdim 1690245431Sdim // The source location entry is a file. Emit input file ID. 1691245431Sdim assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry"); 1692245431Sdim Record.push_back(InputFileIDs[Content->OrigEntry]); 1693212795Sdim 1694226890Sdim Record.push_back(File.NumCreatedFIDs); 1695235633Sdim 1696245431Sdim FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID); 1697235633Sdim if (FDI != FileDeclIDs.end()) { 1698235633Sdim Record.push_back(FDI->second->FirstDeclIndex); 1699235633Sdim Record.push_back(FDI->second->DeclIDs.size()); 1700235633Sdim } else { 1701235633Sdim Record.push_back(0); 1702235633Sdim Record.push_back(0); 1703235633Sdim } 1704235633Sdim 1705245431Sdim Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); 1706235633Sdim 1707235633Sdim if (Content->BufferOverridden) { 1708235633Sdim Record.clear(); 1709235633Sdim Record.push_back(SM_SLOC_BUFFER_BLOB); 1710235633Sdim const llvm::MemoryBuffer *Buffer 1711235633Sdim = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1712235633Sdim Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, 1713235633Sdim StringRef(Buffer->getBufferStart(), 1714235633Sdim Buffer->getBufferSize() + 1)); 1715235633Sdim } 1716212795Sdim } else { 1717212795Sdim // The source location entry is a buffer. The blob associated 1718212795Sdim // with this entry contains the contents of the buffer. 1719212795Sdim 1720212795Sdim // We add one to the size so that we capture the trailing NULL 1721212795Sdim // that is required by llvm::MemoryBuffer::getMemBuffer (on 1722212795Sdim // the reader side). 1723212795Sdim const llvm::MemoryBuffer *Buffer 1724212795Sdim = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1725212795Sdim const char *Name = Buffer->getBufferIdentifier(); 1726212795Sdim Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, 1727226890Sdim StringRef(Name, strlen(Name) + 1)); 1728212795Sdim Record.clear(); 1729212795Sdim Record.push_back(SM_SLOC_BUFFER_BLOB); 1730212795Sdim Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, 1731226890Sdim StringRef(Buffer->getBufferStart(), 1732212795Sdim Buffer->getBufferSize() + 1)); 1733212795Sdim 1734226890Sdim if (strcmp(Name, "<built-in>") == 0) { 1735226890Sdim PreloadSLocs.push_back(SLocEntryOffsets.size()); 1736226890Sdim } 1737212795Sdim } 1738212795Sdim } else { 1739224145Sdim // The source location entry is a macro expansion. 1740226890Sdim const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); 1741226890Sdim Record.push_back(Expansion.getSpellingLoc().getRawEncoding()); 1742226890Sdim Record.push_back(Expansion.getExpansionLocStart().getRawEncoding()); 1743226890Sdim Record.push_back(Expansion.isMacroArgExpansion() ? 0 1744226890Sdim : Expansion.getExpansionLocEnd().getRawEncoding()); 1745212795Sdim 1746212795Sdim // Compute the token length for this macro expansion. 1747226890Sdim unsigned NextOffset = SourceMgr.getNextLocalOffset(); 1748212795Sdim if (I + 1 != N) 1749226890Sdim NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); 1750212795Sdim Record.push_back(NextOffset - SLoc->getOffset() - 1); 1751224145Sdim Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); 1752212795Sdim } 1753212795Sdim } 1754212795Sdim 1755212795Sdim Stream.ExitBlock(); 1756212795Sdim 1757212795Sdim if (SLocEntryOffsets.empty()) 1758212795Sdim return; 1759212795Sdim 1760212795Sdim // Write the source-location offsets table into the AST block. This 1761212795Sdim // table is used for lazily loading source-location information. 1762212795Sdim using namespace llvm; 1763212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 1764212795Sdim Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); 1765212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 1766226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size 1767212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 1768212795Sdim unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); 1769212795Sdim 1770212795Sdim Record.clear(); 1771212795Sdim Record.push_back(SOURCE_LOCATION_OFFSETS); 1772212795Sdim Record.push_back(SLocEntryOffsets.size()); 1773226890Sdim Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy 1774221345Sdim Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(SLocEntryOffsets)); 1775212795Sdim 1776212795Sdim // Write the source location entry preloads array, telling the AST 1777212795Sdim // reader which source locations entries it should load eagerly. 1778212795Sdim Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); 1779226890Sdim 1780226890Sdim // Write the line table. It depends on remapping working, so it must come 1781226890Sdim // after the source location offsets. 1782226890Sdim if (SourceMgr.hasLineTable()) { 1783226890Sdim LineTableInfo &LineTable = SourceMgr.getLineTable(); 1784226890Sdim 1785226890Sdim Record.clear(); 1786226890Sdim // Emit the file names 1787226890Sdim Record.push_back(LineTable.getNumFilenames()); 1788226890Sdim for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) { 1789226890Sdim // Emit the file name 1790226890Sdim const char *Filename = LineTable.getFilename(I); 1791226890Sdim Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); 1792226890Sdim unsigned FilenameLen = Filename? strlen(Filename) : 0; 1793226890Sdim Record.push_back(FilenameLen); 1794226890Sdim if (FilenameLen) 1795226890Sdim Record.insert(Record.end(), Filename, Filename + FilenameLen); 1796226890Sdim } 1797226890Sdim 1798226890Sdim // Emit the line entries 1799226890Sdim for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); 1800226890Sdim L != LEnd; ++L) { 1801226890Sdim // Only emit entries for local files. 1802245431Sdim if (L->first.ID < 0) 1803226890Sdim continue; 1804226890Sdim 1805226890Sdim // Emit the file ID 1806245431Sdim Record.push_back(L->first.ID); 1807226890Sdim 1808226890Sdim // Emit the line entries 1809226890Sdim Record.push_back(L->second.size()); 1810226890Sdim for (std::vector<LineEntry>::iterator LE = L->second.begin(), 1811226890Sdim LEEnd = L->second.end(); 1812226890Sdim LE != LEEnd; ++LE) { 1813226890Sdim Record.push_back(LE->FileOffset); 1814226890Sdim Record.push_back(LE->LineNo); 1815226890Sdim Record.push_back(LE->FilenameID); 1816226890Sdim Record.push_back((unsigned)LE->FileKind); 1817226890Sdim Record.push_back(LE->IncludeOffset); 1818226890Sdim } 1819226890Sdim } 1820226890Sdim Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); 1821226890Sdim } 1822212795Sdim} 1823212795Sdim 1824212795Sdim//===----------------------------------------------------------------------===// 1825212795Sdim// Preprocessor Serialization 1826212795Sdim//===----------------------------------------------------------------------===// 1827212795Sdim 1828252723Sdimnamespace { 1829252723Sdimclass ASTMacroTableTrait { 1830252723Sdimpublic: 1831252723Sdim typedef IdentID key_type; 1832252723Sdim typedef key_type key_type_ref; 1833252723Sdim 1834252723Sdim struct Data { 1835252723Sdim uint32_t MacroDirectivesOffset; 1836252723Sdim }; 1837252723Sdim 1838252723Sdim typedef Data data_type; 1839252723Sdim typedef const data_type &data_type_ref; 1840252723Sdim 1841252723Sdim static unsigned ComputeHash(IdentID IdID) { 1842252723Sdim return llvm::hash_value(IdID); 1843252723Sdim } 1844252723Sdim 1845252723Sdim std::pair<unsigned,unsigned> 1846252723Sdim static EmitKeyDataLength(raw_ostream& Out, 1847252723Sdim key_type_ref Key, data_type_ref Data) { 1848252723Sdim unsigned KeyLen = 4; // IdentID. 1849252723Sdim unsigned DataLen = 4; // MacroDirectivesOffset. 1850252723Sdim return std::make_pair(KeyLen, DataLen); 1851252723Sdim } 1852252723Sdim 1853252723Sdim static void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) { 1854252723Sdim clang::io::Emit32(Out, Key); 1855252723Sdim } 1856252723Sdim 1857252723Sdim static void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data, 1858252723Sdim unsigned) { 1859252723Sdim clang::io::Emit32(Out, Data.MacroDirectivesOffset); 1860252723Sdim } 1861252723Sdim}; 1862252723Sdim} // end anonymous namespace 1863252723Sdim 1864263509Sdimstatic int compareMacroDirectives( 1865263509Sdim const std::pair<const IdentifierInfo *, MacroDirective *> *X, 1866263509Sdim const std::pair<const IdentifierInfo *, MacroDirective *> *Y) { 1867263509Sdim return X->first->getName().compare(Y->first->getName()); 1868218893Sdim} 1869218893Sdim 1870252723Sdimstatic bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, 1871252723Sdim const Preprocessor &PP) { 1872252723Sdim if (MacroInfo *MI = MD->getMacroInfo()) 1873252723Sdim if (MI->isBuiltinMacro()) 1874252723Sdim return true; 1875252723Sdim 1876252723Sdim if (IsModule) { 1877252723Sdim SourceLocation Loc = MD->getLocation(); 1878252723Sdim if (Loc.isInvalid()) 1879252723Sdim return true; 1880252723Sdim if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID()) 1881252723Sdim return true; 1882252723Sdim } 1883252723Sdim 1884252723Sdim return false; 1885252723Sdim} 1886252723Sdim 1887212795Sdim/// \brief Writes the block containing the serialized form of the 1888212795Sdim/// preprocessor. 1889212795Sdim/// 1890226890Sdimvoid ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { 1891226890Sdim PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 1892226890Sdim if (PPRec) 1893226890Sdim WritePreprocessorDetail(*PPRec); 1894226890Sdim 1895212795Sdim RecordData Record; 1896212795Sdim 1897212795Sdim // If the preprocessor __COUNTER__ value has been bumped, remember it. 1898212795Sdim if (PP.getCounterValue() != 0) { 1899212795Sdim Record.push_back(PP.getCounterValue()); 1900212795Sdim Stream.EmitRecord(PP_COUNTER_VALUE, Record); 1901212795Sdim Record.clear(); 1902212795Sdim } 1903212795Sdim 1904212795Sdim // Enter the preprocessor block. 1905218893Sdim Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); 1906212795Sdim 1907212795Sdim // If the AST file contains __DATE__ or __TIME__ emit a warning about this. 1908212795Sdim // FIXME: use diagnostics subsystem for localization etc. 1909212795Sdim if (PP.SawDateOrTime()) 1910212795Sdim fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); 1911212795Sdim 1912218893Sdim 1913252723Sdim // Loop over all the macro directives that are live at the end of the file, 1914212795Sdim // emitting each to the PP section. 1915218893Sdim 1916252723Sdim // Construct the list of macro directives that need to be serialized. 1917252723Sdim SmallVector<std::pair<const IdentifierInfo *, MacroDirective *>, 2> 1918252723Sdim MacroDirectives; 1919252723Sdim for (Preprocessor::macro_iterator 1920252723Sdim I = PP.macro_begin(/*IncludeExternalMacros=*/false), 1921252723Sdim E = PP.macro_end(/*IncludeExternalMacros=*/false); 1922212795Sdim I != E; ++I) { 1923252723Sdim MacroDirectives.push_back(std::make_pair(I->first, I->second)); 1924218893Sdim } 1925245431Sdim 1926218893Sdim // Sort the set of macro definitions that need to be serialized by the 1927218893Sdim // name of the macro, to provide a stable ordering. 1928252723Sdim llvm::array_pod_sort(MacroDirectives.begin(), MacroDirectives.end(), 1929252723Sdim &compareMacroDirectives); 1930245431Sdim 1931252723Sdim OnDiskChainedHashTableGenerator<ASTMacroTableTrait> Generator; 1932252723Sdim 1933252723Sdim // Emit the macro directives as a list and associate the offset with the 1934252723Sdim // identifier they belong to. 1935252723Sdim for (unsigned I = 0, N = MacroDirectives.size(); I != N; ++I) { 1936252723Sdim const IdentifierInfo *Name = MacroDirectives[I].first; 1937252723Sdim uint64_t MacroDirectiveOffset = Stream.GetCurrentBitNo(); 1938252723Sdim MacroDirective *MD = MacroDirectives[I].second; 1939252723Sdim 1940252723Sdim // If the macro or identifier need no updates, don't write the macro history 1941252723Sdim // for this one. 1942252723Sdim // FIXME: Chain the macro history instead of re-writing it. 1943252723Sdim if (MD->isFromPCH() && 1944252723Sdim Name->isFromAST() && !Name->hasChangedSinceDeserialization()) 1945252723Sdim continue; 1946252723Sdim 1947252723Sdim // Emit the macro directives in reverse source order. 1948252723Sdim for (; MD; MD = MD->getPrevious()) { 1949252723Sdim if (MD->isHidden()) 1950252723Sdim continue; 1951252723Sdim if (shouldIgnoreMacro(MD, IsModule, PP)) 1952252723Sdim continue; 1953252723Sdim 1954252723Sdim AddSourceLocation(MD->getLocation(), Record); 1955252723Sdim Record.push_back(MD->getKind()); 1956252723Sdim if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) { 1957252723Sdim MacroID InfoID = getMacroRef(DefMD->getInfo(), Name); 1958252723Sdim Record.push_back(InfoID); 1959252723Sdim Record.push_back(DefMD->isImported()); 1960252723Sdim Record.push_back(DefMD->isAmbiguous()); 1961252723Sdim 1962252723Sdim } else if (VisibilityMacroDirective * 1963252723Sdim VisMD = dyn_cast<VisibilityMacroDirective>(MD)) { 1964252723Sdim Record.push_back(VisMD->isPublic()); 1965252723Sdim } 1966252723Sdim } 1967252723Sdim if (Record.empty()) 1968252723Sdim continue; 1969252723Sdim 1970252723Sdim Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record); 1971252723Sdim Record.clear(); 1972252723Sdim 1973252723Sdim IdentMacroDirectivesOffsetMap[Name] = MacroDirectiveOffset; 1974252723Sdim 1975252723Sdim IdentID NameID = getIdentifierRef(Name); 1976252723Sdim ASTMacroTableTrait::Data data; 1977252723Sdim data.MacroDirectivesOffset = MacroDirectiveOffset; 1978252723Sdim Generator.insert(NameID, data); 1979252723Sdim } 1980252723Sdim 1981245431Sdim /// \brief Offsets of each of the macros into the bitstream, indexed by 1982245431Sdim /// the local macro ID 1983245431Sdim /// 1984245431Sdim /// For each identifier that is associated with a macro, this map 1985245431Sdim /// provides the offset into the bitstream where that macro is 1986245431Sdim /// defined. 1987245431Sdim std::vector<uint32_t> MacroOffsets; 1988245431Sdim 1989252723Sdim for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) { 1990252723Sdim const IdentifierInfo *Name = MacroInfosToEmit[I].Name; 1991252723Sdim MacroInfo *MI = MacroInfosToEmit[I].MI; 1992252723Sdim MacroID ID = MacroInfosToEmit[I].ID; 1993218893Sdim 1994252723Sdim if (ID < FirstMacroID) { 1995252723Sdim assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?"); 1996252723Sdim continue; 1997252723Sdim } 1998212795Sdim 1999252723Sdim // Record the local offset of this macro. 2000252723Sdim unsigned Index = ID - FirstMacroID; 2001252723Sdim if (Index == MacroOffsets.size()) 2002252723Sdim MacroOffsets.push_back(Stream.GetCurrentBitNo()); 2003252723Sdim else { 2004252723Sdim if (Index > MacroOffsets.size()) 2005252723Sdim MacroOffsets.resize(Index + 1); 2006212795Sdim 2007252723Sdim MacroOffsets[Index] = Stream.GetCurrentBitNo(); 2008252723Sdim } 2009218893Sdim 2010252723Sdim AddIdentifierRef(Name, Record); 2011252723Sdim Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc())); 2012252723Sdim AddSourceLocation(MI->getDefinitionLoc(), Record); 2013252723Sdim AddSourceLocation(MI->getDefinitionEndLoc(), Record); 2014252723Sdim Record.push_back(MI->isUsed()); 2015252723Sdim unsigned Code; 2016252723Sdim if (MI->isObjectLike()) { 2017252723Sdim Code = PP_MACRO_OBJECT_LIKE; 2018252723Sdim } else { 2019252723Sdim Code = PP_MACRO_FUNCTION_LIKE; 2020218893Sdim 2021252723Sdim Record.push_back(MI->isC99Varargs()); 2022252723Sdim Record.push_back(MI->isGNUVarargs()); 2023252723Sdim Record.push_back(MI->hasCommaPasting()); 2024252723Sdim Record.push_back(MI->getNumArgs()); 2025252723Sdim for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end(); 2026252723Sdim I != E; ++I) 2027252723Sdim AddIdentifierRef(*I, Record); 2028252723Sdim } 2029212795Sdim 2030252723Sdim // If we have a detailed preprocessing record, record the macro definition 2031252723Sdim // ID that corresponds to this macro. 2032252723Sdim if (PPRec) 2033252723Sdim Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); 2034212795Sdim 2035252723Sdim Stream.EmitRecord(Code, Record); 2036252723Sdim Record.clear(); 2037212795Sdim 2038252723Sdim // Emit the tokens array. 2039252723Sdim for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { 2040252723Sdim // Note that we know that the preprocessor does not have any annotation 2041252723Sdim // tokens in it because they are created by the parser, and thus can't 2042252723Sdim // be in a macro definition. 2043252723Sdim const Token &Tok = MI->getReplacementToken(TokNo); 2044252723Sdim AddToken(Tok, Record); 2045252723Sdim Stream.EmitRecord(PP_TOKEN, Record); 2046212795Sdim Record.clear(); 2047252723Sdim } 2048252723Sdim ++NumMacros; 2049252723Sdim } 2050245431Sdim 2051252723Sdim Stream.ExitBlock(); 2052245431Sdim 2053252723Sdim // Create the on-disk hash table in a buffer. 2054252723Sdim SmallString<4096> MacroTable; 2055252723Sdim uint32_t BucketOffset; 2056252723Sdim { 2057252723Sdim llvm::raw_svector_ostream Out(MacroTable); 2058252723Sdim // Make sure that no bucket is at offset 0 2059252723Sdim clang::io::Emit32(Out, 0); 2060252723Sdim BucketOffset = Generator.Emit(Out); 2061252723Sdim } 2062245431Sdim 2063252723Sdim // Write the macro table 2064252723Sdim using namespace llvm; 2065252723Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2066252723Sdim Abbrev->Add(BitCodeAbbrevOp(MACRO_TABLE)); 2067252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2068252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2069252723Sdim unsigned MacroTableAbbrev = Stream.EmitAbbrev(Abbrev); 2070245431Sdim 2071252723Sdim Record.push_back(MACRO_TABLE); 2072252723Sdim Record.push_back(BucketOffset); 2073252723Sdim Stream.EmitRecordWithBlob(MacroTableAbbrev, Record, MacroTable.str()); 2074252723Sdim Record.clear(); 2075245431Sdim 2076245431Sdim // Write the offsets table for macro IDs. 2077245431Sdim using namespace llvm; 2078252723Sdim Abbrev = new BitCodeAbbrev(); 2079245431Sdim Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET)); 2080245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros 2081245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 2082245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2083245431Sdim 2084245431Sdim unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2085245431Sdim Record.clear(); 2086245431Sdim Record.push_back(MACRO_OFFSET); 2087245431Sdim Record.push_back(MacroOffsets.size()); 2088245431Sdim Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS); 2089245431Sdim Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, 2090245431Sdim data(MacroOffsets)); 2091218893Sdim} 2092218893Sdim 2093218893Sdimvoid ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { 2094226890Sdim if (PPRec.local_begin() == PPRec.local_end()) 2095218893Sdim return; 2096226890Sdim 2097226890Sdim SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets; 2098226890Sdim 2099218893Sdim // Enter the preprocessor block. 2100218893Sdim Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); 2101218893Sdim 2102212795Sdim // If the preprocessor has a preprocessing record, emit it. 2103212795Sdim unsigned NumPreprocessingRecords = 0; 2104218893Sdim using namespace llvm; 2105218893Sdim 2106218893Sdim // Set up the abbreviation for 2107218893Sdim unsigned InclusionAbbrev = 0; 2108218893Sdim { 2109218893Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2110218893Sdim Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); 2111218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length 2112218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes 2113218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind 2114245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module 2115218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2116218893Sdim InclusionAbbrev = Stream.EmitAbbrev(Abbrev); 2117218893Sdim } 2118218893Sdim 2119226890Sdim unsigned FirstPreprocessorEntityID 2120226890Sdim = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) 2121226890Sdim + NUM_PREDEF_PP_ENTITY_IDS; 2122226890Sdim unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; 2123218893Sdim RecordData Record; 2124226890Sdim for (PreprocessingRecord::iterator E = PPRec.local_begin(), 2125226890Sdim EEnd = PPRec.local_end(); 2126226890Sdim E != EEnd; 2127226890Sdim (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { 2128218893Sdim Record.clear(); 2129218893Sdim 2130226890Sdim PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(), 2131226890Sdim Stream.GetCurrentBitNo())); 2132226890Sdim 2133218893Sdim if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) { 2134226890Sdim // Record this macro definition's ID. 2135226890Sdim MacroDefinitions[MD] = NextPreprocessorEntityID; 2136212795Sdim 2137218893Sdim AddIdentifierRef(MD->getName(), Record); 2138218893Sdim Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); 2139218893Sdim continue; 2140212795Sdim } 2141218893Sdim 2142224145Sdim if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) { 2143226890Sdim Record.push_back(ME->isBuiltinMacro()); 2144226890Sdim if (ME->isBuiltinMacro()) 2145226890Sdim AddIdentifierRef(ME->getName(), Record); 2146226890Sdim else 2147226890Sdim Record.push_back(MacroDefinitions[ME->getDefinition()]); 2148224145Sdim Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); 2149218893Sdim continue; 2150218893Sdim } 2151218893Sdim 2152218893Sdim if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) { 2153218893Sdim Record.push_back(PPD_INCLUSION_DIRECTIVE); 2154218893Sdim Record.push_back(ID->getFileName().size()); 2155218893Sdim Record.push_back(ID->wasInQuotes()); 2156218893Sdim Record.push_back(static_cast<unsigned>(ID->getKind())); 2157245431Sdim Record.push_back(ID->importedModule()); 2158235633Sdim SmallString<64> Buffer; 2159218893Sdim Buffer += ID->getFileName(); 2160235633Sdim // Check that the FileEntry is not null because it was not resolved and 2161235633Sdim // we create a PCH even with compiler errors. 2162235633Sdim if (ID->getFile()) 2163235633Sdim Buffer += ID->getFile()->getName(); 2164218893Sdim Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); 2165218893Sdim continue; 2166218893Sdim } 2167218893Sdim 2168218893Sdim llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); 2169212795Sdim } 2170212795Sdim Stream.ExitBlock(); 2171218893Sdim 2172212795Sdim // Write the offsets table for the preprocessing record. 2173212795Sdim if (NumPreprocessingRecords > 0) { 2174226890Sdim assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); 2175226890Sdim 2176212795Sdim // Write the offsets table for identifier IDs. 2177212795Sdim using namespace llvm; 2178212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2179226890Sdim Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); 2180226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity 2181212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2182226890Sdim unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2183218893Sdim 2184212795Sdim Record.clear(); 2185226890Sdim Record.push_back(PPD_ENTITIES_OFFSETS); 2186226890Sdim Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS); 2187226890Sdim Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, 2188226890Sdim data(PreprocessedEntityOffsets)); 2189212795Sdim } 2190212795Sdim} 2191212795Sdim 2192235633Sdimunsigned ASTWriter::getSubmoduleID(Module *Mod) { 2193235633Sdim llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod); 2194235633Sdim if (Known != SubmoduleIDs.end()) 2195235633Sdim return Known->second; 2196235633Sdim 2197235633Sdim return SubmoduleIDs[Mod] = NextSubmoduleID++; 2198235633Sdim} 2199235633Sdim 2200252723Sdimunsigned ASTWriter::getExistingSubmoduleID(Module *Mod) const { 2201252723Sdim if (!Mod) 2202252723Sdim return 0; 2203252723Sdim 2204252723Sdim llvm::DenseMap<Module *, unsigned>::const_iterator 2205252723Sdim Known = SubmoduleIDs.find(Mod); 2206252723Sdim if (Known != SubmoduleIDs.end()) 2207252723Sdim return Known->second; 2208252723Sdim 2209252723Sdim return 0; 2210252723Sdim} 2211252723Sdim 2212235633Sdim/// \brief Compute the number of modules within the given tree (including the 2213235633Sdim/// given module). 2214235633Sdimstatic unsigned getNumberOfModules(Module *Mod) { 2215235633Sdim unsigned ChildModules = 0; 2216235633Sdim for (Module::submodule_iterator Sub = Mod->submodule_begin(), 2217235633Sdim SubEnd = Mod->submodule_end(); 2218235633Sdim Sub != SubEnd; ++Sub) 2219235633Sdim ChildModules += getNumberOfModules(*Sub); 2220235633Sdim 2221235633Sdim return ChildModules + 1; 2222235633Sdim} 2223235633Sdim 2224235633Sdimvoid ASTWriter::WriteSubmodules(Module *WritingModule) { 2225235633Sdim // Determine the dependencies of our module and each of it's submodules. 2226235633Sdim // FIXME: This feels like it belongs somewhere else, but there are no 2227235633Sdim // other consumers of this information. 2228235633Sdim SourceManager &SrcMgr = PP->getSourceManager(); 2229235633Sdim ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); 2230235633Sdim for (ASTContext::import_iterator I = Context->local_import_begin(), 2231235633Sdim IEnd = Context->local_import_end(); 2232235633Sdim I != IEnd; ++I) { 2233235633Sdim if (Module *ImportedFrom 2234235633Sdim = ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(), 2235235633Sdim SrcMgr))) { 2236235633Sdim ImportedFrom->Imports.push_back(I->getImportedModule()); 2237235633Sdim } 2238235633Sdim } 2239235633Sdim 2240235633Sdim // Enter the submodule description block. 2241235633Sdim Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); 2242235633Sdim 2243235633Sdim // Write the abbreviations needed for the submodules block. 2244235633Sdim using namespace llvm; 2245235633Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2246235633Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); 2247235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID 2248235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent 2249235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 2250235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit 2251235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem 2252235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... 2253235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... 2254235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... 2255252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh... 2256235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2257235633Sdim unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); 2258235633Sdim 2259235633Sdim Abbrev = new BitCodeAbbrev(); 2260235633Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); 2261235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2262235633Sdim unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); 2263235633Sdim 2264235633Sdim Abbrev = new BitCodeAbbrev(); 2265235633Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); 2266235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2267235633Sdim unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2268235633Sdim 2269235633Sdim Abbrev = new BitCodeAbbrev(); 2270245431Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER)); 2271245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2272245431Sdim unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2273245431Sdim 2274245431Sdim Abbrev = new BitCodeAbbrev(); 2275235633Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); 2276235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2277235633Sdim unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev); 2278235633Sdim 2279235633Sdim Abbrev = new BitCodeAbbrev(); 2280235633Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); 2281263509Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State 2282263509Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature 2283235633Sdim unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev); 2284235633Sdim 2285245431Sdim Abbrev = new BitCodeAbbrev(); 2286245431Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER)); 2287245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2288245431Sdim unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2289245431Sdim 2290252723Sdim Abbrev = new BitCodeAbbrev(); 2291263509Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER)); 2292263509Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2293263509Sdim unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2294263509Sdim 2295263509Sdim Abbrev = new BitCodeAbbrev(); 2296252723Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY)); 2297252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 2298252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2299252723Sdim unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev); 2300252723Sdim 2301252723Sdim Abbrev = new BitCodeAbbrev(); 2302252723Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO)); 2303252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name 2304252723Sdim unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev); 2305252723Sdim 2306252723Sdim Abbrev = new BitCodeAbbrev(); 2307252723Sdim Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT)); 2308252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module 2309252723Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message 2310252723Sdim unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev); 2311252723Sdim 2312235633Sdim // Write the submodule metadata block. 2313235633Sdim RecordData Record; 2314235633Sdim Record.push_back(getNumberOfModules(WritingModule)); 2315235633Sdim Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS); 2316235633Sdim Stream.EmitRecord(SUBMODULE_METADATA, Record); 2317235633Sdim 2318235633Sdim // Write all of the submodules. 2319235633Sdim std::queue<Module *> Q; 2320235633Sdim Q.push(WritingModule); 2321235633Sdim while (!Q.empty()) { 2322235633Sdim Module *Mod = Q.front(); 2323235633Sdim Q.pop(); 2324235633Sdim unsigned ID = getSubmoduleID(Mod); 2325235633Sdim 2326235633Sdim // Emit the definition of the block. 2327235633Sdim Record.clear(); 2328235633Sdim Record.push_back(SUBMODULE_DEFINITION); 2329235633Sdim Record.push_back(ID); 2330235633Sdim if (Mod->Parent) { 2331235633Sdim assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); 2332235633Sdim Record.push_back(SubmoduleIDs[Mod->Parent]); 2333235633Sdim } else { 2334235633Sdim Record.push_back(0); 2335235633Sdim } 2336235633Sdim Record.push_back(Mod->IsFramework); 2337235633Sdim Record.push_back(Mod->IsExplicit); 2338235633Sdim Record.push_back(Mod->IsSystem); 2339235633Sdim Record.push_back(Mod->InferSubmodules); 2340235633Sdim Record.push_back(Mod->InferExplicitSubmodules); 2341235633Sdim Record.push_back(Mod->InferExportWildcard); 2342252723Sdim Record.push_back(Mod->ConfigMacrosExhaustive); 2343235633Sdim Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); 2344235633Sdim 2345235633Sdim // Emit the requirements. 2346263509Sdim for (unsigned I = 0, N = Mod->Requirements.size(); I != N; ++I) { 2347235633Sdim Record.clear(); 2348235633Sdim Record.push_back(SUBMODULE_REQUIRES); 2349263509Sdim Record.push_back(Mod->Requirements[I].second); 2350235633Sdim Stream.EmitRecordWithBlob(RequiresAbbrev, Record, 2351263509Sdim Mod->Requirements[I].first); 2352235633Sdim } 2353235633Sdim 2354235633Sdim // Emit the umbrella header, if there is one. 2355235633Sdim if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) { 2356235633Sdim Record.clear(); 2357235633Sdim Record.push_back(SUBMODULE_UMBRELLA_HEADER); 2358235633Sdim Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, 2359235633Sdim UmbrellaHeader->getName()); 2360235633Sdim } else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) { 2361235633Sdim Record.clear(); 2362235633Sdim Record.push_back(SUBMODULE_UMBRELLA_DIR); 2363235633Sdim Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, 2364235633Sdim UmbrellaDir->getName()); 2365235633Sdim } 2366235633Sdim 2367235633Sdim // Emit the headers. 2368263509Sdim for (unsigned I = 0, N = Mod->NormalHeaders.size(); I != N; ++I) { 2369235633Sdim Record.clear(); 2370235633Sdim Record.push_back(SUBMODULE_HEADER); 2371235633Sdim Stream.EmitRecordWithBlob(HeaderAbbrev, Record, 2372263509Sdim Mod->NormalHeaders[I]->getName()); 2373235633Sdim } 2374245431Sdim // Emit the excluded headers. 2375245431Sdim for (unsigned I = 0, N = Mod->ExcludedHeaders.size(); I != N; ++I) { 2376245431Sdim Record.clear(); 2377245431Sdim Record.push_back(SUBMODULE_EXCLUDED_HEADER); 2378245431Sdim Stream.EmitRecordWithBlob(ExcludedHeaderAbbrev, Record, 2379245431Sdim Mod->ExcludedHeaders[I]->getName()); 2380245431Sdim } 2381263509Sdim // Emit the private headers. 2382263509Sdim for (unsigned I = 0, N = Mod->PrivateHeaders.size(); I != N; ++I) { 2383263509Sdim Record.clear(); 2384263509Sdim Record.push_back(SUBMODULE_PRIVATE_HEADER); 2385263509Sdim Stream.EmitRecordWithBlob(PrivateHeaderAbbrev, Record, 2386263509Sdim Mod->PrivateHeaders[I]->getName()); 2387263509Sdim } 2388252723Sdim ArrayRef<const FileEntry *> 2389252723Sdim TopHeaders = Mod->getTopHeaders(PP->getFileManager()); 2390252723Sdim for (unsigned I = 0, N = TopHeaders.size(); I != N; ++I) { 2391245431Sdim Record.clear(); 2392245431Sdim Record.push_back(SUBMODULE_TOPHEADER); 2393245431Sdim Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, 2394252723Sdim TopHeaders[I]->getName()); 2395245431Sdim } 2396235633Sdim 2397235633Sdim // Emit the imports. 2398235633Sdim if (!Mod->Imports.empty()) { 2399235633Sdim Record.clear(); 2400235633Sdim for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { 2401235633Sdim unsigned ImportedID = getSubmoduleID(Mod->Imports[I]); 2402235633Sdim assert(ImportedID && "Unknown submodule!"); 2403235633Sdim Record.push_back(ImportedID); 2404235633Sdim } 2405235633Sdim Stream.EmitRecord(SUBMODULE_IMPORTS, Record); 2406235633Sdim } 2407235633Sdim 2408235633Sdim // Emit the exports. 2409235633Sdim if (!Mod->Exports.empty()) { 2410235633Sdim Record.clear(); 2411235633Sdim for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { 2412235633Sdim if (Module *Exported = Mod->Exports[I].getPointer()) { 2413235633Sdim unsigned ExportedID = SubmoduleIDs[Exported]; 2414235633Sdim assert(ExportedID > 0 && "Unknown submodule ID?"); 2415235633Sdim Record.push_back(ExportedID); 2416235633Sdim } else { 2417235633Sdim Record.push_back(0); 2418235633Sdim } 2419235633Sdim 2420235633Sdim Record.push_back(Mod->Exports[I].getInt()); 2421235633Sdim } 2422235633Sdim Stream.EmitRecord(SUBMODULE_EXPORTS, Record); 2423235633Sdim } 2424252723Sdim 2425263509Sdim //FIXME: How do we emit the 'use'd modules? They may not be submodules. 2426263509Sdim // Might be unnecessary as use declarations are only used to build the 2427263509Sdim // module itself. 2428263509Sdim 2429252723Sdim // Emit the link libraries. 2430252723Sdim for (unsigned I = 0, N = Mod->LinkLibraries.size(); I != N; ++I) { 2431252723Sdim Record.clear(); 2432252723Sdim Record.push_back(SUBMODULE_LINK_LIBRARY); 2433252723Sdim Record.push_back(Mod->LinkLibraries[I].IsFramework); 2434252723Sdim Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, 2435252723Sdim Mod->LinkLibraries[I].Library); 2436252723Sdim } 2437252723Sdim 2438252723Sdim // Emit the conflicts. 2439252723Sdim for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { 2440252723Sdim Record.clear(); 2441252723Sdim Record.push_back(SUBMODULE_CONFLICT); 2442252723Sdim unsigned OtherID = getSubmoduleID(Mod->Conflicts[I].Other); 2443252723Sdim assert(OtherID && "Unknown submodule!"); 2444252723Sdim Record.push_back(OtherID); 2445252723Sdim Stream.EmitRecordWithBlob(ConflictAbbrev, Record, 2446252723Sdim Mod->Conflicts[I].Message); 2447252723Sdim } 2448252723Sdim 2449252723Sdim // Emit the configuration macros. 2450252723Sdim for (unsigned I = 0, N = Mod->ConfigMacros.size(); I != N; ++I) { 2451252723Sdim Record.clear(); 2452252723Sdim Record.push_back(SUBMODULE_CONFIG_MACRO); 2453252723Sdim Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, 2454252723Sdim Mod->ConfigMacros[I]); 2455252723Sdim } 2456252723Sdim 2457235633Sdim // Queue up the submodules of this module. 2458235633Sdim for (Module::submodule_iterator Sub = Mod->submodule_begin(), 2459235633Sdim SubEnd = Mod->submodule_end(); 2460235633Sdim Sub != SubEnd; ++Sub) 2461235633Sdim Q.push(*Sub); 2462235633Sdim } 2463235633Sdim 2464235633Sdim Stream.ExitBlock(); 2465235633Sdim 2466235633Sdim assert((NextSubmoduleID - FirstSubmoduleID 2467235633Sdim == getNumberOfModules(WritingModule)) && "Wrong # of submodules"); 2468235633Sdim} 2469235633Sdim 2470235633Sdimserialization::SubmoduleID 2471235633SdimASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { 2472235633Sdim if (Loc.isInvalid() || !WritingModule) 2473235633Sdim return 0; // No submodule 2474235633Sdim 2475235633Sdim // Find the module that owns this location. 2476235633Sdim ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); 2477235633Sdim Module *OwningMod 2478235633Sdim = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); 2479235633Sdim if (!OwningMod) 2480235633Sdim return 0; 2481235633Sdim 2482235633Sdim // Check whether this submodule is part of our own module. 2483235633Sdim if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule)) 2484235633Sdim return 0; 2485235633Sdim 2486235633Sdim return getSubmoduleID(OwningMod); 2487235633Sdim} 2488235633Sdim 2489252723Sdimvoid ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, 2490252723Sdim bool isModule) { 2491252723Sdim // Make sure set diagnostic pragmas don't affect the translation unit that 2492252723Sdim // imports the module. 2493252723Sdim // FIXME: Make diagnostic pragma sections work properly with modules. 2494252723Sdim if (isModule) 2495252723Sdim return; 2496252723Sdim 2497245431Sdim llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64> 2498245431Sdim DiagStateIDMap; 2499245431Sdim unsigned CurrID = 0; 2500245431Sdim DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one. 2501218893Sdim RecordData Record; 2502226890Sdim for (DiagnosticsEngine::DiagStatePointsTy::const_iterator 2503218893Sdim I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); 2504218893Sdim I != E; ++I) { 2505245431Sdim const DiagnosticsEngine::DiagStatePoint &point = *I; 2506218893Sdim if (point.Loc.isInvalid()) 2507218893Sdim continue; 2508218893Sdim 2509218893Sdim Record.push_back(point.Loc.getRawEncoding()); 2510245431Sdim unsigned &DiagStateID = DiagStateIDMap[point.State]; 2511245431Sdim Record.push_back(DiagStateID); 2512245431Sdim 2513245431Sdim if (DiagStateID == 0) { 2514245431Sdim DiagStateID = ++CurrID; 2515245431Sdim for (DiagnosticsEngine::DiagState::const_iterator 2516245431Sdim I = point.State->begin(), E = point.State->end(); I != E; ++I) { 2517245431Sdim if (I->second.isPragma()) { 2518245431Sdim Record.push_back(I->first); 2519245431Sdim Record.push_back(I->second.getMapping()); 2520245431Sdim } 2521218893Sdim } 2522245431Sdim Record.push_back(-1); // mark the end of the diag/map pairs for this 2523245431Sdim // location. 2524218893Sdim } 2525218893Sdim } 2526218893Sdim 2527218893Sdim if (!Record.empty()) 2528218893Sdim Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); 2529218893Sdim} 2530218893Sdim 2531221345Sdimvoid ASTWriter::WriteCXXBaseSpecifiersOffsets() { 2532221345Sdim if (CXXBaseSpecifiersOffsets.empty()) 2533221345Sdim return; 2534221345Sdim 2535221345Sdim RecordData Record; 2536221345Sdim 2537221345Sdim // Create a blob abbreviation for the C++ base specifiers offsets. 2538221345Sdim using namespace llvm; 2539221345Sdim 2540221345Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2541221345Sdim Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS)); 2542221345Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 2543221345Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2544221345Sdim unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2545221345Sdim 2546226890Sdim // Write the base specifier offsets table. 2547221345Sdim Record.clear(); 2548221345Sdim Record.push_back(CXX_BASE_SPECIFIER_OFFSETS); 2549221345Sdim Record.push_back(CXXBaseSpecifiersOffsets.size()); 2550221345Sdim Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record, 2551221345Sdim data(CXXBaseSpecifiersOffsets)); 2552221345Sdim} 2553221345Sdim 2554212795Sdim//===----------------------------------------------------------------------===// 2555212795Sdim// Type Serialization 2556212795Sdim//===----------------------------------------------------------------------===// 2557212795Sdim 2558212795Sdim/// \brief Write the representation of a type to the AST stream. 2559212795Sdimvoid ASTWriter::WriteType(QualType T) { 2560212795Sdim TypeIdx &Idx = TypeIdxs[T]; 2561212795Sdim if (Idx.getIndex() == 0) // we haven't seen this type before. 2562212795Sdim Idx = TypeIdx(NextTypeID++); 2563212795Sdim 2564218893Sdim assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); 2565218893Sdim 2566212795Sdim // Record the offset for this type. 2567212795Sdim unsigned Index = Idx.getIndex() - FirstTypeID; 2568212795Sdim if (TypeOffsets.size() == Index) 2569212795Sdim TypeOffsets.push_back(Stream.GetCurrentBitNo()); 2570212795Sdim else if (TypeOffsets.size() < Index) { 2571212795Sdim TypeOffsets.resize(Index + 1); 2572212795Sdim TypeOffsets[Index] = Stream.GetCurrentBitNo(); 2573212795Sdim } 2574212795Sdim 2575212795Sdim RecordData Record; 2576212795Sdim 2577212795Sdim // Emit the type's representation. 2578212795Sdim ASTTypeWriter W(*this, Record); 2579212795Sdim 2580212795Sdim if (T.hasLocalNonFastQualifiers()) { 2581212795Sdim Qualifiers Qs = T.getLocalQualifiers(); 2582212795Sdim AddTypeRef(T.getLocalUnqualifiedType(), Record); 2583212795Sdim Record.push_back(Qs.getAsOpaqueValue()); 2584212795Sdim W.Code = TYPE_EXT_QUAL; 2585212795Sdim } else { 2586212795Sdim switch (T->getTypeClass()) { 2587212795Sdim // For all of the concrete, non-dependent types, call the 2588212795Sdim // appropriate visitor function. 2589212795Sdim#define TYPE(Class, Base) \ 2590212795Sdim case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break; 2591212795Sdim#define ABSTRACT_TYPE(Class, Base) 2592212795Sdim#include "clang/AST/TypeNodes.def" 2593212795Sdim } 2594212795Sdim } 2595212795Sdim 2596212795Sdim // Emit the serialized record. 2597212795Sdim Stream.EmitRecord(W.Code, Record); 2598212795Sdim 2599212795Sdim // Flush any expressions that were written as part of this type. 2600212795Sdim FlushStmts(); 2601212795Sdim} 2602212795Sdim 2603212795Sdim//===----------------------------------------------------------------------===// 2604212795Sdim// Declaration Serialization 2605212795Sdim//===----------------------------------------------------------------------===// 2606212795Sdim 2607212795Sdim/// \brief Write the block containing all of the declaration IDs 2608212795Sdim/// lexically declared within the given DeclContext. 2609212795Sdim/// 2610212795Sdim/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the 2611212795Sdim/// bistream, or 0 if no block was written. 2612212795Sdimuint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, 2613212795Sdim DeclContext *DC) { 2614212795Sdim if (DC->decls_empty()) 2615212795Sdim return 0; 2616212795Sdim 2617212795Sdim uint64_t Offset = Stream.GetCurrentBitNo(); 2618212795Sdim RecordData Record; 2619212795Sdim Record.push_back(DECL_CONTEXT_LEXICAL); 2620226890Sdim SmallVector<KindDeclIDPair, 64> Decls; 2621212795Sdim for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); 2622212795Sdim D != DEnd; ++D) 2623218893Sdim Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D))); 2624212795Sdim 2625212795Sdim ++NumLexicalDeclContexts; 2626221345Sdim Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls)); 2627212795Sdim return Offset; 2628212795Sdim} 2629212795Sdim 2630212795Sdimvoid ASTWriter::WriteTypeDeclOffsets() { 2631212795Sdim using namespace llvm; 2632212795Sdim RecordData Record; 2633212795Sdim 2634212795Sdim // Write the type offsets array 2635212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2636212795Sdim Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); 2637212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types 2638226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index 2639212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block 2640212795Sdim unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2641212795Sdim Record.clear(); 2642212795Sdim Record.push_back(TYPE_OFFSET); 2643212795Sdim Record.push_back(TypeOffsets.size()); 2644226890Sdim Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS); 2645221345Sdim Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets)); 2646212795Sdim 2647212795Sdim // Write the declaration offsets array 2648212795Sdim Abbrev = new BitCodeAbbrev(); 2649212795Sdim Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); 2650212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations 2651226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID 2652212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block 2653212795Sdim unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2654212795Sdim Record.clear(); 2655212795Sdim Record.push_back(DECL_OFFSET); 2656212795Sdim Record.push_back(DeclOffsets.size()); 2657226890Sdim Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS); 2658221345Sdim Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets)); 2659212795Sdim} 2660212795Sdim 2661235633Sdimvoid ASTWriter::WriteFileDeclIDsMap() { 2662235633Sdim using namespace llvm; 2663235633Sdim RecordData Record; 2664235633Sdim 2665235633Sdim // Join the vectors of DeclIDs from all files. 2666235633Sdim SmallVector<DeclID, 256> FileSortedIDs; 2667235633Sdim for (FileDeclIDsTy::iterator 2668235633Sdim FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) { 2669235633Sdim DeclIDInFileInfo &Info = *FI->second; 2670235633Sdim Info.FirstDeclIndex = FileSortedIDs.size(); 2671235633Sdim for (LocDeclIDsTy::iterator 2672235633Sdim DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI) 2673235633Sdim FileSortedIDs.push_back(DI->second); 2674235633Sdim } 2675235633Sdim 2676235633Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2677235633Sdim Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); 2678245431Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2679235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2680235633Sdim unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 2681235633Sdim Record.push_back(FILE_SORTED_DECLS); 2682245431Sdim Record.push_back(FileSortedIDs.size()); 2683235633Sdim Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs)); 2684235633Sdim} 2685235633Sdim 2686245431Sdimvoid ASTWriter::WriteComments() { 2687245431Sdim Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3); 2688245431Sdim ArrayRef<RawComment *> RawComments = Context->Comments.getComments(); 2689245431Sdim RecordData Record; 2690245431Sdim for (ArrayRef<RawComment *>::iterator I = RawComments.begin(), 2691245431Sdim E = RawComments.end(); 2692245431Sdim I != E; ++I) { 2693245431Sdim Record.clear(); 2694245431Sdim AddSourceRange((*I)->getSourceRange(), Record); 2695245431Sdim Record.push_back((*I)->getKind()); 2696245431Sdim Record.push_back((*I)->isTrailingComment()); 2697245431Sdim Record.push_back((*I)->isAlmostTrailingComment()); 2698245431Sdim Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record); 2699245431Sdim } 2700245431Sdim Stream.ExitBlock(); 2701245431Sdim} 2702245431Sdim 2703212795Sdim//===----------------------------------------------------------------------===// 2704212795Sdim// Global Method Pool and Selector Serialization 2705212795Sdim//===----------------------------------------------------------------------===// 2706212795Sdim 2707212795Sdimnamespace { 2708212795Sdim// Trait used for the on-disk hash table used in the method pool. 2709212795Sdimclass ASTMethodPoolTrait { 2710212795Sdim ASTWriter &Writer; 2711212795Sdim 2712212795Sdimpublic: 2713212795Sdim typedef Selector key_type; 2714212795Sdim typedef key_type key_type_ref; 2715212795Sdim 2716212795Sdim struct data_type { 2717212795Sdim SelectorID ID; 2718212795Sdim ObjCMethodList Instance, Factory; 2719212795Sdim }; 2720212795Sdim typedef const data_type& data_type_ref; 2721212795Sdim 2722212795Sdim explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } 2723212795Sdim 2724212795Sdim static unsigned ComputeHash(Selector Sel) { 2725212795Sdim return serialization::ComputeHash(Sel); 2726212795Sdim } 2727212795Sdim 2728212795Sdim std::pair<unsigned,unsigned> 2729226890Sdim EmitKeyDataLength(raw_ostream& Out, Selector Sel, 2730212795Sdim data_type_ref Methods) { 2731212795Sdim unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); 2732212795Sdim clang::io::Emit16(Out, KeyLen); 2733212795Sdim unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts 2734212795Sdim for (const ObjCMethodList *Method = &Methods.Instance; Method; 2735252723Sdim Method = Method->getNext()) 2736212795Sdim if (Method->Method) 2737212795Sdim DataLen += 4; 2738212795Sdim for (const ObjCMethodList *Method = &Methods.Factory; Method; 2739252723Sdim Method = Method->getNext()) 2740212795Sdim if (Method->Method) 2741212795Sdim DataLen += 4; 2742212795Sdim clang::io::Emit16(Out, DataLen); 2743212795Sdim return std::make_pair(KeyLen, DataLen); 2744212795Sdim } 2745212795Sdim 2746226890Sdim void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { 2747212795Sdim uint64_t Start = Out.tell(); 2748212795Sdim assert((Start >> 32) == 0 && "Selector key offset too large"); 2749212795Sdim Writer.SetSelectorOffset(Sel, Start); 2750212795Sdim unsigned N = Sel.getNumArgs(); 2751212795Sdim clang::io::Emit16(Out, N); 2752212795Sdim if (N == 0) 2753212795Sdim N = 1; 2754212795Sdim for (unsigned I = 0; I != N; ++I) 2755212795Sdim clang::io::Emit32(Out, 2756212795Sdim Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); 2757212795Sdim } 2758212795Sdim 2759226890Sdim void EmitData(raw_ostream& Out, key_type_ref, 2760212795Sdim data_type_ref Methods, unsigned DataLen) { 2761212795Sdim uint64_t Start = Out.tell(); (void)Start; 2762212795Sdim clang::io::Emit32(Out, Methods.ID); 2763212795Sdim unsigned NumInstanceMethods = 0; 2764212795Sdim for (const ObjCMethodList *Method = &Methods.Instance; Method; 2765252723Sdim Method = Method->getNext()) 2766212795Sdim if (Method->Method) 2767212795Sdim ++NumInstanceMethods; 2768212795Sdim 2769212795Sdim unsigned NumFactoryMethods = 0; 2770212795Sdim for (const ObjCMethodList *Method = &Methods.Factory; Method; 2771252723Sdim Method = Method->getNext()) 2772212795Sdim if (Method->Method) 2773212795Sdim ++NumFactoryMethods; 2774212795Sdim 2775252723Sdim unsigned InstanceBits = Methods.Instance.getBits(); 2776252723Sdim assert(InstanceBits < 4); 2777252723Sdim unsigned NumInstanceMethodsAndBits = 2778252723Sdim (NumInstanceMethods << 2) | InstanceBits; 2779252723Sdim unsigned FactoryBits = Methods.Factory.getBits(); 2780252723Sdim assert(FactoryBits < 4); 2781252723Sdim unsigned NumFactoryMethodsAndBits = (NumFactoryMethods << 2) | FactoryBits; 2782252723Sdim clang::io::Emit16(Out, NumInstanceMethodsAndBits); 2783252723Sdim clang::io::Emit16(Out, NumFactoryMethodsAndBits); 2784212795Sdim for (const ObjCMethodList *Method = &Methods.Instance; Method; 2785252723Sdim Method = Method->getNext()) 2786212795Sdim if (Method->Method) 2787212795Sdim clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 2788212795Sdim for (const ObjCMethodList *Method = &Methods.Factory; Method; 2789252723Sdim Method = Method->getNext()) 2790212795Sdim if (Method->Method) 2791212795Sdim clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); 2792212795Sdim 2793212795Sdim assert(Out.tell() - Start == DataLen && "Data length is wrong"); 2794212795Sdim } 2795212795Sdim}; 2796212795Sdim} // end anonymous namespace 2797212795Sdim 2798212795Sdim/// \brief Write ObjC data: selectors and the method pool. 2799212795Sdim/// 2800212795Sdim/// The method pool contains both instance and factory methods, stored 2801212795Sdim/// in an on-disk hash table indexed by the selector. The hash table also 2802212795Sdim/// contains an empty entry for every other selector known to Sema. 2803212795Sdimvoid ASTWriter::WriteSelectors(Sema &SemaRef) { 2804212795Sdim using namespace llvm; 2805212795Sdim 2806212795Sdim // Do we have to do anything at all? 2807212795Sdim if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) 2808212795Sdim return; 2809212795Sdim unsigned NumTableEntries = 0; 2810212795Sdim // Create and write out the blob that contains selectors and the method pool. 2811212795Sdim { 2812212795Sdim OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator; 2813212795Sdim ASTMethodPoolTrait Trait(*this); 2814212795Sdim 2815212795Sdim // Create the on-disk hash table representation. We walk through every 2816212795Sdim // selector we've seen and look it up in the method pool. 2817212795Sdim SelectorOffsets.resize(NextSelectorID - FirstSelectorID); 2818212795Sdim for (llvm::DenseMap<Selector, SelectorID>::iterator 2819212795Sdim I = SelectorIDs.begin(), E = SelectorIDs.end(); 2820212795Sdim I != E; ++I) { 2821212795Sdim Selector S = I->first; 2822212795Sdim Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); 2823212795Sdim ASTMethodPoolTrait::data_type Data = { 2824212795Sdim I->second, 2825212795Sdim ObjCMethodList(), 2826212795Sdim ObjCMethodList() 2827212795Sdim }; 2828212795Sdim if (F != SemaRef.MethodPool.end()) { 2829212795Sdim Data.Instance = F->second.first; 2830212795Sdim Data.Factory = F->second.second; 2831212795Sdim } 2832212795Sdim // Only write this selector if it's not in an existing AST or something 2833212795Sdim // changed. 2834212795Sdim if (Chain && I->second < FirstSelectorID) { 2835212795Sdim // Selector already exists. Did it change? 2836212795Sdim bool changed = false; 2837212795Sdim for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method; 2838252723Sdim M = M->getNext()) { 2839226890Sdim if (!M->Method->isFromASTFile()) 2840212795Sdim changed = true; 2841212795Sdim } 2842212795Sdim for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method; 2843252723Sdim M = M->getNext()) { 2844226890Sdim if (!M->Method->isFromASTFile()) 2845212795Sdim changed = true; 2846212795Sdim } 2847212795Sdim if (!changed) 2848212795Sdim continue; 2849212795Sdim } else if (Data.Instance.Method || Data.Factory.Method) { 2850212795Sdim // A new method pool entry. 2851212795Sdim ++NumTableEntries; 2852212795Sdim } 2853212795Sdim Generator.insert(S, Data, Trait); 2854212795Sdim } 2855212795Sdim 2856212795Sdim // Create the on-disk hash table in a buffer. 2857235633Sdim SmallString<4096> MethodPool; 2858212795Sdim uint32_t BucketOffset; 2859212795Sdim { 2860212795Sdim ASTMethodPoolTrait Trait(*this); 2861212795Sdim llvm::raw_svector_ostream Out(MethodPool); 2862212795Sdim // Make sure that no bucket is at offset 0 2863212795Sdim clang::io::Emit32(Out, 0); 2864212795Sdim BucketOffset = Generator.Emit(Out, Trait); 2865212795Sdim } 2866212795Sdim 2867212795Sdim // Create a blob abbreviation 2868212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 2869212795Sdim Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); 2870212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2871212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2872212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2873212795Sdim unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); 2874212795Sdim 2875212795Sdim // Write the method pool 2876212795Sdim RecordData Record; 2877212795Sdim Record.push_back(METHOD_POOL); 2878212795Sdim Record.push_back(BucketOffset); 2879212795Sdim Record.push_back(NumTableEntries); 2880212795Sdim Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str()); 2881212795Sdim 2882212795Sdim // Create a blob abbreviation for the selector table offsets. 2883212795Sdim Abbrev = new BitCodeAbbrev(); 2884212795Sdim Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); 2885218893Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 2886226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 2887212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2888212795Sdim unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2889212795Sdim 2890212795Sdim // Write the selector offsets table. 2891212795Sdim Record.clear(); 2892212795Sdim Record.push_back(SELECTOR_OFFSETS); 2893212795Sdim Record.push_back(SelectorOffsets.size()); 2894226890Sdim Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS); 2895212795Sdim Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, 2896221345Sdim data(SelectorOffsets)); 2897212795Sdim } 2898212795Sdim} 2899212795Sdim 2900212795Sdim/// \brief Write the selectors referenced in @selector expression into AST file. 2901212795Sdimvoid ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { 2902212795Sdim using namespace llvm; 2903212795Sdim if (SemaRef.ReferencedSelectors.empty()) 2904212795Sdim return; 2905212795Sdim 2906212795Sdim RecordData Record; 2907212795Sdim 2908212795Sdim // Note: this writes out all references even for a dependent AST. But it is 2909212795Sdim // very tricky to fix, and given that @selector shouldn't really appear in 2910212795Sdim // headers, probably not worth it. It's not a correctness issue. 2911212795Sdim for (DenseMap<Selector, SourceLocation>::iterator S = 2912212795Sdim SemaRef.ReferencedSelectors.begin(), 2913212795Sdim E = SemaRef.ReferencedSelectors.end(); S != E; ++S) { 2914212795Sdim Selector Sel = (*S).first; 2915212795Sdim SourceLocation Loc = (*S).second; 2916212795Sdim AddSelectorRef(Sel, Record); 2917212795Sdim AddSourceLocation(Loc, Record); 2918212795Sdim } 2919212795Sdim Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record); 2920212795Sdim} 2921212795Sdim 2922212795Sdim//===----------------------------------------------------------------------===// 2923212795Sdim// Identifier Table Serialization 2924212795Sdim//===----------------------------------------------------------------------===// 2925212795Sdim 2926212795Sdimnamespace { 2927212795Sdimclass ASTIdentifierTableTrait { 2928212795Sdim ASTWriter &Writer; 2929212795Sdim Preprocessor &PP; 2930235633Sdim IdentifierResolver &IdResolver; 2931226890Sdim bool IsModule; 2932226890Sdim 2933212795Sdim /// \brief Determines whether this is an "interesting" identifier 2934212795Sdim /// that needs a full IdentifierInfo structure written into the hash 2935212795Sdim /// table. 2936252723Sdim bool isInterestingIdentifier(IdentifierInfo *II, MacroDirective *&Macro) { 2937226890Sdim if (II->isPoisoned() || 2938226890Sdim II->isExtensionToken() || 2939226890Sdim II->getObjCOrBuiltinID() || 2940235633Sdim II->hasRevertedTokenIDToIdentifier() || 2941226890Sdim II->getFETokenInfo<void>()) 2942226890Sdim return true; 2943226890Sdim 2944245431Sdim return hadMacroDefinition(II, Macro); 2945212795Sdim } 2946245431Sdim 2947252723Sdim bool hadMacroDefinition(IdentifierInfo *II, MacroDirective *&Macro) { 2948245431Sdim if (!II->hadMacroDefinition()) 2949226890Sdim return false; 2950245431Sdim 2951252723Sdim if (Macro || (Macro = PP.getMacroDirectiveHistory(II))) { 2952252723Sdim if (!IsModule) 2953252723Sdim return !shouldIgnoreMacro(Macro, IsModule, PP); 2954252723Sdim SubmoduleID ModID; 2955252723Sdim if (getFirstPublicSubmoduleMacro(Macro, ModID)) 2956252723Sdim return true; 2957252723Sdim } 2958245431Sdim 2959245431Sdim return false; 2960226890Sdim } 2961212795Sdim 2962252723Sdim DefMacroDirective *getFirstPublicSubmoduleMacro(MacroDirective *MD, 2963252723Sdim SubmoduleID &ModID) { 2964252723Sdim ModID = 0; 2965252723Sdim if (DefMacroDirective *DefMD = getPublicSubmoduleMacro(MD, ModID)) 2966252723Sdim if (!shouldIgnoreMacro(DefMD, IsModule, PP)) 2967252723Sdim return DefMD; 2968252723Sdim return 0; 2969252723Sdim } 2970252723Sdim 2971252723Sdim DefMacroDirective *getNextPublicSubmoduleMacro(DefMacroDirective *MD, 2972252723Sdim SubmoduleID &ModID) { 2973252723Sdim if (DefMacroDirective * 2974252723Sdim DefMD = getPublicSubmoduleMacro(MD->getPrevious(), ModID)) 2975252723Sdim if (!shouldIgnoreMacro(DefMD, IsModule, PP)) 2976252723Sdim return DefMD; 2977252723Sdim return 0; 2978252723Sdim } 2979252723Sdim 2980252723Sdim /// \brief Traverses the macro directives history and returns the latest 2981252723Sdim /// macro that is public and not undefined in the same submodule. 2982252723Sdim /// A macro that is defined in submodule A and undefined in submodule B, 2983252723Sdim /// will still be considered as defined/exported from submodule A. 2984252723Sdim DefMacroDirective *getPublicSubmoduleMacro(MacroDirective *MD, 2985252723Sdim SubmoduleID &ModID) { 2986252723Sdim if (!MD) 2987252723Sdim return 0; 2988252723Sdim 2989252723Sdim SubmoduleID OrigModID = ModID; 2990252723Sdim bool isUndefined = false; 2991252723Sdim Optional<bool> isPublic; 2992252723Sdim for (; MD; MD = MD->getPrevious()) { 2993252723Sdim if (MD->isHidden()) 2994252723Sdim continue; 2995252723Sdim 2996252723Sdim SubmoduleID ThisModID = getSubmoduleID(MD); 2997252723Sdim if (ThisModID == 0) { 2998252723Sdim isUndefined = false; 2999252723Sdim isPublic = Optional<bool>(); 3000252723Sdim continue; 3001252723Sdim } 3002252723Sdim if (ThisModID != ModID){ 3003252723Sdim ModID = ThisModID; 3004252723Sdim isUndefined = false; 3005252723Sdim isPublic = Optional<bool>(); 3006252723Sdim } 3007252723Sdim // We are looking for a definition in a different submodule than the one 3008252723Sdim // that we started with. If a submodule has re-definitions of the same 3009252723Sdim // macro, only the last definition will be used as the "exported" one. 3010252723Sdim if (ModID == OrigModID) 3011252723Sdim continue; 3012252723Sdim 3013252723Sdim if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) { 3014252723Sdim if (!isUndefined && (!isPublic.hasValue() || isPublic.getValue())) 3015252723Sdim return DefMD; 3016252723Sdim continue; 3017252723Sdim } 3018252723Sdim 3019252723Sdim if (isa<UndefMacroDirective>(MD)) { 3020252723Sdim isUndefined = true; 3021252723Sdim continue; 3022252723Sdim } 3023252723Sdim 3024252723Sdim VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD); 3025252723Sdim if (!isPublic.hasValue()) 3026252723Sdim isPublic = VisMD->isPublic(); 3027252723Sdim } 3028252723Sdim 3029252723Sdim return 0; 3030252723Sdim } 3031252723Sdim 3032252723Sdim SubmoduleID getSubmoduleID(MacroDirective *MD) { 3033252723Sdim if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) { 3034252723Sdim MacroInfo *MI = DefMD->getInfo(); 3035252723Sdim if (unsigned ID = MI->getOwningModuleID()) 3036252723Sdim return ID; 3037252723Sdim return Writer.inferSubmoduleIDFromLocation(MI->getDefinitionLoc()); 3038252723Sdim } 3039252723Sdim return Writer.inferSubmoduleIDFromLocation(MD->getLocation()); 3040252723Sdim } 3041252723Sdim 3042212795Sdimpublic: 3043226890Sdim typedef IdentifierInfo* key_type; 3044212795Sdim typedef key_type key_type_ref; 3045212795Sdim 3046212795Sdim typedef IdentID data_type; 3047212795Sdim typedef data_type data_type_ref; 3048212795Sdim 3049235633Sdim ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, 3050235633Sdim IdentifierResolver &IdResolver, bool IsModule) 3051235633Sdim : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { } 3052212795Sdim 3053212795Sdim static unsigned ComputeHash(const IdentifierInfo* II) { 3054212795Sdim return llvm::HashString(II->getName()); 3055212795Sdim } 3056212795Sdim 3057212795Sdim std::pair<unsigned,unsigned> 3058235633Sdim EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { 3059212795Sdim unsigned KeyLen = II->getLength() + 1; 3060212795Sdim unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 3061252723Sdim MacroDirective *Macro = 0; 3062226890Sdim if (isInterestingIdentifier(II, Macro)) { 3063245431Sdim DataLen += 2; // 2 bytes for builtin ID 3064245431Sdim DataLen += 2; // 2 bytes for flags 3065245431Sdim if (hadMacroDefinition(II, Macro)) { 3066252723Sdim DataLen += 4; // MacroDirectives offset. 3067252723Sdim if (IsModule) { 3068252723Sdim SubmoduleID ModID; 3069252723Sdim for (DefMacroDirective * 3070252723Sdim DefMD = getFirstPublicSubmoduleMacro(Macro, ModID); 3071252723Sdim DefMD; DefMD = getNextPublicSubmoduleMacro(DefMD, ModID)) { 3072252723Sdim DataLen += 4; // MacroInfo ID. 3073252723Sdim } 3074252723Sdim DataLen += 4; 3075245431Sdim } 3076245431Sdim } 3077245431Sdim 3078235633Sdim for (IdentifierResolver::iterator D = IdResolver.begin(II), 3079235633Sdim DEnd = IdResolver.end(); 3080212795Sdim D != DEnd; ++D) 3081212795Sdim DataLen += sizeof(DeclID); 3082212795Sdim } 3083212795Sdim clang::io::Emit16(Out, DataLen); 3084212795Sdim // We emit the key length after the data length so that every 3085212795Sdim // string is preceded by a 16-bit length. This matches the PTH 3086212795Sdim // format for storing identifiers. 3087212795Sdim clang::io::Emit16(Out, KeyLen); 3088212795Sdim return std::make_pair(KeyLen, DataLen); 3089212795Sdim } 3090212795Sdim 3091226890Sdim void EmitKey(raw_ostream& Out, const IdentifierInfo* II, 3092212795Sdim unsigned KeyLen) { 3093212795Sdim // Record the location of the key data. This is used when generating 3094212795Sdim // the mapping from persistent IDs to strings. 3095212795Sdim Writer.SetIdentifierOffset(II, Out.tell()); 3096212795Sdim Out.write(II->getNameStart(), KeyLen); 3097212795Sdim } 3098212795Sdim 3099226890Sdim void EmitData(raw_ostream& Out, IdentifierInfo* II, 3100212795Sdim IdentID ID, unsigned) { 3101252723Sdim MacroDirective *Macro = 0; 3102226890Sdim if (!isInterestingIdentifier(II, Macro)) { 3103212795Sdim clang::io::Emit32(Out, ID << 1); 3104212795Sdim return; 3105212795Sdim } 3106212795Sdim 3107212795Sdim clang::io::Emit32(Out, (ID << 1) | 0x01); 3108245431Sdim uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID(); 3109245431Sdim assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); 3110245431Sdim clang::io::Emit16(Out, Bits); 3111245431Sdim Bits = 0; 3112245431Sdim bool HadMacroDefinition = hadMacroDefinition(II, Macro); 3113245431Sdim Bits = (Bits << 1) | unsigned(HadMacroDefinition); 3114252723Sdim Bits = (Bits << 1) | unsigned(IsModule); 3115212795Sdim Bits = (Bits << 1) | unsigned(II->isExtensionToken()); 3116212795Sdim Bits = (Bits << 1) | unsigned(II->isPoisoned()); 3117212795Sdim Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); 3118212795Sdim Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); 3119212795Sdim clang::io::Emit16(Out, Bits); 3120212795Sdim 3121245431Sdim if (HadMacroDefinition) { 3122252723Sdim clang::io::Emit32(Out, Writer.getMacroDirectivesOffset(II)); 3123252723Sdim if (IsModule) { 3124252723Sdim // Write the IDs of macros coming from different submodules. 3125252723Sdim SubmoduleID ModID; 3126252723Sdim for (DefMacroDirective * 3127252723Sdim DefMD = getFirstPublicSubmoduleMacro(Macro, ModID); 3128252723Sdim DefMD; DefMD = getNextPublicSubmoduleMacro(DefMD, ModID)) { 3129252723Sdim MacroID InfoID = Writer.getMacroID(DefMD->getInfo()); 3130252723Sdim assert(InfoID); 3131252723Sdim clang::io::Emit32(Out, InfoID); 3132252723Sdim } 3133252723Sdim clang::io::Emit32(Out, 0); 3134245431Sdim } 3135235633Sdim } 3136245431Sdim 3137212795Sdim // Emit the declaration IDs in reverse order, because the 3138212795Sdim // IdentifierResolver provides the declarations as they would be 3139212795Sdim // visible (e.g., the function "stat" would come before the struct 3140235633Sdim // "stat"), but the ASTReader adds declarations to the end of the list 3141235633Sdim // (so we need to see the struct "status" before the function "status"). 3142212795Sdim // Only emit declarations that aren't from a chained PCH, though. 3143235633Sdim SmallVector<Decl *, 16> Decls(IdResolver.begin(II), 3144235633Sdim IdResolver.end()); 3145263509Sdim for (SmallVectorImpl<Decl *>::reverse_iterator D = Decls.rbegin(), 3146235633Sdim DEnd = Decls.rend(); 3147212795Sdim D != DEnd; ++D) 3148252723Sdim clang::io::Emit32(Out, Writer.getDeclID(getMostRecentLocalDecl(*D))); 3149212795Sdim } 3150252723Sdim 3151252723Sdim /// \brief Returns the most recent local decl or the given decl if there are 3152252723Sdim /// no local ones. The given decl is assumed to be the most recent one. 3153252723Sdim Decl *getMostRecentLocalDecl(Decl *Orig) { 3154252723Sdim // The only way a "from AST file" decl would be more recent from a local one 3155252723Sdim // is if it came from a module. 3156252723Sdim if (!PP.getLangOpts().Modules) 3157252723Sdim return Orig; 3158252723Sdim 3159252723Sdim // Look for a local in the decl chain. 3160252723Sdim for (Decl *D = Orig; D; D = D->getPreviousDecl()) { 3161252723Sdim if (!D->isFromASTFile()) 3162252723Sdim return D; 3163252723Sdim // If we come up a decl from a (chained-)PCH stop since we won't find a 3164252723Sdim // local one. 3165252723Sdim if (D->getOwningModuleID() == 0) 3166252723Sdim break; 3167252723Sdim } 3168252723Sdim 3169252723Sdim return Orig; 3170252723Sdim } 3171212795Sdim}; 3172212795Sdim} // end anonymous namespace 3173212795Sdim 3174212795Sdim/// \brief Write the identifier table into the AST file. 3175212795Sdim/// 3176212795Sdim/// The identifier table consists of a blob containing string data 3177212795Sdim/// (the actual identifiers themselves) and a separate "offsets" index 3178212795Sdim/// that maps identifier IDs to locations within the blob. 3179235633Sdimvoid ASTWriter::WriteIdentifierTable(Preprocessor &PP, 3180235633Sdim IdentifierResolver &IdResolver, 3181235633Sdim bool IsModule) { 3182212795Sdim using namespace llvm; 3183212795Sdim 3184212795Sdim // Create and write out the blob that contains the identifier 3185212795Sdim // strings. 3186212795Sdim { 3187212795Sdim OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; 3188235633Sdim ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); 3189212795Sdim 3190212795Sdim // Look for any identifiers that were named while processing the 3191212795Sdim // headers, but are otherwise not needed. We add these to the hash 3192212795Sdim // table to enable checking of the predefines buffer in the case 3193212795Sdim // where the user adds new macro definitions when building the AST 3194212795Sdim // file. 3195212795Sdim for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 3196212795Sdim IDEnd = PP.getIdentifierTable().end(); 3197212795Sdim ID != IDEnd; ++ID) 3198212795Sdim getIdentifierRef(ID->second); 3199212795Sdim 3200212795Sdim // Create the on-disk hash table representation. We only store offsets 3201212795Sdim // for identifiers that appear here for the first time. 3202212795Sdim IdentifierOffsets.resize(NextIdentID - FirstIdentID); 3203212795Sdim for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator 3204212795Sdim ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end(); 3205212795Sdim ID != IDEnd; ++ID) { 3206212795Sdim assert(ID->first && "NULL identifier in identifier table"); 3207235633Sdim if (!Chain || !ID->first->isFromAST() || 3208235633Sdim ID->first->hasChangedSinceDeserialization()) 3209252723Sdim Generator.insert(const_cast<IdentifierInfo *>(ID->first), ID->second, 3210226890Sdim Trait); 3211212795Sdim } 3212212795Sdim 3213212795Sdim // Create the on-disk hash table in a buffer. 3214235633Sdim SmallString<4096> IdentifierTable; 3215212795Sdim uint32_t BucketOffset; 3216212795Sdim { 3217235633Sdim ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule); 3218212795Sdim llvm::raw_svector_ostream Out(IdentifierTable); 3219212795Sdim // Make sure that no bucket is at offset 0 3220212795Sdim clang::io::Emit32(Out, 0); 3221212795Sdim BucketOffset = Generator.Emit(Out, Trait); 3222212795Sdim } 3223212795Sdim 3224212795Sdim // Create a blob abbreviation 3225212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 3226212795Sdim Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); 3227212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3228212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3229212795Sdim unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); 3230212795Sdim 3231212795Sdim // Write the identifier table 3232212795Sdim RecordData Record; 3233212795Sdim Record.push_back(IDENTIFIER_TABLE); 3234212795Sdim Record.push_back(BucketOffset); 3235212795Sdim Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str()); 3236212795Sdim } 3237212795Sdim 3238212795Sdim // Write the offsets table for identifier IDs. 3239212795Sdim BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 3240212795Sdim Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); 3241212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers 3242226890Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 3243212795Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3244212795Sdim unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 3245212795Sdim 3246252723Sdim#ifndef NDEBUG 3247252723Sdim for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) 3248252723Sdim assert(IdentifierOffsets[I] && "Missing identifier offset?"); 3249252723Sdim#endif 3250252723Sdim 3251212795Sdim RecordData Record; 3252212795Sdim Record.push_back(IDENTIFIER_OFFSET); 3253212795Sdim Record.push_back(IdentifierOffsets.size()); 3254226890Sdim Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS); 3255212795Sdim Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, 3256221345Sdim data(IdentifierOffsets)); 3257212795Sdim} 3258212795Sdim 3259212795Sdim//===----------------------------------------------------------------------===// 3260212795Sdim// DeclContext's Name Lookup Table Serialization 3261212795Sdim//===----------------------------------------------------------------------===// 3262212795Sdim 3263212795Sdimnamespace { 3264212795Sdim// Trait used for the on-disk hash table used in the method pool. 3265212795Sdimclass ASTDeclContextNameLookupTrait { 3266212795Sdim ASTWriter &Writer; 3267212795Sdim 3268212795Sdimpublic: 3269212795Sdim typedef DeclarationName key_type; 3270212795Sdim typedef key_type key_type_ref; 3271212795Sdim 3272212795Sdim typedef DeclContext::lookup_result data_type; 3273212795Sdim typedef const data_type& data_type_ref; 3274212795Sdim 3275212795Sdim explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } 3276212795Sdim 3277212795Sdim unsigned ComputeHash(DeclarationName Name) { 3278212795Sdim llvm::FoldingSetNodeID ID; 3279212795Sdim ID.AddInteger(Name.getNameKind()); 3280212795Sdim 3281212795Sdim switch (Name.getNameKind()) { 3282212795Sdim case DeclarationName::Identifier: 3283212795Sdim ID.AddString(Name.getAsIdentifierInfo()->getName()); 3284212795Sdim break; 3285212795Sdim case DeclarationName::ObjCZeroArgSelector: 3286212795Sdim case DeclarationName::ObjCOneArgSelector: 3287212795Sdim case DeclarationName::ObjCMultiArgSelector: 3288212795Sdim ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector())); 3289212795Sdim break; 3290212795Sdim case DeclarationName::CXXConstructorName: 3291212795Sdim case DeclarationName::CXXDestructorName: 3292212795Sdim case DeclarationName::CXXConversionFunctionName: 3293212795Sdim break; 3294212795Sdim case DeclarationName::CXXOperatorName: 3295212795Sdim ID.AddInteger(Name.getCXXOverloadedOperator()); 3296212795Sdim break; 3297212795Sdim case DeclarationName::CXXLiteralOperatorName: 3298212795Sdim ID.AddString(Name.getCXXLiteralIdentifier()->getName()); 3299212795Sdim case DeclarationName::CXXUsingDirective: 3300212795Sdim break; 3301212795Sdim } 3302212795Sdim 3303212795Sdim return ID.ComputeHash(); 3304212795Sdim } 3305212795Sdim 3306212795Sdim std::pair<unsigned,unsigned> 3307226890Sdim EmitKeyDataLength(raw_ostream& Out, DeclarationName Name, 3308212795Sdim data_type_ref Lookup) { 3309212795Sdim unsigned KeyLen = 1; 3310212795Sdim switch (Name.getNameKind()) { 3311212795Sdim case DeclarationName::Identifier: 3312212795Sdim case DeclarationName::ObjCZeroArgSelector: 3313212795Sdim case DeclarationName::ObjCOneArgSelector: 3314212795Sdim case DeclarationName::ObjCMultiArgSelector: 3315212795Sdim case DeclarationName::CXXLiteralOperatorName: 3316212795Sdim KeyLen += 4; 3317212795Sdim break; 3318212795Sdim case DeclarationName::CXXOperatorName: 3319212795Sdim KeyLen += 1; 3320212795Sdim break; 3321226890Sdim case DeclarationName::CXXConstructorName: 3322226890Sdim case DeclarationName::CXXDestructorName: 3323226890Sdim case DeclarationName::CXXConversionFunctionName: 3324212795Sdim case DeclarationName::CXXUsingDirective: 3325212795Sdim break; 3326212795Sdim } 3327212795Sdim clang::io::Emit16(Out, KeyLen); 3328212795Sdim 3329212795Sdim // 2 bytes for num of decls and 4 for each DeclID. 3330252723Sdim unsigned DataLen = 2 + 4 * Lookup.size(); 3331212795Sdim clang::io::Emit16(Out, DataLen); 3332212795Sdim 3333212795Sdim return std::make_pair(KeyLen, DataLen); 3334212795Sdim } 3335212795Sdim 3336226890Sdim void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) { 3337212795Sdim using namespace clang::io; 3338212795Sdim 3339212795Sdim Emit8(Out, Name.getNameKind()); 3340212795Sdim switch (Name.getNameKind()) { 3341212795Sdim case DeclarationName::Identifier: 3342212795Sdim Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo())); 3343245431Sdim return; 3344212795Sdim case DeclarationName::ObjCZeroArgSelector: 3345212795Sdim case DeclarationName::ObjCOneArgSelector: 3346212795Sdim case DeclarationName::ObjCMultiArgSelector: 3347212795Sdim Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector())); 3348245431Sdim return; 3349212795Sdim case DeclarationName::CXXOperatorName: 3350245431Sdim assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS && 3351245431Sdim "Invalid operator?"); 3352212795Sdim Emit8(Out, Name.getCXXOverloadedOperator()); 3353245431Sdim return; 3354212795Sdim case DeclarationName::CXXLiteralOperatorName: 3355212795Sdim Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier())); 3356245431Sdim return; 3357226890Sdim case DeclarationName::CXXConstructorName: 3358226890Sdim case DeclarationName::CXXDestructorName: 3359226890Sdim case DeclarationName::CXXConversionFunctionName: 3360212795Sdim case DeclarationName::CXXUsingDirective: 3361245431Sdim return; 3362212795Sdim } 3363245431Sdim 3364245431Sdim llvm_unreachable("Invalid name kind?"); 3365212795Sdim } 3366212795Sdim 3367226890Sdim void EmitData(raw_ostream& Out, key_type_ref, 3368212795Sdim data_type Lookup, unsigned DataLen) { 3369212795Sdim uint64_t Start = Out.tell(); (void)Start; 3370252723Sdim clang::io::Emit16(Out, Lookup.size()); 3371252723Sdim for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end(); 3372252723Sdim I != E; ++I) 3373252723Sdim clang::io::Emit32(Out, Writer.GetDeclRef(*I)); 3374212795Sdim 3375212795Sdim assert(Out.tell() - Start == DataLen && "Data length is wrong"); 3376212795Sdim } 3377212795Sdim}; 3378212795Sdim} // end anonymous namespace 3379212795Sdim 3380212795Sdim/// \brief Write the block containing all of the declaration IDs 3381212795Sdim/// visible from the given DeclContext. 3382212795Sdim/// 3383212795Sdim/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the 3384212795Sdim/// bitstream, or 0 if no block was written. 3385212795Sdimuint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, 3386212795Sdim DeclContext *DC) { 3387212795Sdim if (DC->getPrimaryContext() != DC) 3388212795Sdim return 0; 3389212795Sdim 3390212795Sdim // Since there is no name lookup into functions or methods, don't bother to 3391212795Sdim // build a visible-declarations table for these entities. 3392212795Sdim if (DC->isFunctionOrMethod()) 3393212795Sdim return 0; 3394212795Sdim 3395212795Sdim // If not in C++, we perform name lookup for the translation unit via the 3396212795Sdim // IdentifierInfo chains, don't bother to build a visible-declarations table. 3397235633Sdim if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) 3398212795Sdim return 0; 3399212795Sdim 3400212795Sdim // Serialize the contents of the mapping used for lookup. Note that, 3401212795Sdim // although we have two very different code paths, the serialized 3402212795Sdim // representation is the same for both cases: a declaration name, 3403212795Sdim // followed by a size, followed by references to the visible 3404212795Sdim // declarations that have that name. 3405212795Sdim uint64_t Offset = Stream.GetCurrentBitNo(); 3406235633Sdim StoredDeclsMap *Map = DC->buildLookup(); 3407212795Sdim if (!Map || Map->empty()) 3408212795Sdim return 0; 3409212795Sdim 3410212795Sdim OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator; 3411212795Sdim ASTDeclContextNameLookupTrait Trait(*this); 3412212795Sdim 3413212795Sdim // Create the on-disk hash table representation. 3414226890Sdim DeclarationName ConversionName; 3415252723Sdim SmallVector<NamedDecl *, 4> ConversionDecls; 3416212795Sdim for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 3417212795Sdim D != DEnd; ++D) { 3418212795Sdim DeclarationName Name = D->first; 3419212795Sdim DeclContext::lookup_result Result = D->second.getLookupResult(); 3420252723Sdim if (!Result.empty()) { 3421226890Sdim if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 3422226890Sdim // Hash all conversion function names to the same name. The actual 3423226890Sdim // type information in conversion function name is not used in the 3424226890Sdim // key (since such type information is not stable across different 3425226890Sdim // modules), so the intended effect is to coalesce all of the conversion 3426226890Sdim // functions under a single key. 3427226890Sdim if (!ConversionName) 3428226890Sdim ConversionName = Name; 3429252723Sdim ConversionDecls.append(Result.begin(), Result.end()); 3430226890Sdim continue; 3431226890Sdim } 3432226890Sdim 3433226890Sdim Generator.insert(Name, Result, Trait); 3434226890Sdim } 3435212795Sdim } 3436212795Sdim 3437226890Sdim // Add the conversion functions 3438226890Sdim if (!ConversionDecls.empty()) { 3439226890Sdim Generator.insert(ConversionName, 3440226890Sdim DeclContext::lookup_result(ConversionDecls.begin(), 3441226890Sdim ConversionDecls.end()), 3442226890Sdim Trait); 3443226890Sdim } 3444226890Sdim 3445212795Sdim // Create the on-disk hash table in a buffer. 3446235633Sdim SmallString<4096> LookupTable; 3447212795Sdim uint32_t BucketOffset; 3448212795Sdim { 3449212795Sdim llvm::raw_svector_ostream Out(LookupTable); 3450212795Sdim // Make sure that no bucket is at offset 0 3451212795Sdim clang::io::Emit32(Out, 0); 3452212795Sdim BucketOffset = Generator.Emit(Out, Trait); 3453212795Sdim } 3454212795Sdim 3455212795Sdim // Write the lookup table 3456212795Sdim RecordData Record; 3457212795Sdim Record.push_back(DECL_CONTEXT_VISIBLE); 3458212795Sdim Record.push_back(BucketOffset); 3459212795Sdim Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, 3460212795Sdim LookupTable.str()); 3461212795Sdim 3462212795Sdim Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record); 3463212795Sdim ++NumVisibleDeclContexts; 3464212795Sdim return Offset; 3465212795Sdim} 3466212795Sdim 3467212795Sdim/// \brief Write an UPDATE_VISIBLE block for the given context. 3468212795Sdim/// 3469212795Sdim/// UPDATE_VISIBLE blocks contain the declarations that are added to an existing 3470212795Sdim/// DeclContext in a dependent AST file. As such, they only exist for the TU 3471235633Sdim/// (in C++), for namespaces, and for classes with forward-declared unscoped 3472235633Sdim/// enumeration members (in C++11). 3473212795Sdimvoid ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { 3474212795Sdim StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr()); 3475212795Sdim if (!Map || Map->empty()) 3476212795Sdim return; 3477212795Sdim 3478212795Sdim OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator; 3479212795Sdim ASTDeclContextNameLookupTrait Trait(*this); 3480212795Sdim 3481212795Sdim // Create the hash table. 3482212795Sdim for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 3483212795Sdim D != DEnd; ++D) { 3484212795Sdim DeclarationName Name = D->first; 3485212795Sdim DeclContext::lookup_result Result = D->second.getLookupResult(); 3486212795Sdim // For any name that appears in this table, the results are complete, i.e. 3487212795Sdim // they overwrite results from previous PCHs. Merging is always a mess. 3488252723Sdim if (!Result.empty()) 3489226890Sdim Generator.insert(Name, Result, Trait); 3490212795Sdim } 3491212795Sdim 3492212795Sdim // Create the on-disk hash table in a buffer. 3493235633Sdim SmallString<4096> LookupTable; 3494212795Sdim uint32_t BucketOffset; 3495212795Sdim { 3496212795Sdim llvm::raw_svector_ostream Out(LookupTable); 3497212795Sdim // Make sure that no bucket is at offset 0 3498212795Sdim clang::io::Emit32(Out, 0); 3499212795Sdim BucketOffset = Generator.Emit(Out, Trait); 3500212795Sdim } 3501212795Sdim 3502212795Sdim // Write the lookup table 3503212795Sdim RecordData Record; 3504212795Sdim Record.push_back(UPDATE_VISIBLE); 3505212795Sdim Record.push_back(getDeclID(cast<Decl>(DC))); 3506212795Sdim Record.push_back(BucketOffset); 3507212795Sdim Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str()); 3508212795Sdim} 3509212795Sdim 3510218893Sdim/// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. 3511218893Sdimvoid ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { 3512212795Sdim RecordData Record; 3513218893Sdim Record.push_back(Opts.fp_contract); 3514218893Sdim Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); 3515212795Sdim} 3516212795Sdim 3517218893Sdim/// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. 3518218893Sdimvoid ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { 3519235633Sdim if (!SemaRef.Context.getLangOpts().OpenCL) 3520218893Sdim return; 3521218893Sdim 3522218893Sdim const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); 3523218893Sdim RecordData Record; 3524218893Sdim#define OPENCLEXT(nm) Record.push_back(Opts.nm); 3525218893Sdim#include "clang/Basic/OpenCLExtensions.def" 3526218893Sdim Stream.EmitRecord(OPENCL_EXTENSIONS, Record); 3527218893Sdim} 3528218893Sdim 3529235633Sdimvoid ASTWriter::WriteRedeclarations() { 3530235633Sdim RecordData LocalRedeclChains; 3531235633Sdim SmallVector<serialization::LocalRedeclarationsInfo, 2> LocalRedeclsMap; 3532235633Sdim 3533235633Sdim for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) { 3534235633Sdim Decl *First = Redeclarations[I]; 3535263509Sdim assert(First->isFirstDecl() && "Not the first declaration?"); 3536235633Sdim 3537235633Sdim Decl *MostRecent = First->getMostRecentDecl(); 3538235633Sdim 3539235633Sdim // If we only have a single declaration, there is no point in storing 3540235633Sdim // a redeclaration chain. 3541235633Sdim if (First == MostRecent) 3542235633Sdim continue; 3543235633Sdim 3544235633Sdim unsigned Offset = LocalRedeclChains.size(); 3545235633Sdim unsigned Size = 0; 3546235633Sdim LocalRedeclChains.push_back(0); // Placeholder for the size. 3547235633Sdim 3548235633Sdim // Collect the set of local redeclarations of this declaration. 3549252723Sdim for (Decl *Prev = MostRecent; Prev != First; 3550235633Sdim Prev = Prev->getPreviousDecl()) { 3551235633Sdim if (!Prev->isFromASTFile()) { 3552235633Sdim AddDeclRef(Prev, LocalRedeclChains); 3553235633Sdim ++Size; 3554235633Sdim } 3555235633Sdim } 3556252723Sdim 3557252723Sdim if (!First->isFromASTFile() && Chain) { 3558252723Sdim Decl *FirstFromAST = MostRecent; 3559252723Sdim for (Decl *Prev = MostRecent; Prev; Prev = Prev->getPreviousDecl()) { 3560252723Sdim if (Prev->isFromASTFile()) 3561252723Sdim FirstFromAST = Prev; 3562252723Sdim } 3563252723Sdim 3564252723Sdim Chain->MergedDecls[FirstFromAST].push_back(getDeclID(First)); 3565252723Sdim } 3566252723Sdim 3567235633Sdim LocalRedeclChains[Offset] = Size; 3568235633Sdim 3569235633Sdim // Reverse the set of local redeclarations, so that we store them in 3570235633Sdim // order (since we found them in reverse order). 3571235633Sdim std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end()); 3572235633Sdim 3573252723Sdim // Add the mapping from the first ID from the AST to the set of local 3574252723Sdim // declarations. 3575235633Sdim LocalRedeclarationsInfo Info = { getDeclID(First), Offset }; 3576235633Sdim LocalRedeclsMap.push_back(Info); 3577235633Sdim 3578235633Sdim assert(N == Redeclarations.size() && 3579235633Sdim "Deserialized a declaration we shouldn't have"); 3580235633Sdim } 3581235633Sdim 3582235633Sdim if (LocalRedeclChains.empty()) 3583235633Sdim return; 3584235633Sdim 3585235633Sdim // Sort the local redeclarations map by the first declaration ID, 3586235633Sdim // since the reader will be performing binary searches on this information. 3587235633Sdim llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end()); 3588235633Sdim 3589235633Sdim // Emit the local redeclarations map. 3590235633Sdim using namespace llvm; 3591235633Sdim llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 3592235633Sdim Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP)); 3593235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries 3594235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3595235633Sdim unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); 3596235633Sdim 3597235633Sdim RecordData Record; 3598235633Sdim Record.push_back(LOCAL_REDECLARATIONS_MAP); 3599235633Sdim Record.push_back(LocalRedeclsMap.size()); 3600235633Sdim Stream.EmitRecordWithBlob(AbbrevID, Record, 3601235633Sdim reinterpret_cast<char*>(LocalRedeclsMap.data()), 3602235633Sdim LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo)); 3603235633Sdim 3604235633Sdim // Emit the redeclaration chains. 3605235633Sdim Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains); 3606235633Sdim} 3607235633Sdim 3608235633Sdimvoid ASTWriter::WriteObjCCategories() { 3609252723Sdim SmallVector<ObjCCategoriesInfo, 2> CategoriesMap; 3610235633Sdim RecordData Categories; 3611235633Sdim 3612235633Sdim for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { 3613235633Sdim unsigned Size = 0; 3614235633Sdim unsigned StartIndex = Categories.size(); 3615235633Sdim 3616235633Sdim ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; 3617235633Sdim 3618235633Sdim // Allocate space for the size. 3619235633Sdim Categories.push_back(0); 3620235633Sdim 3621235633Sdim // Add the categories. 3622252723Sdim for (ObjCInterfaceDecl::known_categories_iterator 3623252723Sdim Cat = Class->known_categories_begin(), 3624252723Sdim CatEnd = Class->known_categories_end(); 3625252723Sdim Cat != CatEnd; ++Cat, ++Size) { 3626252723Sdim assert(getDeclID(*Cat) != 0 && "Bogus category"); 3627252723Sdim AddDeclRef(*Cat, Categories); 3628235633Sdim } 3629235633Sdim 3630235633Sdim // Update the size. 3631235633Sdim Categories[StartIndex] = Size; 3632235633Sdim 3633235633Sdim // Record this interface -> category map. 3634235633Sdim ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; 3635235633Sdim CategoriesMap.push_back(CatInfo); 3636235633Sdim } 3637235633Sdim 3638235633Sdim // Sort the categories map by the definition ID, since the reader will be 3639235633Sdim // performing binary searches on this information. 3640235633Sdim llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); 3641235633Sdim 3642235633Sdim // Emit the categories map. 3643235633Sdim using namespace llvm; 3644235633Sdim llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 3645235633Sdim Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); 3646235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries 3647235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3648235633Sdim unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); 3649235633Sdim 3650235633Sdim RecordData Record; 3651235633Sdim Record.push_back(OBJC_CATEGORIES_MAP); 3652235633Sdim Record.push_back(CategoriesMap.size()); 3653235633Sdim Stream.EmitRecordWithBlob(AbbrevID, Record, 3654235633Sdim reinterpret_cast<char*>(CategoriesMap.data()), 3655235633Sdim CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); 3656235633Sdim 3657235633Sdim // Emit the category lists. 3658235633Sdim Stream.EmitRecord(OBJC_CATEGORIES, Categories); 3659235633Sdim} 3660235633Sdim 3661235633Sdimvoid ASTWriter::WriteMergedDecls() { 3662235633Sdim if (!Chain || Chain->MergedDecls.empty()) 3663235633Sdim return; 3664235633Sdim 3665235633Sdim RecordData Record; 3666235633Sdim for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(), 3667235633Sdim IEnd = Chain->MergedDecls.end(); 3668235633Sdim I != IEnd; ++I) { 3669235633Sdim DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID() 3670235633Sdim : getDeclID(I->first); 3671235633Sdim assert(CanonID && "Merged declaration not known?"); 3672235633Sdim 3673235633Sdim Record.push_back(CanonID); 3674235633Sdim Record.push_back(I->second.size()); 3675235633Sdim Record.append(I->second.begin(), I->second.end()); 3676235633Sdim } 3677235633Sdim Stream.EmitRecord(MERGED_DECLARATIONS, Record); 3678235633Sdim} 3679235633Sdim 3680263509Sdimvoid ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) { 3681263509Sdim Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap; 3682263509Sdim 3683263509Sdim if (LPTMap.empty()) 3684263509Sdim return; 3685263509Sdim 3686263509Sdim RecordData Record; 3687263509Sdim for (Sema::LateParsedTemplateMapT::iterator It = LPTMap.begin(), 3688263509Sdim ItEnd = LPTMap.end(); 3689263509Sdim It != ItEnd; ++It) { 3690263509Sdim LateParsedTemplate *LPT = It->second; 3691263509Sdim AddDeclRef(It->first, Record); 3692263509Sdim AddDeclRef(LPT->D, Record); 3693263509Sdim Record.push_back(LPT->Toks.size()); 3694263509Sdim 3695263509Sdim for (CachedTokens::iterator TokIt = LPT->Toks.begin(), 3696263509Sdim TokEnd = LPT->Toks.end(); 3697263509Sdim TokIt != TokEnd; ++TokIt) { 3698263509Sdim AddToken(*TokIt, Record); 3699263509Sdim } 3700263509Sdim } 3701263509Sdim Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record); 3702263509Sdim} 3703263509Sdim 3704212795Sdim//===----------------------------------------------------------------------===// 3705212795Sdim// General Serialization Routines 3706212795Sdim//===----------------------------------------------------------------------===// 3707212795Sdim 3708212795Sdim/// \brief Write a record containing the given attributes. 3709245431Sdimvoid ASTWriter::WriteAttributes(ArrayRef<const Attr*> Attrs, 3710245431Sdim RecordDataImpl &Record) { 3711218893Sdim Record.push_back(Attrs.size()); 3712245431Sdim for (ArrayRef<const Attr *>::iterator i = Attrs.begin(), 3713245431Sdim e = Attrs.end(); i != e; ++i){ 3714245431Sdim const Attr *A = *i; 3715212795Sdim Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs 3716226890Sdim AddSourceRange(A->getRange(), Record); 3717212795Sdim 3718212795Sdim#include "clang/Serialization/AttrPCHWrite.inc" 3719212795Sdim 3720212795Sdim } 3721212795Sdim} 3722212795Sdim 3723252723Sdimvoid ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) { 3724252723Sdim AddSourceLocation(Tok.getLocation(), Record); 3725252723Sdim Record.push_back(Tok.getLength()); 3726252723Sdim 3727252723Sdim // FIXME: When reading literal tokens, reconstruct the literal pointer 3728252723Sdim // if it is needed. 3729252723Sdim AddIdentifierRef(Tok.getIdentifierInfo(), Record); 3730252723Sdim // FIXME: Should translate token kind to a stable encoding. 3731252723Sdim Record.push_back(Tok.getKind()); 3732252723Sdim // FIXME: Should translate token flags to a stable encoding. 3733252723Sdim Record.push_back(Tok.getFlags()); 3734252723Sdim} 3735252723Sdim 3736226890Sdimvoid ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { 3737212795Sdim Record.push_back(Str.size()); 3738212795Sdim Record.insert(Record.end(), Str.begin(), Str.end()); 3739212795Sdim} 3740212795Sdim 3741221345Sdimvoid ASTWriter::AddVersionTuple(const VersionTuple &Version, 3742221345Sdim RecordDataImpl &Record) { 3743221345Sdim Record.push_back(Version.getMajor()); 3744252723Sdim if (Optional<unsigned> Minor = Version.getMinor()) 3745221345Sdim Record.push_back(*Minor + 1); 3746221345Sdim else 3747221345Sdim Record.push_back(0); 3748252723Sdim if (Optional<unsigned> Subminor = Version.getSubminor()) 3749221345Sdim Record.push_back(*Subminor + 1); 3750221345Sdim else 3751221345Sdim Record.push_back(0); 3752221345Sdim} 3753221345Sdim 3754212795Sdim/// \brief Note that the identifier II occurs at the given offset 3755212795Sdim/// within the identifier table. 3756212795Sdimvoid ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { 3757212795Sdim IdentID ID = IdentifierIDs[II]; 3758212795Sdim // Only store offsets new to this AST file. Other identifier names are looked 3759212795Sdim // up earlier in the chain and thus don't need an offset. 3760212795Sdim if (ID >= FirstIdentID) 3761212795Sdim IdentifierOffsets[ID - FirstIdentID] = Offset; 3762212795Sdim} 3763212795Sdim 3764212795Sdim/// \brief Note that the selector Sel occurs at the given offset 3765212795Sdim/// within the method pool/selector table. 3766212795Sdimvoid ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { 3767212795Sdim unsigned ID = SelectorIDs[Sel]; 3768212795Sdim assert(ID && "Unknown selector"); 3769212795Sdim // Don't record offsets for selectors that are also available in a different 3770212795Sdim // file. 3771212795Sdim if (ID < FirstSelectorID) 3772212795Sdim return; 3773212795Sdim SelectorOffsets[ID - FirstSelectorID] = Offset; 3774212795Sdim} 3775212795Sdim 3776212795SdimASTWriter::ASTWriter(llvm::BitstreamWriter &Stream) 3777235633Sdim : Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0), 3778245431Sdim WritingAST(false), DoneWritingDeclsAndTypes(false), 3779245431Sdim ASTHasCompilerErrors(false), 3780226890Sdim FirstDeclID(NUM_PREDEF_DECL_IDS), NextDeclID(FirstDeclID), 3781212795Sdim FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID), 3782245431Sdim FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID), 3783245431Sdim FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID), 3784235633Sdim FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), 3785235633Sdim NextSubmoduleID(FirstSubmoduleID), 3786226890Sdim FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), 3787218893Sdim CollectedStmts(&StmtsToEmit), 3788212795Sdim NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), 3789223017Sdim NumVisibleDeclContexts(0), 3790226890Sdim NextCXXBaseSpecifiersID(1), 3791223017Sdim DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0), 3792223017Sdim DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0), 3793223017Sdim DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0), 3794223017Sdim DeclRecordAbbrev(0), IntegerLiteralAbbrev(0), 3795223017Sdim DeclTypedefAbbrev(0), 3796223017Sdim DeclVarAbbrev(0), DeclFieldAbbrev(0), 3797223017Sdim DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0) 3798218893Sdim{ 3799212795Sdim} 3800212795Sdim 3801235633SdimASTWriter::~ASTWriter() { 3802235633Sdim for (FileDeclIDsTy::iterator 3803235633Sdim I = FileDeclIDs.begin(), E = FileDeclIDs.end(); I != E; ++I) 3804235633Sdim delete I->second; 3805235633Sdim} 3806235633Sdim 3807245431Sdimvoid ASTWriter::WriteAST(Sema &SemaRef, 3808218893Sdim const std::string &OutputFile, 3809235633Sdim Module *WritingModule, StringRef isysroot, 3810235633Sdim bool hasErrors) { 3811226890Sdim WritingAST = true; 3812226890Sdim 3813235633Sdim ASTHasCompilerErrors = hasErrors; 3814235633Sdim 3815212795Sdim // Emit the file header. 3816212795Sdim Stream.Emit((unsigned)'C', 8); 3817212795Sdim Stream.Emit((unsigned)'P', 8); 3818212795Sdim Stream.Emit((unsigned)'C', 8); 3819212795Sdim Stream.Emit((unsigned)'H', 8); 3820212795Sdim 3821212795Sdim WriteBlockInfoBlock(); 3822212795Sdim 3823226890Sdim Context = &SemaRef.Context; 3824235633Sdim PP = &SemaRef.PP; 3825235633Sdim this->WritingModule = WritingModule; 3826245431Sdim WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); 3827226890Sdim Context = 0; 3828235633Sdim PP = 0; 3829235633Sdim this->WritingModule = 0; 3830226890Sdim 3831226890Sdim WritingAST = false; 3832212795Sdim} 3833212795Sdim 3834226890Sdimtemplate<typename Vector> 3835226890Sdimstatic void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, 3836226890Sdim ASTWriter::RecordData &Record) { 3837226890Sdim for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end(); 3838226890Sdim I != E; ++I) { 3839226890Sdim Writer.AddDeclRef(*I, Record); 3840226890Sdim } 3841226890Sdim} 3842226890Sdim 3843245431Sdimvoid ASTWriter::WriteASTCore(Sema &SemaRef, 3844226890Sdim StringRef isysroot, 3845235633Sdim const std::string &OutputFile, 3846235633Sdim Module *WritingModule) { 3847212795Sdim using namespace llvm; 3848212795Sdim 3849252723Sdim bool isModule = WritingModule != 0; 3850252723Sdim 3851235633Sdim // Make sure that the AST reader knows to finalize itself. 3852235633Sdim if (Chain) 3853235633Sdim Chain->finalizeForWriting(); 3854235633Sdim 3855212795Sdim ASTContext &Context = SemaRef.Context; 3856212795Sdim Preprocessor &PP = SemaRef.PP; 3857212795Sdim 3858226890Sdim // Set up predefined declaration IDs. 3859226890Sdim DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID; 3860226890Sdim if (Context.ObjCIdDecl) 3861226890Sdim DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID; 3862226890Sdim if (Context.ObjCSelDecl) 3863226890Sdim DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID; 3864226890Sdim if (Context.ObjCClassDecl) 3865226890Sdim DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID; 3866235633Sdim if (Context.ObjCProtocolClassDecl) 3867235633Sdim DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID; 3868226890Sdim if (Context.Int128Decl) 3869226890Sdim DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID; 3870226890Sdim if (Context.UInt128Decl) 3871226890Sdim DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID; 3872226890Sdim if (Context.ObjCInstanceTypeDecl) 3873226890Sdim DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID; 3874245431Sdim if (Context.BuiltinVaListDecl) 3875245431Sdim DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID; 3876245431Sdim 3877226890Sdim if (!Chain) { 3878226890Sdim // Make sure that we emit IdentifierInfos (and any attached 3879226890Sdim // declarations) for builtins. We don't need to do this when we're 3880226890Sdim // emitting chained PCH files, because all of the builtins will be 3881226890Sdim // in the original PCH file. 3882226890Sdim // FIXME: Modules won't like this at all. 3883212795Sdim IdentifierTable &Table = PP.getIdentifierTable(); 3884226890Sdim SmallVector<const char *, 32> BuiltinNames; 3885263509Sdim if (!Context.getLangOpts().NoBuiltin) { 3886263509Sdim Context.BuiltinInfo.GetBuiltinNames(BuiltinNames); 3887263509Sdim } 3888212795Sdim for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I) 3889212795Sdim getIdentifierRef(&Table.get(BuiltinNames[I])); 3890212795Sdim } 3891212795Sdim 3892235633Sdim // If there are any out-of-date identifiers, bring them up to date. 3893235633Sdim if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) { 3894252723Sdim // Find out-of-date identifiers. 3895252723Sdim SmallVector<IdentifierInfo *, 4> OutOfDate; 3896235633Sdim for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 3897235633Sdim IDEnd = PP.getIdentifierTable().end(); 3898252723Sdim ID != IDEnd; ++ID) { 3899235633Sdim if (ID->second->isOutOfDate()) 3900252723Sdim OutOfDate.push_back(ID->second); 3901252723Sdim } 3902252723Sdim 3903252723Sdim // Update the out-of-date identifiers. 3904252723Sdim for (unsigned I = 0, N = OutOfDate.size(); I != N; ++I) { 3905252723Sdim ExtSource->updateOutOfDateIdentifier(*OutOfDate[I]); 3906252723Sdim } 3907235633Sdim } 3908235633Sdim 3909212795Sdim // Build a record containing all of the tentative definitions in this file, in 3910212795Sdim // TentativeDefinitions order. Generally, this record will be empty for 3911212795Sdim // headers. 3912212795Sdim RecordData TentativeDefinitions; 3913226890Sdim AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); 3914226890Sdim 3915212795Sdim // Build a record containing all of the file scoped decls in this file. 3916212795Sdim RecordData UnusedFileScopedDecls; 3917252723Sdim if (!isModule) 3918252723Sdim AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, 3919252723Sdim UnusedFileScopedDecls); 3920212795Sdim 3921226890Sdim // Build a record containing all of the delegating constructors we still need 3922226890Sdim // to resolve. 3923223017Sdim RecordData DelegatingCtorDecls; 3924252723Sdim if (!isModule) 3925252723Sdim AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); 3926223017Sdim 3927226890Sdim // Write the set of weak, undeclared identifiers. We always write the 3928226890Sdim // entire table, since later PCH files in a PCH chain are only interested in 3929226890Sdim // the results at the end of the chain. 3930212795Sdim RecordData WeakUndeclaredIdentifiers; 3931212795Sdim if (!SemaRef.WeakUndeclaredIdentifiers.empty()) { 3932226890Sdim for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 3933212795Sdim I = SemaRef.WeakUndeclaredIdentifiers.begin(), 3934212795Sdim E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) { 3935212795Sdim AddIdentifierRef(I->first, WeakUndeclaredIdentifiers); 3936212795Sdim AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers); 3937212795Sdim AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers); 3938212795Sdim WeakUndeclaredIdentifiers.push_back(I->second.getUsed()); 3939212795Sdim } 3940212795Sdim } 3941212795Sdim 3942252723Sdim // Build a record containing all of the locally-scoped extern "C" 3943212795Sdim // declarations in this header file. Generally, this record will be 3944212795Sdim // empty. 3945252723Sdim RecordData LocallyScopedExternCDecls; 3946212795Sdim // FIXME: This is filling in the AST file in densemap order which is 3947212795Sdim // nondeterminstic! 3948212795Sdim for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator 3949252723Sdim TD = SemaRef.LocallyScopedExternCDecls.begin(), 3950252723Sdim TDEnd = SemaRef.LocallyScopedExternCDecls.end(); 3951226890Sdim TD != TDEnd; ++TD) { 3952226890Sdim if (!TD->second->isFromASTFile()) 3953252723Sdim AddDeclRef(TD->second, LocallyScopedExternCDecls); 3954226890Sdim } 3955226890Sdim 3956212795Sdim // Build a record containing all of the ext_vector declarations. 3957212795Sdim RecordData ExtVectorDecls; 3958226890Sdim AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); 3959212795Sdim 3960212795Sdim // Build a record containing all of the VTable uses information. 3961212795Sdim RecordData VTableUses; 3962212795Sdim if (!SemaRef.VTableUses.empty()) { 3963212795Sdim for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 3964212795Sdim AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 3965212795Sdim AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 3966212795Sdim VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 3967212795Sdim } 3968212795Sdim } 3969212795Sdim 3970212795Sdim // Build a record containing all of dynamic classes declarations. 3971212795Sdim RecordData DynamicClasses; 3972226890Sdim AddLazyVectorDecls(*this, SemaRef.DynamicClasses, DynamicClasses); 3973212795Sdim 3974212795Sdim // Build a record containing all of pending implicit instantiations. 3975212795Sdim RecordData PendingInstantiations; 3976212795Sdim for (std::deque<Sema::PendingImplicitInstantiation>::iterator 3977212795Sdim I = SemaRef.PendingInstantiations.begin(), 3978212795Sdim N = SemaRef.PendingInstantiations.end(); I != N; ++I) { 3979212795Sdim AddDeclRef(I->first, PendingInstantiations); 3980212795Sdim AddSourceLocation(I->second, PendingInstantiations); 3981212795Sdim } 3982212795Sdim assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 3983212795Sdim "There are local ones at end of translation unit!"); 3984212795Sdim 3985212795Sdim // Build a record containing some declaration references. 3986212795Sdim RecordData SemaDeclRefs; 3987212795Sdim if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 3988212795Sdim AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 3989212795Sdim AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 3990212795Sdim } 3991212795Sdim 3992218893Sdim RecordData CUDASpecialDeclRefs; 3993218893Sdim if (Context.getcudaConfigureCallDecl()) { 3994218893Sdim AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); 3995218893Sdim } 3996218893Sdim 3997224145Sdim // Build a record containing all of the known namespaces. 3998224145Sdim RecordData KnownNamespaces; 3999252723Sdim for (llvm::MapVector<NamespaceDecl*, bool>::iterator 4000224145Sdim I = SemaRef.KnownNamespaces.begin(), 4001224145Sdim IEnd = SemaRef.KnownNamespaces.end(); 4002224145Sdim I != IEnd; ++I) { 4003224145Sdim if (!I->second) 4004224145Sdim AddDeclRef(I->first, KnownNamespaces); 4005224145Sdim } 4006245431Sdim 4007252723Sdim // Build a record of all used, undefined objects that require definitions. 4008252723Sdim RecordData UndefinedButUsed; 4009252723Sdim 4010252723Sdim SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined; 4011252723Sdim SemaRef.getUndefinedButUsed(Undefined); 4012252723Sdim for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator 4013252723Sdim I = Undefined.begin(), E = Undefined.end(); I != E; ++I) { 4014252723Sdim AddDeclRef(I->first, UndefinedButUsed); 4015252723Sdim AddSourceLocation(I->second, UndefinedButUsed); 4016252723Sdim } 4017252723Sdim 4018245431Sdim // Write the control block 4019245431Sdim WriteControlBlock(PP, Context, isysroot, OutputFile); 4020245431Sdim 4021212795Sdim // Write the remaining AST contents. 4022212795Sdim RecordData Record; 4023212795Sdim Stream.EnterSubblock(AST_BLOCK_ID, 5); 4024212795Sdim 4025252723Sdim // This is so that older clang versions, before the introduction 4026252723Sdim // of the control block, can read and reject the newer PCH format. 4027252723Sdim Record.clear(); 4028252723Sdim Record.push_back(VERSION_MAJOR); 4029252723Sdim Stream.EmitRecord(METADATA_OLD_FORMAT, Record); 4030252723Sdim 4031226890Sdim // Create a lexical update block containing all of the declarations in the 4032226890Sdim // translation unit that do not come from other AST files. 4033212795Sdim const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 4034226890Sdim SmallVector<KindDeclIDPair, 64> NewGlobalDecls; 4035212795Sdim for (DeclContext::decl_iterator I = TU->noload_decls_begin(), 4036212795Sdim E = TU->noload_decls_end(); 4037212795Sdim I != E; ++I) { 4038226890Sdim if (!(*I)->isFromASTFile()) 4039218893Sdim NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I))); 4040212795Sdim } 4041226890Sdim 4042212795Sdim llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev(); 4043212795Sdim Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); 4044212795Sdim Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4045212795Sdim unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); 4046212795Sdim Record.clear(); 4047212795Sdim Record.push_back(TU_UPDATE_LEXICAL); 4048212795Sdim Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, 4049221345Sdim data(NewGlobalDecls)); 4050226890Sdim 4051226890Sdim // And a visible updates block for the translation unit. 4052218893Sdim Abv = new llvm::BitCodeAbbrev(); 4053218893Sdim Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); 4054218893Sdim Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 4055218893Sdim Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32)); 4056218893Sdim Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4057218893Sdim UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); 4058218893Sdim WriteDeclContextVisibleUpdate(TU); 4059226890Sdim 4060226890Sdim // If the translation unit has an anonymous namespace, and we don't already 4061226890Sdim // have an update block for it, write it as an update block. 4062226890Sdim if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { 4063226890Sdim ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; 4064226890Sdim if (Record.empty()) { 4065226890Sdim Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); 4066226890Sdim Record.push_back(reinterpret_cast<uint64_t>(NS)); 4067212795Sdim } 4068212795Sdim } 4069245431Sdim 4070245431Sdim // Make sure visible decls, added to DeclContexts previously loaded from 4071245431Sdim // an AST file, are registered for serialization. 4072263509Sdim for (SmallVectorImpl<const Decl *>::iterator 4073245431Sdim I = UpdatingVisibleDecls.begin(), 4074245431Sdim E = UpdatingVisibleDecls.end(); I != E; ++I) { 4075245431Sdim GetDeclRef(*I); 4076245431Sdim } 4077245431Sdim 4078263509Sdim // Make sure all decls associated with an identifier are registered for 4079263509Sdim // serialization. 4080263509Sdim for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(), 4081263509Sdim IDEnd = PP.getIdentifierTable().end(); 4082263509Sdim ID != IDEnd; ++ID) { 4083263509Sdim const IdentifierInfo *II = ID->second; 4084263509Sdim if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) { 4085263509Sdim for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), 4086263509Sdim DEnd = SemaRef.IdResolver.end(); 4087263509Sdim D != DEnd; ++D) { 4088263509Sdim GetDeclRef(*D); 4089263509Sdim } 4090263509Sdim } 4091263509Sdim } 4092263509Sdim 4093235633Sdim // Resolve any declaration pointers within the declaration updates block. 4094226890Sdim ResolveDeclUpdatesBlocks(); 4095226890Sdim 4096226890Sdim // Form the record of special types. 4097226890Sdim RecordData SpecialTypes; 4098226890Sdim AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); 4099226890Sdim AddTypeRef(Context.getFILEType(), SpecialTypes); 4100226890Sdim AddTypeRef(Context.getjmp_bufType(), SpecialTypes); 4101226890Sdim AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); 4102226890Sdim AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); 4103226890Sdim AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); 4104226890Sdim AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); 4105229041Sdim AddTypeRef(Context.getucontext_tType(), SpecialTypes); 4106235633Sdim 4107226890Sdim // Keep writing types and declarations until all types and 4108226890Sdim // declarations have been written. 4109223017Sdim Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); 4110212795Sdim WriteDeclsBlockAbbrevs(); 4111226890Sdim for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(), 4112226890Sdim E = DeclsToRewrite.end(); 4113226890Sdim I != E; ++I) 4114218893Sdim DeclTypesToEmit.push(const_cast<Decl*>(*I)); 4115212795Sdim while (!DeclTypesToEmit.empty()) { 4116212795Sdim DeclOrType DOT = DeclTypesToEmit.front(); 4117212795Sdim DeclTypesToEmit.pop(); 4118212795Sdim if (DOT.isType()) 4119212795Sdim WriteType(DOT.getType()); 4120212795Sdim else 4121212795Sdim WriteDecl(Context, DOT.getDecl()); 4122212795Sdim } 4123212795Sdim Stream.ExitBlock(); 4124212795Sdim 4125245431Sdim DoneWritingDeclsAndTypes = true; 4126245431Sdim 4127235633Sdim WriteFileDeclIDsMap(); 4128235633Sdim WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); 4129245431Sdim WriteComments(); 4130235633Sdim 4131235633Sdim if (Chain) { 4132235633Sdim // Write the mapping information describing our module dependencies and how 4133235633Sdim // each of those modules were mapped into our own offset/ID space, so that 4134235633Sdim // the reader can build the appropriate mapping to its own offset/ID space. 4135235633Sdim // The map consists solely of a blob with the following format: 4136235633Sdim // *(module-name-len:i16 module-name:len*i8 4137235633Sdim // source-location-offset:i32 4138235633Sdim // identifier-id:i32 4139235633Sdim // preprocessed-entity-id:i32 4140235633Sdim // macro-definition-id:i32 4141235633Sdim // submodule-id:i32 4142235633Sdim // selector-id:i32 4143235633Sdim // declaration-id:i32 4144235633Sdim // c++-base-specifiers-id:i32 4145235633Sdim // type-id:i32) 4146235633Sdim // 4147235633Sdim llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); 4148235633Sdim Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); 4149235633Sdim Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 4150235633Sdim unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); 4151235633Sdim SmallString<2048> Buffer; 4152235633Sdim { 4153235633Sdim llvm::raw_svector_ostream Out(Buffer); 4154235633Sdim for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(), 4155235633Sdim MEnd = Chain->ModuleMgr.end(); 4156235633Sdim M != MEnd; ++M) { 4157235633Sdim StringRef FileName = (*M)->FileName; 4158235633Sdim io::Emit16(Out, FileName.size()); 4159235633Sdim Out.write(FileName.data(), FileName.size()); 4160235633Sdim io::Emit32(Out, (*M)->SLocEntryBaseOffset); 4161235633Sdim io::Emit32(Out, (*M)->BaseIdentifierID); 4162245431Sdim io::Emit32(Out, (*M)->BaseMacroID); 4163235633Sdim io::Emit32(Out, (*M)->BasePreprocessedEntityID); 4164235633Sdim io::Emit32(Out, (*M)->BaseSubmoduleID); 4165235633Sdim io::Emit32(Out, (*M)->BaseSelectorID); 4166235633Sdim io::Emit32(Out, (*M)->BaseDeclID); 4167235633Sdim io::Emit32(Out, (*M)->BaseTypeIndex); 4168235633Sdim } 4169235633Sdim } 4170235633Sdim Record.clear(); 4171235633Sdim Record.push_back(MODULE_OFFSET_MAP); 4172235633Sdim Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, 4173235633Sdim Buffer.data(), Buffer.size()); 4174235633Sdim } 4175252723Sdim WritePreprocessor(PP, isModule); 4176226890Sdim WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot); 4177212795Sdim WriteSelectors(SemaRef); 4178212795Sdim WriteReferencedSelectorsPool(SemaRef); 4179252723Sdim WriteIdentifierTable(PP, SemaRef.IdResolver, isModule); 4180218893Sdim WriteFPPragmaOptions(SemaRef.getFPOptions()); 4181218893Sdim WriteOpenCLExtensions(SemaRef); 4182218893Sdim 4183212795Sdim WriteTypeDeclOffsets(); 4184252723Sdim WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule); 4185212795Sdim 4186221345Sdim WriteCXXBaseSpecifiersOffsets(); 4187226890Sdim 4188235633Sdim // If we're emitting a module, write out the submodule information. 4189235633Sdim if (WritingModule) 4190235633Sdim WriteSubmodules(WritingModule); 4191235633Sdim 4192226890Sdim Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); 4193221345Sdim 4194212795Sdim // Write the record containing external, unnamed definitions. 4195212795Sdim if (!ExternalDefinitions.empty()) 4196212795Sdim Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions); 4197212795Sdim 4198212795Sdim // Write the record containing tentative definitions. 4199212795Sdim if (!TentativeDefinitions.empty()) 4200212795Sdim Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 4201212795Sdim 4202212795Sdim // Write the record containing unused file scoped decls. 4203212795Sdim if (!UnusedFileScopedDecls.empty()) 4204212795Sdim Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 4205212795Sdim 4206212795Sdim // Write the record containing weak undeclared identifiers. 4207212795Sdim if (!WeakUndeclaredIdentifiers.empty()) 4208212795Sdim Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 4209212795Sdim WeakUndeclaredIdentifiers); 4210212795Sdim 4211252723Sdim // Write the record containing locally-scoped extern "C" definitions. 4212252723Sdim if (!LocallyScopedExternCDecls.empty()) 4213252723Sdim Stream.EmitRecord(LOCALLY_SCOPED_EXTERN_C_DECLS, 4214252723Sdim LocallyScopedExternCDecls); 4215212795Sdim 4216212795Sdim // Write the record containing ext_vector type names. 4217212795Sdim if (!ExtVectorDecls.empty()) 4218212795Sdim Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 4219212795Sdim 4220212795Sdim // Write the record containing VTable uses information. 4221212795Sdim if (!VTableUses.empty()) 4222212795Sdim Stream.EmitRecord(VTABLE_USES, VTableUses); 4223212795Sdim 4224212795Sdim // Write the record containing dynamic classes declarations. 4225212795Sdim if (!DynamicClasses.empty()) 4226212795Sdim Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses); 4227212795Sdim 4228212795Sdim // Write the record containing pending implicit instantiations. 4229212795Sdim if (!PendingInstantiations.empty()) 4230212795Sdim Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); 4231212795Sdim 4232212795Sdim // Write the record containing declaration references of Sema. 4233212795Sdim if (!SemaDeclRefs.empty()) 4234212795Sdim Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 4235226890Sdim 4236226890Sdim // Write the record containing CUDA-specific declaration references. 4237226890Sdim if (!CUDASpecialDeclRefs.empty()) 4238226890Sdim Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); 4239223017Sdim 4240223017Sdim // Write the delegating constructors. 4241223017Sdim if (!DelegatingCtorDecls.empty()) 4242223017Sdim Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); 4243212795Sdim 4244226890Sdim // Write the known namespaces. 4245226890Sdim if (!KnownNamespaces.empty()) 4246226890Sdim Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); 4247252723Sdim 4248252723Sdim // Write the undefined internal functions and variables, and inline functions. 4249252723Sdim if (!UndefinedButUsed.empty()) 4250252723Sdim Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed); 4251226890Sdim 4252226890Sdim // Write the visible updates to DeclContexts. 4253218893Sdim for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator 4254226890Sdim I = UpdatedDeclContexts.begin(), 4255226890Sdim E = UpdatedDeclContexts.end(); 4256226890Sdim I != E; ++I) 4257212795Sdim WriteDeclContextVisibleUpdate(*I); 4258212795Sdim 4259235633Sdim if (!WritingModule) { 4260235633Sdim // Write the submodules that were imported, if any. 4261235633Sdim RecordData ImportedModules; 4262235633Sdim for (ASTContext::import_iterator I = Context.local_import_begin(), 4263235633Sdim IEnd = Context.local_import_end(); 4264235633Sdim I != IEnd; ++I) { 4265235633Sdim assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); 4266235633Sdim ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]); 4267235633Sdim } 4268235633Sdim if (!ImportedModules.empty()) { 4269235633Sdim // Sort module IDs. 4270235633Sdim llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end()); 4271235633Sdim 4272235633Sdim // Unique module IDs. 4273235633Sdim ImportedModules.erase(std::unique(ImportedModules.begin(), 4274235633Sdim ImportedModules.end()), 4275235633Sdim ImportedModules.end()); 4276235633Sdim 4277235633Sdim Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); 4278235633Sdim } 4279235633Sdim } 4280245431Sdim 4281218893Sdim WriteDeclUpdatesBlocks(); 4282226890Sdim WriteDeclReplacementsBlock(); 4283252723Sdim WriteRedeclarations(); 4284235633Sdim WriteMergedDecls(); 4285235633Sdim WriteObjCCategories(); 4286263509Sdim WriteLateParsedTemplates(SemaRef); 4287263509Sdim 4288226890Sdim // Some simple statistics 4289212795Sdim Record.clear(); 4290212795Sdim Record.push_back(NumStatements); 4291212795Sdim Record.push_back(NumMacros); 4292212795Sdim Record.push_back(NumLexicalDeclContexts); 4293212795Sdim Record.push_back(NumVisibleDeclContexts); 4294212795Sdim Stream.EmitRecord(STATISTICS, Record); 4295212795Sdim Stream.ExitBlock(); 4296212795Sdim} 4297212795Sdim 4298226890Sdim/// \brief Go through the declaration update blocks and resolve declaration 4299226890Sdim/// pointers into declaration IDs. 4300226890Sdimvoid ASTWriter::ResolveDeclUpdatesBlocks() { 4301226890Sdim for (DeclUpdateMap::iterator 4302226890Sdim I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { 4303226890Sdim const Decl *D = I->first; 4304226890Sdim UpdateRecord &URec = I->second; 4305226890Sdim 4306235633Sdim if (isRewritten(D)) 4307226890Sdim continue; // The decl will be written completely 4308226890Sdim 4309226890Sdim unsigned Idx = 0, N = URec.size(); 4310226890Sdim while (Idx < N) { 4311226890Sdim switch ((DeclUpdateKind)URec[Idx++]) { 4312226890Sdim case UPD_CXX_ADDED_IMPLICIT_MEMBER: 4313226890Sdim case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: 4314226890Sdim case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: 4315226890Sdim URec[Idx] = GetDeclRef(reinterpret_cast<Decl *>(URec[Idx])); 4316226890Sdim ++Idx; 4317226890Sdim break; 4318263509Sdim 4319226890Sdim case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: 4320263509Sdim case UPD_DECL_MARKED_USED: 4321226890Sdim ++Idx; 4322226890Sdim break; 4323263509Sdim 4324263509Sdim case UPD_CXX_DEDUCED_RETURN_TYPE: 4325263509Sdim URec[Idx] = GetOrCreateTypeID( 4326263509Sdim QualType::getFromOpaquePtr(reinterpret_cast<void *>(URec[Idx]))); 4327263509Sdim ++Idx; 4328263509Sdim break; 4329226890Sdim } 4330226890Sdim } 4331226890Sdim } 4332226890Sdim} 4333226890Sdim 4334218893Sdimvoid ASTWriter::WriteDeclUpdatesBlocks() { 4335218893Sdim if (DeclUpdates.empty()) 4336218893Sdim return; 4337218893Sdim 4338218893Sdim RecordData OffsetsRecord; 4339223017Sdim Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE); 4340218893Sdim for (DeclUpdateMap::iterator 4341218893Sdim I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) { 4342218893Sdim const Decl *D = I->first; 4343218893Sdim UpdateRecord &URec = I->second; 4344218893Sdim 4345235633Sdim if (isRewritten(D)) 4346218893Sdim continue; // The decl will be written completely,no need to store updates. 4347218893Sdim 4348218893Sdim uint64_t Offset = Stream.GetCurrentBitNo(); 4349218893Sdim Stream.EmitRecord(DECL_UPDATES, URec); 4350218893Sdim 4351218893Sdim OffsetsRecord.push_back(GetDeclRef(D)); 4352218893Sdim OffsetsRecord.push_back(Offset); 4353218893Sdim } 4354218893Sdim Stream.ExitBlock(); 4355218893Sdim Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord); 4356218893Sdim} 4357218893Sdim 4358218893Sdimvoid ASTWriter::WriteDeclReplacementsBlock() { 4359212795Sdim if (ReplacedDecls.empty()) 4360212795Sdim return; 4361212795Sdim 4362212795Sdim RecordData Record; 4363263509Sdim for (SmallVectorImpl<ReplacedDeclInfo>::iterator 4364263509Sdim I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) { 4365235633Sdim Record.push_back(I->ID); 4366235633Sdim Record.push_back(I->Offset); 4367235633Sdim Record.push_back(I->Loc); 4368212795Sdim } 4369212795Sdim Stream.EmitRecord(DECL_REPLACEMENTS, Record); 4370212795Sdim} 4371212795Sdim 4372218893Sdimvoid ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { 4373212795Sdim Record.push_back(Loc.getRawEncoding()); 4374212795Sdim} 4375212795Sdim 4376218893Sdimvoid ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { 4377212795Sdim AddSourceLocation(Range.getBegin(), Record); 4378212795Sdim AddSourceLocation(Range.getEnd(), Record); 4379212795Sdim} 4380212795Sdim 4381218893Sdimvoid ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record) { 4382212795Sdim Record.push_back(Value.getBitWidth()); 4383218893Sdim const uint64_t *Words = Value.getRawData(); 4384218893Sdim Record.append(Words, Words + Value.getNumWords()); 4385212795Sdim} 4386212795Sdim 4387218893Sdimvoid ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &Record) { 4388212795Sdim Record.push_back(Value.isUnsigned()); 4389212795Sdim AddAPInt(Value, Record); 4390212795Sdim} 4391212795Sdim 4392218893Sdimvoid ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) { 4393212795Sdim AddAPInt(Value.bitcastToAPInt(), Record); 4394212795Sdim} 4395212795Sdim 4396218893Sdimvoid ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { 4397212795Sdim Record.push_back(getIdentifierRef(II)); 4398212795Sdim} 4399212795Sdim 4400212795SdimIdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { 4401212795Sdim if (II == 0) 4402212795Sdim return 0; 4403212795Sdim 4404212795Sdim IdentID &ID = IdentifierIDs[II]; 4405212795Sdim if (ID == 0) 4406212795Sdim ID = NextIdentID++; 4407212795Sdim return ID; 4408212795Sdim} 4409212795Sdim 4410252723SdimMacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) { 4411245431Sdim // Don't emit builtin macros like __LINE__ to the AST file unless they 4412245431Sdim // have been redefined by the header (in which case they are not 4413245431Sdim // isBuiltinMacro). 4414245431Sdim if (MI == 0 || MI->isBuiltinMacro()) 4415245431Sdim return 0; 4416245431Sdim 4417245431Sdim MacroID &ID = MacroIDs[MI]; 4418252723Sdim if (ID == 0) { 4419245431Sdim ID = NextMacroID++; 4420252723Sdim MacroInfoToEmitData Info = { Name, MI, ID }; 4421252723Sdim MacroInfosToEmit.push_back(Info); 4422252723Sdim } 4423245431Sdim return ID; 4424245431Sdim} 4425245431Sdim 4426252723SdimMacroID ASTWriter::getMacroID(MacroInfo *MI) { 4427252723Sdim if (MI == 0 || MI->isBuiltinMacro()) 4428252723Sdim return 0; 4429252723Sdim 4430252723Sdim assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!"); 4431252723Sdim return MacroIDs[MI]; 4432252723Sdim} 4433252723Sdim 4434252723Sdimuint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) { 4435252723Sdim assert(IdentMacroDirectivesOffsetMap[Name] && "not set!"); 4436252723Sdim return IdentMacroDirectivesOffsetMap[Name]; 4437252723Sdim} 4438252723Sdim 4439218893Sdimvoid ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &Record) { 4440212795Sdim Record.push_back(getSelectorRef(SelRef)); 4441212795Sdim} 4442212795Sdim 4443212795SdimSelectorID ASTWriter::getSelectorRef(Selector Sel) { 4444212795Sdim if (Sel.getAsOpaquePtr() == 0) { 4445212795Sdim return 0; 4446212795Sdim } 4447212795Sdim 4448252723Sdim SelectorID SID = SelectorIDs[Sel]; 4449212795Sdim if (SID == 0 && Chain) { 4450212795Sdim // This might trigger a ReadSelector callback, which will set the ID for 4451212795Sdim // this selector. 4452212795Sdim Chain->LoadSelector(Sel); 4453252723Sdim SID = SelectorIDs[Sel]; 4454212795Sdim } 4455212795Sdim if (SID == 0) { 4456212795Sdim SID = NextSelectorID++; 4457252723Sdim SelectorIDs[Sel] = SID; 4458212795Sdim } 4459212795Sdim return SID; 4460212795Sdim} 4461212795Sdim 4462218893Sdimvoid ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) { 4463212795Sdim AddDeclRef(Temp->getDestructor(), Record); 4464212795Sdim} 4465212795Sdim 4466218893Sdimvoid ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases, 4467218893Sdim CXXBaseSpecifier const *BasesEnd, 4468218893Sdim RecordDataImpl &Record) { 4469218893Sdim assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded"); 4470218893Sdim CXXBaseSpecifiersToWrite.push_back( 4471218893Sdim QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID, 4472218893Sdim Bases, BasesEnd)); 4473218893Sdim Record.push_back(NextCXXBaseSpecifiersID++); 4474218893Sdim} 4475218893Sdim 4476212795Sdimvoid ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, 4477212795Sdim const TemplateArgumentLocInfo &Arg, 4478218893Sdim RecordDataImpl &Record) { 4479212795Sdim switch (Kind) { 4480212795Sdim case TemplateArgument::Expression: 4481212795Sdim AddStmt(Arg.getAsExpr()); 4482212795Sdim break; 4483212795Sdim case TemplateArgument::Type: 4484212795Sdim AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record); 4485212795Sdim break; 4486212795Sdim case TemplateArgument::Template: 4487221345Sdim AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); 4488212795Sdim AddSourceLocation(Arg.getTemplateNameLoc(), Record); 4489212795Sdim break; 4490218893Sdim case TemplateArgument::TemplateExpansion: 4491221345Sdim AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record); 4492218893Sdim AddSourceLocation(Arg.getTemplateNameLoc(), Record); 4493218893Sdim AddSourceLocation(Arg.getTemplateEllipsisLoc(), Record); 4494218893Sdim break; 4495212795Sdim case TemplateArgument::Null: 4496212795Sdim case TemplateArgument::Integral: 4497212795Sdim case TemplateArgument::Declaration: 4498245431Sdim case TemplateArgument::NullPtr: 4499212795Sdim case TemplateArgument::Pack: 4500245431Sdim // FIXME: Is this right? 4501212795Sdim break; 4502212795Sdim } 4503212795Sdim} 4504212795Sdim 4505212795Sdimvoid ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, 4506218893Sdim RecordDataImpl &Record) { 4507212795Sdim AddTemplateArgument(Arg.getArgument(), Record); 4508212795Sdim 4509212795Sdim if (Arg.getArgument().getKind() == TemplateArgument::Expression) { 4510212795Sdim bool InfoHasSameExpr 4511212795Sdim = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); 4512212795Sdim Record.push_back(InfoHasSameExpr); 4513212795Sdim if (InfoHasSameExpr) 4514212795Sdim return; // Avoid storing the same expr twice. 4515212795Sdim } 4516212795Sdim AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(), 4517212795Sdim Record); 4518212795Sdim} 4519212795Sdim 4520219077Sdimvoid ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, 4521219077Sdim RecordDataImpl &Record) { 4522212795Sdim if (TInfo == 0) { 4523212795Sdim AddTypeRef(QualType(), Record); 4524212795Sdim return; 4525212795Sdim } 4526212795Sdim 4527219077Sdim AddTypeLoc(TInfo->getTypeLoc(), Record); 4528219077Sdim} 4529219077Sdim 4530219077Sdimvoid ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) { 4531219077Sdim AddTypeRef(TL.getType(), Record); 4532219077Sdim 4533212795Sdim TypeLocWriter TLW(*this, Record); 4534219077Sdim for (; !TL.isNull(); TL = TL.getNextTypeLoc()) 4535212795Sdim TLW.Visit(TL); 4536212795Sdim} 4537212795Sdim 4538218893Sdimvoid ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { 4539212795Sdim Record.push_back(GetOrCreateTypeID(T)); 4540212795Sdim} 4541212795Sdim 4542226890SdimTypeID ASTWriter::GetOrCreateTypeID( QualType T) { 4543263509Sdim assert(Context); 4544226890Sdim return MakeTypeID(*Context, T, 4545212795Sdim std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this)); 4546212795Sdim} 4547212795Sdim 4548212795SdimTypeID ASTWriter::getTypeID(QualType T) const { 4549263509Sdim assert(Context); 4550226890Sdim return MakeTypeID(*Context, T, 4551212795Sdim std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this)); 4552212795Sdim} 4553212795Sdim 4554212795SdimTypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) { 4555212795Sdim if (T.isNull()) 4556212795Sdim return TypeIdx(); 4557212795Sdim assert(!T.getLocalFastQualifiers()); 4558212795Sdim 4559212795Sdim TypeIdx &Idx = TypeIdxs[T]; 4560212795Sdim if (Idx.getIndex() == 0) { 4561245431Sdim if (DoneWritingDeclsAndTypes) { 4562245431Sdim assert(0 && "New type seen after serializing all the types to emit!"); 4563245431Sdim return TypeIdx(); 4564245431Sdim } 4565245431Sdim 4566212795Sdim // We haven't seen this type before. Assign it a new ID and put it 4567212795Sdim // into the queue of types to emit. 4568212795Sdim Idx = TypeIdx(NextTypeID++); 4569212795Sdim DeclTypesToEmit.push(T); 4570212795Sdim } 4571212795Sdim return Idx; 4572212795Sdim} 4573212795Sdim 4574212795SdimTypeIdx ASTWriter::getTypeIdx(QualType T) const { 4575212795Sdim if (T.isNull()) 4576212795Sdim return TypeIdx(); 4577212795Sdim assert(!T.getLocalFastQualifiers()); 4578212795Sdim 4579212795Sdim TypeIdxMap::const_iterator I = TypeIdxs.find(T); 4580212795Sdim assert(I != TypeIdxs.end() && "Type not emitted!"); 4581212795Sdim return I->second; 4582212795Sdim} 4583212795Sdim 4584218893Sdimvoid ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { 4585212795Sdim Record.push_back(GetDeclRef(D)); 4586212795Sdim} 4587212795Sdim 4588212795SdimDeclID ASTWriter::GetDeclRef(const Decl *D) { 4589226890Sdim assert(WritingAST && "Cannot request a declaration ID before AST writing"); 4590226890Sdim 4591212795Sdim if (D == 0) { 4592212795Sdim return 0; 4593212795Sdim } 4594235633Sdim 4595235633Sdim // If D comes from an AST file, its declaration ID is already known and 4596235633Sdim // fixed. 4597235633Sdim if (D->isFromASTFile()) 4598235633Sdim return D->getGlobalID(); 4599235633Sdim 4600218893Sdim assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer"); 4601212795Sdim DeclID &ID = DeclIDs[D]; 4602212795Sdim if (ID == 0) { 4603245431Sdim if (DoneWritingDeclsAndTypes) { 4604245431Sdim assert(0 && "New decl seen after serializing all the decls to emit!"); 4605245431Sdim return 0; 4606245431Sdim } 4607245431Sdim 4608212795Sdim // We haven't seen this declaration before. Give it a new ID and 4609212795Sdim // enqueue it in the list of declarations to emit. 4610212795Sdim ID = NextDeclID++; 4611212795Sdim DeclTypesToEmit.push(const_cast<Decl *>(D)); 4612212795Sdim } 4613212795Sdim 4614212795Sdim return ID; 4615212795Sdim} 4616212795Sdim 4617212795SdimDeclID ASTWriter::getDeclID(const Decl *D) { 4618212795Sdim if (D == 0) 4619212795Sdim return 0; 4620212795Sdim 4621235633Sdim // If D comes from an AST file, its declaration ID is already known and 4622235633Sdim // fixed. 4623235633Sdim if (D->isFromASTFile()) 4624235633Sdim return D->getGlobalID(); 4625235633Sdim 4626212795Sdim assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); 4627212795Sdim return DeclIDs[D]; 4628212795Sdim} 4629212795Sdim 4630235633Sdimvoid ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { 4631235633Sdim assert(ID); 4632235633Sdim assert(D); 4633235633Sdim 4634235633Sdim SourceLocation Loc = D->getLocation(); 4635235633Sdim if (Loc.isInvalid()) 4636235633Sdim return; 4637235633Sdim 4638235633Sdim // We only keep track of the file-level declarations of each file. 4639235633Sdim if (!D->getLexicalDeclContext()->isFileContext()) 4640235633Sdim return; 4641235633Sdim // FIXME: ParmVarDecls that are part of a function type of a parameter of 4642235633Sdim // a function/objc method, should not have TU as lexical context. 4643235633Sdim if (isa<ParmVarDecl>(D)) 4644235633Sdim return; 4645235633Sdim 4646235633Sdim SourceManager &SM = Context->getSourceManager(); 4647235633Sdim SourceLocation FileLoc = SM.getFileLoc(Loc); 4648235633Sdim assert(SM.isLocalSourceLocation(FileLoc)); 4649235633Sdim FileID FID; 4650235633Sdim unsigned Offset; 4651235633Sdim llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); 4652235633Sdim if (FID.isInvalid()) 4653235633Sdim return; 4654245431Sdim assert(SM.getSLocEntry(FID).isFile()); 4655235633Sdim 4656245431Sdim DeclIDInFileInfo *&Info = FileDeclIDs[FID]; 4657235633Sdim if (!Info) 4658235633Sdim Info = new DeclIDInFileInfo(); 4659235633Sdim 4660235633Sdim std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID); 4661235633Sdim LocDeclIDsTy &Decls = Info->DeclIDs; 4662235633Sdim 4663235633Sdim if (Decls.empty() || Decls.back().first <= Offset) { 4664235633Sdim Decls.push_back(LocDecl); 4665235633Sdim return; 4666235633Sdim } 4667235633Sdim 4668263509Sdim LocDeclIDsTy::iterator I = 4669263509Sdim std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first()); 4670235633Sdim 4671235633Sdim Decls.insert(I, LocDecl); 4672235633Sdim} 4673235633Sdim 4674218893Sdimvoid ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &Record) { 4675212795Sdim // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. 4676212795Sdim Record.push_back(Name.getNameKind()); 4677212795Sdim switch (Name.getNameKind()) { 4678212795Sdim case DeclarationName::Identifier: 4679212795Sdim AddIdentifierRef(Name.getAsIdentifierInfo(), Record); 4680212795Sdim break; 4681212795Sdim 4682212795Sdim case DeclarationName::ObjCZeroArgSelector: 4683212795Sdim case DeclarationName::ObjCOneArgSelector: 4684212795Sdim case DeclarationName::ObjCMultiArgSelector: 4685212795Sdim AddSelectorRef(Name.getObjCSelector(), Record); 4686212795Sdim break; 4687212795Sdim 4688212795Sdim case DeclarationName::CXXConstructorName: 4689212795Sdim case DeclarationName::CXXDestructorName: 4690212795Sdim case DeclarationName::CXXConversionFunctionName: 4691212795Sdim AddTypeRef(Name.getCXXNameType(), Record); 4692212795Sdim break; 4693212795Sdim 4694212795Sdim case DeclarationName::CXXOperatorName: 4695212795Sdim Record.push_back(Name.getCXXOverloadedOperator()); 4696212795Sdim break; 4697212795Sdim 4698212795Sdim case DeclarationName::CXXLiteralOperatorName: 4699212795Sdim AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record); 4700212795Sdim break; 4701212795Sdim 4702212795Sdim case DeclarationName::CXXUsingDirective: 4703212795Sdim // No extra data to emit 4704212795Sdim break; 4705212795Sdim } 4706212795Sdim} 4707212795Sdim 4708218893Sdimvoid ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, 4709218893Sdim DeclarationName Name, RecordDataImpl &Record) { 4710218893Sdim switch (Name.getNameKind()) { 4711218893Sdim case DeclarationName::CXXConstructorName: 4712218893Sdim case DeclarationName::CXXDestructorName: 4713218893Sdim case DeclarationName::CXXConversionFunctionName: 4714218893Sdim AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record); 4715218893Sdim break; 4716218893Sdim 4717218893Sdim case DeclarationName::CXXOperatorName: 4718218893Sdim AddSourceLocation( 4719218893Sdim SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc), 4720218893Sdim Record); 4721218893Sdim AddSourceLocation( 4722218893Sdim SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc), 4723218893Sdim Record); 4724218893Sdim break; 4725218893Sdim 4726218893Sdim case DeclarationName::CXXLiteralOperatorName: 4727218893Sdim AddSourceLocation( 4728218893Sdim SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc), 4729218893Sdim Record); 4730218893Sdim break; 4731218893Sdim 4732218893Sdim case DeclarationName::Identifier: 4733218893Sdim case DeclarationName::ObjCZeroArgSelector: 4734218893Sdim case DeclarationName::ObjCOneArgSelector: 4735218893Sdim case DeclarationName::ObjCMultiArgSelector: 4736218893Sdim case DeclarationName::CXXUsingDirective: 4737218893Sdim break; 4738218893Sdim } 4739218893Sdim} 4740218893Sdim 4741218893Sdimvoid ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 4742218893Sdim RecordDataImpl &Record) { 4743218893Sdim AddDeclarationName(NameInfo.getName(), Record); 4744218893Sdim AddSourceLocation(NameInfo.getLoc(), Record); 4745218893Sdim AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record); 4746218893Sdim} 4747218893Sdim 4748218893Sdimvoid ASTWriter::AddQualifierInfo(const QualifierInfo &Info, 4749218893Sdim RecordDataImpl &Record) { 4750219077Sdim AddNestedNameSpecifierLoc(Info.QualifierLoc, Record); 4751218893Sdim Record.push_back(Info.NumTemplParamLists); 4752218893Sdim for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) 4753218893Sdim AddTemplateParameterList(Info.TemplParamLists[i], Record); 4754218893Sdim} 4755218893Sdim 4756212795Sdimvoid ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS, 4757218893Sdim RecordDataImpl &Record) { 4758212795Sdim // Nested name specifiers usually aren't too long. I think that 8 would 4759221345Sdim // typically accommodate the vast majority. 4760226890Sdim SmallVector<NestedNameSpecifier *, 8> NestedNames; 4761212795Sdim 4762212795Sdim // Push each of the NNS's onto a stack for serialization in reverse order. 4763212795Sdim while (NNS) { 4764212795Sdim NestedNames.push_back(NNS); 4765212795Sdim NNS = NNS->getPrefix(); 4766212795Sdim } 4767212795Sdim 4768212795Sdim Record.push_back(NestedNames.size()); 4769212795Sdim while(!NestedNames.empty()) { 4770212795Sdim NNS = NestedNames.pop_back_val(); 4771212795Sdim NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); 4772212795Sdim Record.push_back(Kind); 4773212795Sdim switch (Kind) { 4774212795Sdim case NestedNameSpecifier::Identifier: 4775212795Sdim AddIdentifierRef(NNS->getAsIdentifier(), Record); 4776212795Sdim break; 4777212795Sdim 4778212795Sdim case NestedNameSpecifier::Namespace: 4779212795Sdim AddDeclRef(NNS->getAsNamespace(), Record); 4780212795Sdim break; 4781212795Sdim 4782219077Sdim case NestedNameSpecifier::NamespaceAlias: 4783219077Sdim AddDeclRef(NNS->getAsNamespaceAlias(), Record); 4784219077Sdim break; 4785219077Sdim 4786212795Sdim case NestedNameSpecifier::TypeSpec: 4787212795Sdim case NestedNameSpecifier::TypeSpecWithTemplate: 4788212795Sdim AddTypeRef(QualType(NNS->getAsType(), 0), Record); 4789212795Sdim Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 4790212795Sdim break; 4791212795Sdim 4792212795Sdim case NestedNameSpecifier::Global: 4793212795Sdim // Don't need to write an associated value. 4794212795Sdim break; 4795212795Sdim } 4796212795Sdim } 4797212795Sdim} 4798212795Sdim 4799219077Sdimvoid ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 4800219077Sdim RecordDataImpl &Record) { 4801219077Sdim // Nested name specifiers usually aren't too long. I think that 8 would 4802221345Sdim // typically accommodate the vast majority. 4803226890Sdim SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 4804219077Sdim 4805219077Sdim // Push each of the nested-name-specifiers's onto a stack for 4806219077Sdim // serialization in reverse order. 4807219077Sdim while (NNS) { 4808219077Sdim NestedNames.push_back(NNS); 4809219077Sdim NNS = NNS.getPrefix(); 4810219077Sdim } 4811219077Sdim 4812219077Sdim Record.push_back(NestedNames.size()); 4813219077Sdim while(!NestedNames.empty()) { 4814219077Sdim NNS = NestedNames.pop_back_val(); 4815219077Sdim NestedNameSpecifier::SpecifierKind Kind 4816219077Sdim = NNS.getNestedNameSpecifier()->getKind(); 4817219077Sdim Record.push_back(Kind); 4818219077Sdim switch (Kind) { 4819219077Sdim case NestedNameSpecifier::Identifier: 4820219077Sdim AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record); 4821219077Sdim AddSourceRange(NNS.getLocalSourceRange(), Record); 4822219077Sdim break; 4823219077Sdim 4824219077Sdim case NestedNameSpecifier::Namespace: 4825219077Sdim AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record); 4826219077Sdim AddSourceRange(NNS.getLocalSourceRange(), Record); 4827219077Sdim break; 4828219077Sdim 4829219077Sdim case NestedNameSpecifier::NamespaceAlias: 4830219077Sdim AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record); 4831219077Sdim AddSourceRange(NNS.getLocalSourceRange(), Record); 4832219077Sdim break; 4833219077Sdim 4834219077Sdim case NestedNameSpecifier::TypeSpec: 4835219077Sdim case NestedNameSpecifier::TypeSpecWithTemplate: 4836219077Sdim Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 4837219077Sdim AddTypeLoc(NNS.getTypeLoc(), Record); 4838219077Sdim AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); 4839219077Sdim break; 4840219077Sdim 4841219077Sdim case NestedNameSpecifier::Global: 4842219077Sdim AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record); 4843219077Sdim break; 4844219077Sdim } 4845219077Sdim } 4846219077Sdim} 4847219077Sdim 4848218893Sdimvoid ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) { 4849218893Sdim TemplateName::NameKind Kind = Name.getKind(); 4850212795Sdim Record.push_back(Kind); 4851212795Sdim switch (Kind) { 4852212795Sdim case TemplateName::Template: 4853212795Sdim AddDeclRef(Name.getAsTemplateDecl(), Record); 4854212795Sdim break; 4855212795Sdim 4856212795Sdim case TemplateName::OverloadedTemplate: { 4857212795Sdim OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); 4858212795Sdim Record.push_back(OvT->size()); 4859212795Sdim for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end(); 4860212795Sdim I != E; ++I) 4861212795Sdim AddDeclRef(*I, Record); 4862212795Sdim break; 4863212795Sdim } 4864218893Sdim 4865212795Sdim case TemplateName::QualifiedTemplate: { 4866212795Sdim QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); 4867212795Sdim AddNestedNameSpecifier(QualT->getQualifier(), Record); 4868212795Sdim Record.push_back(QualT->hasTemplateKeyword()); 4869212795Sdim AddDeclRef(QualT->getTemplateDecl(), Record); 4870212795Sdim break; 4871212795Sdim } 4872218893Sdim 4873212795Sdim case TemplateName::DependentTemplate: { 4874212795Sdim DependentTemplateName *DepT = Name.getAsDependentTemplateName(); 4875212795Sdim AddNestedNameSpecifier(DepT->getQualifier(), Record); 4876212795Sdim Record.push_back(DepT->isIdentifier()); 4877212795Sdim if (DepT->isIdentifier()) 4878212795Sdim AddIdentifierRef(DepT->getIdentifier(), Record); 4879212795Sdim else 4880212795Sdim Record.push_back(DepT->getOperator()); 4881212795Sdim break; 4882212795Sdim } 4883224145Sdim 4884224145Sdim case TemplateName::SubstTemplateTemplateParm: { 4885224145Sdim SubstTemplateTemplateParmStorage *subst 4886224145Sdim = Name.getAsSubstTemplateTemplateParm(); 4887224145Sdim AddDeclRef(subst->getParameter(), Record); 4888224145Sdim AddTemplateName(subst->getReplacement(), Record); 4889224145Sdim break; 4890224145Sdim } 4891218893Sdim 4892218893Sdim case TemplateName::SubstTemplateTemplateParmPack: { 4893218893Sdim SubstTemplateTemplateParmPackStorage *SubstPack 4894218893Sdim = Name.getAsSubstTemplateTemplateParmPack(); 4895218893Sdim AddDeclRef(SubstPack->getParameterPack(), Record); 4896218893Sdim AddTemplateArgument(SubstPack->getArgumentPack(), Record); 4897218893Sdim break; 4898212795Sdim } 4899218893Sdim } 4900212795Sdim} 4901212795Sdim 4902218893Sdimvoid ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, 4903218893Sdim RecordDataImpl &Record) { 4904212795Sdim Record.push_back(Arg.getKind()); 4905212795Sdim switch (Arg.getKind()) { 4906212795Sdim case TemplateArgument::Null: 4907212795Sdim break; 4908212795Sdim case TemplateArgument::Type: 4909212795Sdim AddTypeRef(Arg.getAsType(), Record); 4910212795Sdim break; 4911212795Sdim case TemplateArgument::Declaration: 4912212795Sdim AddDeclRef(Arg.getAsDecl(), Record); 4913245431Sdim Record.push_back(Arg.isDeclForReferenceParam()); 4914212795Sdim break; 4915245431Sdim case TemplateArgument::NullPtr: 4916245431Sdim AddTypeRef(Arg.getNullPtrType(), Record); 4917245431Sdim break; 4918212795Sdim case TemplateArgument::Integral: 4919245431Sdim AddAPSInt(Arg.getAsIntegral(), Record); 4920212795Sdim AddTypeRef(Arg.getIntegralType(), Record); 4921212795Sdim break; 4922212795Sdim case TemplateArgument::Template: 4923218893Sdim AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); 4924212795Sdim break; 4925218893Sdim case TemplateArgument::TemplateExpansion: 4926218893Sdim AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); 4927252723Sdim if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions()) 4928218893Sdim Record.push_back(*NumExpansions + 1); 4929218893Sdim else 4930218893Sdim Record.push_back(0); 4931218893Sdim break; 4932212795Sdim case TemplateArgument::Expression: 4933212795Sdim AddStmt(Arg.getAsExpr()); 4934212795Sdim break; 4935212795Sdim case TemplateArgument::Pack: 4936212795Sdim Record.push_back(Arg.pack_size()); 4937212795Sdim for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); 4938212795Sdim I != E; ++I) 4939212795Sdim AddTemplateArgument(*I, Record); 4940212795Sdim break; 4941212795Sdim } 4942212795Sdim} 4943212795Sdim 4944212795Sdimvoid 4945212795SdimASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams, 4946218893Sdim RecordDataImpl &Record) { 4947212795Sdim assert(TemplateParams && "No TemplateParams!"); 4948212795Sdim AddSourceLocation(TemplateParams->getTemplateLoc(), Record); 4949212795Sdim AddSourceLocation(TemplateParams->getLAngleLoc(), Record); 4950212795Sdim AddSourceLocation(TemplateParams->getRAngleLoc(), Record); 4951212795Sdim Record.push_back(TemplateParams->size()); 4952212795Sdim for (TemplateParameterList::const_iterator 4953212795Sdim P = TemplateParams->begin(), PEnd = TemplateParams->end(); 4954212795Sdim P != PEnd; ++P) 4955212795Sdim AddDeclRef(*P, Record); 4956212795Sdim} 4957212795Sdim 4958212795Sdim/// \brief Emit a template argument list. 4959212795Sdimvoid 4960212795SdimASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs, 4961218893Sdim RecordDataImpl &Record) { 4962212795Sdim assert(TemplateArgs && "No TemplateArgs!"); 4963218893Sdim Record.push_back(TemplateArgs->size()); 4964218893Sdim for (int i=0, e = TemplateArgs->size(); i != e; ++i) 4965212795Sdim AddTemplateArgument(TemplateArgs->get(i), Record); 4966212795Sdim} 4967212795Sdim 4968263509Sdimvoid 4969263509SdimASTWriter::AddASTTemplateArgumentListInfo 4970263509Sdim(const ASTTemplateArgumentListInfo *ASTTemplArgList, RecordDataImpl &Record) { 4971263509Sdim assert(ASTTemplArgList && "No ASTTemplArgList!"); 4972263509Sdim AddSourceLocation(ASTTemplArgList->LAngleLoc, Record); 4973263509Sdim AddSourceLocation(ASTTemplArgList->RAngleLoc, Record); 4974263509Sdim Record.push_back(ASTTemplArgList->NumTemplateArgs); 4975263509Sdim const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs(); 4976263509Sdim for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) 4977263509Sdim AddTemplateArgumentLoc(TemplArgs[i], Record); 4978263509Sdim} 4979212795Sdim 4980212795Sdimvoid 4981252723SdimASTWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set, RecordDataImpl &Record) { 4982212795Sdim Record.push_back(Set.size()); 4983252723Sdim for (ASTUnresolvedSet::const_iterator 4984212795Sdim I = Set.begin(), E = Set.end(); I != E; ++I) { 4985212795Sdim AddDeclRef(I.getDecl(), Record); 4986212795Sdim Record.push_back(I.getAccess()); 4987212795Sdim } 4988212795Sdim} 4989212795Sdim 4990212795Sdimvoid ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, 4991218893Sdim RecordDataImpl &Record) { 4992212795Sdim Record.push_back(Base.isVirtual()); 4993212795Sdim Record.push_back(Base.isBaseOfClass()); 4994212795Sdim Record.push_back(Base.getAccessSpecifierAsWritten()); 4995218893Sdim Record.push_back(Base.getInheritConstructors()); 4996212795Sdim AddTypeSourceInfo(Base.getTypeSourceInfo(), Record); 4997212795Sdim AddSourceRange(Base.getSourceRange(), Record); 4998218893Sdim AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() 4999218893Sdim : SourceLocation(), 5000218893Sdim Record); 5001212795Sdim} 5002212795Sdim 5003218893Sdimvoid ASTWriter::FlushCXXBaseSpecifiers() { 5004218893Sdim RecordData Record; 5005218893Sdim for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) { 5006218893Sdim Record.clear(); 5007218893Sdim 5008218893Sdim // Record the offset of this base-specifier set. 5009226890Sdim unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1; 5010218893Sdim if (Index == CXXBaseSpecifiersOffsets.size()) 5011218893Sdim CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo()); 5012218893Sdim else { 5013218893Sdim if (Index > CXXBaseSpecifiersOffsets.size()) 5014218893Sdim CXXBaseSpecifiersOffsets.resize(Index + 1); 5015218893Sdim CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo(); 5016218893Sdim } 5017212795Sdim 5018218893Sdim const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases, 5019218893Sdim *BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd; 5020218893Sdim Record.push_back(BEnd - B); 5021218893Sdim for (; B != BEnd; ++B) 5022218893Sdim AddCXXBaseSpecifier(*B, Record); 5023218893Sdim Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record); 5024218893Sdim 5025218893Sdim // Flush any expressions that were written as part of the base specifiers. 5026218893Sdim FlushStmts(); 5027218893Sdim } 5028218893Sdim 5029218893Sdim CXXBaseSpecifiersToWrite.clear(); 5030218893Sdim} 5031218893Sdim 5032218893Sdimvoid ASTWriter::AddCXXCtorInitializers( 5033218893Sdim const CXXCtorInitializer * const *CtorInitializers, 5034218893Sdim unsigned NumCtorInitializers, 5035218893Sdim RecordDataImpl &Record) { 5036218893Sdim Record.push_back(NumCtorInitializers); 5037218893Sdim for (unsigned i=0; i != NumCtorInitializers; ++i) { 5038218893Sdim const CXXCtorInitializer *Init = CtorInitializers[i]; 5039218893Sdim 5040212795Sdim if (Init->isBaseInitializer()) { 5041223017Sdim Record.push_back(CTOR_INITIALIZER_BASE); 5042235633Sdim AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); 5043212795Sdim Record.push_back(Init->isBaseVirtual()); 5044223017Sdim } else if (Init->isDelegatingInitializer()) { 5045223017Sdim Record.push_back(CTOR_INITIALIZER_DELEGATING); 5046235633Sdim AddTypeSourceInfo(Init->getTypeSourceInfo(), Record); 5047223017Sdim } else if (Init->isMemberInitializer()){ 5048223017Sdim Record.push_back(CTOR_INITIALIZER_MEMBER); 5049223017Sdim AddDeclRef(Init->getMember(), Record); 5050212795Sdim } else { 5051223017Sdim Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); 5052223017Sdim AddDeclRef(Init->getIndirectMember(), Record); 5053212795Sdim } 5054218893Sdim 5055212795Sdim AddSourceLocation(Init->getMemberLocation(), Record); 5056212795Sdim AddStmt(Init->getInit()); 5057212795Sdim AddSourceLocation(Init->getLParenLoc(), Record); 5058212795Sdim AddSourceLocation(Init->getRParenLoc(), Record); 5059212795Sdim Record.push_back(Init->isWritten()); 5060212795Sdim if (Init->isWritten()) { 5061212795Sdim Record.push_back(Init->getSourceOrder()); 5062212795Sdim } else { 5063212795Sdim Record.push_back(Init->getNumArrayIndices()); 5064212795Sdim for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i) 5065212795Sdim AddDeclRef(Init->getArrayIndex(i), Record); 5066212795Sdim } 5067212795Sdim } 5068212795Sdim} 5069212795Sdim 5070218893Sdimvoid ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) { 5071218893Sdim assert(D->DefinitionData); 5072218893Sdim struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData; 5073235633Sdim Record.push_back(Data.IsLambda); 5074218893Sdim Record.push_back(Data.UserDeclaredConstructor); 5075252723Sdim Record.push_back(Data.UserDeclaredSpecialMembers); 5076218893Sdim Record.push_back(Data.Aggregate); 5077218893Sdim Record.push_back(Data.PlainOldData); 5078218893Sdim Record.push_back(Data.Empty); 5079218893Sdim Record.push_back(Data.Polymorphic); 5080218893Sdim Record.push_back(Data.Abstract); 5081221345Sdim Record.push_back(Data.IsStandardLayout); 5082221345Sdim Record.push_back(Data.HasNoNonEmptyBases); 5083221345Sdim Record.push_back(Data.HasPrivateFields); 5084221345Sdim Record.push_back(Data.HasProtectedFields); 5085221345Sdim Record.push_back(Data.HasPublicFields); 5086223017Sdim Record.push_back(Data.HasMutableFields); 5087235633Sdim Record.push_back(Data.HasOnlyCMembers); 5088245431Sdim Record.push_back(Data.HasInClassInitializer); 5089252723Sdim Record.push_back(Data.HasUninitializedReferenceMember); 5090252723Sdim Record.push_back(Data.NeedOverloadResolutionForMoveConstructor); 5091252723Sdim Record.push_back(Data.NeedOverloadResolutionForMoveAssignment); 5092252723Sdim Record.push_back(Data.NeedOverloadResolutionForDestructor); 5093252723Sdim Record.push_back(Data.DefaultedMoveConstructorIsDeleted); 5094252723Sdim Record.push_back(Data.DefaultedMoveAssignmentIsDeleted); 5095252723Sdim Record.push_back(Data.DefaultedDestructorIsDeleted); 5096252723Sdim Record.push_back(Data.HasTrivialSpecialMembers); 5097252723Sdim Record.push_back(Data.HasIrrelevantDestructor); 5098226890Sdim Record.push_back(Data.HasConstexprNonCopyMoveConstructor); 5099235633Sdim Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr); 5100235633Sdim Record.push_back(Data.HasConstexprDefaultConstructor); 5101221345Sdim Record.push_back(Data.HasNonLiteralTypeFieldsOrBases); 5102218893Sdim Record.push_back(Data.ComputedVisibleConversions); 5103223017Sdim Record.push_back(Data.UserProvidedDefaultConstructor); 5104252723Sdim Record.push_back(Data.DeclaredSpecialMembers); 5105252723Sdim Record.push_back(Data.ImplicitCopyConstructorHasConstParam); 5106252723Sdim Record.push_back(Data.ImplicitCopyAssignmentHasConstParam); 5107252723Sdim Record.push_back(Data.HasDeclaredCopyConstructorWithConstParam); 5108252723Sdim Record.push_back(Data.HasDeclaredCopyAssignmentWithConstParam); 5109235633Sdim // IsLambda bit is already saved. 5110218893Sdim 5111218893Sdim Record.push_back(Data.NumBases); 5112218893Sdim if (Data.NumBases > 0) 5113218893Sdim AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases, 5114218893Sdim Record); 5115218893Sdim 5116218893Sdim // FIXME: Make VBases lazily computed when needed to avoid storing them. 5117218893Sdim Record.push_back(Data.NumVBases); 5118218893Sdim if (Data.NumVBases > 0) 5119218893Sdim AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases, 5120218893Sdim Record); 5121218893Sdim 5122263509Sdim AddUnresolvedSet(Data.Conversions.get(*Context), Record); 5123263509Sdim AddUnresolvedSet(Data.VisibleConversions.get(*Context), Record); 5124218893Sdim // Data.Definition is the owning decl, no need to write it. 5125263509Sdim AddDeclRef(D->getFirstFriend(), Record); 5126235633Sdim 5127235633Sdim // Add lambda-specific data. 5128235633Sdim if (Data.IsLambda) { 5129235633Sdim CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData(); 5130235633Sdim Record.push_back(Lambda.Dependent); 5131263509Sdim Record.push_back(Lambda.IsGenericLambda); 5132263509Sdim Record.push_back(Lambda.CaptureDefault); 5133235633Sdim Record.push_back(Lambda.NumCaptures); 5134235633Sdim Record.push_back(Lambda.NumExplicitCaptures); 5135235633Sdim Record.push_back(Lambda.ManglingNumber); 5136235633Sdim AddDeclRef(Lambda.ContextDecl, Record); 5137245431Sdim AddTypeSourceInfo(Lambda.MethodTyInfo, Record); 5138235633Sdim for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { 5139235633Sdim LambdaExpr::Capture &Capture = Lambda.Captures[I]; 5140235633Sdim AddSourceLocation(Capture.getLocation(), Record); 5141235633Sdim Record.push_back(Capture.isImplicit()); 5142263509Sdim Record.push_back(Capture.getCaptureKind()); 5143263509Sdim switch (Capture.getCaptureKind()) { 5144263509Sdim case LCK_This: 5145263509Sdim break; 5146263509Sdim case LCK_ByCopy: 5147263509Sdim case LCK_ByRef: 5148263509Sdim VarDecl *Var = 5149263509Sdim Capture.capturesVariable() ? Capture.getCapturedVar() : 0; 5150263509Sdim AddDeclRef(Var, Record); 5151263509Sdim AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc() 5152263509Sdim : SourceLocation(), 5153263509Sdim Record); 5154263509Sdim break; 5155263509Sdim } 5156235633Sdim } 5157235633Sdim } 5158218893Sdim} 5159218893Sdim 5160218893Sdimvoid ASTWriter::ReaderInitialized(ASTReader *Reader) { 5161212795Sdim assert(Reader && "Cannot remove chain"); 5162226890Sdim assert((!Chain || Chain == Reader) && "Cannot replace chain"); 5163212795Sdim assert(FirstDeclID == NextDeclID && 5164212795Sdim FirstTypeID == NextTypeID && 5165212795Sdim FirstIdentID == NextIdentID && 5166245431Sdim FirstMacroID == NextMacroID && 5167235633Sdim FirstSubmoduleID == NextSubmoduleID && 5168212795Sdim FirstSelectorID == NextSelectorID && 5169212795Sdim "Setting chain after writing has started."); 5170226890Sdim 5171212795Sdim Chain = Reader; 5172218893Sdim 5173226890Sdim FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); 5174226890Sdim FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); 5175226890Sdim FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); 5176245431Sdim FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros(); 5177235633Sdim FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); 5178226890Sdim FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); 5179218893Sdim NextDeclID = FirstDeclID; 5180218893Sdim NextTypeID = FirstTypeID; 5181218893Sdim NextIdentID = FirstIdentID; 5182245431Sdim NextMacroID = FirstMacroID; 5183218893Sdim NextSelectorID = FirstSelectorID; 5184235633Sdim NextSubmoduleID = FirstSubmoduleID; 5185212795Sdim} 5186212795Sdim 5187212795Sdimvoid ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { 5188252723Sdim // Always keep the highest ID. See \p TypeRead() for more information. 5189252723Sdim IdentID &StoredID = IdentifierIDs[II]; 5190252723Sdim if (ID > StoredID) 5191252723Sdim StoredID = ID; 5192212795Sdim} 5193212795Sdim 5194245431Sdimvoid ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) { 5195252723Sdim // Always keep the highest ID. See \p TypeRead() for more information. 5196252723Sdim MacroID &StoredID = MacroIDs[MI]; 5197252723Sdim if (ID > StoredID) 5198252723Sdim StoredID = ID; 5199245431Sdim} 5200245431Sdim 5201212795Sdimvoid ASTWriter::TypeRead(TypeIdx Idx, QualType T) { 5202218893Sdim // Always take the highest-numbered type index. This copes with an interesting 5203218893Sdim // case for chained AST writing where we schedule writing the type and then, 5204218893Sdim // later, deserialize the type from another AST. In this case, we want to 5205218893Sdim // keep the higher-numbered entry so that we can properly write it out to 5206218893Sdim // the AST file. 5207218893Sdim TypeIdx &StoredIdx = TypeIdxs[T]; 5208218893Sdim if (Idx.getIndex() >= StoredIdx.getIndex()) 5209218893Sdim StoredIdx = Idx; 5210212795Sdim} 5211212795Sdim 5212212795Sdimvoid ASTWriter::SelectorRead(SelectorID ID, Selector S) { 5213252723Sdim // Always keep the highest ID. See \p TypeRead() for more information. 5214252723Sdim SelectorID &StoredID = SelectorIDs[S]; 5215252723Sdim if (ID > StoredID) 5216252723Sdim StoredID = ID; 5217212795Sdim} 5218218893Sdim 5219226890Sdimvoid ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, 5220218893Sdim MacroDefinition *MD) { 5221226890Sdim assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); 5222218893Sdim MacroDefinitions[MD] = ID; 5223218893Sdim} 5224218893Sdim 5225235633Sdimvoid ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { 5226235633Sdim assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); 5227235633Sdim SubmoduleIDs[Mod] = ID; 5228235633Sdim} 5229235633Sdim 5230218893Sdimvoid ASTWriter::CompletedTagDefinition(const TagDecl *D) { 5231226890Sdim assert(D->isCompleteDefinition()); 5232226890Sdim assert(!WritingAST && "Already writing the AST!"); 5233218893Sdim if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 5234218893Sdim // We are interested when a PCH decl is modified. 5235226890Sdim if (RD->isFromASTFile()) { 5236218893Sdim // A forward reference was mutated into a definition. Rewrite it. 5237218893Sdim // FIXME: This happens during template instantiation, should we 5238218893Sdim // have created a new definition decl instead ? 5239218893Sdim RewriteDecl(RD); 5240218893Sdim } 5241218893Sdim } 5242218893Sdim} 5243245431Sdim 5244218893Sdimvoid ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { 5245226890Sdim assert(!WritingAST && "Already writing the AST!"); 5246226890Sdim 5247218893Sdim // TU and namespaces are handled elsewhere. 5248218893Sdim if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC)) 5249218893Sdim return; 5250218893Sdim 5251226890Sdim if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile())) 5252218893Sdim return; // Not a source decl added to a DeclContext from PCH. 5253218893Sdim 5254252723Sdim assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!"); 5255218893Sdim AddUpdatedDeclContext(DC); 5256245431Sdim UpdatingVisibleDecls.push_back(D); 5257218893Sdim} 5258218893Sdim 5259218893Sdimvoid ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { 5260226890Sdim assert(!WritingAST && "Already writing the AST!"); 5261218893Sdim assert(D->isImplicit()); 5262226890Sdim if (!(!D->isFromASTFile() && RD->isFromASTFile())) 5263218893Sdim return; // Not a source member added to a class from PCH. 5264218893Sdim if (!isa<CXXMethodDecl>(D)) 5265218893Sdim return; // We are interested in lazily declared implicit methods. 5266218893Sdim 5267218893Sdim // A decl coming from PCH was modified. 5268226890Sdim assert(RD->isCompleteDefinition()); 5269218893Sdim UpdateRecord &Record = DeclUpdates[RD]; 5270218893Sdim Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER); 5271226890Sdim Record.push_back(reinterpret_cast<uint64_t>(D)); 5272218893Sdim} 5273218893Sdim 5274218893Sdimvoid ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, 5275218893Sdim const ClassTemplateSpecializationDecl *D) { 5276218893Sdim // The specializations set is kept in the canonical template. 5277226890Sdim assert(!WritingAST && "Already writing the AST!"); 5278218893Sdim TD = TD->getCanonicalDecl(); 5279226890Sdim if (!(!D->isFromASTFile() && TD->isFromASTFile())) 5280218893Sdim return; // Not a source specialization added to a template from PCH. 5281218893Sdim 5282218893Sdim UpdateRecord &Record = DeclUpdates[TD]; 5283218893Sdim Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 5284226890Sdim Record.push_back(reinterpret_cast<uint64_t>(D)); 5285218893Sdim} 5286218893Sdim 5287263509Sdimvoid ASTWriter::AddedCXXTemplateSpecialization( 5288263509Sdim const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { 5289263509Sdim // The specializations set is kept in the canonical template. 5290263509Sdim assert(!WritingAST && "Already writing the AST!"); 5291263509Sdim TD = TD->getCanonicalDecl(); 5292263509Sdim if (!(!D->isFromASTFile() && TD->isFromASTFile())) 5293263509Sdim return; // Not a source specialization added to a template from PCH. 5294263509Sdim 5295263509Sdim UpdateRecord &Record = DeclUpdates[TD]; 5296263509Sdim Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 5297263509Sdim Record.push_back(reinterpret_cast<uint64_t>(D)); 5298263509Sdim} 5299263509Sdim 5300221345Sdimvoid ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 5301221345Sdim const FunctionDecl *D) { 5302221345Sdim // The specializations set is kept in the canonical template. 5303226890Sdim assert(!WritingAST && "Already writing the AST!"); 5304221345Sdim TD = TD->getCanonicalDecl(); 5305226890Sdim if (!(!D->isFromASTFile() && TD->isFromASTFile())) 5306221345Sdim return; // Not a source specialization added to a template from PCH. 5307221345Sdim 5308221345Sdim UpdateRecord &Record = DeclUpdates[TD]; 5309221345Sdim Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION); 5310226890Sdim Record.push_back(reinterpret_cast<uint64_t>(D)); 5311221345Sdim} 5312221345Sdim 5313263509Sdimvoid ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { 5314263509Sdim assert(!WritingAST && "Already writing the AST!"); 5315263509Sdim FD = FD->getCanonicalDecl(); 5316263509Sdim if (!FD->isFromASTFile()) 5317263509Sdim return; // Not a function declared in PCH and defined outside. 5318263509Sdim 5319263509Sdim UpdateRecord &Record = DeclUpdates[FD]; 5320263509Sdim Record.push_back(UPD_CXX_DEDUCED_RETURN_TYPE); 5321263509Sdim Record.push_back(reinterpret_cast<uint64_t>(ReturnType.getAsOpaquePtr())); 5322263509Sdim} 5323263509Sdim 5324221345Sdimvoid ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { 5325226890Sdim assert(!WritingAST && "Already writing the AST!"); 5326226890Sdim if (!D->isFromASTFile()) 5327221345Sdim return; // Declaration not imported from PCH. 5328221345Sdim 5329221345Sdim // Implicit decl from a PCH was defined. 5330221345Sdim // FIXME: Should implicit definition be a separate FunctionDecl? 5331221345Sdim RewriteDecl(D); 5332221345Sdim} 5333221345Sdim 5334221345Sdimvoid ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { 5335226890Sdim assert(!WritingAST && "Already writing the AST!"); 5336226890Sdim if (!D->isFromASTFile()) 5337221345Sdim return; 5338221345Sdim 5339221345Sdim // Since the actual instantiation is delayed, this really means that we need 5340221345Sdim // to update the instantiation location. 5341221345Sdim UpdateRecord &Record = DeclUpdates[D]; 5342221345Sdim Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER); 5343221345Sdim AddSourceLocation( 5344221345Sdim D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record); 5345221345Sdim} 5346221345Sdim 5347226890Sdimvoid ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 5348226890Sdim const ObjCInterfaceDecl *IFD) { 5349226890Sdim assert(!WritingAST && "Already writing the AST!"); 5350226890Sdim if (!IFD->isFromASTFile()) 5351226890Sdim return; // Declaration not imported from PCH. 5352235633Sdim 5353235633Sdim assert(IFD->getDefinition() && "Category on a class without a definition?"); 5354235633Sdim ObjCClassesWithCategories.insert( 5355235633Sdim const_cast<ObjCInterfaceDecl *>(IFD->getDefinition())); 5356235633Sdim} 5357226890Sdim 5358235633Sdim 5359235633Sdimvoid ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, 5360235633Sdim const ObjCPropertyDecl *OrigProp, 5361235633Sdim const ObjCCategoryDecl *ClassExt) { 5362235633Sdim const ObjCInterfaceDecl *D = ClassExt->getClassInterface(); 5363235633Sdim if (!D) 5364235633Sdim return; 5365235633Sdim 5366235633Sdim assert(!WritingAST && "Already writing the AST!"); 5367235633Sdim if (!D->isFromASTFile()) 5368235633Sdim return; // Declaration not imported from PCH. 5369235633Sdim 5370235633Sdim RewriteDecl(D); 5371226890Sdim} 5372263509Sdim 5373263509Sdimvoid ASTWriter::DeclarationMarkedUsed(const Decl *D) { 5374263509Sdim assert(!WritingAST && "Already writing the AST!"); 5375263509Sdim if (!D->isFromASTFile()) 5376263509Sdim return; 5377263509Sdim 5378263509Sdim UpdateRecord &Record = DeclUpdates[D]; 5379263509Sdim Record.push_back(UPD_DECL_MARKED_USED); 5380263509Sdim} 5381