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/SmallPtrSet.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(static_cast<uint64_t>(TL.getWrittenSignSpec())); 202 Record.push_back(static_cast<uint64_t>(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)); // Errors 1123 MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag 1124 unsigned MetadataAbbrevCode = Stream.EmitAbbrev(std::move(MetadataAbbrev)); 1125 assert((!WritingModule || isysroot.empty()) && 1126 "writing module as a relocatable PCH?"); 1127 { 1128 RecordData::value_type Record[] = { 1129 METADATA, 1130 VERSION_MAJOR, 1131 VERSION_MINOR, 1132 CLANG_VERSION_MAJOR, 1133 CLANG_VERSION_MINOR, 1134 !isysroot.empty(), 1135 IncludeTimestamps, 1136 ASTHasCompilerErrors}; 1137 Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record, 1138 getClangFullRepositoryVersion()); 1139 } 1140 1141 if (WritingModule) { 1142 // Module name 1143 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 1144 Abbrev->Add(BitCodeAbbrevOp(MODULE_NAME)); 1145 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 1146 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); 1147 RecordData::value_type Record[] = {MODULE_NAME}; 1148 Stream.EmitRecordWithBlob(AbbrevCode, Record, WritingModule->Name); 1149 } 1150 1151 if (WritingModule && WritingModule->Directory) { 1152 SmallString<128> BaseDir(WritingModule->Directory->getName()); 1153 cleanPathForOutput(Context.getSourceManager().getFileManager(), BaseDir); 1154 1155 // If the home of the module is the current working directory, then we 1156 // want to pick up the cwd of the build process loading the module, not 1157 // our cwd, when we load this module. 1158 if (!PP.getHeaderSearchInfo() 1159 .getHeaderSearchOpts() 1160 .ModuleMapFileHomeIsCwd || 1161 WritingModule->Directory->getName() != StringRef(".")) { 1162 // Module directory. 1163 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 1164 Abbrev->Add(BitCodeAbbrevOp(MODULE_DIRECTORY)); 1165 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Directory 1166 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); 1167 1168 RecordData::value_type Record[] = {MODULE_DIRECTORY}; 1169 Stream.EmitRecordWithBlob(AbbrevCode, Record, BaseDir); 1170 } 1171 1172 // Write out all other paths relative to the base directory if possible. 1173 BaseDirectory.assign(BaseDir.begin(), BaseDir.end()); 1174 } else if (!isysroot.empty()) { 1175 // Write out paths relative to the sysroot if possible. 1176 BaseDirectory = std::string(isysroot); 1177 } 1178 1179 // Module map file 1180 if (WritingModule && WritingModule->Kind == Module::ModuleMapModule) { 1181 Record.clear(); 1182 1183 auto &Map = PP.getHeaderSearchInfo().getModuleMap(); 1184 AddPath(WritingModule->PresumedModuleMapFile.empty() 1185 ? Map.getModuleMapFileForUniquing(WritingModule)->getName() 1186 : StringRef(WritingModule->PresumedModuleMapFile), 1187 Record); 1188 1189 // Additional module map files. 1190 if (auto *AdditionalModMaps = 1191 Map.getAdditionalModuleMapFiles(WritingModule)) { 1192 Record.push_back(AdditionalModMaps->size()); 1193 for (const FileEntry *F : *AdditionalModMaps) 1194 AddPath(F->getName(), Record); 1195 } else { 1196 Record.push_back(0); 1197 } 1198 1199 Stream.EmitRecord(MODULE_MAP_FILE, Record); 1200 } 1201 1202 // Imports 1203 if (Chain) { 1204 serialization::ModuleManager &Mgr = Chain->getModuleManager(); 1205 Record.clear(); 1206 1207 for (ModuleFile &M : Mgr) { 1208 // Skip modules that weren't directly imported. 1209 if (!M.isDirectlyImported()) 1210 continue; 1211 1212 Record.push_back((unsigned)M.Kind); // FIXME: Stable encoding 1213 AddSourceLocation(M.ImportLoc, Record); 1214 1215 // If we have calculated signature, there is no need to store 1216 // the size or timestamp. 1217 Record.push_back(M.Signature ? 0 : M.File->getSize()); 1218 Record.push_back(M.Signature ? 0 : getTimestampForOutput(M.File)); 1219 1220 for (auto I : M.Signature) 1221 Record.push_back(I); 1222 1223 AddString(M.ModuleName, Record); 1224 AddPath(M.FileName, Record); 1225 } 1226 Stream.EmitRecord(IMPORTS, Record); 1227 } 1228 1229 // Write the options block. 1230 Stream.EnterSubblock(OPTIONS_BLOCK_ID, 4); 1231 1232 // Language options. 1233 Record.clear(); 1234 const LangOptions &LangOpts = Context.getLangOpts(); 1235 #define LANGOPT(Name, Bits, Default, Description) \ 1236 Record.push_back(LangOpts.Name); 1237 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 1238 Record.push_back(static_cast<unsigned>(LangOpts.get##Name())); 1239 #include "clang/Basic/LangOptions.def" 1240 #define SANITIZER(NAME, ID) \ 1241 Record.push_back(LangOpts.Sanitize.has(SanitizerKind::ID)); 1242 #include "clang/Basic/Sanitizers.def" 1243 1244 Record.push_back(LangOpts.ModuleFeatures.size()); 1245 for (StringRef Feature : LangOpts.ModuleFeatures) 1246 AddString(Feature, Record); 1247 1248 Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind()); 1249 AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record); 1250 1251 AddString(LangOpts.CurrentModule, Record); 1252 1253 // Comment options. 1254 Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size()); 1255 for (const auto &I : LangOpts.CommentOpts.BlockCommandNames) { 1256 AddString(I, Record); 1257 } 1258 Record.push_back(LangOpts.CommentOpts.ParseAllComments); 1259 1260 // OpenMP offloading options. 1261 Record.push_back(LangOpts.OMPTargetTriples.size()); 1262 for (auto &T : LangOpts.OMPTargetTriples) 1263 AddString(T.getTriple(), Record); 1264 1265 AddString(LangOpts.OMPHostIRFile, Record); 1266 1267 Stream.EmitRecord(LANGUAGE_OPTIONS, Record); 1268 1269 // Target options. 1270 Record.clear(); 1271 const TargetInfo &Target = Context.getTargetInfo(); 1272 const TargetOptions &TargetOpts = Target.getTargetOpts(); 1273 AddString(TargetOpts.Triple, Record); 1274 AddString(TargetOpts.CPU, Record); 1275 AddString(TargetOpts.TuneCPU, Record); 1276 AddString(TargetOpts.ABI, Record); 1277 Record.push_back(TargetOpts.FeaturesAsWritten.size()); 1278 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) { 1279 AddString(TargetOpts.FeaturesAsWritten[I], Record); 1280 } 1281 Record.push_back(TargetOpts.Features.size()); 1282 for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) { 1283 AddString(TargetOpts.Features[I], Record); 1284 } 1285 Stream.EmitRecord(TARGET_OPTIONS, Record); 1286 1287 // File system options. 1288 Record.clear(); 1289 const FileSystemOptions &FSOpts = 1290 Context.getSourceManager().getFileManager().getFileSystemOpts(); 1291 AddString(FSOpts.WorkingDir, Record); 1292 Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record); 1293 1294 // Header search options. 1295 Record.clear(); 1296 const HeaderSearchOptions &HSOpts 1297 = PP.getHeaderSearchInfo().getHeaderSearchOpts(); 1298 AddString(HSOpts.Sysroot, Record); 1299 1300 // Include entries. 1301 Record.push_back(HSOpts.UserEntries.size()); 1302 for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) { 1303 const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I]; 1304 AddString(Entry.Path, Record); 1305 Record.push_back(static_cast<unsigned>(Entry.Group)); 1306 Record.push_back(Entry.IsFramework); 1307 Record.push_back(Entry.IgnoreSysRoot); 1308 } 1309 1310 // System header prefixes. 1311 Record.push_back(HSOpts.SystemHeaderPrefixes.size()); 1312 for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) { 1313 AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record); 1314 Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader); 1315 } 1316 1317 AddString(HSOpts.ResourceDir, Record); 1318 AddString(HSOpts.ModuleCachePath, Record); 1319 AddString(HSOpts.ModuleUserBuildPath, Record); 1320 Record.push_back(HSOpts.DisableModuleHash); 1321 Record.push_back(HSOpts.ImplicitModuleMaps); 1322 Record.push_back(HSOpts.ModuleMapFileHomeIsCwd); 1323 Record.push_back(HSOpts.EnablePrebuiltImplicitModules); 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->getBufferIfLoaded(); 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 SmallString<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); 1713 FrameworkStringData.push_back(0); 1714 1715 FrameworkNameOffset[Data.HFI.Framework] = Offset; 1716 } else 1717 Offset = Pos->second; 1718 } 1719 LE.write<uint32_t>(Offset); 1720 1721 auto EmitModule = [&](Module *M, ModuleMap::ModuleHeaderRole Role) { 1722 if (uint32_t ModID = Writer.getLocalOrImportedSubmoduleID(M)) { 1723 uint32_t Value = (ModID << 2) | (unsigned)Role; 1724 assert((Value >> 2) == ModID && "overflow in header module info"); 1725 LE.write<uint32_t>(Value); 1726 } 1727 }; 1728 1729 // FIXME: If the header is excluded, we should write out some 1730 // record of that fact. 1731 for (auto ModInfo : Data.KnownHeaders) 1732 EmitModule(ModInfo.getModule(), ModInfo.getRole()); 1733 if (Data.Unresolved.getPointer()) 1734 EmitModule(Data.Unresolved.getPointer(), Data.Unresolved.getInt()); 1735 1736 assert(Out.tell() - Start == DataLen && "Wrong data length"); 1737 } 1738 1739 const char *strings_begin() const { return FrameworkStringData.begin(); } 1740 const char *strings_end() const { return FrameworkStringData.end(); } 1741 }; 1742 1743 } // namespace 1744 1745 /// Write the header search block for the list of files that 1746 /// 1747 /// \param HS The header search structure to save. 1748 void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) { 1749 HeaderFileInfoTrait GeneratorTrait(*this); 1750 llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator; 1751 SmallVector<const char *, 4> SavedStrings; 1752 unsigned NumHeaderSearchEntries = 0; 1753 1754 // Find all unresolved headers for the current module. We generally will 1755 // have resolved them before we get here, but not necessarily: we might be 1756 // compiling a preprocessed module, where there is no requirement for the 1757 // original files to exist any more. 1758 const HeaderFileInfo Empty; // So we can take a reference. 1759 if (WritingModule) { 1760 llvm::SmallVector<Module *, 16> Worklist(1, WritingModule); 1761 while (!Worklist.empty()) { 1762 Module *M = Worklist.pop_back_val(); 1763 // We don't care about headers in unimportable submodules. 1764 if (M->isUnimportable()) 1765 continue; 1766 1767 // Map to disk files where possible, to pick up any missing stat 1768 // information. This also means we don't need to check the unresolved 1769 // headers list when emitting resolved headers in the first loop below. 1770 // FIXME: It'd be preferable to avoid doing this if we were given 1771 // sufficient stat information in the module map. 1772 HS.getModuleMap().resolveHeaderDirectives(M); 1773 1774 // If the file didn't exist, we can still create a module if we were given 1775 // enough information in the module map. 1776 for (auto U : M->MissingHeaders) { 1777 // Check that we were given enough information to build a module 1778 // without this file existing on disk. 1779 if (!U.Size || (!U.ModTime && IncludeTimestamps)) { 1780 PP->Diag(U.FileNameLoc, diag::err_module_no_size_mtime_for_header) 1781 << WritingModule->getFullModuleName() << U.Size.hasValue() 1782 << U.FileName; 1783 continue; 1784 } 1785 1786 // Form the effective relative pathname for the file. 1787 SmallString<128> Filename(M->Directory->getName()); 1788 llvm::sys::path::append(Filename, U.FileName); 1789 PreparePathForOutput(Filename); 1790 1791 StringRef FilenameDup = strdup(Filename.c_str()); 1792 SavedStrings.push_back(FilenameDup.data()); 1793 1794 HeaderFileInfoTrait::key_type Key = { 1795 FilenameDup, *U.Size, IncludeTimestamps ? *U.ModTime : 0 1796 }; 1797 HeaderFileInfoTrait::data_type Data = { 1798 Empty, {}, {M, ModuleMap::headerKindToRole(U.Kind)} 1799 }; 1800 // FIXME: Deal with cases where there are multiple unresolved header 1801 // directives in different submodules for the same header. 1802 Generator.insert(Key, Data, GeneratorTrait); 1803 ++NumHeaderSearchEntries; 1804 } 1805 1806 Worklist.append(M->submodule_begin(), M->submodule_end()); 1807 } 1808 } 1809 1810 SmallVector<const FileEntry *, 16> FilesByUID; 1811 HS.getFileMgr().GetUniqueIDMapping(FilesByUID); 1812 1813 if (FilesByUID.size() > HS.header_file_size()) 1814 FilesByUID.resize(HS.header_file_size()); 1815 1816 for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) { 1817 const FileEntry *File = FilesByUID[UID]; 1818 if (!File) 1819 continue; 1820 1821 // Get the file info. This will load info from the external source if 1822 // necessary. Skip emitting this file if we have no information on it 1823 // as a header file (in which case HFI will be null) or if it hasn't 1824 // changed since it was loaded. Also skip it if it's for a modular header 1825 // from a different module; in that case, we rely on the module(s) 1826 // containing the header to provide this information. 1827 const HeaderFileInfo *HFI = 1828 HS.getExistingFileInfo(File, /*WantExternal*/!Chain); 1829 if (!HFI || (HFI->isModuleHeader && !HFI->isCompilingModuleHeader)) 1830 continue; 1831 1832 // Massage the file path into an appropriate form. 1833 StringRef Filename = File->getName(); 1834 SmallString<128> FilenameTmp(Filename); 1835 if (PreparePathForOutput(FilenameTmp)) { 1836 // If we performed any translation on the file name at all, we need to 1837 // save this string, since the generator will refer to it later. 1838 Filename = StringRef(strdup(FilenameTmp.c_str())); 1839 SavedStrings.push_back(Filename.data()); 1840 } 1841 1842 HeaderFileInfoTrait::key_type Key = { 1843 Filename, File->getSize(), getTimestampForOutput(File) 1844 }; 1845 HeaderFileInfoTrait::data_type Data = { 1846 *HFI, HS.getModuleMap().findResolvedModulesForHeader(File), {} 1847 }; 1848 Generator.insert(Key, Data, GeneratorTrait); 1849 ++NumHeaderSearchEntries; 1850 } 1851 1852 // Create the on-disk hash table in a buffer. 1853 SmallString<4096> TableData; 1854 uint32_t BucketOffset; 1855 { 1856 using namespace llvm::support; 1857 1858 llvm::raw_svector_ostream Out(TableData); 1859 // Make sure that no bucket is at offset 0 1860 endian::write<uint32_t>(Out, 0, little); 1861 BucketOffset = Generator.Emit(Out, GeneratorTrait); 1862 } 1863 1864 // Create a blob abbreviation 1865 using namespace llvm; 1866 1867 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 1868 Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE)); 1869 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1870 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1871 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1872 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1873 unsigned TableAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 1874 1875 // Write the header search table 1876 RecordData::value_type Record[] = {HEADER_SEARCH_TABLE, BucketOffset, 1877 NumHeaderSearchEntries, TableData.size()}; 1878 TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end()); 1879 Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData); 1880 1881 // Free all of the strings we had to duplicate. 1882 for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I) 1883 free(const_cast<char *>(SavedStrings[I])); 1884 } 1885 1886 static void emitBlob(llvm::BitstreamWriter &Stream, StringRef Blob, 1887 unsigned SLocBufferBlobCompressedAbbrv, 1888 unsigned SLocBufferBlobAbbrv) { 1889 using RecordDataType = ASTWriter::RecordData::value_type; 1890 1891 // Compress the buffer if possible. We expect that almost all PCM 1892 // consumers will not want its contents. 1893 SmallString<0> CompressedBuffer; 1894 if (llvm::zlib::isAvailable()) { 1895 llvm::Error E = llvm::zlib::compress(Blob.drop_back(1), CompressedBuffer); 1896 if (!E) { 1897 RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB_COMPRESSED, 1898 Blob.size() - 1}; 1899 Stream.EmitRecordWithBlob(SLocBufferBlobCompressedAbbrv, Record, 1900 CompressedBuffer); 1901 return; 1902 } 1903 llvm::consumeError(std::move(E)); 1904 } 1905 1906 RecordDataType Record[] = {SM_SLOC_BUFFER_BLOB}; 1907 Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Blob); 1908 } 1909 1910 /// Writes the block containing the serialized form of the 1911 /// source manager. 1912 /// 1913 /// TODO: We should probably use an on-disk hash table (stored in a 1914 /// blob), indexed based on the file name, so that we only create 1915 /// entries for files that we actually need. In the common case (no 1916 /// errors), we probably won't have to create file entries for any of 1917 /// the files in the AST. 1918 void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, 1919 const Preprocessor &PP) { 1920 RecordData Record; 1921 1922 // Enter the source manager block. 1923 Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 4); 1924 const uint64_t SourceManagerBlockOffset = Stream.GetCurrentBitNo(); 1925 1926 // Abbreviations for the various kinds of source-location entries. 1927 unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream); 1928 unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); 1929 unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream, false); 1930 unsigned SLocBufferBlobCompressedAbbrv = 1931 CreateSLocBufferBlobAbbrev(Stream, true); 1932 unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(Stream); 1933 1934 // Write out the source location entry table. We skip the first 1935 // entry, which is always the same dummy entry. 1936 std::vector<uint32_t> SLocEntryOffsets; 1937 uint64_t SLocEntryOffsetsBase = Stream.GetCurrentBitNo(); 1938 RecordData PreloadSLocs; 1939 SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1); 1940 for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); 1941 I != N; ++I) { 1942 // Get this source location entry. 1943 const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I); 1944 FileID FID = FileID::get(I); 1945 assert(&SourceMgr.getSLocEntry(FID) == SLoc); 1946 1947 // Record the offset of this source-location entry. 1948 uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase; 1949 assert((Offset >> 32) == 0 && "SLocEntry offset too large"); 1950 SLocEntryOffsets.push_back(Offset); 1951 1952 // Figure out which record code to use. 1953 unsigned Code; 1954 if (SLoc->isFile()) { 1955 const SrcMgr::ContentCache *Cache = &SLoc->getFile().getContentCache(); 1956 if (Cache->OrigEntry) { 1957 Code = SM_SLOC_FILE_ENTRY; 1958 } else 1959 Code = SM_SLOC_BUFFER_ENTRY; 1960 } else 1961 Code = SM_SLOC_EXPANSION_ENTRY; 1962 Record.clear(); 1963 Record.push_back(Code); 1964 1965 // Starting offset of this entry within this module, so skip the dummy. 1966 Record.push_back(SLoc->getOffset() - 2); 1967 if (SLoc->isFile()) { 1968 const SrcMgr::FileInfo &File = SLoc->getFile(); 1969 AddSourceLocation(File.getIncludeLoc(), Record); 1970 Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding 1971 Record.push_back(File.hasLineDirectives()); 1972 1973 const SrcMgr::ContentCache *Content = &File.getContentCache(); 1974 bool EmitBlob = false; 1975 if (Content->OrigEntry) { 1976 assert(Content->OrigEntry == Content->ContentsEntry && 1977 "Writing to AST an overridden file is not supported"); 1978 1979 // The source location entry is a file. Emit input file ID. 1980 assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry"); 1981 Record.push_back(InputFileIDs[Content->OrigEntry]); 1982 1983 Record.push_back(File.NumCreatedFIDs); 1984 1985 FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID); 1986 if (FDI != FileDeclIDs.end()) { 1987 Record.push_back(FDI->second->FirstDeclIndex); 1988 Record.push_back(FDI->second->DeclIDs.size()); 1989 } else { 1990 Record.push_back(0); 1991 Record.push_back(0); 1992 } 1993 1994 Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record); 1995 1996 if (Content->BufferOverridden || Content->IsTransient) 1997 EmitBlob = true; 1998 } else { 1999 // The source location entry is a buffer. The blob associated 2000 // with this entry contains the contents of the buffer. 2001 2002 // We add one to the size so that we capture the trailing NULL 2003 // that is required by llvm::MemoryBuffer::getMemBuffer (on 2004 // the reader side). 2005 llvm::Optional<llvm::MemoryBufferRef> Buffer = 2006 Content->getBufferOrNone(PP.getDiagnostics(), PP.getFileManager()); 2007 StringRef Name = Buffer ? Buffer->getBufferIdentifier() : ""; 2008 Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, 2009 StringRef(Name.data(), Name.size() + 1)); 2010 EmitBlob = true; 2011 2012 if (Name == "<built-in>") 2013 PreloadSLocs.push_back(SLocEntryOffsets.size()); 2014 } 2015 2016 if (EmitBlob) { 2017 // Include the implicit terminating null character in the on-disk buffer 2018 // if we're writing it uncompressed. 2019 llvm::Optional<llvm::MemoryBufferRef> Buffer = 2020 Content->getBufferOrNone(PP.getDiagnostics(), PP.getFileManager()); 2021 if (!Buffer) 2022 Buffer = llvm::MemoryBufferRef("<<<INVALID BUFFER>>>", ""); 2023 StringRef Blob(Buffer->getBufferStart(), Buffer->getBufferSize() + 1); 2024 emitBlob(Stream, Blob, SLocBufferBlobCompressedAbbrv, 2025 SLocBufferBlobAbbrv); 2026 } 2027 } else { 2028 // The source location entry is a macro expansion. 2029 const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion(); 2030 AddSourceLocation(Expansion.getSpellingLoc(), Record); 2031 AddSourceLocation(Expansion.getExpansionLocStart(), Record); 2032 AddSourceLocation(Expansion.isMacroArgExpansion() 2033 ? SourceLocation() 2034 : Expansion.getExpansionLocEnd(), 2035 Record); 2036 Record.push_back(Expansion.isExpansionTokenRange()); 2037 2038 // Compute the token length for this macro expansion. 2039 unsigned NextOffset = SourceMgr.getNextLocalOffset(); 2040 if (I + 1 != N) 2041 NextOffset = SourceMgr.getLocalSLocEntry(I + 1).getOffset(); 2042 Record.push_back(NextOffset - SLoc->getOffset() - 1); 2043 Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, Record); 2044 } 2045 } 2046 2047 Stream.ExitBlock(); 2048 2049 if (SLocEntryOffsets.empty()) 2050 return; 2051 2052 // Write the source-location offsets table into the AST block. This 2053 // table is used for lazily loading source-location information. 2054 using namespace llvm; 2055 2056 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2057 Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS)); 2058 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs 2059 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size 2060 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // base offset 2061 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets 2062 unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2063 { 2064 RecordData::value_type Record[] = { 2065 SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(), 2066 SourceMgr.getNextLocalOffset() - 1 /* skip dummy */, 2067 SLocEntryOffsetsBase - SourceManagerBlockOffset}; 2068 Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, 2069 bytes(SLocEntryOffsets)); 2070 } 2071 // Write the source location entry preloads array, telling the AST 2072 // reader which source locations entries it should load eagerly. 2073 Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs); 2074 2075 // Write the line table. It depends on remapping working, so it must come 2076 // after the source location offsets. 2077 if (SourceMgr.hasLineTable()) { 2078 LineTableInfo &LineTable = SourceMgr.getLineTable(); 2079 2080 Record.clear(); 2081 2082 // Emit the needed file names. 2083 llvm::DenseMap<int, int> FilenameMap; 2084 FilenameMap[-1] = -1; // For unspecified filenames. 2085 for (const auto &L : LineTable) { 2086 if (L.first.ID < 0) 2087 continue; 2088 for (auto &LE : L.second) { 2089 if (FilenameMap.insert(std::make_pair(LE.FilenameID, 2090 FilenameMap.size() - 1)).second) 2091 AddPath(LineTable.getFilename(LE.FilenameID), Record); 2092 } 2093 } 2094 Record.push_back(0); 2095 2096 // Emit the line entries 2097 for (const auto &L : LineTable) { 2098 // Only emit entries for local files. 2099 if (L.first.ID < 0) 2100 continue; 2101 2102 // Emit the file ID 2103 Record.push_back(L.first.ID); 2104 2105 // Emit the line entries 2106 Record.push_back(L.second.size()); 2107 for (const auto &LE : L.second) { 2108 Record.push_back(LE.FileOffset); 2109 Record.push_back(LE.LineNo); 2110 Record.push_back(FilenameMap[LE.FilenameID]); 2111 Record.push_back((unsigned)LE.FileKind); 2112 Record.push_back(LE.IncludeOffset); 2113 } 2114 } 2115 2116 Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, Record); 2117 } 2118 } 2119 2120 //===----------------------------------------------------------------------===// 2121 // Preprocessor Serialization 2122 //===----------------------------------------------------------------------===// 2123 2124 static bool shouldIgnoreMacro(MacroDirective *MD, bool IsModule, 2125 const Preprocessor &PP) { 2126 if (MacroInfo *MI = MD->getMacroInfo()) 2127 if (MI->isBuiltinMacro()) 2128 return true; 2129 2130 if (IsModule) { 2131 SourceLocation Loc = MD->getLocation(); 2132 if (Loc.isInvalid()) 2133 return true; 2134 if (PP.getSourceManager().getFileID(Loc) == PP.getPredefinesFileID()) 2135 return true; 2136 } 2137 2138 return false; 2139 } 2140 2141 /// Writes the block containing the serialized form of the 2142 /// preprocessor. 2143 void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) { 2144 uint64_t MacroOffsetsBase = Stream.GetCurrentBitNo(); 2145 2146 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 2147 if (PPRec) 2148 WritePreprocessorDetail(*PPRec, MacroOffsetsBase); 2149 2150 RecordData Record; 2151 RecordData ModuleMacroRecord; 2152 2153 // If the preprocessor __COUNTER__ value has been bumped, remember it. 2154 if (PP.getCounterValue() != 0) { 2155 RecordData::value_type Record[] = {PP.getCounterValue()}; 2156 Stream.EmitRecord(PP_COUNTER_VALUE, Record); 2157 } 2158 2159 if (PP.isRecordingPreamble() && PP.hasRecordedPreamble()) { 2160 assert(!IsModule); 2161 auto SkipInfo = PP.getPreambleSkipInfo(); 2162 if (SkipInfo.hasValue()) { 2163 Record.push_back(true); 2164 AddSourceLocation(SkipInfo->HashTokenLoc, Record); 2165 AddSourceLocation(SkipInfo->IfTokenLoc, Record); 2166 Record.push_back(SkipInfo->FoundNonSkipPortion); 2167 Record.push_back(SkipInfo->FoundElse); 2168 AddSourceLocation(SkipInfo->ElseLoc, Record); 2169 } else { 2170 Record.push_back(false); 2171 } 2172 for (const auto &Cond : PP.getPreambleConditionalStack()) { 2173 AddSourceLocation(Cond.IfLoc, Record); 2174 Record.push_back(Cond.WasSkipping); 2175 Record.push_back(Cond.FoundNonSkip); 2176 Record.push_back(Cond.FoundElse); 2177 } 2178 Stream.EmitRecord(PP_CONDITIONAL_STACK, Record); 2179 Record.clear(); 2180 } 2181 2182 // Enter the preprocessor block. 2183 Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3); 2184 2185 // If the AST file contains __DATE__ or __TIME__ emit a warning about this. 2186 // FIXME: Include a location for the use, and say which one was used. 2187 if (PP.SawDateOrTime()) 2188 PP.Diag(SourceLocation(), diag::warn_module_uses_date_time) << IsModule; 2189 2190 // Loop over all the macro directives that are live at the end of the file, 2191 // emitting each to the PP section. 2192 2193 // Construct the list of identifiers with macro directives that need to be 2194 // serialized. 2195 SmallVector<const IdentifierInfo *, 128> MacroIdentifiers; 2196 for (auto &Id : PP.getIdentifierTable()) 2197 if (Id.second->hadMacroDefinition() && 2198 (!Id.second->isFromAST() || 2199 Id.second->hasChangedSinceDeserialization())) 2200 MacroIdentifiers.push_back(Id.second); 2201 // Sort the set of macro definitions that need to be serialized by the 2202 // name of the macro, to provide a stable ordering. 2203 llvm::sort(MacroIdentifiers, llvm::deref<std::less<>>()); 2204 2205 // Emit the macro directives as a list and associate the offset with the 2206 // identifier they belong to. 2207 for (const IdentifierInfo *Name : MacroIdentifiers) { 2208 MacroDirective *MD = PP.getLocalMacroDirectiveHistory(Name); 2209 uint64_t StartOffset = Stream.GetCurrentBitNo() - MacroOffsetsBase; 2210 assert((StartOffset >> 32) == 0 && "Macro identifiers offset too large"); 2211 2212 // Emit the macro directives in reverse source order. 2213 for (; MD; MD = MD->getPrevious()) { 2214 // Once we hit an ignored macro, we're done: the rest of the chain 2215 // will all be ignored macros. 2216 if (shouldIgnoreMacro(MD, IsModule, PP)) 2217 break; 2218 2219 AddSourceLocation(MD->getLocation(), Record); 2220 Record.push_back(MD->getKind()); 2221 if (auto *DefMD = dyn_cast<DefMacroDirective>(MD)) { 2222 Record.push_back(getMacroRef(DefMD->getInfo(), Name)); 2223 } else if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) { 2224 Record.push_back(VisMD->isPublic()); 2225 } 2226 } 2227 2228 // Write out any exported module macros. 2229 bool EmittedModuleMacros = false; 2230 // We write out exported module macros for PCH as well. 2231 auto Leafs = PP.getLeafModuleMacros(Name); 2232 SmallVector<ModuleMacro*, 8> Worklist(Leafs.begin(), Leafs.end()); 2233 llvm::DenseMap<ModuleMacro*, unsigned> Visits; 2234 while (!Worklist.empty()) { 2235 auto *Macro = Worklist.pop_back_val(); 2236 2237 // Emit a record indicating this submodule exports this macro. 2238 ModuleMacroRecord.push_back( 2239 getSubmoduleID(Macro->getOwningModule())); 2240 ModuleMacroRecord.push_back(getMacroRef(Macro->getMacroInfo(), Name)); 2241 for (auto *M : Macro->overrides()) 2242 ModuleMacroRecord.push_back(getSubmoduleID(M->getOwningModule())); 2243 2244 Stream.EmitRecord(PP_MODULE_MACRO, ModuleMacroRecord); 2245 ModuleMacroRecord.clear(); 2246 2247 // Enqueue overridden macros once we've visited all their ancestors. 2248 for (auto *M : Macro->overrides()) 2249 if (++Visits[M] == M->getNumOverridingMacros()) 2250 Worklist.push_back(M); 2251 2252 EmittedModuleMacros = true; 2253 } 2254 2255 if (Record.empty() && !EmittedModuleMacros) 2256 continue; 2257 2258 IdentMacroDirectivesOffsetMap[Name] = StartOffset; 2259 Stream.EmitRecord(PP_MACRO_DIRECTIVE_HISTORY, Record); 2260 Record.clear(); 2261 } 2262 2263 /// Offsets of each of the macros into the bitstream, indexed by 2264 /// the local macro ID 2265 /// 2266 /// For each identifier that is associated with a macro, this map 2267 /// provides the offset into the bitstream where that macro is 2268 /// defined. 2269 std::vector<uint32_t> MacroOffsets; 2270 2271 for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) { 2272 const IdentifierInfo *Name = MacroInfosToEmit[I].Name; 2273 MacroInfo *MI = MacroInfosToEmit[I].MI; 2274 MacroID ID = MacroInfosToEmit[I].ID; 2275 2276 if (ID < FirstMacroID) { 2277 assert(0 && "Loaded MacroInfo entered MacroInfosToEmit ?"); 2278 continue; 2279 } 2280 2281 // Record the local offset of this macro. 2282 unsigned Index = ID - FirstMacroID; 2283 if (Index >= MacroOffsets.size()) 2284 MacroOffsets.resize(Index + 1); 2285 2286 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase; 2287 assert((Offset >> 32) == 0 && "Macro offset too large"); 2288 MacroOffsets[Index] = Offset; 2289 2290 AddIdentifierRef(Name, Record); 2291 AddSourceLocation(MI->getDefinitionLoc(), Record); 2292 AddSourceLocation(MI->getDefinitionEndLoc(), Record); 2293 Record.push_back(MI->isUsed()); 2294 Record.push_back(MI->isUsedForHeaderGuard()); 2295 unsigned Code; 2296 if (MI->isObjectLike()) { 2297 Code = PP_MACRO_OBJECT_LIKE; 2298 } else { 2299 Code = PP_MACRO_FUNCTION_LIKE; 2300 2301 Record.push_back(MI->isC99Varargs()); 2302 Record.push_back(MI->isGNUVarargs()); 2303 Record.push_back(MI->hasCommaPasting()); 2304 Record.push_back(MI->getNumParams()); 2305 for (const IdentifierInfo *Param : MI->params()) 2306 AddIdentifierRef(Param, Record); 2307 } 2308 2309 // If we have a detailed preprocessing record, record the macro definition 2310 // ID that corresponds to this macro. 2311 if (PPRec) 2312 Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]); 2313 2314 Stream.EmitRecord(Code, Record); 2315 Record.clear(); 2316 2317 // Emit the tokens array. 2318 for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) { 2319 // Note that we know that the preprocessor does not have any annotation 2320 // tokens in it because they are created by the parser, and thus can't 2321 // be in a macro definition. 2322 const Token &Tok = MI->getReplacementToken(TokNo); 2323 AddToken(Tok, Record); 2324 Stream.EmitRecord(PP_TOKEN, Record); 2325 Record.clear(); 2326 } 2327 ++NumMacros; 2328 } 2329 2330 Stream.ExitBlock(); 2331 2332 // Write the offsets table for macro IDs. 2333 using namespace llvm; 2334 2335 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2336 Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET)); 2337 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros 2338 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 2339 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // base offset 2340 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2341 2342 unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2343 { 2344 RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(), 2345 FirstMacroID - NUM_PREDEF_MACRO_IDS, 2346 MacroOffsetsBase - ASTBlockStartOffset}; 2347 Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record, bytes(MacroOffsets)); 2348 } 2349 } 2350 2351 void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec, 2352 uint64_t MacroOffsetsBase) { 2353 if (PPRec.local_begin() == PPRec.local_end()) 2354 return; 2355 2356 SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets; 2357 2358 // Enter the preprocessor block. 2359 Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3); 2360 2361 // If the preprocessor has a preprocessing record, emit it. 2362 unsigned NumPreprocessingRecords = 0; 2363 using namespace llvm; 2364 2365 // Set up the abbreviation for 2366 unsigned InclusionAbbrev = 0; 2367 { 2368 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2369 Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE)); 2370 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length 2371 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes 2372 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind 2373 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module 2374 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2375 InclusionAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2376 } 2377 2378 unsigned FirstPreprocessorEntityID 2379 = (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0) 2380 + NUM_PREDEF_PP_ENTITY_IDS; 2381 unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID; 2382 RecordData Record; 2383 for (PreprocessingRecord::iterator E = PPRec.local_begin(), 2384 EEnd = PPRec.local_end(); 2385 E != EEnd; 2386 (void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) { 2387 Record.clear(); 2388 2389 uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase; 2390 assert((Offset >> 32) == 0 && "Preprocessed entity offset too large"); 2391 PreprocessedEntityOffsets.push_back( 2392 PPEntityOffset((*E)->getSourceRange(), Offset)); 2393 2394 if (auto *MD = dyn_cast<MacroDefinitionRecord>(*E)) { 2395 // Record this macro definition's ID. 2396 MacroDefinitions[MD] = NextPreprocessorEntityID; 2397 2398 AddIdentifierRef(MD->getName(), Record); 2399 Stream.EmitRecord(PPD_MACRO_DEFINITION, Record); 2400 continue; 2401 } 2402 2403 if (auto *ME = dyn_cast<MacroExpansion>(*E)) { 2404 Record.push_back(ME->isBuiltinMacro()); 2405 if (ME->isBuiltinMacro()) 2406 AddIdentifierRef(ME->getName(), Record); 2407 else 2408 Record.push_back(MacroDefinitions[ME->getDefinition()]); 2409 Stream.EmitRecord(PPD_MACRO_EXPANSION, Record); 2410 continue; 2411 } 2412 2413 if (auto *ID = dyn_cast<InclusionDirective>(*E)) { 2414 Record.push_back(PPD_INCLUSION_DIRECTIVE); 2415 Record.push_back(ID->getFileName().size()); 2416 Record.push_back(ID->wasInQuotes()); 2417 Record.push_back(static_cast<unsigned>(ID->getKind())); 2418 Record.push_back(ID->importedModule()); 2419 SmallString<64> Buffer; 2420 Buffer += ID->getFileName(); 2421 // Check that the FileEntry is not null because it was not resolved and 2422 // we create a PCH even with compiler errors. 2423 if (ID->getFile()) 2424 Buffer += ID->getFile()->getName(); 2425 Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer); 2426 continue; 2427 } 2428 2429 llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter"); 2430 } 2431 Stream.ExitBlock(); 2432 2433 // Write the offsets table for the preprocessing record. 2434 if (NumPreprocessingRecords > 0) { 2435 assert(PreprocessedEntityOffsets.size() == NumPreprocessingRecords); 2436 2437 // Write the offsets table for identifier IDs. 2438 using namespace llvm; 2439 2440 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2441 Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS)); 2442 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity 2443 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2444 unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2445 2446 RecordData::value_type Record[] = {PPD_ENTITIES_OFFSETS, 2447 FirstPreprocessorEntityID - 2448 NUM_PREDEF_PP_ENTITY_IDS}; 2449 Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record, 2450 bytes(PreprocessedEntityOffsets)); 2451 } 2452 2453 // Write the skipped region table for the preprocessing record. 2454 ArrayRef<SourceRange> SkippedRanges = PPRec.getSkippedRanges(); 2455 if (SkippedRanges.size() > 0) { 2456 std::vector<PPSkippedRange> SerializedSkippedRanges; 2457 SerializedSkippedRanges.reserve(SkippedRanges.size()); 2458 for (auto const& Range : SkippedRanges) 2459 SerializedSkippedRanges.emplace_back(Range); 2460 2461 using namespace llvm; 2462 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2463 Abbrev->Add(BitCodeAbbrevOp(PPD_SKIPPED_RANGES)); 2464 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2465 unsigned PPESkippedRangeAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2466 2467 Record.clear(); 2468 Record.push_back(PPD_SKIPPED_RANGES); 2469 Stream.EmitRecordWithBlob(PPESkippedRangeAbbrev, Record, 2470 bytes(SerializedSkippedRanges)); 2471 } 2472 } 2473 2474 unsigned ASTWriter::getLocalOrImportedSubmoduleID(Module *Mod) { 2475 if (!Mod) 2476 return 0; 2477 2478 llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod); 2479 if (Known != SubmoduleIDs.end()) 2480 return Known->second; 2481 2482 auto *Top = Mod->getTopLevelModule(); 2483 if (Top != WritingModule && 2484 (getLangOpts().CompilingPCH || 2485 !Top->fullModuleNameIs(StringRef(getLangOpts().CurrentModule)))) 2486 return 0; 2487 2488 return SubmoduleIDs[Mod] = NextSubmoduleID++; 2489 } 2490 2491 unsigned ASTWriter::getSubmoduleID(Module *Mod) { 2492 // FIXME: This can easily happen, if we have a reference to a submodule that 2493 // did not result in us loading a module file for that submodule. For 2494 // instance, a cross-top-level-module 'conflict' declaration will hit this. 2495 unsigned ID = getLocalOrImportedSubmoduleID(Mod); 2496 assert((ID || !Mod) && 2497 "asked for module ID for non-local, non-imported module"); 2498 return ID; 2499 } 2500 2501 /// Compute the number of modules within the given tree (including the 2502 /// given module). 2503 static unsigned getNumberOfModules(Module *Mod) { 2504 unsigned ChildModules = 0; 2505 for (auto Sub = Mod->submodule_begin(), SubEnd = Mod->submodule_end(); 2506 Sub != SubEnd; ++Sub) 2507 ChildModules += getNumberOfModules(*Sub); 2508 2509 return ChildModules + 1; 2510 } 2511 2512 void ASTWriter::WriteSubmodules(Module *WritingModule) { 2513 // Enter the submodule description block. 2514 Stream.EnterSubblock(SUBMODULE_BLOCK_ID, /*bits for abbreviations*/5); 2515 2516 // Write the abbreviations needed for the submodules block. 2517 using namespace llvm; 2518 2519 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2520 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION)); 2521 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID 2522 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent 2523 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind 2524 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 2525 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit 2526 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem 2527 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC 2528 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules... 2529 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit... 2530 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild... 2531 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh... 2532 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModuleMapIsPriv... 2533 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2534 unsigned DefinitionAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2535 2536 Abbrev = std::make_shared<BitCodeAbbrev>(); 2537 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER)); 2538 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2539 unsigned UmbrellaAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2540 2541 Abbrev = std::make_shared<BitCodeAbbrev>(); 2542 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER)); 2543 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2544 unsigned HeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2545 2546 Abbrev = std::make_shared<BitCodeAbbrev>(); 2547 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER)); 2548 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2549 unsigned TopHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2550 2551 Abbrev = std::make_shared<BitCodeAbbrev>(); 2552 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR)); 2553 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2554 unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2555 2556 Abbrev = std::make_shared<BitCodeAbbrev>(); 2557 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES)); 2558 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // State 2559 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature 2560 unsigned RequiresAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2561 2562 Abbrev = std::make_shared<BitCodeAbbrev>(); 2563 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER)); 2564 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2565 unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2566 2567 Abbrev = std::make_shared<BitCodeAbbrev>(); 2568 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TEXTUAL_HEADER)); 2569 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2570 unsigned TextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2571 2572 Abbrev = std::make_shared<BitCodeAbbrev>(); 2573 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_HEADER)); 2574 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2575 unsigned PrivateHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2576 2577 Abbrev = std::make_shared<BitCodeAbbrev>(); 2578 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_PRIVATE_TEXTUAL_HEADER)); 2579 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2580 unsigned PrivateTextualHeaderAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2581 2582 Abbrev = std::make_shared<BitCodeAbbrev>(); 2583 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_LINK_LIBRARY)); 2584 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework 2585 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name 2586 unsigned LinkLibraryAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2587 2588 Abbrev = std::make_shared<BitCodeAbbrev>(); 2589 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFIG_MACRO)); 2590 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name 2591 unsigned ConfigMacroAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2592 2593 Abbrev = std::make_shared<BitCodeAbbrev>(); 2594 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_CONFLICT)); 2595 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Other module 2596 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Message 2597 unsigned ConflictAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2598 2599 Abbrev = std::make_shared<BitCodeAbbrev>(); 2600 Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXPORT_AS)); 2601 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Macro name 2602 unsigned ExportAsAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2603 2604 // Write the submodule metadata block. 2605 RecordData::value_type Record[] = { 2606 getNumberOfModules(WritingModule), 2607 FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS}; 2608 Stream.EmitRecord(SUBMODULE_METADATA, Record); 2609 2610 // Write all of the submodules. 2611 std::queue<Module *> Q; 2612 Q.push(WritingModule); 2613 while (!Q.empty()) { 2614 Module *Mod = Q.front(); 2615 Q.pop(); 2616 unsigned ID = getSubmoduleID(Mod); 2617 2618 uint64_t ParentID = 0; 2619 if (Mod->Parent) { 2620 assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?"); 2621 ParentID = SubmoduleIDs[Mod->Parent]; 2622 } 2623 2624 // Emit the definition of the block. 2625 { 2626 RecordData::value_type Record[] = {SUBMODULE_DEFINITION, 2627 ID, 2628 ParentID, 2629 (RecordData::value_type)Mod->Kind, 2630 Mod->IsFramework, 2631 Mod->IsExplicit, 2632 Mod->IsSystem, 2633 Mod->IsExternC, 2634 Mod->InferSubmodules, 2635 Mod->InferExplicitSubmodules, 2636 Mod->InferExportWildcard, 2637 Mod->ConfigMacrosExhaustive, 2638 Mod->ModuleMapIsPrivate}; 2639 Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name); 2640 } 2641 2642 // Emit the requirements. 2643 for (const auto &R : Mod->Requirements) { 2644 RecordData::value_type Record[] = {SUBMODULE_REQUIRES, R.second}; 2645 Stream.EmitRecordWithBlob(RequiresAbbrev, Record, R.first); 2646 } 2647 2648 // Emit the umbrella header, if there is one. 2649 if (auto UmbrellaHeader = Mod->getUmbrellaHeader()) { 2650 RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_HEADER}; 2651 Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record, 2652 UmbrellaHeader.NameAsWritten); 2653 } else if (auto UmbrellaDir = Mod->getUmbrellaDir()) { 2654 RecordData::value_type Record[] = {SUBMODULE_UMBRELLA_DIR}; 2655 Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record, 2656 UmbrellaDir.NameAsWritten); 2657 } 2658 2659 // Emit the headers. 2660 struct { 2661 unsigned RecordKind; 2662 unsigned Abbrev; 2663 Module::HeaderKind HeaderKind; 2664 } HeaderLists[] = { 2665 {SUBMODULE_HEADER, HeaderAbbrev, Module::HK_Normal}, 2666 {SUBMODULE_TEXTUAL_HEADER, TextualHeaderAbbrev, Module::HK_Textual}, 2667 {SUBMODULE_PRIVATE_HEADER, PrivateHeaderAbbrev, Module::HK_Private}, 2668 {SUBMODULE_PRIVATE_TEXTUAL_HEADER, PrivateTextualHeaderAbbrev, 2669 Module::HK_PrivateTextual}, 2670 {SUBMODULE_EXCLUDED_HEADER, ExcludedHeaderAbbrev, Module::HK_Excluded} 2671 }; 2672 for (auto &HL : HeaderLists) { 2673 RecordData::value_type Record[] = {HL.RecordKind}; 2674 for (auto &H : Mod->Headers[HL.HeaderKind]) 2675 Stream.EmitRecordWithBlob(HL.Abbrev, Record, H.NameAsWritten); 2676 } 2677 2678 // Emit the top headers. 2679 { 2680 auto TopHeaders = Mod->getTopHeaders(PP->getFileManager()); 2681 RecordData::value_type Record[] = {SUBMODULE_TOPHEADER}; 2682 for (auto *H : TopHeaders) 2683 Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record, H->getName()); 2684 } 2685 2686 // Emit the imports. 2687 if (!Mod->Imports.empty()) { 2688 RecordData Record; 2689 for (auto *I : Mod->Imports) 2690 Record.push_back(getSubmoduleID(I)); 2691 Stream.EmitRecord(SUBMODULE_IMPORTS, Record); 2692 } 2693 2694 // Emit the exports. 2695 if (!Mod->Exports.empty()) { 2696 RecordData Record; 2697 for (const auto &E : Mod->Exports) { 2698 // FIXME: This may fail; we don't require that all exported modules 2699 // are local or imported. 2700 Record.push_back(getSubmoduleID(E.getPointer())); 2701 Record.push_back(E.getInt()); 2702 } 2703 Stream.EmitRecord(SUBMODULE_EXPORTS, Record); 2704 } 2705 2706 //FIXME: How do we emit the 'use'd modules? They may not be submodules. 2707 // Might be unnecessary as use declarations are only used to build the 2708 // module itself. 2709 2710 // Emit the link libraries. 2711 for (const auto &LL : Mod->LinkLibraries) { 2712 RecordData::value_type Record[] = {SUBMODULE_LINK_LIBRARY, 2713 LL.IsFramework}; 2714 Stream.EmitRecordWithBlob(LinkLibraryAbbrev, Record, LL.Library); 2715 } 2716 2717 // Emit the conflicts. 2718 for (const auto &C : Mod->Conflicts) { 2719 // FIXME: This may fail; we don't require that all conflicting modules 2720 // are local or imported. 2721 RecordData::value_type Record[] = {SUBMODULE_CONFLICT, 2722 getSubmoduleID(C.Other)}; 2723 Stream.EmitRecordWithBlob(ConflictAbbrev, Record, C.Message); 2724 } 2725 2726 // Emit the configuration macros. 2727 for (const auto &CM : Mod->ConfigMacros) { 2728 RecordData::value_type Record[] = {SUBMODULE_CONFIG_MACRO}; 2729 Stream.EmitRecordWithBlob(ConfigMacroAbbrev, Record, CM); 2730 } 2731 2732 // Emit the initializers, if any. 2733 RecordData Inits; 2734 for (Decl *D : Context->getModuleInitializers(Mod)) 2735 Inits.push_back(GetDeclRef(D)); 2736 if (!Inits.empty()) 2737 Stream.EmitRecord(SUBMODULE_INITIALIZERS, Inits); 2738 2739 // Emit the name of the re-exported module, if any. 2740 if (!Mod->ExportAsModule.empty()) { 2741 RecordData::value_type Record[] = {SUBMODULE_EXPORT_AS}; 2742 Stream.EmitRecordWithBlob(ExportAsAbbrev, Record, Mod->ExportAsModule); 2743 } 2744 2745 // Queue up the submodules of this module. 2746 for (auto *M : Mod->submodules()) 2747 Q.push(M); 2748 } 2749 2750 Stream.ExitBlock(); 2751 2752 assert((NextSubmoduleID - FirstSubmoduleID == 2753 getNumberOfModules(WritingModule)) && 2754 "Wrong # of submodules; found a reference to a non-local, " 2755 "non-imported submodule?"); 2756 } 2757 2758 void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag, 2759 bool isModule) { 2760 llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64> 2761 DiagStateIDMap; 2762 unsigned CurrID = 0; 2763 RecordData Record; 2764 2765 auto EncodeDiagStateFlags = 2766 [](const DiagnosticsEngine::DiagState *DS) -> unsigned { 2767 unsigned Result = (unsigned)DS->ExtBehavior; 2768 for (unsigned Val : 2769 {(unsigned)DS->IgnoreAllWarnings, (unsigned)DS->EnableAllWarnings, 2770 (unsigned)DS->WarningsAsErrors, (unsigned)DS->ErrorsAsFatal, 2771 (unsigned)DS->SuppressSystemWarnings}) 2772 Result = (Result << 1) | Val; 2773 return Result; 2774 }; 2775 2776 unsigned Flags = EncodeDiagStateFlags(Diag.DiagStatesByLoc.FirstDiagState); 2777 Record.push_back(Flags); 2778 2779 auto AddDiagState = [&](const DiagnosticsEngine::DiagState *State, 2780 bool IncludeNonPragmaStates) { 2781 // Ensure that the diagnostic state wasn't modified since it was created. 2782 // We will not correctly round-trip this information otherwise. 2783 assert(Flags == EncodeDiagStateFlags(State) && 2784 "diag state flags vary in single AST file"); 2785 2786 unsigned &DiagStateID = DiagStateIDMap[State]; 2787 Record.push_back(DiagStateID); 2788 2789 if (DiagStateID == 0) { 2790 DiagStateID = ++CurrID; 2791 2792 // Add a placeholder for the number of mappings. 2793 auto SizeIdx = Record.size(); 2794 Record.emplace_back(); 2795 for (const auto &I : *State) { 2796 if (I.second.isPragma() || IncludeNonPragmaStates) { 2797 Record.push_back(I.first); 2798 Record.push_back(I.second.serialize()); 2799 } 2800 } 2801 // Update the placeholder. 2802 Record[SizeIdx] = (Record.size() - SizeIdx) / 2; 2803 } 2804 }; 2805 2806 AddDiagState(Diag.DiagStatesByLoc.FirstDiagState, isModule); 2807 2808 // Reserve a spot for the number of locations with state transitions. 2809 auto NumLocationsIdx = Record.size(); 2810 Record.emplace_back(); 2811 2812 // Emit the state transitions. 2813 unsigned NumLocations = 0; 2814 for (auto &FileIDAndFile : Diag.DiagStatesByLoc.Files) { 2815 if (!FileIDAndFile.first.isValid() || 2816 !FileIDAndFile.second.HasLocalTransitions) 2817 continue; 2818 ++NumLocations; 2819 2820 SourceLocation Loc = Diag.SourceMgr->getComposedLoc(FileIDAndFile.first, 0); 2821 assert(!Loc.isInvalid() && "start loc for valid FileID is invalid"); 2822 AddSourceLocation(Loc, Record); 2823 2824 Record.push_back(FileIDAndFile.second.StateTransitions.size()); 2825 for (auto &StatePoint : FileIDAndFile.second.StateTransitions) { 2826 Record.push_back(StatePoint.Offset); 2827 AddDiagState(StatePoint.State, false); 2828 } 2829 } 2830 2831 // Backpatch the number of locations. 2832 Record[NumLocationsIdx] = NumLocations; 2833 2834 // Emit CurDiagStateLoc. Do it last in order to match source order. 2835 // 2836 // This also protects against a hypothetical corner case with simulating 2837 // -Werror settings for implicit modules in the ASTReader, where reading 2838 // CurDiagState out of context could change whether warning pragmas are 2839 // treated as errors. 2840 AddSourceLocation(Diag.DiagStatesByLoc.CurDiagStateLoc, Record); 2841 AddDiagState(Diag.DiagStatesByLoc.CurDiagState, false); 2842 2843 Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record); 2844 } 2845 2846 //===----------------------------------------------------------------------===// 2847 // Type Serialization 2848 //===----------------------------------------------------------------------===// 2849 2850 /// Write the representation of a type to the AST stream. 2851 void ASTWriter::WriteType(QualType T) { 2852 TypeIdx &IdxRef = TypeIdxs[T]; 2853 if (IdxRef.getIndex() == 0) // we haven't seen this type before. 2854 IdxRef = TypeIdx(NextTypeID++); 2855 TypeIdx Idx = IdxRef; 2856 2857 assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST"); 2858 2859 // Emit the type's representation. 2860 uint64_t Offset = ASTTypeWriter(*this).write(T) - DeclTypesBlockStartOffset; 2861 2862 // Record the offset for this type. 2863 unsigned Index = Idx.getIndex() - FirstTypeID; 2864 if (TypeOffsets.size() == Index) 2865 TypeOffsets.emplace_back(Offset); 2866 else if (TypeOffsets.size() < Index) { 2867 TypeOffsets.resize(Index + 1); 2868 TypeOffsets[Index].setBitOffset(Offset); 2869 } else { 2870 llvm_unreachable("Types emitted in wrong order"); 2871 } 2872 } 2873 2874 //===----------------------------------------------------------------------===// 2875 // Declaration Serialization 2876 //===----------------------------------------------------------------------===// 2877 2878 /// Write the block containing all of the declaration IDs 2879 /// lexically declared within the given DeclContext. 2880 /// 2881 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the 2882 /// bitstream, or 0 if no block was written. 2883 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, 2884 DeclContext *DC) { 2885 if (DC->decls_empty()) 2886 return 0; 2887 2888 uint64_t Offset = Stream.GetCurrentBitNo(); 2889 SmallVector<uint32_t, 128> KindDeclPairs; 2890 for (const auto *D : DC->decls()) { 2891 KindDeclPairs.push_back(D->getKind()); 2892 KindDeclPairs.push_back(GetDeclRef(D)); 2893 } 2894 2895 ++NumLexicalDeclContexts; 2896 RecordData::value_type Record[] = {DECL_CONTEXT_LEXICAL}; 2897 Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, 2898 bytes(KindDeclPairs)); 2899 return Offset; 2900 } 2901 2902 void ASTWriter::WriteTypeDeclOffsets() { 2903 using namespace llvm; 2904 2905 // Write the type offsets array 2906 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2907 Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET)); 2908 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types 2909 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index 2910 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block 2911 unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2912 { 2913 RecordData::value_type Record[] = {TYPE_OFFSET, TypeOffsets.size(), 2914 FirstTypeID - NUM_PREDEF_TYPE_IDS}; 2915 Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, bytes(TypeOffsets)); 2916 } 2917 2918 // Write the declaration offsets array 2919 Abbrev = std::make_shared<BitCodeAbbrev>(); 2920 Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET)); 2921 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations 2922 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID 2923 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block 2924 unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 2925 { 2926 RecordData::value_type Record[] = {DECL_OFFSET, DeclOffsets.size(), 2927 FirstDeclID - NUM_PREDEF_DECL_IDS}; 2928 Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, bytes(DeclOffsets)); 2929 } 2930 } 2931 2932 void ASTWriter::WriteFileDeclIDsMap() { 2933 using namespace llvm; 2934 2935 SmallVector<std::pair<FileID, DeclIDInFileInfo *>, 64> SortedFileDeclIDs; 2936 SortedFileDeclIDs.reserve(FileDeclIDs.size()); 2937 for (const auto &P : FileDeclIDs) 2938 SortedFileDeclIDs.push_back(std::make_pair(P.first, P.second.get())); 2939 llvm::sort(SortedFileDeclIDs, llvm::less_first()); 2940 2941 // Join the vectors of DeclIDs from all files. 2942 SmallVector<DeclID, 256> FileGroupedDeclIDs; 2943 for (auto &FileDeclEntry : SortedFileDeclIDs) { 2944 DeclIDInFileInfo &Info = *FileDeclEntry.second; 2945 Info.FirstDeclIndex = FileGroupedDeclIDs.size(); 2946 for (auto &LocDeclEntry : Info.DeclIDs) 2947 FileGroupedDeclIDs.push_back(LocDeclEntry.second); 2948 } 2949 2950 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 2951 Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS)); 2952 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 2953 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 2954 unsigned AbbrevCode = Stream.EmitAbbrev(std::move(Abbrev)); 2955 RecordData::value_type Record[] = {FILE_SORTED_DECLS, 2956 FileGroupedDeclIDs.size()}; 2957 Stream.EmitRecordWithBlob(AbbrevCode, Record, bytes(FileGroupedDeclIDs)); 2958 } 2959 2960 void ASTWriter::WriteComments() { 2961 Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3); 2962 auto _ = llvm::make_scope_exit([this] { Stream.ExitBlock(); }); 2963 if (!PP->getPreprocessorOpts().WriteCommentListToPCH) 2964 return; 2965 RecordData Record; 2966 for (const auto &FO : Context->Comments.OrderedComments) { 2967 for (const auto &OC : FO.second) { 2968 const RawComment *I = OC.second; 2969 Record.clear(); 2970 AddSourceRange(I->getSourceRange(), Record); 2971 Record.push_back(I->getKind()); 2972 Record.push_back(I->isTrailingComment()); 2973 Record.push_back(I->isAlmostTrailingComment()); 2974 Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record); 2975 } 2976 } 2977 } 2978 2979 //===----------------------------------------------------------------------===// 2980 // Global Method Pool and Selector Serialization 2981 //===----------------------------------------------------------------------===// 2982 2983 namespace { 2984 2985 // Trait used for the on-disk hash table used in the method pool. 2986 class ASTMethodPoolTrait { 2987 ASTWriter &Writer; 2988 2989 public: 2990 using key_type = Selector; 2991 using key_type_ref = key_type; 2992 2993 struct data_type { 2994 SelectorID ID; 2995 ObjCMethodList Instance, Factory; 2996 }; 2997 using data_type_ref = const data_type &; 2998 2999 using hash_value_type = unsigned; 3000 using offset_type = unsigned; 3001 3002 explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) {} 3003 3004 static hash_value_type ComputeHash(Selector Sel) { 3005 return serialization::ComputeHash(Sel); 3006 } 3007 3008 std::pair<unsigned, unsigned> 3009 EmitKeyDataLength(raw_ostream& Out, Selector Sel, 3010 data_type_ref Methods) { 3011 using namespace llvm::support; 3012 3013 endian::Writer LE(Out, little); 3014 unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); 3015 LE.write<uint16_t>(KeyLen); 3016 unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts 3017 for (const ObjCMethodList *Method = &Methods.Instance; Method; 3018 Method = Method->getNext()) 3019 if (Method->getMethod()) 3020 DataLen += 4; 3021 for (const ObjCMethodList *Method = &Methods.Factory; Method; 3022 Method = Method->getNext()) 3023 if (Method->getMethod()) 3024 DataLen += 4; 3025 LE.write<uint16_t>(DataLen); 3026 return std::make_pair(KeyLen, DataLen); 3027 } 3028 3029 void EmitKey(raw_ostream& Out, Selector Sel, unsigned) { 3030 using namespace llvm::support; 3031 3032 endian::Writer LE(Out, little); 3033 uint64_t Start = Out.tell(); 3034 assert((Start >> 32) == 0 && "Selector key offset too large"); 3035 Writer.SetSelectorOffset(Sel, Start); 3036 unsigned N = Sel.getNumArgs(); 3037 LE.write<uint16_t>(N); 3038 if (N == 0) 3039 N = 1; 3040 for (unsigned I = 0; I != N; ++I) 3041 LE.write<uint32_t>( 3042 Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); 3043 } 3044 3045 void EmitData(raw_ostream& Out, key_type_ref, 3046 data_type_ref Methods, unsigned DataLen) { 3047 using namespace llvm::support; 3048 3049 endian::Writer LE(Out, little); 3050 uint64_t Start = Out.tell(); (void)Start; 3051 LE.write<uint32_t>(Methods.ID); 3052 unsigned NumInstanceMethods = 0; 3053 for (const ObjCMethodList *Method = &Methods.Instance; Method; 3054 Method = Method->getNext()) 3055 if (Method->getMethod()) 3056 ++NumInstanceMethods; 3057 3058 unsigned NumFactoryMethods = 0; 3059 for (const ObjCMethodList *Method = &Methods.Factory; Method; 3060 Method = Method->getNext()) 3061 if (Method->getMethod()) 3062 ++NumFactoryMethods; 3063 3064 unsigned InstanceBits = Methods.Instance.getBits(); 3065 assert(InstanceBits < 4); 3066 unsigned InstanceHasMoreThanOneDeclBit = 3067 Methods.Instance.hasMoreThanOneDecl(); 3068 unsigned FullInstanceBits = (NumInstanceMethods << 3) | 3069 (InstanceHasMoreThanOneDeclBit << 2) | 3070 InstanceBits; 3071 unsigned FactoryBits = Methods.Factory.getBits(); 3072 assert(FactoryBits < 4); 3073 unsigned FactoryHasMoreThanOneDeclBit = 3074 Methods.Factory.hasMoreThanOneDecl(); 3075 unsigned FullFactoryBits = (NumFactoryMethods << 3) | 3076 (FactoryHasMoreThanOneDeclBit << 2) | 3077 FactoryBits; 3078 LE.write<uint16_t>(FullInstanceBits); 3079 LE.write<uint16_t>(FullFactoryBits); 3080 for (const ObjCMethodList *Method = &Methods.Instance; Method; 3081 Method = Method->getNext()) 3082 if (Method->getMethod()) 3083 LE.write<uint32_t>(Writer.getDeclID(Method->getMethod())); 3084 for (const ObjCMethodList *Method = &Methods.Factory; Method; 3085 Method = Method->getNext()) 3086 if (Method->getMethod()) 3087 LE.write<uint32_t>(Writer.getDeclID(Method->getMethod())); 3088 3089 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 3090 } 3091 }; 3092 3093 } // namespace 3094 3095 /// Write ObjC data: selectors and the method pool. 3096 /// 3097 /// The method pool contains both instance and factory methods, stored 3098 /// in an on-disk hash table indexed by the selector. The hash table also 3099 /// contains an empty entry for every other selector known to Sema. 3100 void ASTWriter::WriteSelectors(Sema &SemaRef) { 3101 using namespace llvm; 3102 3103 // Do we have to do anything at all? 3104 if (SemaRef.MethodPool.empty() && SelectorIDs.empty()) 3105 return; 3106 unsigned NumTableEntries = 0; 3107 // Create and write out the blob that contains selectors and the method pool. 3108 { 3109 llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator; 3110 ASTMethodPoolTrait Trait(*this); 3111 3112 // Create the on-disk hash table representation. We walk through every 3113 // selector we've seen and look it up in the method pool. 3114 SelectorOffsets.resize(NextSelectorID - FirstSelectorID); 3115 for (auto &SelectorAndID : SelectorIDs) { 3116 Selector S = SelectorAndID.first; 3117 SelectorID ID = SelectorAndID.second; 3118 Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S); 3119 ASTMethodPoolTrait::data_type Data = { 3120 ID, 3121 ObjCMethodList(), 3122 ObjCMethodList() 3123 }; 3124 if (F != SemaRef.MethodPool.end()) { 3125 Data.Instance = F->second.first; 3126 Data.Factory = F->second.second; 3127 } 3128 // Only write this selector if it's not in an existing AST or something 3129 // changed. 3130 if (Chain && ID < FirstSelectorID) { 3131 // Selector already exists. Did it change? 3132 bool changed = false; 3133 for (ObjCMethodList *M = &Data.Instance; 3134 !changed && M && M->getMethod(); M = M->getNext()) { 3135 if (!M->getMethod()->isFromASTFile()) 3136 changed = true; 3137 } 3138 for (ObjCMethodList *M = &Data.Factory; !changed && M && M->getMethod(); 3139 M = M->getNext()) { 3140 if (!M->getMethod()->isFromASTFile()) 3141 changed = true; 3142 } 3143 if (!changed) 3144 continue; 3145 } else if (Data.Instance.getMethod() || Data.Factory.getMethod()) { 3146 // A new method pool entry. 3147 ++NumTableEntries; 3148 } 3149 Generator.insert(S, Data, Trait); 3150 } 3151 3152 // Create the on-disk hash table in a buffer. 3153 SmallString<4096> MethodPool; 3154 uint32_t BucketOffset; 3155 { 3156 using namespace llvm::support; 3157 3158 ASTMethodPoolTrait Trait(*this); 3159 llvm::raw_svector_ostream Out(MethodPool); 3160 // Make sure that no bucket is at offset 0 3161 endian::write<uint32_t>(Out, 0, little); 3162 BucketOffset = Generator.Emit(Out, Trait); 3163 } 3164 3165 // Create a blob abbreviation 3166 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 3167 Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL)); 3168 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3169 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3170 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3171 unsigned MethodPoolAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 3172 3173 // Write the method pool 3174 { 3175 RecordData::value_type Record[] = {METHOD_POOL, BucketOffset, 3176 NumTableEntries}; 3177 Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool); 3178 } 3179 3180 // Create a blob abbreviation for the selector table offsets. 3181 Abbrev = std::make_shared<BitCodeAbbrev>(); 3182 Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS)); 3183 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size 3184 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 3185 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3186 unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 3187 3188 // Write the selector offsets table. 3189 { 3190 RecordData::value_type Record[] = { 3191 SELECTOR_OFFSETS, SelectorOffsets.size(), 3192 FirstSelectorID - NUM_PREDEF_SELECTOR_IDS}; 3193 Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record, 3194 bytes(SelectorOffsets)); 3195 } 3196 } 3197 } 3198 3199 /// Write the selectors referenced in @selector expression into AST file. 3200 void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) { 3201 using namespace llvm; 3202 3203 if (SemaRef.ReferencedSelectors.empty()) 3204 return; 3205 3206 RecordData Record; 3207 ASTRecordWriter Writer(*this, Record); 3208 3209 // Note: this writes out all references even for a dependent AST. But it is 3210 // very tricky to fix, and given that @selector shouldn't really appear in 3211 // headers, probably not worth it. It's not a correctness issue. 3212 for (auto &SelectorAndLocation : SemaRef.ReferencedSelectors) { 3213 Selector Sel = SelectorAndLocation.first; 3214 SourceLocation Loc = SelectorAndLocation.second; 3215 Writer.AddSelectorRef(Sel); 3216 Writer.AddSourceLocation(Loc); 3217 } 3218 Writer.Emit(REFERENCED_SELECTOR_POOL); 3219 } 3220 3221 //===----------------------------------------------------------------------===// 3222 // Identifier Table Serialization 3223 //===----------------------------------------------------------------------===// 3224 3225 /// Determine the declaration that should be put into the name lookup table to 3226 /// represent the given declaration in this module. This is usually D itself, 3227 /// but if D was imported and merged into a local declaration, we want the most 3228 /// recent local declaration instead. The chosen declaration will be the most 3229 /// recent declaration in any module that imports this one. 3230 static NamedDecl *getDeclForLocalLookup(const LangOptions &LangOpts, 3231 NamedDecl *D) { 3232 if (!LangOpts.Modules || !D->isFromASTFile()) 3233 return D; 3234 3235 if (Decl *Redecl = D->getPreviousDecl()) { 3236 // For Redeclarable decls, a prior declaration might be local. 3237 for (; Redecl; Redecl = Redecl->getPreviousDecl()) { 3238 // If we find a local decl, we're done. 3239 if (!Redecl->isFromASTFile()) { 3240 // Exception: in very rare cases (for injected-class-names), not all 3241 // redeclarations are in the same semantic context. Skip ones in a 3242 // different context. They don't go in this lookup table at all. 3243 if (!Redecl->getDeclContext()->getRedeclContext()->Equals( 3244 D->getDeclContext()->getRedeclContext())) 3245 continue; 3246 return cast<NamedDecl>(Redecl); 3247 } 3248 3249 // If we find a decl from a (chained-)PCH stop since we won't find a 3250 // local one. 3251 if (Redecl->getOwningModuleID() == 0) 3252 break; 3253 } 3254 } else if (Decl *First = D->getCanonicalDecl()) { 3255 // For Mergeable decls, the first decl might be local. 3256 if (!First->isFromASTFile()) 3257 return cast<NamedDecl>(First); 3258 } 3259 3260 // All declarations are imported. Our most recent declaration will also be 3261 // the most recent one in anyone who imports us. 3262 return D; 3263 } 3264 3265 namespace { 3266 3267 class ASTIdentifierTableTrait { 3268 ASTWriter &Writer; 3269 Preprocessor &PP; 3270 IdentifierResolver &IdResolver; 3271 bool IsModule; 3272 bool NeedDecls; 3273 ASTWriter::RecordData *InterestingIdentifierOffsets; 3274 3275 /// Determines whether this is an "interesting" identifier that needs a 3276 /// full IdentifierInfo structure written into the hash table. Notably, this 3277 /// doesn't check whether the name has macros defined; use PublicMacroIterator 3278 /// to check that. 3279 bool isInterestingIdentifier(const IdentifierInfo *II, uint64_t MacroOffset) { 3280 if (MacroOffset || II->isPoisoned() || 3281 (!IsModule && II->getObjCOrBuiltinID()) || 3282 II->hasRevertedTokenIDToIdentifier() || 3283 (NeedDecls && II->getFETokenInfo())) 3284 return true; 3285 3286 return false; 3287 } 3288 3289 public: 3290 using key_type = IdentifierInfo *; 3291 using key_type_ref = key_type; 3292 3293 using data_type = IdentID; 3294 using data_type_ref = data_type; 3295 3296 using hash_value_type = unsigned; 3297 using offset_type = unsigned; 3298 3299 ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP, 3300 IdentifierResolver &IdResolver, bool IsModule, 3301 ASTWriter::RecordData *InterestingIdentifierOffsets) 3302 : Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule), 3303 NeedDecls(!IsModule || !Writer.getLangOpts().CPlusPlus), 3304 InterestingIdentifierOffsets(InterestingIdentifierOffsets) {} 3305 3306 bool needDecls() const { return NeedDecls; } 3307 3308 static hash_value_type ComputeHash(const IdentifierInfo* II) { 3309 return llvm::djbHash(II->getName()); 3310 } 3311 3312 bool isInterestingIdentifier(const IdentifierInfo *II) { 3313 auto MacroOffset = Writer.getMacroDirectivesOffset(II); 3314 return isInterestingIdentifier(II, MacroOffset); 3315 } 3316 3317 bool isInterestingNonMacroIdentifier(const IdentifierInfo *II) { 3318 return isInterestingIdentifier(II, 0); 3319 } 3320 3321 std::pair<unsigned, unsigned> 3322 EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, IdentID ID) { 3323 unsigned KeyLen = II->getLength() + 1; 3324 unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 3325 auto MacroOffset = Writer.getMacroDirectivesOffset(II); 3326 if (isInterestingIdentifier(II, MacroOffset)) { 3327 DataLen += 2; // 2 bytes for builtin ID 3328 DataLen += 2; // 2 bytes for flags 3329 if (MacroOffset) 3330 DataLen += 4; // MacroDirectives offset. 3331 3332 if (NeedDecls) { 3333 for (IdentifierResolver::iterator D = IdResolver.begin(II), 3334 DEnd = IdResolver.end(); 3335 D != DEnd; ++D) 3336 DataLen += 4; 3337 } 3338 } 3339 3340 using namespace llvm::support; 3341 3342 endian::Writer LE(Out, little); 3343 3344 assert((uint16_t)DataLen == DataLen && (uint16_t)KeyLen == KeyLen); 3345 LE.write<uint16_t>(DataLen); 3346 // We emit the key length after the data length so that every 3347 // string is preceded by a 16-bit length. This matches the PTH 3348 // format for storing identifiers. 3349 LE.write<uint16_t>(KeyLen); 3350 return std::make_pair(KeyLen, DataLen); 3351 } 3352 3353 void EmitKey(raw_ostream& Out, const IdentifierInfo* II, 3354 unsigned KeyLen) { 3355 // Record the location of the key data. This is used when generating 3356 // the mapping from persistent IDs to strings. 3357 Writer.SetIdentifierOffset(II, Out.tell()); 3358 3359 // Emit the offset of the key/data length information to the interesting 3360 // identifiers table if necessary. 3361 if (InterestingIdentifierOffsets && isInterestingIdentifier(II)) 3362 InterestingIdentifierOffsets->push_back(Out.tell() - 4); 3363 3364 Out.write(II->getNameStart(), KeyLen); 3365 } 3366 3367 void EmitData(raw_ostream& Out, IdentifierInfo* II, 3368 IdentID ID, unsigned) { 3369 using namespace llvm::support; 3370 3371 endian::Writer LE(Out, little); 3372 3373 auto MacroOffset = Writer.getMacroDirectivesOffset(II); 3374 if (!isInterestingIdentifier(II, MacroOffset)) { 3375 LE.write<uint32_t>(ID << 1); 3376 return; 3377 } 3378 3379 LE.write<uint32_t>((ID << 1) | 0x01); 3380 uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID(); 3381 assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader."); 3382 LE.write<uint16_t>(Bits); 3383 Bits = 0; 3384 bool HadMacroDefinition = MacroOffset != 0; 3385 Bits = (Bits << 1) | unsigned(HadMacroDefinition); 3386 Bits = (Bits << 1) | unsigned(II->isExtensionToken()); 3387 Bits = (Bits << 1) | unsigned(II->isPoisoned()); 3388 Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier()); 3389 Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword()); 3390 LE.write<uint16_t>(Bits); 3391 3392 if (HadMacroDefinition) 3393 LE.write<uint32_t>(MacroOffset); 3394 3395 if (NeedDecls) { 3396 // Emit the declaration IDs in reverse order, because the 3397 // IdentifierResolver provides the declarations as they would be 3398 // visible (e.g., the function "stat" would come before the struct 3399 // "stat"), but the ASTReader adds declarations to the end of the list 3400 // (so we need to see the struct "stat" before the function "stat"). 3401 // Only emit declarations that aren't from a chained PCH, though. 3402 SmallVector<NamedDecl *, 16> Decls(IdResolver.begin(II), 3403 IdResolver.end()); 3404 for (SmallVectorImpl<NamedDecl *>::reverse_iterator D = Decls.rbegin(), 3405 DEnd = Decls.rend(); 3406 D != DEnd; ++D) 3407 LE.write<uint32_t>( 3408 Writer.getDeclID(getDeclForLocalLookup(PP.getLangOpts(), *D))); 3409 } 3410 } 3411 }; 3412 3413 } // namespace 3414 3415 /// Write the identifier table into the AST file. 3416 /// 3417 /// The identifier table consists of a blob containing string data 3418 /// (the actual identifiers themselves) and a separate "offsets" index 3419 /// that maps identifier IDs to locations within the blob. 3420 void ASTWriter::WriteIdentifierTable(Preprocessor &PP, 3421 IdentifierResolver &IdResolver, 3422 bool IsModule) { 3423 using namespace llvm; 3424 3425 RecordData InterestingIdents; 3426 3427 // Create and write out the blob that contains the identifier 3428 // strings. 3429 { 3430 llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator; 3431 ASTIdentifierTableTrait Trait( 3432 *this, PP, IdResolver, IsModule, 3433 (getLangOpts().CPlusPlus && IsModule) ? &InterestingIdents : nullptr); 3434 3435 // Look for any identifiers that were named while processing the 3436 // headers, but are otherwise not needed. We add these to the hash 3437 // table to enable checking of the predefines buffer in the case 3438 // where the user adds new macro definitions when building the AST 3439 // file. 3440 SmallVector<const IdentifierInfo *, 128> IIs; 3441 for (const auto &ID : PP.getIdentifierTable()) 3442 IIs.push_back(ID.second); 3443 // Sort the identifiers lexicographically before getting them references so 3444 // that their order is stable. 3445 llvm::sort(IIs, llvm::deref<std::less<>>()); 3446 for (const IdentifierInfo *II : IIs) 3447 if (Trait.isInterestingNonMacroIdentifier(II)) 3448 getIdentifierRef(II); 3449 3450 // Create the on-disk hash table representation. We only store offsets 3451 // for identifiers that appear here for the first time. 3452 IdentifierOffsets.resize(NextIdentID - FirstIdentID); 3453 for (auto IdentIDPair : IdentifierIDs) { 3454 auto *II = const_cast<IdentifierInfo *>(IdentIDPair.first); 3455 IdentID ID = IdentIDPair.second; 3456 assert(II && "NULL identifier in identifier table"); 3457 // Write out identifiers if either the ID is local or the identifier has 3458 // changed since it was loaded. 3459 if (ID >= FirstIdentID || !Chain || !II->isFromAST() 3460 || II->hasChangedSinceDeserialization() || 3461 (Trait.needDecls() && 3462 II->hasFETokenInfoChangedSinceDeserialization())) 3463 Generator.insert(II, ID, Trait); 3464 } 3465 3466 // Create the on-disk hash table in a buffer. 3467 SmallString<4096> IdentifierTable; 3468 uint32_t BucketOffset; 3469 { 3470 using namespace llvm::support; 3471 3472 llvm::raw_svector_ostream Out(IdentifierTable); 3473 // Make sure that no bucket is at offset 0 3474 endian::write<uint32_t>(Out, 0, little); 3475 BucketOffset = Generator.Emit(Out, Trait); 3476 } 3477 3478 // Create a blob abbreviation 3479 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 3480 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE)); 3481 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 3482 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3483 unsigned IDTableAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 3484 3485 // Write the identifier table 3486 RecordData::value_type Record[] = {IDENTIFIER_TABLE, BucketOffset}; 3487 Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable); 3488 } 3489 3490 // Write the offsets table for identifier IDs. 3491 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 3492 Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET)); 3493 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers 3494 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID 3495 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 3496 unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 3497 3498 #ifndef NDEBUG 3499 for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I) 3500 assert(IdentifierOffsets[I] && "Missing identifier offset?"); 3501 #endif 3502 3503 RecordData::value_type Record[] = {IDENTIFIER_OFFSET, 3504 IdentifierOffsets.size(), 3505 FirstIdentID - NUM_PREDEF_IDENT_IDS}; 3506 Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record, 3507 bytes(IdentifierOffsets)); 3508 3509 // In C++, write the list of interesting identifiers (those that are 3510 // defined as macros, poisoned, or similar unusual things). 3511 if (!InterestingIdents.empty()) 3512 Stream.EmitRecord(INTERESTING_IDENTIFIERS, InterestingIdents); 3513 } 3514 3515 //===----------------------------------------------------------------------===// 3516 // DeclContext's Name Lookup Table Serialization 3517 //===----------------------------------------------------------------------===// 3518 3519 namespace { 3520 3521 // Trait used for the on-disk hash table used in the method pool. 3522 class ASTDeclContextNameLookupTrait { 3523 ASTWriter &Writer; 3524 llvm::SmallVector<DeclID, 64> DeclIDs; 3525 3526 public: 3527 using key_type = DeclarationNameKey; 3528 using key_type_ref = key_type; 3529 3530 /// A start and end index into DeclIDs, representing a sequence of decls. 3531 using data_type = std::pair<unsigned, unsigned>; 3532 using data_type_ref = const data_type &; 3533 3534 using hash_value_type = unsigned; 3535 using offset_type = unsigned; 3536 3537 explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) {} 3538 3539 template<typename Coll> 3540 data_type getData(const Coll &Decls) { 3541 unsigned Start = DeclIDs.size(); 3542 for (NamedDecl *D : Decls) { 3543 DeclIDs.push_back( 3544 Writer.GetDeclRef(getDeclForLocalLookup(Writer.getLangOpts(), D))); 3545 } 3546 return std::make_pair(Start, DeclIDs.size()); 3547 } 3548 3549 data_type ImportData(const reader::ASTDeclContextNameLookupTrait::data_type &FromReader) { 3550 unsigned Start = DeclIDs.size(); 3551 for (auto ID : FromReader) 3552 DeclIDs.push_back(ID); 3553 return std::make_pair(Start, DeclIDs.size()); 3554 } 3555 3556 static bool EqualKey(key_type_ref a, key_type_ref b) { 3557 return a == b; 3558 } 3559 3560 hash_value_type ComputeHash(DeclarationNameKey Name) { 3561 return Name.getHash(); 3562 } 3563 3564 void EmitFileRef(raw_ostream &Out, ModuleFile *F) const { 3565 assert(Writer.hasChain() && 3566 "have reference to loaded module file but no chain?"); 3567 3568 using namespace llvm::support; 3569 3570 endian::write<uint32_t>(Out, Writer.getChain()->getModuleFileID(F), little); 3571 } 3572 3573 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out, 3574 DeclarationNameKey Name, 3575 data_type_ref Lookup) { 3576 using namespace llvm::support; 3577 3578 endian::Writer LE(Out, little); 3579 unsigned KeyLen = 1; 3580 switch (Name.getKind()) { 3581 case DeclarationName::Identifier: 3582 case DeclarationName::ObjCZeroArgSelector: 3583 case DeclarationName::ObjCOneArgSelector: 3584 case DeclarationName::ObjCMultiArgSelector: 3585 case DeclarationName::CXXLiteralOperatorName: 3586 case DeclarationName::CXXDeductionGuideName: 3587 KeyLen += 4; 3588 break; 3589 case DeclarationName::CXXOperatorName: 3590 KeyLen += 1; 3591 break; 3592 case DeclarationName::CXXConstructorName: 3593 case DeclarationName::CXXDestructorName: 3594 case DeclarationName::CXXConversionFunctionName: 3595 case DeclarationName::CXXUsingDirective: 3596 break; 3597 } 3598 LE.write<uint16_t>(KeyLen); 3599 3600 // 4 bytes for each DeclID. 3601 unsigned DataLen = 4 * (Lookup.second - Lookup.first); 3602 assert(uint16_t(DataLen) == DataLen && 3603 "too many decls for serialized lookup result"); 3604 LE.write<uint16_t>(DataLen); 3605 3606 return std::make_pair(KeyLen, DataLen); 3607 } 3608 3609 void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) { 3610 using namespace llvm::support; 3611 3612 endian::Writer LE(Out, little); 3613 LE.write<uint8_t>(Name.getKind()); 3614 switch (Name.getKind()) { 3615 case DeclarationName::Identifier: 3616 case DeclarationName::CXXLiteralOperatorName: 3617 case DeclarationName::CXXDeductionGuideName: 3618 LE.write<uint32_t>(Writer.getIdentifierRef(Name.getIdentifier())); 3619 return; 3620 case DeclarationName::ObjCZeroArgSelector: 3621 case DeclarationName::ObjCOneArgSelector: 3622 case DeclarationName::ObjCMultiArgSelector: 3623 LE.write<uint32_t>(Writer.getSelectorRef(Name.getSelector())); 3624 return; 3625 case DeclarationName::CXXOperatorName: 3626 assert(Name.getOperatorKind() < NUM_OVERLOADED_OPERATORS && 3627 "Invalid operator?"); 3628 LE.write<uint8_t>(Name.getOperatorKind()); 3629 return; 3630 case DeclarationName::CXXConstructorName: 3631 case DeclarationName::CXXDestructorName: 3632 case DeclarationName::CXXConversionFunctionName: 3633 case DeclarationName::CXXUsingDirective: 3634 return; 3635 } 3636 3637 llvm_unreachable("Invalid name kind?"); 3638 } 3639 3640 void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup, 3641 unsigned DataLen) { 3642 using namespace llvm::support; 3643 3644 endian::Writer LE(Out, little); 3645 uint64_t Start = Out.tell(); (void)Start; 3646 for (unsigned I = Lookup.first, N = Lookup.second; I != N; ++I) 3647 LE.write<uint32_t>(DeclIDs[I]); 3648 assert(Out.tell() - Start == DataLen && "Data length is wrong"); 3649 } 3650 }; 3651 3652 } // namespace 3653 3654 bool ASTWriter::isLookupResultExternal(StoredDeclsList &Result, 3655 DeclContext *DC) { 3656 return Result.hasExternalDecls() && 3657 DC->hasNeedToReconcileExternalVisibleStorage(); 3658 } 3659 3660 bool ASTWriter::isLookupResultEntirelyExternal(StoredDeclsList &Result, 3661 DeclContext *DC) { 3662 for (auto *D : Result.getLookupResult()) 3663 if (!getDeclForLocalLookup(getLangOpts(), D)->isFromASTFile()) 3664 return false; 3665 3666 return true; 3667 } 3668 3669 void 3670 ASTWriter::GenerateNameLookupTable(const DeclContext *ConstDC, 3671 llvm::SmallVectorImpl<char> &LookupTable) { 3672 assert(!ConstDC->hasLazyLocalLexicalLookups() && 3673 !ConstDC->hasLazyExternalLexicalLookups() && 3674 "must call buildLookups first"); 3675 3676 // FIXME: We need to build the lookups table, which is logically const. 3677 auto *DC = const_cast<DeclContext*>(ConstDC); 3678 assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table"); 3679 3680 // Create the on-disk hash table representation. 3681 MultiOnDiskHashTableGenerator<reader::ASTDeclContextNameLookupTrait, 3682 ASTDeclContextNameLookupTrait> Generator; 3683 ASTDeclContextNameLookupTrait Trait(*this); 3684 3685 // The first step is to collect the declaration names which we need to 3686 // serialize into the name lookup table, and to collect them in a stable 3687 // order. 3688 SmallVector<DeclarationName, 16> Names; 3689 3690 // We also build up small sets of the constructor and conversion function 3691 // names which are visible. 3692 llvm::SmallPtrSet<DeclarationName, 8> ConstructorNameSet, ConversionNameSet; 3693 3694 for (auto &Lookup : *DC->buildLookup()) { 3695 auto &Name = Lookup.first; 3696 auto &Result = Lookup.second; 3697 3698 // If there are no local declarations in our lookup result, we 3699 // don't need to write an entry for the name at all. If we can't 3700 // write out a lookup set without performing more deserialization, 3701 // just skip this entry. 3702 if (isLookupResultExternal(Result, DC) && 3703 isLookupResultEntirelyExternal(Result, DC)) 3704 continue; 3705 3706 // We also skip empty results. If any of the results could be external and 3707 // the currently available results are empty, then all of the results are 3708 // external and we skip it above. So the only way we get here with an empty 3709 // results is when no results could have been external *and* we have 3710 // external results. 3711 // 3712 // FIXME: While we might want to start emitting on-disk entries for negative 3713 // lookups into a decl context as an optimization, today we *have* to skip 3714 // them because there are names with empty lookup results in decl contexts 3715 // which we can't emit in any stable ordering: we lookup constructors and 3716 // conversion functions in the enclosing namespace scope creating empty 3717 // results for them. This in almost certainly a bug in Clang's name lookup, 3718 // but that is likely to be hard or impossible to fix and so we tolerate it 3719 // here by omitting lookups with empty results. 3720 if (Lookup.second.getLookupResult().empty()) 3721 continue; 3722 3723 switch (Lookup.first.getNameKind()) { 3724 default: 3725 Names.push_back(Lookup.first); 3726 break; 3727 3728 case DeclarationName::CXXConstructorName: 3729 assert(isa<CXXRecordDecl>(DC) && 3730 "Cannot have a constructor name outside of a class!"); 3731 ConstructorNameSet.insert(Name); 3732 break; 3733 3734 case DeclarationName::CXXConversionFunctionName: 3735 assert(isa<CXXRecordDecl>(DC) && 3736 "Cannot have a conversion function name outside of a class!"); 3737 ConversionNameSet.insert(Name); 3738 break; 3739 } 3740 } 3741 3742 // Sort the names into a stable order. 3743 llvm::sort(Names); 3744 3745 if (auto *D = dyn_cast<CXXRecordDecl>(DC)) { 3746 // We need to establish an ordering of constructor and conversion function 3747 // names, and they don't have an intrinsic ordering. 3748 3749 // First we try the easy case by forming the current context's constructor 3750 // name and adding that name first. This is a very useful optimization to 3751 // avoid walking the lexical declarations in many cases, and it also 3752 // handles the only case where a constructor name can come from some other 3753 // lexical context -- when that name is an implicit constructor merged from 3754 // another declaration in the redecl chain. Any non-implicit constructor or 3755 // conversion function which doesn't occur in all the lexical contexts 3756 // would be an ODR violation. 3757 auto ImplicitCtorName = Context->DeclarationNames.getCXXConstructorName( 3758 Context->getCanonicalType(Context->getRecordType(D))); 3759 if (ConstructorNameSet.erase(ImplicitCtorName)) 3760 Names.push_back(ImplicitCtorName); 3761 3762 // If we still have constructors or conversion functions, we walk all the 3763 // names in the decl and add the constructors and conversion functions 3764 // which are visible in the order they lexically occur within the context. 3765 if (!ConstructorNameSet.empty() || !ConversionNameSet.empty()) 3766 for (Decl *ChildD : cast<CXXRecordDecl>(DC)->decls()) 3767 if (auto *ChildND = dyn_cast<NamedDecl>(ChildD)) { 3768 auto Name = ChildND->getDeclName(); 3769 switch (Name.getNameKind()) { 3770 default: 3771 continue; 3772 3773 case DeclarationName::CXXConstructorName: 3774 if (ConstructorNameSet.erase(Name)) 3775 Names.push_back(Name); 3776 break; 3777 3778 case DeclarationName::CXXConversionFunctionName: 3779 if (ConversionNameSet.erase(Name)) 3780 Names.push_back(Name); 3781 break; 3782 } 3783 3784 if (ConstructorNameSet.empty() && ConversionNameSet.empty()) 3785 break; 3786 } 3787 3788 assert(ConstructorNameSet.empty() && "Failed to find all of the visible " 3789 "constructors by walking all the " 3790 "lexical members of the context."); 3791 assert(ConversionNameSet.empty() && "Failed to find all of the visible " 3792 "conversion functions by walking all " 3793 "the lexical members of the context."); 3794 } 3795 3796 // Next we need to do a lookup with each name into this decl context to fully 3797 // populate any results from external sources. We don't actually use the 3798 // results of these lookups because we only want to use the results after all 3799 // results have been loaded and the pointers into them will be stable. 3800 for (auto &Name : Names) 3801 DC->lookup(Name); 3802 3803 // Now we need to insert the results for each name into the hash table. For 3804 // constructor names and conversion function names, we actually need to merge 3805 // all of the results for them into one list of results each and insert 3806 // those. 3807 SmallVector<NamedDecl *, 8> ConstructorDecls; 3808 SmallVector<NamedDecl *, 8> ConversionDecls; 3809 3810 // Now loop over the names, either inserting them or appending for the two 3811 // special cases. 3812 for (auto &Name : Names) { 3813 DeclContext::lookup_result Result = DC->noload_lookup(Name); 3814 3815 switch (Name.getNameKind()) { 3816 default: 3817 Generator.insert(Name, Trait.getData(Result), Trait); 3818 break; 3819 3820 case DeclarationName::CXXConstructorName: 3821 ConstructorDecls.append(Result.begin(), Result.end()); 3822 break; 3823 3824 case DeclarationName::CXXConversionFunctionName: 3825 ConversionDecls.append(Result.begin(), Result.end()); 3826 break; 3827 } 3828 } 3829 3830 // Handle our two special cases if we ended up having any. We arbitrarily use 3831 // the first declaration's name here because the name itself isn't part of 3832 // the key, only the kind of name is used. 3833 if (!ConstructorDecls.empty()) 3834 Generator.insert(ConstructorDecls.front()->getDeclName(), 3835 Trait.getData(ConstructorDecls), Trait); 3836 if (!ConversionDecls.empty()) 3837 Generator.insert(ConversionDecls.front()->getDeclName(), 3838 Trait.getData(ConversionDecls), Trait); 3839 3840 // Create the on-disk hash table. Also emit the existing imported and 3841 // merged table if there is one. 3842 auto *Lookups = Chain ? Chain->getLoadedLookupTables(DC) : nullptr; 3843 Generator.emit(LookupTable, Trait, Lookups ? &Lookups->Table : nullptr); 3844 } 3845 3846 /// Write the block containing all of the declaration IDs 3847 /// visible from the given DeclContext. 3848 /// 3849 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the 3850 /// bitstream, or 0 if no block was written. 3851 uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context, 3852 DeclContext *DC) { 3853 // If we imported a key declaration of this namespace, write the visible 3854 // lookup results as an update record for it rather than including them 3855 // on this declaration. We will only look at key declarations on reload. 3856 if (isa<NamespaceDecl>(DC) && Chain && 3857 Chain->getKeyDeclaration(cast<Decl>(DC))->isFromASTFile()) { 3858 // Only do this once, for the first local declaration of the namespace. 3859 for (auto *Prev = cast<NamespaceDecl>(DC)->getPreviousDecl(); Prev; 3860 Prev = Prev->getPreviousDecl()) 3861 if (!Prev->isFromASTFile()) 3862 return 0; 3863 3864 // Note that we need to emit an update record for the primary context. 3865 UpdatedDeclContexts.insert(DC->getPrimaryContext()); 3866 3867 // Make sure all visible decls are written. They will be recorded later. We 3868 // do this using a side data structure so we can sort the names into 3869 // a deterministic order. 3870 StoredDeclsMap *Map = DC->getPrimaryContext()->buildLookup(); 3871 SmallVector<std::pair<DeclarationName, DeclContext::lookup_result>, 16> 3872 LookupResults; 3873 if (Map) { 3874 LookupResults.reserve(Map->size()); 3875 for (auto &Entry : *Map) 3876 LookupResults.push_back( 3877 std::make_pair(Entry.first, Entry.second.getLookupResult())); 3878 } 3879 3880 llvm::sort(LookupResults, llvm::less_first()); 3881 for (auto &NameAndResult : LookupResults) { 3882 DeclarationName Name = NameAndResult.first; 3883 DeclContext::lookup_result Result = NameAndResult.second; 3884 if (Name.getNameKind() == DeclarationName::CXXConstructorName || 3885 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 3886 // We have to work around a name lookup bug here where negative lookup 3887 // results for these names get cached in namespace lookup tables (these 3888 // names should never be looked up in a namespace). 3889 assert(Result.empty() && "Cannot have a constructor or conversion " 3890 "function name in a namespace!"); 3891 continue; 3892 } 3893 3894 for (NamedDecl *ND : Result) 3895 if (!ND->isFromASTFile()) 3896 GetDeclRef(ND); 3897 } 3898 3899 return 0; 3900 } 3901 3902 if (DC->getPrimaryContext() != DC) 3903 return 0; 3904 3905 // Skip contexts which don't support name lookup. 3906 if (!DC->isLookupContext()) 3907 return 0; 3908 3909 // If not in C++, we perform name lookup for the translation unit via the 3910 // IdentifierInfo chains, don't bother to build a visible-declarations table. 3911 if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus) 3912 return 0; 3913 3914 // Serialize the contents of the mapping used for lookup. Note that, 3915 // although we have two very different code paths, the serialized 3916 // representation is the same for both cases: a declaration name, 3917 // followed by a size, followed by references to the visible 3918 // declarations that have that name. 3919 uint64_t Offset = Stream.GetCurrentBitNo(); 3920 StoredDeclsMap *Map = DC->buildLookup(); 3921 if (!Map || Map->empty()) 3922 return 0; 3923 3924 // Create the on-disk hash table in a buffer. 3925 SmallString<4096> LookupTable; 3926 GenerateNameLookupTable(DC, LookupTable); 3927 3928 // Write the lookup table 3929 RecordData::value_type Record[] = {DECL_CONTEXT_VISIBLE}; 3930 Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record, 3931 LookupTable); 3932 ++NumVisibleDeclContexts; 3933 return Offset; 3934 } 3935 3936 /// Write an UPDATE_VISIBLE block for the given context. 3937 /// 3938 /// UPDATE_VISIBLE blocks contain the declarations that are added to an existing 3939 /// DeclContext in a dependent AST file. As such, they only exist for the TU 3940 /// (in C++), for namespaces, and for classes with forward-declared unscoped 3941 /// enumeration members (in C++11). 3942 void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) { 3943 StoredDeclsMap *Map = DC->getLookupPtr(); 3944 if (!Map || Map->empty()) 3945 return; 3946 3947 // Create the on-disk hash table in a buffer. 3948 SmallString<4096> LookupTable; 3949 GenerateNameLookupTable(DC, LookupTable); 3950 3951 // If we're updating a namespace, select a key declaration as the key for the 3952 // update record; those are the only ones that will be checked on reload. 3953 if (isa<NamespaceDecl>(DC)) 3954 DC = cast<DeclContext>(Chain->getKeyDeclaration(cast<Decl>(DC))); 3955 3956 // Write the lookup table 3957 RecordData::value_type Record[] = {UPDATE_VISIBLE, getDeclID(cast<Decl>(DC))}; 3958 Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable); 3959 } 3960 3961 /// Write an FP_PRAGMA_OPTIONS block for the given FPOptions. 3962 void ASTWriter::WriteFPPragmaOptions(const FPOptionsOverride &Opts) { 3963 RecordData::value_type Record[] = {Opts.getAsOpaqueInt()}; 3964 Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record); 3965 } 3966 3967 /// Write an OPENCL_EXTENSIONS block for the given OpenCLOptions. 3968 void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) { 3969 if (!SemaRef.Context.getLangOpts().OpenCL) 3970 return; 3971 3972 const OpenCLOptions &Opts = SemaRef.getOpenCLOptions(); 3973 RecordData Record; 3974 for (const auto &I:Opts.OptMap) { 3975 AddString(I.getKey(), Record); 3976 auto V = I.getValue(); 3977 Record.push_back(V.Supported ? 1 : 0); 3978 Record.push_back(V.Enabled ? 1 : 0); 3979 Record.push_back(V.Avail); 3980 Record.push_back(V.Core); 3981 Record.push_back(V.Opt); 3982 } 3983 Stream.EmitRecord(OPENCL_EXTENSIONS, Record); 3984 } 3985 3986 void ASTWriter::WriteOpenCLExtensionTypes(Sema &SemaRef) { 3987 if (!SemaRef.Context.getLangOpts().OpenCL) 3988 return; 3989 3990 // Sort the elements of the map OpenCLTypeExtMap by TypeIDs, 3991 // without copying them. 3992 const llvm::DenseMap<const Type *, std::set<std::string>> &OpenCLTypeExtMap = 3993 SemaRef.OpenCLTypeExtMap; 3994 using ElementTy = std::pair<TypeID, const std::set<std::string> *>; 3995 llvm::SmallVector<ElementTy, 8> StableOpenCLTypeExtMap; 3996 StableOpenCLTypeExtMap.reserve(OpenCLTypeExtMap.size()); 3997 3998 for (const auto &I : OpenCLTypeExtMap) 3999 StableOpenCLTypeExtMap.emplace_back( 4000 getTypeID(I.first->getCanonicalTypeInternal()), &I.second); 4001 4002 auto CompareByTypeID = [](const ElementTy &E1, const ElementTy &E2) -> bool { 4003 return E1.first < E2.first; 4004 }; 4005 llvm::sort(StableOpenCLTypeExtMap, CompareByTypeID); 4006 4007 RecordData Record; 4008 for (const ElementTy &E : StableOpenCLTypeExtMap) { 4009 Record.push_back(E.first); // TypeID 4010 const std::set<std::string> *ExtSet = E.second; 4011 Record.push_back(static_cast<unsigned>(ExtSet->size())); 4012 for (const std::string &Ext : *ExtSet) 4013 AddString(Ext, Record); 4014 } 4015 4016 Stream.EmitRecord(OPENCL_EXTENSION_TYPES, Record); 4017 } 4018 4019 void ASTWriter::WriteOpenCLExtensionDecls(Sema &SemaRef) { 4020 if (!SemaRef.Context.getLangOpts().OpenCL) 4021 return; 4022 4023 // Sort the elements of the map OpenCLDeclExtMap by DeclIDs, 4024 // without copying them. 4025 const llvm::DenseMap<const Decl *, std::set<std::string>> &OpenCLDeclExtMap = 4026 SemaRef.OpenCLDeclExtMap; 4027 using ElementTy = std::pair<DeclID, const std::set<std::string> *>; 4028 llvm::SmallVector<ElementTy, 8> StableOpenCLDeclExtMap; 4029 StableOpenCLDeclExtMap.reserve(OpenCLDeclExtMap.size()); 4030 4031 for (const auto &I : OpenCLDeclExtMap) 4032 StableOpenCLDeclExtMap.emplace_back(getDeclID(I.first), &I.second); 4033 4034 auto CompareByDeclID = [](const ElementTy &E1, const ElementTy &E2) -> bool { 4035 return E1.first < E2.first; 4036 }; 4037 llvm::sort(StableOpenCLDeclExtMap, CompareByDeclID); 4038 4039 RecordData Record; 4040 for (const ElementTy &E : StableOpenCLDeclExtMap) { 4041 Record.push_back(E.first); // DeclID 4042 const std::set<std::string> *ExtSet = E.second; 4043 Record.push_back(static_cast<unsigned>(ExtSet->size())); 4044 for (const std::string &Ext : *ExtSet) 4045 AddString(Ext, Record); 4046 } 4047 4048 Stream.EmitRecord(OPENCL_EXTENSION_DECLS, Record); 4049 } 4050 4051 void ASTWriter::WriteCUDAPragmas(Sema &SemaRef) { 4052 if (SemaRef.ForceCUDAHostDeviceDepth > 0) { 4053 RecordData::value_type Record[] = {SemaRef.ForceCUDAHostDeviceDepth}; 4054 Stream.EmitRecord(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH, Record); 4055 } 4056 } 4057 4058 void ASTWriter::WriteObjCCategories() { 4059 SmallVector<ObjCCategoriesInfo, 2> CategoriesMap; 4060 RecordData Categories; 4061 4062 for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) { 4063 unsigned Size = 0; 4064 unsigned StartIndex = Categories.size(); 4065 4066 ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I]; 4067 4068 // Allocate space for the size. 4069 Categories.push_back(0); 4070 4071 // Add the categories. 4072 for (ObjCInterfaceDecl::known_categories_iterator 4073 Cat = Class->known_categories_begin(), 4074 CatEnd = Class->known_categories_end(); 4075 Cat != CatEnd; ++Cat, ++Size) { 4076 assert(getDeclID(*Cat) != 0 && "Bogus category"); 4077 AddDeclRef(*Cat, Categories); 4078 } 4079 4080 // Update the size. 4081 Categories[StartIndex] = Size; 4082 4083 // Record this interface -> category map. 4084 ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex }; 4085 CategoriesMap.push_back(CatInfo); 4086 } 4087 4088 // Sort the categories map by the definition ID, since the reader will be 4089 // performing binary searches on this information. 4090 llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end()); 4091 4092 // Emit the categories map. 4093 using namespace llvm; 4094 4095 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 4096 Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP)); 4097 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries 4098 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 4099 unsigned AbbrevID = Stream.EmitAbbrev(std::move(Abbrev)); 4100 4101 RecordData::value_type Record[] = {OBJC_CATEGORIES_MAP, CategoriesMap.size()}; 4102 Stream.EmitRecordWithBlob(AbbrevID, Record, 4103 reinterpret_cast<char *>(CategoriesMap.data()), 4104 CategoriesMap.size() * sizeof(ObjCCategoriesInfo)); 4105 4106 // Emit the category lists. 4107 Stream.EmitRecord(OBJC_CATEGORIES, Categories); 4108 } 4109 4110 void ASTWriter::WriteLateParsedTemplates(Sema &SemaRef) { 4111 Sema::LateParsedTemplateMapT &LPTMap = SemaRef.LateParsedTemplateMap; 4112 4113 if (LPTMap.empty()) 4114 return; 4115 4116 RecordData Record; 4117 for (auto &LPTMapEntry : LPTMap) { 4118 const FunctionDecl *FD = LPTMapEntry.first; 4119 LateParsedTemplate &LPT = *LPTMapEntry.second; 4120 AddDeclRef(FD, Record); 4121 AddDeclRef(LPT.D, Record); 4122 Record.push_back(LPT.Toks.size()); 4123 4124 for (const auto &Tok : LPT.Toks) { 4125 AddToken(Tok, Record); 4126 } 4127 } 4128 Stream.EmitRecord(LATE_PARSED_TEMPLATE, Record); 4129 } 4130 4131 /// Write the state of 'pragma clang optimize' at the end of the module. 4132 void ASTWriter::WriteOptimizePragmaOptions(Sema &SemaRef) { 4133 RecordData Record; 4134 SourceLocation PragmaLoc = SemaRef.getOptimizeOffPragmaLocation(); 4135 AddSourceLocation(PragmaLoc, Record); 4136 Stream.EmitRecord(OPTIMIZE_PRAGMA_OPTIONS, Record); 4137 } 4138 4139 /// Write the state of 'pragma ms_struct' at the end of the module. 4140 void ASTWriter::WriteMSStructPragmaOptions(Sema &SemaRef) { 4141 RecordData Record; 4142 Record.push_back(SemaRef.MSStructPragmaOn ? PMSST_ON : PMSST_OFF); 4143 Stream.EmitRecord(MSSTRUCT_PRAGMA_OPTIONS, Record); 4144 } 4145 4146 /// Write the state of 'pragma pointers_to_members' at the end of the 4147 //module. 4148 void ASTWriter::WriteMSPointersToMembersPragmaOptions(Sema &SemaRef) { 4149 RecordData Record; 4150 Record.push_back(SemaRef.MSPointerToMemberRepresentationMethod); 4151 AddSourceLocation(SemaRef.ImplicitMSInheritanceAttrLoc, Record); 4152 Stream.EmitRecord(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS, Record); 4153 } 4154 4155 /// Write the state of 'pragma align/pack' at the end of the module. 4156 void ASTWriter::WritePackPragmaOptions(Sema &SemaRef) { 4157 // Don't serialize pragma align/pack state for modules, since it should only 4158 // take effect on a per-submodule basis. 4159 if (WritingModule) 4160 return; 4161 4162 RecordData Record; 4163 AddAlignPackInfo(SemaRef.AlignPackStack.CurrentValue, Record); 4164 AddSourceLocation(SemaRef.AlignPackStack.CurrentPragmaLocation, Record); 4165 Record.push_back(SemaRef.AlignPackStack.Stack.size()); 4166 for (const auto &StackEntry : SemaRef.AlignPackStack.Stack) { 4167 AddAlignPackInfo(StackEntry.Value, Record); 4168 AddSourceLocation(StackEntry.PragmaLocation, Record); 4169 AddSourceLocation(StackEntry.PragmaPushLocation, Record); 4170 AddString(StackEntry.StackSlotLabel, Record); 4171 } 4172 Stream.EmitRecord(ALIGN_PACK_PRAGMA_OPTIONS, Record); 4173 } 4174 4175 /// Write the state of 'pragma float_control' at the end of the module. 4176 void ASTWriter::WriteFloatControlPragmaOptions(Sema &SemaRef) { 4177 // Don't serialize pragma float_control state for modules, 4178 // since it should only take effect on a per-submodule basis. 4179 if (WritingModule) 4180 return; 4181 4182 RecordData Record; 4183 Record.push_back(SemaRef.FpPragmaStack.CurrentValue.getAsOpaqueInt()); 4184 AddSourceLocation(SemaRef.FpPragmaStack.CurrentPragmaLocation, Record); 4185 Record.push_back(SemaRef.FpPragmaStack.Stack.size()); 4186 for (const auto &StackEntry : SemaRef.FpPragmaStack.Stack) { 4187 Record.push_back(StackEntry.Value.getAsOpaqueInt()); 4188 AddSourceLocation(StackEntry.PragmaLocation, Record); 4189 AddSourceLocation(StackEntry.PragmaPushLocation, Record); 4190 AddString(StackEntry.StackSlotLabel, Record); 4191 } 4192 Stream.EmitRecord(FLOAT_CONTROL_PRAGMA_OPTIONS, Record); 4193 } 4194 4195 void ASTWriter::WriteModuleFileExtension(Sema &SemaRef, 4196 ModuleFileExtensionWriter &Writer) { 4197 // Enter the extension block. 4198 Stream.EnterSubblock(EXTENSION_BLOCK_ID, 4); 4199 4200 // Emit the metadata record abbreviation. 4201 auto Abv = std::make_shared<llvm::BitCodeAbbrev>(); 4202 Abv->Add(llvm::BitCodeAbbrevOp(EXTENSION_METADATA)); 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::VBR, 6)); 4206 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 4207 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4208 unsigned Abbrev = Stream.EmitAbbrev(std::move(Abv)); 4209 4210 // Emit the metadata record. 4211 RecordData Record; 4212 auto Metadata = Writer.getExtension()->getExtensionMetadata(); 4213 Record.push_back(EXTENSION_METADATA); 4214 Record.push_back(Metadata.MajorVersion); 4215 Record.push_back(Metadata.MinorVersion); 4216 Record.push_back(Metadata.BlockName.size()); 4217 Record.push_back(Metadata.UserInfo.size()); 4218 SmallString<64> Buffer; 4219 Buffer += Metadata.BlockName; 4220 Buffer += Metadata.UserInfo; 4221 Stream.EmitRecordWithBlob(Abbrev, Record, Buffer); 4222 4223 // Emit the contents of the extension block. 4224 Writer.writeExtensionContents(SemaRef, Stream); 4225 4226 // Exit the extension block. 4227 Stream.ExitBlock(); 4228 } 4229 4230 //===----------------------------------------------------------------------===// 4231 // General Serialization Routines 4232 //===----------------------------------------------------------------------===// 4233 4234 void ASTRecordWriter::AddAttr(const Attr *A) { 4235 auto &Record = *this; 4236 if (!A) 4237 return Record.push_back(0); 4238 Record.push_back(A->getKind() + 1); // FIXME: stable encoding, target attrs 4239 4240 Record.AddIdentifierRef(A->getAttrName()); 4241 Record.AddIdentifierRef(A->getScopeName()); 4242 Record.AddSourceRange(A->getRange()); 4243 Record.AddSourceLocation(A->getScopeLoc()); 4244 Record.push_back(A->getParsedKind()); 4245 Record.push_back(A->getSyntax()); 4246 Record.push_back(A->getAttributeSpellingListIndexRaw()); 4247 4248 #include "clang/Serialization/AttrPCHWrite.inc" 4249 } 4250 4251 /// Emit the list of attributes to the specified record. 4252 void ASTRecordWriter::AddAttributes(ArrayRef<const Attr *> Attrs) { 4253 push_back(Attrs.size()); 4254 for (const auto *A : Attrs) 4255 AddAttr(A); 4256 } 4257 4258 void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) { 4259 AddSourceLocation(Tok.getLocation(), Record); 4260 Record.push_back(Tok.getLength()); 4261 4262 // FIXME: When reading literal tokens, reconstruct the literal pointer 4263 // if it is needed. 4264 AddIdentifierRef(Tok.getIdentifierInfo(), Record); 4265 // FIXME: Should translate token kind to a stable encoding. 4266 Record.push_back(Tok.getKind()); 4267 // FIXME: Should translate token flags to a stable encoding. 4268 Record.push_back(Tok.getFlags()); 4269 } 4270 4271 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { 4272 Record.push_back(Str.size()); 4273 Record.insert(Record.end(), Str.begin(), Str.end()); 4274 } 4275 4276 bool ASTWriter::PreparePathForOutput(SmallVectorImpl<char> &Path) { 4277 assert(Context && "should have context when outputting path"); 4278 4279 bool Changed = 4280 cleanPathForOutput(Context->getSourceManager().getFileManager(), Path); 4281 4282 // Remove a prefix to make the path relative, if relevant. 4283 const char *PathBegin = Path.data(); 4284 const char *PathPtr = 4285 adjustFilenameForRelocatableAST(PathBegin, BaseDirectory); 4286 if (PathPtr != PathBegin) { 4287 Path.erase(Path.begin(), Path.begin() + (PathPtr - PathBegin)); 4288 Changed = true; 4289 } 4290 4291 return Changed; 4292 } 4293 4294 void ASTWriter::AddPath(StringRef Path, RecordDataImpl &Record) { 4295 SmallString<128> FilePath(Path); 4296 PreparePathForOutput(FilePath); 4297 AddString(FilePath, Record); 4298 } 4299 4300 void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, 4301 StringRef Path) { 4302 SmallString<128> FilePath(Path); 4303 PreparePathForOutput(FilePath); 4304 Stream.EmitRecordWithBlob(Abbrev, Record, FilePath); 4305 } 4306 4307 void ASTWriter::AddVersionTuple(const VersionTuple &Version, 4308 RecordDataImpl &Record) { 4309 Record.push_back(Version.getMajor()); 4310 if (Optional<unsigned> Minor = Version.getMinor()) 4311 Record.push_back(*Minor + 1); 4312 else 4313 Record.push_back(0); 4314 if (Optional<unsigned> Subminor = Version.getSubminor()) 4315 Record.push_back(*Subminor + 1); 4316 else 4317 Record.push_back(0); 4318 } 4319 4320 /// Note that the identifier II occurs at the given offset 4321 /// within the identifier table. 4322 void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) { 4323 IdentID ID = IdentifierIDs[II]; 4324 // Only store offsets new to this AST file. Other identifier names are looked 4325 // up earlier in the chain and thus don't need an offset. 4326 if (ID >= FirstIdentID) 4327 IdentifierOffsets[ID - FirstIdentID] = Offset; 4328 } 4329 4330 /// Note that the selector Sel occurs at the given offset 4331 /// within the method pool/selector table. 4332 void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { 4333 unsigned ID = SelectorIDs[Sel]; 4334 assert(ID && "Unknown selector"); 4335 // Don't record offsets for selectors that are also available in a different 4336 // file. 4337 if (ID < FirstSelectorID) 4338 return; 4339 SelectorOffsets[ID - FirstSelectorID] = Offset; 4340 } 4341 4342 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream, 4343 SmallVectorImpl<char> &Buffer, 4344 InMemoryModuleCache &ModuleCache, 4345 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions, 4346 bool IncludeTimestamps) 4347 : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache), 4348 IncludeTimestamps(IncludeTimestamps) { 4349 for (const auto &Ext : Extensions) { 4350 if (auto Writer = Ext->createExtensionWriter(*this)) 4351 ModuleFileExtensionWriters.push_back(std::move(Writer)); 4352 } 4353 } 4354 4355 ASTWriter::~ASTWriter() = default; 4356 4357 const LangOptions &ASTWriter::getLangOpts() const { 4358 assert(WritingAST && "can't determine lang opts when not writing AST"); 4359 return Context->getLangOpts(); 4360 } 4361 4362 time_t ASTWriter::getTimestampForOutput(const FileEntry *E) const { 4363 return IncludeTimestamps ? E->getModificationTime() : 0; 4364 } 4365 4366 ASTFileSignature ASTWriter::WriteAST(Sema &SemaRef, 4367 const std::string &OutputFile, 4368 Module *WritingModule, StringRef isysroot, 4369 bool hasErrors, 4370 bool ShouldCacheASTInMemory) { 4371 WritingAST = true; 4372 4373 ASTHasCompilerErrors = hasErrors; 4374 4375 // Emit the file header. 4376 Stream.Emit((unsigned)'C', 8); 4377 Stream.Emit((unsigned)'P', 8); 4378 Stream.Emit((unsigned)'C', 8); 4379 Stream.Emit((unsigned)'H', 8); 4380 4381 WriteBlockInfoBlock(); 4382 4383 Context = &SemaRef.Context; 4384 PP = &SemaRef.PP; 4385 this->WritingModule = WritingModule; 4386 ASTFileSignature Signature = 4387 WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule); 4388 Context = nullptr; 4389 PP = nullptr; 4390 this->WritingModule = nullptr; 4391 this->BaseDirectory.clear(); 4392 4393 WritingAST = false; 4394 if (ShouldCacheASTInMemory) { 4395 // Construct MemoryBuffer and update buffer manager. 4396 ModuleCache.addBuiltPCM(OutputFile, 4397 llvm::MemoryBuffer::getMemBufferCopy( 4398 StringRef(Buffer.begin(), Buffer.size()))); 4399 } 4400 return Signature; 4401 } 4402 4403 template<typename Vector> 4404 static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec, 4405 ASTWriter::RecordData &Record) { 4406 for (typename Vector::iterator I = Vec.begin(nullptr, true), E = Vec.end(); 4407 I != E; ++I) { 4408 Writer.AddDeclRef(*I, Record); 4409 } 4410 } 4411 4412 ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot, 4413 const std::string &OutputFile, 4414 Module *WritingModule) { 4415 using namespace llvm; 4416 4417 bool isModule = WritingModule != nullptr; 4418 4419 // Make sure that the AST reader knows to finalize itself. 4420 if (Chain) 4421 Chain->finalizeForWriting(); 4422 4423 ASTContext &Context = SemaRef.Context; 4424 Preprocessor &PP = SemaRef.PP; 4425 4426 // Set up predefined declaration IDs. 4427 auto RegisterPredefDecl = [&] (Decl *D, PredefinedDeclIDs ID) { 4428 if (D) { 4429 assert(D->isCanonicalDecl() && "predefined decl is not canonical"); 4430 DeclIDs[D] = ID; 4431 } 4432 }; 4433 RegisterPredefDecl(Context.getTranslationUnitDecl(), 4434 PREDEF_DECL_TRANSLATION_UNIT_ID); 4435 RegisterPredefDecl(Context.ObjCIdDecl, PREDEF_DECL_OBJC_ID_ID); 4436 RegisterPredefDecl(Context.ObjCSelDecl, PREDEF_DECL_OBJC_SEL_ID); 4437 RegisterPredefDecl(Context.ObjCClassDecl, PREDEF_DECL_OBJC_CLASS_ID); 4438 RegisterPredefDecl(Context.ObjCProtocolClassDecl, 4439 PREDEF_DECL_OBJC_PROTOCOL_ID); 4440 RegisterPredefDecl(Context.Int128Decl, PREDEF_DECL_INT_128_ID); 4441 RegisterPredefDecl(Context.UInt128Decl, PREDEF_DECL_UNSIGNED_INT_128_ID); 4442 RegisterPredefDecl(Context.ObjCInstanceTypeDecl, 4443 PREDEF_DECL_OBJC_INSTANCETYPE_ID); 4444 RegisterPredefDecl(Context.BuiltinVaListDecl, PREDEF_DECL_BUILTIN_VA_LIST_ID); 4445 RegisterPredefDecl(Context.VaListTagDecl, PREDEF_DECL_VA_LIST_TAG); 4446 RegisterPredefDecl(Context.BuiltinMSVaListDecl, 4447 PREDEF_DECL_BUILTIN_MS_VA_LIST_ID); 4448 RegisterPredefDecl(Context.MSGuidTagDecl, 4449 PREDEF_DECL_BUILTIN_MS_GUID_ID); 4450 RegisterPredefDecl(Context.ExternCContext, PREDEF_DECL_EXTERN_C_CONTEXT_ID); 4451 RegisterPredefDecl(Context.MakeIntegerSeqDecl, 4452 PREDEF_DECL_MAKE_INTEGER_SEQ_ID); 4453 RegisterPredefDecl(Context.CFConstantStringTypeDecl, 4454 PREDEF_DECL_CF_CONSTANT_STRING_ID); 4455 RegisterPredefDecl(Context.CFConstantStringTagDecl, 4456 PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID); 4457 RegisterPredefDecl(Context.TypePackElementDecl, 4458 PREDEF_DECL_TYPE_PACK_ELEMENT_ID); 4459 4460 // Build a record containing all of the tentative definitions in this file, in 4461 // TentativeDefinitions order. Generally, this record will be empty for 4462 // headers. 4463 RecordData TentativeDefinitions; 4464 AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions); 4465 4466 // Build a record containing all of the file scoped decls in this file. 4467 RecordData UnusedFileScopedDecls; 4468 if (!isModule) 4469 AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls, 4470 UnusedFileScopedDecls); 4471 4472 // Build a record containing all of the delegating constructors we still need 4473 // to resolve. 4474 RecordData DelegatingCtorDecls; 4475 if (!isModule) 4476 AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls); 4477 4478 // Write the set of weak, undeclared identifiers. We always write the 4479 // entire table, since later PCH files in a PCH chain are only interested in 4480 // the results at the end of the chain. 4481 RecordData WeakUndeclaredIdentifiers; 4482 for (auto &WeakUndeclaredIdentifier : SemaRef.WeakUndeclaredIdentifiers) { 4483 IdentifierInfo *II = WeakUndeclaredIdentifier.first; 4484 WeakInfo &WI = WeakUndeclaredIdentifier.second; 4485 AddIdentifierRef(II, WeakUndeclaredIdentifiers); 4486 AddIdentifierRef(WI.getAlias(), WeakUndeclaredIdentifiers); 4487 AddSourceLocation(WI.getLocation(), WeakUndeclaredIdentifiers); 4488 WeakUndeclaredIdentifiers.push_back(WI.getUsed()); 4489 } 4490 4491 // Build a record containing all of the ext_vector declarations. 4492 RecordData ExtVectorDecls; 4493 AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls); 4494 4495 // Build a record containing all of the VTable uses information. 4496 RecordData VTableUses; 4497 if (!SemaRef.VTableUses.empty()) { 4498 for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) { 4499 AddDeclRef(SemaRef.VTableUses[I].first, VTableUses); 4500 AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses); 4501 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]); 4502 } 4503 } 4504 4505 // Build a record containing all of the UnusedLocalTypedefNameCandidates. 4506 RecordData UnusedLocalTypedefNameCandidates; 4507 for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates) 4508 AddDeclRef(TD, UnusedLocalTypedefNameCandidates); 4509 4510 // Build a record containing all of pending implicit instantiations. 4511 RecordData PendingInstantiations; 4512 for (const auto &I : SemaRef.PendingInstantiations) { 4513 AddDeclRef(I.first, PendingInstantiations); 4514 AddSourceLocation(I.second, PendingInstantiations); 4515 } 4516 assert(SemaRef.PendingLocalImplicitInstantiations.empty() && 4517 "There are local ones at end of translation unit!"); 4518 4519 // Build a record containing some declaration references. 4520 RecordData SemaDeclRefs; 4521 if (SemaRef.StdNamespace || SemaRef.StdBadAlloc || SemaRef.StdAlignValT) { 4522 AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs); 4523 AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs); 4524 AddDeclRef(SemaRef.getStdAlignValT(), SemaDeclRefs); 4525 } 4526 4527 RecordData CUDASpecialDeclRefs; 4528 if (Context.getcudaConfigureCallDecl()) { 4529 AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs); 4530 } 4531 4532 // Build a record containing all of the known namespaces. 4533 RecordData KnownNamespaces; 4534 for (const auto &I : SemaRef.KnownNamespaces) { 4535 if (!I.second) 4536 AddDeclRef(I.first, KnownNamespaces); 4537 } 4538 4539 // Build a record of all used, undefined objects that require definitions. 4540 RecordData UndefinedButUsed; 4541 4542 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined; 4543 SemaRef.getUndefinedButUsed(Undefined); 4544 for (const auto &I : Undefined) { 4545 AddDeclRef(I.first, UndefinedButUsed); 4546 AddSourceLocation(I.second, UndefinedButUsed); 4547 } 4548 4549 // Build a record containing all delete-expressions that we would like to 4550 // analyze later in AST. 4551 RecordData DeleteExprsToAnalyze; 4552 4553 if (!isModule) { 4554 for (const auto &DeleteExprsInfo : 4555 SemaRef.getMismatchingDeleteExpressions()) { 4556 AddDeclRef(DeleteExprsInfo.first, DeleteExprsToAnalyze); 4557 DeleteExprsToAnalyze.push_back(DeleteExprsInfo.second.size()); 4558 for (const auto &DeleteLoc : DeleteExprsInfo.second) { 4559 AddSourceLocation(DeleteLoc.first, DeleteExprsToAnalyze); 4560 DeleteExprsToAnalyze.push_back(DeleteLoc.second); 4561 } 4562 } 4563 } 4564 4565 // Write the control block 4566 WriteControlBlock(PP, Context, isysroot, OutputFile); 4567 4568 // Write the remaining AST contents. 4569 Stream.FlushToWord(); 4570 ASTBlockRange.first = Stream.GetCurrentBitNo(); 4571 Stream.EnterSubblock(AST_BLOCK_ID, 5); 4572 ASTBlockStartOffset = Stream.GetCurrentBitNo(); 4573 4574 // This is so that older clang versions, before the introduction 4575 // of the control block, can read and reject the newer PCH format. 4576 { 4577 RecordData Record = {VERSION_MAJOR}; 4578 Stream.EmitRecord(METADATA_OLD_FORMAT, Record); 4579 } 4580 4581 // Create a lexical update block containing all of the declarations in the 4582 // translation unit that do not come from other AST files. 4583 const TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 4584 SmallVector<uint32_t, 128> NewGlobalKindDeclPairs; 4585 for (const auto *D : TU->noload_decls()) { 4586 if (!D->isFromASTFile()) { 4587 NewGlobalKindDeclPairs.push_back(D->getKind()); 4588 NewGlobalKindDeclPairs.push_back(GetDeclRef(D)); 4589 } 4590 } 4591 4592 auto Abv = std::make_shared<BitCodeAbbrev>(); 4593 Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL)); 4594 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4595 unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv)); 4596 { 4597 RecordData::value_type Record[] = {TU_UPDATE_LEXICAL}; 4598 Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record, 4599 bytes(NewGlobalKindDeclPairs)); 4600 } 4601 4602 // And a visible updates block for the translation unit. 4603 Abv = std::make_shared<BitCodeAbbrev>(); 4604 Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE)); 4605 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6)); 4606 Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)); 4607 UpdateVisibleAbbrev = Stream.EmitAbbrev(std::move(Abv)); 4608 WriteDeclContextVisibleUpdate(TU); 4609 4610 // If we have any extern "C" names, write out a visible update for them. 4611 if (Context.ExternCContext) 4612 WriteDeclContextVisibleUpdate(Context.ExternCContext); 4613 4614 // If the translation unit has an anonymous namespace, and we don't already 4615 // have an update block for it, write it as an update block. 4616 // FIXME: Why do we not do this if there's already an update block? 4617 if (NamespaceDecl *NS = TU->getAnonymousNamespace()) { 4618 ASTWriter::UpdateRecord &Record = DeclUpdates[TU]; 4619 if (Record.empty()) 4620 Record.push_back(DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, NS)); 4621 } 4622 4623 // Add update records for all mangling numbers and static local numbers. 4624 // These aren't really update records, but this is a convenient way of 4625 // tagging this rare extra data onto the declarations. 4626 for (const auto &Number : Context.MangleNumbers) 4627 if (!Number.first->isFromASTFile()) 4628 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_MANGLING_NUMBER, 4629 Number.second)); 4630 for (const auto &Number : Context.StaticLocalNumbers) 4631 if (!Number.first->isFromASTFile()) 4632 DeclUpdates[Number.first].push_back(DeclUpdate(UPD_STATIC_LOCAL_NUMBER, 4633 Number.second)); 4634 4635 // Make sure visible decls, added to DeclContexts previously loaded from 4636 // an AST file, are registered for serialization. Likewise for template 4637 // specializations added to imported templates. 4638 for (const auto *I : DeclsToEmitEvenIfUnreferenced) { 4639 GetDeclRef(I); 4640 } 4641 4642 // Make sure all decls associated with an identifier are registered for 4643 // serialization, if we're storing decls with identifiers. 4644 if (!WritingModule || !getLangOpts().CPlusPlus) { 4645 llvm::SmallVector<const IdentifierInfo*, 256> IIs; 4646 for (const auto &ID : PP.getIdentifierTable()) { 4647 const IdentifierInfo *II = ID.second; 4648 if (!Chain || !II->isFromAST() || II->hasChangedSinceDeserialization()) 4649 IIs.push_back(II); 4650 } 4651 // Sort the identifiers to visit based on their name. 4652 llvm::sort(IIs, llvm::deref<std::less<>>()); 4653 for (const IdentifierInfo *II : IIs) { 4654 for (IdentifierResolver::iterator D = SemaRef.IdResolver.begin(II), 4655 DEnd = SemaRef.IdResolver.end(); 4656 D != DEnd; ++D) { 4657 GetDeclRef(*D); 4658 } 4659 } 4660 } 4661 4662 // For method pool in the module, if it contains an entry for a selector, 4663 // the entry should be complete, containing everything introduced by that 4664 // module and all modules it imports. It's possible that the entry is out of 4665 // date, so we need to pull in the new content here. 4666 4667 // It's possible that updateOutOfDateSelector can update SelectorIDs. To be 4668 // safe, we copy all selectors out. 4669 llvm::SmallVector<Selector, 256> AllSelectors; 4670 for (auto &SelectorAndID : SelectorIDs) 4671 AllSelectors.push_back(SelectorAndID.first); 4672 for (auto &Selector : AllSelectors) 4673 SemaRef.updateOutOfDateSelector(Selector); 4674 4675 // Form the record of special types. 4676 RecordData SpecialTypes; 4677 AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes); 4678 AddTypeRef(Context.getFILEType(), SpecialTypes); 4679 AddTypeRef(Context.getjmp_bufType(), SpecialTypes); 4680 AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes); 4681 AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes); 4682 AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes); 4683 AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes); 4684 AddTypeRef(Context.getucontext_tType(), SpecialTypes); 4685 4686 if (Chain) { 4687 // Write the mapping information describing our module dependencies and how 4688 // each of those modules were mapped into our own offset/ID space, so that 4689 // the reader can build the appropriate mapping to its own offset/ID space. 4690 // The map consists solely of a blob with the following format: 4691 // *(module-kind:i8 4692 // module-name-len:i16 module-name:len*i8 4693 // source-location-offset:i32 4694 // identifier-id:i32 4695 // preprocessed-entity-id:i32 4696 // macro-definition-id:i32 4697 // submodule-id:i32 4698 // selector-id:i32 4699 // declaration-id:i32 4700 // c++-base-specifiers-id:i32 4701 // type-id:i32) 4702 // 4703 // module-kind is the ModuleKind enum value. If it is MK_PrebuiltModule, 4704 // MK_ExplicitModule or MK_ImplicitModule, then the module-name is the 4705 // module name. Otherwise, it is the module file name. 4706 auto Abbrev = std::make_shared<BitCodeAbbrev>(); 4707 Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP)); 4708 Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 4709 unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev)); 4710 SmallString<2048> Buffer; 4711 { 4712 llvm::raw_svector_ostream Out(Buffer); 4713 for (ModuleFile &M : Chain->ModuleMgr) { 4714 using namespace llvm::support; 4715 4716 endian::Writer LE(Out, little); 4717 LE.write<uint8_t>(static_cast<uint8_t>(M.Kind)); 4718 StringRef Name = M.isModule() ? M.ModuleName : M.FileName; 4719 LE.write<uint16_t>(Name.size()); 4720 Out.write(Name.data(), Name.size()); 4721 4722 // Note: if a base ID was uint max, it would not be possible to load 4723 // another module after it or have more than one entity inside it. 4724 uint32_t None = std::numeric_limits<uint32_t>::max(); 4725 4726 auto writeBaseIDOrNone = [&](uint32_t BaseID, bool ShouldWrite) { 4727 assert(BaseID < std::numeric_limits<uint32_t>::max() && "base id too high"); 4728 if (ShouldWrite) 4729 LE.write<uint32_t>(BaseID); 4730 else 4731 LE.write<uint32_t>(None); 4732 }; 4733 4734 // These values should be unique within a chain, since they will be read 4735 // as keys into ContinuousRangeMaps. 4736 writeBaseIDOrNone(M.SLocEntryBaseOffset, M.LocalNumSLocEntries); 4737 writeBaseIDOrNone(M.BaseIdentifierID, M.LocalNumIdentifiers); 4738 writeBaseIDOrNone(M.BaseMacroID, M.LocalNumMacros); 4739 writeBaseIDOrNone(M.BasePreprocessedEntityID, 4740 M.NumPreprocessedEntities); 4741 writeBaseIDOrNone(M.BaseSubmoduleID, M.LocalNumSubmodules); 4742 writeBaseIDOrNone(M.BaseSelectorID, M.LocalNumSelectors); 4743 writeBaseIDOrNone(M.BaseDeclID, M.LocalNumDecls); 4744 writeBaseIDOrNone(M.BaseTypeIndex, M.LocalNumTypes); 4745 } 4746 } 4747 RecordData::value_type Record[] = {MODULE_OFFSET_MAP}; 4748 Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record, 4749 Buffer.data(), Buffer.size()); 4750 } 4751 4752 // Build a record containing all of the DeclsToCheckForDeferredDiags. 4753 RecordData DeclsToCheckForDeferredDiags; 4754 for (auto *D : SemaRef.DeclsToCheckForDeferredDiags) 4755 AddDeclRef(D, DeclsToCheckForDeferredDiags); 4756 4757 RecordData DeclUpdatesOffsetsRecord; 4758 4759 // Keep writing types, declarations, and declaration update records 4760 // until we've emitted all of them. 4761 Stream.EnterSubblock(DECLTYPES_BLOCK_ID, /*bits for abbreviations*/5); 4762 DeclTypesBlockStartOffset = Stream.GetCurrentBitNo(); 4763 WriteTypeAbbrevs(); 4764 WriteDeclAbbrevs(); 4765 do { 4766 WriteDeclUpdatesBlocks(DeclUpdatesOffsetsRecord); 4767 while (!DeclTypesToEmit.empty()) { 4768 DeclOrType DOT = DeclTypesToEmit.front(); 4769 DeclTypesToEmit.pop(); 4770 if (DOT.isType()) 4771 WriteType(DOT.getType()); 4772 else 4773 WriteDecl(Context, DOT.getDecl()); 4774 } 4775 } while (!DeclUpdates.empty()); 4776 Stream.ExitBlock(); 4777 4778 DoneWritingDeclsAndTypes = true; 4779 4780 // These things can only be done once we've written out decls and types. 4781 WriteTypeDeclOffsets(); 4782 if (!DeclUpdatesOffsetsRecord.empty()) 4783 Stream.EmitRecord(DECL_UPDATE_OFFSETS, DeclUpdatesOffsetsRecord); 4784 WriteFileDeclIDsMap(); 4785 WriteSourceManagerBlock(Context.getSourceManager(), PP); 4786 WriteComments(); 4787 WritePreprocessor(PP, isModule); 4788 WriteHeaderSearch(PP.getHeaderSearchInfo()); 4789 WriteSelectors(SemaRef); 4790 WriteReferencedSelectorsPool(SemaRef); 4791 WriteLateParsedTemplates(SemaRef); 4792 WriteIdentifierTable(PP, SemaRef.IdResolver, isModule); 4793 WriteFPPragmaOptions(SemaRef.CurFPFeatureOverrides()); 4794 WriteOpenCLExtensions(SemaRef); 4795 WriteOpenCLExtensionTypes(SemaRef); 4796 WriteCUDAPragmas(SemaRef); 4797 4798 // If we're emitting a module, write out the submodule information. 4799 if (WritingModule) 4800 WriteSubmodules(WritingModule); 4801 4802 // We need to have information about submodules to correctly deserialize 4803 // decls from OpenCLExtensionDecls block 4804 WriteOpenCLExtensionDecls(SemaRef); 4805 4806 Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes); 4807 4808 // Write the record containing external, unnamed definitions. 4809 if (!EagerlyDeserializedDecls.empty()) 4810 Stream.EmitRecord(EAGERLY_DESERIALIZED_DECLS, EagerlyDeserializedDecls); 4811 4812 if (!ModularCodegenDecls.empty()) 4813 Stream.EmitRecord(MODULAR_CODEGEN_DECLS, ModularCodegenDecls); 4814 4815 // Write the record containing tentative definitions. 4816 if (!TentativeDefinitions.empty()) 4817 Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions); 4818 4819 // Write the record containing unused file scoped decls. 4820 if (!UnusedFileScopedDecls.empty()) 4821 Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls); 4822 4823 // Write the record containing weak undeclared identifiers. 4824 if (!WeakUndeclaredIdentifiers.empty()) 4825 Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS, 4826 WeakUndeclaredIdentifiers); 4827 4828 // Write the record containing ext_vector type names. 4829 if (!ExtVectorDecls.empty()) 4830 Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls); 4831 4832 // Write the record containing VTable uses information. 4833 if (!VTableUses.empty()) 4834 Stream.EmitRecord(VTABLE_USES, VTableUses); 4835 4836 // Write the record containing potentially unused local typedefs. 4837 if (!UnusedLocalTypedefNameCandidates.empty()) 4838 Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES, 4839 UnusedLocalTypedefNameCandidates); 4840 4841 // Write the record containing pending implicit instantiations. 4842 if (!PendingInstantiations.empty()) 4843 Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations); 4844 4845 // Write the record containing declaration references of Sema. 4846 if (!SemaDeclRefs.empty()) 4847 Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs); 4848 4849 // Write the record containing decls to be checked for deferred diags. 4850 if (!DeclsToCheckForDeferredDiags.empty()) 4851 Stream.EmitRecord(DECLS_TO_CHECK_FOR_DEFERRED_DIAGS, 4852 DeclsToCheckForDeferredDiags); 4853 4854 // Write the record containing CUDA-specific declaration references. 4855 if (!CUDASpecialDeclRefs.empty()) 4856 Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs); 4857 4858 // Write the delegating constructors. 4859 if (!DelegatingCtorDecls.empty()) 4860 Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls); 4861 4862 // Write the known namespaces. 4863 if (!KnownNamespaces.empty()) 4864 Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces); 4865 4866 // Write the undefined internal functions and variables, and inline functions. 4867 if (!UndefinedButUsed.empty()) 4868 Stream.EmitRecord(UNDEFINED_BUT_USED, UndefinedButUsed); 4869 4870 if (!DeleteExprsToAnalyze.empty()) 4871 Stream.EmitRecord(DELETE_EXPRS_TO_ANALYZE, DeleteExprsToAnalyze); 4872 4873 // Write the visible updates to DeclContexts. 4874 for (auto *DC : UpdatedDeclContexts) 4875 WriteDeclContextVisibleUpdate(DC); 4876 4877 if (!WritingModule) { 4878 // Write the submodules that were imported, if any. 4879 struct ModuleInfo { 4880 uint64_t ID; 4881 Module *M; 4882 ModuleInfo(uint64_t ID, Module *M) : ID(ID), M(M) {} 4883 }; 4884 llvm::SmallVector<ModuleInfo, 64> Imports; 4885 for (const auto *I : Context.local_imports()) { 4886 assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end()); 4887 Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()], 4888 I->getImportedModule())); 4889 } 4890 4891 if (!Imports.empty()) { 4892 auto Cmp = [](const ModuleInfo &A, const ModuleInfo &B) { 4893 return A.ID < B.ID; 4894 }; 4895 auto Eq = [](const ModuleInfo &A, const ModuleInfo &B) { 4896 return A.ID == B.ID; 4897 }; 4898 4899 // Sort and deduplicate module IDs. 4900 llvm::sort(Imports, Cmp); 4901 Imports.erase(std::unique(Imports.begin(), Imports.end(), Eq), 4902 Imports.end()); 4903 4904 RecordData ImportedModules; 4905 for (const auto &Import : Imports) { 4906 ImportedModules.push_back(Import.ID); 4907 // FIXME: If the module has macros imported then later has declarations 4908 // imported, this location won't be the right one as a location for the 4909 // declaration imports. 4910 AddSourceLocation(PP.getModuleImportLoc(Import.M), ImportedModules); 4911 } 4912 4913 Stream.EmitRecord(IMPORTED_MODULES, ImportedModules); 4914 } 4915 } 4916 4917 WriteObjCCategories(); 4918 if(!WritingModule) { 4919 WriteOptimizePragmaOptions(SemaRef); 4920 WriteMSStructPragmaOptions(SemaRef); 4921 WriteMSPointersToMembersPragmaOptions(SemaRef); 4922 } 4923 WritePackPragmaOptions(SemaRef); 4924 WriteFloatControlPragmaOptions(SemaRef); 4925 4926 // Some simple statistics 4927 RecordData::value_type Record[] = { 4928 NumStatements, NumMacros, NumLexicalDeclContexts, NumVisibleDeclContexts}; 4929 Stream.EmitRecord(STATISTICS, Record); 4930 Stream.ExitBlock(); 4931 Stream.FlushToWord(); 4932 ASTBlockRange.second = Stream.GetCurrentBitNo(); 4933 4934 // Write the module file extension blocks. 4935 for (const auto &ExtWriter : ModuleFileExtensionWriters) 4936 WriteModuleFileExtension(SemaRef, *ExtWriter); 4937 4938 return writeUnhashedControlBlock(PP, Context); 4939 } 4940 4941 void ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { 4942 if (DeclUpdates.empty()) 4943 return; 4944 4945 DeclUpdateMap LocalUpdates; 4946 LocalUpdates.swap(DeclUpdates); 4947 4948 for (auto &DeclUpdate : LocalUpdates) { 4949 const Decl *D = DeclUpdate.first; 4950 4951 bool HasUpdatedBody = false; 4952 RecordData RecordData; 4953 ASTRecordWriter Record(*this, RecordData); 4954 for (auto &Update : DeclUpdate.second) { 4955 DeclUpdateKind Kind = (DeclUpdateKind)Update.getKind(); 4956 4957 // An updated body is emitted last, so that the reader doesn't need 4958 // to skip over the lazy body to reach statements for other records. 4959 if (Kind == UPD_CXX_ADDED_FUNCTION_DEFINITION) 4960 HasUpdatedBody = true; 4961 else 4962 Record.push_back(Kind); 4963 4964 switch (Kind) { 4965 case UPD_CXX_ADDED_IMPLICIT_MEMBER: 4966 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: 4967 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: 4968 assert(Update.getDecl() && "no decl to add?"); 4969 Record.push_back(GetDeclRef(Update.getDecl())); 4970 break; 4971 4972 case UPD_CXX_ADDED_FUNCTION_DEFINITION: 4973 break; 4974 4975 case UPD_CXX_POINT_OF_INSTANTIATION: 4976 // FIXME: Do we need to also save the template specialization kind here? 4977 Record.AddSourceLocation(Update.getLoc()); 4978 break; 4979 4980 case UPD_CXX_ADDED_VAR_DEFINITION: { 4981 const VarDecl *VD = cast<VarDecl>(D); 4982 Record.push_back(VD->isInline()); 4983 Record.push_back(VD->isInlineSpecified()); 4984 Record.AddVarDeclInit(VD); 4985 break; 4986 } 4987 4988 case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: 4989 Record.AddStmt(const_cast<Expr *>( 4990 cast<ParmVarDecl>(Update.getDecl())->getDefaultArg())); 4991 break; 4992 4993 case UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER: 4994 Record.AddStmt( 4995 cast<FieldDecl>(Update.getDecl())->getInClassInitializer()); 4996 break; 4997 4998 case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: { 4999 auto *RD = cast<CXXRecordDecl>(D); 5000 UpdatedDeclContexts.insert(RD->getPrimaryContext()); 5001 Record.push_back(RD->isParamDestroyedInCallee()); 5002 Record.push_back(RD->getArgPassingRestrictions()); 5003 Record.AddCXXDefinitionData(RD); 5004 Record.AddOffset(WriteDeclContextLexicalBlock( 5005 *Context, const_cast<CXXRecordDecl *>(RD))); 5006 5007 // This state is sometimes updated by template instantiation, when we 5008 // switch from the specialization referring to the template declaration 5009 // to it referring to the template definition. 5010 if (auto *MSInfo = RD->getMemberSpecializationInfo()) { 5011 Record.push_back(MSInfo->getTemplateSpecializationKind()); 5012 Record.AddSourceLocation(MSInfo->getPointOfInstantiation()); 5013 } else { 5014 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD); 5015 Record.push_back(Spec->getTemplateSpecializationKind()); 5016 Record.AddSourceLocation(Spec->getPointOfInstantiation()); 5017 5018 // The instantiation might have been resolved to a partial 5019 // specialization. If so, record which one. 5020 auto From = Spec->getInstantiatedFrom(); 5021 if (auto PartialSpec = 5022 From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) { 5023 Record.push_back(true); 5024 Record.AddDeclRef(PartialSpec); 5025 Record.AddTemplateArgumentList( 5026 &Spec->getTemplateInstantiationArgs()); 5027 } else { 5028 Record.push_back(false); 5029 } 5030 } 5031 Record.push_back(RD->getTagKind()); 5032 Record.AddSourceLocation(RD->getLocation()); 5033 Record.AddSourceLocation(RD->getBeginLoc()); 5034 Record.AddSourceRange(RD->getBraceRange()); 5035 5036 // Instantiation may change attributes; write them all out afresh. 5037 Record.push_back(D->hasAttrs()); 5038 if (D->hasAttrs()) 5039 Record.AddAttributes(D->getAttrs()); 5040 5041 // FIXME: Ensure we don't get here for explicit instantiations. 5042 break; 5043 } 5044 5045 case UPD_CXX_RESOLVED_DTOR_DELETE: 5046 Record.AddDeclRef(Update.getDecl()); 5047 Record.AddStmt(cast<CXXDestructorDecl>(D)->getOperatorDeleteThisArg()); 5048 break; 5049 5050 case UPD_CXX_RESOLVED_EXCEPTION_SPEC: { 5051 auto prototype = 5052 cast<FunctionDecl>(D)->getType()->castAs<FunctionProtoType>(); 5053 Record.writeExceptionSpecInfo(prototype->getExceptionSpecInfo()); 5054 break; 5055 } 5056 5057 case UPD_CXX_DEDUCED_RETURN_TYPE: 5058 Record.push_back(GetOrCreateTypeID(Update.getType())); 5059 break; 5060 5061 case UPD_DECL_MARKED_USED: 5062 break; 5063 5064 case UPD_MANGLING_NUMBER: 5065 case UPD_STATIC_LOCAL_NUMBER: 5066 Record.push_back(Update.getNumber()); 5067 break; 5068 5069 case UPD_DECL_MARKED_OPENMP_THREADPRIVATE: 5070 Record.AddSourceRange( 5071 D->getAttr<OMPThreadPrivateDeclAttr>()->getRange()); 5072 break; 5073 5074 case UPD_DECL_MARKED_OPENMP_ALLOCATE: { 5075 auto *A = D->getAttr<OMPAllocateDeclAttr>(); 5076 Record.push_back(A->getAllocatorType()); 5077 Record.AddStmt(A->getAllocator()); 5078 Record.AddSourceRange(A->getRange()); 5079 break; 5080 } 5081 5082 case UPD_DECL_MARKED_OPENMP_DECLARETARGET: 5083 Record.push_back(D->getAttr<OMPDeclareTargetDeclAttr>()->getMapType()); 5084 Record.AddSourceRange( 5085 D->getAttr<OMPDeclareTargetDeclAttr>()->getRange()); 5086 break; 5087 5088 case UPD_DECL_EXPORTED: 5089 Record.push_back(getSubmoduleID(Update.getModule())); 5090 break; 5091 5092 case UPD_ADDED_ATTR_TO_RECORD: 5093 Record.AddAttributes(llvm::makeArrayRef(Update.getAttr())); 5094 break; 5095 } 5096 } 5097 5098 if (HasUpdatedBody) { 5099 const auto *Def = cast<FunctionDecl>(D); 5100 Record.push_back(UPD_CXX_ADDED_FUNCTION_DEFINITION); 5101 Record.push_back(Def->isInlined()); 5102 Record.AddSourceLocation(Def->getInnerLocStart()); 5103 Record.AddFunctionDefinition(Def); 5104 } 5105 5106 OffsetsRecord.push_back(GetDeclRef(D)); 5107 OffsetsRecord.push_back(Record.Emit(DECL_UPDATES)); 5108 } 5109 } 5110 5111 void ASTWriter::AddAlignPackInfo(const Sema::AlignPackInfo &Info, 5112 RecordDataImpl &Record) { 5113 uint32_t Raw = Sema::AlignPackInfo::getRawEncoding(Info); 5114 Record.push_back(Raw); 5115 } 5116 5117 void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) { 5118 uint32_t Raw = Loc.getRawEncoding(); 5119 Record.push_back((Raw << 1) | (Raw >> 31)); 5120 } 5121 5122 void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) { 5123 AddSourceLocation(Range.getBegin(), Record); 5124 AddSourceLocation(Range.getEnd(), Record); 5125 } 5126 5127 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) { 5128 AddAPInt(Value.bitcastToAPInt()); 5129 } 5130 5131 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) { 5132 Record.push_back(getIdentifierRef(II)); 5133 } 5134 5135 IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) { 5136 if (!II) 5137 return 0; 5138 5139 IdentID &ID = IdentifierIDs[II]; 5140 if (ID == 0) 5141 ID = NextIdentID++; 5142 return ID; 5143 } 5144 5145 MacroID ASTWriter::getMacroRef(MacroInfo *MI, const IdentifierInfo *Name) { 5146 // Don't emit builtin macros like __LINE__ to the AST file unless they 5147 // have been redefined by the header (in which case they are not 5148 // isBuiltinMacro). 5149 if (!MI || MI->isBuiltinMacro()) 5150 return 0; 5151 5152 MacroID &ID = MacroIDs[MI]; 5153 if (ID == 0) { 5154 ID = NextMacroID++; 5155 MacroInfoToEmitData Info = { Name, MI, ID }; 5156 MacroInfosToEmit.push_back(Info); 5157 } 5158 return ID; 5159 } 5160 5161 MacroID ASTWriter::getMacroID(MacroInfo *MI) { 5162 if (!MI || MI->isBuiltinMacro()) 5163 return 0; 5164 5165 assert(MacroIDs.find(MI) != MacroIDs.end() && "Macro not emitted!"); 5166 return MacroIDs[MI]; 5167 } 5168 5169 uint32_t ASTWriter::getMacroDirectivesOffset(const IdentifierInfo *Name) { 5170 return IdentMacroDirectivesOffsetMap.lookup(Name); 5171 } 5172 5173 void ASTRecordWriter::AddSelectorRef(const Selector SelRef) { 5174 Record->push_back(Writer->getSelectorRef(SelRef)); 5175 } 5176 5177 SelectorID ASTWriter::getSelectorRef(Selector Sel) { 5178 if (Sel.getAsOpaquePtr() == nullptr) { 5179 return 0; 5180 } 5181 5182 SelectorID SID = SelectorIDs[Sel]; 5183 if (SID == 0 && Chain) { 5184 // This might trigger a ReadSelector callback, which will set the ID for 5185 // this selector. 5186 Chain->LoadSelector(Sel); 5187 SID = SelectorIDs[Sel]; 5188 } 5189 if (SID == 0) { 5190 SID = NextSelectorID++; 5191 SelectorIDs[Sel] = SID; 5192 } 5193 return SID; 5194 } 5195 5196 void ASTRecordWriter::AddCXXTemporary(const CXXTemporary *Temp) { 5197 AddDeclRef(Temp->getDestructor()); 5198 } 5199 5200 void ASTRecordWriter::AddTemplateArgumentLocInfo( 5201 TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) { 5202 switch (Kind) { 5203 case TemplateArgument::Expression: 5204 AddStmt(Arg.getAsExpr()); 5205 break; 5206 case TemplateArgument::Type: 5207 AddTypeSourceInfo(Arg.getAsTypeSourceInfo()); 5208 break; 5209 case TemplateArgument::Template: 5210 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); 5211 AddSourceLocation(Arg.getTemplateNameLoc()); 5212 break; 5213 case TemplateArgument::TemplateExpansion: 5214 AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc()); 5215 AddSourceLocation(Arg.getTemplateNameLoc()); 5216 AddSourceLocation(Arg.getTemplateEllipsisLoc()); 5217 break; 5218 case TemplateArgument::Null: 5219 case TemplateArgument::Integral: 5220 case TemplateArgument::Declaration: 5221 case TemplateArgument::NullPtr: 5222 case TemplateArgument::Pack: 5223 // FIXME: Is this right? 5224 break; 5225 } 5226 } 5227 5228 void ASTRecordWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg) { 5229 AddTemplateArgument(Arg.getArgument()); 5230 5231 if (Arg.getArgument().getKind() == TemplateArgument::Expression) { 5232 bool InfoHasSameExpr 5233 = Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr(); 5234 Record->push_back(InfoHasSameExpr); 5235 if (InfoHasSameExpr) 5236 return; // Avoid storing the same expr twice. 5237 } 5238 AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo()); 5239 } 5240 5241 void ASTRecordWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo) { 5242 if (!TInfo) { 5243 AddTypeRef(QualType()); 5244 return; 5245 } 5246 5247 AddTypeRef(TInfo->getType()); 5248 AddTypeLoc(TInfo->getTypeLoc()); 5249 } 5250 5251 void ASTRecordWriter::AddTypeLoc(TypeLoc TL) { 5252 TypeLocWriter TLW(*this); 5253 for (; !TL.isNull(); TL = TL.getNextTypeLoc()) 5254 TLW.Visit(TL); 5255 } 5256 5257 void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &Record) { 5258 Record.push_back(GetOrCreateTypeID(T)); 5259 } 5260 5261 TypeID ASTWriter::GetOrCreateTypeID(QualType T) { 5262 assert(Context); 5263 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx { 5264 if (T.isNull()) 5265 return TypeIdx(); 5266 assert(!T.getLocalFastQualifiers()); 5267 5268 TypeIdx &Idx = TypeIdxs[T]; 5269 if (Idx.getIndex() == 0) { 5270 if (DoneWritingDeclsAndTypes) { 5271 assert(0 && "New type seen after serializing all the types to emit!"); 5272 return TypeIdx(); 5273 } 5274 5275 // We haven't seen this type before. Assign it a new ID and put it 5276 // into the queue of types to emit. 5277 Idx = TypeIdx(NextTypeID++); 5278 DeclTypesToEmit.push(T); 5279 } 5280 return Idx; 5281 }); 5282 } 5283 5284 TypeID ASTWriter::getTypeID(QualType T) const { 5285 assert(Context); 5286 return MakeTypeID(*Context, T, [&](QualType T) -> TypeIdx { 5287 if (T.isNull()) 5288 return TypeIdx(); 5289 assert(!T.getLocalFastQualifiers()); 5290 5291 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 5292 assert(I != TypeIdxs.end() && "Type not emitted!"); 5293 return I->second; 5294 }); 5295 } 5296 5297 void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &Record) { 5298 Record.push_back(GetDeclRef(D)); 5299 } 5300 5301 DeclID ASTWriter::GetDeclRef(const Decl *D) { 5302 assert(WritingAST && "Cannot request a declaration ID before AST writing"); 5303 5304 if (!D) { 5305 return 0; 5306 } 5307 5308 // If D comes from an AST file, its declaration ID is already known and 5309 // fixed. 5310 if (D->isFromASTFile()) 5311 return D->getGlobalID(); 5312 5313 assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer"); 5314 DeclID &ID = DeclIDs[D]; 5315 if (ID == 0) { 5316 if (DoneWritingDeclsAndTypes) { 5317 assert(0 && "New decl seen after serializing all the decls to emit!"); 5318 return 0; 5319 } 5320 5321 // We haven't seen this declaration before. Give it a new ID and 5322 // enqueue it in the list of declarations to emit. 5323 ID = NextDeclID++; 5324 DeclTypesToEmit.push(const_cast<Decl *>(D)); 5325 } 5326 5327 return ID; 5328 } 5329 5330 DeclID ASTWriter::getDeclID(const Decl *D) { 5331 if (!D) 5332 return 0; 5333 5334 // If D comes from an AST file, its declaration ID is already known and 5335 // fixed. 5336 if (D->isFromASTFile()) 5337 return D->getGlobalID(); 5338 5339 assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!"); 5340 return DeclIDs[D]; 5341 } 5342 5343 void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) { 5344 assert(ID); 5345 assert(D); 5346 5347 SourceLocation Loc = D->getLocation(); 5348 if (Loc.isInvalid()) 5349 return; 5350 5351 // We only keep track of the file-level declarations of each file. 5352 if (!D->getLexicalDeclContext()->isFileContext()) 5353 return; 5354 // FIXME: ParmVarDecls that are part of a function type of a parameter of 5355 // a function/objc method, should not have TU as lexical context. 5356 // TemplateTemplateParmDecls that are part of an alias template, should not 5357 // have TU as lexical context. 5358 if (isa<ParmVarDecl>(D) || isa<TemplateTemplateParmDecl>(D)) 5359 return; 5360 5361 SourceManager &SM = Context->getSourceManager(); 5362 SourceLocation FileLoc = SM.getFileLoc(Loc); 5363 assert(SM.isLocalSourceLocation(FileLoc)); 5364 FileID FID; 5365 unsigned Offset; 5366 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); 5367 if (FID.isInvalid()) 5368 return; 5369 assert(SM.getSLocEntry(FID).isFile()); 5370 5371 std::unique_ptr<DeclIDInFileInfo> &Info = FileDeclIDs[FID]; 5372 if (!Info) 5373 Info = std::make_unique<DeclIDInFileInfo>(); 5374 5375 std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID); 5376 LocDeclIDsTy &Decls = Info->DeclIDs; 5377 5378 if (Decls.empty() || Decls.back().first <= Offset) { 5379 Decls.push_back(LocDecl); 5380 return; 5381 } 5382 5383 LocDeclIDsTy::iterator I = 5384 llvm::upper_bound(Decls, LocDecl, llvm::less_first()); 5385 5386 Decls.insert(I, LocDecl); 5387 } 5388 5389 unsigned ASTWriter::getAnonymousDeclarationNumber(const NamedDecl *D) { 5390 assert(needsAnonymousDeclarationNumber(D) && 5391 "expected an anonymous declaration"); 5392 5393 // Number the anonymous declarations within this context, if we've not 5394 // already done so. 5395 auto It = AnonymousDeclarationNumbers.find(D); 5396 if (It == AnonymousDeclarationNumbers.end()) { 5397 auto *DC = D->getLexicalDeclContext(); 5398 numberAnonymousDeclsWithin(DC, [&](const NamedDecl *ND, unsigned Number) { 5399 AnonymousDeclarationNumbers[ND] = Number; 5400 }); 5401 5402 It = AnonymousDeclarationNumbers.find(D); 5403 assert(It != AnonymousDeclarationNumbers.end() && 5404 "declaration not found within its lexical context"); 5405 } 5406 5407 return It->second; 5408 } 5409 5410 void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, 5411 DeclarationName Name) { 5412 switch (Name.getNameKind()) { 5413 case DeclarationName::CXXConstructorName: 5414 case DeclarationName::CXXDestructorName: 5415 case DeclarationName::CXXConversionFunctionName: 5416 AddTypeSourceInfo(DNLoc.NamedType.TInfo); 5417 break; 5418 5419 case DeclarationName::CXXOperatorName: 5420 AddSourceLocation(SourceLocation::getFromRawEncoding( 5421 DNLoc.CXXOperatorName.BeginOpNameLoc)); 5422 AddSourceLocation( 5423 SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc)); 5424 break; 5425 5426 case DeclarationName::CXXLiteralOperatorName: 5427 AddSourceLocation(SourceLocation::getFromRawEncoding( 5428 DNLoc.CXXLiteralOperatorName.OpNameLoc)); 5429 break; 5430 5431 case DeclarationName::Identifier: 5432 case DeclarationName::ObjCZeroArgSelector: 5433 case DeclarationName::ObjCOneArgSelector: 5434 case DeclarationName::ObjCMultiArgSelector: 5435 case DeclarationName::CXXUsingDirective: 5436 case DeclarationName::CXXDeductionGuideName: 5437 break; 5438 } 5439 } 5440 5441 void ASTRecordWriter::AddDeclarationNameInfo( 5442 const DeclarationNameInfo &NameInfo) { 5443 AddDeclarationName(NameInfo.getName()); 5444 AddSourceLocation(NameInfo.getLoc()); 5445 AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName()); 5446 } 5447 5448 void ASTRecordWriter::AddQualifierInfo(const QualifierInfo &Info) { 5449 AddNestedNameSpecifierLoc(Info.QualifierLoc); 5450 Record->push_back(Info.NumTemplParamLists); 5451 for (unsigned i = 0, e = Info.NumTemplParamLists; i != e; ++i) 5452 AddTemplateParameterList(Info.TemplParamLists[i]); 5453 } 5454 5455 void ASTRecordWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) { 5456 // Nested name specifiers usually aren't too long. I think that 8 would 5457 // typically accommodate the vast majority. 5458 SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 5459 5460 // Push each of the nested-name-specifiers's onto a stack for 5461 // serialization in reverse order. 5462 while (NNS) { 5463 NestedNames.push_back(NNS); 5464 NNS = NNS.getPrefix(); 5465 } 5466 5467 Record->push_back(NestedNames.size()); 5468 while(!NestedNames.empty()) { 5469 NNS = NestedNames.pop_back_val(); 5470 NestedNameSpecifier::SpecifierKind Kind 5471 = NNS.getNestedNameSpecifier()->getKind(); 5472 Record->push_back(Kind); 5473 switch (Kind) { 5474 case NestedNameSpecifier::Identifier: 5475 AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier()); 5476 AddSourceRange(NNS.getLocalSourceRange()); 5477 break; 5478 5479 case NestedNameSpecifier::Namespace: 5480 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace()); 5481 AddSourceRange(NNS.getLocalSourceRange()); 5482 break; 5483 5484 case NestedNameSpecifier::NamespaceAlias: 5485 AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias()); 5486 AddSourceRange(NNS.getLocalSourceRange()); 5487 break; 5488 5489 case NestedNameSpecifier::TypeSpec: 5490 case NestedNameSpecifier::TypeSpecWithTemplate: 5491 Record->push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate); 5492 AddTypeRef(NNS.getTypeLoc().getType()); 5493 AddTypeLoc(NNS.getTypeLoc()); 5494 AddSourceLocation(NNS.getLocalSourceRange().getEnd()); 5495 break; 5496 5497 case NestedNameSpecifier::Global: 5498 AddSourceLocation(NNS.getLocalSourceRange().getEnd()); 5499 break; 5500 5501 case NestedNameSpecifier::Super: 5502 AddDeclRef(NNS.getNestedNameSpecifier()->getAsRecordDecl()); 5503 AddSourceRange(NNS.getLocalSourceRange()); 5504 break; 5505 } 5506 } 5507 } 5508 5509 void ASTRecordWriter::AddTemplateParameterList( 5510 const TemplateParameterList *TemplateParams) { 5511 assert(TemplateParams && "No TemplateParams!"); 5512 AddSourceLocation(TemplateParams->getTemplateLoc()); 5513 AddSourceLocation(TemplateParams->getLAngleLoc()); 5514 AddSourceLocation(TemplateParams->getRAngleLoc()); 5515 5516 Record->push_back(TemplateParams->size()); 5517 for (const auto &P : *TemplateParams) 5518 AddDeclRef(P); 5519 if (const Expr *RequiresClause = TemplateParams->getRequiresClause()) { 5520 Record->push_back(true); 5521 AddStmt(const_cast<Expr*>(RequiresClause)); 5522 } else { 5523 Record->push_back(false); 5524 } 5525 } 5526 5527 /// Emit a template argument list. 5528 void ASTRecordWriter::AddTemplateArgumentList( 5529 const TemplateArgumentList *TemplateArgs) { 5530 assert(TemplateArgs && "No TemplateArgs!"); 5531 Record->push_back(TemplateArgs->size()); 5532 for (int i = 0, e = TemplateArgs->size(); i != e; ++i) 5533 AddTemplateArgument(TemplateArgs->get(i)); 5534 } 5535 5536 void ASTRecordWriter::AddASTTemplateArgumentListInfo( 5537 const ASTTemplateArgumentListInfo *ASTTemplArgList) { 5538 assert(ASTTemplArgList && "No ASTTemplArgList!"); 5539 AddSourceLocation(ASTTemplArgList->LAngleLoc); 5540 AddSourceLocation(ASTTemplArgList->RAngleLoc); 5541 Record->push_back(ASTTemplArgList->NumTemplateArgs); 5542 const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs(); 5543 for (int i = 0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i) 5544 AddTemplateArgumentLoc(TemplArgs[i]); 5545 } 5546 5547 void ASTRecordWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set) { 5548 Record->push_back(Set.size()); 5549 for (ASTUnresolvedSet::const_iterator 5550 I = Set.begin(), E = Set.end(); I != E; ++I) { 5551 AddDeclRef(I.getDecl()); 5552 Record->push_back(I.getAccess()); 5553 } 5554 } 5555 5556 // FIXME: Move this out of the main ASTRecordWriter interface. 5557 void ASTRecordWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base) { 5558 Record->push_back(Base.isVirtual()); 5559 Record->push_back(Base.isBaseOfClass()); 5560 Record->push_back(Base.getAccessSpecifierAsWritten()); 5561 Record->push_back(Base.getInheritConstructors()); 5562 AddTypeSourceInfo(Base.getTypeSourceInfo()); 5563 AddSourceRange(Base.getSourceRange()); 5564 AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc() 5565 : SourceLocation()); 5566 } 5567 5568 static uint64_t EmitCXXBaseSpecifiers(ASTWriter &W, 5569 ArrayRef<CXXBaseSpecifier> Bases) { 5570 ASTWriter::RecordData Record; 5571 ASTRecordWriter Writer(W, Record); 5572 Writer.push_back(Bases.size()); 5573 5574 for (auto &Base : Bases) 5575 Writer.AddCXXBaseSpecifier(Base); 5576 5577 return Writer.Emit(serialization::DECL_CXX_BASE_SPECIFIERS); 5578 } 5579 5580 // FIXME: Move this out of the main ASTRecordWriter interface. 5581 void ASTRecordWriter::AddCXXBaseSpecifiers(ArrayRef<CXXBaseSpecifier> Bases) { 5582 AddOffset(EmitCXXBaseSpecifiers(*Writer, Bases)); 5583 } 5584 5585 static uint64_t 5586 EmitCXXCtorInitializers(ASTWriter &W, 5587 ArrayRef<CXXCtorInitializer *> CtorInits) { 5588 ASTWriter::RecordData Record; 5589 ASTRecordWriter Writer(W, Record); 5590 Writer.push_back(CtorInits.size()); 5591 5592 for (auto *Init : CtorInits) { 5593 if (Init->isBaseInitializer()) { 5594 Writer.push_back(CTOR_INITIALIZER_BASE); 5595 Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); 5596 Writer.push_back(Init->isBaseVirtual()); 5597 } else if (Init->isDelegatingInitializer()) { 5598 Writer.push_back(CTOR_INITIALIZER_DELEGATING); 5599 Writer.AddTypeSourceInfo(Init->getTypeSourceInfo()); 5600 } else if (Init->isMemberInitializer()){ 5601 Writer.push_back(CTOR_INITIALIZER_MEMBER); 5602 Writer.AddDeclRef(Init->getMember()); 5603 } else { 5604 Writer.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER); 5605 Writer.AddDeclRef(Init->getIndirectMember()); 5606 } 5607 5608 Writer.AddSourceLocation(Init->getMemberLocation()); 5609 Writer.AddStmt(Init->getInit()); 5610 Writer.AddSourceLocation(Init->getLParenLoc()); 5611 Writer.AddSourceLocation(Init->getRParenLoc()); 5612 Writer.push_back(Init->isWritten()); 5613 if (Init->isWritten()) 5614 Writer.push_back(Init->getSourceOrder()); 5615 } 5616 5617 return Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS); 5618 } 5619 5620 // FIXME: Move this out of the main ASTRecordWriter interface. 5621 void ASTRecordWriter::AddCXXCtorInitializers( 5622 ArrayRef<CXXCtorInitializer *> CtorInits) { 5623 AddOffset(EmitCXXCtorInitializers(*Writer, CtorInits)); 5624 } 5625 5626 void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) { 5627 auto &Data = D->data(); 5628 Record->push_back(Data.IsLambda); 5629 5630 #define FIELD(Name, Width, Merge) \ 5631 Record->push_back(Data.Name); 5632 #include "clang/AST/CXXRecordDeclDefinitionBits.def" 5633 5634 // getODRHash will compute the ODRHash if it has not been previously computed. 5635 Record->push_back(D->getODRHash()); 5636 bool ModulesDebugInfo = 5637 Writer->Context->getLangOpts().ModulesDebugInfo && !D->isDependentType(); 5638 Record->push_back(ModulesDebugInfo); 5639 if (ModulesDebugInfo) 5640 Writer->ModularCodegenDecls.push_back(Writer->GetDeclRef(D)); 5641 5642 // IsLambda bit is already saved. 5643 5644 Record->push_back(Data.NumBases); 5645 if (Data.NumBases > 0) 5646 AddCXXBaseSpecifiers(Data.bases()); 5647 5648 // FIXME: Make VBases lazily computed when needed to avoid storing them. 5649 Record->push_back(Data.NumVBases); 5650 if (Data.NumVBases > 0) 5651 AddCXXBaseSpecifiers(Data.vbases()); 5652 5653 AddUnresolvedSet(Data.Conversions.get(*Writer->Context)); 5654 Record->push_back(Data.ComputedVisibleConversions); 5655 if (Data.ComputedVisibleConversions) 5656 AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context)); 5657 // Data.Definition is the owning decl, no need to write it. 5658 AddDeclRef(D->getFirstFriend()); 5659 5660 // Add lambda-specific data. 5661 if (Data.IsLambda) { 5662 auto &Lambda = D->getLambdaData(); 5663 Record->push_back(Lambda.Dependent); 5664 Record->push_back(Lambda.IsGenericLambda); 5665 Record->push_back(Lambda.CaptureDefault); 5666 Record->push_back(Lambda.NumCaptures); 5667 Record->push_back(Lambda.NumExplicitCaptures); 5668 Record->push_back(Lambda.HasKnownInternalLinkage); 5669 Record->push_back(Lambda.ManglingNumber); 5670 Record->push_back(D->getDeviceLambdaManglingNumber()); 5671 AddDeclRef(D->getLambdaContextDecl()); 5672 AddTypeSourceInfo(Lambda.MethodTyInfo); 5673 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { 5674 const LambdaCapture &Capture = Lambda.Captures[I]; 5675 AddSourceLocation(Capture.getLocation()); 5676 Record->push_back(Capture.isImplicit()); 5677 Record->push_back(Capture.getCaptureKind()); 5678 switch (Capture.getCaptureKind()) { 5679 case LCK_StarThis: 5680 case LCK_This: 5681 case LCK_VLAType: 5682 break; 5683 case LCK_ByCopy: 5684 case LCK_ByRef: 5685 VarDecl *Var = 5686 Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr; 5687 AddDeclRef(Var); 5688 AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc() 5689 : SourceLocation()); 5690 break; 5691 } 5692 } 5693 } 5694 } 5695 5696 void ASTRecordWriter::AddVarDeclInit(const VarDecl *VD) { 5697 const Expr *Init = VD->getInit(); 5698 if (!Init) { 5699 push_back(0); 5700 return; 5701 } 5702 5703 unsigned Val = 1; 5704 if (EvaluatedStmt *ES = VD->getEvaluatedStmt()) { 5705 Val |= (ES->HasConstantInitialization ? 2 : 0); 5706 Val |= (ES->HasConstantDestruction ? 4 : 0); 5707 // FIXME: Also emit the constant initializer value. 5708 } 5709 push_back(Val); 5710 writeStmtRef(Init); 5711 } 5712 5713 void ASTWriter::ReaderInitialized(ASTReader *Reader) { 5714 assert(Reader && "Cannot remove chain"); 5715 assert((!Chain || Chain == Reader) && "Cannot replace chain"); 5716 assert(FirstDeclID == NextDeclID && 5717 FirstTypeID == NextTypeID && 5718 FirstIdentID == NextIdentID && 5719 FirstMacroID == NextMacroID && 5720 FirstSubmoduleID == NextSubmoduleID && 5721 FirstSelectorID == NextSelectorID && 5722 "Setting chain after writing has started."); 5723 5724 Chain = Reader; 5725 5726 // Note, this will get called multiple times, once one the reader starts up 5727 // and again each time it's done reading a PCH or module. 5728 FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls(); 5729 FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes(); 5730 FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers(); 5731 FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros(); 5732 FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules(); 5733 FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors(); 5734 NextDeclID = FirstDeclID; 5735 NextTypeID = FirstTypeID; 5736 NextIdentID = FirstIdentID; 5737 NextMacroID = FirstMacroID; 5738 NextSelectorID = FirstSelectorID; 5739 NextSubmoduleID = FirstSubmoduleID; 5740 } 5741 5742 void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) { 5743 // Always keep the highest ID. See \p TypeRead() for more information. 5744 IdentID &StoredID = IdentifierIDs[II]; 5745 if (ID > StoredID) 5746 StoredID = ID; 5747 } 5748 5749 void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) { 5750 // Always keep the highest ID. See \p TypeRead() for more information. 5751 MacroID &StoredID = MacroIDs[MI]; 5752 if (ID > StoredID) 5753 StoredID = ID; 5754 } 5755 5756 void ASTWriter::TypeRead(TypeIdx Idx, QualType T) { 5757 // Always take the highest-numbered type index. This copes with an interesting 5758 // case for chained AST writing where we schedule writing the type and then, 5759 // later, deserialize the type from another AST. In this case, we want to 5760 // keep the higher-numbered entry so that we can properly write it out to 5761 // the AST file. 5762 TypeIdx &StoredIdx = TypeIdxs[T]; 5763 if (Idx.getIndex() >= StoredIdx.getIndex()) 5764 StoredIdx = Idx; 5765 } 5766 5767 void ASTWriter::SelectorRead(SelectorID ID, Selector S) { 5768 // Always keep the highest ID. See \p TypeRead() for more information. 5769 SelectorID &StoredID = SelectorIDs[S]; 5770 if (ID > StoredID) 5771 StoredID = ID; 5772 } 5773 5774 void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID ID, 5775 MacroDefinitionRecord *MD) { 5776 assert(MacroDefinitions.find(MD) == MacroDefinitions.end()); 5777 MacroDefinitions[MD] = ID; 5778 } 5779 5780 void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) { 5781 assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end()); 5782 SubmoduleIDs[Mod] = ID; 5783 } 5784 5785 void ASTWriter::CompletedTagDefinition(const TagDecl *D) { 5786 if (Chain && Chain->isProcessingUpdateRecords()) return; 5787 assert(D->isCompleteDefinition()); 5788 assert(!WritingAST && "Already writing the AST!"); 5789 if (auto *RD = dyn_cast<CXXRecordDecl>(D)) { 5790 // We are interested when a PCH decl is modified. 5791 if (RD->isFromASTFile()) { 5792 // A forward reference was mutated into a definition. Rewrite it. 5793 // FIXME: This happens during template instantiation, should we 5794 // have created a new definition decl instead ? 5795 assert(isTemplateInstantiation(RD->getTemplateSpecializationKind()) && 5796 "completed a tag from another module but not by instantiation?"); 5797 DeclUpdates[RD].push_back( 5798 DeclUpdate(UPD_CXX_INSTANTIATED_CLASS_DEFINITION)); 5799 } 5800 } 5801 } 5802 5803 static bool isImportedDeclContext(ASTReader *Chain, const Decl *D) { 5804 if (D->isFromASTFile()) 5805 return true; 5806 5807 // The predefined __va_list_tag struct is imported if we imported any decls. 5808 // FIXME: This is a gross hack. 5809 return D == D->getASTContext().getVaListTagDecl(); 5810 } 5811 5812 void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) { 5813 if (Chain && Chain->isProcessingUpdateRecords()) return; 5814 assert(DC->isLookupContext() && 5815 "Should not add lookup results to non-lookup contexts!"); 5816 5817 // TU is handled elsewhere. 5818 if (isa<TranslationUnitDecl>(DC)) 5819 return; 5820 5821 // Namespaces are handled elsewhere, except for template instantiations of 5822 // FunctionTemplateDecls in namespaces. We are interested in cases where the 5823 // local instantiations are added to an imported context. Only happens when 5824 // adding ADL lookup candidates, for example templated friends. 5825 if (isa<NamespaceDecl>(DC) && D->getFriendObjectKind() == Decl::FOK_None && 5826 !isa<FunctionTemplateDecl>(D)) 5827 return; 5828 5829 // We're only interested in cases where a local declaration is added to an 5830 // imported context. 5831 if (D->isFromASTFile() || !isImportedDeclContext(Chain, cast<Decl>(DC))) 5832 return; 5833 5834 assert(DC == DC->getPrimaryContext() && "added to non-primary context"); 5835 assert(!getDefinitiveDeclContext(DC) && "DeclContext not definitive!"); 5836 assert(!WritingAST && "Already writing the AST!"); 5837 if (UpdatedDeclContexts.insert(DC) && !cast<Decl>(DC)->isFromASTFile()) { 5838 // We're adding a visible declaration to a predefined decl context. Ensure 5839 // that we write out all of its lookup results so we don't get a nasty 5840 // surprise when we try to emit its lookup table. 5841 for (auto *Child : DC->decls()) 5842 DeclsToEmitEvenIfUnreferenced.push_back(Child); 5843 } 5844 DeclsToEmitEvenIfUnreferenced.push_back(D); 5845 } 5846 5847 void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) { 5848 if (Chain && Chain->isProcessingUpdateRecords()) return; 5849 assert(D->isImplicit()); 5850 5851 // We're only interested in cases where a local declaration is added to an 5852 // imported context. 5853 if (D->isFromASTFile() || !isImportedDeclContext(Chain, RD)) 5854 return; 5855 5856 if (!isa<CXXMethodDecl>(D)) 5857 return; 5858 5859 // A decl coming from PCH was modified. 5860 assert(RD->isCompleteDefinition()); 5861 assert(!WritingAST && "Already writing the AST!"); 5862 DeclUpdates[RD].push_back(DeclUpdate(UPD_CXX_ADDED_IMPLICIT_MEMBER, D)); 5863 } 5864 5865 void ASTWriter::ResolvedExceptionSpec(const FunctionDecl *FD) { 5866 if (Chain && Chain->isProcessingUpdateRecords()) return; 5867 assert(!DoneWritingDeclsAndTypes && "Already done writing updates!"); 5868 if (!Chain) return; 5869 Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { 5870 // If we don't already know the exception specification for this redecl 5871 // chain, add an update record for it. 5872 if (isUnresolvedExceptionSpec(cast<FunctionDecl>(D) 5873 ->getType() 5874 ->castAs<FunctionProtoType>() 5875 ->getExceptionSpecType())) 5876 DeclUpdates[D].push_back(UPD_CXX_RESOLVED_EXCEPTION_SPEC); 5877 }); 5878 } 5879 5880 void ASTWriter::DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) { 5881 if (Chain && Chain->isProcessingUpdateRecords()) return; 5882 assert(!WritingAST && "Already writing the AST!"); 5883 if (!Chain) return; 5884 Chain->forEachImportedKeyDecl(FD, [&](const Decl *D) { 5885 DeclUpdates[D].push_back( 5886 DeclUpdate(UPD_CXX_DEDUCED_RETURN_TYPE, ReturnType)); 5887 }); 5888 } 5889 5890 void ASTWriter::ResolvedOperatorDelete(const CXXDestructorDecl *DD, 5891 const FunctionDecl *Delete, 5892 Expr *ThisArg) { 5893 if (Chain && Chain->isProcessingUpdateRecords()) return; 5894 assert(!WritingAST && "Already writing the AST!"); 5895 assert(Delete && "Not given an operator delete"); 5896 if (!Chain) return; 5897 Chain->forEachImportedKeyDecl(DD, [&](const Decl *D) { 5898 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_RESOLVED_DTOR_DELETE, Delete)); 5899 }); 5900 } 5901 5902 void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) { 5903 if (Chain && Chain->isProcessingUpdateRecords()) return; 5904 assert(!WritingAST && "Already writing the AST!"); 5905 if (!D->isFromASTFile()) 5906 return; // Declaration not imported from PCH. 5907 5908 // Implicit function decl from a PCH was defined. 5909 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); 5910 } 5911 5912 void ASTWriter::VariableDefinitionInstantiated(const VarDecl *D) { 5913 if (Chain && Chain->isProcessingUpdateRecords()) return; 5914 assert(!WritingAST && "Already writing the AST!"); 5915 if (!D->isFromASTFile()) 5916 return; 5917 5918 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_VAR_DEFINITION)); 5919 } 5920 5921 void ASTWriter::FunctionDefinitionInstantiated(const FunctionDecl *D) { 5922 if (Chain && Chain->isProcessingUpdateRecords()) return; 5923 assert(!WritingAST && "Already writing the AST!"); 5924 if (!D->isFromASTFile()) 5925 return; 5926 5927 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_ADDED_FUNCTION_DEFINITION)); 5928 } 5929 5930 void ASTWriter::InstantiationRequested(const ValueDecl *D) { 5931 if (Chain && Chain->isProcessingUpdateRecords()) return; 5932 assert(!WritingAST && "Already writing the AST!"); 5933 if (!D->isFromASTFile()) 5934 return; 5935 5936 // Since the actual instantiation is delayed, this really means that we need 5937 // to update the instantiation location. 5938 SourceLocation POI; 5939 if (auto *VD = dyn_cast<VarDecl>(D)) 5940 POI = VD->getPointOfInstantiation(); 5941 else 5942 POI = cast<FunctionDecl>(D)->getPointOfInstantiation(); 5943 DeclUpdates[D].push_back(DeclUpdate(UPD_CXX_POINT_OF_INSTANTIATION, POI)); 5944 } 5945 5946 void ASTWriter::DefaultArgumentInstantiated(const ParmVarDecl *D) { 5947 if (Chain && Chain->isProcessingUpdateRecords()) return; 5948 assert(!WritingAST && "Already writing the AST!"); 5949 if (!D->isFromASTFile()) 5950 return; 5951 5952 DeclUpdates[D].push_back( 5953 DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT, D)); 5954 } 5955 5956 void ASTWriter::DefaultMemberInitializerInstantiated(const FieldDecl *D) { 5957 assert(!WritingAST && "Already writing the AST!"); 5958 if (!D->isFromASTFile()) 5959 return; 5960 5961 DeclUpdates[D].push_back( 5962 DeclUpdate(UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER, D)); 5963 } 5964 5965 void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 5966 const ObjCInterfaceDecl *IFD) { 5967 if (Chain && Chain->isProcessingUpdateRecords()) return; 5968 assert(!WritingAST && "Already writing the AST!"); 5969 if (!IFD->isFromASTFile()) 5970 return; // Declaration not imported from PCH. 5971 5972 assert(IFD->getDefinition() && "Category on a class without a definition?"); 5973 ObjCClassesWithCategories.insert( 5974 const_cast<ObjCInterfaceDecl *>(IFD->getDefinition())); 5975 } 5976 5977 void ASTWriter::DeclarationMarkedUsed(const Decl *D) { 5978 if (Chain && Chain->isProcessingUpdateRecords()) return; 5979 assert(!WritingAST && "Already writing the AST!"); 5980 5981 // If there is *any* declaration of the entity that's not from an AST file, 5982 // we can skip writing the update record. We make sure that isUsed() triggers 5983 // completion of the redeclaration chain of the entity. 5984 for (auto Prev = D->getMostRecentDecl(); Prev; Prev = Prev->getPreviousDecl()) 5985 if (IsLocalDecl(Prev)) 5986 return; 5987 5988 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_USED)); 5989 } 5990 5991 void ASTWriter::DeclarationMarkedOpenMPThreadPrivate(const Decl *D) { 5992 if (Chain && Chain->isProcessingUpdateRecords()) return; 5993 assert(!WritingAST && "Already writing the AST!"); 5994 if (!D->isFromASTFile()) 5995 return; 5996 5997 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_THREADPRIVATE)); 5998 } 5999 6000 void ASTWriter::DeclarationMarkedOpenMPAllocate(const Decl *D, const Attr *A) { 6001 if (Chain && Chain->isProcessingUpdateRecords()) return; 6002 assert(!WritingAST && "Already writing the AST!"); 6003 if (!D->isFromASTFile()) 6004 return; 6005 6006 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_ALLOCATE, A)); 6007 } 6008 6009 void ASTWriter::DeclarationMarkedOpenMPDeclareTarget(const Decl *D, 6010 const Attr *Attr) { 6011 if (Chain && Chain->isProcessingUpdateRecords()) return; 6012 assert(!WritingAST && "Already writing the AST!"); 6013 if (!D->isFromASTFile()) 6014 return; 6015 6016 DeclUpdates[D].push_back( 6017 DeclUpdate(UPD_DECL_MARKED_OPENMP_DECLARETARGET, Attr)); 6018 } 6019 6020 void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D, Module *M) { 6021 if (Chain && Chain->isProcessingUpdateRecords()) return; 6022 assert(!WritingAST && "Already writing the AST!"); 6023 assert(!D->isUnconditionallyVisible() && "expected a hidden declaration"); 6024 DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_EXPORTED, M)); 6025 } 6026 6027 void ASTWriter::AddedAttributeToRecord(const Attr *Attr, 6028 const RecordDecl *Record) { 6029 if (Chain && Chain->isProcessingUpdateRecords()) return; 6030 assert(!WritingAST && "Already writing the AST!"); 6031 if (!Record->isFromASTFile()) 6032 return; 6033 DeclUpdates[Record].push_back(DeclUpdate(UPD_ADDED_ATTR_TO_RECORD, Attr)); 6034 } 6035 6036 void ASTWriter::AddedCXXTemplateSpecialization( 6037 const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { 6038 assert(!WritingAST && "Already writing the AST!"); 6039 6040 if (!TD->getFirstDecl()->isFromASTFile()) 6041 return; 6042 if (Chain && Chain->isProcessingUpdateRecords()) 6043 return; 6044 6045 DeclsToEmitEvenIfUnreferenced.push_back(D); 6046 } 6047 6048 void ASTWriter::AddedCXXTemplateSpecialization( 6049 const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { 6050 assert(!WritingAST && "Already writing the AST!"); 6051 6052 if (!TD->getFirstDecl()->isFromASTFile()) 6053 return; 6054 if (Chain && Chain->isProcessingUpdateRecords()) 6055 return; 6056 6057 DeclsToEmitEvenIfUnreferenced.push_back(D); 6058 } 6059 6060 void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 6061 const FunctionDecl *D) { 6062 assert(!WritingAST && "Already writing the AST!"); 6063 6064 if (!TD->getFirstDecl()->isFromASTFile()) 6065 return; 6066 if (Chain && Chain->isProcessingUpdateRecords()) 6067 return; 6068 6069 DeclsToEmitEvenIfUnreferenced.push_back(D); 6070 } 6071 6072 //===----------------------------------------------------------------------===// 6073 //// OMPClause Serialization 6074 ////===----------------------------------------------------------------------===// 6075 6076 namespace { 6077 6078 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> { 6079 ASTRecordWriter &Record; 6080 6081 public: 6082 OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {} 6083 #define GEN_CLANG_CLAUSE_CLASS 6084 #define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S); 6085 #include "llvm/Frontend/OpenMP/OMP.inc" 6086 void writeClause(OMPClause *C); 6087 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); 6088 void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); 6089 }; 6090 6091 } 6092 6093 void ASTRecordWriter::writeOMPClause(OMPClause *C) { 6094 OMPClauseWriter(*this).writeClause(C); 6095 } 6096 6097 void OMPClauseWriter::writeClause(OMPClause *C) { 6098 Record.push_back(unsigned(C->getClauseKind())); 6099 Visit(C); 6100 Record.AddSourceLocation(C->getBeginLoc()); 6101 Record.AddSourceLocation(C->getEndLoc()); 6102 } 6103 6104 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) { 6105 Record.push_back(uint64_t(C->getCaptureRegion())); 6106 Record.AddStmt(C->getPreInitStmt()); 6107 } 6108 6109 void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) { 6110 VisitOMPClauseWithPreInit(C); 6111 Record.AddStmt(C->getPostUpdateExpr()); 6112 } 6113 6114 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) { 6115 VisitOMPClauseWithPreInit(C); 6116 Record.push_back(uint64_t(C->getNameModifier())); 6117 Record.AddSourceLocation(C->getNameModifierLoc()); 6118 Record.AddSourceLocation(C->getColonLoc()); 6119 Record.AddStmt(C->getCondition()); 6120 Record.AddSourceLocation(C->getLParenLoc()); 6121 } 6122 6123 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) { 6124 VisitOMPClauseWithPreInit(C); 6125 Record.AddStmt(C->getCondition()); 6126 Record.AddSourceLocation(C->getLParenLoc()); 6127 } 6128 6129 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { 6130 VisitOMPClauseWithPreInit(C); 6131 Record.AddStmt(C->getNumThreads()); 6132 Record.AddSourceLocation(C->getLParenLoc()); 6133 } 6134 6135 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) { 6136 Record.AddStmt(C->getSafelen()); 6137 Record.AddSourceLocation(C->getLParenLoc()); 6138 } 6139 6140 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) { 6141 Record.AddStmt(C->getSimdlen()); 6142 Record.AddSourceLocation(C->getLParenLoc()); 6143 } 6144 6145 void OMPClauseWriter::VisitOMPAllocatorClause(OMPAllocatorClause *C) { 6146 Record.AddStmt(C->getAllocator()); 6147 Record.AddSourceLocation(C->getLParenLoc()); 6148 } 6149 6150 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) { 6151 Record.AddStmt(C->getNumForLoops()); 6152 Record.AddSourceLocation(C->getLParenLoc()); 6153 } 6154 6155 void OMPClauseWriter::VisitOMPDetachClause(OMPDetachClause *C) { 6156 Record.AddStmt(C->getEventHandler()); 6157 Record.AddSourceLocation(C->getLParenLoc()); 6158 } 6159 6160 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) { 6161 Record.push_back(unsigned(C->getDefaultKind())); 6162 Record.AddSourceLocation(C->getLParenLoc()); 6163 Record.AddSourceLocation(C->getDefaultKindKwLoc()); 6164 } 6165 6166 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) { 6167 Record.push_back(unsigned(C->getProcBindKind())); 6168 Record.AddSourceLocation(C->getLParenLoc()); 6169 Record.AddSourceLocation(C->getProcBindKindKwLoc()); 6170 } 6171 6172 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) { 6173 VisitOMPClauseWithPreInit(C); 6174 Record.push_back(C->getScheduleKind()); 6175 Record.push_back(C->getFirstScheduleModifier()); 6176 Record.push_back(C->getSecondScheduleModifier()); 6177 Record.AddStmt(C->getChunkSize()); 6178 Record.AddSourceLocation(C->getLParenLoc()); 6179 Record.AddSourceLocation(C->getFirstScheduleModifierLoc()); 6180 Record.AddSourceLocation(C->getSecondScheduleModifierLoc()); 6181 Record.AddSourceLocation(C->getScheduleKindLoc()); 6182 Record.AddSourceLocation(C->getCommaLoc()); 6183 } 6184 6185 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) { 6186 Record.push_back(C->getLoopNumIterations().size()); 6187 Record.AddStmt(C->getNumForLoops()); 6188 for (Expr *NumIter : C->getLoopNumIterations()) 6189 Record.AddStmt(NumIter); 6190 for (unsigned I = 0, E = C->getLoopNumIterations().size(); I <E; ++I) 6191 Record.AddStmt(C->getLoopCounter(I)); 6192 Record.AddSourceLocation(C->getLParenLoc()); 6193 } 6194 6195 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {} 6196 6197 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {} 6198 6199 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {} 6200 6201 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {} 6202 6203 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {} 6204 6205 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *C) { 6206 Record.push_back(C->isExtended() ? 1 : 0); 6207 if (C->isExtended()) { 6208 Record.AddSourceLocation(C->getLParenLoc()); 6209 Record.AddSourceLocation(C->getArgumentLoc()); 6210 Record.writeEnum(C->getDependencyKind()); 6211 } 6212 } 6213 6214 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {} 6215 6216 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {} 6217 6218 void OMPClauseWriter::VisitOMPAcqRelClause(OMPAcqRelClause *) {} 6219 6220 void OMPClauseWriter::VisitOMPAcquireClause(OMPAcquireClause *) {} 6221 6222 void OMPClauseWriter::VisitOMPReleaseClause(OMPReleaseClause *) {} 6223 6224 void OMPClauseWriter::VisitOMPRelaxedClause(OMPRelaxedClause *) {} 6225 6226 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {} 6227 6228 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {} 6229 6230 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {} 6231 6232 void OMPClauseWriter::VisitOMPDestroyClause(OMPDestroyClause *) {} 6233 6234 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) { 6235 Record.push_back(C->varlist_size()); 6236 Record.AddSourceLocation(C->getLParenLoc()); 6237 for (auto *VE : C->varlists()) { 6238 Record.AddStmt(VE); 6239 } 6240 for (auto *VE : C->private_copies()) { 6241 Record.AddStmt(VE); 6242 } 6243 } 6244 6245 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) { 6246 Record.push_back(C->varlist_size()); 6247 VisitOMPClauseWithPreInit(C); 6248 Record.AddSourceLocation(C->getLParenLoc()); 6249 for (auto *VE : C->varlists()) { 6250 Record.AddStmt(VE); 6251 } 6252 for (auto *VE : C->private_copies()) { 6253 Record.AddStmt(VE); 6254 } 6255 for (auto *VE : C->inits()) { 6256 Record.AddStmt(VE); 6257 } 6258 } 6259 6260 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) { 6261 Record.push_back(C->varlist_size()); 6262 VisitOMPClauseWithPostUpdate(C); 6263 Record.AddSourceLocation(C->getLParenLoc()); 6264 Record.writeEnum(C->getKind()); 6265 Record.AddSourceLocation(C->getKindLoc()); 6266 Record.AddSourceLocation(C->getColonLoc()); 6267 for (auto *VE : C->varlists()) 6268 Record.AddStmt(VE); 6269 for (auto *E : C->private_copies()) 6270 Record.AddStmt(E); 6271 for (auto *E : C->source_exprs()) 6272 Record.AddStmt(E); 6273 for (auto *E : C->destination_exprs()) 6274 Record.AddStmt(E); 6275 for (auto *E : C->assignment_ops()) 6276 Record.AddStmt(E); 6277 } 6278 6279 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) { 6280 Record.push_back(C->varlist_size()); 6281 Record.AddSourceLocation(C->getLParenLoc()); 6282 for (auto *VE : C->varlists()) 6283 Record.AddStmt(VE); 6284 } 6285 6286 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) { 6287 Record.push_back(C->varlist_size()); 6288 Record.writeEnum(C->getModifier()); 6289 VisitOMPClauseWithPostUpdate(C); 6290 Record.AddSourceLocation(C->getLParenLoc()); 6291 Record.AddSourceLocation(C->getModifierLoc()); 6292 Record.AddSourceLocation(C->getColonLoc()); 6293 Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); 6294 Record.AddDeclarationNameInfo(C->getNameInfo()); 6295 for (auto *VE : C->varlists()) 6296 Record.AddStmt(VE); 6297 for (auto *VE : C->privates()) 6298 Record.AddStmt(VE); 6299 for (auto *E : C->lhs_exprs()) 6300 Record.AddStmt(E); 6301 for (auto *E : C->rhs_exprs()) 6302 Record.AddStmt(E); 6303 for (auto *E : C->reduction_ops()) 6304 Record.AddStmt(E); 6305 if (C->getModifier() == clang::OMPC_REDUCTION_inscan) { 6306 for (auto *E : C->copy_ops()) 6307 Record.AddStmt(E); 6308 for (auto *E : C->copy_array_temps()) 6309 Record.AddStmt(E); 6310 for (auto *E : C->copy_array_elems()) 6311 Record.AddStmt(E); 6312 } 6313 } 6314 6315 void OMPClauseWriter::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) { 6316 Record.push_back(C->varlist_size()); 6317 VisitOMPClauseWithPostUpdate(C); 6318 Record.AddSourceLocation(C->getLParenLoc()); 6319 Record.AddSourceLocation(C->getColonLoc()); 6320 Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); 6321 Record.AddDeclarationNameInfo(C->getNameInfo()); 6322 for (auto *VE : C->varlists()) 6323 Record.AddStmt(VE); 6324 for (auto *VE : C->privates()) 6325 Record.AddStmt(VE); 6326 for (auto *E : C->lhs_exprs()) 6327 Record.AddStmt(E); 6328 for (auto *E : C->rhs_exprs()) 6329 Record.AddStmt(E); 6330 for (auto *E : C->reduction_ops()) 6331 Record.AddStmt(E); 6332 } 6333 6334 void OMPClauseWriter::VisitOMPInReductionClause(OMPInReductionClause *C) { 6335 Record.push_back(C->varlist_size()); 6336 VisitOMPClauseWithPostUpdate(C); 6337 Record.AddSourceLocation(C->getLParenLoc()); 6338 Record.AddSourceLocation(C->getColonLoc()); 6339 Record.AddNestedNameSpecifierLoc(C->getQualifierLoc()); 6340 Record.AddDeclarationNameInfo(C->getNameInfo()); 6341 for (auto *VE : C->varlists()) 6342 Record.AddStmt(VE); 6343 for (auto *VE : C->privates()) 6344 Record.AddStmt(VE); 6345 for (auto *E : C->lhs_exprs()) 6346 Record.AddStmt(E); 6347 for (auto *E : C->rhs_exprs()) 6348 Record.AddStmt(E); 6349 for (auto *E : C->reduction_ops()) 6350 Record.AddStmt(E); 6351 for (auto *E : C->taskgroup_descriptors()) 6352 Record.AddStmt(E); 6353 } 6354 6355 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) { 6356 Record.push_back(C->varlist_size()); 6357 VisitOMPClauseWithPostUpdate(C); 6358 Record.AddSourceLocation(C->getLParenLoc()); 6359 Record.AddSourceLocation(C->getColonLoc()); 6360 Record.push_back(C->getModifier()); 6361 Record.AddSourceLocation(C->getModifierLoc()); 6362 for (auto *VE : C->varlists()) { 6363 Record.AddStmt(VE); 6364 } 6365 for (auto *VE : C->privates()) { 6366 Record.AddStmt(VE); 6367 } 6368 for (auto *VE : C->inits()) { 6369 Record.AddStmt(VE); 6370 } 6371 for (auto *VE : C->updates()) { 6372 Record.AddStmt(VE); 6373 } 6374 for (auto *VE : C->finals()) { 6375 Record.AddStmt(VE); 6376 } 6377 Record.AddStmt(C->getStep()); 6378 Record.AddStmt(C->getCalcStep()); 6379 for (auto *VE : C->used_expressions()) 6380 Record.AddStmt(VE); 6381 } 6382 6383 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) { 6384 Record.push_back(C->varlist_size()); 6385 Record.AddSourceLocation(C->getLParenLoc()); 6386 Record.AddSourceLocation(C->getColonLoc()); 6387 for (auto *VE : C->varlists()) 6388 Record.AddStmt(VE); 6389 Record.AddStmt(C->getAlignment()); 6390 } 6391 6392 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) { 6393 Record.push_back(C->varlist_size()); 6394 Record.AddSourceLocation(C->getLParenLoc()); 6395 for (auto *VE : C->varlists()) 6396 Record.AddStmt(VE); 6397 for (auto *E : C->source_exprs()) 6398 Record.AddStmt(E); 6399 for (auto *E : C->destination_exprs()) 6400 Record.AddStmt(E); 6401 for (auto *E : C->assignment_ops()) 6402 Record.AddStmt(E); 6403 } 6404 6405 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) { 6406 Record.push_back(C->varlist_size()); 6407 Record.AddSourceLocation(C->getLParenLoc()); 6408 for (auto *VE : C->varlists()) 6409 Record.AddStmt(VE); 6410 for (auto *E : C->source_exprs()) 6411 Record.AddStmt(E); 6412 for (auto *E : C->destination_exprs()) 6413 Record.AddStmt(E); 6414 for (auto *E : C->assignment_ops()) 6415 Record.AddStmt(E); 6416 } 6417 6418 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) { 6419 Record.push_back(C->varlist_size()); 6420 Record.AddSourceLocation(C->getLParenLoc()); 6421 for (auto *VE : C->varlists()) 6422 Record.AddStmt(VE); 6423 } 6424 6425 void OMPClauseWriter::VisitOMPDepobjClause(OMPDepobjClause *C) { 6426 Record.AddStmt(C->getDepobj()); 6427 Record.AddSourceLocation(C->getLParenLoc()); 6428 } 6429 6430 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) { 6431 Record.push_back(C->varlist_size()); 6432 Record.push_back(C->getNumLoops()); 6433 Record.AddSourceLocation(C->getLParenLoc()); 6434 Record.AddStmt(C->getModifier()); 6435 Record.push_back(C->getDependencyKind()); 6436 Record.AddSourceLocation(C->getDependencyLoc()); 6437 Record.AddSourceLocation(C->getColonLoc()); 6438 for (auto *VE : C->varlists()) 6439 Record.AddStmt(VE); 6440 for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I) 6441 Record.AddStmt(C->getLoopData(I)); 6442 } 6443 6444 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) { 6445 VisitOMPClauseWithPreInit(C); 6446 Record.writeEnum(C->getModifier()); 6447 Record.AddStmt(C->getDevice()); 6448 Record.AddSourceLocation(C->getModifierLoc()); 6449 Record.AddSourceLocation(C->getLParenLoc()); 6450 } 6451 6452 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) { 6453 Record.push_back(C->varlist_size()); 6454 Record.push_back(C->getUniqueDeclarationsNum()); 6455 Record.push_back(C->getTotalComponentListNum()); 6456 Record.push_back(C->getTotalComponentsNum()); 6457 Record.AddSourceLocation(C->getLParenLoc()); 6458 for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) { 6459 Record.push_back(C->getMapTypeModifier(I)); 6460 Record.AddSourceLocation(C->getMapTypeModifierLoc(I)); 6461 } 6462 Record.AddNestedNameSpecifierLoc(C->getMapperQualifierLoc()); 6463 Record.AddDeclarationNameInfo(C->getMapperIdInfo()); 6464 Record.push_back(C->getMapType()); 6465 Record.AddSourceLocation(C->getMapLoc()); 6466 Record.AddSourceLocation(C->getColonLoc()); 6467 for (auto *E : C->varlists()) 6468 Record.AddStmt(E); 6469 for (auto *E : C->mapperlists()) 6470 Record.AddStmt(E); 6471 for (auto *D : C->all_decls()) 6472 Record.AddDeclRef(D); 6473 for (auto N : C->all_num_lists()) 6474 Record.push_back(N); 6475 for (auto N : C->all_lists_sizes()) 6476 Record.push_back(N); 6477 for (auto &M : C->all_components()) { 6478 Record.AddStmt(M.getAssociatedExpression()); 6479 Record.AddDeclRef(M.getAssociatedDeclaration()); 6480 } 6481 } 6482 6483 void OMPClauseWriter::VisitOMPAllocateClause(OMPAllocateClause *C) { 6484 Record.push_back(C->varlist_size()); 6485 Record.AddSourceLocation(C->getLParenLoc()); 6486 Record.AddSourceLocation(C->getColonLoc()); 6487 Record.AddStmt(C->getAllocator()); 6488 for (auto *VE : C->varlists()) 6489 Record.AddStmt(VE); 6490 } 6491 6492 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) { 6493 VisitOMPClauseWithPreInit(C); 6494 Record.AddStmt(C->getNumTeams()); 6495 Record.AddSourceLocation(C->getLParenLoc()); 6496 } 6497 6498 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) { 6499 VisitOMPClauseWithPreInit(C); 6500 Record.AddStmt(C->getThreadLimit()); 6501 Record.AddSourceLocation(C->getLParenLoc()); 6502 } 6503 6504 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) { 6505 VisitOMPClauseWithPreInit(C); 6506 Record.AddStmt(C->getPriority()); 6507 Record.AddSourceLocation(C->getLParenLoc()); 6508 } 6509 6510 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) { 6511 VisitOMPClauseWithPreInit(C); 6512 Record.AddStmt(C->getGrainsize()); 6513 Record.AddSourceLocation(C->getLParenLoc()); 6514 } 6515 6516 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) { 6517 VisitOMPClauseWithPreInit(C); 6518 Record.AddStmt(C->getNumTasks()); 6519 Record.AddSourceLocation(C->getLParenLoc()); 6520 } 6521 6522 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) { 6523 Record.AddStmt(C->getHint()); 6524 Record.AddSourceLocation(C->getLParenLoc()); 6525 } 6526 6527 void OMPClauseWriter::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) { 6528 VisitOMPClauseWithPreInit(C); 6529 Record.push_back(C->getDistScheduleKind()); 6530 Record.AddStmt(C->getChunkSize()); 6531 Record.AddSourceLocation(C->getLParenLoc()); 6532 Record.AddSourceLocation(C->getDistScheduleKindLoc()); 6533 Record.AddSourceLocation(C->getCommaLoc()); 6534 } 6535 6536 void OMPClauseWriter::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { 6537 Record.push_back(C->getDefaultmapKind()); 6538 Record.push_back(C->getDefaultmapModifier()); 6539 Record.AddSourceLocation(C->getLParenLoc()); 6540 Record.AddSourceLocation(C->getDefaultmapModifierLoc()); 6541 Record.AddSourceLocation(C->getDefaultmapKindLoc()); 6542 } 6543 6544 void OMPClauseWriter::VisitOMPToClause(OMPToClause *C) { 6545 Record.push_back(C->varlist_size()); 6546 Record.push_back(C->getUniqueDeclarationsNum()); 6547 Record.push_back(C->getTotalComponentListNum()); 6548 Record.push_back(C->getTotalComponentsNum()); 6549 Record.AddSourceLocation(C->getLParenLoc()); 6550 for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) { 6551 Record.push_back(C->getMotionModifier(I)); 6552 Record.AddSourceLocation(C->getMotionModifierLoc(I)); 6553 } 6554 Record.AddNestedNameSpecifierLoc(C->getMapperQualifierLoc()); 6555 Record.AddDeclarationNameInfo(C->getMapperIdInfo()); 6556 Record.AddSourceLocation(C->getColonLoc()); 6557 for (auto *E : C->varlists()) 6558 Record.AddStmt(E); 6559 for (auto *E : C->mapperlists()) 6560 Record.AddStmt(E); 6561 for (auto *D : C->all_decls()) 6562 Record.AddDeclRef(D); 6563 for (auto N : C->all_num_lists()) 6564 Record.push_back(N); 6565 for (auto N : C->all_lists_sizes()) 6566 Record.push_back(N); 6567 for (auto &M : C->all_components()) { 6568 Record.AddStmt(M.getAssociatedExpression()); 6569 Record.writeBool(M.isNonContiguous()); 6570 Record.AddDeclRef(M.getAssociatedDeclaration()); 6571 } 6572 } 6573 6574 void OMPClauseWriter::VisitOMPFromClause(OMPFromClause *C) { 6575 Record.push_back(C->varlist_size()); 6576 Record.push_back(C->getUniqueDeclarationsNum()); 6577 Record.push_back(C->getTotalComponentListNum()); 6578 Record.push_back(C->getTotalComponentsNum()); 6579 Record.AddSourceLocation(C->getLParenLoc()); 6580 for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) { 6581 Record.push_back(C->getMotionModifier(I)); 6582 Record.AddSourceLocation(C->getMotionModifierLoc(I)); 6583 } 6584 Record.AddNestedNameSpecifierLoc(C->getMapperQualifierLoc()); 6585 Record.AddDeclarationNameInfo(C->getMapperIdInfo()); 6586 Record.AddSourceLocation(C->getColonLoc()); 6587 for (auto *E : C->varlists()) 6588 Record.AddStmt(E); 6589 for (auto *E : C->mapperlists()) 6590 Record.AddStmt(E); 6591 for (auto *D : C->all_decls()) 6592 Record.AddDeclRef(D); 6593 for (auto N : C->all_num_lists()) 6594 Record.push_back(N); 6595 for (auto N : C->all_lists_sizes()) 6596 Record.push_back(N); 6597 for (auto &M : C->all_components()) { 6598 Record.AddStmt(M.getAssociatedExpression()); 6599 Record.writeBool(M.isNonContiguous()); 6600 Record.AddDeclRef(M.getAssociatedDeclaration()); 6601 } 6602 } 6603 6604 void OMPClauseWriter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) { 6605 Record.push_back(C->varlist_size()); 6606 Record.push_back(C->getUniqueDeclarationsNum()); 6607 Record.push_back(C->getTotalComponentListNum()); 6608 Record.push_back(C->getTotalComponentsNum()); 6609 Record.AddSourceLocation(C->getLParenLoc()); 6610 for (auto *E : C->varlists()) 6611 Record.AddStmt(E); 6612 for (auto *VE : C->private_copies()) 6613 Record.AddStmt(VE); 6614 for (auto *VE : C->inits()) 6615 Record.AddStmt(VE); 6616 for (auto *D : C->all_decls()) 6617 Record.AddDeclRef(D); 6618 for (auto N : C->all_num_lists()) 6619 Record.push_back(N); 6620 for (auto N : C->all_lists_sizes()) 6621 Record.push_back(N); 6622 for (auto &M : C->all_components()) { 6623 Record.AddStmt(M.getAssociatedExpression()); 6624 Record.AddDeclRef(M.getAssociatedDeclaration()); 6625 } 6626 } 6627 6628 void OMPClauseWriter::VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause *C) { 6629 Record.push_back(C->varlist_size()); 6630 Record.push_back(C->getUniqueDeclarationsNum()); 6631 Record.push_back(C->getTotalComponentListNum()); 6632 Record.push_back(C->getTotalComponentsNum()); 6633 Record.AddSourceLocation(C->getLParenLoc()); 6634 for (auto *E : C->varlists()) 6635 Record.AddStmt(E); 6636 for (auto *D : C->all_decls()) 6637 Record.AddDeclRef(D); 6638 for (auto N : C->all_num_lists()) 6639 Record.push_back(N); 6640 for (auto N : C->all_lists_sizes()) 6641 Record.push_back(N); 6642 for (auto &M : C->all_components()) { 6643 Record.AddStmt(M.getAssociatedExpression()); 6644 Record.AddDeclRef(M.getAssociatedDeclaration()); 6645 } 6646 } 6647 6648 void OMPClauseWriter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { 6649 Record.push_back(C->varlist_size()); 6650 Record.push_back(C->getUniqueDeclarationsNum()); 6651 Record.push_back(C->getTotalComponentListNum()); 6652 Record.push_back(C->getTotalComponentsNum()); 6653 Record.AddSourceLocation(C->getLParenLoc()); 6654 for (auto *E : C->varlists()) 6655 Record.AddStmt(E); 6656 for (auto *D : C->all_decls()) 6657 Record.AddDeclRef(D); 6658 for (auto N : C->all_num_lists()) 6659 Record.push_back(N); 6660 for (auto N : C->all_lists_sizes()) 6661 Record.push_back(N); 6662 for (auto &M : C->all_components()) { 6663 Record.AddStmt(M.getAssociatedExpression()); 6664 Record.AddDeclRef(M.getAssociatedDeclaration()); 6665 } 6666 } 6667 6668 void OMPClauseWriter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {} 6669 6670 void OMPClauseWriter::VisitOMPUnifiedSharedMemoryClause( 6671 OMPUnifiedSharedMemoryClause *) {} 6672 6673 void OMPClauseWriter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {} 6674 6675 void 6676 OMPClauseWriter::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) { 6677 } 6678 6679 void OMPClauseWriter::VisitOMPAtomicDefaultMemOrderClause( 6680 OMPAtomicDefaultMemOrderClause *C) { 6681 Record.push_back(C->getAtomicDefaultMemOrderKind()); 6682 Record.AddSourceLocation(C->getLParenLoc()); 6683 Record.AddSourceLocation(C->getAtomicDefaultMemOrderKindKwLoc()); 6684 } 6685 6686 void OMPClauseWriter::VisitOMPNontemporalClause(OMPNontemporalClause *C) { 6687 Record.push_back(C->varlist_size()); 6688 Record.AddSourceLocation(C->getLParenLoc()); 6689 for (auto *VE : C->varlists()) 6690 Record.AddStmt(VE); 6691 for (auto *E : C->private_refs()) 6692 Record.AddStmt(E); 6693 } 6694 6695 void OMPClauseWriter::VisitOMPInclusiveClause(OMPInclusiveClause *C) { 6696 Record.push_back(C->varlist_size()); 6697 Record.AddSourceLocation(C->getLParenLoc()); 6698 for (auto *VE : C->varlists()) 6699 Record.AddStmt(VE); 6700 } 6701 6702 void OMPClauseWriter::VisitOMPExclusiveClause(OMPExclusiveClause *C) { 6703 Record.push_back(C->varlist_size()); 6704 Record.AddSourceLocation(C->getLParenLoc()); 6705 for (auto *VE : C->varlists()) 6706 Record.AddStmt(VE); 6707 } 6708 6709 void OMPClauseWriter::VisitOMPOrderClause(OMPOrderClause *C) { 6710 Record.writeEnum(C->getKind()); 6711 Record.AddSourceLocation(C->getLParenLoc()); 6712 Record.AddSourceLocation(C->getKindKwLoc()); 6713 } 6714 6715 void OMPClauseWriter::VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause *C) { 6716 Record.push_back(C->getNumberOfAllocators()); 6717 Record.AddSourceLocation(C->getLParenLoc()); 6718 for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) { 6719 OMPUsesAllocatorsClause::Data Data = C->getAllocatorData(I); 6720 Record.AddStmt(Data.Allocator); 6721 Record.AddStmt(Data.AllocatorTraits); 6722 Record.AddSourceLocation(Data.LParenLoc); 6723 Record.AddSourceLocation(Data.RParenLoc); 6724 } 6725 } 6726 6727 void OMPClauseWriter::VisitOMPAffinityClause(OMPAffinityClause *C) { 6728 Record.push_back(C->varlist_size()); 6729 Record.AddSourceLocation(C->getLParenLoc()); 6730 Record.AddStmt(C->getModifier()); 6731 Record.AddSourceLocation(C->getColonLoc()); 6732 for (Expr *E : C->varlists()) 6733 Record.AddStmt(E); 6734 } 6735 6736 void ASTRecordWriter::writeOMPTraitInfo(const OMPTraitInfo *TI) { 6737 writeUInt32(TI->Sets.size()); 6738 for (const auto &Set : TI->Sets) { 6739 writeEnum(Set.Kind); 6740 writeUInt32(Set.Selectors.size()); 6741 for (const auto &Selector : Set.Selectors) { 6742 writeEnum(Selector.Kind); 6743 writeBool(Selector.ScoreOrCondition); 6744 if (Selector.ScoreOrCondition) 6745 writeExprRef(Selector.ScoreOrCondition); 6746 writeUInt32(Selector.Properties.size()); 6747 for (const auto &Property : Selector.Properties) 6748 writeEnum(Property.Kind); 6749 } 6750 } 6751 } 6752 6753 void ASTRecordWriter::writeOMPChildren(OMPChildren *Data) { 6754 if (!Data) 6755 return; 6756 writeUInt32(Data->getNumClauses()); 6757 writeUInt32(Data->getNumChildren()); 6758 writeBool(Data->hasAssociatedStmt()); 6759 for (unsigned I = 0, E = Data->getNumClauses(); I < E; ++I) 6760 writeOMPClause(Data->getClauses()[I]); 6761 if (Data->hasAssociatedStmt()) 6762 AddStmt(Data->getAssociatedStmt()); 6763 for (unsigned I = 0, E = Data->getNumChildren(); I < E; ++I) 6764 AddStmt(Data->getChildren()[I]); 6765 } 6766