1 //===--- ASTWriter.cpp - AST File Writer ------------------------*- C++ -*-===// 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 "clang/Serialization/ModuleFileExtension.h" 16 #include "ASTCommon.h" 17 #include "ASTReaderInternals.h" 18 #include "MultiOnDiskHashTable.h" 19 #include "clang/AST/ASTContext.h" 20 #include "clang/AST/Decl.h" 21 #include "clang/AST/DeclContextInternals.h" 22 #include "clang/AST/DeclFriend.h" 23 #include "clang/AST/DeclLookups.h" 24 #include "clang/AST/DeclTemplate.h" 25 #include "clang/AST/Expr.h" 26 #include "clang/AST/ExprCXX.h" 27 #include "clang/AST/Type.h" 28 #include "clang/AST/TypeLocVisitor.h" 29 #include "clang/Basic/DiagnosticOptions.h" 30 #include "clang/Basic/FileManager.h" 31 #include "clang/Basic/FileSystemStatCache.h" 32 #include "clang/Basic/SourceManager.h" 33 #include "clang/Basic/SourceManagerInternals.h" 34 #include "clang/Basic/TargetInfo.h" 35 #include "clang/Basic/TargetOptions.h" 36 #include "clang/Basic/Version.h" 37 #include "clang/Basic/VersionTuple.h" 38 #include "clang/Lex/HeaderSearch.h" 39 #include "clang/Lex/HeaderSearchOptions.h" 40 #include "clang/Lex/MacroInfo.h" 41 #include "clang/Lex/PreprocessingRecord.h" 42 #include "clang/Lex/Preprocessor.h" 43 #include "clang/Lex/PreprocessorOptions.h" 44 #include "clang/Sema/IdentifierResolver.h" 45 #include "clang/Sema/Sema.h" 46 #include "clang/Serialization/ASTReader.h" 47 #include "clang/Serialization/SerializationDiagnostic.h" 48 #include "llvm/ADT/APFloat.h" 49 #include "llvm/ADT/APInt.h" 50 #include "llvm/ADT/Hashing.h" 51 #include "llvm/ADT/StringExtras.h" 52 #include "llvm/Bitcode/BitstreamWriter.h" 53 #include "llvm/Support/Compression.h" 54 #include "llvm/Support/EndianStream.h" 55 #include "llvm/Support/FileSystem.h" 56 #include "llvm/Support/MemoryBuffer.h" 57 #include "llvm/Support/OnDiskHashTable.h" 58 #include "llvm/Support/Path.h" 59 #include "llvm/Support/Process.h" 60 #include <algorithm> 61 #include <cstdio> 62 #include <string.h> 63 #include <utility> 64 65 using namespace clang; 66 using namespace clang::serialization; 67 68 template <typename T, typename Allocator> 69 static StringRef bytes(const std::vector<T, Allocator> &v) { 70 if (v.empty()) return StringRef(); 71 return StringRef(reinterpret_cast<const char*>(&v[0]), 72 sizeof(T) * v.size()); 73 } 74 75 template <typename T> 76 static StringRef bytes(const SmallVectorImpl<T> &v) { 77 return StringRef(reinterpret_cast<const char*>(v.data()), 78 sizeof(T) * v.size()); 79 } 80 81 //===----------------------------------------------------------------------===// 82 // Type serialization 83 //===----------------------------------------------------------------------===// 84 85 namespace clang { 86 class ASTTypeWriter { 87 ASTWriter &Writer; 88 ASTRecordWriter Record; 89 90 /// \brief Type code that corresponds to the record generated. 91 TypeCode Code; 92 /// \brief Abbreviation to use for the record, if any. 93 unsigned AbbrevToUse; 94 95 public: 96 ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record) 97 : Writer(Writer), Record(Writer, Record), Code((TypeCode)0), AbbrevToUse(0) { } 98 99 uint64_t Emit() { 100 return Record.Emit(Code, AbbrevToUse); 101 } 102 103 void Visit(QualType T) { 104 if (T.hasLocalNonFastQualifiers()) { 105 Qualifiers Qs = T.getLocalQualifiers(); 106 Record.AddTypeRef(T.getLocalUnqualifiedType()); 107 Record.push_back(Qs.getAsOpaqueValue()); 108 Code = TYPE_EXT_QUAL; 109 AbbrevToUse = Writer.TypeExtQualAbbrev; 110 } else { 111 switch (T->getTypeClass()) { 112 // For all of the concrete, non-dependent types, call the 113 // appropriate visitor function. 114 #define TYPE(Class, Base) \ 115 case Type::Class: Visit##Class##Type(cast<Class##Type>(T)); break; 116 #define ABSTRACT_TYPE(Class, Base) 117 #include "clang/AST/TypeNodes.def" 118 } 119 } 120 } 121 122 void VisitArrayType(const ArrayType *T); 123 void VisitFunctionType(const FunctionType *T); 124 void VisitTagType(const TagType *T); 125 126 #define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T); 127 #define ABSTRACT_TYPE(Class, Base) 128 #include "clang/AST/TypeNodes.def" 129 }; 130 } // end namespace clang 131 132 void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) { 133 llvm_unreachable("Built-in types are never serialized"); 134 } 135 136 void ASTTypeWriter::VisitComplexType(const ComplexType *T) { 137 Record.AddTypeRef(T->getElementType()); 138 Code = TYPE_COMPLEX; 139 } 140 141 void ASTTypeWriter::VisitPointerType(const PointerType *T) { 142 Record.AddTypeRef(T->getPointeeType()); 143 Code = TYPE_POINTER; 144 } 145 146 void ASTTypeWriter::VisitDecayedType(const DecayedType *T) { 147 Record.AddTypeRef(T->getOriginalType()); 148 Code = TYPE_DECAYED; 149 } 150 151 void ASTTypeWriter::VisitAdjustedType(const AdjustedType *T) { 152 Record.AddTypeRef(T->getOriginalType()); 153 Record.AddTypeRef(T->getAdjustedType()); 154 Code = TYPE_ADJUSTED; 155 } 156 157 void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { 158 Record.AddTypeRef(T->getPointeeType()); 159 Code = TYPE_BLOCK_POINTER; 160 } 161 162 void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) { 163 Record.AddTypeRef(T->getPointeeTypeAsWritten()); 164 Record.push_back(T->isSpelledAsLValue()); 165 Code = TYPE_LVALUE_REFERENCE; 166 } 167 168 void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { 169 Record.AddTypeRef(T->getPointeeTypeAsWritten()); 170 Code = TYPE_RVALUE_REFERENCE; 171 } 172 173 void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { 174 Record.AddTypeRef(T->getPointeeType()); 175 Record.AddTypeRef(QualType(T->getClass(), 0)); 176 Code = TYPE_MEMBER_POINTER; 177 } 178 179 void ASTTypeWriter::VisitArrayType(const ArrayType *T) { 180 Record.AddTypeRef(T->getElementType()); 181 Record.push_back(T->getSizeModifier()); // FIXME: stable values 182 Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values 183 } 184 185 void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) { 186 VisitArrayType(T); 187 Record.AddAPInt(T->getSize()); 188 Code = TYPE_CONSTANT_ARRAY; 189 } 190 191 void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 192 VisitArrayType(T); 193 Code = TYPE_INCOMPLETE_ARRAY; 194 } 195 196 void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { 197 VisitArrayType(T); 198 Record.AddSourceLocation(T->getLBracketLoc()); 199 Record.AddSourceLocation(T->getRBracketLoc()); 200 Record.AddStmt(T->getSizeExpr()); 201 Code = TYPE_VARIABLE_ARRAY; 202 } 203 204 void ASTTypeWriter::VisitVectorType(const VectorType *T) { 205 Record.AddTypeRef(T->getElementType()); 206 Record.push_back(T->getNumElements()); 207 Record.push_back(T->getVectorKind()); 208 Code = TYPE_VECTOR; 209 } 210 211 void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) { 212 VisitVectorType(T); 213 Code = TYPE_EXT_VECTOR; 214 } 215 216 void ASTTypeWriter::VisitFunctionType(const FunctionType *T) { 217 Record.AddTypeRef(T->getReturnType()); 218 FunctionType::ExtInfo C = T->getExtInfo(); 219 Record.push_back(C.getNoReturn()); 220 Record.push_back(C.getHasRegParm()); 221 Record.push_back(C.getRegParm()); 222 // FIXME: need to stabilize encoding of calling convention... 223 Record.push_back(C.getCC()); 224 Record.push_back(C.getProducesResult()); 225 226 if (C.getHasRegParm() || C.getRegParm() || C.getProducesResult()) 227 AbbrevToUse = 0; 228 } 229 230 void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 231 VisitFunctionType(T); 232 Code = TYPE_FUNCTION_NO_PROTO; 233 } 234 235 static void addExceptionSpec(const FunctionProtoType *T, 236 ASTRecordWriter &Record) { 237 Record.push_back(T->getExceptionSpecType()); 238 if (T->getExceptionSpecType() == EST_Dynamic) { 239 Record.push_back(T->getNumExceptions()); 240 for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) 241 Record.AddTypeRef(T->getExceptionType(I)); 242 } else if (T->getExceptionSpecType() == EST_ComputedNoexcept) { 243 Record.AddStmt(T->getNoexceptExpr()); 244 } else if (T->getExceptionSpecType() == EST_Uninstantiated) { 245 Record.AddDeclRef(T->getExceptionSpecDecl()); 246 Record.AddDeclRef(T->getExceptionSpecTemplate()); 247 } else if (T->getExceptionSpecType() == EST_Unevaluated) { 248 Record.AddDeclRef(T->getExceptionSpecDecl()); 249 } 250 } 251 252 void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) { 253 VisitFunctionType(T); 254 255 Record.push_back(T->isVariadic()); 256 Record.push_back(T->hasTrailingReturn()); 257 Record.push_back(T->getTypeQuals()); 258 Record.push_back(static_cast<unsigned>(T->getRefQualifier())); 259 addExceptionSpec(T, Record); 260 261 Record.push_back(T->getNumParams()); 262 for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) 263 Record.AddTypeRef(T->getParamType(I)); 264 265 if (T->hasExtParameterInfos()) { 266 for (unsigned I = 0, N = T->getNumParams(); I != N; ++I) 267 Record.push_back(T->getExtParameterInfo(I).getOpaqueValue()); 268 } 269 270 if (T->isVariadic() || T->hasTrailingReturn() || T->getTypeQuals() || 271 T->getRefQualifier() || T->getExceptionSpecType() != EST_None || 272 T->hasExtParameterInfos()) 273 AbbrevToUse = 0; 274 275 Code = TYPE_FUNCTION_PROTO; 276 } 277 278 void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) { 279 Record.AddDeclRef(T->getDecl()); 280 Code = TYPE_UNRESOLVED_USING; 281 } 282 283 void ASTTypeWriter::VisitTypedefType(const TypedefType *T) { 284 Record.AddDeclRef(T->getDecl()); 285 assert(!T->isCanonicalUnqualified() && "Invalid typedef ?"); 286 Record.AddTypeRef(T->getCanonicalTypeInternal()); 287 Code = TYPE_TYPEDEF; 288 } 289 290 void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { 291 Record.AddStmt(T->getUnderlyingExpr()); 292 Code = TYPE_TYPEOF_EXPR; 293 } 294 295 void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) { 296 Record.AddTypeRef(T->getUnderlyingType()); 297 Code = TYPE_TYPEOF; 298 } 299 300 void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) { 301 Record.AddTypeRef(T->getUnderlyingType()); 302 Record.AddStmt(T->getUnderlyingExpr()); 303 Code = TYPE_DECLTYPE; 304 } 305 306 void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) { 307 Record.AddTypeRef(T->getBaseType()); 308 Record.AddTypeRef(T->getUnderlyingType()); 309 Record.push_back(T->getUTTKind()); 310 Code = TYPE_UNARY_TRANSFORM; 311 } 312 313 void ASTTypeWriter::VisitAutoType(const AutoType *T) { 314 Record.AddTypeRef(T->getDeducedType()); 315 Record.push_back((unsigned)T->getKeyword()); 316 if (T->getDeducedType().isNull()) 317 Record.push_back(T->isDependentType()); 318 Code = TYPE_AUTO; 319 } 320 321 void ASTTypeWriter::VisitTagType(const TagType *T) { 322 Record.push_back(T->isDependentType()); 323 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); 324 assert(!T->isBeingDefined() && 325 "Cannot serialize in the middle of a type definition"); 326 } 327 328 void ASTTypeWriter::VisitRecordType(const RecordType *T) { 329 VisitTagType(T); 330 Code = TYPE_RECORD; 331 } 332 333 void ASTTypeWriter::VisitEnumType(const EnumType *T) { 334 VisitTagType(T); 335 Code = TYPE_ENUM; 336 } 337 338 void ASTTypeWriter::VisitAttributedType(const AttributedType *T) { 339 Record.AddTypeRef(T->getModifiedType()); 340 Record.AddTypeRef(T->getEquivalentType()); 341 Record.push_back(T->getAttrKind()); 342 Code = TYPE_ATTRIBUTED; 343 } 344 345 void 346 ASTTypeWriter::VisitSubstTemplateTypeParmType( 347 const SubstTemplateTypeParmType *T) { 348 Record.AddTypeRef(QualType(T->getReplacedParameter(), 0)); 349 Record.AddTypeRef(T->getReplacementType()); 350 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM; 351 } 352 353 void 354 ASTTypeWriter::VisitSubstTemplateTypeParmPackType( 355 const SubstTemplateTypeParmPackType *T) { 356 Record.AddTypeRef(QualType(T->getReplacedParameter(), 0)); 357 Record.AddTemplateArgument(T->getArgumentPack()); 358 Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK; 359 } 360 361 void 362 ASTTypeWriter::VisitTemplateSpecializationType( 363 const TemplateSpecializationType *T) { 364 Record.push_back(T->isDependentType()); 365 Record.AddTemplateName(T->getTemplateName()); 366 Record.push_back(T->getNumArgs()); 367 for (const auto &ArgI : *T) 368 Record.AddTemplateArgument(ArgI); 369 Record.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() 370 : T->isCanonicalUnqualified() 371 ? QualType() 372 : T->getCanonicalTypeInternal()); 373 Code = TYPE_TEMPLATE_SPECIALIZATION; 374 } 375 376 void 377 ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) { 378 VisitArrayType(T); 379 Record.AddStmt(T->getSizeExpr()); 380 Record.AddSourceRange(T->getBracketsRange()); 381 Code = TYPE_DEPENDENT_SIZED_ARRAY; 382 } 383 384 void 385 ASTTypeWriter::VisitDependentSizedExtVectorType( 386 const DependentSizedExtVectorType *T) { 387 // FIXME: Serialize this type (C++ only) 388 llvm_unreachable("Cannot serialize dependent sized extended vector types"); 389 } 390 391 void 392 ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 393 Record.push_back(T->getDepth()); 394 Record.push_back(T->getIndex()); 395 Record.push_back(T->isParameterPack()); 396 Record.AddDeclRef(T->getDecl()); 397 Code = TYPE_TEMPLATE_TYPE_PARM; 398 } 399 400 void 401 ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) { 402 Record.push_back(T->getKeyword()); 403 Record.AddNestedNameSpecifier(T->getQualifier()); 404 Record.AddIdentifierRef(T->getIdentifier()); 405 Record.AddTypeRef( 406 T->isCanonicalUnqualified() ? QualType() : T->getCanonicalTypeInternal()); 407 Code = TYPE_DEPENDENT_NAME; 408 } 409 410 void 411 ASTTypeWriter::VisitDependentTemplateSpecializationType( 412 const DependentTemplateSpecializationType *T) { 413 Record.push_back(T->getKeyword()); 414 Record.AddNestedNameSpecifier(T->getQualifier()); 415 Record.AddIdentifierRef(T->getIdentifier()); 416 Record.push_back(T->getNumArgs()); 417 for (const auto &I : *T) 418 Record.AddTemplateArgument(I); 419 Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION; 420 } 421 422 void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { 423 Record.AddTypeRef(T->getPattern()); 424 if (Optional<unsigned> NumExpansions = T->getNumExpansions()) 425 Record.push_back(*NumExpansions + 1); 426 else 427 Record.push_back(0); 428 Code = TYPE_PACK_EXPANSION; 429 } 430 431 void ASTTypeWriter::VisitParenType(const ParenType *T) { 432 Record.AddTypeRef(T->getInnerType()); 433 Code = TYPE_PAREN; 434 } 435 436 void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) { 437 Record.push_back(T->getKeyword()); 438 Record.AddNestedNameSpecifier(T->getQualifier()); 439 Record.AddTypeRef(T->getNamedType()); 440 Code = TYPE_ELABORATED; 441 } 442 443 void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) { 444 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); 445 Record.AddTypeRef(T->getInjectedSpecializationType()); 446 Code = TYPE_INJECTED_CLASS_NAME; 447 } 448 449 void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 450 Record.AddDeclRef(T->getDecl()->getCanonicalDecl()); 451 Code = TYPE_OBJC_INTERFACE; 452 } 453 454 void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) { 455 Record.AddTypeRef(T->getBaseType()); 456 Record.push_back(T->getTypeArgsAsWritten().size()); 457 for (auto TypeArg : T->getTypeArgsAsWritten()) 458 Record.AddTypeRef(TypeArg); 459 Record.push_back(T->getNumProtocols()); 460 for (const auto *I : T->quals()) 461 Record.AddDeclRef(I); 462 Record.push_back(T->isKindOfTypeAsWritten()); 463 Code = TYPE_OBJC_OBJECT; 464 } 465 466 void 467 ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 468 Record.AddTypeRef(T->getPointeeType()); 469 Code = TYPE_OBJC_OBJECT_POINTER; 470 } 471 472 void 473 ASTTypeWriter::VisitAtomicType(const AtomicType *T) { 474 Record.AddTypeRef(T->getValueType()); 475 Code = TYPE_ATOMIC; 476 } 477 478 void 479 ASTTypeWriter::VisitPipeType(const PipeType *T) { 480 Record.AddTypeRef(T->getElementType()); 481 Code = TYPE_PIPE; 482 } 483 484 namespace { 485 486 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> { 487 ASTRecordWriter &Record; 488 489 public: 490 TypeLocWriter(ASTRecordWriter &Record) 491 : Record(Record) { } 492 493 #define ABSTRACT_TYPELOC(CLASS, PARENT) 494 #define TYPELOC(CLASS, PARENT) \ 495 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 496 #include "clang/AST/TypeLocNodes.def" 497 498 void VisitArrayTypeLoc(ArrayTypeLoc TyLoc); 499 void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc); 500 }; 501 502 } // end anonymous namespace 503 504 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 505 // nothing to do 506 } 507 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 508 Record.AddSourceLocation(TL.getBuiltinLoc()); 509 if (TL.needsExtraLocalData()) { 510 Record.push_back(TL.getWrittenTypeSpec()); 511 Record.push_back(TL.getWrittenSignSpec()); 512 Record.push_back(TL.getWrittenWidthSpec()); 513 Record.push_back(TL.hasModeAttr()); 514 } 515 } 516 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) { 517 Record.AddSourceLocation(TL.getNameLoc()); 518 } 519 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) { 520 Record.AddSourceLocation(TL.getStarLoc()); 521 } 522 void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) { 523 // nothing to do 524 } 525 void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { 526 // nothing to do 527 } 528 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 529 Record.AddSourceLocation(TL.getCaretLoc()); 530 } 531 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 532 Record.AddSourceLocation(TL.getAmpLoc()); 533 } 534 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 535 Record.AddSourceLocation(TL.getAmpAmpLoc()); 536 } 537 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 538 Record.AddSourceLocation(TL.getStarLoc()); 539 Record.AddTypeSourceInfo(TL.getClassTInfo()); 540 } 541 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) { 542 Record.AddSourceLocation(TL.getLBracketLoc()); 543 Record.AddSourceLocation(TL.getRBracketLoc()); 544 Record.push_back(TL.getSizeExpr() ? 1 : 0); 545 if (TL.getSizeExpr()) 546 Record.AddStmt(TL.getSizeExpr()); 547 } 548 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 549 VisitArrayTypeLoc(TL); 550 } 551 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 552 VisitArrayTypeLoc(TL); 553 } 554 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 555 VisitArrayTypeLoc(TL); 556 } 557 void TypeLocWriter::VisitDependentSizedArrayTypeLoc( 558 DependentSizedArrayTypeLoc TL) { 559 VisitArrayTypeLoc(TL); 560 } 561 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc( 562 DependentSizedExtVectorTypeLoc TL) { 563 Record.AddSourceLocation(TL.getNameLoc()); 564 } 565 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) { 566 Record.AddSourceLocation(TL.getNameLoc()); 567 } 568 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 569 Record.AddSourceLocation(TL.getNameLoc()); 570 } 571 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 572 Record.AddSourceLocation(TL.getLocalRangeBegin()); 573 Record.AddSourceLocation(TL.getLParenLoc()); 574 Record.AddSourceLocation(TL.getRParenLoc()); 575 Record.AddSourceLocation(TL.getLocalRangeEnd()); 576 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) 577 Record.AddDeclRef(TL.getParam(i)); 578 } 579 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 580 VisitFunctionTypeLoc(TL); 581 } 582 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 583 VisitFunctionTypeLoc(TL); 584 } 585 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 586 Record.AddSourceLocation(TL.getNameLoc()); 587 } 588 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 589 Record.AddSourceLocation(TL.getNameLoc()); 590 } 591 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 592 Record.AddSourceLocation(TL.getTypeofLoc()); 593 Record.AddSourceLocation(TL.getLParenLoc()); 594 Record.AddSourceLocation(TL.getRParenLoc()); 595 } 596 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 597 Record.AddSourceLocation(TL.getTypeofLoc()); 598 Record.AddSourceLocation(TL.getLParenLoc()); 599 Record.AddSourceLocation(TL.getRParenLoc()); 600 Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); 601 } 602 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 603 Record.AddSourceLocation(TL.getNameLoc()); 604 } 605 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 606 Record.AddSourceLocation(TL.getKWLoc()); 607 Record.AddSourceLocation(TL.getLParenLoc()); 608 Record.AddSourceLocation(TL.getRParenLoc()); 609 Record.AddTypeSourceInfo(TL.getUnderlyingTInfo()); 610 } 611 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) { 612 Record.AddSourceLocation(TL.getNameLoc()); 613 } 614 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) { 615 Record.AddSourceLocation(TL.getNameLoc()); 616 } 617 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) { 618 Record.AddSourceLocation(TL.getNameLoc()); 619 } 620 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 621 Record.AddSourceLocation(TL.getAttrNameLoc()); 622 if (TL.hasAttrOperand()) { 623 SourceRange range = TL.getAttrOperandParensRange(); 624 Record.AddSourceLocation(range.getBegin()); 625 Record.AddSourceLocation(range.getEnd()); 626 } 627 if (TL.hasAttrExprOperand()) { 628 Expr *operand = TL.getAttrExprOperand(); 629 Record.push_back(operand ? 1 : 0); 630 if (operand) Record.AddStmt(operand); 631 } else if (TL.hasAttrEnumOperand()) { 632 Record.AddSourceLocation(TL.getAttrEnumOperandLoc()); 633 } 634 } 635 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 636 Record.AddSourceLocation(TL.getNameLoc()); 637 } 638 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc( 639 SubstTemplateTypeParmTypeLoc TL) { 640 Record.AddSourceLocation(TL.getNameLoc()); 641 } 642 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc( 643 SubstTemplateTypeParmPackTypeLoc TL) { 644 Record.AddSourceLocation(TL.getNameLoc()); 645 } 646 void TypeLocWriter::VisitTemplateSpecializationTypeLoc( 647 TemplateSpecializationTypeLoc TL) { 648 Record.AddSourceLocation(TL.getTemplateKeywordLoc()); 649 Record.AddSourceLocation(TL.getTemplateNameLoc()); 650 Record.AddSourceLocation(TL.getLAngleLoc()); 651 Record.AddSourceLocation(TL.getRAngleLoc()); 652 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 653 Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(), 654 TL.getArgLoc(i).getLocInfo()); 655 } 656 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) { 657 Record.AddSourceLocation(TL.getLParenLoc()); 658 Record.AddSourceLocation(TL.getRParenLoc()); 659 } 660 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 661 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); 662 Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); 663 } 664 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 665 Record.AddSourceLocation(TL.getNameLoc()); 666 } 667 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 668 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); 669 Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); 670 Record.AddSourceLocation(TL.getNameLoc()); 671 } 672 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc( 673 DependentTemplateSpecializationTypeLoc TL) { 674 Record.AddSourceLocation(TL.getElaboratedKeywordLoc()); 675 Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc()); 676 Record.AddSourceLocation(TL.getTemplateKeywordLoc()); 677 Record.AddSourceLocation(TL.getTemplateNameLoc()); 678 Record.AddSourceLocation(TL.getLAngleLoc()); 679 Record.AddSourceLocation(TL.getRAngleLoc()); 680 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 681 Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(), 682 TL.getArgLoc(I).getLocInfo()); 683 } 684 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 685 Record.AddSourceLocation(TL.getEllipsisLoc()); 686 } 687 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 688 Record.AddSourceLocation(TL.getNameLoc()); 689 } 690 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 691 Record.push_back(TL.hasBaseTypeAsWritten()); 692 Record.AddSourceLocation(TL.getTypeArgsLAngleLoc()); 693 Record.AddSourceLocation(TL.getTypeArgsRAngleLoc()); 694 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i) 695 Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i)); 696 Record.AddSourceLocation(TL.getProtocolLAngleLoc()); 697 Record.AddSourceLocation(TL.getProtocolRAngleLoc()); 698 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 699 Record.AddSourceLocation(TL.getProtocolLoc(i)); 700 } 701 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 702 Record.AddSourceLocation(TL.getStarLoc()); 703 } 704 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 705 Record.AddSourceLocation(TL.getKWLoc()); 706 Record.AddSourceLocation(TL.getLParenLoc()); 707 Record.AddSourceLocation(TL.getRParenLoc()); 708 } 709 void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) { 710 Record.AddSourceLocation(TL.getKWLoc()); 711 } 712 713 void ASTWriter::WriteTypeAbbrevs() { 714 using namespace llvm; 715 716 BitCodeAbbrev *Abv; 717 718 // Abbreviation for TYPE_EXT_QUAL 719 Abv = new BitCodeAbbrev(); 720 Abv->Add(BitCodeAbbrevOp(serialization::TYPE_EXT_QUAL)); 721 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 722 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 3)); // Quals 723 TypeExtQualAbbrev = Stream.EmitAbbrev(Abv); 724 725 // Abbreviation for TYPE_FUNCTION_PROTO 726 Abv = new BitCodeAbbrev(); 727 Abv->Add(BitCodeAbbrevOp(serialization::TYPE_FUNCTION_PROTO)); 728 // FunctionType 729 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ReturnType 730 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // NoReturn 731 Abv->Add(BitCodeAbbrevOp(0)); // HasRegParm 732 Abv->Add(BitCodeAbbrevOp(0)); // RegParm 733 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // CC 734 Abv->Add(BitCodeAbbrevOp(0)); // ProducesResult 735 // FunctionProtoType 736 Abv->Add(BitCodeAbbrevOp(0)); // IsVariadic 737 Abv->Add(BitCodeAbbrevOp(0)); // HasTrailingReturn 738 Abv->Add(BitCodeAbbrevOp(0)); // TypeQuals 739 Abv->Add(BitCodeAbbrevOp(0)); // RefQualifier 740 Abv->Add(BitCodeAbbrevOp(EST_None)); // ExceptionSpec 741 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumParams 742 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 743 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Params 744 TypeFunctionProtoAbbrev = Stream.EmitAbbrev(Abv); 745 } 746 747 //===----------------------------------------------------------------------===// 748 // ASTWriter Implementation 749 //===----------------------------------------------------------------------===// 750 751 static void EmitBlockID(unsigned ID, const char *Name, 752 llvm::BitstreamWriter &Stream, 753 ASTWriter::RecordDataImpl &Record) { 754 Record.clear(); 755 Record.push_back(ID); 756 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); 757 758 // Emit the block name if present. 759 if (!Name || Name[0] == 0) 760 return; 761 Record.clear(); 762 while (*Name) 763 Record.push_back(*Name++); 764 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record); 765 } 766 767 static void EmitRecordID(unsigned ID, const char *Name, 768 llvm::BitstreamWriter &Stream, 769 ASTWriter::RecordDataImpl &Record) { 770 Record.clear(); 771 Record.push_back(ID); 772 while (*Name) 773 Record.push_back(*Name++); 774 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); 775 } 776 777 static void AddStmtsExprs(llvm::BitstreamWriter &Stream, 778 ASTWriter::RecordDataImpl &Record) { 779 #define RECORD(X) EmitRecordID(X, #X, Stream, Record) 780 RECORD(STMT_STOP); 781 RECORD(STMT_NULL_PTR); 782 RECORD(STMT_REF_PTR); 783 RECORD(STMT_NULL); 784 RECORD(STMT_COMPOUND); 785 RECORD(STMT_CASE); 786 RECORD(STMT_DEFAULT); 787 RECORD(STMT_LABEL); 788 RECORD(STMT_ATTRIBUTED); 789 RECORD(STMT_IF); 790 RECORD(STMT_SWITCH); 791 RECORD(STMT_WHILE); 792 RECORD(STMT_DO); 793 RECORD(STMT_FOR); 794 RECORD(STMT_GOTO); 795 RECORD(STMT_INDIRECT_GOTO); 796 RECORD(STMT_CONTINUE); 797 RECORD(STMT_BREAK); 798 RECORD(STMT_RETURN); 799 RECORD(STMT_DECL); 800 RECORD(STMT_GCCASM); 801 RECORD(STMT_MSASM); 802 RECORD(EXPR_PREDEFINED); 803 RECORD(EXPR_DECL_REF); 804 RECORD(EXPR_INTEGER_LITERAL); 805 RECORD(EXPR_FLOATING_LITERAL); 806 RECORD(EXPR_IMAGINARY_LITERAL); 807 RECORD(EXPR_STRING_LITERAL); 808 RECORD(EXPR_CHARACTER_LITERAL); 809 RECORD(EXPR_PAREN); 810 RECORD(EXPR_PAREN_LIST); 811 RECORD(EXPR_UNARY_OPERATOR); 812 RECORD(EXPR_SIZEOF_ALIGN_OF); 813 RECORD(EXPR_ARRAY_SUBSCRIPT); 814 RECORD(EXPR_CALL); 815 RECORD(EXPR_MEMBER); 816 RECORD(EXPR_BINARY_OPERATOR); 817 RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR); 818 RECORD(EXPR_CONDITIONAL_OPERATOR); 819 RECORD(EXPR_IMPLICIT_CAST); 820 RECORD(EXPR_CSTYLE_CAST); 821 RECORD(EXPR_COMPOUND_LITERAL); 822 RECORD(EXPR_EXT_VECTOR_ELEMENT); 823 RECORD(EXPR_INIT_LIST); 824 RECORD(EXPR_DESIGNATED_INIT); 825 RECORD(EXPR_DESIGNATED_INIT_UPDATE); 826 RECORD(EXPR_IMPLICIT_VALUE_INIT); 827 RECORD(EXPR_NO_INIT); 828 RECORD(EXPR_VA_ARG); 829 RECORD(EXPR_ADDR_LABEL); 830 RECORD(EXPR_STMT); 831 RECORD(EXPR_CHOOSE); 832 RECORD(EXPR_GNU_NULL); 833 RECORD(EXPR_SHUFFLE_VECTOR); 834 RECORD(EXPR_BLOCK); 835 RECORD(EXPR_GENERIC_SELECTION); 836 RECORD(EXPR_OBJC_STRING_LITERAL); 837 RECORD(EXPR_OBJC_BOXED_EXPRESSION); 838 RECORD(EXPR_OBJC_ARRAY_LITERAL); 839 RECORD(EXPR_OBJC_DICTIONARY_LITERAL); 840 RECORD(EXPR_OBJC_ENCODE); 841 RECORD(EXPR_OBJC_SELECTOR_EXPR); 842 RECORD(EXPR_OBJC_PROTOCOL_EXPR); 843 RECORD(EXPR_OBJC_IVAR_REF_EXPR); 844 RECORD(EXPR_OBJC_PROPERTY_REF_EXPR); 845 RECORD(EXPR_OBJC_KVC_REF_EXPR); 846 RECORD(EXPR_OBJC_MESSAGE_EXPR); 847 RECORD(STMT_OBJC_FOR_COLLECTION); 848 RECORD(STMT_OBJC_CATCH); 849 RECORD(STMT_OBJC_FINALLY); 850 RECORD(STMT_OBJC_AT_TRY); 851 RECORD(STMT_OBJC_AT_SYNCHRONIZED); 852 RECORD(STMT_OBJC_AT_THROW); 853 RECORD(EXPR_OBJC_BOOL_LITERAL); 854 RECORD(STMT_CXX_CATCH); 855 RECORD(STMT_CXX_TRY); 856 RECORD(STMT_CXX_FOR_RANGE); 857 RECORD(EXPR_CXX_OPERATOR_CALL); 858 RECORD(EXPR_CXX_MEMBER_CALL); 859 RECORD(EXPR_CXX_CONSTRUCT); 860 RECORD(EXPR_CXX_TEMPORARY_OBJECT); 861 RECORD(EXPR_CXX_STATIC_CAST); 862 RECORD(EXPR_CXX_DYNAMIC_CAST); 863 RECORD(EXPR_CXX_REINTERPRET_CAST); 864 RECORD(EXPR_CXX_CONST_CAST); 865 RECORD(EXPR_CXX_FUNCTIONAL_CAST); 866 RECORD(EXPR_USER_DEFINED_LITERAL); 867 RECORD(EXPR_CXX_STD_INITIALIZER_LIST); 868 RECORD(EXPR_CXX_BOOL_LITERAL); 869 RECORD(EXPR_CXX_NULL_PTR_LITERAL); 870 RECORD(EXPR_CXX_TYPEID_EXPR); 871 RECORD(EXPR_CXX_TYPEID_TYPE); 872 RECORD(EXPR_CXX_THIS); 873 RECORD(EXPR_CXX_THROW); 874 RECORD(EXPR_CXX_DEFAULT_ARG); 875 RECORD(EXPR_CXX_DEFAULT_INIT); 876 RECORD(EXPR_CXX_BIND_TEMPORARY); 877 RECORD(EXPR_CXX_SCALAR_VALUE_INIT); 878 RECORD(EXPR_CXX_NEW); 879 RECORD(EXPR_CXX_DELETE); 880 RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR); 881 RECORD(EXPR_EXPR_WITH_CLEANUPS); 882 RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER); 883 RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF); 884 RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT); 885 RECORD(EXPR_CXX_UNRESOLVED_MEMBER); 886 RECORD(EXPR_CXX_UNRESOLVED_LOOKUP); 887 RECORD(EXPR_CXX_EXPRESSION_TRAIT); 888 RECORD(EXPR_CXX_NOEXCEPT); 889 RECORD(EXPR_OPAQUE_VALUE); 890 RECORD(EXPR_BINARY_CONDITIONAL_OPERATOR); 891 RECORD(EXPR_TYPE_TRAIT); 892 RECORD(EXPR_ARRAY_TYPE_TRAIT); 893 RECORD(EXPR_PACK_EXPANSION); 894 RECORD(EXPR_SIZEOF_PACK); 895 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM); 896 RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK); 897 RECORD(EXPR_FUNCTION_PARM_PACK); 898 RECORD(EXPR_MATERIALIZE_TEMPORARY); 899 RECORD(EXPR_CUDA_KERNEL_CALL); 900 RECORD(EXPR_CXX_UUIDOF_EXPR); 901 RECORD(EXPR_CXX_UUIDOF_TYPE); 902 RECORD(EXPR_LAMBDA); 903 #undef RECORD 904 } 905 906 void ASTWriter::WriteBlockInfoBlock() { 907 RecordData Record; 908 Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); 909 910 #define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record) 911 #define RECORD(X) EmitRecordID(X, #X, Stream, Record) 912 913 // Control Block. 914 BLOCK(CONTROL_BLOCK); 915 RECORD(METADATA); 916 RECORD(SIGNATURE); 917 RECORD(MODULE_NAME); 918 RECORD(MODULE_DIRECTORY); 919 RECORD(MODULE_MAP_FILE); 920 RECORD(IMPORTS); 921 RECORD(ORIGINAL_FILE); 922 RECORD(ORIGINAL_PCH_DIR); 923 RECORD(ORIGINAL_FILE_ID); 924 RECORD(INPUT_FILE_OFFSETS); 925 926 BLOCK(OPTIONS_BLOCK); 927 RECORD(LANGUAGE_OPTIONS); 928 RECORD(TARGET_OPTIONS); 929 RECORD(DIAGNOSTIC_OPTIONS); 930 RECORD(FILE_SYSTEM_OPTIONS); 931 RECORD(HEADER_SEARCH_OPTIONS); 932 RECORD(PREPROCESSOR_OPTIONS); 933 934 BLOCK(INPUT_FILES_BLOCK); 935 RECORD(INPUT_FILE); 936 937 // AST Top-Level Block. 938 BLOCK(AST_BLOCK); 939 RECORD(TYPE_OFFSET); 940 RECORD(DECL_OFFSET); 941 RECORD(IDENTIFIER_OFFSET); 942 RECORD(IDENTIFIER_TABLE); 943 RECORD(EAGERLY_DESERIALIZED_DECLS); 944 RECORD(SPECIAL_TYPES); 945 RECORD(STATISTICS); 946 RECORD(TENTATIVE_DEFINITIONS); 947 RECORD(SELECTOR_OFFSETS); 948 RECORD(METHOD_POOL); 949 RECORD(PP_COUNTER_VALUE); 950 RECORD(SOURCE_LOCATION_OFFSETS); 951 RECORD(SOURCE_LOCATION_PRELOADS); 952 RECORD(EXT_VECTOR_DECLS); 953 RECORD(UNUSED_FILESCOPED_DECLS); 954 RECORD(PPD_ENTITIES_OFFSETS); 955 RECORD(VTABLE_USES); 956 RECORD(REFERENCED_SELECTOR_POOL); 957 RECORD(TU_UPDATE_LEXICAL); 958 RECORD(SEMA_DECL_REFS); 959 RECORD(WEAK_UNDECLARED_IDENTIFIERS); 960 RECORD(PENDING_IMPLICIT_INSTANTIATIONS); 961 RECORD(UPDATE_VISIBLE); 962 RECORD(DECL_UPDATE_OFFSETS); 963 RECORD(DECL_UPDATES); 964 RECORD(DIAG_PRAGMA_MAPPINGS); 965 RECORD(CUDA_SPECIAL_DECL_REFS); 966 RECORD(HEADER_SEARCH_TABLE); 967 RECORD(FP_PRAGMA_OPTIONS); 968 RECORD(OPENCL_EXTENSIONS); 969 RECORD(DELEGATING_CTORS); 970 RECORD(KNOWN_NAMESPACES); 971 RECORD(MODULE_OFFSET_MAP); 972 RECORD(SOURCE_MANAGER_LINE_TABLE); 973 RECORD(OBJC_CATEGORIES_MAP); 974 RECORD(FILE_SORTED_DECLS); 975 RECORD(IMPORTED_MODULES); 976 RECORD(OBJC_CATEGORIES); 977 RECORD(MACRO_OFFSET); 978 RECORD(INTERESTING_IDENTIFIERS); 979 RECORD(UNDEFINED_BUT_USED); 980 RECORD(LATE_PARSED_TEMPLATE); 981 RECORD(OPTIMIZE_PRAGMA_OPTIONS); 982 RECORD(MSSTRUCT_PRAGMA_OPTIONS); 983 RECORD(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS); 984 RECORD(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES); 985 RECORD(DELETE_EXPRS_TO_ANALYZE); 986 987 // SourceManager Block. 988 BLOCK(SOURCE_MANAGER_BLOCK); 989 RECORD(SM_SLOC_FILE_ENTRY); 990 RECORD(SM_SLOC_BUFFER_ENTRY); 991 RECORD(SM_SLOC_BUFFER_BLOB); 992 RECORD(SM_SLOC_BUFFER_BLOB_COMPRESSED); 993 RECORD(SM_SLOC_EXPANSION_ENTRY); 994 995 // Preprocessor Block. 996 BLOCK(PREPROCESSOR_BLOCK); 997 RECORD(PP_MACRO_DIRECTIVE_HISTORY); 998 RECORD(PP_MACRO_FUNCTION_LIKE); 999 RECORD(PP_MACRO_OBJECT_LIKE); 1000 RECORD(PP_MODULE_MACRO); 1001 RECORD(PP_TOKEN); 1002 1003 // Submodule Block. 1004 BLOCK(SUBMODULE_BLOCK); 1005 RECORD(SUBMODULE_METADATA); 1006 RECORD(SUBMODULE_DEFINITION); 1007 RECORD(SUBMODULE_UMBRELLA_HEADER); 1008 RECORD(SUBMODULE_HEADER); 1009 RECORD(SUBMODULE_TOPHEADER); 1010 RECORD(SUBMODULE_UMBRELLA_DIR); 1011 RECORD(SUBMODULE_IMPORTS); 1012 RECORD(SUBMODULE_EXPORTS); 1013 RECORD(SUBMODULE_REQUIRES); 1014 RECORD(SUBMODULE_EXCLUDED_HEADER); 1015 RECORD(SUBMODULE_LINK_LIBRARY); 1016 RECORD(SUBMODULE_CONFIG_MACRO); 1017 RECORD(SUBMODULE_CONFLICT); 1018 RECORD(SUBMODULE_PRIVATE_HEADER); 1019 RECORD(SUBMODULE_TEXTUAL_HEADER); 1020 RECORD(SUBMODULE_PRIVATE_TEXTUAL_HEADER); 1021 1022 // Comments Block. 1023 BLOCK(COMMENTS_BLOCK); 1024 RECORD(COMMENTS_RAW_COMMENT); 1025 1026 // Decls and Types block. 1027 BLOCK(DECLTYPES_BLOCK); 1028 RECORD(TYPE_EXT_QUAL); 1029 RECORD(TYPE_COMPLEX); 1030 RECORD(TYPE_POINTER); 1031 RECORD(TYPE_BLOCK_POINTER); 1032 RECORD(TYPE_LVALUE_REFERENCE); 1033 RECORD(TYPE_RVALUE_REFERENCE); 1034 RECORD(TYPE_MEMBER_POINTER); 1035 RECORD(TYPE_CONSTANT_ARRAY); 1036 RECORD(TYPE_INCOMPLETE_ARRAY); 1037 RECORD(TYPE_VARIABLE_ARRAY); 1038 RECORD(TYPE_VECTOR); 1039 RECORD(TYPE_EXT_VECTOR); 1040 RECORD(TYPE_FUNCTION_NO_PROTO); 1041 RECORD(TYPE_FUNCTION_PROTO); 1042 RECORD(TYPE_TYPEDEF); 1043 RECORD(TYPE_TYPEOF_EXPR); 1044 RECORD(TYPE_TYPEOF); 1045 RECORD(TYPE_RECORD); 1046 RECORD(TYPE_ENUM); 1047 RECORD(TYPE_OBJC_INTERFACE); 1048 RECORD(TYPE_OBJC_OBJECT_POINTER); 1049 RECORD(TYPE_DECLTYPE); 1050 RECORD(TYPE_ELABORATED); 1051 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM); 1052 RECORD(TYPE_UNRESOLVED_USING); 1053 RECORD(TYPE_INJECTED_CLASS_NAME); 1054 RECORD(TYPE_OBJC_OBJECT); 1055 RECORD(TYPE_TEMPLATE_TYPE_PARM); 1056 RECORD(TYPE_TEMPLATE_SPECIALIZATION); 1057 RECORD(TYPE_DEPENDENT_NAME); 1058 RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION); 1059 RECORD(TYPE_DEPENDENT_SIZED_ARRAY); 1060 RECORD(TYPE_PAREN); 1061 RECORD(TYPE_PACK_EXPANSION); 1062 RECORD(TYPE_ATTRIBUTED); 1063 RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK); 1064 RECORD(TYPE_AUTO); 1065 RECORD(TYPE_UNARY_TRANSFORM); 1066 RECORD(TYPE_ATOMIC); 1067 RECORD(TYPE_DECAYED); 1068 RECORD(TYPE_ADJUSTED); 1069 RECORD(LOCAL_REDECLARATIONS); 1070 RECORD(DECL_TYPEDEF); 1071 RECORD(DECL_TYPEALIAS); 1072 RECORD(DECL_ENUM); 1073 RECORD(DECL_RECORD); 1074 RECORD(DECL_ENUM_CONSTANT); 1075 RECORD(DECL_FUNCTION); 1076 RECORD(DECL_OBJC_METHOD); 1077 RECORD(DECL_OBJC_INTERFACE); 1078 RECORD(DECL_OBJC_PROTOCOL); 1079 RECORD(DECL_OBJC_IVAR); 1080 RECORD(DECL_OBJC_AT_DEFS_FIELD); 1081 RECORD(DECL_OBJC_CATEGORY); 1082 RECORD(DECL_OBJC_CATEGORY_IMPL); 1083 RECORD(DECL_OBJC_IMPLEMENTATION); 1084 RECORD(DECL_OBJC_COMPATIBLE_ALIAS); 1085 RECORD(DECL_OBJC_PROPERTY); 1086 RECORD(DECL_OBJC_PROPERTY_IMPL); 1087 RECORD(DECL_FIELD); 1088 RECORD(DECL_MS_PROPERTY); 1089 RECORD(DECL_VAR); 1090 RECORD(DECL_IMPLICIT_PARAM); 1091 RECORD(DECL_PARM_VAR); 1092 RECORD(DECL_FILE_SCOPE_ASM); 1093 RECORD(DECL_BLOCK); 1094 RECORD(DECL_CONTEXT_LEXICAL); 1095 RECORD(DECL_CONTEXT_VISIBLE); 1096 RECORD(DECL_NAMESPACE); 1097 RECORD(DECL_NAMESPACE_ALIAS); 1098 RECORD(DECL_USING); 1099 RECORD(DECL_USING_SHADOW); 1100 RECORD(DECL_USING_DIRECTIVE); 1101 RECORD(DECL_UNRESOLVED_USING_VALUE); 1102 RECORD(DECL_UNRESOLVED_USING_TYPENAME); 1103 RECORD(DECL_LINKAGE_SPEC); 1104 RECORD(DECL_CXX_RECORD); 1105 RECORD(DECL_CXX_METHOD); 1106 RECORD(DECL_CXX_CONSTRUCTOR); 1107 RECORD(DECL_CXX_INHERITED_CONSTRUCTOR); 1108 RECORD(DECL_CXX_DESTRUCTOR); 1109 RECORD(DECL_CXX_CONVERSION); 1110 RECORD(DECL_ACCESS_SPEC); 1111 RECORD(DECL_FRIEND); 1112 RECORD(DECL_FRIEND_TEMPLATE); 1113 RECORD(DECL_CLASS_TEMPLATE); 1114 RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION); 1115 RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION); 1116 RECORD(DECL_VAR_TEMPLATE); 1117 RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION); 1118 RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION); 1119 RECORD(DECL_FUNCTION_TEMPLATE); 1120 RECORD(DECL_TEMPLATE_TYPE_PARM); 1121 RECORD(DECL_NON_TYPE_TEMPLATE_PARM); 1122 RECORD(DECL_TEMPLATE_TEMPLATE_PARM); 1123 RECORD(DECL_TYPE_ALIAS_TEMPLATE); 1124 RECORD(DECL_STATIC_ASSERT); 1125 RECORD(DECL_CXX_BASE_SPECIFIERS); 1126 RECORD(DECL_CXX_CTOR_INITIALIZERS); 1127 RECORD(DECL_INDIRECTFIELD); 1128 RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK); 1129 RECORD(DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK); 1130 RECORD(DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION); 1131 RECORD(DECL_IMPORT); 1132 RECORD(DECL_OMP_THREADPRIVATE); 1133 RECORD(DECL_EMPTY); 1134 RECORD(DECL_OBJC_TYPE_PARAM); 1135 RECORD(DECL_OMP_CAPTUREDEXPR); 1136 RECORD(DECL_PRAGMA_COMMENT); 1137 RECORD(DECL_PRAGMA_DETECT_MISMATCH); 1138 RECORD(DECL_OMP_DECLARE_REDUCTION); 1139 1140 // Statements and Exprs can occur in the Decls and Types block. 1141 AddStmtsExprs(Stream, Record); 1142 1143 BLOCK(PREPROCESSOR_DETAIL_BLOCK); 1144 RECORD(PPD_MACRO_EXPANSION); 1145 RECORD(PPD_MACRO_DEFINITION); 1146 RECORD(PPD_INCLUSION_DIRECTIVE); 1147 1148 // Decls and Types block. 1149 BLOCK(EXTENSION_BLOCK); 1150 RECORD(EXTENSION_METADATA); 1151 1152 #undef RECORD 1153 #undef BLOCK 1154 Stream.ExitBlock(); 1155 } 1156 1157 /// \brief Prepares a path for being written to an AST file by converting it 1158 /// to an absolute path and removing nested './'s. 1159 /// 1160 /// \return \c true if the path was changed. 1161 static bool cleanPathForOutput(FileManager &FileMgr, 1162 SmallVectorImpl<char> &Path) { 1163 bool Changed = FileMgr.makeAbsolutePath(Path); 1164 return Changed | llvm::sys::path::remove_dots(Path); 1165 } 1166 1167 /// \brief Adjusts the given filename to only write out the portion of the 1168 /// filename that is not part of the system root directory. 1169 /// 1170 /// \param Filename the file name to adjust. 1171 /// 1172 /// \param BaseDir When non-NULL, the PCH file is a relocatable AST file and 1173 /// the returned filename will be adjusted by this root directory. 1174 /// 1175 /// \returns either the original filename (if it needs no adjustment) or the 1176 /// adjusted filename (which points into the @p Filename parameter). 1177 static const char * 1178 adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir) { 1179 assert(Filename && "No file name to adjust?"); 1180 1181 if (BaseDir.empty()) 1182 return Filename; 1183 1184 // Verify that the filename and the system root have the same prefix. 1185 unsigned Pos = 0; 1186 for (; Filename[Pos] && Pos < BaseDir.size(); ++Pos) 1187 if (Filename[Pos] != BaseDir[Pos]) 1188 return Filename; // Prefixes don't match. 1189 1190 // We hit the end of the filename before we hit the end of the system root. 1191 if (!Filename[Pos]) 1192 return Filename; 1193 1194 // If there's not a path separator at the end of the base directory nor 1195 // immediately after it, then this isn't within the base directory. 1196 if (!llvm::sys::path::is_separator(Filename[Pos])) { 1197 if (!llvm::sys::path::is_separator(BaseDir.back())) 1198 return Filename; 1199 } else { 1200 // If the file name has a '/' at the current position, skip over the '/'. 1201 // We distinguish relative paths from absolute paths by the 1202 // absence of '/' at the beginning of relative paths. 1203 // 1204 // FIXME: This is wrong. We distinguish them by asking if the path is 1205 // absolute, which isn't the same thing. And there might be multiple '/'s 1206 // in a row. Use a better mechanism to indicate whether we have emitted an 1207 // absolute or relative path. 1208 ++Pos; 1209 } 1210 1211 return Filename + Pos; 1212 } 1213 1214 static ASTFileSignature getSignature() { 1215 while (1) { 1216 if (ASTFileSignature S = llvm::sys::Process::GetRandomNumber()) 1217 return S; 1218 // Rely on GetRandomNumber to eventually return non-zero... 1219 } 1220 } 1221 1222 /// \brief Write the control block. 1223 uint64_t ASTWriter::WriteControlBlock(Preprocessor &PP, 1224 ASTContext &Context, 1225 StringRef isysroot, 1226 const std::string &OutputFile) { 1227 ASTFileSignature Signature = 0; 1228 1229 using namespace llvm; 1230 Stream.EnterSubblock(CONTROL_BLOCK_ID, 5); 1231 RecordData Record; 1232 1233 // Metadata 1234 auto *MetadataAbbrev = new BitCodeAbbrev(); 1235 MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA)); 1236 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major 1237 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor 1238 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj. 1239 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min. 1240 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable 1241 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Timestamps 1242 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors 1243 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag 1244 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev); 1245 assert((!WritingModule || isysroot.empty()) && 1246 "writing module as a relocatable PCH?"); 1247 { 1248 RecordData::value_type Record[] = {METADATA, VERSION_MAJOR, VERSION_MINOR, 1249 CLANG_VERSION_MAJOR, CLANG_VERSION_MINOR, 1250 !isysroot.empty(), IncludeTimestamps, 1251 ASTHasCompilerErrors}; 1252 Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, 1253 getClangFullRepositoryVersion()); 1254 } 1255 if (WritingModule) { 1256 // For implicit modules we output a signature that we can use to ensure 1257 // duplicate module builds don't collide in the cache as their output order 1258 // is non-deterministic. 1259 // FIXME: Remove this when output is deterministic. 1260 if (Context.getLangOpts().ImplicitModules) { 1261 Signature = getSignature(); 1262 RecordData::value_type Record[] = {Signature}; 1263 Stream.EmitRecord(SIGNATURE, Record); 1264 } 1265 1266 // Module name 1267 auto *Abbrev = new BitCodeAbbrev(); 1268 Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME)); 1269 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 1270 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 1271 RecordData::value_type Record[] = {MODULE_NAME}; 1272 Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name); 1273 } 1274 1275 if (WritingModule && WritingModule->Directory) { 1276 SmallString<128> BaseDir(WritingModule->Directory->getName()); 1277 cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir); 1278 1279 // If the home of the module is the current working directory, then we 1280 // want to pick up the cwd of the build process loading the module, not 1281 // our cwd, when we load this module. 1282 if (!PP.getHeaderSearchInfo() 1283 .getHeaderSearchOpts() 1284 .ModuleMapFileHomeIsCwd || 1285 WritingModule->Directory->getName() != StringRef(".")) { 1286 // Module directory. 1287 auto *Abbrev = new BitCodeAbbrev(); 1288 Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY)); 1289 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory 1290 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 1291 1292 RecordData::value_type Record[] = {MODULE_DIRECTORY}; 1293 Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir); 1294 } 1295 1296 // Write out all other paths relative to the base directory if possible. 1297 BaseDirectory.assign(BaseDir.begin(), BaseDir.end()); 1298 } else if (!isysroot.empty()) { 1299 // Write out paths relative to the sysroot if possible. 1300 BaseDirectory = isysroot; 1301 } 1302 1303 // Module map file 1304 if (WritingModule) { 1305 Record.clear(); 1306 1307 auto &Map = PP.getHeaderSearchInfo().getModuleMap(); 1308 1309 // Primary module map file. 1310 AddPath(Map.getModuleMapFileForUniquing(WritingModule)->getName(), Record); 1311 1312 // Additional module map files. 1313 if (auto *AdditionalModMaps = 1314 Map.getAdditionalModuleMapFiles(WritingModule)) { 1315 Record.push_back(AdditionalModMaps->size()); 1316 for (const FileEntry *F : *AdditionalModMaps) 1317 AddPath(F->getName(), Record); 1318 } else { 1319 Record.push_back(0); 1320 } 1321 1322 Stream.EmitRecord(MODULE_MAP_FILE, Record); 1323 } 1324 1325 // Imports 1326 if (Chain) { 1327 serialization::ModuleManager &Mgr = Chain->getModuleManager(); 1328 Record.clear(); 1329 1330 for (auto *M : Mgr) { 1331 // Skip modules that weren't directly imported. 1332 if (!M->isDirectlyImported()) 1333 continue; 1334 1335 Record.push_back((unsigned)M->Kind); // FIXME: Stable encoding 1336 AddSourceLocation(M->ImportLoc, Record); 1337 Record.push_back(M->File->getSize()); 1338 Record.push_back(getTimestampForOutput(M->File)); 1339 Record.push_back(M->Signature); 1340 AddPath(M->FileName, Record); 1341 } 1342 Stream.EmitRecord(IMPORTS, Record); 1343 } 1344 1345 // Write the options block. 1346 Stream.EnterSubblock(OPTIONS_BLOCK_ID, 4); 1347 1348 // Language options. 1349 Record.clear(); 1350 const LangOptions &LangOpts = Context.getLangOpts(); 1351 #define LANGOPT(Name, Bits, Default, Description) \ 1352 Record.push_back(LangOpts.Name); 1353 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 1354 Record.push_back(static_cast<unsigned>(LangOpts.get##Name())); 1355 #include "clang/Basic/LangOptions.def" 1356 #define SANITIZER(NAME, ID) \ 1357 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID)); 1358 #include "clang/Basic/Sanitizers.def" 1359 1360 Record.push_back(LangOpts.ModuleFeatures.size()); 1361 for (StringRef Feature : LangOpts.ModuleFeatures) 1362 AddString(Feature, Record); 1363 1364 Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); 1365 AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); 1366 1367 AddString(LangOpts.CurrentModule, Record); 1368 1369 // Comment options. 1370 Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); 1371 for (const auto &I : LangOpts.CommentOpts.BlockCommandNames) { 1372 AddString(I, Record); 1373 } 1374 Record.push_back(LangOpts.CommentOpts.ParseAllComments); 1375 1376 // OpenMP offloading options. 1377 Record.push_back(LangOpts.OMPTargetTriples.size()); 1378 for (auto &T : LangOpts.OMPTargetTriples) 1379 AddString(T.getTriple(), Record); 1380 1381 AddString(LangOpts.OMPHostIRFile, Record); 1382 1383 Stream.EmitRecord(LANGUAGE_OPTIONS, Record); 1384 1385 // Target options. 1386 Record.clear(); 1387 const TargetInfo &Target = Context.getTargetInfo(); 1388 const TargetOptions &TargetOpts = Target.getTargetOpts(); 1389 AddString(TargetOpts.Triple, Record); 1390 AddString(TargetOpts.CPU, Record); 1391 AddString(TargetOpts.ABI, Record); 1392 Record.push_back(TargetOpts.FeaturesAsWritten.size()); 1393 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { 1394 AddString(TargetOpts.FeaturesAsWritten[I], Record); 1395 } 1396 Record.push_back(TargetOpts.Features.size()); 1397 for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { 1398 AddString(TargetOpts.Features[I], Record); 1399 } 1400 Stream.EmitRecord(TARGET_OPTIONS, Record); 1401 1402 // Diagnostic options. 1403 Record.clear(); 1404 const DiagnosticOptions &DiagOpts 1405 = Context.getDiagnostics().getDiagnosticOptions(); 1406 #define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name); 1407 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 1408 Record.push_back(static_cast<unsigned>(DiagOpts.get##Name())); 1409 #include "clang/Basic/DiagnosticOptions.def" 1410 Record.push_back(DiagOpts.Warnings.size()); 1411 for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I) 1412 AddString(DiagOpts.Warnings[I], Record); 1413 Record.push_back(DiagOpts.Remarks.size()); 1414 for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I) 1415 AddString(DiagOpts.Remarks[I], Record); 1416 // Note: we don't serialize the log or serialization file names, because they 1417 // are generally transient files and will almost always be overridden. 1418 Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record); 1419 1420 // File system options. 1421 Record.clear(); 1422 const FileSystemOptions &FSOpts = 1423 Context.getSourceManager().getFileManager().getFileSystemOpts(); 1424 AddString(FSOpts.WorkingDir, Record); 1425 Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record); 1426 1427 // Header search options. 1428 Record.clear(); 1429 const HeaderSearchOptions &HSOpts 1430 = PP.getHeaderSearchInfo().getHeaderSearchOpts(); 1431 AddString(HSOpts.Sysroot, Record); 1432 1433 // Include entries. 1434 Record.push_back(HSOpts.UserEntries.size()); 1435 for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) { 1436 const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I]; 1437 AddString(Entry.Path, Record); 1438 Record.push_back(static_cast<unsigned>(Entry.Group)); 1439 Record.push_back(Entry.IsFramework); 1440 Record.push_back(Entry.IgnoreSysRoot); 1441 } 1442 1443 // System header prefixes. 1444 Record.push_back(HSOpts.SystemHeaderPrefixes.size()); 1445 for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) { 1446 AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record); 1447 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader); 1448 } 1449 1450 AddString(HSOpts.ResourceDir, Record); 1451 AddString(HSOpts.ModuleCachePath, Record); 1452 AddString(HSOpts.ModuleUserBuildPath, Record); 1453 Record.push_back(HSOpts.DisableModuleHash); 1454 Record.push_back(HSOpts.UseBuiltinIncludes); 1455 Record.push_back(HSOpts.UseStandardSystemIncludes); 1456 Record.push_back(HSOpts.UseStandardCXXIncludes); 1457 Record.push_back(HSOpts.UseLibcxx); 1458 // Write out the specific module cache path that contains the module files. 1459 AddString(PP.getHeaderSearchInfo().getModuleCachePath(), Record); 1460 Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record); 1461 1462 // Preprocessor options. 1463 Record.clear(); 1464 const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts(); 1465 1466 // Macro definitions. 1467 Record.push_back(PPOpts.Macros.size()); 1468 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { 1469 AddString(PPOpts.Macros[I].first, Record); 1470 Record.push_back(PPOpts.Macros[I].second); 1471 } 1472 1473 // Includes 1474 Record.push_back(PPOpts.Includes.size()); 1475 for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I) 1476 AddString(PPOpts.Includes[I], Record); 1477 1478 // Macro includes 1479 Record.push_back(PPOpts.MacroIncludes.size()); 1480 for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I) 1481 AddString(PPOpts.MacroIncludes[I], Record); 1482 1483 Record.push_back(PPOpts.UsePredefines); 1484 // Detailed record is important since it is used for the module cache hash. 1485 Record.push_back(PPOpts.DetailedRecord); 1486 AddString(PPOpts.ImplicitPCHInclude, Record); 1487 AddString(PPOpts.ImplicitPTHInclude, Record); 1488 Record.push_back(static_cast<unsigned>(PPOpts.ObjCXXARCStandardLibrary)); 1489 Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record); 1490 1491 // Leave the options block. 1492 Stream.ExitBlock(); 1493 1494 // Original file name and file ID 1495 SourceManager &SM = Context.getSourceManager(); 1496 if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { 1497 auto *FileAbbrev = new BitCodeAbbrev(); 1498 FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE)); 1499 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID 1500 FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1501 unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev); 1502 1503 Record.clear(); 1504 Record.push_back(ORIGINAL_FILE); 1505 Record.push_back(SM.getMainFileID().getOpaqueValue()); 1506 EmitRecordWithPath(FileAbbrevCode, Record, MainFile->getName()); 1507 } 1508 1509 Record.clear(); 1510 Record.push_back(SM.getMainFileID().getOpaqueValue()); 1511 Stream.EmitRecord(ORIGINAL_FILE_ID, Record); 1512 1513 // Original PCH directory 1514 if (!OutputFile.empty() && OutputFile != "-") { 1515 auto *Abbrev = new BitCodeAbbrev(); 1516 Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR)); 1517 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1518 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 1519 1520 SmallString<128> OutputPath(OutputFile); 1521 1522 SM.getFileManager().makeAbsolutePath(OutputPath); 1523 StringRef origDir = llvm::sys::path::parent_path(OutputPath); 1524 1525 RecordData::value_type Record[] = {ORIGINAL_PCH_DIR}; 1526 Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir); 1527 } 1528 1529 WriteInputFiles(Context.SourceMgr, 1530 PP.getHeaderSearchInfo().getHeaderSearchOpts(), 1531 PP.getLangOpts().Modules); 1532 Stream.ExitBlock(); 1533 return Signature; 1534 } 1535 1536 namespace { 1537 /// \brief An input file. 1538 struct InputFileEntry { 1539 const FileEntry *File; 1540 bool IsSystemFile; 1541 bool IsTransient; 1542 bool BufferOverridden; 1543 }; 1544 } // end anonymous namespace 1545 1546 void ASTWriter::WriteInputFiles(SourceManager &SourceMgr, 1547 HeaderSearchOptions &HSOpts, 1548 bool Modules) { 1549 using namespace llvm; 1550 Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4); 1551 1552 // Create input-file abbreviation. 1553 auto *IFAbbrev = new BitCodeAbbrev(); 1554 IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE)); 1555 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID 1556 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size 1557 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time 1558 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden 1559 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Transient 1560 IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name 1561 unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev); 1562 1563 // Get all ContentCache objects for files, sorted by whether the file is a 1564 // system one or not. System files go at the back, users files at the front. 1565 std::deque<InputFileEntry> SortedFiles; 1566 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) { 1567 // Get this source location entry. 1568 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); 1569 assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc); 1570 1571 // We only care about file entries that were not overridden. 1572 if (!SLoc->isFile()) 1573 continue; 1574 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); 1575 if (!Cache->OrigEntry) 1576 continue; 1577 1578 InputFileEntry Entry; 1579 Entry.File = Cache->OrigEntry; 1580 Entry.IsSystemFile = Cache->IsSystemFile; 1581 Entry.IsTransient = Cache->IsTransient; 1582 Entry.BufferOverridden = Cache->BufferOverridden; 1583 if (Cache->IsSystemFile) 1584 SortedFiles.push_back(Entry); 1585 else 1586 SortedFiles.push_front(Entry); 1587 } 1588 1589 unsigned UserFilesNum = 0; 1590 // Write out all of the input files. 1591 std::vector<uint64_t> InputFileOffsets; 1592 for (const auto &Entry : SortedFiles) { 1593 uint32_t &InputFileID = InputFileIDs[Entry.File]; 1594 if (InputFileID != 0) 1595 continue; // already recorded this file. 1596 1597 // Record this entry's offset. 1598 InputFileOffsets.push_back(Stream.GetCurrentBitNo()); 1599 1600 InputFileID = InputFileOffsets.size(); 1601 1602 if (!Entry.IsSystemFile) 1603 ++UserFilesNum; 1604 1605 // Emit size/modification time for this file. 1606 // And whether this file was overridden. 1607 RecordData::value_type Record[] = { 1608 INPUT_FILE, 1609 InputFileOffsets.size(), 1610 (uint64_t)Entry.File->getSize(), 1611 (uint64_t)getTimestampForOutput(Entry.File), 1612 Entry.BufferOverridden, 1613 Entry.IsTransient}; 1614 1615 EmitRecordWithPath(IFAbbrevCode, Record, Entry.File->getName()); 1616 } 1617 1618 Stream.ExitBlock(); 1619 1620 // Create input file offsets abbreviation. 1621 auto *OffsetsAbbrev = new BitCodeAbbrev(); 1622 OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS)); 1623 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files 1624 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # non-system 1625 // input files 1626 OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array 1627 unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev); 1628 1629 // Write input file offsets. 1630 RecordData::value_type Record[] = {INPUT_FILE_OFFSETS, 1631 InputFileOffsets.size(), UserFilesNum}; 1632 Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, bytes(InputFileOffsets)); 1633 } 1634 1635 //===----------------------------------------------------------------------===// 1636 // Source Manager Serialization 1637 //===----------------------------------------------------------------------===// 1638 1639 /// \brief Create an abbreviation for the SLocEntry that refers to a 1640 /// file. 1641 static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { 1642 using namespace llvm; 1643 1644 auto *Abbrev = new BitCodeAbbrev(); 1645 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY)); 1646 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1647 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1648 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1649 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1650 // FileEntry fields. 1651 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID 1652 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs 1653 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex 1654 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls 1655 return Stream.EmitAbbrev(Abbrev); 1656 } 1657 1658 /// \brief Create an abbreviation for the SLocEntry that refers to a 1659 /// buffer. 1660 static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { 1661 using namespace llvm; 1662 1663 auto *Abbrev = new BitCodeAbbrev(); 1664 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY)); 1665 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1666 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location 1667 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic 1668 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives 1669 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob 1670 return Stream.EmitAbbrev(Abbrev); 1671 } 1672 1673 /// \brief Create an abbreviation for the SLocEntry that refers to a 1674 /// buffer's blob. 1675 static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream, 1676 bool Compressed) { 1677 using namespace llvm; 1678 1679 auto *Abbrev = new BitCodeAbbrev(); 1680 Abbrev->Add(BitCodeAbbrevOp(Compressed ? SM_SLOC_BUFFER_BLOB_COMPRESSED 1681 : SM_SLOC_BUFFER_BLOB)); 1682 if (Compressed) 1683 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Uncompressed size 1684 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob 1685 return Stream.EmitAbbrev(Abbrev); 1686 } 1687 1688 /// \brief Create an abbreviation for the SLocEntry that refers to a macro 1689 /// expansion. 1690 static unsigned CreateSLocExpansionAbbrev(llvm::BitstreamWriter &Stream) { 1691 using namespace llvm; 1692 1693 auto *Abbrev = new BitCodeAbbrev(); 1694 Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_ENTRY)); 1695 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset 1696 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location 1697 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location 1698 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location 1699 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length 1700 return Stream.EmitAbbrev(Abbrev); 1701 } 1702 1703 namespace { 1704 // Trait used for the on-disk hash table of header search information. 1705 class HeaderFileInfoTrait { 1706 ASTWriter &Writer; 1707 const HeaderSearch &HS; 1708 1709 // Keep track of the framework names we've used during serialization. 1710 SmallVector<char, 128> FrameworkStringData; 1711 llvm::StringMap<unsigned> FrameworkNameOffset; 1712 1713 public: 1714 HeaderFileInfoTrait(ASTWriter &Writer, const HeaderSearch &HS) 1715 : Writer(Writer), HS(HS) { } 1716 1717 struct key_type { 1718 const FileEntry *FE; 1719 const char *Filename; 1720 }; 1721 typedef const key_type &key_type_ref; 1722 1723 typedef HeaderFileInfo data_type; 1724 typedef const data_type &data_type_ref; 1725 typedef unsigned hash_value_type; 1726 typedef unsigned offset_type; 1727 1728 hash_value_type ComputeHash(key_type_ref key) { 1729 // The hash is based only on size/time of the file, so that the reader can 1730 // match even when symlinking or excess path elements ("foo/../", "../") 1731 // change the form of the name. However, complete path is still the key. 1732 return llvm::hash_combine(key.FE->getSize(), 1733 Writer.getTimestampForOutput(key.FE)); 1734 } 1735 1736 std::pair<unsigned,unsigned> 1737 EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) { 1738 using namespace llvm::support; 1739 endian::Writer<little> LE(Out); 1740 unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8; 1741 LE.write<uint16_t>(KeyLen); 1742 unsigned DataLen = 1 + 2 + 4 + 4; 1743 for (auto ModInfo : HS.getModuleMap().findAllModulesForHeader(key.FE)) 1744 if (Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule())) 1745 DataLen += 4; 1746 LE.write<uint8_t>(DataLen); 1747 return std::make_pair(KeyLen, DataLen); 1748 } 1749 1750 void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) { 1751 using namespace llvm::support; 1752 endian::Writer<little> LE(Out); 1753 LE.write<uint64_t>(key.FE->getSize()); 1754 KeyLen -= 8; 1755 LE.write<uint64_t>(Writer.getTimestampForOutput(key.FE)); 1756 KeyLen -= 8; 1757 Out.write(key.Filename, KeyLen); 1758 } 1759 1760 void EmitData(raw_ostream &Out, key_type_ref key, 1761 data_type_ref Data, unsigned DataLen) { 1762 using namespace llvm::support; 1763 endian::Writer<little> LE(Out); 1764 uint64_t Start = Out.tell(); (void)Start; 1765 1766 unsigned char Flags = (Data.isImport << 4) 1767 | (Data.isPragmaOnce << 3) 1768 | (Data.DirInfo << 1) 1769 | Data.IndexHeaderMapHeader; 1770 LE.write<uint8_t>(Flags); 1771 LE.write<uint16_t>(Data.NumIncludes); 1772 1773 if (!Data.ControllingMacro) 1774 LE.write<uint32_t>(Data.ControllingMacroID); 1775 else 1776 LE.write<uint32_t>(Writer.getIdentifierRef(Data.ControllingMacro)); 1777 1778 unsigned Offset = 0; 1779 if (!Data.Framework.empty()) { 1780 // If this header refers into a framework, save the framework name. 1781 llvm::StringMap<unsigned>::iterator Pos 1782 = FrameworkNameOffset.find(Data.Framework); 1783 if (Pos == FrameworkNameOffset.end()) { 1784 Offset = FrameworkStringData.size() + 1; 1785 FrameworkStringData.append(Data.Framework.begin(), 1786 Data.Framework.end()); 1787 FrameworkStringData.push_back(0); 1788 1789 FrameworkNameOffset[Data.Framework] = Offset; 1790 } else 1791 Offset = Pos->second; 1792 } 1793 LE.write<uint32_t>(Offset); 1794 1795 // FIXME: If the header is excluded, we should write out some 1796 // record of that fact. 1797 for (auto ModInfo : HS.getModuleMap().findAllModulesForHeader(key.FE)) { 1798 if (uint32_t ModID = 1799 Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule())) { 1800 uint32_t Value = (ModID << 2) | (unsigned)ModInfo.getRole(); 1801 assert((Value >> 2) == ModID && "overflow in header module info"); 1802 LE.write<uint32_t>(Value); 1803 } 1804 } 1805 1806 assert(Out.tell() - Start == DataLen && "Wrong data length"); 1807 } 1808 1809 const char *strings_begin() const { return FrameworkStringData.begin(); } 1810 const char *strings_end() const { return FrameworkStringData.end(); } 1811 }; 1812 } // end anonymous namespace 1813 1814 /// \brief Write the header search block for the list of files that 1815 /// 1816 /// \param HS The header search structure to save. 1817 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) { 1818 SmallVector<const FileEntry *, 16> FilesByUID; 1819 HS.getFileMgr().GetUniqueIDMapping(FilesByUID); 1820 1821 if (FilesByUID.size() > HS.header_file_size()) 1822 FilesByUID.resize(HS.header_file_size()); 1823 1824 HeaderFileInfoTrait GeneratorTrait(*this, HS); 1825 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator; 1826 SmallVector<const char *, 4> SavedStrings; 1827 unsigned NumHeaderSearchEntries = 0; 1828 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { 1829 const FileEntry *File = FilesByUID[UID]; 1830 if (!File) 1831 continue; 1832 1833 // Get the file info. This will load info from the external source if 1834 // necessary. Skip emitting this file if we have no information on it 1835 // as a header file (in which case HFI will be null) or if it hasn't 1836 // changed since it was loaded. Also skip it if it's for a modular header 1837 // from a different module; in that case, we rely on the module(s) 1838 // containing the header to provide this information. 1839 const HeaderFileInfo *HFI = 1840 HS.getExistingFileInfo(File, /*WantExternal*/!Chain); 1841 if (!HFI || (HFI->isModuleHeader && !HFI->isCompilingModuleHeader)) 1842 continue; 1843 1844 // Massage the file path into an appropriate form. 1845 const char *Filename = File->getName(); 1846 SmallString<128> FilenameTmp(Filename); 1847 if (PreparePathForOutput(FilenameTmp)) { 1848 // If we performed any translation on the file name at all, we need to 1849 // save this string, since the generator will refer to it later. 1850 Filename = strdup(FilenameTmp.c_str()); 1851 SavedStrings.push_back(Filename); 1852 } 1853 1854 HeaderFileInfoTrait::key_type key = { File, Filename }; 1855 Generator.insert(key, *HFI, GeneratorTrait); 1856 ++NumHeaderSearchEntries; 1857 } 1858 1859 // Create the on-disk hash table in a buffer. 1860 SmallString<4096> TableData; 1861 uint32_t BucketOffset; 1862 { 1863 using namespace llvm::support; 1864 llvm::raw_svector_ostream Out(TableData); 1865 // Make sure that no bucket is at offset 0 1866 endian::Writer<little>(Out).write<uint32_t>(0); 1867 BucketOffset = Generator.Emit(Out, GeneratorTrait); 1868 } 1869 1870 // Create a blob abbreviation 1871 using namespace llvm; 1872 1873 auto *Abbrev = new BitCodeAbbrev(); 1874 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); 1875 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1876 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1877 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1878 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1879 unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev); 1880 1881 // Write the header search table 1882 RecordData::value_type Record[] = {HEADER_SEARCH_TABLE, BucketOffset, 1883 NumHeaderSearchEntries, TableData.size()}; 1884 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); 1885 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData); 1886 1887 // Free all of the strings we had to duplicate. 1888 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) 1889 free(const_cast<char *>(SavedStrings[I])); 1890 } 1891 1892 /// \brief Writes the block containing the serialized form of the 1893 /// source manager. 1894 /// 1895 /// TODO: We should probably use an on-disk hash table (stored in a 1896 /// blob), indexed based on the file name, so that we only create 1897 /// entries for files that we actually need. In the common case (no 1898 /// errors), we probably won't have to create file entries for any of 1899 /// the files in the AST. 1900 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, 1901 const Preprocessor &PP) { 1902 RecordData Record; 1903 1904 // Enter the source manager block. 1905 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 4); 1906 1907 // Abbreviations for the various kinds of source-location entries. 1908 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); 1909 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); 1910 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false); 1911 unsigned SLocBufferBlobCompressedAbbrv = 1912 CreateSLocBufferBlobAbbrev(Stream, true); 1913 unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); 1914 1915 // Write out the source location entry table. We skip the first 1916 // entry, which is always the same dummy entry. 1917 std::vector<uint32_t> SLocEntryOffsets; 1918 RecordData PreloadSLocs; 1919 SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); 1920 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); 1921 I != N; ++I) { 1922 // Get this source location entry. 1923 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); 1924 FileID FID = FileID::get(I); 1925 assert(&SourceMgr.getSLocEntry(FID) == SLoc); 1926 1927 // Record the offset of this source-location entry. 1928 SLocEntryOffsets.push_back(Stream.GetCurrentBitNo()); 1929 1930 // Figure out which record code to use. 1931 unsigned Code; 1932 if (SLoc->isFile()) { 1933 const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache(); 1934 if (Cache->OrigEntry) { 1935 Code = SM_SLOC_FILE_ENTRY; 1936 } else 1937 Code = SM_SLOC_BUFFER_ENTRY; 1938 } else 1939 Code = SM_SLOC_EXPANSION_ENTRY; 1940 Record.clear(); 1941 Record.push_back(Code); 1942 1943 // Starting offset of this entry within this module, so skip the dummy. 1944 Record.push_back(SLoc->getOffset() - 2); 1945 if (SLoc->isFile()) { 1946 const SrcMgr::FileInfo &File = SLoc->getFile(); 1947 AddSourceLocation(File.getIncludeLoc(), Record); 1948 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding 1949 Record.push_back(File.hasLineDirectives()); 1950 1951 const SrcMgr::ContentCache *Content = File.getContentCache(); 1952 bool EmitBlob = false; 1953 if (Content->OrigEntry) { 1954 assert(Content->OrigEntry == Content->ContentsEntry && 1955 "Writing to AST an overridden file is not supported"); 1956 1957 // The source location entry is a file. Emit input file ID. 1958 assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry"); 1959 Record.push_back(InputFileIDs[Content->OrigEntry]); 1960 1961 Record.push_back(File.NumCreatedFIDs); 1962 1963 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID); 1964 if (FDI != FileDeclIDs.end()) { 1965 Record.push_back(FDI->second->FirstDeclIndex); 1966 Record.push_back(FDI->second->DeclIDs.size()); 1967 } else { 1968 Record.push_back(0); 1969 Record.push_back(0); 1970 } 1971 1972 Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); 1973 1974 if (Content->BufferOverridden || Content->IsTransient) 1975 EmitBlob = true; 1976 } else { 1977 // The source location entry is a buffer. The blob associated 1978 // with this entry contains the contents of the buffer. 1979 1980 // We add one to the size so that we capture the trailing NULL 1981 // that is required by llvm::MemoryBuffer::getMemBuffer (on 1982 // the reader side). 1983 const llvm::MemoryBuffer *Buffer 1984 = Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 1985 const char *Name = Buffer->getBufferIdentifier(); 1986 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, 1987 StringRef(Name, strlen(Name) + 1)); 1988 EmitBlob = true; 1989 1990 if (strcmp(Name, "<built-in>") == 0) { 1991 PreloadSLocs.push_back(SLocEntryOffsets.size()); 1992 } 1993 } 1994 1995 if (EmitBlob) { 1996 // Include the implicit terminating null character in the on-disk buffer 1997 // if we're writing it uncompressed. 1998 const llvm::MemoryBuffer *Buffer = 1999 Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager()); 2000 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1); 2001 2002 // Compress the buffer if possible. We expect that almost all PCM 2003 // consumers will not want its contents. 2004 SmallString<0> CompressedBuffer; 2005 if (llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer) == 2006 llvm::zlib::StatusOK) { 2007 RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, 2008 Blob.size() - 1}; 2009 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, 2010 CompressedBuffer); 2011 } else { 2012 RecordData::value_type Record[] = {SM_SLOC_BUFFER_BLOB}; 2013 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob); 2014 } 2015 } 2016 } else { 2017 // The source location entry is a macro expansion. 2018 const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); 2019 AddSourceLocation(Expansion.getSpellingLoc(), Record); 2020 AddSourceLocation(Expansion.getExpansionLocStart(), Record); 2021 AddSourceLocation(Expansion.isMacroArgExpansion() 2022 ? SourceLocation() 2023 : Expansion.getExpansionLocEnd(), 2024 Record); 2025 2026 // Compute the token length for this macro expansion. 2027 unsigned NextOffset = SourceMgr.getNextLocalOffset(); 2028 if (I + 1 != N) 2029 NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); 2030 Record.push_back(NextOffset - SLoc->getOffset() - 1); 2031 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); 2032 } 2033 } 2034 2035 Stream.ExitBlock(); 2036 2037 if (SLocEntryOffsets.empty()) 2038 return; 2039 2040 // Write the source-location offsets table into the AST block. This 2041 // table is used for lazily loading source-location information. 2042 using namespace llvm; 2043 2044 auto *Abbrev = new BitCodeAbbrev(); 2045 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); 2046 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 2047 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size 2048 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 2049 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); 2050 { 2051 RecordData::value_type Record[] = { 2052 SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(), 2053 SourceMgr.getNextLocalOffset() - 1 /* skip dummy */}; 2054 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, 2055 bytes(SLocEntryOffsets)); 2056 } 2057 // Write the source location entry preloads array, telling the AST 2058 // reader which source locations entries it should load eagerly. 2059 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); 2060 2061 // Write the line table. It depends on remapping working, so it must come 2062 // after the source location offsets. 2063 if (SourceMgr.hasLineTable()) { 2064 LineTableInfo &LineTable = SourceMgr.getLineTable(); 2065 2066 Record.clear(); 2067 2068 // Emit the needed file names. 2069 llvm::DenseMap<int, int> FilenameMap; 2070 for (const auto &L : LineTable) { 2071 if (L.first.ID < 0) 2072 continue; 2073 for (auto &LE : L.second) { 2074 if (FilenameMap.insert(std::make_pair(LE.FilenameID, 2075 FilenameMap.size())).second) 2076 AddPath(LineTable.getFilename(LE.FilenameID), Record); 2077 } 2078 } 2079 Record.push_back(0); 2080 2081 // Emit the line entries 2082 for (const auto &L : LineTable) { 2083 // Only emit entries for local files. 2084 if (L.first.ID < 0) 2085 continue; 2086 2087 // Emit the file ID 2088 Record.push_back(L.first.ID); 2089 2090 // Emit the line entries 2091 Record.push_back(L.second.size()); 2092 for (const auto &LE : L.second) { 2093 Record.push_back(LE.FileOffset); 2094 Record.push_back(LE.LineNo); 2095 Record.push_back(FilenameMap[LE.FilenameID]); 2096 Record.push_back((unsigned)LE.FileKind); 2097 Record.push_back(LE.IncludeOffset); 2098 } 2099 } 2100 2101 Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); 2102 } 2103 } 2104 2105 //===----------------------------------------------------------------------===// 2106 // Preprocessor Serialization 2107 //===----------------------------------------------------------------------===// 2108 2109 static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, 2110 const Preprocessor &PP) { 2111 if (MacroInfo *MI = MD->getMacroInfo()) 2112 if (MI->isBuiltinMacro()) 2113 return true; 2114 2115 if (IsModule) { 2116 SourceLocation Loc = MD->getLocation(); 2117 if (Loc.isInvalid()) 2118 return true; 2119 if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID()) 2120 return true; 2121 } 2122 2123 return false; 2124 } 2125 2126 /// \brief Writes the block containing the serialized form of the 2127 /// preprocessor. 2128 /// 2129 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { 2130 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 2131 if (PPRec) 2132 WritePreprocessorDetail(*PPRec); 2133 2134 RecordData Record; 2135 RecordData ModuleMacroRecord; 2136 2137 // If the preprocessor __COUNTER__ value has been bumped, remember it. 2138 if (PP.getCounterValue() != 0) { 2139 RecordData::value_type Record[] = {PP.getCounterValue()}; 2140 Stream.EmitRecord(PP_COUNTER_VALUE, Record); 2141 } 2142 2143 // Enter the preprocessor block. 2144 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); 2145 2146 // If the AST file contains __DATE__ or __TIME__ emit a warning about this. 2147 // FIXME: Include a location for the use, and say which one was used. 2148 if (PP.SawDateOrTime()) 2149 PP.Diag(SourceLocation(), diag::warn_module_uses_date_time) << IsModule; 2150 2151 // Loop over all the macro directives that are live at the end of the file, 2152 // emitting each to the PP section. 2153 2154 // Construct the list of identifiers with macro directives that need to be 2155 // serialized. 2156 SmallVector<const IdentifierInfo *, 128> MacroIdentifiers; 2157 for (auto &Id : PP.getIdentifierTable()) 2158 if (Id.second->hadMacroDefinition() && 2159 (!Id.second->isFromAST() || 2160 Id.second->hasChangedSinceDeserialization())) 2161 MacroIdentifiers.push_back(Id.second); 2162 // Sort the set of macro definitions that need to be serialized by the 2163 // name of the macro, to provide a stable ordering. 2164 std::sort(MacroIdentifiers.begin(), MacroIdentifiers.end(), 2165 llvm::less_ptr<IdentifierInfo>()); 2166 2167 // Emit the macro directives as a list and associate the offset with the 2168 // identifier they belong to. 2169 for (const IdentifierInfo *Name : MacroIdentifiers) { 2170 MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name); 2171 auto StartOffset = Stream.GetCurrentBitNo(); 2172 2173 // Emit the macro directives in reverse source order. 2174 for (; MD; MD = MD->getPrevious()) { 2175 // Once we hit an ignored macro, we're done: the rest of the chain 2176 // will all be ignored macros. 2177 if (shouldIgnoreMacro(MD, IsModule, PP)) 2178 break; 2179 2180 AddSourceLocation(MD->getLocation(), Record); 2181 Record.push_back(MD->getKind()); 2182 if (auto *DefMD = dyn_cast<DefMacroDirective>(MD)) { 2183 Record.push_back(getMacroRef(DefMD->getInfo(), Name)); 2184 } else if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) { 2185 Record.push_back(VisMD->isPublic()); 2186 } 2187 } 2188 2189 // Write out any exported module macros. 2190 bool EmittedModuleMacros = false; 2191 // We write out exported module macros for PCH as well. 2192 auto Leafs = PP.getLeafModuleMacros(Name); 2193 SmallVector<ModuleMacro*, 8> Worklist(Leafs.begin(), Leafs.end()); 2194 llvm::DenseMap<ModuleMacro*, unsigned> Visits; 2195 while (!Worklist.empty()) { 2196 auto *Macro = Worklist.pop_back_val(); 2197 2198 // Emit a record indicating this submodule exports this macro. 2199 ModuleMacroRecord.push_back( 2200 getSubmoduleID(Macro->getOwningModule())); 2201 ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); 2202 for (auto *M : Macro->overrides()) 2203 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); 2204 2205 Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); 2206 ModuleMacroRecord.clear(); 2207 2208 // Enqueue overridden macros once we've visited all their ancestors. 2209 for (auto *M : Macro->overrides()) 2210 if (++Visits[M] == M->getNumOverridingMacros()) 2211 Worklist.push_back(M); 2212 2213 EmittedModuleMacros = true; 2214 } 2215 2216 if (Record.empty() && !EmittedModuleMacros) 2217 continue; 2218 2219 IdentMacroDirectivesOffsetMap[Name] = StartOffset; 2220 Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record); 2221 Record.clear(); 2222 } 2223 2224 /// \brief Offsets of each of the macros into the bitstream, indexed by 2225 /// the local macro ID 2226 /// 2227 /// For each identifier that is associated with a macro, this map 2228 /// provides the offset into the bitstream where that macro is 2229 /// defined. 2230 std::vector<uint32_t> MacroOffsets; 2231 2232 for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) { 2233 const IdentifierInfo *Name = MacroInfosToEmit[I].Name; 2234 MacroInfo *MI = MacroInfosToEmit[I].MI; 2235 MacroID ID = MacroInfosToEmit[I].ID; 2236 2237 if (ID < FirstMacroID) { 2238 assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?"); 2239 continue; 2240 } 2241 2242 // Record the local offset of this macro. 2243 unsigned Index = ID - FirstMacroID; 2244 if (Index == MacroOffsets.size()) 2245 MacroOffsets.push_back(Stream.GetCurrentBitNo()); 2246 else { 2247 if (Index > MacroOffsets.size()) 2248 MacroOffsets.resize(Index + 1); 2249 2250 MacroOffsets[Index] = Stream.GetCurrentBitNo(); 2251 } 2252 2253 AddIdentifierRef(Name, Record); 2254 Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc())); 2255 AddSourceLocation(MI->getDefinitionLoc(), Record); 2256 AddSourceLocation(MI->getDefinitionEndLoc(), Record); 2257 Record.push_back(MI->isUsed()); 2258 Record.push_back(MI->isUsedForHeaderGuard()); 2259 unsigned Code; 2260 if (MI->isObjectLike()) { 2261 Code = PP_MACRO_OBJECT_LIKE; 2262 } else { 2263 Code = PP_MACRO_FUNCTION_LIKE; 2264 2265 Record.push_back(MI->isC99Varargs()); 2266 Record.push_back(MI->isGNUVarargs()); 2267 Record.push_back(MI->hasCommaPasting()); 2268 Record.push_back(MI->getNumArgs()); 2269 for (const IdentifierInfo *Arg : MI->args()) 2270 AddIdentifierRef(Arg, Record); 2271 } 2272 2273 // If we have a detailed preprocessing record, record the macro definition 2274 // ID that corresponds to this macro. 2275 if (PPRec) 2276 Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); 2277 2278 Stream.EmitRecord(Code, Record); 2279 Record.clear(); 2280 2281 // Emit the tokens array. 2282 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { 2283 // Note that we know that the preprocessor does not have any annotation 2284 // tokens in it because they are created by the parser, and thus can't 2285 // be in a macro definition. 2286 const Token &Tok = MI->getReplacementToken(TokNo); 2287 AddToken(Tok, Record); 2288 Stream.EmitRecord(PP_TOKEN, Record); 2289 Record.clear(); 2290 } 2291 ++NumMacros; 2292 } 2293 2294 Stream.ExitBlock(); 2295 2296 // Write the offsets table for macro IDs. 2297 using namespace llvm; 2298 2299 auto *Abbrev = new BitCodeAbbrev(); 2300 Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET)); 2301 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros 2302 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 2303 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2304 2305 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2306 { 2307 RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(), 2308 FirstMacroID - NUM_PREDEF_MACRO_IDS}; 2309 Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, bytes(MacroOffsets)); 2310 } 2311 } 2312 2313 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) { 2314 if (PPRec.local_begin() == PPRec.local_end()) 2315 return; 2316 2317 SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets; 2318 2319 // Enter the preprocessor block. 2320 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); 2321 2322 // If the preprocessor has a preprocessing record, emit it. 2323 unsigned NumPreprocessingRecords = 0; 2324 using namespace llvm; 2325 2326 // Set up the abbreviation for 2327 unsigned InclusionAbbrev = 0; 2328 { 2329 auto *Abbrev = new BitCodeAbbrev(); 2330 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); 2331 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length 2332 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes 2333 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind 2334 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module 2335 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2336 InclusionAbbrev = Stream.EmitAbbrev(Abbrev); 2337 } 2338 2339 unsigned FirstPreprocessorEntityID 2340 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) 2341 + NUM_PREDEF_PP_ENTITY_IDS; 2342 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; 2343 RecordData Record; 2344 for (PreprocessingRecord::iterator E = PPRec.local_begin(), 2345 EEnd = PPRec.local_end(); 2346 E != EEnd; 2347 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { 2348 Record.clear(); 2349 2350 PreprocessedEntityOffsets.push_back( 2351 PPEntityOffset((*E)->getSourceRange(), Stream.GetCurrentBitNo())); 2352 2353 if (auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) { 2354 // Record this macro definition's ID. 2355 MacroDefinitions[MD] = NextPreprocessorEntityID; 2356 2357 AddIdentifierRef(MD->getName(), Record); 2358 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); 2359 continue; 2360 } 2361 2362 if (auto *ME = dyn_cast<MacroExpansion>(*E)) { 2363 Record.push_back(ME->isBuiltinMacro()); 2364 if (ME->isBuiltinMacro()) 2365 AddIdentifierRef(ME->getName(), Record); 2366 else 2367 Record.push_back(MacroDefinitions[ME->getDefinition()]); 2368 Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); 2369 continue; 2370 } 2371 2372 if (auto *ID = dyn_cast<InclusionDirective>(*E)) { 2373 Record.push_back(PPD_INCLUSION_DIRECTIVE); 2374 Record.push_back(ID->getFileName().size()); 2375 Record.push_back(ID->wasInQuotes()); 2376 Record.push_back(static_cast<unsigned>(ID->getKind())); 2377 Record.push_back(ID->importedModule()); 2378 SmallString<64> Buffer; 2379 Buffer += ID->getFileName(); 2380 // Check that the FileEntry is not null because it was not resolved and 2381 // we create a PCH even with compiler errors. 2382 if (ID->getFile()) 2383 Buffer += ID->getFile()->getName(); 2384 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); 2385 continue; 2386 } 2387 2388 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); 2389 } 2390 Stream.ExitBlock(); 2391 2392 // Write the offsets table for the preprocessing record. 2393 if (NumPreprocessingRecords > 0) { 2394 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); 2395 2396 // Write the offsets table for identifier IDs. 2397 using namespace llvm; 2398 2399 auto *Abbrev = new BitCodeAbbrev(); 2400 Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); 2401 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity 2402 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2403 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2404 2405 RecordData::value_type Record[] = {PPD_ENTITIES_OFFSETS, 2406 FirstPreprocessorEntityID - 2407 NUM_PREDEF_PP_ENTITY_IDS}; 2408 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, 2409 bytes(PreprocessedEntityOffsets)); 2410 } 2411 } 2412 2413 unsigned ASTWriter::getLocalOrImportedSubmoduleID(Module *Mod) { 2414 if (!Mod) 2415 return 0; 2416 2417 llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod); 2418 if (Known != SubmoduleIDs.end()) 2419 return Known->second; 2420 2421 if (Mod->getTopLevelModule() != WritingModule) 2422 return 0; 2423 2424 return SubmoduleIDs[Mod] = NextSubmoduleID++; 2425 } 2426 2427 unsigned ASTWriter::getSubmoduleID(Module *Mod) { 2428 // FIXME: This can easily happen, if we have a reference to a submodule that 2429 // did not result in us loading a module file for that submodule. For 2430 // instance, a cross-top-level-module 'conflict' declaration will hit this. 2431 unsigned ID = getLocalOrImportedSubmoduleID(Mod); 2432 assert((ID || !Mod) && 2433 "asked for module ID for non-local, non-imported module"); 2434 return ID; 2435 } 2436 2437 /// \brief Compute the number of modules within the given tree (including the 2438 /// given module). 2439 static unsigned getNumberOfModules(Module *Mod) { 2440 unsigned ChildModules = 0; 2441 for (auto Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); 2442 Sub != SubEnd; ++Sub) 2443 ChildModules += getNumberOfModules(*Sub); 2444 2445 return ChildModules + 1; 2446 } 2447 2448 void ASTWriter::WriteSubmodules(Module *WritingModule) { 2449 // Enter the submodule description block. 2450 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/5); 2451 2452 // Write the abbreviations needed for the submodules block. 2453 using namespace llvm; 2454 2455 auto *Abbrev = new BitCodeAbbrev(); 2456 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); 2457 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID 2458 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent 2459 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 2460 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit 2461 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem 2462 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC 2463 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... 2464 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... 2465 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... 2466 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh... 2467 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2468 unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev); 2469 2470 Abbrev = new BitCodeAbbrev(); 2471 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); 2472 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2473 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev); 2474 2475 Abbrev = new BitCodeAbbrev(); 2476 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); 2477 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2478 unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2479 2480 Abbrev = new BitCodeAbbrev(); 2481 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER)); 2482 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2483 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2484 2485 Abbrev = new BitCodeAbbrev(); 2486 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); 2487 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2488 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev); 2489 2490 Abbrev = new BitCodeAbbrev(); 2491 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); 2492 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State 2493 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature 2494 unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev); 2495 2496 Abbrev = new BitCodeAbbrev(); 2497 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER)); 2498 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2499 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2500 2501 Abbrev = new BitCodeAbbrev(); 2502 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER)); 2503 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2504 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2505 2506 Abbrev = new BitCodeAbbrev(); 2507 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER)); 2508 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2509 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2510 2511 Abbrev = new BitCodeAbbrev(); 2512 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER)); 2513 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2514 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(Abbrev); 2515 2516 Abbrev = new BitCodeAbbrev(); 2517 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY)); 2518 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 2519 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2520 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(Abbrev); 2521 2522 Abbrev = new BitCodeAbbrev(); 2523 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO)); 2524 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name 2525 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(Abbrev); 2526 2527 Abbrev = new BitCodeAbbrev(); 2528 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT)); 2529 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module 2530 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message 2531 unsigned ConflictAbbrev = Stream.EmitAbbrev(Abbrev); 2532 2533 // Write the submodule metadata block. 2534 RecordData::value_type Record[] = {getNumberOfModules(WritingModule), 2535 FirstSubmoduleID - 2536 NUM_PREDEF_SUBMODULE_IDS}; 2537 Stream.EmitRecord(SUBMODULE_METADATA, Record); 2538 2539 // Write all of the submodules. 2540 std::queue<Module *> Q; 2541 Q.push(WritingModule); 2542 while (!Q.empty()) { 2543 Module *Mod = Q.front(); 2544 Q.pop(); 2545 unsigned ID = getSubmoduleID(Mod); 2546 2547 uint64_t ParentID = 0; 2548 if (Mod->Parent) { 2549 assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); 2550 ParentID = SubmoduleIDs[Mod->Parent]; 2551 } 2552 2553 // Emit the definition of the block. 2554 { 2555 RecordData::value_type Record[] = { 2556 SUBMODULE_DEFINITION, ID, ParentID, Mod->IsFramework, Mod->IsExplicit, 2557 Mod->IsSystem, Mod->IsExternC, Mod->InferSubmodules, 2558 Mod->InferExplicitSubmodules, Mod->InferExportWildcard, 2559 Mod->ConfigMacrosExhaustive}; 2560 Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); 2561 } 2562 2563 // Emit the requirements. 2564 for (const auto &R : Mod->Requirements) { 2565 RecordData::value_type Record[] = {SUBMODULE_REQUIRES, R.second}; 2566 Stream.EmitRecordWithBlob(RequiresAbbrev, Record, R.first); 2567 } 2568 2569 // Emit the umbrella header, if there is one. 2570 if (auto UmbrellaHeader = Mod->getUmbrellaHeader()) { 2571 RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_HEADER}; 2572 Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, 2573 UmbrellaHeader.NameAsWritten); 2574 } else if (auto UmbrellaDir = Mod->getUmbrellaDir()) { 2575 RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_DIR}; 2576 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, 2577 UmbrellaDir.NameAsWritten); 2578 } 2579 2580 // Emit the headers. 2581 struct { 2582 unsigned RecordKind; 2583 unsigned Abbrev; 2584 Module::HeaderKind HeaderKind; 2585 } HeaderLists[] = { 2586 {SUBMODULE_HEADER, HeaderAbbrev, Module::HK_Normal}, 2587 {SUBMODULE_TEXTUAL_HEADER, TextualHeaderAbbrev, Module::HK_Textual}, 2588 {SUBMODULE_PRIVATE_HEADER, PrivateHeaderAbbrev, Module::HK_Private}, 2589 {SUBMODULE_PRIVATE_TEXTUAL_HEADER, PrivateTextualHeaderAbbrev, 2590 Module::HK_PrivateTextual}, 2591 {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, Module::HK_Excluded} 2592 }; 2593 for (auto &HL : HeaderLists) { 2594 RecordData::value_type Record[] = {HL.RecordKind}; 2595 for (auto &H : Mod->Headers[HL.HeaderKind]) 2596 Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten); 2597 } 2598 2599 // Emit the top headers. 2600 { 2601 auto TopHeaders = Mod->getTopHeaders(PP->getFileManager()); 2602 RecordData::value_type Record[] = {SUBMODULE_TOPHEADER}; 2603 for (auto *H : TopHeaders) 2604 Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName()); 2605 } 2606 2607 // Emit the imports. 2608 if (!Mod->Imports.empty()) { 2609 RecordData Record; 2610 for (auto *I : Mod->Imports) 2611 Record.push_back(getSubmoduleID(I)); 2612 Stream.EmitRecord(SUBMODULE_IMPORTS, Record); 2613 } 2614 2615 // Emit the exports. 2616 if (!Mod->Exports.empty()) { 2617 RecordData Record; 2618 for (const auto &E : Mod->Exports) { 2619 // FIXME: This may fail; we don't require that all exported modules 2620 // are local or imported. 2621 Record.push_back(getSubmoduleID(E.getPointer())); 2622 Record.push_back(E.getInt()); 2623 } 2624 Stream.EmitRecord(SUBMODULE_EXPORTS, Record); 2625 } 2626 2627 //FIXME: How do we emit the 'use'd modules? They may not be submodules. 2628 // Might be unnecessary as use declarations are only used to build the 2629 // module itself. 2630 2631 // Emit the link libraries. 2632 for (const auto &LL : Mod->LinkLibraries) { 2633 RecordData::value_type Record[] = {SUBMODULE_LINK_LIBRARY, 2634 LL.IsFramework}; 2635 Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, LL.Library); 2636 } 2637 2638 // Emit the conflicts. 2639 for (const auto &C : Mod->Conflicts) { 2640 // FIXME: This may fail; we don't require that all conflicting modules 2641 // are local or imported. 2642 RecordData::value_type Record[] = {SUBMODULE_CONFLICT, 2643 getSubmoduleID(C.Other)}; 2644 Stream.EmitRecordWithBlob(ConflictAbbrev, Record, C.Message); 2645 } 2646 2647 // Emit the configuration macros. 2648 for (const auto &CM : Mod->ConfigMacros) { 2649 RecordData::value_type Record[] = {SUBMODULE_CONFIG_MACRO}; 2650 Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, CM); 2651 } 2652 2653 // Queue up the submodules of this module. 2654 for (auto *M : Mod->submodules()) 2655 Q.push(M); 2656 } 2657 2658 Stream.ExitBlock(); 2659 2660 assert((NextSubmoduleID - FirstSubmoduleID == 2661 getNumberOfModules(WritingModule)) && 2662 "Wrong # of submodules; found a reference to a non-local, " 2663 "non-imported submodule?"); 2664 } 2665 2666 serialization::SubmoduleID 2667 ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) { 2668 if (Loc.isInvalid() || !WritingModule) 2669 return 0; // No submodule 2670 2671 // Find the module that owns this location. 2672 ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap(); 2673 Module *OwningMod 2674 = ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager())); 2675 if (!OwningMod) 2676 return 0; 2677 2678 // Check whether this submodule is part of our own module. 2679 if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule)) 2680 return 0; 2681 2682 return getSubmoduleID(OwningMod); 2683 } 2684 2685 void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, 2686 bool isModule) { 2687 // Make sure set diagnostic pragmas don't affect the translation unit that 2688 // imports the module. 2689 // FIXME: Make diagnostic pragma sections work properly with modules. 2690 if (isModule) 2691 return; 2692 2693 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64> 2694 DiagStateIDMap; 2695 unsigned CurrID = 0; 2696 DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one. 2697 RecordData Record; 2698 for (DiagnosticsEngine::DiagStatePointsTy::const_iterator 2699 I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end(); 2700 I != E; ++I) { 2701 const DiagnosticsEngine::DiagStatePoint &point = *I; 2702 if (point.Loc.isInvalid()) 2703 continue; 2704 2705 AddSourceLocation(point.Loc, Record); 2706 unsigned &DiagStateID = DiagStateIDMap[point.State]; 2707 Record.push_back(DiagStateID); 2708 2709 if (DiagStateID == 0) { 2710 DiagStateID = ++CurrID; 2711 for (const auto &I : *(point.State)) { 2712 if (I.second.isPragma()) { 2713 Record.push_back(I.first); 2714 Record.push_back((unsigned)I.second.getSeverity()); 2715 } 2716 } 2717 Record.push_back(-1); // mark the end of the diag/map pairs for this 2718 // location. 2719 } 2720 } 2721 2722 if (!Record.empty()) 2723 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); 2724 } 2725 2726 //===----------------------------------------------------------------------===// 2727 // Type Serialization 2728 //===----------------------------------------------------------------------===// 2729 2730 /// \brief Write the representation of a type to the AST stream. 2731 void ASTWriter::WriteType(QualType T) { 2732 TypeIdx &IdxRef = TypeIdxs[T]; 2733 if (IdxRef.getIndex() == 0) // we haven't seen this type before. 2734 IdxRef = TypeIdx(NextTypeID++); 2735 TypeIdx Idx = IdxRef; 2736 2737 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); 2738 2739 RecordData Record; 2740 2741 // Emit the type's representation. 2742 ASTTypeWriter W(*this, Record); 2743 W.Visit(T); 2744 uint64_t Offset = W.Emit(); 2745 2746 // Record the offset for this type. 2747 unsigned Index = Idx.getIndex() - FirstTypeID; 2748 if (TypeOffsets.size() == Index) 2749 TypeOffsets.push_back(Offset); 2750 else if (TypeOffsets.size() < Index) { 2751 TypeOffsets.resize(Index + 1); 2752 TypeOffsets[Index] = Offset; 2753 } else { 2754 llvm_unreachable("Types emitted in wrong order"); 2755 } 2756 } 2757 2758 //===----------------------------------------------------------------------===// 2759 // Declaration Serialization 2760 //===----------------------------------------------------------------------===// 2761 2762 /// \brief Write the block containing all of the declaration IDs 2763 /// lexically declared within the given DeclContext. 2764 /// 2765 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the 2766 /// bistream, or 0 if no block was written. 2767 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, 2768 DeclContext *DC) { 2769 if (DC->decls_empty()) 2770 return 0; 2771 2772 uint64_t Offset = Stream.GetCurrentBitNo(); 2773 SmallVector<uint32_t, 128> KindDeclPairs; 2774 for (const auto *D : DC->decls()) { 2775 KindDeclPairs.push_back(D->getKind()); 2776 KindDeclPairs.push_back(GetDeclRef(D)); 2777 } 2778 2779 ++NumLexicalDeclContexts; 2780 RecordData::value_type Record[] = {DECL_CONTEXT_LEXICAL}; 2781 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, 2782 bytes(KindDeclPairs)); 2783 return Offset; 2784 } 2785 2786 void ASTWriter::WriteTypeDeclOffsets() { 2787 using namespace llvm; 2788 2789 // Write the type offsets array 2790 auto *Abbrev = new BitCodeAbbrev(); 2791 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); 2792 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types 2793 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index 2794 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block 2795 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2796 { 2797 RecordData::value_type Record[] = {TYPE_OFFSET, TypeOffsets.size(), 2798 FirstTypeID - NUM_PREDEF_TYPE_IDS}; 2799 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, bytes(TypeOffsets)); 2800 } 2801 2802 // Write the declaration offsets array 2803 Abbrev = new BitCodeAbbrev(); 2804 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); 2805 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations 2806 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID 2807 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block 2808 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 2809 { 2810 RecordData::value_type Record[] = {DECL_OFFSET, DeclOffsets.size(), 2811 FirstDeclID - NUM_PREDEF_DECL_IDS}; 2812 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, bytes(DeclOffsets)); 2813 } 2814 } 2815 2816 void ASTWriter::WriteFileDeclIDsMap() { 2817 using namespace llvm; 2818 2819 SmallVector<std::pair<FileID, DeclIDInFileInfo *>, 64> SortedFileDeclIDs( 2820 FileDeclIDs.begin(), FileDeclIDs.end()); 2821 std::sort(SortedFileDeclIDs.begin(), SortedFileDeclIDs.end(), 2822 llvm::less_first()); 2823 2824 // Join the vectors of DeclIDs from all files. 2825 SmallVector<DeclID, 256> FileGroupedDeclIDs; 2826 for (auto &FileDeclEntry : SortedFileDeclIDs) { 2827 DeclIDInFileInfo &Info = *FileDeclEntry.second; 2828 Info.FirstDeclIndex = FileGroupedDeclIDs.size(); 2829 for (auto &LocDeclEntry : Info.DeclIDs) 2830 FileGroupedDeclIDs.push_back(LocDeclEntry.second); 2831 } 2832 2833 auto *Abbrev = new BitCodeAbbrev(); 2834 Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); 2835 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2836 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2837 unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev); 2838 RecordData::value_type Record[] = {FILE_SORTED_DECLS, 2839 FileGroupedDeclIDs.size()}; 2840 Stream.EmitRecordWithBlob(AbbrevCode, Record, bytes(FileGroupedDeclIDs)); 2841 } 2842 2843 void ASTWriter::WriteComments() { 2844 Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3); 2845 ArrayRef<RawComment *> RawComments = Context->Comments.getComments(); 2846 RecordData Record; 2847 for (const auto *I : RawComments) { 2848 Record.clear(); 2849 AddSourceRange(I->getSourceRange(), Record); 2850 Record.push_back(I->getKind()); 2851 Record.push_back(I->isTrailingComment()); 2852 Record.push_back(I->isAlmostTrailingComment()); 2853 Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record); 2854 } 2855 Stream.ExitBlock(); 2856 } 2857 2858 //===----------------------------------------------------------------------===// 2859 // Global Method Pool and Selector Serialization 2860 //===----------------------------------------------------------------------===// 2861 2862 namespace { 2863 // Trait used for the on-disk hash table used in the method pool. 2864 class ASTMethodPoolTrait { 2865 ASTWriter &Writer; 2866 2867 public: 2868 typedef Selector key_type; 2869 typedef key_type key_type_ref; 2870 2871 struct data_type { 2872 SelectorID ID; 2873 ObjCMethodList Instance, Factory; 2874 }; 2875 typedef const data_type& data_type_ref; 2876 2877 typedef unsigned hash_value_type; 2878 typedef unsigned offset_type; 2879 2880 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { } 2881 2882 static hash_value_type ComputeHash(Selector Sel) { 2883 return serialization::ComputeHash(Sel); 2884 } 2885 2886 std::pair<unsigned,unsigned> 2887 EmitKeyDataLength(raw_ostream& Out, Selector Sel, 2888 data_type_ref Methods) { 2889 using namespace llvm::support; 2890 endian::Writer<little> LE(Out); 2891 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); 2892 LE.write<uint16_t>(KeyLen); 2893 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts 2894 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2895 Method = Method->getNext()) 2896 if (Method->getMethod()) 2897 DataLen += 4; 2898 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2899 Method = Method->getNext()) 2900 if (Method->getMethod()) 2901 DataLen += 4; 2902 LE.write<uint16_t>(DataLen); 2903 return std::make_pair(KeyLen, DataLen); 2904 } 2905 2906 void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { 2907 using namespace llvm::support; 2908 endian::Writer<little> LE(Out); 2909 uint64_t Start = Out.tell(); 2910 assert((Start >> 32) == 0 && "Selector key offset too large"); 2911 Writer.SetSelectorOffset(Sel, Start); 2912 unsigned N = Sel.getNumArgs(); 2913 LE.write<uint16_t>(N); 2914 if (N == 0) 2915 N = 1; 2916 for (unsigned I = 0; I != N; ++I) 2917 LE.write<uint32_t>( 2918 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); 2919 } 2920 2921 void EmitData(raw_ostream& Out, key_type_ref, 2922 data_type_ref Methods, unsigned DataLen) { 2923 using namespace llvm::support; 2924 endian::Writer<little> LE(Out); 2925 uint64_t Start = Out.tell(); (void)Start; 2926 LE.write<uint32_t>(Methods.ID); 2927 unsigned NumInstanceMethods = 0; 2928 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2929 Method = Method->getNext()) 2930 if (Method->getMethod()) 2931 ++NumInstanceMethods; 2932 2933 unsigned NumFactoryMethods = 0; 2934 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2935 Method = Method->getNext()) 2936 if (Method->getMethod()) 2937 ++NumFactoryMethods; 2938 2939 unsigned InstanceBits = Methods.Instance.getBits(); 2940 assert(InstanceBits < 4); 2941 unsigned InstanceHasMoreThanOneDeclBit = 2942 Methods.Instance.hasMoreThanOneDecl(); 2943 unsigned FullInstanceBits = (NumInstanceMethods << 3) | 2944 (InstanceHasMoreThanOneDeclBit << 2) | 2945 InstanceBits; 2946 unsigned FactoryBits = Methods.Factory.getBits(); 2947 assert(FactoryBits < 4); 2948 unsigned FactoryHasMoreThanOneDeclBit = 2949 Methods.Factory.hasMoreThanOneDecl(); 2950 unsigned FullFactoryBits = (NumFactoryMethods << 3) | 2951 (FactoryHasMoreThanOneDeclBit << 2) | 2952 FactoryBits; 2953 LE.write<uint16_t>(FullInstanceBits); 2954 LE.write<uint16_t>(FullFactoryBits); 2955 for (const ObjCMethodList *Method = &Methods.Instance; Method; 2956 Method = Method->getNext()) 2957 if (Method->getMethod()) 2958 LE.write<uint32_t>(Writer.getDeclID(Method->getMethod())); 2959 for (const ObjCMethodList *Method = &Methods.Factory; Method; 2960 Method = Method->getNext()) 2961 if (Method->getMethod()) 2962 LE.write<uint32_t>(Writer.getDeclID(Method->getMethod())); 2963 2964 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 2965 } 2966 }; 2967 } // end anonymous namespace 2968 2969 /// \brief Write ObjC data: selectors and the method pool. 2970 /// 2971 /// The method pool contains both instance and factory methods, stored 2972 /// in an on-disk hash table indexed by the selector. The hash table also 2973 /// contains an empty entry for every other selector known to Sema. 2974 void ASTWriter::WriteSelectors(Sema &SemaRef) { 2975 using namespace llvm; 2976 2977 // Do we have to do anything at all? 2978 if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) 2979 return; 2980 unsigned NumTableEntries = 0; 2981 // Create and write out the blob that contains selectors and the method pool. 2982 { 2983 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator; 2984 ASTMethodPoolTrait Trait(*this); 2985 2986 // Create the on-disk hash table representation. We walk through every 2987 // selector we've seen and look it up in the method pool. 2988 SelectorOffsets.resize(NextSelectorID - FirstSelectorID); 2989 for (auto &SelectorAndID : SelectorIDs) { 2990 Selector S = SelectorAndID.first; 2991 SelectorID ID = SelectorAndID.second; 2992 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); 2993 ASTMethodPoolTrait::data_type Data = { 2994 ID, 2995 ObjCMethodList(), 2996 ObjCMethodList() 2997 }; 2998 if (F != SemaRef.MethodPool.end()) { 2999 Data.Instance = F->second.first; 3000 Data.Factory = F->second.second; 3001 } 3002 // Only write this selector if it's not in an existing AST or something 3003 // changed. 3004 if (Chain && ID < FirstSelectorID) { 3005 // Selector already exists. Did it change? 3006 bool changed = false; 3007 for (ObjCMethodList *M = &Data.Instance; 3008 !changed && M && M->getMethod(); M = M->getNext()) { 3009 if (!M->getMethod()->isFromASTFile()) 3010 changed = true; 3011 } 3012 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->getMethod(); 3013 M = M->getNext()) { 3014 if (!M->getMethod()->isFromASTFile()) 3015 changed = true; 3016 } 3017 if (!changed) 3018 continue; 3019 } else if (Data.Instance.getMethod() || Data.Factory.getMethod()) { 3020 // A new method pool entry. 3021 ++NumTableEntries; 3022 } 3023 Generator.insert(S, Data, Trait); 3024 } 3025 3026 // Create the on-disk hash table in a buffer. 3027 SmallString<4096> MethodPool; 3028 uint32_t BucketOffset; 3029 { 3030 using namespace llvm::support; 3031 ASTMethodPoolTrait Trait(*this); 3032 llvm::raw_svector_ostream Out(MethodPool); 3033 // Make sure that no bucket is at offset 0 3034 endian::Writer<little>(Out).write<uint32_t>(0); 3035 BucketOffset = Generator.Emit(Out, Trait); 3036 } 3037 3038 // Create a blob abbreviation 3039 auto *Abbrev = new BitCodeAbbrev(); 3040 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); 3041 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3042 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3043 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3044 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev); 3045 3046 // Write the method pool 3047 { 3048 RecordData::value_type Record[] = {METHOD_POOL, BucketOffset, 3049 NumTableEntries}; 3050 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool); 3051 } 3052 3053 // Create a blob abbreviation for the selector table offsets. 3054 Abbrev = new BitCodeAbbrev(); 3055 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); 3056 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 3057 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 3058 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3059 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 3060 3061 // Write the selector offsets table. 3062 { 3063 RecordData::value_type Record[] = { 3064 SELECTOR_OFFSETS, SelectorOffsets.size(), 3065 FirstSelectorID - NUM_PREDEF_SELECTOR_IDS}; 3066 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, 3067 bytes(SelectorOffsets)); 3068 } 3069 } 3070 } 3071 3072 /// \brief Write the selectors referenced in @selector expression into AST file. 3073 void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { 3074 using namespace llvm; 3075 if (SemaRef.ReferencedSelectors.empty()) 3076 return; 3077 3078 RecordData Record; 3079 ASTRecordWriter Writer(*this, Record); 3080 3081 // Note: this writes out all references even for a dependent AST. But it is 3082 // very tricky to fix, and given that @selector shouldn't really appear in 3083 // headers, probably not worth it. It's not a correctness issue. 3084 for (auto &SelectorAndLocation : SemaRef.ReferencedSelectors) { 3085 Selector Sel = SelectorAndLocation.first; 3086 SourceLocation Loc = SelectorAndLocation.second; 3087 Writer.AddSelectorRef(Sel); 3088 Writer.AddSourceLocation(Loc); 3089 } 3090 Writer.Emit(REFERENCED_SELECTOR_POOL); 3091 } 3092 3093 //===----------------------------------------------------------------------===// 3094 // Identifier Table Serialization 3095 //===----------------------------------------------------------------------===// 3096 3097 /// Determine the declaration that should be put into the name lookup table to 3098 /// represent the given declaration in this module. This is usually D itself, 3099 /// but if D was imported and merged into a local declaration, we want the most 3100 /// recent local declaration instead. The chosen declaration will be the most 3101 /// recent declaration in any module that imports this one. 3102 static NamedDecl *getDeclForLocalLookup(const LangOptions &LangOpts, 3103 NamedDecl *D) { 3104 if (!LangOpts.Modules || !D->isFromASTFile()) 3105 return D; 3106 3107 if (Decl *Redecl = D->getPreviousDecl()) { 3108 // For Redeclarable decls, a prior declaration might be local. 3109 for (; Redecl; Redecl = Redecl->getPreviousDecl()) { 3110 // If we find a local decl, we're done. 3111 if (!Redecl->isFromASTFile()) { 3112 // Exception: in very rare cases (for injected-class-names), not all 3113 // redeclarations are in the same semantic context. Skip ones in a 3114 // different context. They don't go in this lookup table at all. 3115 if (!Redecl->getDeclContext()->getRedeclContext()->Equals( 3116 D->getDeclContext()->getRedeclContext())) 3117 continue; 3118 return cast<NamedDecl>(Redecl); 3119 } 3120 3121 // If we find a decl from a (chained-)PCH stop since we won't find a 3122 // local one. 3123 if (Redecl->getOwningModuleID() == 0) 3124 break; 3125 } 3126 } else if (Decl *First = D->getCanonicalDecl()) { 3127 // For Mergeable decls, the first decl might be local. 3128 if (!First->isFromASTFile()) 3129 return cast<NamedDecl>(First); 3130 } 3131 3132 // All declarations are imported. Our most recent declaration will also be 3133 // the most recent one in anyone who imports us. 3134 return D; 3135 } 3136 3137 namespace { 3138 class ASTIdentifierTableTrait { 3139 ASTWriter &Writer; 3140 Preprocessor &PP; 3141 IdentifierResolver &IdResolver; 3142 bool IsModule; 3143 bool NeedDecls; 3144 ASTWriter::RecordData *InterestingIdentifierOffsets; 3145 3146 /// \brief Determines whether this is an "interesting" identifier that needs a 3147 /// full IdentifierInfo structure written into the hash table. Notably, this 3148 /// doesn't check whether the name has macros defined; use PublicMacroIterator 3149 /// to check that. 3150 bool isInterestingIdentifier(const IdentifierInfo *II, uint64_t MacroOffset) { 3151 if (MacroOffset || 3152 II->isPoisoned() || 3153 (IsModule ? II->hasRevertedBuiltin() : II->getObjCOrBuiltinID()) || 3154 II->hasRevertedTokenIDToIdentifier() || 3155 (NeedDecls && II->getFETokenInfo<void>())) 3156 return true; 3157 3158 return false; 3159 } 3160 3161 public: 3162 typedef IdentifierInfo* key_type; 3163 typedef key_type key_type_ref; 3164 3165 typedef IdentID data_type; 3166 typedef data_type data_type_ref; 3167 3168 typedef unsigned hash_value_type; 3169 typedef unsigned offset_type; 3170 3171 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, 3172 IdentifierResolver &IdResolver, bool IsModule, 3173 ASTWriter::RecordData *InterestingIdentifierOffsets) 3174 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule), 3175 NeedDecls(!IsModule || !Writer.getLangOpts().CPlusPlus), 3176 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {} 3177 3178 bool needDecls() const { return NeedDecls; } 3179 3180 static hash_value_type ComputeHash(const IdentifierInfo* II) { 3181 return llvm::HashString(II->getName()); 3182 } 3183 3184 bool isInterestingIdentifier(const IdentifierInfo *II) { 3185 auto MacroOffset = Writer.getMacroDirectivesOffset(II); 3186 return isInterestingIdentifier(II, MacroOffset); 3187 } 3188 bool isInterestingNonMacroIdentifier(const IdentifierInfo *II) { 3189 return isInterestingIdentifier(II, 0); 3190 } 3191 3192 std::pair<unsigned,unsigned> 3193 EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { 3194 unsigned KeyLen = II->getLength() + 1; 3195 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 3196 auto MacroOffset = Writer.getMacroDirectivesOffset(II); 3197 if (isInterestingIdentifier(II, MacroOffset)) { 3198 DataLen += 2; // 2 bytes for builtin ID 3199 DataLen += 2; // 2 bytes for flags 3200 if (MacroOffset) 3201 DataLen += 4; // MacroDirectives offset. 3202 3203 if (NeedDecls) { 3204 for (IdentifierResolver::iterator D = IdResolver.begin(II), 3205 DEnd = IdResolver.end(); 3206 D != DEnd; ++D) 3207 DataLen += 4; 3208 } 3209 } 3210 using namespace llvm::support; 3211 endian::Writer<little> LE(Out); 3212 3213 assert((uint16_t)DataLen == DataLen && (uint16_t)KeyLen == KeyLen); 3214 LE.write<uint16_t>(DataLen); 3215 // We emit the key length after the data length so that every 3216 // string is preceded by a 16-bit length. This matches the PTH 3217 // format for storing identifiers. 3218 LE.write<uint16_t>(KeyLen); 3219 return std::make_pair(KeyLen, DataLen); 3220 } 3221 3222 void EmitKey(raw_ostream& Out, const IdentifierInfo* II, 3223 unsigned KeyLen) { 3224 // Record the location of the key data. This is used when generating 3225 // the mapping from persistent IDs to strings. 3226 Writer.SetIdentifierOffset(II, Out.tell()); 3227 3228 // Emit the offset of the key/data length information to the interesting 3229 // identifiers table if necessary. 3230 if (InterestingIdentifierOffsets && isInterestingIdentifier(II)) 3231 InterestingIdentifierOffsets->push_back(Out.tell() - 4); 3232 3233 Out.write(II->getNameStart(), KeyLen); 3234 } 3235 3236 void EmitData(raw_ostream& Out, IdentifierInfo* II, 3237 IdentID ID, unsigned) { 3238 using namespace llvm::support; 3239 endian::Writer<little> LE(Out); 3240 3241 auto MacroOffset = Writer.getMacroDirectivesOffset(II); 3242 if (!isInterestingIdentifier(II, MacroOffset)) { 3243 LE.write<uint32_t>(ID << 1); 3244 return; 3245 } 3246 3247 LE.write<uint32_t>((ID << 1) | 0x01); 3248 uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID(); 3249 assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); 3250 LE.write<uint16_t>(Bits); 3251 Bits = 0; 3252 bool HadMacroDefinition = MacroOffset != 0; 3253 Bits = (Bits << 1) | unsigned(HadMacroDefinition); 3254 Bits = (Bits << 1) | unsigned(II->isExtensionToken()); 3255 Bits = (Bits << 1) | unsigned(II->isPoisoned()); 3256 Bits = (Bits << 1) | unsigned(II->hasRevertedBuiltin()); 3257 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); 3258 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); 3259 LE.write<uint16_t>(Bits); 3260 3261 if (HadMacroDefinition) 3262 LE.write<uint32_t>(MacroOffset); 3263 3264 if (NeedDecls) { 3265 // Emit the declaration IDs in reverse order, because the 3266 // IdentifierResolver provides the declarations as they would be 3267 // visible (e.g., the function "stat" would come before the struct 3268 // "stat"), but the ASTReader adds declarations to the end of the list 3269 // (so we need to see the struct "stat" before the function "stat"). 3270 // Only emit declarations that aren't from a chained PCH, though. 3271 SmallVector<NamedDecl *, 16> Decls(IdResolver.begin(II), 3272 IdResolver.end()); 3273 for (SmallVectorImpl<NamedDecl *>::reverse_iterator D = Decls.rbegin(), 3274 DEnd = Decls.rend(); 3275 D != DEnd; ++D) 3276 LE.write<uint32_t>( 3277 Writer.getDeclID(getDeclForLocalLookup(PP.getLangOpts(), *D))); 3278 } 3279 } 3280 }; 3281 } // end anonymous namespace 3282 3283 /// \brief Write the identifier table into the AST file. 3284 /// 3285 /// The identifier table consists of a blob containing string data 3286 /// (the actual identifiers themselves) and a separate "offsets" index 3287 /// that maps identifier IDs to locations within the blob. 3288 void ASTWriter::WriteIdentifierTable(Preprocessor &PP, 3289 IdentifierResolver &IdResolver, 3290 bool IsModule) { 3291 using namespace llvm; 3292 3293 RecordData InterestingIdents; 3294 3295 // Create and write out the blob that contains the identifier 3296 // strings. 3297 { 3298 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; 3299 ASTIdentifierTableTrait Trait( 3300 *this, PP, IdResolver, IsModule, 3301 (getLangOpts().CPlusPlus && IsModule) ? &InterestingIdents : nullptr); 3302 3303 // Look for any identifiers that were named while processing the 3304 // headers, but are otherwise not needed. We add these to the hash 3305 // table to enable checking of the predefines buffer in the case 3306 // where the user adds new macro definitions when building the AST 3307 // file. 3308 SmallVector<const IdentifierInfo *, 128> IIs; 3309 for (const auto &ID : PP.getIdentifierTable()) 3310 IIs.push_back(ID.second); 3311 // Sort the identifiers lexicographically before getting them references so 3312 // that their order is stable. 3313 std::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>()); 3314 for (const IdentifierInfo *II : IIs) 3315 if (Trait.isInterestingNonMacroIdentifier(II)) 3316 getIdentifierRef(II); 3317 3318 // Create the on-disk hash table representation. We only store offsets 3319 // for identifiers that appear here for the first time. 3320 IdentifierOffsets.resize(NextIdentID - FirstIdentID); 3321 for (auto IdentIDPair : IdentifierIDs) { 3322 auto *II = const_cast<IdentifierInfo *>(IdentIDPair.first); 3323 IdentID ID = IdentIDPair.second; 3324 assert(II && "NULL identifier in identifier table"); 3325 // Write out identifiers if either the ID is local or the identifier has 3326 // changed since it was loaded. 3327 if (ID >= FirstIdentID || !Chain || !II->isFromAST() 3328 || II->hasChangedSinceDeserialization() || 3329 (Trait.needDecls() && 3330 II->hasFETokenInfoChangedSinceDeserialization())) 3331 Generator.insert(II, ID, Trait); 3332 } 3333 3334 // Create the on-disk hash table in a buffer. 3335 SmallString<4096> IdentifierTable; 3336 uint32_t BucketOffset; 3337 { 3338 using namespace llvm::support; 3339 llvm::raw_svector_ostream Out(IdentifierTable); 3340 // Make sure that no bucket is at offset 0 3341 endian::Writer<little>(Out).write<uint32_t>(0); 3342 BucketOffset = Generator.Emit(Out, Trait); 3343 } 3344 3345 // Create a blob abbreviation 3346 auto *Abbrev = new BitCodeAbbrev(); 3347 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); 3348 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3349 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3350 unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); 3351 3352 // Write the identifier table 3353 RecordData::value_type Record[] = {IDENTIFIER_TABLE, BucketOffset}; 3354 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable); 3355 } 3356 3357 // Write the offsets table for identifier IDs. 3358 auto *Abbrev = new BitCodeAbbrev(); 3359 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); 3360 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers 3361 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 3362 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3363 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev); 3364 3365 #ifndef NDEBUG 3366 for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) 3367 assert(IdentifierOffsets[I] && "Missing identifier offset?"); 3368 #endif 3369 3370 RecordData::value_type Record[] = {IDENTIFIER_OFFSET, 3371 IdentifierOffsets.size(), 3372 FirstIdentID - NUM_PREDEF_IDENT_IDS}; 3373 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, 3374 bytes(IdentifierOffsets)); 3375 3376 // In C++, write the list of interesting identifiers (those that are 3377 // defined as macros, poisoned, or similar unusual things). 3378 if (!InterestingIdents.empty()) 3379 Stream.EmitRecord(INTERESTING_IDENTIFIERS, InterestingIdents); 3380 } 3381 3382 //===----------------------------------------------------------------------===// 3383 // DeclContext's Name Lookup Table Serialization 3384 //===----------------------------------------------------------------------===// 3385 3386 namespace { 3387 // Trait used for the on-disk hash table used in the method pool. 3388 class ASTDeclContextNameLookupTrait { 3389 ASTWriter &Writer; 3390 llvm::SmallVector<DeclID, 64> DeclIDs; 3391 3392 public: 3393 typedef DeclarationNameKey key_type; 3394 typedef key_type key_type_ref; 3395 3396 /// A start and end index into DeclIDs, representing a sequence of decls. 3397 typedef std::pair<unsigned, unsigned> data_type; 3398 typedef const data_type& data_type_ref; 3399 3400 typedef unsigned hash_value_type; 3401 typedef unsigned offset_type; 3402 3403 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { } 3404 3405 template<typename Coll> 3406 data_type getData(const Coll &Decls) { 3407 unsigned Start = DeclIDs.size(); 3408 for (NamedDecl *D : Decls) { 3409 DeclIDs.push_back( 3410 Writer.GetDeclRef(getDeclForLocalLookup(Writer.getLangOpts(), D))); 3411 } 3412 return std::make_pair(Start, DeclIDs.size()); 3413 } 3414 3415 data_type ImportData(const reader::ASTDeclContextNameLookupTrait::data_type &FromReader) { 3416 unsigned Start = DeclIDs.size(); 3417 for (auto ID : FromReader) 3418 DeclIDs.push_back(ID); 3419 return std::make_pair(Start, DeclIDs.size()); 3420 } 3421 3422 static bool EqualKey(key_type_ref a, key_type_ref b) { 3423 return a == b; 3424 } 3425 3426 hash_value_type ComputeHash(DeclarationNameKey Name) { 3427 return Name.getHash(); 3428 } 3429 3430 void EmitFileRef(raw_ostream &Out, ModuleFile *F) const { 3431 assert(Writer.hasChain() && 3432 "have reference to loaded module file but no chain?"); 3433 3434 using namespace llvm::support; 3435 endian::Writer<little>(Out) 3436 .write<uint32_t>(Writer.getChain()->getModuleFileID(F)); 3437 } 3438 3439 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out, 3440 DeclarationNameKey Name, 3441 data_type_ref Lookup) { 3442 using namespace llvm::support; 3443 endian::Writer<little> LE(Out); 3444 unsigned KeyLen = 1; 3445 switch (Name.getKind()) { 3446 case DeclarationName::Identifier: 3447 case DeclarationName::ObjCZeroArgSelector: 3448 case DeclarationName::ObjCOneArgSelector: 3449 case DeclarationName::ObjCMultiArgSelector: 3450 case DeclarationName::CXXLiteralOperatorName: 3451 KeyLen += 4; 3452 break; 3453 case DeclarationName::CXXOperatorName: 3454 KeyLen += 1; 3455 break; 3456 case DeclarationName::CXXConstructorName: 3457 case DeclarationName::CXXDestructorName: 3458 case DeclarationName::CXXConversionFunctionName: 3459 case DeclarationName::CXXUsingDirective: 3460 break; 3461 } 3462 LE.write<uint16_t>(KeyLen); 3463 3464 // 4 bytes for each DeclID. 3465 unsigned DataLen = 4 * (Lookup.second - Lookup.first); 3466 assert(uint16_t(DataLen) == DataLen && 3467 "too many decls for serialized lookup result"); 3468 LE.write<uint16_t>(DataLen); 3469 3470 return std::make_pair(KeyLen, DataLen); 3471 } 3472 3473 void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) { 3474 using namespace llvm::support; 3475 endian::Writer<little> LE(Out); 3476 LE.write<uint8_t>(Name.getKind()); 3477 switch (Name.getKind()) { 3478 case DeclarationName::Identifier: 3479 case DeclarationName::CXXLiteralOperatorName: 3480 LE.write<uint32_t>(Writer.getIdentifierRef(Name.getIdentifier())); 3481 return; 3482 case DeclarationName::ObjCZeroArgSelector: 3483 case DeclarationName::ObjCOneArgSelector: 3484 case DeclarationName::ObjCMultiArgSelector: 3485 LE.write<uint32_t>(Writer.getSelectorRef(Name.getSelector())); 3486 return; 3487 case DeclarationName::CXXOperatorName: 3488 assert(Name.getOperatorKind() < NUM_OVERLOADED_OPERATORS && 3489 "Invalid operator?"); 3490 LE.write<uint8_t>(Name.getOperatorKind()); 3491 return; 3492 case DeclarationName::CXXConstructorName: 3493 case DeclarationName::CXXDestructorName: 3494 case DeclarationName::CXXConversionFunctionName: 3495 case DeclarationName::CXXUsingDirective: 3496 return; 3497 } 3498 3499 llvm_unreachable("Invalid name kind?"); 3500 } 3501 3502 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup, 3503 unsigned DataLen) { 3504 using namespace llvm::support; 3505 endian::Writer<little> LE(Out); 3506 uint64_t Start = Out.tell(); (void)Start; 3507 for (unsigned I = Lookup.first, N = Lookup.second; I != N; ++I) 3508 LE.write<uint32_t>(DeclIDs[I]); 3509 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 3510 } 3511 }; 3512 } // end anonymous namespace 3513 3514 bool ASTWriter::isLookupResultExternal(StoredDeclsList &Result, 3515 DeclContext *DC) { 3516 return Result.hasExternalDecls() && DC->NeedToReconcileExternalVisibleStorage; 3517 } 3518 3519 bool ASTWriter::isLookupResultEntirelyExternal(StoredDeclsList &Result, 3520 DeclContext *DC) { 3521 for (auto *D : Result.getLookupResult()) 3522 if (!getDeclForLocalLookup(getLangOpts(), D)->isFromASTFile()) 3523 return false; 3524 3525 return true; 3526 } 3527 3528 void 3529 ASTWriter::GenerateNameLookupTable(const DeclContext *ConstDC, 3530 llvm::SmallVectorImpl<char> &LookupTable) { 3531 assert(!ConstDC->HasLazyLocalLexicalLookups && 3532 !ConstDC->HasLazyExternalLexicalLookups && 3533 "must call buildLookups first"); 3534 3535 // FIXME: We need to build the lookups table, which is logically const. 3536 auto *DC = const_cast<DeclContext*>(ConstDC); 3537 assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table"); 3538 3539 // Create the on-disk hash table representation. 3540 MultiOnDiskHashTableGenerator<reader::ASTDeclContextNameLookupTrait, 3541 ASTDeclContextNameLookupTrait> Generator; 3542 ASTDeclContextNameLookupTrait Trait(*this); 3543 3544 // The first step is to collect the declaration names which we need to 3545 // serialize into the name lookup table, and to collect them in a stable 3546 // order. 3547 SmallVector<DeclarationName, 16> Names; 3548 3549 // We also build up small sets of the constructor and conversion function 3550 // names which are visible. 3551 llvm::SmallSet<DeclarationName, 8> ConstructorNameSet, ConversionNameSet; 3552 3553 for (auto &Lookup : *DC->buildLookup()) { 3554 auto &Name = Lookup.first; 3555 auto &Result = Lookup.second; 3556 3557 // If there are no local declarations in our lookup result, we 3558 // don't need to write an entry for the name at all. If we can't 3559 // write out a lookup set without performing more deserialization, 3560 // just skip this entry. 3561 if (isLookupResultExternal(Result, DC) && 3562 isLookupResultEntirelyExternal(Result, DC)) 3563 continue; 3564 3565 // We also skip empty results. If any of the results could be external and 3566 // the currently available results are empty, then all of the results are 3567 // external and we skip it above. So the only way we get here with an empty 3568 // results is when no results could have been external *and* we have 3569 // external results. 3570 // 3571 // FIXME: While we might want to start emitting on-disk entries for negative 3572 // lookups into a decl context as an optimization, today we *have* to skip 3573 // them because there are names with empty lookup results in decl contexts 3574 // which we can't emit in any stable ordering: we lookup constructors and 3575 // conversion functions in the enclosing namespace scope creating empty 3576 // results for them. This in almost certainly a bug in Clang's name lookup, 3577 // but that is likely to be hard or impossible to fix and so we tolerate it 3578 // here by omitting lookups with empty results. 3579 if (Lookup.second.getLookupResult().empty()) 3580 continue; 3581 3582 switch (Lookup.first.getNameKind()) { 3583 default: 3584 Names.push_back(Lookup.first); 3585 break; 3586 3587 case DeclarationName::CXXConstructorName: 3588 assert(isa<CXXRecordDecl>(DC) && 3589 "Cannot have a constructor name outside of a class!"); 3590 ConstructorNameSet.insert(Name); 3591 break; 3592 3593 case DeclarationName::CXXConversionFunctionName: 3594 assert(isa<CXXRecordDecl>(DC) && 3595 "Cannot have a conversion function name outside of a class!"); 3596 ConversionNameSet.insert(Name); 3597 break; 3598 } 3599 } 3600 3601 // Sort the names into a stable order. 3602 std::sort(Names.begin(), Names.end()); 3603 3604 if (auto *D = dyn_cast<CXXRecordDecl>(DC)) { 3605 // We need to establish an ordering of constructor and conversion function 3606 // names, and they don't have an intrinsic ordering. 3607 3608 // First we try the easy case by forming the current context's constructor 3609 // name and adding that name first. This is a very useful optimization to 3610 // avoid walking the lexical declarations in many cases, and it also 3611 // handles the only case where a constructor name can come from some other 3612 // lexical context -- when that name is an implicit constructor merged from 3613 // another declaration in the redecl chain. Any non-implicit constructor or 3614 // conversion function which doesn't occur in all the lexical contexts 3615 // would be an ODR violation. 3616 auto ImplicitCtorName = Context->DeclarationNames.getCXXConstructorName( 3617 Context->getCanonicalType(Context->getRecordType(D))); 3618 if (ConstructorNameSet.erase(ImplicitCtorName)) 3619 Names.push_back(ImplicitCtorName); 3620 3621 // If we still have constructors or conversion functions, we walk all the 3622 // names in the decl and add the constructors and conversion functions 3623 // which are visible in the order they lexically occur within the context. 3624 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty()) 3625 for (Decl *ChildD : cast<CXXRecordDecl>(DC)->decls()) 3626 if (auto *ChildND = dyn_cast<NamedDecl>(ChildD)) { 3627 auto Name = ChildND->getDeclName(); 3628 switch (Name.getNameKind()) { 3629 default: 3630 continue; 3631 3632 case DeclarationName::CXXConstructorName: 3633 if (ConstructorNameSet.erase(Name)) 3634 Names.push_back(Name); 3635 break; 3636 3637 case DeclarationName::CXXConversionFunctionName: 3638 if (ConversionNameSet.erase(Name)) 3639 Names.push_back(Name); 3640 break; 3641 } 3642 3643 if (ConstructorNameSet.empty() && ConversionNameSet.empty()) 3644 break; 3645 } 3646 3647 assert(ConstructorNameSet.empty() && "Failed to find all of the visible " 3648 "constructors by walking all the " 3649 "lexical members of the context."); 3650 assert(ConversionNameSet.empty() && "Failed to find all of the visible " 3651 "conversion functions by walking all " 3652 "the lexical members of the context."); 3653 } 3654 3655 // Next we need to do a lookup with each name into this decl context to fully 3656 // populate any results from external sources. We don't actually use the 3657 // results of these lookups because we only want to use the results after all 3658 // results have been loaded and the pointers into them will be stable. 3659 for (auto &Name : Names) 3660 DC->lookup(Name); 3661 3662 // Now we need to insert the results for each name into the hash table. For 3663 // constructor names and conversion function names, we actually need to merge 3664 // all of the results for them into one list of results each and insert 3665 // those. 3666 SmallVector<NamedDecl *, 8> ConstructorDecls; 3667 SmallVector<NamedDecl *, 8> ConversionDecls; 3668 3669 // Now loop over the names, either inserting them or appending for the two 3670 // special cases. 3671 for (auto &Name : Names) { 3672 DeclContext::lookup_result Result = DC->noload_lookup(Name); 3673 3674 switch (Name.getNameKind()) { 3675 default: 3676 Generator.insert(Name, Trait.getData(Result), Trait); 3677 break; 3678 3679 case DeclarationName::CXXConstructorName: 3680 ConstructorDecls.append(Result.begin(), Result.end()); 3681 break; 3682 3683 case DeclarationName::CXXConversionFunctionName: 3684 ConversionDecls.append(Result.begin(), Result.end()); 3685 break; 3686 } 3687 } 3688 3689 // Handle our two special cases if we ended up having any. We arbitrarily use 3690 // the first declaration's name here because the name itself isn't part of 3691 // the key, only the kind of name is used. 3692 if (!ConstructorDecls.empty()) 3693 Generator.insert(ConstructorDecls.front()->getDeclName(), 3694 Trait.getData(ConstructorDecls), Trait); 3695 if (!ConversionDecls.empty()) 3696 Generator.insert(ConversionDecls.front()->getDeclName(), 3697 Trait.getData(ConversionDecls), Trait); 3698 3699 // Create the on-disk hash table. Also emit the existing imported and 3700 // merged table if there is one. 3701 auto *Lookups = Chain ? Chain->getLoadedLookupTables(DC) : nullptr; 3702 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table : nullptr); 3703 } 3704 3705 /// \brief Write the block containing all of the declaration IDs 3706 /// visible from the given DeclContext. 3707 /// 3708 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the 3709 /// bitstream, or 0 if no block was written. 3710 uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, 3711 DeclContext *DC) { 3712 // If we imported a key declaration of this namespace, write the visible 3713 // lookup results as an update record for it rather than including them 3714 // on this declaration. We will only look at key declarations on reload. 3715 if (isa<NamespaceDecl>(DC) && Chain && 3716 Chain->getKeyDeclaration(cast<Decl>(DC))->isFromASTFile()) { 3717 // Only do this once, for the first local declaration of the namespace. 3718 for (auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev; 3719 Prev = Prev->getPreviousDecl()) 3720 if (!Prev->isFromASTFile()) 3721 return 0; 3722 3723 // Note that we need to emit an update record for the primary context. 3724 UpdatedDeclContexts.insert(DC->getPrimaryContext()); 3725 3726 // Make sure all visible decls are written. They will be recorded later. We 3727 // do this using a side data structure so we can sort the names into 3728 // a deterministic order. 3729 StoredDeclsMap *Map = DC->getPrimaryContext()->buildLookup(); 3730 SmallVector<std::pair<DeclarationName, DeclContext::lookup_result>, 16> 3731 LookupResults; 3732 if (Map) { 3733 LookupResults.reserve(Map->size()); 3734 for (auto &Entry : *Map) 3735 LookupResults.push_back( 3736 std::make_pair(Entry.first, Entry.second.getLookupResult())); 3737 } 3738 3739 std::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); 3740 for (auto &NameAndResult : LookupResults) { 3741 DeclarationName Name = NameAndResult.first; 3742 DeclContext::lookup_result Result = NameAndResult.second; 3743 if (Name.getNameKind() == DeclarationName::CXXConstructorName || 3744 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 3745 // We have to work around a name lookup bug here where negative lookup 3746 // results for these names get cached in namespace lookup tables (these 3747 // names should never be looked up in a namespace). 3748 assert(Result.empty() && "Cannot have a constructor or conversion " 3749 "function name in a namespace!"); 3750 continue; 3751 } 3752 3753 for (NamedDecl *ND : Result) 3754 if (!ND->isFromASTFile()) 3755 GetDeclRef(ND); 3756 } 3757 3758 return 0; 3759 } 3760 3761 if (DC->getPrimaryContext() != DC) 3762 return 0; 3763 3764 // Skip contexts which don't support name lookup. 3765 if (!DC->isLookupContext()) 3766 return 0; 3767 3768 // If not in C++, we perform name lookup for the translation unit via the 3769 // IdentifierInfo chains, don't bother to build a visible-declarations table. 3770 if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) 3771 return 0; 3772 3773 // Serialize the contents of the mapping used for lookup. Note that, 3774 // although we have two very different code paths, the serialized 3775 // representation is the same for both cases: a declaration name, 3776 // followed by a size, followed by references to the visible 3777 // declarations that have that name. 3778 uint64_t Offset = Stream.GetCurrentBitNo(); 3779 StoredDeclsMap *Map = DC->buildLookup(); 3780 if (!Map || Map->empty()) 3781 return 0; 3782 3783 // Create the on-disk hash table in a buffer. 3784 SmallString<4096> LookupTable; 3785 GenerateNameLookupTable(DC, LookupTable); 3786 3787 // Write the lookup table 3788 RecordData::value_type Record[] = {DECL_CONTEXT_VISIBLE}; 3789 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, 3790 LookupTable); 3791 ++NumVisibleDeclContexts; 3792 return Offset; 3793 } 3794 3795 /// \brief Write an UPDATE_VISIBLE block for the given context. 3796 /// 3797 /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing 3798 /// DeclContext in a dependent AST file. As such, they only exist for the TU 3799 /// (in C++), for namespaces, and for classes with forward-declared unscoped 3800 /// enumeration members (in C++11). 3801 void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { 3802 StoredDeclsMap *Map = DC->getLookupPtr(); 3803 if (!Map || Map->empty()) 3804 return; 3805 3806 // Create the on-disk hash table in a buffer. 3807 SmallString<4096> LookupTable; 3808 GenerateNameLookupTable(DC, LookupTable); 3809 3810 // If we're updating a namespace, select a key declaration as the key for the 3811 // update record; those are the only ones that will be checked on reload. 3812 if (isa<NamespaceDecl>(DC)) 3813 DC = cast<DeclContext>(Chain->getKeyDeclaration(cast<Decl>(DC))); 3814 3815 // Write the lookup table 3816 RecordData::value_type Record[] = {UPDATE_VISIBLE, getDeclID(cast<Decl>(DC))}; 3817 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable); 3818 } 3819 3820 /// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions. 3821 void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) { 3822 RecordData::value_type Record[] = {Opts.fp_contract}; 3823 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); 3824 } 3825 3826 /// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. 3827 void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { 3828 if (!SemaRef.Context.getLangOpts().OpenCL) 3829 return; 3830 3831 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); 3832 RecordData Record; 3833 #define OPENCLEXT(nm) Record.push_back(Opts.nm); 3834 #include "clang/Basic/OpenCLExtensions.def" 3835 Stream.EmitRecord(OPENCL_EXTENSIONS, Record); 3836 } 3837 3838 void ASTWriter::WriteObjCCategories() { 3839 SmallVector<ObjCCategoriesInfo, 2> CategoriesMap; 3840 RecordData Categories; 3841 3842 for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { 3843 unsigned Size = 0; 3844 unsigned StartIndex = Categories.size(); 3845 3846 ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; 3847 3848 // Allocate space for the size. 3849 Categories.push_back(0); 3850 3851 // Add the categories. 3852 for (ObjCInterfaceDecl::known_categories_iterator 3853 Cat = Class->known_categories_begin(), 3854 CatEnd = Class->known_categories_end(); 3855 Cat != CatEnd; ++Cat, ++Size) { 3856 assert(getDeclID(*Cat) != 0 && "Bogus category"); 3857 AddDeclRef(*Cat, Categories); 3858 } 3859 3860 // Update the size. 3861 Categories[StartIndex] = Size; 3862 3863 // Record this interface -> category map. 3864 ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; 3865 CategoriesMap.push_back(CatInfo); 3866 } 3867 3868 // Sort the categories map by the definition ID, since the reader will be 3869 // performing binary searches on this information. 3870 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); 3871 3872 // Emit the categories map. 3873 using namespace llvm; 3874 3875 auto *Abbrev = new BitCodeAbbrev(); 3876 Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); 3877 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries 3878 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3879 unsigned AbbrevID = Stream.EmitAbbrev(Abbrev); 3880 3881 RecordData::value_type Record[] = {OBJC_CATEGORIES_MAP, CategoriesMap.size()}; 3882 Stream.EmitRecordWithBlob(AbbrevID, Record, 3883 reinterpret_cast<char *>(CategoriesMap.data()), 3884 CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); 3885 3886 // Emit the category lists. 3887 Stream.EmitRecord(OBJC_CATEGORIES, Categories); 3888 } 3889 3890 void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) { 3891 Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap; 3892 3893 if (LPTMap.empty()) 3894 return; 3895 3896 RecordData Record; 3897 for (auto LPTMapEntry : LPTMap) { 3898 const FunctionDecl *FD = LPTMapEntry.first; 3899 LateParsedTemplate *LPT = LPTMapEntry.second; 3900 AddDeclRef(FD, Record); 3901 AddDeclRef(LPT->D, Record); 3902 Record.push_back(LPT->Toks.size()); 3903 3904 for (const auto &Tok : LPT->Toks) { 3905 AddToken(Tok, Record); 3906 } 3907 } 3908 Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record); 3909 } 3910 3911 /// \brief Write the state of 'pragma clang optimize' at the end of the module. 3912 void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) { 3913 RecordData Record; 3914 SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation(); 3915 AddSourceLocation(PragmaLoc, Record); 3916 Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record); 3917 } 3918 3919 /// \brief Write the state of 'pragma ms_struct' at the end of the module. 3920 void ASTWriter::WriteMSStructPragmaOptions(Sema &SemaRef) { 3921 RecordData Record; 3922 Record.push_back(SemaRef.MSStructPragmaOn ? PMSST_ON : PMSST_OFF); 3923 Stream.EmitRecord(MSSTRUCT_PRAGMA_OPTIONS, Record); 3924 } 3925 3926 /// \brief Write the state of 'pragma pointers_to_members' at the end of the 3927 //module. 3928 void ASTWriter::WriteMSPointersToMembersPragmaOptions(Sema &SemaRef) { 3929 RecordData Record; 3930 Record.push_back(SemaRef.MSPointerToMemberRepresentationMethod); 3931 AddSourceLocation(SemaRef.ImplicitMSInheritanceAttrLoc, Record); 3932 Stream.EmitRecord(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS, Record); 3933 } 3934 3935 void ASTWriter::WriteModuleFileExtension(Sema &SemaRef, 3936 ModuleFileExtensionWriter &Writer) { 3937 // Enter the extension block. 3938 Stream.EnterSubblock(EXTENSION_BLOCK_ID, 4); 3939 3940 // Emit the metadata record abbreviation. 3941 auto *Abv = new llvm::BitCodeAbbrev(); 3942 Abv->Add(llvm::BitCodeAbbrevOp(EXTENSION_METADATA)); 3943 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 3944 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 3945 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 3946 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 3947 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 3948 unsigned Abbrev = Stream.EmitAbbrev(Abv); 3949 3950 // Emit the metadata record. 3951 RecordData Record; 3952 auto Metadata = Writer.getExtension()->getExtensionMetadata(); 3953 Record.push_back(EXTENSION_METADATA); 3954 Record.push_back(Metadata.MajorVersion); 3955 Record.push_back(Metadata.MinorVersion); 3956 Record.push_back(Metadata.BlockName.size()); 3957 Record.push_back(Metadata.UserInfo.size()); 3958 SmallString<64> Buffer; 3959 Buffer += Metadata.BlockName; 3960 Buffer += Metadata.UserInfo; 3961 Stream.EmitRecordWithBlob(Abbrev, Record, Buffer); 3962 3963 // Emit the contents of the extension block. 3964 Writer.writeExtensionContents(SemaRef, Stream); 3965 3966 // Exit the extension block. 3967 Stream.ExitBlock(); 3968 } 3969 3970 //===----------------------------------------------------------------------===// 3971 // General Serialization Routines 3972 //===----------------------------------------------------------------------===// 3973 3974 /// \brief Emit the list of attributes to the specified record. 3975 void ASTRecordWriter::AddAttributes(ArrayRef<const Attr *> Attrs) { 3976 auto &Record = *this; 3977 Record.push_back(Attrs.size()); 3978 for (const auto *A : Attrs) { 3979 Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs 3980 Record.AddSourceRange(A->getRange()); 3981 3982 #include "clang/Serialization/AttrPCHWrite.inc" 3983 3984 } 3985 } 3986 3987 void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) { 3988 AddSourceLocation(Tok.getLocation(), Record); 3989 Record.push_back(Tok.getLength()); 3990 3991 // FIXME: When reading literal tokens, reconstruct the literal pointer 3992 // if it is needed. 3993 AddIdentifierRef(Tok.getIdentifierInfo(), Record); 3994 // FIXME: Should translate token kind to a stable encoding. 3995 Record.push_back(Tok.getKind()); 3996 // FIXME: Should translate token flags to a stable encoding. 3997 Record.push_back(Tok.getFlags()); 3998 } 3999 4000 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { 4001 Record.push_back(Str.size()); 4002 Record.insert(Record.end(), Str.begin(), Str.end()); 4003 } 4004 4005 bool ASTWriter::PreparePathForOutput(SmallVectorImpl<char> &Path) { 4006 assert(Context && "should have context when outputting path"); 4007 4008 bool Changed = 4009 cleanPathForOutput(Context->getSourceManager().getFileManager(), Path); 4010 4011 // Remove a prefix to make the path relative, if relevant. 4012 const char *PathBegin = Path.data(); 4013 const char *PathPtr = 4014 adjustFilenameForRelocatableAST(PathBegin, BaseDirectory); 4015 if (PathPtr != PathBegin) { 4016 Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin)); 4017 Changed = true; 4018 } 4019 4020 return Changed; 4021 } 4022 4023 void ASTWriter::AddPath(StringRef Path, RecordDataImpl &Record) { 4024 SmallString<128> FilePath(Path); 4025 PreparePathForOutput(FilePath); 4026 AddString(FilePath, Record); 4027 } 4028 4029 void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, 4030 StringRef Path) { 4031 SmallString<128> FilePath(Path); 4032 PreparePathForOutput(FilePath); 4033 Stream.EmitRecordWithBlob(Abbrev, Record, FilePath); 4034 } 4035 4036 void ASTWriter::AddVersionTuple(const VersionTuple &Version, 4037 RecordDataImpl &Record) { 4038 Record.push_back(Version.getMajor()); 4039 if (Optional<unsigned> Minor = Version.getMinor()) 4040 Record.push_back(*Minor + 1); 4041 else 4042 Record.push_back(0); 4043 if (Optional<unsigned> Subminor = Version.getSubminor()) 4044 Record.push_back(*Subminor + 1); 4045 else 4046 Record.push_back(0); 4047 } 4048 4049 /// \brief Note that the identifier II occurs at the given offset 4050 /// within the identifier table. 4051 void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { 4052 IdentID ID = IdentifierIDs[II]; 4053 // Only store offsets new to this AST file. Other identifier names are looked 4054 // up earlier in the chain and thus don't need an offset. 4055 if (ID >= FirstIdentID) 4056 IdentifierOffsets[ID - FirstIdentID] = Offset; 4057 } 4058 4059 /// \brief Note that the selector Sel occurs at the given offset 4060 /// within the method pool/selector table. 4061 void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { 4062 unsigned ID = SelectorIDs[Sel]; 4063 assert(ID && "Unknown selector"); 4064 // Don't record offsets for selectors that are also available in a different 4065 // file. 4066 if (ID < FirstSelectorID) 4067 return; 4068 SelectorOffsets[ID - FirstSelectorID] = Offset; 4069 } 4070 4071 ASTWriter::ASTWriter( 4072 llvm::BitstreamWriter &Stream, 4073 ArrayRef<llvm::IntrusiveRefCntPtr<ModuleFileExtension>> Extensions, 4074 bool IncludeTimestamps) 4075 : Stream(Stream), Context(nullptr), PP(nullptr), Chain(nullptr), 4076 WritingModule(nullptr), IncludeTimestamps(IncludeTimestamps), 4077 WritingAST(false), DoneWritingDeclsAndTypes(false), 4078 ASTHasCompilerErrors(false), FirstDeclID(NUM_PREDEF_DECL_IDS), 4079 NextDeclID(FirstDeclID), FirstTypeID(NUM_PREDEF_TYPE_IDS), 4080 NextTypeID(FirstTypeID), FirstIdentID(NUM_PREDEF_IDENT_IDS), 4081 NextIdentID(FirstIdentID), FirstMacroID(NUM_PREDEF_MACRO_IDS), 4082 NextMacroID(FirstMacroID), FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS), 4083 NextSubmoduleID(FirstSubmoduleID), 4084 FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), NextSelectorID(FirstSelectorID), 4085 NumStatements(0), NumMacros(0), 4086 NumLexicalDeclContexts(0), NumVisibleDeclContexts(0), 4087 TypeExtQualAbbrev(0), TypeFunctionProtoAbbrev(0), DeclParmVarAbbrev(0), 4088 DeclContextLexicalAbbrev(0), DeclContextVisibleLookupAbbrev(0), 4089 UpdateVisibleAbbrev(0), DeclRecordAbbrev(0), DeclTypedefAbbrev(0), 4090 DeclVarAbbrev(0), DeclFieldAbbrev(0), DeclEnumAbbrev(0), 4091 DeclObjCIvarAbbrev(0), DeclCXXMethodAbbrev(0), DeclRefExprAbbrev(0), 4092 CharacterLiteralAbbrev(0), IntegerLiteralAbbrev(0), 4093 ExprImplicitCastAbbrev(0) { 4094 for (const auto &Ext : Extensions) { 4095 if (auto Writer = Ext->createExtensionWriter(*this)) 4096 ModuleFileExtensionWriters.push_back(std::move(Writer)); 4097 } 4098 } 4099 4100 ASTWriter::~ASTWriter() { 4101 llvm::DeleteContainerSeconds(FileDeclIDs); 4102 } 4103 4104 const LangOptions &ASTWriter::getLangOpts() const { 4105 assert(WritingAST && "can't determine lang opts when not writing AST"); 4106 return Context->getLangOpts(); 4107 } 4108 4109 time_t ASTWriter::getTimestampForOutput(const FileEntry *E) const { 4110 return IncludeTimestamps ? E->getModificationTime() : 0; 4111 } 4112 4113 uint64_t ASTWriter::WriteAST(Sema &SemaRef, const std::string &OutputFile, 4114 Module *WritingModule, StringRef isysroot, 4115 bool hasErrors) { 4116 WritingAST = true; 4117 4118 ASTHasCompilerErrors = hasErrors; 4119 4120 // Emit the file header. 4121 Stream.Emit((unsigned)'C', 8); 4122 Stream.Emit((unsigned)'P', 8); 4123 Stream.Emit((unsigned)'C', 8); 4124 Stream.Emit((unsigned)'H', 8); 4125 4126 WriteBlockInfoBlock(); 4127 4128 Context = &SemaRef.Context; 4129 PP = &SemaRef.PP; 4130 this->WritingModule = WritingModule; 4131 ASTFileSignature Signature = 4132 WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); 4133 Context = nullptr; 4134 PP = nullptr; 4135 this->WritingModule = nullptr; 4136 this->BaseDirectory.clear(); 4137 4138 WritingAST = false; 4139 return Signature; 4140 } 4141 4142 template<typename Vector> 4143 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, 4144 ASTWriter::RecordData &Record) { 4145 for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end(); 4146 I != E; ++I) { 4147 Writer.AddDeclRef(*I, Record); 4148 } 4149 } 4150 4151 uint64_t ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, 4152 const std::string &OutputFile, 4153 Module *WritingModule) { 4154 using namespace llvm; 4155 4156 bool isModule = WritingModule != nullptr; 4157 4158 // Make sure that the AST reader knows to finalize itself. 4159 if (Chain) 4160 Chain->finalizeForWriting(); 4161 4162 ASTContext &Context = SemaRef.Context; 4163 Preprocessor &PP = SemaRef.PP; 4164 4165 // Set up predefined declaration IDs. 4166 auto RegisterPredefDecl = [&] (Decl *D, PredefinedDeclIDs ID) { 4167 if (D) { 4168 assert(D->isCanonicalDecl() && "predefined decl is not canonical"); 4169 DeclIDs[D] = ID; 4170 } 4171 }; 4172 RegisterPredefDecl(Context.getTranslationUnitDecl(), 4173 PREDEF_DECL_TRANSLATION_UNIT_ID); 4174 RegisterPredefDecl(Context.ObjCIdDecl, PREDEF_DECL_OBJC_ID_ID); 4175 RegisterPredefDecl(Context.ObjCSelDecl, PREDEF_DECL_OBJC_SEL_ID); 4176 RegisterPredefDecl(Context.ObjCClassDecl, PREDEF_DECL_OBJC_CLASS_ID); 4177 RegisterPredefDecl(Context.ObjCProtocolClassDecl, 4178 PREDEF_DECL_OBJC_PROTOCOL_ID); 4179 RegisterPredefDecl(Context.Int128Decl, PREDEF_DECL_INT_128_ID); 4180 RegisterPredefDecl(Context.UInt128Decl, PREDEF_DECL_UNSIGNED_INT_128_ID); 4181 RegisterPredefDecl(Context.ObjCInstanceTypeDecl, 4182 PREDEF_DECL_OBJC_INSTANCETYPE_ID); 4183 RegisterPredefDecl(Context.BuiltinVaListDecl, PREDEF_DECL_BUILTIN_VA_LIST_ID); 4184 RegisterPredefDecl(Context.VaListTagDecl, PREDEF_DECL_VA_LIST_TAG); 4185 RegisterPredefDecl(Context.BuiltinMSVaListDecl, 4186 PREDEF_DECL_BUILTIN_MS_VA_LIST_ID); 4187 RegisterPredefDecl(Context.ExternCContext, PREDEF_DECL_EXTERN_C_CONTEXT_ID); 4188 RegisterPredefDecl(Context.MakeIntegerSeqDecl, 4189 PREDEF_DECL_MAKE_INTEGER_SEQ_ID); 4190 RegisterPredefDecl(Context.CFConstantStringTypeDecl, 4191 PREDEF_DECL_CF_CONSTANT_STRING_ID); 4192 RegisterPredefDecl(Context.CFConstantStringTagDecl, 4193 PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID); 4194 RegisterPredefDecl(Context.TypePackElementDecl, 4195 PREDEF_DECL_TYPE_PACK_ELEMENT_ID); 4196 4197 // Build a record containing all of the tentative definitions in this file, in 4198 // TentativeDefinitions order. Generally, this record will be empty for 4199 // headers. 4200 RecordData TentativeDefinitions; 4201 AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); 4202 4203 // Build a record containing all of the file scoped decls in this file. 4204 RecordData UnusedFileScopedDecls; 4205 if (!isModule) 4206 AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, 4207 UnusedFileScopedDecls); 4208 4209 // Build a record containing all of the delegating constructors we still need 4210 // to resolve. 4211 RecordData DelegatingCtorDecls; 4212 if (!isModule) 4213 AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); 4214 4215 // Write the set of weak, undeclared identifiers. We always write the 4216 // entire table, since later PCH files in a PCH chain are only interested in 4217 // the results at the end of the chain. 4218 RecordData WeakUndeclaredIdentifiers; 4219 for (auto &WeakUndeclaredIdentifier : SemaRef.WeakUndeclaredIdentifiers) { 4220 IdentifierInfo *II = WeakUndeclaredIdentifier.first; 4221 WeakInfo &WI = WeakUndeclaredIdentifier.second; 4222 AddIdentifierRef(II, WeakUndeclaredIdentifiers); 4223 AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers); 4224 AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers); 4225 WeakUndeclaredIdentifiers.push_back(WI.getUsed()); 4226 } 4227 4228 // Build a record containing all of the ext_vector declarations. 4229 RecordData ExtVectorDecls; 4230 AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); 4231 4232 // Build a record containing all of the VTable uses information. 4233 RecordData VTableUses; 4234 if (!SemaRef.VTableUses.empty()) { 4235 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 4236 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 4237 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 4238 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 4239 } 4240 } 4241 4242 // Build a record containing all of the UnusedLocalTypedefNameCandidates. 4243 RecordData UnusedLocalTypedefNameCandidates; 4244 for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates) 4245 AddDeclRef(TD, UnusedLocalTypedefNameCandidates); 4246 4247 // Build a record containing all of pending implicit instantiations. 4248 RecordData PendingInstantiations; 4249 for (const auto &I : SemaRef.PendingInstantiations) { 4250 AddDeclRef(I.first, PendingInstantiations); 4251 AddSourceLocation(I.second, PendingInstantiations); 4252 } 4253 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 4254 "There are local ones at end of translation unit!"); 4255 4256 // Build a record containing some declaration references. 4257 RecordData SemaDeclRefs; 4258 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) { 4259 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 4260 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 4261 } 4262 4263 RecordData CUDASpecialDeclRefs; 4264 if (Context.getcudaConfigureCallDecl()) { 4265 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); 4266 } 4267 4268 // Build a record containing all of the known namespaces. 4269 RecordData KnownNamespaces; 4270 for (const auto &I : SemaRef.KnownNamespaces) { 4271 if (!I.second) 4272 AddDeclRef(I.first, KnownNamespaces); 4273 } 4274 4275 // Build a record of all used, undefined objects that require definitions. 4276 RecordData UndefinedButUsed; 4277 4278 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined; 4279 SemaRef.getUndefinedButUsed(Undefined); 4280 for (const auto &I : Undefined) { 4281 AddDeclRef(I.first, UndefinedButUsed); 4282 AddSourceLocation(I.second, UndefinedButUsed); 4283 } 4284 4285 // Build a record containing all delete-expressions that we would like to 4286 // analyze later in AST. 4287 RecordData DeleteExprsToAnalyze; 4288 4289 for (const auto &DeleteExprsInfo : 4290 SemaRef.getMismatchingDeleteExpressions()) { 4291 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze); 4292 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size()); 4293 for (const auto &DeleteLoc : DeleteExprsInfo.second) { 4294 AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze); 4295 DeleteExprsToAnalyze.push_back(DeleteLoc.second); 4296 } 4297 } 4298 4299 // Write the control block 4300 uint64_t Signature = WriteControlBlock(PP, Context, isysroot, OutputFile); 4301 4302 // Write the remaining AST contents. 4303 Stream.EnterSubblock(AST_BLOCK_ID, 5); 4304 4305 // This is so that older clang versions, before the introduction 4306 // of the control block, can read and reject the newer PCH format. 4307 { 4308 RecordData Record = {VERSION_MAJOR}; 4309 Stream.EmitRecord(METADATA_OLD_FORMAT, Record); 4310 } 4311 4312 // Create a lexical update block containing all of the declarations in the 4313 // translation unit that do not come from other AST files. 4314 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 4315 SmallVector<uint32_t, 128> NewGlobalKindDeclPairs; 4316 for (const auto *D : TU->noload_decls()) { 4317 if (!D->isFromASTFile()) { 4318 NewGlobalKindDeclPairs.push_back(D->getKind()); 4319 NewGlobalKindDeclPairs.push_back(GetDeclRef(D)); 4320 } 4321 } 4322 4323 auto *Abv = new llvm::BitCodeAbbrev(); 4324 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); 4325 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4326 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv); 4327 { 4328 RecordData::value_type Record[] = {TU_UPDATE_LEXICAL}; 4329 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, 4330 bytes(NewGlobalKindDeclPairs)); 4331 } 4332 4333 // And a visible updates block for the translation unit. 4334 Abv = new llvm::BitCodeAbbrev(); 4335 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); 4336 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 4337 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4338 UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv); 4339 WriteDeclContextVisibleUpdate(TU); 4340 4341 // If we have any extern "C" names, write out a visible update for them. 4342 if (Context.ExternCContext) 4343 WriteDeclContextVisibleUpdate(Context.ExternCContext); 4344 4345 // If the translation unit has an anonymous namespace, and we don't already 4346 // have an update block for it, write it as an update block. 4347 // FIXME: Why do we not do this if there's already an update block? 4348 if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { 4349 ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; 4350 if (Record.empty()) 4351 Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS)); 4352 } 4353 4354 // Add update records for all mangling numbers and static local numbers. 4355 // These aren't really update records, but this is a convenient way of 4356 // tagging this rare extra data onto the declarations. 4357 for (const auto &Number : Context.MangleNumbers) 4358 if (!Number.first->isFromASTFile()) 4359 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER, 4360 Number.second)); 4361 for (const auto &Number : Context.StaticLocalNumbers) 4362 if (!Number.first->isFromASTFile()) 4363 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER, 4364 Number.second)); 4365 4366 // Make sure visible decls, added to DeclContexts previously loaded from 4367 // an AST file, are registered for serialization. 4368 for (const auto *I : UpdatingVisibleDecls) { 4369 GetDeclRef(I); 4370 } 4371 4372 // Make sure all decls associated with an identifier are registered for 4373 // serialization, if we're storing decls with identifiers. 4374 if (!WritingModule || !getLangOpts().CPlusPlus) { 4375 llvm::SmallVector<const IdentifierInfo*, 256> IIs; 4376 for (const auto &ID : PP.getIdentifierTable()) { 4377 const IdentifierInfo *II = ID.second; 4378 if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) 4379 IIs.push_back(II); 4380 } 4381 // Sort the identifiers to visit based on their name. 4382 std::sort(IIs.begin(), IIs.end(), llvm::less_ptr<IdentifierInfo>()); 4383 for (const IdentifierInfo *II : IIs) { 4384 for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), 4385 DEnd = SemaRef.IdResolver.end(); 4386 D != DEnd; ++D) { 4387 GetDeclRef(*D); 4388 } 4389 } 4390 } 4391 4392 // For method pool in the module, if it contains an entry for a selector, 4393 // the entry should be complete, containing everything introduced by that 4394 // module and all modules it imports. It's possible that the entry is out of 4395 // date, so we need to pull in the new content here. 4396 4397 // It's possible that updateOutOfDateSelector can update SelectorIDs. To be 4398 // safe, we copy all selectors out. 4399 llvm::SmallVector<Selector, 256> AllSelectors; 4400 for (auto &SelectorAndID : SelectorIDs) 4401 AllSelectors.push_back(SelectorAndID.first); 4402 for (auto &Selector : AllSelectors) 4403 SemaRef.updateOutOfDateSelector(Selector); 4404 4405 // Form the record of special types. 4406 RecordData SpecialTypes; 4407 AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); 4408 AddTypeRef(Context.getFILEType(), SpecialTypes); 4409 AddTypeRef(Context.getjmp_bufType(), SpecialTypes); 4410 AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); 4411 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); 4412 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); 4413 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); 4414 AddTypeRef(Context.getucontext_tType(), SpecialTypes); 4415 4416 if (Chain) { 4417 // Write the mapping information describing our module dependencies and how 4418 // each of those modules were mapped into our own offset/ID space, so that 4419 // the reader can build the appropriate mapping to its own offset/ID space. 4420 // The map consists solely of a blob with the following format: 4421 // *(module-name-len:i16 module-name:len*i8 4422 // source-location-offset:i32 4423 // identifier-id:i32 4424 // preprocessed-entity-id:i32 4425 // macro-definition-id:i32 4426 // submodule-id:i32 4427 // selector-id:i32 4428 // declaration-id:i32 4429 // c++-base-specifiers-id:i32 4430 // type-id:i32) 4431 // 4432 auto *Abbrev = new BitCodeAbbrev(); 4433 Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); 4434 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 4435 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev); 4436 SmallString<2048> Buffer; 4437 { 4438 llvm::raw_svector_ostream Out(Buffer); 4439 for (ModuleFile *M : Chain->ModuleMgr) { 4440 using namespace llvm::support; 4441 endian::Writer<little> LE(Out); 4442 StringRef FileName = M->FileName; 4443 LE.write<uint16_t>(FileName.size()); 4444 Out.write(FileName.data(), FileName.size()); 4445 4446 // Note: if a base ID was uint max, it would not be possible to load 4447 // another module after it or have more than one entity inside it. 4448 uint32_t None = std::numeric_limits<uint32_t>::max(); 4449 4450 auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) { 4451 assert(BaseID < std::numeric_limits<uint32_t>::max() && "base id too high"); 4452 if (ShouldWrite) 4453 LE.write<uint32_t>(BaseID); 4454 else 4455 LE.write<uint32_t>(None); 4456 }; 4457 4458 // These values should be unique within a chain, since they will be read 4459 // as keys into ContinuousRangeMaps. 4460 writeBaseIDOrNone(M->SLocEntryBaseOffset, M->LocalNumSLocEntries); 4461 writeBaseIDOrNone(M->BaseIdentifierID, M->LocalNumIdentifiers); 4462 writeBaseIDOrNone(M->BaseMacroID, M->LocalNumMacros); 4463 writeBaseIDOrNone(M->BasePreprocessedEntityID, 4464 M->NumPreprocessedEntities); 4465 writeBaseIDOrNone(M->BaseSubmoduleID, M->LocalNumSubmodules); 4466 writeBaseIDOrNone(M->BaseSelectorID, M->LocalNumSelectors); 4467 writeBaseIDOrNone(M->BaseDeclID, M->LocalNumDecls); 4468 writeBaseIDOrNone(M->BaseTypeIndex, M->LocalNumTypes); 4469 } 4470 } 4471 RecordData::value_type Record[] = {MODULE_OFFSET_MAP}; 4472 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, 4473 Buffer.data(), Buffer.size()); 4474 } 4475 4476 RecordData DeclUpdatesOffsetsRecord; 4477 4478 // Keep writing types, declarations, and declaration update records 4479 // until we've emitted all of them. 4480 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, /*bits for abbreviations*/5); 4481 WriteTypeAbbrevs(); 4482 WriteDeclAbbrevs(); 4483 do { 4484 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord); 4485 while (!DeclTypesToEmit.empty()) { 4486 DeclOrType DOT = DeclTypesToEmit.front(); 4487 DeclTypesToEmit.pop(); 4488 if (DOT.isType()) 4489 WriteType(DOT.getType()); 4490 else 4491 WriteDecl(Context, DOT.getDecl()); 4492 } 4493 } while (!DeclUpdates.empty()); 4494 Stream.ExitBlock(); 4495 4496 DoneWritingDeclsAndTypes = true; 4497 4498 // These things can only be done once we've written out decls and types. 4499 WriteTypeDeclOffsets(); 4500 if (!DeclUpdatesOffsetsRecord.empty()) 4501 Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord); 4502 WriteFileDeclIDsMap(); 4503 WriteSourceManagerBlock(Context.getSourceManager(), PP); 4504 WriteComments(); 4505 WritePreprocessor(PP, isModule); 4506 WriteHeaderSearch(PP.getHeaderSearchInfo()); 4507 WriteSelectors(SemaRef); 4508 WriteReferencedSelectorsPool(SemaRef); 4509 WriteLateParsedTemplates(SemaRef); 4510 WriteIdentifierTable(PP, SemaRef.IdResolver, isModule); 4511 WriteFPPragmaOptions(SemaRef.getFPOptions()); 4512 WriteOpenCLExtensions(SemaRef); 4513 WritePragmaDiagnosticMappings(Context.getDiagnostics(), isModule); 4514 4515 // If we're emitting a module, write out the submodule information. 4516 if (WritingModule) 4517 WriteSubmodules(WritingModule); 4518 4519 Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); 4520 4521 // Write the record containing external, unnamed definitions. 4522 if (!EagerlyDeserializedDecls.empty()) 4523 Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls); 4524 4525 // Write the record containing tentative definitions. 4526 if (!TentativeDefinitions.empty()) 4527 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 4528 4529 // Write the record containing unused file scoped decls. 4530 if (!UnusedFileScopedDecls.empty()) 4531 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 4532 4533 // Write the record containing weak undeclared identifiers. 4534 if (!WeakUndeclaredIdentifiers.empty()) 4535 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 4536 WeakUndeclaredIdentifiers); 4537 4538 // Write the record containing ext_vector type names. 4539 if (!ExtVectorDecls.empty()) 4540 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 4541 4542 // Write the record containing VTable uses information. 4543 if (!VTableUses.empty()) 4544 Stream.EmitRecord(VTABLE_USES, VTableUses); 4545 4546 // Write the record containing potentially unused local typedefs. 4547 if (!UnusedLocalTypedefNameCandidates.empty()) 4548 Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES, 4549 UnusedLocalTypedefNameCandidates); 4550 4551 // Write the record containing pending implicit instantiations. 4552 if (!PendingInstantiations.empty()) 4553 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); 4554 4555 // Write the record containing declaration references of Sema. 4556 if (!SemaDeclRefs.empty()) 4557 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 4558 4559 // Write the record containing CUDA-specific declaration references. 4560 if (!CUDASpecialDeclRefs.empty()) 4561 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); 4562 4563 // Write the delegating constructors. 4564 if (!DelegatingCtorDecls.empty()) 4565 Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); 4566 4567 // Write the known namespaces. 4568 if (!KnownNamespaces.empty()) 4569 Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); 4570 4571 // Write the undefined internal functions and variables, and inline functions. 4572 if (!UndefinedButUsed.empty()) 4573 Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed); 4574 4575 if (!DeleteExprsToAnalyze.empty()) 4576 Stream.EmitRecord(DELETE_EXPRS_TO_ANALYZE, DeleteExprsToAnalyze); 4577 4578 // Write the visible updates to DeclContexts. 4579 for (auto *DC : UpdatedDeclContexts) 4580 WriteDeclContextVisibleUpdate(DC); 4581 4582 if (!WritingModule) { 4583 // Write the submodules that were imported, if any. 4584 struct ModuleInfo { 4585 uint64_t ID; 4586 Module *M; 4587 ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {} 4588 }; 4589 llvm::SmallVector<ModuleInfo, 64> Imports; 4590 for (const auto *I : Context.local_imports()) { 4591 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); 4592 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()], 4593 I->getImportedModule())); 4594 } 4595 4596 if (!Imports.empty()) { 4597 auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) { 4598 return A.ID < B.ID; 4599 }; 4600 auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) { 4601 return A.ID == B.ID; 4602 }; 4603 4604 // Sort and deduplicate module IDs. 4605 std::sort(Imports.begin(), Imports.end(), Cmp); 4606 Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq), 4607 Imports.end()); 4608 4609 RecordData ImportedModules; 4610 for (const auto &Import : Imports) { 4611 ImportedModules.push_back(Import.ID); 4612 // FIXME: If the module has macros imported then later has declarations 4613 // imported, this location won't be the right one as a location for the 4614 // declaration imports. 4615 AddSourceLocation(PP.getModuleImportLoc(Import.M), ImportedModules); 4616 } 4617 4618 Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); 4619 } 4620 } 4621 4622 WriteObjCCategories(); 4623 if(!WritingModule) { 4624 WriteOptimizePragmaOptions(SemaRef); 4625 WriteMSStructPragmaOptions(SemaRef); 4626 WriteMSPointersToMembersPragmaOptions(SemaRef); 4627 } 4628 4629 // Some simple statistics 4630 RecordData::value_type Record[] = { 4631 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts}; 4632 Stream.EmitRecord(STATISTICS, Record); 4633 Stream.ExitBlock(); 4634 4635 // Write the module file extension blocks. 4636 for (const auto &ExtWriter : ModuleFileExtensionWriters) 4637 WriteModuleFileExtension(SemaRef, *ExtWriter); 4638 4639 return Signature; 4640 } 4641 4642 void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { 4643 if (DeclUpdates.empty()) 4644 return; 4645 4646 DeclUpdateMap LocalUpdates; 4647 LocalUpdates.swap(DeclUpdates); 4648 4649 for (auto &DeclUpdate : LocalUpdates) { 4650 const Decl *D = DeclUpdate.first; 4651 4652 bool HasUpdatedBody = false; 4653 RecordData RecordData; 4654 ASTRecordWriter Record(*this, RecordData); 4655 for (auto &Update : DeclUpdate.second) { 4656 DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind(); 4657 4658 // An updated body is emitted last, so that the reader doesn't need 4659 // to skip over the lazy body to reach statements for other records. 4660 if (Kind == UPD_CXX_ADDED_FUNCTION_DEFINITION) 4661 HasUpdatedBody = true; 4662 else 4663 Record.push_back(Kind); 4664 4665 switch (Kind) { 4666 case UPD_CXX_ADDED_IMPLICIT_MEMBER: 4667 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: 4668 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: 4669 assert(Update.getDecl() && "no decl to add?"); 4670 Record.push_back(GetDeclRef(Update.getDecl())); 4671 break; 4672 4673 case UPD_CXX_ADDED_FUNCTION_DEFINITION: 4674 break; 4675 4676 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: 4677 Record.AddSourceLocation(Update.getLoc()); 4678 break; 4679 4680 case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: 4681 Record.AddStmt(const_cast<Expr *>( 4682 cast<ParmVarDecl>(Update.getDecl())->getDefaultArg())); 4683 break; 4684 4685 case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: { 4686 auto *RD = cast<CXXRecordDecl>(D); 4687 UpdatedDeclContexts.insert(RD->getPrimaryContext()); 4688 Record.AddCXXDefinitionData(RD); 4689 Record.AddOffset(WriteDeclContextLexicalBlock( 4690 *Context, const_cast<CXXRecordDecl *>(RD))); 4691 4692 // This state is sometimes updated by template instantiation, when we 4693 // switch from the specialization referring to the template declaration 4694 // to it referring to the template definition. 4695 if (auto *MSInfo = RD->getMemberSpecializationInfo()) { 4696 Record.push_back(MSInfo->getTemplateSpecializationKind()); 4697 Record.AddSourceLocation(MSInfo->getPointOfInstantiation()); 4698 } else { 4699 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD); 4700 Record.push_back(Spec->getTemplateSpecializationKind()); 4701 Record.AddSourceLocation(Spec->getPointOfInstantiation()); 4702 4703 // The instantiation might have been resolved to a partial 4704 // specialization. If so, record which one. 4705 auto From = Spec->getInstantiatedFrom(); 4706 if (auto PartialSpec = 4707 From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) { 4708 Record.push_back(true); 4709 Record.AddDeclRef(PartialSpec); 4710 Record.AddTemplateArgumentList( 4711 &Spec->getTemplateInstantiationArgs()); 4712 } else { 4713 Record.push_back(false); 4714 } 4715 } 4716 Record.push_back(RD->getTagKind()); 4717 Record.AddSourceLocation(RD->getLocation()); 4718 Record.AddSourceLocation(RD->getLocStart()); 4719 Record.AddSourceLocation(RD->getRBraceLoc()); 4720 4721 // Instantiation may change attributes; write them all out afresh. 4722 Record.push_back(D->hasAttrs()); 4723 if (D->hasAttrs()) 4724 Record.AddAttributes(D->getAttrs()); 4725 4726 // FIXME: Ensure we don't get here for explicit instantiations. 4727 break; 4728 } 4729 4730 case UPD_CXX_RESOLVED_DTOR_DELETE: 4731 Record.AddDeclRef(Update.getDecl()); 4732 break; 4733 4734 case UPD_CXX_RESOLVED_EXCEPTION_SPEC: 4735 addExceptionSpec( 4736 cast<FunctionDecl>(D)->getType()->castAs<FunctionProtoType>(), 4737 Record); 4738 break; 4739 4740 case UPD_CXX_DEDUCED_RETURN_TYPE: 4741 Record.push_back(GetOrCreateTypeID(Update.getType())); 4742 break; 4743 4744 case UPD_DECL_MARKED_USED: 4745 break; 4746 4747 case UPD_MANGLING_NUMBER: 4748 case UPD_STATIC_LOCAL_NUMBER: 4749 Record.push_back(Update.getNumber()); 4750 break; 4751 4752 case UPD_DECL_MARKED_OPENMP_THREADPRIVATE: 4753 Record.AddSourceRange( 4754 D->getAttr<OMPThreadPrivateDeclAttr>()->getRange()); 4755 break; 4756 4757 case UPD_DECL_MARKED_OPENMP_DECLARETARGET: 4758 Record.AddSourceRange( 4759 D->getAttr<OMPDeclareTargetDeclAttr>()->getRange()); 4760 break; 4761 4762 case UPD_DECL_EXPORTED: 4763 Record.push_back(getSubmoduleID(Update.getModule())); 4764 break; 4765 4766 case UPD_ADDED_ATTR_TO_RECORD: 4767 Record.AddAttributes(llvm::makeArrayRef(Update.getAttr())); 4768 break; 4769 } 4770 } 4771 4772 if (HasUpdatedBody) { 4773 const auto *Def = cast<FunctionDecl>(D); 4774 Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION); 4775 Record.push_back(Def->isInlined()); 4776 Record.AddSourceLocation(Def->getInnerLocStart()); 4777 Record.AddFunctionDefinition(Def); 4778 } 4779 4780 OffsetsRecord.push_back(GetDeclRef(D)); 4781 OffsetsRecord.push_back(Record.Emit(DECL_UPDATES)); 4782 } 4783 } 4784 4785 void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { 4786 uint32_t Raw = Loc.getRawEncoding(); 4787 Record.push_back((Raw << 1) | (Raw >> 31)); 4788 } 4789 4790 void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { 4791 AddSourceLocation(Range.getBegin(), Record); 4792 AddSourceLocation(Range.getEnd(), Record); 4793 } 4794 4795 void ASTRecordWriter::AddAPInt(const llvm::APInt &Value) { 4796 Record->push_back(Value.getBitWidth()); 4797 const uint64_t *Words = Value.getRawData(); 4798 Record->append(Words, Words + Value.getNumWords()); 4799 } 4800 4801 void ASTRecordWriter::AddAPSInt(const llvm::APSInt &Value) { 4802 Record->push_back(Value.isUnsigned()); 4803 AddAPInt(Value); 4804 } 4805 4806 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) { 4807 AddAPInt(Value.bitcastToAPInt()); 4808 } 4809 4810 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { 4811 Record.push_back(getIdentifierRef(II)); 4812 } 4813 4814 IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { 4815 if (!II) 4816 return 0; 4817 4818 IdentID &ID = IdentifierIDs[II]; 4819 if (ID == 0) 4820 ID = NextIdentID++; 4821 return ID; 4822 } 4823 4824 MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) { 4825 // Don't emit builtin macros like __LINE__ to the AST file unless they 4826 // have been redefined by the header (in which case they are not 4827 // isBuiltinMacro). 4828 if (!MI || MI->isBuiltinMacro()) 4829 return 0; 4830 4831 MacroID &ID = MacroIDs[MI]; 4832 if (ID == 0) { 4833 ID = NextMacroID++; 4834 MacroInfoToEmitData Info = { Name, MI, ID }; 4835 MacroInfosToEmit.push_back(Info); 4836 } 4837 return ID; 4838 } 4839 4840 MacroID ASTWriter::getMacroID(MacroInfo *MI) { 4841 if (!MI || MI->isBuiltinMacro()) 4842 return 0; 4843 4844 assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!"); 4845 return MacroIDs[MI]; 4846 } 4847 4848 uint64_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) { 4849 return IdentMacroDirectivesOffsetMap.lookup(Name); 4850 } 4851 4852 void ASTRecordWriter::AddSelectorRef(const Selector SelRef) { 4853 Record->push_back(Writer->getSelectorRef(SelRef)); 4854 } 4855 4856 SelectorID ASTWriter::getSelectorRef(Selector Sel) { 4857 if (Sel.getAsOpaquePtr() == nullptr) { 4858 return 0; 4859 } 4860 4861 SelectorID SID = SelectorIDs[Sel]; 4862 if (SID == 0 && Chain) { 4863 // This might trigger a ReadSelector callback, which will set the ID for 4864 // this selector. 4865 Chain->LoadSelector(Sel); 4866 SID = SelectorIDs[Sel]; 4867 } 4868 if (SID == 0) { 4869 SID = NextSelectorID++; 4870 SelectorIDs[Sel] = SID; 4871 } 4872 return SID; 4873 } 4874 4875 void ASTRecordWriter::AddCXXTemporary(const CXXTemporary *Temp) { 4876 AddDeclRef(Temp->getDestructor()); 4877 } 4878 4879 void ASTRecordWriter::AddTemplateArgumentLocInfo( 4880 TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) { 4881 switch (Kind) { 4882 case TemplateArgument::Expression: 4883 AddStmt(Arg.getAsExpr()); 4884 break; 4885 case TemplateArgument::Type: 4886 AddTypeSourceInfo(Arg.getAsTypeSourceInfo()); 4887 break; 4888 case TemplateArgument::Template: 4889 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); 4890 AddSourceLocation(Arg.getTemplateNameLoc()); 4891 break; 4892 case TemplateArgument::TemplateExpansion: 4893 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); 4894 AddSourceLocation(Arg.getTemplateNameLoc()); 4895 AddSourceLocation(Arg.getTemplateEllipsisLoc()); 4896 break; 4897 case TemplateArgument::Null: 4898 case TemplateArgument::Integral: 4899 case TemplateArgument::Declaration: 4900 case TemplateArgument::NullPtr: 4901 case TemplateArgument::Pack: 4902 // FIXME: Is this right? 4903 break; 4904 } 4905 } 4906 4907 void ASTRecordWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) { 4908 AddTemplateArgument(Arg.getArgument()); 4909 4910 if (Arg.getArgument().getKind() == TemplateArgument::Expression) { 4911 bool InfoHasSameExpr 4912 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); 4913 Record->push_back(InfoHasSameExpr); 4914 if (InfoHasSameExpr) 4915 return; // Avoid storing the same expr twice. 4916 } 4917 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo()); 4918 } 4919 4920 void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) { 4921 if (!TInfo) { 4922 AddTypeRef(QualType()); 4923 return; 4924 } 4925 4926 AddTypeLoc(TInfo->getTypeLoc()); 4927 } 4928 4929 void ASTRecordWriter::AddTypeLoc(TypeLoc TL) { 4930 AddTypeRef(TL.getType()); 4931 4932 TypeLocWriter TLW(*this); 4933 for (; !TL.isNull(); TL = TL.getNextTypeLoc()) 4934 TLW.Visit(TL); 4935 } 4936 4937 void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { 4938 Record.push_back(GetOrCreateTypeID(T)); 4939 } 4940 4941 TypeID ASTWriter::GetOrCreateTypeID(QualType T) { 4942 assert(Context); 4943 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx { 4944 if (T.isNull()) 4945 return TypeIdx(); 4946 assert(!T.getLocalFastQualifiers()); 4947 4948 TypeIdx &Idx = TypeIdxs[T]; 4949 if (Idx.getIndex() == 0) { 4950 if (DoneWritingDeclsAndTypes) { 4951 assert(0 && "New type seen after serializing all the types to emit!"); 4952 return TypeIdx(); 4953 } 4954 4955 // We haven't seen this type before. Assign it a new ID and put it 4956 // into the queue of types to emit. 4957 Idx = TypeIdx(NextTypeID++); 4958 DeclTypesToEmit.push(T); 4959 } 4960 return Idx; 4961 }); 4962 } 4963 4964 TypeID ASTWriter::getTypeID(QualType T) const { 4965 assert(Context); 4966 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx { 4967 if (T.isNull()) 4968 return TypeIdx(); 4969 assert(!T.getLocalFastQualifiers()); 4970 4971 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 4972 assert(I != TypeIdxs.end() && "Type not emitted!"); 4973 return I->second; 4974 }); 4975 } 4976 4977 void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { 4978 Record.push_back(GetDeclRef(D)); 4979 } 4980 4981 DeclID ASTWriter::GetDeclRef(const Decl *D) { 4982 assert(WritingAST && "Cannot request a declaration ID before AST writing"); 4983 4984 if (!D) { 4985 return 0; 4986 } 4987 4988 // If D comes from an AST file, its declaration ID is already known and 4989 // fixed. 4990 if (D->isFromASTFile()) 4991 return D->getGlobalID(); 4992 4993 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer"); 4994 DeclID &ID = DeclIDs[D]; 4995 if (ID == 0) { 4996 if (DoneWritingDeclsAndTypes) { 4997 assert(0 && "New decl seen after serializing all the decls to emit!"); 4998 return 0; 4999 } 5000 5001 // We haven't seen this declaration before. Give it a new ID and 5002 // enqueue it in the list of declarations to emit. 5003 ID = NextDeclID++; 5004 DeclTypesToEmit.push(const_cast<Decl *>(D)); 5005 } 5006 5007 return ID; 5008 } 5009 5010 DeclID ASTWriter::getDeclID(const Decl *D) { 5011 if (!D) 5012 return 0; 5013 5014 // If D comes from an AST file, its declaration ID is already known and 5015 // fixed. 5016 if (D->isFromASTFile()) 5017 return D->getGlobalID(); 5018 5019 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); 5020 return DeclIDs[D]; 5021 } 5022 5023 void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { 5024 assert(ID); 5025 assert(D); 5026 5027 SourceLocation Loc = D->getLocation(); 5028 if (Loc.isInvalid()) 5029 return; 5030 5031 // We only keep track of the file-level declarations of each file. 5032 if (!D->getLexicalDeclContext()->isFileContext()) 5033 return; 5034 // FIXME: ParmVarDecls that are part of a function type of a parameter of 5035 // a function/objc method, should not have TU as lexical context. 5036 if (isa<ParmVarDecl>(D)) 5037 return; 5038 5039 SourceManager &SM = Context->getSourceManager(); 5040 SourceLocation FileLoc = SM.getFileLoc(Loc); 5041 assert(SM.isLocalSourceLocation(FileLoc)); 5042 FileID FID; 5043 unsigned Offset; 5044 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); 5045 if (FID.isInvalid()) 5046 return; 5047 assert(SM.getSLocEntry(FID).isFile()); 5048 5049 DeclIDInFileInfo *&Info = FileDeclIDs[FID]; 5050 if (!Info) 5051 Info = new DeclIDInFileInfo(); 5052 5053 std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID); 5054 LocDeclIDsTy &Decls = Info->DeclIDs; 5055 5056 if (Decls.empty() || Decls.back().first <= Offset) { 5057 Decls.push_back(LocDecl); 5058 return; 5059 } 5060 5061 LocDeclIDsTy::iterator I = 5062 std::upper_bound(Decls.begin(), Decls.end(), LocDecl, llvm::less_first()); 5063 5064 Decls.insert(I, LocDecl); 5065 } 5066 5067 void ASTRecordWriter::AddDeclarationName(DeclarationName Name) { 5068 // FIXME: Emit a stable enum for NameKind. 0 = Identifier etc. 5069 Record->push_back(Name.getNameKind()); 5070 switch (Name.getNameKind()) { 5071 case DeclarationName::Identifier: 5072 AddIdentifierRef(Name.getAsIdentifierInfo()); 5073 break; 5074 5075 case DeclarationName::ObjCZeroArgSelector: 5076 case DeclarationName::ObjCOneArgSelector: 5077 case DeclarationName::ObjCMultiArgSelector: 5078 AddSelectorRef(Name.getObjCSelector()); 5079 break; 5080 5081 case DeclarationName::CXXConstructorName: 5082 case DeclarationName::CXXDestructorName: 5083 case DeclarationName::CXXConversionFunctionName: 5084 AddTypeRef(Name.getCXXNameType()); 5085 break; 5086 5087 case DeclarationName::CXXOperatorName: 5088 Record->push_back(Name.getCXXOverloadedOperator()); 5089 break; 5090 5091 case DeclarationName::CXXLiteralOperatorName: 5092 AddIdentifierRef(Name.getCXXLiteralIdentifier()); 5093 break; 5094 5095 case DeclarationName::CXXUsingDirective: 5096 // No extra data to emit 5097 break; 5098 } 5099 } 5100 5101 unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) { 5102 assert(needsAnonymousDeclarationNumber(D) && 5103 "expected an anonymous declaration"); 5104 5105 // Number the anonymous declarations within this context, if we've not 5106 // already done so. 5107 auto It = AnonymousDeclarationNumbers.find(D); 5108 if (It == AnonymousDeclarationNumbers.end()) { 5109 auto *DC = D->getLexicalDeclContext(); 5110 numberAnonymousDeclsWithin(DC, [&](const NamedDecl *ND, unsigned Number) { 5111 AnonymousDeclarationNumbers[ND] = Number; 5112 }); 5113 5114 It = AnonymousDeclarationNumbers.find(D); 5115 assert(It != AnonymousDeclarationNumbers.end() && 5116 "declaration not found within its lexical context"); 5117 } 5118 5119 return It->second; 5120 } 5121 5122 void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, 5123 DeclarationName Name) { 5124 switch (Name.getNameKind()) { 5125 case DeclarationName::CXXConstructorName: 5126 case DeclarationName::CXXDestructorName: 5127 case DeclarationName::CXXConversionFunctionName: 5128 AddTypeSourceInfo(DNLoc.NamedType.TInfo); 5129 break; 5130 5131 case DeclarationName::CXXOperatorName: 5132 AddSourceLocation(SourceLocation::getFromRawEncoding( 5133 DNLoc.CXXOperatorName.BeginOpNameLoc)); 5134 AddSourceLocation( 5135 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc)); 5136 break; 5137 5138 case DeclarationName::CXXLiteralOperatorName: 5139 AddSourceLocation(SourceLocation::getFromRawEncoding( 5140 DNLoc.CXXLiteralOperatorName.OpNameLoc)); 5141 break; 5142 5143 case DeclarationName::Identifier: 5144 case DeclarationName::ObjCZeroArgSelector: 5145 case DeclarationName::ObjCOneArgSelector: 5146 case DeclarationName::ObjCMultiArgSelector: 5147 case DeclarationName::CXXUsingDirective: 5148 break; 5149 } 5150 } 5151 5152 void ASTRecordWriter::AddDeclarationNameInfo( 5153 const DeclarationNameInfo &NameInfo) { 5154 AddDeclarationName(NameInfo.getName()); 5155 AddSourceLocation(NameInfo.getLoc()); 5156 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName()); 5157 } 5158 5159 void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info) { 5160 AddNestedNameSpecifierLoc(Info.QualifierLoc); 5161 Record->push_back(Info.NumTemplParamLists); 5162 for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i) 5163 AddTemplateParameterList(Info.TemplParamLists[i]); 5164 } 5165 5166 void ASTRecordWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS) { 5167 // Nested name specifiers usually aren't too long. I think that 8 would 5168 // typically accommodate the vast majority. 5169 SmallVector<NestedNameSpecifier *, 8> NestedNames; 5170 5171 // Push each of the NNS's onto a stack for serialization in reverse order. 5172 while (NNS) { 5173 NestedNames.push_back(NNS); 5174 NNS = NNS->getPrefix(); 5175 } 5176 5177 Record->push_back(NestedNames.size()); 5178 while(!NestedNames.empty()) { 5179 NNS = NestedNames.pop_back_val(); 5180 NestedNameSpecifier::SpecifierKind Kind = NNS->getKind(); 5181 Record->push_back(Kind); 5182 switch (Kind) { 5183 case NestedNameSpecifier::Identifier: 5184 AddIdentifierRef(NNS->getAsIdentifier()); 5185 break; 5186 5187 case NestedNameSpecifier::Namespace: 5188 AddDeclRef(NNS->getAsNamespace()); 5189 break; 5190 5191 case NestedNameSpecifier::NamespaceAlias: 5192 AddDeclRef(NNS->getAsNamespaceAlias()); 5193 break; 5194 5195 case NestedNameSpecifier::TypeSpec: 5196 case NestedNameSpecifier::TypeSpecWithTemplate: 5197 AddTypeRef(QualType(NNS->getAsType(), 0)); 5198 Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 5199 break; 5200 5201 case NestedNameSpecifier::Global: 5202 // Don't need to write an associated value. 5203 break; 5204 5205 case NestedNameSpecifier::Super: 5206 AddDeclRef(NNS->getAsRecordDecl()); 5207 break; 5208 } 5209 } 5210 } 5211 5212 void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) { 5213 // Nested name specifiers usually aren't too long. I think that 8 would 5214 // typically accommodate the vast majority. 5215 SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 5216 5217 // Push each of the nested-name-specifiers's onto a stack for 5218 // serialization in reverse order. 5219 while (NNS) { 5220 NestedNames.push_back(NNS); 5221 NNS = NNS.getPrefix(); 5222 } 5223 5224 Record->push_back(NestedNames.size()); 5225 while(!NestedNames.empty()) { 5226 NNS = NestedNames.pop_back_val(); 5227 NestedNameSpecifier::SpecifierKind Kind 5228 = NNS.getNestedNameSpecifier()->getKind(); 5229 Record->push_back(Kind); 5230 switch (Kind) { 5231 case NestedNameSpecifier::Identifier: 5232 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier()); 5233 AddSourceRange(NNS.getLocalSourceRange()); 5234 break; 5235 5236 case NestedNameSpecifier::Namespace: 5237 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace()); 5238 AddSourceRange(NNS.getLocalSourceRange()); 5239 break; 5240 5241 case NestedNameSpecifier::NamespaceAlias: 5242 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias()); 5243 AddSourceRange(NNS.getLocalSourceRange()); 5244 break; 5245 5246 case NestedNameSpecifier::TypeSpec: 5247 case NestedNameSpecifier::TypeSpecWithTemplate: 5248 Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 5249 AddTypeLoc(NNS.getTypeLoc()); 5250 AddSourceLocation(NNS.getLocalSourceRange().getEnd()); 5251 break; 5252 5253 case NestedNameSpecifier::Global: 5254 AddSourceLocation(NNS.getLocalSourceRange().getEnd()); 5255 break; 5256 5257 case NestedNameSpecifier::Super: 5258 AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl()); 5259 AddSourceRange(NNS.getLocalSourceRange()); 5260 break; 5261 } 5262 } 5263 } 5264 5265 void ASTRecordWriter::AddTemplateName(TemplateName Name) { 5266 TemplateName::NameKind Kind = Name.getKind(); 5267 Record->push_back(Kind); 5268 switch (Kind) { 5269 case TemplateName::Template: 5270 AddDeclRef(Name.getAsTemplateDecl()); 5271 break; 5272 5273 case TemplateName::OverloadedTemplate: { 5274 OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate(); 5275 Record->push_back(OvT->size()); 5276 for (const auto &I : *OvT) 5277 AddDeclRef(I); 5278 break; 5279 } 5280 5281 case TemplateName::QualifiedTemplate: { 5282 QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName(); 5283 AddNestedNameSpecifier(QualT->getQualifier()); 5284 Record->push_back(QualT->hasTemplateKeyword()); 5285 AddDeclRef(QualT->getTemplateDecl()); 5286 break; 5287 } 5288 5289 case TemplateName::DependentTemplate: { 5290 DependentTemplateName *DepT = Name.getAsDependentTemplateName(); 5291 AddNestedNameSpecifier(DepT->getQualifier()); 5292 Record->push_back(DepT->isIdentifier()); 5293 if (DepT->isIdentifier()) 5294 AddIdentifierRef(DepT->getIdentifier()); 5295 else 5296 Record->push_back(DepT->getOperator()); 5297 break; 5298 } 5299 5300 case TemplateName::SubstTemplateTemplateParm: { 5301 SubstTemplateTemplateParmStorage *subst 5302 = Name.getAsSubstTemplateTemplateParm(); 5303 AddDeclRef(subst->getParameter()); 5304 AddTemplateName(subst->getReplacement()); 5305 break; 5306 } 5307 5308 case TemplateName::SubstTemplateTemplateParmPack: { 5309 SubstTemplateTemplateParmPackStorage *SubstPack 5310 = Name.getAsSubstTemplateTemplateParmPack(); 5311 AddDeclRef(SubstPack->getParameterPack()); 5312 AddTemplateArgument(SubstPack->getArgumentPack()); 5313 break; 5314 } 5315 } 5316 } 5317 5318 void ASTRecordWriter::AddTemplateArgument(const TemplateArgument &Arg) { 5319 Record->push_back(Arg.getKind()); 5320 switch (Arg.getKind()) { 5321 case TemplateArgument::Null: 5322 break; 5323 case TemplateArgument::Type: 5324 AddTypeRef(Arg.getAsType()); 5325 break; 5326 case TemplateArgument::Declaration: 5327 AddDeclRef(Arg.getAsDecl()); 5328 AddTypeRef(Arg.getParamTypeForDecl()); 5329 break; 5330 case TemplateArgument::NullPtr: 5331 AddTypeRef(Arg.getNullPtrType()); 5332 break; 5333 case TemplateArgument::Integral: 5334 AddAPSInt(Arg.getAsIntegral()); 5335 AddTypeRef(Arg.getIntegralType()); 5336 break; 5337 case TemplateArgument::Template: 5338 AddTemplateName(Arg.getAsTemplateOrTemplatePattern()); 5339 break; 5340 case TemplateArgument::TemplateExpansion: 5341 AddTemplateName(Arg.getAsTemplateOrTemplatePattern()); 5342 if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions()) 5343 Record->push_back(*NumExpansions + 1); 5344 else 5345 Record->push_back(0); 5346 break; 5347 case TemplateArgument::Expression: 5348 AddStmt(Arg.getAsExpr()); 5349 break; 5350 case TemplateArgument::Pack: 5351 Record->push_back(Arg.pack_size()); 5352 for (const auto &P : Arg.pack_elements()) 5353 AddTemplateArgument(P); 5354 break; 5355 } 5356 } 5357 5358 void ASTRecordWriter::AddTemplateParameterList( 5359 const TemplateParameterList *TemplateParams) { 5360 assert(TemplateParams && "No TemplateParams!"); 5361 AddSourceLocation(TemplateParams->getTemplateLoc()); 5362 AddSourceLocation(TemplateParams->getLAngleLoc()); 5363 AddSourceLocation(TemplateParams->getRAngleLoc()); 5364 Record->push_back(TemplateParams->size()); 5365 for (const auto &P : *TemplateParams) 5366 AddDeclRef(P); 5367 } 5368 5369 /// \brief Emit a template argument list. 5370 void ASTRecordWriter::AddTemplateArgumentList( 5371 const TemplateArgumentList *TemplateArgs) { 5372 assert(TemplateArgs && "No TemplateArgs!"); 5373 Record->push_back(TemplateArgs->size()); 5374 for (int i=0, e = TemplateArgs->size(); i != e; ++i) 5375 AddTemplateArgument(TemplateArgs->get(i)); 5376 } 5377 5378 void ASTRecordWriter::AddASTTemplateArgumentListInfo( 5379 const ASTTemplateArgumentListInfo *ASTTemplArgList) { 5380 assert(ASTTemplArgList && "No ASTTemplArgList!"); 5381 AddSourceLocation(ASTTemplArgList->LAngleLoc); 5382 AddSourceLocation(ASTTemplArgList->RAngleLoc); 5383 Record->push_back(ASTTemplArgList->NumTemplateArgs); 5384 const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs(); 5385 for (int i=0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) 5386 AddTemplateArgumentLoc(TemplArgs[i]); 5387 } 5388 5389 void ASTRecordWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set) { 5390 Record->push_back(Set.size()); 5391 for (ASTUnresolvedSet::const_iterator 5392 I = Set.begin(), E = Set.end(); I != E; ++I) { 5393 AddDeclRef(I.getDecl()); 5394 Record->push_back(I.getAccess()); 5395 } 5396 } 5397 5398 // FIXME: Move this out of the main ASTRecordWriter interface. 5399 void ASTRecordWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) { 5400 Record->push_back(Base.isVirtual()); 5401 Record->push_back(Base.isBaseOfClass()); 5402 Record->push_back(Base.getAccessSpecifierAsWritten()); 5403 Record->push_back(Base.getInheritConstructors()); 5404 AddTypeSourceInfo(Base.getTypeSourceInfo()); 5405 AddSourceRange(Base.getSourceRange()); 5406 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() 5407 : SourceLocation()); 5408 } 5409 5410 static uint64_t EmitCXXBaseSpecifiers(ASTWriter &W, 5411 ArrayRef<CXXBaseSpecifier> Bases) { 5412 ASTWriter::RecordData Record; 5413 ASTRecordWriter Writer(W, Record); 5414 Writer.push_back(Bases.size()); 5415 5416 for (auto &Base : Bases) 5417 Writer.AddCXXBaseSpecifier(Base); 5418 5419 return Writer.Emit(serialization::DECL_CXX_BASE_SPECIFIERS); 5420 } 5421 5422 // FIXME: Move this out of the main ASTRecordWriter interface. 5423 void ASTRecordWriter::AddCXXBaseSpecifiers(ArrayRef<CXXBaseSpecifier> Bases) { 5424 AddOffset(EmitCXXBaseSpecifiers(*Writer, Bases)); 5425 } 5426 5427 static uint64_t 5428 EmitCXXCtorInitializers(ASTWriter &W, 5429 ArrayRef<CXXCtorInitializer *> CtorInits) { 5430 ASTWriter::RecordData Record; 5431 ASTRecordWriter Writer(W, Record); 5432 Writer.push_back(CtorInits.size()); 5433 5434 for (auto *Init : CtorInits) { 5435 if (Init->isBaseInitializer()) { 5436 Writer.push_back(CTOR_INITIALIZER_BASE); 5437 Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); 5438 Writer.push_back(Init->isBaseVirtual()); 5439 } else if (Init->isDelegatingInitializer()) { 5440 Writer.push_back(CTOR_INITIALIZER_DELEGATING); 5441 Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); 5442 } else if (Init->isMemberInitializer()){ 5443 Writer.push_back(CTOR_INITIALIZER_MEMBER); 5444 Writer.AddDeclRef(Init->getMember()); 5445 } else { 5446 Writer.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); 5447 Writer.AddDeclRef(Init->getIndirectMember()); 5448 } 5449 5450 Writer.AddSourceLocation(Init->getMemberLocation()); 5451 Writer.AddStmt(Init->getInit()); 5452 Writer.AddSourceLocation(Init->getLParenLoc()); 5453 Writer.AddSourceLocation(Init->getRParenLoc()); 5454 Writer.push_back(Init->isWritten()); 5455 if (Init->isWritten()) { 5456 Writer.push_back(Init->getSourceOrder()); 5457 } else { 5458 Writer.push_back(Init->getNumArrayIndices()); 5459 for (auto *VD : Init->getArrayIndices()) 5460 Writer.AddDeclRef(VD); 5461 } 5462 } 5463 5464 return Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS); 5465 } 5466 5467 // FIXME: Move this out of the main ASTRecordWriter interface. 5468 void ASTRecordWriter::AddCXXCtorInitializers( 5469 ArrayRef<CXXCtorInitializer *> CtorInits) { 5470 AddOffset(EmitCXXCtorInitializers(*Writer, CtorInits)); 5471 } 5472 5473 void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { 5474 auto &Data = D->data(); 5475 Record->push_back(Data.IsLambda); 5476 Record->push_back(Data.UserDeclaredConstructor); 5477 Record->push_back(Data.UserDeclaredSpecialMembers); 5478 Record->push_back(Data.Aggregate); 5479 Record->push_back(Data.PlainOldData); 5480 Record->push_back(Data.Empty); 5481 Record->push_back(Data.Polymorphic); 5482 Record->push_back(Data.Abstract); 5483 Record->push_back(Data.IsStandardLayout); 5484 Record->push_back(Data.HasNoNonEmptyBases); 5485 Record->push_back(Data.HasPrivateFields); 5486 Record->push_back(Data.HasProtectedFields); 5487 Record->push_back(Data.HasPublicFields); 5488 Record->push_back(Data.HasMutableFields); 5489 Record->push_back(Data.HasVariantMembers); 5490 Record->push_back(Data.HasOnlyCMembers); 5491 Record->push_back(Data.HasInClassInitializer); 5492 Record->push_back(Data.HasUninitializedReferenceMember); 5493 Record->push_back(Data.HasUninitializedFields); 5494 Record->push_back(Data.HasInheritedConstructor); 5495 Record->push_back(Data.HasInheritedAssignment); 5496 Record->push_back(Data.NeedOverloadResolutionForMoveConstructor); 5497 Record->push_back(Data.NeedOverloadResolutionForMoveAssignment); 5498 Record->push_back(Data.NeedOverloadResolutionForDestructor); 5499 Record->push_back(Data.DefaultedMoveConstructorIsDeleted); 5500 Record->push_back(Data.DefaultedMoveAssignmentIsDeleted); 5501 Record->push_back(Data.DefaultedDestructorIsDeleted); 5502 Record->push_back(Data.HasTrivialSpecialMembers); 5503 Record->push_back(Data.DeclaredNonTrivialSpecialMembers); 5504 Record->push_back(Data.HasIrrelevantDestructor); 5505 Record->push_back(Data.HasConstexprNonCopyMoveConstructor); 5506 Record->push_back(Data.HasDefaultedDefaultConstructor); 5507 Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr); 5508 Record->push_back(Data.HasConstexprDefaultConstructor); 5509 Record->push_back(Data.HasNonLiteralTypeFieldsOrBases); 5510 Record->push_back(Data.ComputedVisibleConversions); 5511 Record->push_back(Data.UserProvidedDefaultConstructor); 5512 Record->push_back(Data.DeclaredSpecialMembers); 5513 Record->push_back(Data.ImplicitCopyConstructorHasConstParam); 5514 Record->push_back(Data.ImplicitCopyAssignmentHasConstParam); 5515 Record->push_back(Data.HasDeclaredCopyConstructorWithConstParam); 5516 Record->push_back(Data.HasDeclaredCopyAssignmentWithConstParam); 5517 // IsLambda bit is already saved. 5518 5519 Record->push_back(Data.NumBases); 5520 if (Data.NumBases > 0) 5521 AddCXXBaseSpecifiers(Data.bases()); 5522 5523 // FIXME: Make VBases lazily computed when needed to avoid storing them. 5524 Record->push_back(Data.NumVBases); 5525 if (Data.NumVBases > 0) 5526 AddCXXBaseSpecifiers(Data.vbases()); 5527 5528 AddUnresolvedSet(Data.Conversions.get(*Writer->Context)); 5529 AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context)); 5530 // Data.Definition is the owning decl, no need to write it. 5531 AddDeclRef(D->getFirstFriend()); 5532 5533 // Add lambda-specific data. 5534 if (Data.IsLambda) { 5535 auto &Lambda = D->getLambdaData(); 5536 Record->push_back(Lambda.Dependent); 5537 Record->push_back(Lambda.IsGenericLambda); 5538 Record->push_back(Lambda.CaptureDefault); 5539 Record->push_back(Lambda.NumCaptures); 5540 Record->push_back(Lambda.NumExplicitCaptures); 5541 Record->push_back(Lambda.ManglingNumber); 5542 AddDeclRef(Lambda.ContextDecl); 5543 AddTypeSourceInfo(Lambda.MethodTyInfo); 5544 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { 5545 const LambdaCapture &Capture = Lambda.Captures[I]; 5546 AddSourceLocation(Capture.getLocation()); 5547 Record->push_back(Capture.isImplicit()); 5548 Record->push_back(Capture.getCaptureKind()); 5549 switch (Capture.getCaptureKind()) { 5550 case LCK_StarThis: 5551 case LCK_This: 5552 case LCK_VLAType: 5553 break; 5554 case LCK_ByCopy: 5555 case LCK_ByRef: 5556 VarDecl *Var = 5557 Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr; 5558 AddDeclRef(Var); 5559 AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc() 5560 : SourceLocation()); 5561 break; 5562 } 5563 } 5564 } 5565 } 5566 5567 void ASTWriter::ReaderInitialized(ASTReader *Reader) { 5568 assert(Reader && "Cannot remove chain"); 5569 assert((!Chain || Chain == Reader) && "Cannot replace chain"); 5570 assert(FirstDeclID == NextDeclID && 5571 FirstTypeID == NextTypeID && 5572 FirstIdentID == NextIdentID && 5573 FirstMacroID == NextMacroID && 5574 FirstSubmoduleID == NextSubmoduleID && 5575 FirstSelectorID == NextSelectorID && 5576 "Setting chain after writing has started."); 5577 5578 Chain = Reader; 5579 5580 // Note, this will get called multiple times, once one the reader starts up 5581 // and again each time it's done reading a PCH or module. 5582 FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); 5583 FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); 5584 FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); 5585 FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros(); 5586 FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); 5587 FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); 5588 NextDeclID = FirstDeclID; 5589 NextTypeID = FirstTypeID; 5590 NextIdentID = FirstIdentID; 5591 NextMacroID = FirstMacroID; 5592 NextSelectorID = FirstSelectorID; 5593 NextSubmoduleID = FirstSubmoduleID; 5594 } 5595 5596 void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { 5597 // Always keep the highest ID. See \p TypeRead() for more information. 5598 IdentID &StoredID = IdentifierIDs[II]; 5599 if (ID > StoredID) 5600 StoredID = ID; 5601 } 5602 5603 void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) { 5604 // Always keep the highest ID. See \p TypeRead() for more information. 5605 MacroID &StoredID = MacroIDs[MI]; 5606 if (ID > StoredID) 5607 StoredID = ID; 5608 } 5609 5610 void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { 5611 // Always take the highest-numbered type index. This copes with an interesting 5612 // case for chained AST writing where we schedule writing the type and then, 5613 // later, deserialize the type from another AST. In this case, we want to 5614 // keep the higher-numbered entry so that we can properly write it out to 5615 // the AST file. 5616 TypeIdx &StoredIdx = TypeIdxs[T]; 5617 if (Idx.getIndex() >= StoredIdx.getIndex()) 5618 StoredIdx = Idx; 5619 } 5620 5621 void ASTWriter::SelectorRead(SelectorID ID, Selector S) { 5622 // Always keep the highest ID. See \p TypeRead() for more information. 5623 SelectorID &StoredID = SelectorIDs[S]; 5624 if (ID > StoredID) 5625 StoredID = ID; 5626 } 5627 5628 void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, 5629 MacroDefinitionRecord *MD) { 5630 assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); 5631 MacroDefinitions[MD] = ID; 5632 } 5633 5634 void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { 5635 assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); 5636 SubmoduleIDs[Mod] = ID; 5637 } 5638 5639 void ASTWriter::CompletedTagDefinition(const TagDecl *D) { 5640 assert(D->isCompleteDefinition()); 5641 assert(!WritingAST && "Already writing the AST!"); 5642 if (auto *RD = dyn_cast<CXXRecordDecl>(D)) { 5643 // We are interested when a PCH decl is modified. 5644 if (RD->isFromASTFile()) { 5645 // A forward reference was mutated into a definition. Rewrite it. 5646 // FIXME: This happens during template instantiation, should we 5647 // have created a new definition decl instead ? 5648 assert(isTemplateInstantiation(RD->getTemplateSpecializationKind()) && 5649 "completed a tag from another module but not by instantiation?"); 5650 DeclUpdates[RD].push_back( 5651 DeclUpdate(UPD_CXX_INSTANTIATED_CLASS_DEFINITION)); 5652 } 5653 } 5654 } 5655 5656 static bool isImportedDeclContext(ASTReader *Chain, const Decl *D) { 5657 if (D->isFromASTFile()) 5658 return true; 5659 5660 // The predefined __va_list_tag struct is imported if we imported any decls. 5661 // FIXME: This is a gross hack. 5662 return D == D->getASTContext().getVaListTagDecl(); 5663 } 5664 5665 void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { 5666 assert(DC->isLookupContext() && 5667 "Should not add lookup results to non-lookup contexts!"); 5668 5669 // TU is handled elsewhere. 5670 if (isa<TranslationUnitDecl>(DC)) 5671 return; 5672 5673 // Namespaces are handled elsewhere, except for template instantiations of 5674 // FunctionTemplateDecls in namespaces. We are interested in cases where the 5675 // local instantiations are added to an imported context. Only happens when 5676 // adding ADL lookup candidates, for example templated friends. 5677 if (isa<NamespaceDecl>(DC) && D->getFriendObjectKind() == Decl::FOK_None && 5678 !isa<FunctionTemplateDecl>(D)) 5679 return; 5680 5681 // We're only interested in cases where a local declaration is added to an 5682 // imported context. 5683 if (D->isFromASTFile() || !isImportedDeclContext(Chain, cast<Decl>(DC))) 5684 return; 5685 5686 assert(DC == DC->getPrimaryContext() && "added to non-primary context"); 5687 assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!"); 5688 assert(!WritingAST && "Already writing the AST!"); 5689 if (UpdatedDeclContexts.insert(DC) && !cast<Decl>(DC)->isFromASTFile()) { 5690 // We're adding a visible declaration to a predefined decl context. Ensure 5691 // that we write out all of its lookup results so we don't get a nasty 5692 // surprise when we try to emit its lookup table. 5693 for (auto *Child : DC->decls()) 5694 UpdatingVisibleDecls.push_back(Child); 5695 } 5696 UpdatingVisibleDecls.push_back(D); 5697 } 5698 5699 void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { 5700 assert(D->isImplicit()); 5701 5702 // We're only interested in cases where a local declaration is added to an 5703 // imported context. 5704 if (D->isFromASTFile() || !isImportedDeclContext(Chain, RD)) 5705 return; 5706 5707 if (!isa<CXXMethodDecl>(D)) 5708 return; 5709 5710 // A decl coming from PCH was modified. 5711 assert(RD->isCompleteDefinition()); 5712 assert(!WritingAST && "Already writing the AST!"); 5713 DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D)); 5714 } 5715 5716 void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) { 5717 assert(!DoneWritingDeclsAndTypes && "Already done writing updates!"); 5718 if (!Chain) return; 5719 Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { 5720 // If we don't already know the exception specification for this redecl 5721 // chain, add an update record for it. 5722 if (isUnresolvedExceptionSpec(cast<FunctionDecl>(D) 5723 ->getType() 5724 ->castAs<FunctionProtoType>() 5725 ->getExceptionSpecType())) 5726 DeclUpdates[D].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); 5727 }); 5728 } 5729 5730 void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { 5731 assert(!WritingAST && "Already writing the AST!"); 5732 if (!Chain) return; 5733 Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { 5734 DeclUpdates[D].push_back( 5735 DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType)); 5736 }); 5737 } 5738 5739 void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD, 5740 const FunctionDecl *Delete) { 5741 assert(!WritingAST && "Already writing the AST!"); 5742 assert(Delete && "Not given an operator delete"); 5743 if (!Chain) return; 5744 Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) { 5745 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_RESOLVED_DTOR_DELETE, Delete)); 5746 }); 5747 } 5748 5749 void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { 5750 assert(!WritingAST && "Already writing the AST!"); 5751 if (!D->isFromASTFile()) 5752 return; // Declaration not imported from PCH. 5753 5754 // Implicit function decl from a PCH was defined. 5755 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); 5756 } 5757 5758 void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) { 5759 assert(!WritingAST && "Already writing the AST!"); 5760 if (!D->isFromASTFile()) 5761 return; 5762 5763 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); 5764 } 5765 5766 void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) { 5767 assert(!WritingAST && "Already writing the AST!"); 5768 if (!D->isFromASTFile()) 5769 return; 5770 5771 // Since the actual instantiation is delayed, this really means that we need 5772 // to update the instantiation location. 5773 DeclUpdates[D].push_back( 5774 DeclUpdate(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER, 5775 D->getMemberSpecializationInfo()->getPointOfInstantiation())); 5776 } 5777 5778 void ASTWriter::DefaultArgumentInstantiated(const ParmVarDecl *D) { 5779 assert(!WritingAST && "Already writing the AST!"); 5780 if (!D->isFromASTFile()) 5781 return; 5782 5783 DeclUpdates[D].push_back( 5784 DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT, D)); 5785 } 5786 5787 void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 5788 const ObjCInterfaceDecl *IFD) { 5789 assert(!WritingAST && "Already writing the AST!"); 5790 if (!IFD->isFromASTFile()) 5791 return; // Declaration not imported from PCH. 5792 5793 assert(IFD->getDefinition() && "Category on a class without a definition?"); 5794 ObjCClassesWithCategories.insert( 5795 const_cast<ObjCInterfaceDecl *>(IFD->getDefinition())); 5796 } 5797 5798 void ASTWriter::DeclarationMarkedUsed(const Decl *D) { 5799 assert(!WritingAST && "Already writing the AST!"); 5800 5801 // If there is *any* declaration of the entity that's not from an AST file, 5802 // we can skip writing the update record. We make sure that isUsed() triggers 5803 // completion of the redeclaration chain of the entity. 5804 for (auto Prev = D->getMostRecentDecl(); Prev; Prev = Prev->getPreviousDecl()) 5805 if (IsLocalDecl(Prev)) 5806 return; 5807 5808 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED)); 5809 } 5810 5811 void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(const Decl *D) { 5812 assert(!WritingAST && "Already writing the AST!"); 5813 if (!D->isFromASTFile()) 5814 return; 5815 5816 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_THREADPRIVATE)); 5817 } 5818 5819 void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(const Decl *D, 5820 const Attr *Attr) { 5821 assert(!WritingAST && "Already writing the AST!"); 5822 if (!D->isFromASTFile()) 5823 return; 5824 5825 DeclUpdates[D].push_back( 5826 DeclUpdate(UPD_DECL_MARKED_OPENMP_DECLARETARGET, Attr)); 5827 } 5828 5829 void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) { 5830 assert(!WritingAST && "Already writing the AST!"); 5831 assert(D->isHidden() && "expected a hidden declaration"); 5832 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M)); 5833 } 5834 5835 void ASTWriter::AddedAttributeToRecord(const Attr *Attr, 5836 const RecordDecl *Record) { 5837 assert(!WritingAST && "Already writing the AST!"); 5838 if (!Record->isFromASTFile()) 5839 return; 5840 DeclUpdates[Record].push_back(DeclUpdate(UPD_ADDED_ATTR_TO_RECORD, Attr)); 5841 } 5842