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