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