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