brintos / llvm-project-archived public Read only

1//===- ASTReaderDecl.cpp - Decl Deserialization ---------------------------===//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-exception6//7//===----------------------------------------------------------------------===//8//9// This file implements the ASTReader::readDeclRecord method, which is the10// entrypoint for loading a decl.11//12//===----------------------------------------------------------------------===//13 14#include "ASTCommon.h"15#include "ASTReaderInternals.h"16#include "clang/AST/ASTConcept.h"17#include "clang/AST/ASTContext.h"18#include "clang/AST/ASTStructuralEquivalence.h"19#include "clang/AST/Attr.h"20#include "clang/AST/AttrIterator.h"21#include "clang/AST/Decl.h"22#include "clang/AST/DeclBase.h"23#include "clang/AST/DeclCXX.h"24#include "clang/AST/DeclFriend.h"25#include "clang/AST/DeclObjC.h"26#include "clang/AST/DeclOpenMP.h"27#include "clang/AST/DeclTemplate.h"28#include "clang/AST/DeclVisitor.h"29#include "clang/AST/DeclarationName.h"30#include "clang/AST/Expr.h"31#include "clang/AST/ExternalASTSource.h"32#include "clang/AST/LambdaCapture.h"33#include "clang/AST/NestedNameSpecifier.h"34#include "clang/AST/OpenMPClause.h"35#include "clang/AST/Redeclarable.h"36#include "clang/AST/Stmt.h"37#include "clang/AST/TemplateBase.h"38#include "clang/AST/Type.h"39#include "clang/AST/UnresolvedSet.h"40#include "clang/Basic/AttrKinds.h"41#include "clang/Basic/DiagnosticSema.h"42#include "clang/Basic/ExceptionSpecificationType.h"43#include "clang/Basic/IdentifierTable.h"44#include "clang/Basic/LLVM.h"45#include "clang/Basic/Lambda.h"46#include "clang/Basic/LangOptions.h"47#include "clang/Basic/Linkage.h"48#include "clang/Basic/Module.h"49#include "clang/Basic/PragmaKinds.h"50#include "clang/Basic/SourceLocation.h"51#include "clang/Basic/Specifiers.h"52#include "clang/Sema/IdentifierResolver.h"53#include "clang/Serialization/ASTBitCodes.h"54#include "clang/Serialization/ASTRecordReader.h"55#include "clang/Serialization/ContinuousRangeMap.h"56#include "clang/Serialization/ModuleFile.h"57#include "llvm/ADT/DenseMap.h"58#include "llvm/ADT/FoldingSet.h"59#include "llvm/ADT/SmallPtrSet.h"60#include "llvm/ADT/SmallVector.h"61#include "llvm/ADT/iterator_range.h"62#include "llvm/Bitstream/BitstreamReader.h"63#include "llvm/Support/ErrorHandling.h"64#include "llvm/Support/SaveAndRestore.h"65#include <algorithm>66#include <cassert>67#include <cstdint>68#include <cstring>69#include <string>70#include <utility>71 72using namespace clang;73using namespace serialization;74 75//===----------------------------------------------------------------------===//76// Declaration Merging77//===----------------------------------------------------------------------===//78 79namespace {80/// Results from loading a RedeclarableDecl.81class RedeclarableResult {82  Decl *MergeWith;83  GlobalDeclID FirstID;84  bool IsKeyDecl;85 86public:87  RedeclarableResult(Decl *MergeWith, GlobalDeclID FirstID, bool IsKeyDecl)88      : MergeWith(MergeWith), FirstID(FirstID), IsKeyDecl(IsKeyDecl) {}89 90  /// Retrieve the first ID.91  GlobalDeclID getFirstID() const { return FirstID; }92 93  /// Is this declaration a key declaration?94  bool isKeyDecl() const { return IsKeyDecl; }95 96  /// Get a known declaration that this should be merged with, if97  /// any.98  Decl *getKnownMergeTarget() const { return MergeWith; }99};100} // namespace101 102namespace clang {103class ASTDeclMerger {104  ASTReader &Reader;105 106public:107  ASTDeclMerger(ASTReader &Reader) : Reader(Reader) {}108 109  void mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl, Decl &Context,110                   unsigned Number);111 112  /// \param KeyDeclID the decl ID of the key declaration \param D.113  /// GlobalDeclID() if \param is not a key declaration.114  /// See the comments of ASTReader::KeyDecls for the explanation115  /// of key declaration.116  template <typename T>117  void mergeRedeclarableImpl(Redeclarable<T> *D, T *Existing,118                             GlobalDeclID KeyDeclID);119 120  template <typename T>121  void mergeRedeclarable(Redeclarable<T> *D, T *Existing,122                         RedeclarableResult &Redecl) {123    mergeRedeclarableImpl(124        D, Existing, Redecl.isKeyDecl() ? Redecl.getFirstID() : GlobalDeclID());125  }126 127  void mergeTemplatePattern(RedeclarableTemplateDecl *D,128                            RedeclarableTemplateDecl *Existing, bool IsKeyDecl);129 130  void MergeDefinitionData(CXXRecordDecl *D,131                           struct CXXRecordDecl::DefinitionData &&NewDD);132  void MergeDefinitionData(ObjCInterfaceDecl *D,133                           struct ObjCInterfaceDecl::DefinitionData &&NewDD);134  void MergeDefinitionData(ObjCProtocolDecl *D,135                           struct ObjCProtocolDecl::DefinitionData &&NewDD);136};137} // namespace clang138 139//===----------------------------------------------------------------------===//140// Declaration deserialization141//===----------------------------------------------------------------------===//142 143namespace clang {144class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {145  ASTReader &Reader;146  ASTDeclMerger MergeImpl;147  ASTRecordReader &Record;148  ASTReader::RecordLocation Loc;149  const GlobalDeclID ThisDeclID;150  const SourceLocation ThisDeclLoc;151 152  using RecordData = ASTReader::RecordData;153 154  TypeID DeferredTypeID = 0;155  unsigned AnonymousDeclNumber = 0;156  GlobalDeclID NamedDeclForTagDecl = GlobalDeclID();157  IdentifierInfo *TypedefNameForLinkage = nullptr;158 159  /// A flag to carry the information for a decl from the entity is160  ///  used. We use it to delay the marking of the canonical decl as used until161  ///  the entire declaration is deserialized and merged.162  bool IsDeclMarkedUsed = false;163 164  uint64_t GetCurrentCursorOffset();165 166  uint64_t ReadLocalOffset() {167    uint64_t LocalOffset = Record.readInt();168    assert(LocalOffset < Loc.Offset && "offset point after current record");169    return LocalOffset ? Loc.Offset - LocalOffset : 0;170  }171 172  uint64_t ReadGlobalOffset() {173    uint64_t Local = ReadLocalOffset();174    return Local ? Record.getGlobalBitOffset(Local) : 0;175  }176 177  SourceLocation readSourceLocation() { return Record.readSourceLocation(); }178 179  SourceRange readSourceRange() { return Record.readSourceRange(); }180 181  TypeSourceInfo *readTypeSourceInfo() { return Record.readTypeSourceInfo(); }182 183  GlobalDeclID readDeclID() { return Record.readDeclID(); }184 185  std::string readString() { return Record.readString(); }186 187  Decl *readDecl() { return Record.readDecl(); }188 189  template <typename T> T *readDeclAs() { return Record.readDeclAs<T>(); }190 191  serialization::SubmoduleID readSubmoduleID() {192    if (Record.getIdx() == Record.size())193      return 0;194 195    return Record.getGlobalSubmoduleID(Record.readInt());196  }197 198  Module *readModule() { return Record.getSubmodule(readSubmoduleID()); }199 200  void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,201                               Decl *LambdaContext = nullptr,202                               unsigned IndexInLambdaContext = 0);203  void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,204                             const CXXRecordDecl *D, Decl *LambdaContext,205                             unsigned IndexInLambdaContext);206  void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data);207  void ReadObjCDefinitionData(struct ObjCProtocolDecl::DefinitionData &Data);208 209  static DeclContext *getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC);210 211  static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,212                                               DeclContext *DC, unsigned Index);213  static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,214                                         unsigned Index, NamedDecl *D);215 216  /// Commit to a primary definition of the class RD, which is known to be217  /// a definition of the class. We might not have read the definition data218  /// for it yet. If we haven't then allocate placeholder definition data219  /// now too.220  static CXXRecordDecl *getOrFakePrimaryClassDefinition(ASTReader &Reader,221                                                        CXXRecordDecl *RD);222 223  /// Class used to capture the result of searching for an existing224  /// declaration of a specific kind and name, along with the ability225  /// to update the place where this result was found (the declaration226  /// chain hanging off an identifier or the DeclContext we searched in)227  /// if requested.228  class FindExistingResult {229    ASTReader &Reader;230    NamedDecl *New = nullptr;231    NamedDecl *Existing = nullptr;232    bool AddResult = false;233    unsigned AnonymousDeclNumber = 0;234    IdentifierInfo *TypedefNameForLinkage = nullptr;235 236  public:237    FindExistingResult(ASTReader &Reader) : Reader(Reader) {}238 239    FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,240                       unsigned AnonymousDeclNumber,241                       IdentifierInfo *TypedefNameForLinkage)242        : Reader(Reader), New(New), Existing(Existing), AddResult(true),243          AnonymousDeclNumber(AnonymousDeclNumber),244          TypedefNameForLinkage(TypedefNameForLinkage) {}245 246    FindExistingResult(FindExistingResult &&Other)247        : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),248          AddResult(Other.AddResult),249          AnonymousDeclNumber(Other.AnonymousDeclNumber),250          TypedefNameForLinkage(Other.TypedefNameForLinkage) {251      Other.AddResult = false;252    }253 254    FindExistingResult &operator=(FindExistingResult &&) = delete;255    ~FindExistingResult();256 257    /// Suppress the addition of this result into the known set of258    /// names.259    void suppress() { AddResult = false; }260 261    operator NamedDecl *() const { return Existing; }262 263    template <typename T> operator T *() const {264      return dyn_cast_or_null<T>(Existing);265    }266  };267 268  static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,269                                                  DeclContext *DC);270  FindExistingResult findExisting(NamedDecl *D);271 272public:273  ASTDeclReader(ASTReader &Reader, ASTRecordReader &Record,274                ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID,275                SourceLocation ThisDeclLoc)276      : Reader(Reader), MergeImpl(Reader), Record(Record), Loc(Loc),277        ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc) {}278 279  template <typename DeclT>280  static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);281  static Decl *getMostRecentDeclImpl(...);282  static Decl *getMostRecentDecl(Decl *D);283 284  template <typename DeclT>285  static void attachPreviousDeclImpl(ASTReader &Reader, Redeclarable<DeclT> *D,286                                     Decl *Previous, Decl *Canon);287  static void attachPreviousDeclImpl(ASTReader &Reader, ...);288  static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,289                                 Decl *Canon);290 291  static void checkMultipleDefinitionInNamedModules(ASTReader &Reader, Decl *D,292                                                    Decl *Previous);293 294  template <typename DeclT>295  static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);296  static void attachLatestDeclImpl(...);297  static void attachLatestDecl(Decl *D, Decl *latest);298 299  template <typename DeclT>300  static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);301  static void markIncompleteDeclChainImpl(...);302 303  void ReadSpecializations(ModuleFile &M, Decl *D,304                           llvm::BitstreamCursor &DeclsCursor, bool IsPartial);305 306  void ReadFunctionDefinition(FunctionDecl *FD);307  void Visit(Decl *D);308 309  void UpdateDecl(Decl *D);310 311  static void setNextObjCCategory(ObjCCategoryDecl *Cat,312                                  ObjCCategoryDecl *Next) {313    Cat->NextClassCategory = Next;314  }315 316  void VisitDecl(Decl *D);317  void VisitPragmaCommentDecl(PragmaCommentDecl *D);318  void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);319  void VisitTranslationUnitDecl(TranslationUnitDecl *TU);320  void VisitNamedDecl(NamedDecl *ND);321  void VisitLabelDecl(LabelDecl *LD);322  void VisitNamespaceDecl(NamespaceDecl *D);323  void VisitHLSLBufferDecl(HLSLBufferDecl *D);324  void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);325  void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);326  void VisitTypeDecl(TypeDecl *TD);327  RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);328  void VisitTypedefDecl(TypedefDecl *TD);329  void VisitTypeAliasDecl(TypeAliasDecl *TD);330  void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);331  void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);332  RedeclarableResult VisitTagDecl(TagDecl *TD);333  void VisitEnumDecl(EnumDecl *ED);334  RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);335  void VisitRecordDecl(RecordDecl *RD);336  RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);337  void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }338  RedeclarableResult339  VisitClassTemplateSpecializationDeclImpl(ClassTemplateSpecializationDecl *D);340 341  void342  VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) {343    VisitClassTemplateSpecializationDeclImpl(D);344  }345 346  void VisitClassTemplatePartialSpecializationDecl(347      ClassTemplatePartialSpecializationDecl *D);348  RedeclarableResult349  VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);350 351  void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {352    VisitVarTemplateSpecializationDeclImpl(D);353  }354 355  void VisitVarTemplatePartialSpecializationDecl(356      VarTemplatePartialSpecializationDecl *D);357  void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);358  void VisitValueDecl(ValueDecl *VD);359  void VisitEnumConstantDecl(EnumConstantDecl *ECD);360  void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);361  void VisitDeclaratorDecl(DeclaratorDecl *DD);362  void VisitFunctionDecl(FunctionDecl *FD);363  void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *GD);364  void VisitCXXMethodDecl(CXXMethodDecl *D);365  void VisitCXXConstructorDecl(CXXConstructorDecl *D);366  void VisitCXXDestructorDecl(CXXDestructorDecl *D);367  void VisitCXXConversionDecl(CXXConversionDecl *D);368  void VisitFieldDecl(FieldDecl *FD);369  void VisitMSPropertyDecl(MSPropertyDecl *FD);370  void VisitMSGuidDecl(MSGuidDecl *D);371  void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D);372  void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);373  void VisitIndirectFieldDecl(IndirectFieldDecl *FD);374  RedeclarableResult VisitVarDeclImpl(VarDecl *D);375  void ReadVarDeclInit(VarDecl *VD);376  void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }377  void VisitImplicitParamDecl(ImplicitParamDecl *PD);378  void VisitParmVarDecl(ParmVarDecl *PD);379  void VisitDecompositionDecl(DecompositionDecl *DD);380  void VisitBindingDecl(BindingDecl *BD);381  void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);382  void VisitTemplateDecl(TemplateDecl *D);383  void VisitConceptDecl(ConceptDecl *D);384  void385  VisitImplicitConceptSpecializationDecl(ImplicitConceptSpecializationDecl *D);386  void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);387  RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);388  void VisitClassTemplateDecl(ClassTemplateDecl *D);389  void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);390  void VisitVarTemplateDecl(VarTemplateDecl *D);391  void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);392  void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);393  void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);394  void VisitUsingDecl(UsingDecl *D);395  void VisitUsingEnumDecl(UsingEnumDecl *D);396  void VisitUsingPackDecl(UsingPackDecl *D);397  void VisitUsingShadowDecl(UsingShadowDecl *D);398  void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);399  void VisitLinkageSpecDecl(LinkageSpecDecl *D);400  void VisitExportDecl(ExportDecl *D);401  void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);402  void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);403  void VisitImportDecl(ImportDecl *D);404  void VisitAccessSpecDecl(AccessSpecDecl *D);405  void VisitFriendDecl(FriendDecl *D);406  void VisitFriendTemplateDecl(FriendTemplateDecl *D);407  void VisitStaticAssertDecl(StaticAssertDecl *D);408  void VisitBlockDecl(BlockDecl *BD);409  void VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D);410  void VisitCapturedDecl(CapturedDecl *CD);411  void VisitEmptyDecl(EmptyDecl *D);412  void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);413 414  void VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D);415  void VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D);416 417  void VisitDeclContext(DeclContext *DC, LookupBlockOffsets &Offsets);418 419  template <typename T>420  RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);421 422  template <typename T>423  void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);424 425  void mergeRedeclarableTemplate(RedeclarableTemplateDecl *D,426                                 RedeclarableResult &Redecl);427 428  template <typename T> void mergeMergeable(Mergeable<T> *D);429 430  void mergeMergeable(LifetimeExtendedTemporaryDecl *D);431 432  ObjCTypeParamList *ReadObjCTypeParamList();433 434  // FIXME: Reorder according to DeclNodes.td?435  void VisitObjCMethodDecl(ObjCMethodDecl *D);436  void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);437  void VisitObjCContainerDecl(ObjCContainerDecl *D);438  void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);439  void VisitObjCIvarDecl(ObjCIvarDecl *D);440  void VisitObjCProtocolDecl(ObjCProtocolDecl *D);441  void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);442  void VisitObjCCategoryDecl(ObjCCategoryDecl *D);443  void VisitObjCImplDecl(ObjCImplDecl *D);444  void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);445  void VisitObjCImplementationDecl(ObjCImplementationDecl *D);446  void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);447  void VisitObjCPropertyDecl(ObjCPropertyDecl *D);448  void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);449  void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);450  void VisitOMPAllocateDecl(OMPAllocateDecl *D);451  void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);452  void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);453  void VisitOMPRequiresDecl(OMPRequiresDecl *D);454  void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);455};456} // namespace clang457 458namespace {459 460/// Iterator over the redeclarations of a declaration that have already461/// been merged into the same redeclaration chain.462template <typename DeclT> class MergedRedeclIterator {463  DeclT *Start = nullptr;464  DeclT *Canonical = nullptr;465  DeclT *Current = nullptr;466 467public:468  MergedRedeclIterator() = default;469  MergedRedeclIterator(DeclT *Start) : Start(Start), Current(Start) {}470 471  DeclT *operator*() { return Current; }472 473  MergedRedeclIterator &operator++() {474    if (Current->isFirstDecl()) {475      Canonical = Current;476      Current = Current->getMostRecentDecl();477    } else478      Current = Current->getPreviousDecl();479 480    // If we started in the merged portion, we'll reach our start position481    // eventually. Otherwise, we'll never reach it, but the second declaration482    // we reached was the canonical declaration, so stop when we see that one483    // again.484    if (Current == Start || Current == Canonical)485      Current = nullptr;486    return *this;487  }488 489  friend bool operator!=(const MergedRedeclIterator &A,490                         const MergedRedeclIterator &B) {491    return A.Current != B.Current;492  }493};494 495} // namespace496 497template <typename DeclT>498static llvm::iterator_range<MergedRedeclIterator<DeclT>>499merged_redecls(DeclT *D) {500  return llvm::make_range(MergedRedeclIterator<DeclT>(D),501                          MergedRedeclIterator<DeclT>());502}503 504uint64_t ASTDeclReader::GetCurrentCursorOffset() {505  return Loc.F->DeclsCursor.GetCurrentBitNo() + Loc.F->GlobalBitOffset;506}507 508void ASTDeclReader::ReadFunctionDefinition(FunctionDecl *FD) {509  if (Record.readInt()) {510    Reader.DefinitionSource[FD] =511        Loc.F->Kind == ModuleKind::MK_MainFile ||512        Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;513  }514  if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {515    CD->setNumCtorInitializers(Record.readInt());516    if (CD->getNumCtorInitializers())517      CD->CtorInitializers = ReadGlobalOffset();518  }519  // Store the offset of the body so we can lazily load it later.520  Reader.PendingBodies[FD] = GetCurrentCursorOffset();521  // For now remember ThisDeclarationWasADefinition only for friend functions.522  if (FD->getFriendObjectKind())523    Reader.ThisDeclarationWasADefinitionSet.insert(FD);524}525 526void ASTDeclReader::Visit(Decl *D) {527  DeclVisitor<ASTDeclReader, void>::Visit(D);528 529  // At this point we have deserialized and merged the decl and it is safe to530  // update its canonical decl to signal that the entire entity is used.531  D->getCanonicalDecl()->Used |= IsDeclMarkedUsed;532  IsDeclMarkedUsed = false;533 534  if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {535    if (auto *TInfo = DD->getTypeSourceInfo())536      Record.readTypeLoc(TInfo->getTypeLoc());537  }538 539  if (auto *TD = dyn_cast<TypeDecl>(D)) {540    // We have a fully initialized TypeDecl. Read its type now.541    if (isa<TagDecl, TypedefDecl, TypeAliasDecl>(TD))542      assert(DeferredTypeID == 0 &&543             "Deferred type not used for TagDecls and Typedefs");544    else545      TD->setTypeForDecl(Reader.GetType(DeferredTypeID).getTypePtrOrNull());546 547    // If this is a tag declaration with a typedef name for linkage, it's safe548    // to load that typedef now.549    if (NamedDeclForTagDecl.isValid())550      cast<TagDecl>(D)->TypedefNameDeclOrQualifier =551          cast<TypedefNameDecl>(Reader.GetDecl(NamedDeclForTagDecl));552  } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {553    // if we have a fully initialized TypeDecl, we can safely read its type now.554    ID->TypeForDecl = Reader.GetType(DeferredTypeID).getTypePtrOrNull();555  } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {556    // FunctionDecl's body was written last after all other Stmts/Exprs.557    if (Record.readInt())558      ReadFunctionDefinition(FD);559  } else if (auto *VD = dyn_cast<VarDecl>(D)) {560    ReadVarDeclInit(VD);561  } else if (auto *FD = dyn_cast<FieldDecl>(D)) {562    if (FD->hasInClassInitializer() && Record.readInt()) {563      FD->setLazyInClassInitializer(LazyDeclStmtPtr(GetCurrentCursorOffset()));564    }565  }566}567 568void ASTDeclReader::VisitDecl(Decl *D) {569  BitsUnpacker DeclBits(Record.readInt());570  auto ModuleOwnership =571      (Decl::ModuleOwnershipKind)DeclBits.getNextBits(/*Width=*/3);572  D->setReferenced(DeclBits.getNextBit());573  D->Used = DeclBits.getNextBit();574  IsDeclMarkedUsed |= D->Used;575  D->setAccess((AccessSpecifier)DeclBits.getNextBits(/*Width=*/2));576  D->setImplicit(DeclBits.getNextBit());577  bool HasStandaloneLexicalDC = DeclBits.getNextBit();578  bool HasAttrs = DeclBits.getNextBit();579  D->setTopLevelDeclInObjCContainer(DeclBits.getNextBit());580  D->InvalidDecl = DeclBits.getNextBit();581  D->FromASTFile = true;582 583  if (D->isTemplateParameter() || D->isTemplateParameterPack() ||584      isa<ParmVarDecl, ObjCTypeParamDecl>(D)) {585    // We don't want to deserialize the DeclContext of a template586    // parameter or of a parameter of a function template immediately.   These587    // entities might be used in the formulation of its DeclContext (for588    // example, a function parameter can be used in decltype() in trailing589    // return type of the function).  Use the translation unit DeclContext as a590    // placeholder.591    GlobalDeclID SemaDCIDForTemplateParmDecl = readDeclID();592    GlobalDeclID LexicalDCIDForTemplateParmDecl =593        HasStandaloneLexicalDC ? readDeclID() : GlobalDeclID();594    if (LexicalDCIDForTemplateParmDecl.isInvalid())595      LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;596    Reader.addPendingDeclContextInfo(D,597                                     SemaDCIDForTemplateParmDecl,598                                     LexicalDCIDForTemplateParmDecl);599    D->setDeclContext(Reader.getContext().getTranslationUnitDecl());600  } else {601    auto *SemaDC = readDeclAs<DeclContext>();602    auto *LexicalDC =603        HasStandaloneLexicalDC ? readDeclAs<DeclContext>() : nullptr;604    if (!LexicalDC)605      LexicalDC = SemaDC;606    // If the context is a class, we might not have actually merged it yet, in607    // the case where the definition comes from an update record.608    DeclContext *MergedSemaDC;609    if (auto *RD = dyn_cast<CXXRecordDecl>(SemaDC))610      MergedSemaDC = getOrFakePrimaryClassDefinition(Reader, RD);611    else612      MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);613    // Avoid calling setLexicalDeclContext() directly because it uses614    // Decl::getASTContext() internally which is unsafe during derialization.615    D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,616                           Reader.getContext());617  }618  D->setLocation(ThisDeclLoc);619 620  if (HasAttrs) {621    AttrVec Attrs;622    Record.readAttributes(Attrs);623    // Avoid calling setAttrs() directly because it uses Decl::getASTContext()624    // internally which is unsafe during derialization.625    D->setAttrsImpl(Attrs, Reader.getContext());626  }627 628  // Determine whether this declaration is part of a (sub)module. If so, it629  // may not yet be visible.630  bool ModulePrivate =631      (ModuleOwnership == Decl::ModuleOwnershipKind::ModulePrivate);632  if (unsigned SubmoduleID = readSubmoduleID()) {633    switch (ModuleOwnership) {634    case Decl::ModuleOwnershipKind::Visible:635      ModuleOwnership = Decl::ModuleOwnershipKind::VisibleWhenImported;636      break;637    case Decl::ModuleOwnershipKind::Unowned:638    case Decl::ModuleOwnershipKind::VisibleWhenImported:639    case Decl::ModuleOwnershipKind::ReachableWhenImported:640    case Decl::ModuleOwnershipKind::ModulePrivate:641      break;642    }643 644    D->setModuleOwnershipKind(ModuleOwnership);645    // Store the owning submodule ID in the declaration.646    D->setOwningModuleID(SubmoduleID);647 648    if (ModulePrivate) {649      // Module-private declarations are never visible, so there is no work to650      // do.651    } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {652      // If local visibility is being tracked, this declaration will become653      // hidden and visible as the owning module does.654    } else if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {655      // Mark the declaration as visible when its owning module becomes visible.656      if (Owner->NameVisibility == Module::AllVisible)657        D->setVisibleDespiteOwningModule();658      else659        Reader.HiddenNamesMap[Owner].push_back(D);660    }661  } else if (ModulePrivate) {662    D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);663  }664}665 666void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {667  VisitDecl(D);668  D->setLocation(readSourceLocation());669  D->CommentKind = (PragmaMSCommentKind)Record.readInt();670  std::string Arg = readString();671  memcpy(D->getTrailingObjects(), Arg.data(), Arg.size());672  D->getTrailingObjects()[Arg.size()] = '\0';673}674 675void ASTDeclReader::VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) {676  VisitDecl(D);677  D->setLocation(readSourceLocation());678  std::string Name = readString();679  memcpy(D->getTrailingObjects(), Name.data(), Name.size());680  D->getTrailingObjects()[Name.size()] = '\0';681 682  D->ValueStart = Name.size() + 1;683  std::string Value = readString();684  memcpy(D->getTrailingObjects() + D->ValueStart, Value.data(), Value.size());685  D->getTrailingObjects()[D->ValueStart + Value.size()] = '\0';686}687 688void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {689  llvm_unreachable("Translation units are not serialized");690}691 692void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {693  VisitDecl(ND);694  ND->setDeclName(Record.readDeclarationName());695  AnonymousDeclNumber = Record.readInt();696}697 698void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {699  VisitNamedDecl(TD);700  TD->setLocStart(readSourceLocation());701  // Delay type reading until after we have fully initialized the decl.702  if (!isa<TagDecl, TypedefDecl, TypeAliasDecl>(TD))703    DeferredTypeID = Record.getGlobalTypeID(Record.readInt());704}705 706RedeclarableResult ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {707  RedeclarableResult Redecl = VisitRedeclarable(TD);708  VisitTypeDecl(TD);709  TypeSourceInfo *TInfo = readTypeSourceInfo();710  if (Record.readInt()) { // isModed711    QualType modedT = Record.readType();712    TD->setModedTypeSourceInfo(TInfo, modedT);713  } else714    TD->setTypeSourceInfo(TInfo);715  // Read and discard the declaration for which this is a typedef name for716  // linkage, if it exists. We cannot rely on our type to pull in this decl,717  // because it might have been merged with a type from another module and718  // thus might not refer to our version of the declaration.719  readDecl();720  return Redecl;721}722 723void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {724  RedeclarableResult Redecl = VisitTypedefNameDecl(TD);725  mergeRedeclarable(TD, Redecl);726}727 728void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {729  RedeclarableResult Redecl = VisitTypedefNameDecl(TD);730  if (auto *Template = readDeclAs<TypeAliasTemplateDecl>())731    // Merged when we merge the template.732    TD->setDescribedAliasTemplate(Template);733  else734    mergeRedeclarable(TD, Redecl);735}736 737RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {738  RedeclarableResult Redecl = VisitRedeclarable(TD);739  VisitTypeDecl(TD);740 741  TD->IdentifierNamespace = Record.readInt();742 743  BitsUnpacker TagDeclBits(Record.readInt());744  TD->setTagKind(745      static_cast<TagTypeKind>(TagDeclBits.getNextBits(/*Width=*/3)));746  TD->setCompleteDefinition(TagDeclBits.getNextBit());747  TD->setEmbeddedInDeclarator(TagDeclBits.getNextBit());748  TD->setFreeStanding(TagDeclBits.getNextBit());749  TD->setCompleteDefinitionRequired(TagDeclBits.getNextBit());750  TD->setBraceRange(readSourceRange());751 752  switch (TagDeclBits.getNextBits(/*Width=*/2)) {753  case 0:754    break;755  case 1: { // ExtInfo756    auto *Info = new (Reader.getContext()) TagDecl::ExtInfo();757    Record.readQualifierInfo(*Info);758    TD->TypedefNameDeclOrQualifier = Info;759    break;760  }761  case 2: // TypedefNameForAnonDecl762    NamedDeclForTagDecl = readDeclID();763    TypedefNameForLinkage = Record.readIdentifier();764    break;765  default:766    llvm_unreachable("unexpected tag info kind");767  }768 769  if (!isa<CXXRecordDecl>(TD))770    mergeRedeclarable(TD, Redecl);771  return Redecl;772}773 774void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {775  VisitTagDecl(ED);776  if (TypeSourceInfo *TI = readTypeSourceInfo())777    ED->setIntegerTypeSourceInfo(TI);778  else779    ED->setIntegerType(Record.readType());780  ED->setPromotionType(Record.readType());781 782  BitsUnpacker EnumDeclBits(Record.readInt());783  ED->setNumPositiveBits(EnumDeclBits.getNextBits(/*Width=*/8));784  ED->setNumNegativeBits(EnumDeclBits.getNextBits(/*Width=*/8));785  ED->setScoped(EnumDeclBits.getNextBit());786  ED->setScopedUsingClassTag(EnumDeclBits.getNextBit());787  ED->setFixed(EnumDeclBits.getNextBit());788 789  ED->setHasODRHash(true);790  ED->ODRHash = Record.readInt();791 792  // If this is a definition subject to the ODR, and we already have a793  // definition, merge this one into it.794  if (ED->isCompleteDefinition() && Reader.getContext().getLangOpts().Modules) {795    EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];796    if (!OldDef) {797      // This is the first time we've seen an imported definition. Look for a798      // local definition before deciding that we are the first definition.799      for (auto *D : merged_redecls(ED->getCanonicalDecl())) {800        if (!D->isFromASTFile() && D->isCompleteDefinition()) {801          OldDef = D;802          break;803        }804      }805    }806    if (OldDef) {807      Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));808      ED->demoteThisDefinitionToDeclaration();809      Reader.mergeDefinitionVisibility(OldDef, ED);810      // We don't want to check the ODR hash value for declarations from global811      // module fragment.812      if (!shouldSkipCheckingODR(ED) && !shouldSkipCheckingODR(OldDef) &&813          OldDef->getODRHash() != ED->getODRHash())814        Reader.PendingEnumOdrMergeFailures[OldDef].push_back(ED);815    } else {816      OldDef = ED;817    }818  }819 820  if (auto *InstED = readDeclAs<EnumDecl>()) {821    auto TSK = (TemplateSpecializationKind)Record.readInt();822    SourceLocation POI = readSourceLocation();823    ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);824    ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);825  }826}827 828RedeclarableResult ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {829  RedeclarableResult Redecl = VisitTagDecl(RD);830 831  BitsUnpacker RecordDeclBits(Record.readInt());832  RD->setHasFlexibleArrayMember(RecordDeclBits.getNextBit());833  RD->setAnonymousStructOrUnion(RecordDeclBits.getNextBit());834  RD->setHasObjectMember(RecordDeclBits.getNextBit());835  RD->setHasVolatileMember(RecordDeclBits.getNextBit());836  RD->setNonTrivialToPrimitiveDefaultInitialize(RecordDeclBits.getNextBit());837  RD->setNonTrivialToPrimitiveCopy(RecordDeclBits.getNextBit());838  RD->setNonTrivialToPrimitiveDestroy(RecordDeclBits.getNextBit());839  RD->setHasNonTrivialToPrimitiveDefaultInitializeCUnion(840      RecordDeclBits.getNextBit());841  RD->setHasNonTrivialToPrimitiveDestructCUnion(RecordDeclBits.getNextBit());842  RD->setHasNonTrivialToPrimitiveCopyCUnion(RecordDeclBits.getNextBit());843  RD->setHasUninitializedExplicitInitFields(RecordDeclBits.getNextBit());844  RD->setParamDestroyedInCallee(RecordDeclBits.getNextBit());845  RD->setArgPassingRestrictions(846      (RecordArgPassingKind)RecordDeclBits.getNextBits(/*Width=*/2));847  return Redecl;848}849 850void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {851  VisitRecordDeclImpl(RD);852  RD->setODRHash(Record.readInt());853 854  // Maintain the invariant of a redeclaration chain containing only855  // a single definition.856  if (RD->isCompleteDefinition()) {857    RecordDecl *Canon = static_cast<RecordDecl *>(RD->getCanonicalDecl());858    RecordDecl *&OldDef = Reader.RecordDefinitions[Canon];859    if (!OldDef) {860      // This is the first time we've seen an imported definition. Look for a861      // local definition before deciding that we are the first definition.862      for (auto *D : merged_redecls(Canon)) {863        if (!D->isFromASTFile() && D->isCompleteDefinition()) {864          OldDef = D;865          break;866        }867      }868    }869    if (OldDef) {870      Reader.MergedDeclContexts.insert(std::make_pair(RD, OldDef));871      RD->demoteThisDefinitionToDeclaration();872      Reader.mergeDefinitionVisibility(OldDef, RD);873      if (OldDef->getODRHash() != RD->getODRHash())874        Reader.PendingRecordOdrMergeFailures[OldDef].push_back(RD);875    } else {876      OldDef = RD;877    }878  }879}880 881void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {882  VisitNamedDecl(VD);883  // For function or variable declarations, defer reading the type in case the884  // declaration has a deduced type that references an entity declared within885  // the function definition or variable initializer.886  if (isa<FunctionDecl, VarDecl>(VD))887    DeferredTypeID = Record.getGlobalTypeID(Record.readInt());888  else889    VD->setType(Record.readType());890}891 892void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {893  VisitValueDecl(ECD);894  if (Record.readInt())895    ECD->setInitExpr(Record.readExpr());896  ECD->setInitVal(Reader.getContext(), Record.readAPSInt());897  mergeMergeable(ECD);898}899 900void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {901  VisitValueDecl(DD);902  DD->setInnerLocStart(readSourceLocation());903  if (Record.readInt()) { // hasExtInfo904    auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo();905    Record.readQualifierInfo(*Info);906    Info->TrailingRequiresClause = AssociatedConstraint(907        Record.readExpr(),908        UnsignedOrNone::fromInternalRepresentation(Record.readUInt32()));909    DD->DeclInfo = Info;910  }911  QualType TSIType = Record.readType();912  DD->setTypeSourceInfo(913      TSIType.isNull() ? nullptr914                       : Reader.getContext().CreateTypeSourceInfo(TSIType));915}916 917void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {918  RedeclarableResult Redecl = VisitRedeclarable(FD);919 920  FunctionDecl *Existing = nullptr;921 922  switch ((FunctionDecl::TemplatedKind)Record.readInt()) {923  case FunctionDecl::TK_NonTemplate:924    break;925  case FunctionDecl::TK_DependentNonTemplate:926    FD->setInstantiatedFromDecl(readDeclAs<FunctionDecl>());927    break;928  case FunctionDecl::TK_FunctionTemplate: {929    auto *Template = readDeclAs<FunctionTemplateDecl>();930    Template->init(FD);931    FD->setDescribedFunctionTemplate(Template);932    break;933  }934  case FunctionDecl::TK_MemberSpecialization: {935    auto *InstFD = readDeclAs<FunctionDecl>();936    auto TSK = (TemplateSpecializationKind)Record.readInt();937    SourceLocation POI = readSourceLocation();938    FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);939    FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);940    break;941  }942  case FunctionDecl::TK_FunctionTemplateSpecialization: {943    auto *Template = readDeclAs<FunctionTemplateDecl>();944    auto TSK = (TemplateSpecializationKind)Record.readInt();945 946    // Template arguments.947    SmallVector<TemplateArgument, 8> TemplArgs;948    Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);949 950    // Template args as written.951    TemplateArgumentListInfo TemplArgsWritten;952    bool HasTemplateArgumentsAsWritten = Record.readBool();953    if (HasTemplateArgumentsAsWritten)954      Record.readTemplateArgumentListInfo(TemplArgsWritten);955 956    SourceLocation POI = readSourceLocation();957 958    ASTContext &C = Reader.getContext();959    TemplateArgumentList *TemplArgList =960        TemplateArgumentList::CreateCopy(C, TemplArgs);961 962    MemberSpecializationInfo *MSInfo = nullptr;963    if (Record.readInt()) {964      auto *FD = readDeclAs<FunctionDecl>();965      auto TSK = (TemplateSpecializationKind)Record.readInt();966      SourceLocation POI = readSourceLocation();967 968      MSInfo = new (C) MemberSpecializationInfo(FD, TSK);969      MSInfo->setPointOfInstantiation(POI);970    }971 972    FunctionTemplateSpecializationInfo *FTInfo =973        FunctionTemplateSpecializationInfo::Create(974            C, FD, Template, TSK, TemplArgList,975            HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr, POI,976            MSInfo);977    FD->TemplateOrSpecialization = FTInfo;978 979    if (FD->isCanonicalDecl()) { // if canonical add to template's set.980      // The template that contains the specializations set. It's not safe to981      // use getCanonicalDecl on Template since it may still be initializing.982      auto *CanonTemplate = readDeclAs<FunctionTemplateDecl>();983      // Get the InsertPos by FindNodeOrInsertPos() instead of calling984      // InsertNode(FTInfo) directly to avoid the getASTContext() call in985      // FunctionTemplateSpecializationInfo's Profile().986      // We avoid getASTContext because a decl in the parent hierarchy may987      // be initializing.988      llvm::FoldingSetNodeID ID;989      FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);990      void *InsertPos = nullptr;991      FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();992      FunctionTemplateSpecializationInfo *ExistingInfo =993          CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);994      if (InsertPos)995        CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);996      else {997        assert(Reader.getContext().getLangOpts().Modules &&998               "already deserialized this template specialization");999        Existing = ExistingInfo->getFunction();1000      }1001    }1002    break;1003  }1004  case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {1005    // Templates.1006    UnresolvedSet<8> Candidates;1007    unsigned NumCandidates = Record.readInt();1008    while (NumCandidates--)1009      Candidates.addDecl(readDeclAs<NamedDecl>());1010 1011    // Templates args.1012    TemplateArgumentListInfo TemplArgsWritten;1013    bool HasTemplateArgumentsAsWritten = Record.readBool();1014    if (HasTemplateArgumentsAsWritten)1015      Record.readTemplateArgumentListInfo(TemplArgsWritten);1016 1017    FD->setDependentTemplateSpecialization(1018        Reader.getContext(), Candidates,1019        HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr);1020    // These are not merged; we don't need to merge redeclarations of dependent1021    // template friends.1022    break;1023  }1024  }1025 1026  VisitDeclaratorDecl(FD);1027 1028  // Attach a type to this function. Use the real type if possible, but fall1029  // back to the type as written if it involves a deduced return type.1030  if (FD->getTypeSourceInfo() && FD->getTypeSourceInfo()1031                                     ->getType()1032                                     ->castAs<FunctionType>()1033                                     ->getReturnType()1034                                     ->getContainedAutoType()) {1035    // We'll set up the real type in Visit, once we've finished loading the1036    // function.1037    FD->setType(FD->getTypeSourceInfo()->getType());1038    Reader.PendingDeducedFunctionTypes.push_back({FD, DeferredTypeID});1039  } else {1040    FD->setType(Reader.GetType(DeferredTypeID));1041  }1042  DeferredTypeID = 0;1043 1044  FD->DNLoc = Record.readDeclarationNameLoc(FD->getDeclName());1045  FD->IdentifierNamespace = Record.readInt();1046 1047  // FunctionDecl's body is handled last at ASTDeclReader::Visit,1048  // after everything else is read.1049  BitsUnpacker FunctionDeclBits(Record.readInt());1050 1051  FD->setCachedLinkage((Linkage)FunctionDeclBits.getNextBits(/*Width=*/3));1052  FD->setStorageClass((StorageClass)FunctionDeclBits.getNextBits(/*Width=*/3));1053  FD->setInlineSpecified(FunctionDeclBits.getNextBit());1054  FD->setImplicitlyInline(FunctionDeclBits.getNextBit());1055  FD->setHasSkippedBody(FunctionDeclBits.getNextBit());1056  FD->setVirtualAsWritten(FunctionDeclBits.getNextBit());1057  // We defer calling `FunctionDecl::setPure()` here as for methods of1058  // `CXXTemplateSpecializationDecl`s, we may not have connected up the1059  // definition (which is required for `setPure`).1060  const bool Pure = FunctionDeclBits.getNextBit();1061  FD->setHasInheritedPrototype(FunctionDeclBits.getNextBit());1062  FD->setHasWrittenPrototype(FunctionDeclBits.getNextBit());1063  FD->setDeletedAsWritten(FunctionDeclBits.getNextBit());1064  FD->setTrivial(FunctionDeclBits.getNextBit());1065  FD->setTrivialForCall(FunctionDeclBits.getNextBit());1066  FD->setDefaulted(FunctionDeclBits.getNextBit());1067  FD->setExplicitlyDefaulted(FunctionDeclBits.getNextBit());1068  FD->setIneligibleOrNotSelected(FunctionDeclBits.getNextBit());1069  FD->setConstexprKind(1070      (ConstexprSpecKind)FunctionDeclBits.getNextBits(/*Width=*/2));1071  FD->setHasImplicitReturnZero(FunctionDeclBits.getNextBit());1072  FD->setIsMultiVersion(FunctionDeclBits.getNextBit());1073  FD->setLateTemplateParsed(FunctionDeclBits.getNextBit());1074  FD->setInstantiatedFromMemberTemplate(FunctionDeclBits.getNextBit());1075  FD->setFriendConstraintRefersToEnclosingTemplate(1076      FunctionDeclBits.getNextBit());1077  FD->setUsesSEHTry(FunctionDeclBits.getNextBit());1078  FD->setIsDestroyingOperatorDelete(FunctionDeclBits.getNextBit());1079  FD->setIsTypeAwareOperatorNewOrDelete(FunctionDeclBits.getNextBit());1080 1081  FD->EndRangeLoc = readSourceLocation();1082  if (FD->isExplicitlyDefaulted())1083    FD->setDefaultLoc(readSourceLocation());1084 1085  FD->ODRHash = Record.readInt();1086  FD->setHasODRHash(true);1087 1088  if (FD->isDefaulted() || FD->isDeletedAsWritten()) {1089    // If 'Info' is nonzero, we need to read an DefaultedOrDeletedInfo; if,1090    // additionally, the second bit is also set, we also need to read1091    // a DeletedMessage for the DefaultedOrDeletedInfo.1092    if (auto Info = Record.readInt()) {1093      bool HasMessage = Info & 2;1094      StringLiteral *DeletedMessage =1095          HasMessage ? cast<StringLiteral>(Record.readExpr()) : nullptr;1096 1097      unsigned NumLookups = Record.readInt();1098      SmallVector<DeclAccessPair, 8> Lookups;1099      for (unsigned I = 0; I != NumLookups; ++I) {1100        NamedDecl *ND = Record.readDeclAs<NamedDecl>();1101        AccessSpecifier AS = (AccessSpecifier)Record.readInt();1102        Lookups.push_back(DeclAccessPair::make(ND, AS));1103      }1104 1105      FD->setDefaultedOrDeletedInfo(1106          FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(1107              Reader.getContext(), Lookups, DeletedMessage));1108    }1109  }1110 1111  if (Existing)1112    MergeImpl.mergeRedeclarable(FD, Existing, Redecl);1113  else if (auto Kind = FD->getTemplatedKind();1114           Kind == FunctionDecl::TK_FunctionTemplate ||1115           Kind == FunctionDecl::TK_FunctionTemplateSpecialization) {1116    // Function Templates have their FunctionTemplateDecls merged instead of1117    // their FunctionDecls.1118    auto merge = [this, &Redecl, FD](auto &&F) {1119      auto *Existing = cast_or_null<FunctionDecl>(Redecl.getKnownMergeTarget());1120      RedeclarableResult NewRedecl(Existing ? F(Existing) : nullptr,1121                                   Redecl.getFirstID(), Redecl.isKeyDecl());1122      mergeRedeclarableTemplate(F(FD), NewRedecl);1123    };1124    if (Kind == FunctionDecl::TK_FunctionTemplate)1125      merge(1126          [](FunctionDecl *FD) { return FD->getDescribedFunctionTemplate(); });1127    else1128      merge([](FunctionDecl *FD) {1129        return FD->getTemplateSpecializationInfo()->getTemplate();1130      });1131  } else1132    mergeRedeclarable(FD, Redecl);1133 1134  // Defer calling `setPure` until merging above has guaranteed we've set1135  // `DefinitionData` (as this will need to access it).1136  FD->setIsPureVirtual(Pure);1137 1138  // Read in the parameters.1139  unsigned NumParams = Record.readInt();1140  SmallVector<ParmVarDecl *, 16> Params;1141  Params.reserve(NumParams);1142  for (unsigned I = 0; I != NumParams; ++I)1143    Params.push_back(readDeclAs<ParmVarDecl>());1144  FD->setParams(Reader.getContext(), Params);1145 1146  // If the declaration is a SYCL kernel entry point function as indicated by1147  // the presence of a sycl_kernel_entry_point attribute, register it so that1148  // associated metadata is recreated.1149  if (FD->hasAttr<SYCLKernelEntryPointAttr>()) {1150    auto *SKEPAttr = FD->getAttr<SYCLKernelEntryPointAttr>();1151    ASTContext &C = Reader.getContext();1152    const SYCLKernelInfo *SKI = C.findSYCLKernelInfo(SKEPAttr->getKernelName());1153    if (SKI) {1154      if (!declaresSameEntity(FD, SKI->getKernelEntryPointDecl())) {1155        Reader.Diag(FD->getLocation(), diag::err_sycl_kernel_name_conflict)1156            << SKEPAttr;1157        Reader.Diag(SKI->getKernelEntryPointDecl()->getLocation(),1158                    diag::note_previous_declaration);1159        SKEPAttr->setInvalidAttr();1160      }1161    } else {1162      C.registerSYCLEntryPointFunction(FD);1163    }1164  }1165}1166 1167void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {1168  VisitNamedDecl(MD);1169  if (Record.readInt()) {1170    // Load the body on-demand. Most clients won't care, because method1171    // definitions rarely show up in headers.1172    Reader.PendingBodies[MD] = GetCurrentCursorOffset();1173  }1174  MD->setSelfDecl(readDeclAs<ImplicitParamDecl>());1175  MD->setCmdDecl(readDeclAs<ImplicitParamDecl>());1176  MD->setInstanceMethod(Record.readInt());1177  MD->setVariadic(Record.readInt());1178  MD->setPropertyAccessor(Record.readInt());1179  MD->setSynthesizedAccessorStub(Record.readInt());1180  MD->setDefined(Record.readInt());1181  MD->setOverriding(Record.readInt());1182  MD->setHasSkippedBody(Record.readInt());1183 1184  MD->setIsRedeclaration(Record.readInt());1185  MD->setHasRedeclaration(Record.readInt());1186  if (MD->hasRedeclaration())1187    Reader.getContext().setObjCMethodRedeclaration(MD,1188                                       readDeclAs<ObjCMethodDecl>());1189 1190  MD->setDeclImplementation(1191      static_cast<ObjCImplementationControl>(Record.readInt()));1192  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record.readInt());1193  MD->setRelatedResultType(Record.readInt());1194  MD->setReturnType(Record.readType());1195  MD->setReturnTypeSourceInfo(readTypeSourceInfo());1196  MD->DeclEndLoc = readSourceLocation();1197  unsigned NumParams = Record.readInt();1198  SmallVector<ParmVarDecl *, 16> Params;1199  Params.reserve(NumParams);1200  for (unsigned I = 0; I != NumParams; ++I)1201    Params.push_back(readDeclAs<ParmVarDecl>());1202 1203  MD->setSelLocsKind((SelectorLocationsKind)Record.readInt());1204  unsigned NumStoredSelLocs = Record.readInt();1205  SmallVector<SourceLocation, 16> SelLocs;1206  SelLocs.reserve(NumStoredSelLocs);1207  for (unsigned i = 0; i != NumStoredSelLocs; ++i)1208    SelLocs.push_back(readSourceLocation());1209 1210  MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);1211}1212 1213void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {1214  VisitTypedefNameDecl(D);1215 1216  D->Variance = Record.readInt();1217  D->Index = Record.readInt();1218  D->VarianceLoc = readSourceLocation();1219  D->ColonLoc = readSourceLocation();1220}1221 1222void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {1223  VisitNamedDecl(CD);1224  CD->setAtStartLoc(readSourceLocation());1225  CD->setAtEndRange(readSourceRange());1226}1227 1228ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {1229  unsigned numParams = Record.readInt();1230  if (numParams == 0)1231    return nullptr;1232 1233  SmallVector<ObjCTypeParamDecl *, 4> typeParams;1234  typeParams.reserve(numParams);1235  for (unsigned i = 0; i != numParams; ++i) {1236    auto *typeParam = readDeclAs<ObjCTypeParamDecl>();1237    if (!typeParam)1238      return nullptr;1239 1240    typeParams.push_back(typeParam);1241  }1242 1243  SourceLocation lAngleLoc = readSourceLocation();1244  SourceLocation rAngleLoc = readSourceLocation();1245 1246  return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,1247                                   typeParams, rAngleLoc);1248}1249 1250void ASTDeclReader::ReadObjCDefinitionData(1251         struct ObjCInterfaceDecl::DefinitionData &Data) {1252  // Read the superclass.1253  Data.SuperClassTInfo = readTypeSourceInfo();1254 1255  Data.EndLoc = readSourceLocation();1256  Data.HasDesignatedInitializers = Record.readInt();1257  Data.ODRHash = Record.readInt();1258  Data.HasODRHash = true;1259 1260  // Read the directly referenced protocols and their SourceLocations.1261  unsigned NumProtocols = Record.readInt();1262  SmallVector<ObjCProtocolDecl *, 16> Protocols;1263  Protocols.reserve(NumProtocols);1264  for (unsigned I = 0; I != NumProtocols; ++I)1265    Protocols.push_back(readDeclAs<ObjCProtocolDecl>());1266  SmallVector<SourceLocation, 16> ProtoLocs;1267  ProtoLocs.reserve(NumProtocols);1268  for (unsigned I = 0; I != NumProtocols; ++I)1269    ProtoLocs.push_back(readSourceLocation());1270  Data.ReferencedProtocols.set(Protocols.data(), NumProtocols, ProtoLocs.data(),1271                               Reader.getContext());1272 1273  // Read the transitive closure of protocols referenced by this class.1274  NumProtocols = Record.readInt();1275  Protocols.clear();1276  Protocols.reserve(NumProtocols);1277  for (unsigned I = 0; I != NumProtocols; ++I)1278    Protocols.push_back(readDeclAs<ObjCProtocolDecl>());1279  Data.AllReferencedProtocols.set(Protocols.data(), NumProtocols,1280                                  Reader.getContext());1281}1282 1283void ASTDeclMerger::MergeDefinitionData(1284    ObjCInterfaceDecl *D, struct ObjCInterfaceDecl::DefinitionData &&NewDD) {1285  struct ObjCInterfaceDecl::DefinitionData &DD = D->data();1286  if (DD.Definition == NewDD.Definition)1287    return;1288 1289  Reader.MergedDeclContexts.insert(1290      std::make_pair(NewDD.Definition, DD.Definition));1291  Reader.mergeDefinitionVisibility(DD.Definition, NewDD.Definition);1292 1293  if (D->getODRHash() != NewDD.ODRHash)1294    Reader.PendingObjCInterfaceOdrMergeFailures[DD.Definition].push_back(1295        {NewDD.Definition, &NewDD});1296}1297 1298void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {1299  RedeclarableResult Redecl = VisitRedeclarable(ID);1300  VisitObjCContainerDecl(ID);1301  DeferredTypeID = Record.getGlobalTypeID(Record.readInt());1302  mergeRedeclarable(ID, Redecl);1303 1304  ID->TypeParamList = ReadObjCTypeParamList();1305  if (Record.readInt()) {1306    // Read the definition.1307    ID->allocateDefinitionData();1308 1309    ReadObjCDefinitionData(ID->data());1310    ObjCInterfaceDecl *Canon = ID->getCanonicalDecl();1311    if (Canon->Data.getPointer()) {1312      // If we already have a definition, keep the definition invariant and1313      // merge the data.1314      MergeImpl.MergeDefinitionData(Canon, std::move(ID->data()));1315      ID->Data = Canon->Data;1316    } else {1317      // Set the definition data of the canonical declaration, so other1318      // redeclarations will see it.1319      ID->getCanonicalDecl()->Data = ID->Data;1320 1321      // We will rebuild this list lazily.1322      ID->setIvarList(nullptr);1323    }1324 1325    // Note that we have deserialized a definition.1326    Reader.PendingDefinitions.insert(ID);1327 1328    // Note that we've loaded this Objective-C class.1329    Reader.ObjCClassesLoaded.push_back(ID);1330  } else {1331    ID->Data = ID->getCanonicalDecl()->Data;1332  }1333}1334 1335void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {1336  VisitFieldDecl(IVD);1337  IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record.readInt());1338  // This field will be built lazily.1339  IVD->setNextIvar(nullptr);1340  bool synth = Record.readInt();1341  IVD->setSynthesize(synth);1342 1343  // Check ivar redeclaration.1344  if (IVD->isInvalidDecl())1345    return;1346  // Don't check ObjCInterfaceDecl as interfaces are named and mismatches can be1347  // detected in VisitObjCInterfaceDecl. Here we are looking for redeclarations1348  // in extensions.1349  if (isa<ObjCInterfaceDecl>(IVD->getDeclContext()))1350    return;1351  ObjCInterfaceDecl *CanonIntf =1352      IVD->getContainingInterface()->getCanonicalDecl();1353  IdentifierInfo *II = IVD->getIdentifier();1354  ObjCIvarDecl *PrevIvar = CanonIntf->lookupInstanceVariable(II);1355  if (PrevIvar && PrevIvar != IVD) {1356    auto *ParentExt = dyn_cast<ObjCCategoryDecl>(IVD->getDeclContext());1357    auto *PrevParentExt =1358        dyn_cast<ObjCCategoryDecl>(PrevIvar->getDeclContext());1359    if (ParentExt && PrevParentExt) {1360      // Postpone diagnostic as we should merge identical extensions from1361      // different modules.1362      Reader1363          .PendingObjCExtensionIvarRedeclarations[std::make_pair(ParentExt,1364                                                                 PrevParentExt)]1365          .push_back(std::make_pair(IVD, PrevIvar));1366    } else if (ParentExt || PrevParentExt) {1367      // Duplicate ivars in extension + implementation are never compatible.1368      // Compatibility of implementation + implementation should be handled in1369      // VisitObjCImplementationDecl.1370      Reader.Diag(IVD->getLocation(), diag::err_duplicate_ivar_declaration)1371          << II;1372      Reader.Diag(PrevIvar->getLocation(), diag::note_previous_definition);1373    }1374  }1375}1376 1377void ASTDeclReader::ReadObjCDefinitionData(1378         struct ObjCProtocolDecl::DefinitionData &Data) {1379    unsigned NumProtoRefs = Record.readInt();1380    SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;1381    ProtoRefs.reserve(NumProtoRefs);1382    for (unsigned I = 0; I != NumProtoRefs; ++I)1383      ProtoRefs.push_back(readDeclAs<ObjCProtocolDecl>());1384    SmallVector<SourceLocation, 16> ProtoLocs;1385    ProtoLocs.reserve(NumProtoRefs);1386    for (unsigned I = 0; I != NumProtoRefs; ++I)1387      ProtoLocs.push_back(readSourceLocation());1388    Data.ReferencedProtocols.set(ProtoRefs.data(), NumProtoRefs,1389                                 ProtoLocs.data(), Reader.getContext());1390    Data.ODRHash = Record.readInt();1391    Data.HasODRHash = true;1392}1393 1394void ASTDeclMerger::MergeDefinitionData(1395    ObjCProtocolDecl *D, struct ObjCProtocolDecl::DefinitionData &&NewDD) {1396  struct ObjCProtocolDecl::DefinitionData &DD = D->data();1397  if (DD.Definition == NewDD.Definition)1398    return;1399 1400  Reader.MergedDeclContexts.insert(1401      std::make_pair(NewDD.Definition, DD.Definition));1402  Reader.mergeDefinitionVisibility(DD.Definition, NewDD.Definition);1403 1404  if (D->getODRHash() != NewDD.ODRHash)1405    Reader.PendingObjCProtocolOdrMergeFailures[DD.Definition].push_back(1406        {NewDD.Definition, &NewDD});1407}1408 1409void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {1410  RedeclarableResult Redecl = VisitRedeclarable(PD);1411  VisitObjCContainerDecl(PD);1412  mergeRedeclarable(PD, Redecl);1413 1414  if (Record.readInt()) {1415    // Read the definition.1416    PD->allocateDefinitionData();1417 1418    ReadObjCDefinitionData(PD->data());1419 1420    ObjCProtocolDecl *Canon = PD->getCanonicalDecl();1421    if (Canon->Data.getPointer()) {1422      // If we already have a definition, keep the definition invariant and1423      // merge the data.1424      MergeImpl.MergeDefinitionData(Canon, std::move(PD->data()));1425      PD->Data = Canon->Data;1426    } else {1427      // Set the definition data of the canonical declaration, so other1428      // redeclarations will see it.1429      PD->getCanonicalDecl()->Data = PD->Data;1430    }1431    // Note that we have deserialized a definition.1432    Reader.PendingDefinitions.insert(PD);1433  } else {1434    PD->Data = PD->getCanonicalDecl()->Data;1435  }1436}1437 1438void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {1439  VisitFieldDecl(FD);1440}1441 1442void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {1443  VisitObjCContainerDecl(CD);1444  CD->setCategoryNameLoc(readSourceLocation());1445  CD->setIvarLBraceLoc(readSourceLocation());1446  CD->setIvarRBraceLoc(readSourceLocation());1447 1448  // Note that this category has been deserialized. We do this before1449  // deserializing the interface declaration, so that it will consider this1450  /// category.1451  Reader.CategoriesDeserialized.insert(CD);1452 1453  CD->ClassInterface = readDeclAs<ObjCInterfaceDecl>();1454  CD->TypeParamList = ReadObjCTypeParamList();1455  unsigned NumProtoRefs = Record.readInt();1456  SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;1457  ProtoRefs.reserve(NumProtoRefs);1458  for (unsigned I = 0; I != NumProtoRefs; ++I)1459    ProtoRefs.push_back(readDeclAs<ObjCProtocolDecl>());1460  SmallVector<SourceLocation, 16> ProtoLocs;1461  ProtoLocs.reserve(NumProtoRefs);1462  for (unsigned I = 0; I != NumProtoRefs; ++I)1463    ProtoLocs.push_back(readSourceLocation());1464  CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),1465                      Reader.getContext());1466 1467  // Protocols in the class extension belong to the class.1468  if (NumProtoRefs > 0 && CD->ClassInterface && CD->IsClassExtension())1469    CD->ClassInterface->mergeClassExtensionProtocolList(1470        (ObjCProtocolDecl *const *)ProtoRefs.data(), NumProtoRefs,1471        Reader.getContext());1472}1473 1474void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {1475  VisitNamedDecl(CAD);1476  CAD->setClassInterface(readDeclAs<ObjCInterfaceDecl>());1477}1478 1479void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {1480  VisitNamedDecl(D);1481  D->setAtLoc(readSourceLocation());1482  D->setLParenLoc(readSourceLocation());1483  QualType T = Record.readType();1484  TypeSourceInfo *TSI = readTypeSourceInfo();1485  D->setType(T, TSI);1486  D->setPropertyAttributes((ObjCPropertyAttribute::Kind)Record.readInt());1487  D->setPropertyAttributesAsWritten(1488      (ObjCPropertyAttribute::Kind)Record.readInt());1489  D->setPropertyImplementation(1490      (ObjCPropertyDecl::PropertyControl)Record.readInt());1491  DeclarationName GetterName = Record.readDeclarationName();1492  SourceLocation GetterLoc = readSourceLocation();1493  D->setGetterName(GetterName.getObjCSelector(), GetterLoc);1494  DeclarationName SetterName = Record.readDeclarationName();1495  SourceLocation SetterLoc = readSourceLocation();1496  D->setSetterName(SetterName.getObjCSelector(), SetterLoc);1497  D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());1498  D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());1499  D->setPropertyIvarDecl(readDeclAs<ObjCIvarDecl>());1500}1501 1502void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {1503  VisitObjCContainerDecl(D);1504  D->setClassInterface(readDeclAs<ObjCInterfaceDecl>());1505}1506 1507void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {1508  VisitObjCImplDecl(D);1509  D->CategoryNameLoc = readSourceLocation();1510}1511 1512void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {1513  VisitObjCImplDecl(D);1514  D->setSuperClass(readDeclAs<ObjCInterfaceDecl>());1515  D->SuperLoc = readSourceLocation();1516  D->setIvarLBraceLoc(readSourceLocation());1517  D->setIvarRBraceLoc(readSourceLocation());1518  D->setHasNonZeroConstructors(Record.readInt());1519  D->setHasDestructors(Record.readInt());1520  D->NumIvarInitializers = Record.readInt();1521  if (D->NumIvarInitializers)1522    D->IvarInitializers = ReadGlobalOffset();1523}1524 1525void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {1526  VisitDecl(D);1527  D->setAtLoc(readSourceLocation());1528  D->setPropertyDecl(readDeclAs<ObjCPropertyDecl>());1529  D->PropertyIvarDecl = readDeclAs<ObjCIvarDecl>();1530  D->IvarLoc = readSourceLocation();1531  D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());1532  D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());1533  D->setGetterCXXConstructor(Record.readExpr());1534  D->setSetterCXXAssignment(Record.readExpr());1535}1536 1537void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {1538  VisitDeclaratorDecl(FD);1539  FD->Mutable = Record.readInt();1540 1541  unsigned Bits = Record.readInt();1542  FD->StorageKind = Bits >> 1;1543  if (FD->StorageKind == FieldDecl::ISK_CapturedVLAType)1544    FD->CapturedVLAType =1545        cast<VariableArrayType>(Record.readType().getTypePtr());1546  else if (Bits & 1)1547    FD->setBitWidth(Record.readExpr());1548 1549  if (!FD->getDeclName() ||1550      FD->isPlaceholderVar(Reader.getContext().getLangOpts())) {1551    if (auto *Tmpl = readDeclAs<FieldDecl>())1552      Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);1553  }1554  mergeMergeable(FD);1555}1556 1557void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {1558  VisitDeclaratorDecl(PD);1559  PD->GetterId = Record.readIdentifier();1560  PD->SetterId = Record.readIdentifier();1561}1562 1563void ASTDeclReader::VisitMSGuidDecl(MSGuidDecl *D) {1564  VisitValueDecl(D);1565  D->PartVal.Part1 = Record.readInt();1566  D->PartVal.Part2 = Record.readInt();1567  D->PartVal.Part3 = Record.readInt();1568  for (auto &C : D->PartVal.Part4And5)1569    C = Record.readInt();1570 1571  // Add this GUID to the AST context's lookup structure, and merge if needed.1572  if (MSGuidDecl *Existing = Reader.getContext().MSGuidDecls.GetOrInsertNode(D))1573    Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());1574}1575 1576void ASTDeclReader::VisitUnnamedGlobalConstantDecl(1577    UnnamedGlobalConstantDecl *D) {1578  VisitValueDecl(D);1579  D->Value = Record.readAPValue();1580 1581  // Add this to the AST context's lookup structure, and merge if needed.1582  if (UnnamedGlobalConstantDecl *Existing =1583          Reader.getContext().UnnamedGlobalConstantDecls.GetOrInsertNode(D))1584    Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());1585}1586 1587void ASTDeclReader::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {1588  VisitValueDecl(D);1589  D->Value = Record.readAPValue();1590 1591  // Add this template parameter object to the AST context's lookup structure,1592  // and merge if needed.1593  if (TemplateParamObjectDecl *Existing =1594          Reader.getContext().TemplateParamObjectDecls.GetOrInsertNode(D))1595    Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());1596}1597 1598void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {1599  VisitValueDecl(FD);1600 1601  FD->ChainingSize = Record.readInt();1602  assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");1603  FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];1604 1605  for (unsigned I = 0; I != FD->ChainingSize; ++I)1606    FD->Chaining[I] = readDeclAs<NamedDecl>();1607 1608  mergeMergeable(FD);1609}1610 1611RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {1612  RedeclarableResult Redecl = VisitRedeclarable(VD);1613  VisitDeclaratorDecl(VD);1614 1615  BitsUnpacker VarDeclBits(Record.readInt());1616  auto VarLinkage = Linkage(VarDeclBits.getNextBits(/*Width=*/3));1617  bool DefGeneratedInModule = VarDeclBits.getNextBit();1618  VD->VarDeclBits.SClass = (StorageClass)VarDeclBits.getNextBits(/*Width=*/3);1619  VD->VarDeclBits.TSCSpec = VarDeclBits.getNextBits(/*Width=*/2);1620  VD->VarDeclBits.InitStyle = VarDeclBits.getNextBits(/*Width=*/2);1621  VD->VarDeclBits.ARCPseudoStrong = VarDeclBits.getNextBit();1622  bool HasDeducedType = false;1623  if (!isa<ParmVarDecl>(VD)) {1624    VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition =1625        VarDeclBits.getNextBit();1626    VD->NonParmVarDeclBits.ExceptionVar = VarDeclBits.getNextBit();1627    VD->NonParmVarDeclBits.NRVOVariable = VarDeclBits.getNextBit();1628    VD->NonParmVarDeclBits.CXXForRangeDecl = VarDeclBits.getNextBit();1629 1630    VD->NonParmVarDeclBits.IsInline = VarDeclBits.getNextBit();1631    VD->NonParmVarDeclBits.IsInlineSpecified = VarDeclBits.getNextBit();1632    VD->NonParmVarDeclBits.IsConstexpr = VarDeclBits.getNextBit();1633    VD->NonParmVarDeclBits.IsInitCapture = VarDeclBits.getNextBit();1634    VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope =1635        VarDeclBits.getNextBit();1636 1637    VD->NonParmVarDeclBits.EscapingByref = VarDeclBits.getNextBit();1638    HasDeducedType = VarDeclBits.getNextBit();1639    VD->NonParmVarDeclBits.ImplicitParamKind =1640        VarDeclBits.getNextBits(/*Width*/ 3);1641 1642    VD->NonParmVarDeclBits.ObjCForDecl = VarDeclBits.getNextBit();1643    VD->NonParmVarDeclBits.IsCXXForRangeImplicitVar = VarDeclBits.getNextBit();1644  }1645 1646  // If this variable has a deduced type, defer reading that type until we are1647  // done deserializing this variable, because the type might refer back to the1648  // variable.1649  if (HasDeducedType)1650    Reader.PendingDeducedVarTypes.push_back({VD, DeferredTypeID});1651  else1652    VD->setType(Reader.GetType(DeferredTypeID));1653  DeferredTypeID = 0;1654 1655  VD->setCachedLinkage(VarLinkage);1656 1657  // Reconstruct the one piece of the IdentifierNamespace that we need.1658  if (VD->getStorageClass() == SC_Extern && VarLinkage != Linkage::None &&1659      VD->getLexicalDeclContext()->isFunctionOrMethod())1660    VD->setLocalExternDecl();1661 1662  if (DefGeneratedInModule) {1663    Reader.DefinitionSource[VD] =1664        Loc.F->Kind == ModuleKind::MK_MainFile ||1665        Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;1666  }1667 1668  if (VD->hasAttr<BlocksAttr>()) {1669    Expr *CopyExpr = Record.readExpr();1670    if (CopyExpr)1671      Reader.getContext().setBlockVarCopyInit(VD, CopyExpr, Record.readInt());1672  }1673 1674  enum VarKind {1675    VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization1676  };1677  switch ((VarKind)Record.readInt()) {1678  case VarNotTemplate:1679    // Only true variables (not parameters or implicit parameters) can be1680    // merged; the other kinds are not really redeclarable at all.1681    if (!isa<ParmVarDecl>(VD) && !isa<ImplicitParamDecl>(VD) &&1682        !isa<VarTemplateSpecializationDecl>(VD))1683      mergeRedeclarable(VD, Redecl);1684    break;1685  case VarTemplate:1686    // Merged when we merge the template.1687    VD->setDescribedVarTemplate(readDeclAs<VarTemplateDecl>());1688    break;1689  case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.1690    auto *Tmpl = readDeclAs<VarDecl>();1691    auto TSK = (TemplateSpecializationKind)Record.readInt();1692    SourceLocation POI = readSourceLocation();1693    Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);1694    mergeRedeclarable(VD, Redecl);1695    break;1696  }1697  }1698 1699  return Redecl;1700}1701 1702void ASTDeclReader::ReadVarDeclInit(VarDecl *VD) {1703  if (uint64_t Val = Record.readInt()) {1704    EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();1705    Eval->HasConstantInitialization = (Val & 2) != 0;1706    Eval->HasConstantDestruction = (Val & 4) != 0;1707    Eval->WasEvaluated = (Val & 8) != 0;1708    Eval->HasSideEffects = (Val & 16) != 0;1709    Eval->CheckedForSideEffects = true;1710    if (Eval->WasEvaluated) {1711      Eval->Evaluated = Record.readAPValue();1712      if (Eval->Evaluated.needsCleanup())1713        Reader.getContext().addDestruction(&Eval->Evaluated);1714    }1715 1716    // Store the offset of the initializer. Don't deserialize it yet: it might1717    // not be needed, and might refer back to the variable, for example if it1718    // contains a lambda.1719    Eval->Value = GetCurrentCursorOffset();1720  }1721}1722 1723void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {1724  VisitVarDecl(PD);1725}1726 1727void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {1728  VisitVarDecl(PD);1729 1730  unsigned scopeIndex = Record.readInt();1731  BitsUnpacker ParmVarDeclBits(Record.readInt());1732  unsigned isObjCMethodParam = ParmVarDeclBits.getNextBit();1733  unsigned scopeDepth = ParmVarDeclBits.getNextBits(/*Width=*/7);1734  unsigned declQualifier = ParmVarDeclBits.getNextBits(/*Width=*/7);1735  if (isObjCMethodParam) {1736    assert(scopeDepth == 0);1737    PD->setObjCMethodScopeInfo(scopeIndex);1738    PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;1739  } else {1740    PD->setScopeInfo(scopeDepth, scopeIndex);1741  }1742  PD->ParmVarDeclBits.IsKNRPromoted = ParmVarDeclBits.getNextBit();1743 1744  PD->ParmVarDeclBits.HasInheritedDefaultArg = ParmVarDeclBits.getNextBit();1745  if (ParmVarDeclBits.getNextBit()) // hasUninstantiatedDefaultArg.1746    PD->setUninstantiatedDefaultArg(Record.readExpr());1747 1748  if (ParmVarDeclBits.getNextBit()) // Valid explicit object parameter1749    PD->ExplicitObjectParameterIntroducerLoc = Record.readSourceLocation();1750 1751  // FIXME: If this is a redeclaration of a function from another module, handle1752  // inheritance of default arguments.1753}1754 1755void ASTDeclReader::VisitDecompositionDecl(DecompositionDecl *DD) {1756  VisitVarDecl(DD);1757  auto **BDs = DD->getTrailingObjects();1758  for (unsigned I = 0; I != DD->NumBindings; ++I) {1759    BDs[I] = readDeclAs<BindingDecl>();1760    BDs[I]->setDecomposedDecl(DD);1761  }1762}1763 1764void ASTDeclReader::VisitBindingDecl(BindingDecl *BD) {1765  VisitValueDecl(BD);1766  BD->Binding = Record.readExpr();1767}1768 1769void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {1770  VisitDecl(AD);1771  AD->setAsmString(cast<StringLiteral>(Record.readExpr()));1772  AD->setRParenLoc(readSourceLocation());1773}1774 1775void ASTDeclReader::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {1776  VisitDecl(D);1777  D->Statement = Record.readStmt();1778}1779 1780void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {1781  VisitDecl(BD);1782  BD->setBody(cast_or_null<CompoundStmt>(Record.readStmt()));1783  BD->setSignatureAsWritten(readTypeSourceInfo());1784  unsigned NumParams = Record.readInt();1785  SmallVector<ParmVarDecl *, 16> Params;1786  Params.reserve(NumParams);1787  for (unsigned I = 0; I != NumParams; ++I)1788    Params.push_back(readDeclAs<ParmVarDecl>());1789  BD->setParams(Params);1790 1791  BD->setIsVariadic(Record.readInt());1792  BD->setBlockMissingReturnType(Record.readInt());1793  BD->setIsConversionFromLambda(Record.readInt());1794  BD->setDoesNotEscape(Record.readInt());1795  BD->setCanAvoidCopyToHeap(Record.readInt());1796 1797  bool capturesCXXThis = Record.readInt();1798  unsigned numCaptures = Record.readInt();1799  SmallVector<BlockDecl::Capture, 16> captures;1800  captures.reserve(numCaptures);1801  for (unsigned i = 0; i != numCaptures; ++i) {1802    auto *decl = readDeclAs<VarDecl>();1803    unsigned flags = Record.readInt();1804    bool byRef = (flags & 1);1805    bool nested = (flags & 2);1806    Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);1807 1808    captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));1809  }1810  BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);1811}1812 1813void ASTDeclReader::VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D) {1814  // NumParams is deserialized by OutlinedFunctionDecl::CreateDeserialized().1815  VisitDecl(D);1816  for (unsigned I = 0; I < D->NumParams; ++I)1817    D->setParam(I, readDeclAs<ImplicitParamDecl>());1818  D->setNothrow(Record.readInt() != 0);1819  D->setBody(cast_or_null<Stmt>(Record.readStmt()));1820}1821 1822void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {1823  VisitDecl(CD);1824  unsigned ContextParamPos = Record.readInt();1825  CD->setNothrow(Record.readInt() != 0);1826  // Body is set by VisitCapturedStmt.1827  for (unsigned I = 0; I < CD->NumParams; ++I) {1828    if (I != ContextParamPos)1829      CD->setParam(I, readDeclAs<ImplicitParamDecl>());1830    else1831      CD->setContextParam(I, readDeclAs<ImplicitParamDecl>());1832  }1833}1834 1835void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {1836  VisitDecl(D);1837  D->setLanguage(static_cast<LinkageSpecLanguageIDs>(Record.readInt()));1838  D->setExternLoc(readSourceLocation());1839  D->setRBraceLoc(readSourceLocation());1840}1841 1842void ASTDeclReader::VisitExportDecl(ExportDecl *D) {1843  VisitDecl(D);1844  D->RBraceLoc = readSourceLocation();1845}1846 1847void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {1848  VisitNamedDecl(D);1849  D->setLocStart(readSourceLocation());1850}1851 1852void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {1853  RedeclarableResult Redecl = VisitRedeclarable(D);1854  VisitNamedDecl(D);1855 1856  BitsUnpacker NamespaceDeclBits(Record.readInt());1857  D->setInline(NamespaceDeclBits.getNextBit());1858  D->setNested(NamespaceDeclBits.getNextBit());1859  D->LocStart = readSourceLocation();1860  D->RBraceLoc = readSourceLocation();1861 1862  // Defer loading the anonymous namespace until we've finished merging1863  // this namespace; loading it might load a later declaration of the1864  // same namespace, and we have an invariant that older declarations1865  // get merged before newer ones try to merge.1866  GlobalDeclID AnonNamespace;1867  if (Redecl.getFirstID() == ThisDeclID)1868    AnonNamespace = readDeclID();1869 1870  mergeRedeclarable(D, Redecl);1871 1872  if (AnonNamespace.isValid()) {1873    // Each module has its own anonymous namespace, which is disjoint from1874    // any other module's anonymous namespaces, so don't attach the anonymous1875    // namespace at all.1876    auto *Anon = cast<NamespaceDecl>(Reader.GetDecl(AnonNamespace));1877    if (!Record.isModule())1878      D->setAnonymousNamespace(Anon);1879  }1880}1881 1882void ASTDeclReader::VisitHLSLBufferDecl(HLSLBufferDecl *D) {1883  VisitNamedDecl(D);1884  LookupBlockOffsets Offsets;1885  VisitDeclContext(D, Offsets);1886  D->IsCBuffer = Record.readBool();1887  D->KwLoc = readSourceLocation();1888  D->LBraceLoc = readSourceLocation();1889  D->RBraceLoc = readSourceLocation();1890}1891 1892void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {1893  RedeclarableResult Redecl = VisitRedeclarable(D);1894  VisitNamedDecl(D);1895  D->NamespaceLoc = readSourceLocation();1896  D->IdentLoc = readSourceLocation();1897  D->QualifierLoc = Record.readNestedNameSpecifierLoc();1898  D->Namespace = readDeclAs<NamespaceBaseDecl>();1899  mergeRedeclarable(D, Redecl);1900}1901 1902void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {1903  VisitNamedDecl(D);1904  D->setUsingLoc(readSourceLocation());1905  D->QualifierLoc = Record.readNestedNameSpecifierLoc();1906  D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());1907  D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());1908  D->setTypename(Record.readInt());1909  if (auto *Pattern = readDeclAs<NamedDecl>())1910    Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);1911  mergeMergeable(D);1912}1913 1914void ASTDeclReader::VisitUsingEnumDecl(UsingEnumDecl *D) {1915  VisitNamedDecl(D);1916  D->setUsingLoc(readSourceLocation());1917  D->setEnumLoc(readSourceLocation());1918  D->setEnumType(Record.readTypeSourceInfo());1919  D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());1920  if (auto *Pattern = readDeclAs<UsingEnumDecl>())1921    Reader.getContext().setInstantiatedFromUsingEnumDecl(D, Pattern);1922  mergeMergeable(D);1923}1924 1925void ASTDeclReader::VisitUsingPackDecl(UsingPackDecl *D) {1926  VisitNamedDecl(D);1927  D->InstantiatedFrom = readDeclAs<NamedDecl>();1928  auto **Expansions = D->getTrailingObjects();1929  for (unsigned I = 0; I != D->NumExpansions; ++I)1930    Expansions[I] = readDeclAs<NamedDecl>();1931  mergeMergeable(D);1932}1933 1934void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {1935  RedeclarableResult Redecl = VisitRedeclarable(D);1936  VisitNamedDecl(D);1937  D->Underlying = readDeclAs<NamedDecl>();1938  D->IdentifierNamespace = Record.readInt();1939  D->UsingOrNextShadow = readDeclAs<NamedDecl>();1940  auto *Pattern = readDeclAs<UsingShadowDecl>();1941  if (Pattern)1942    Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);1943  mergeRedeclarable(D, Redecl);1944}1945 1946void ASTDeclReader::VisitConstructorUsingShadowDecl(1947    ConstructorUsingShadowDecl *D) {1948  VisitUsingShadowDecl(D);1949  D->NominatedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();1950  D->ConstructedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();1951  D->IsVirtual = Record.readInt();1952}1953 1954void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {1955  VisitNamedDecl(D);1956  D->UsingLoc = readSourceLocation();1957  D->NamespaceLoc = readSourceLocation();1958  D->QualifierLoc = Record.readNestedNameSpecifierLoc();1959  D->NominatedNamespace = readDeclAs<NamedDecl>();1960  D->CommonAncestor = readDeclAs<DeclContext>();1961}1962 1963void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {1964  VisitValueDecl(D);1965  D->setUsingLoc(readSourceLocation());1966  D->QualifierLoc = Record.readNestedNameSpecifierLoc();1967  D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());1968  D->EllipsisLoc = readSourceLocation();1969  mergeMergeable(D);1970}1971 1972void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(1973                                               UnresolvedUsingTypenameDecl *D) {1974  VisitTypeDecl(D);1975  D->TypenameLocation = readSourceLocation();1976  D->QualifierLoc = Record.readNestedNameSpecifierLoc();1977  D->EllipsisLoc = readSourceLocation();1978  mergeMergeable(D);1979}1980 1981void ASTDeclReader::VisitUnresolvedUsingIfExistsDecl(1982    UnresolvedUsingIfExistsDecl *D) {1983  VisitNamedDecl(D);1984}1985 1986void ASTDeclReader::ReadCXXDefinitionData(1987    struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D,1988    Decl *LambdaContext, unsigned IndexInLambdaContext) {1989 1990  BitsUnpacker CXXRecordDeclBits = Record.readInt();1991 1992#define FIELD(Name, Width, Merge)                                              \1993  if (!CXXRecordDeclBits.canGetNextNBits(Width))                         \1994    CXXRecordDeclBits.updateValue(Record.readInt());                           \1995  Data.Name = CXXRecordDeclBits.getNextBits(Width);1996 1997#include "clang/AST/CXXRecordDeclDefinitionBits.def"1998#undef FIELD1999 2000  // Note: the caller has deserialized the IsLambda bit already.2001  Data.ODRHash = Record.readInt();2002  Data.HasODRHash = true;2003 2004  if (Record.readInt()) {2005    Reader.DefinitionSource[D] =2006        Loc.F->Kind == ModuleKind::MK_MainFile ||2007        Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;2008  }2009 2010  Record.readUnresolvedSet(Data.Conversions);2011  Data.ComputedVisibleConversions = Record.readInt();2012  if (Data.ComputedVisibleConversions)2013    Record.readUnresolvedSet(Data.VisibleConversions);2014  assert(Data.Definition && "Data.Definition should be already set!");2015 2016  if (!Data.IsLambda) {2017    assert(!LambdaContext && !IndexInLambdaContext &&2018           "given lambda context for non-lambda");2019 2020    Data.NumBases = Record.readInt();2021    if (Data.NumBases)2022      Data.Bases = ReadGlobalOffset();2023 2024    Data.NumVBases = Record.readInt();2025    if (Data.NumVBases)2026      Data.VBases = ReadGlobalOffset();2027 2028    Data.FirstFriend = readDeclID().getRawValue();2029  } else {2030    using Capture = LambdaCapture;2031 2032    auto &Lambda = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);2033 2034    BitsUnpacker LambdaBits(Record.readInt());2035    Lambda.DependencyKind = LambdaBits.getNextBits(/*Width=*/2);2036    Lambda.IsGenericLambda = LambdaBits.getNextBit();2037    Lambda.CaptureDefault = LambdaBits.getNextBits(/*Width=*/2);2038    Lambda.NumCaptures = LambdaBits.getNextBits(/*Width=*/15);2039    Lambda.HasKnownInternalLinkage = LambdaBits.getNextBit();2040 2041    Lambda.NumExplicitCaptures = Record.readInt();2042    Lambda.ManglingNumber = Record.readInt();2043    if (unsigned DeviceManglingNumber = Record.readInt())2044      Reader.getContext().DeviceLambdaManglingNumbers[D] = DeviceManglingNumber;2045    Lambda.IndexInContext = IndexInLambdaContext;2046    Lambda.ContextDecl = LambdaContext;2047    Capture *ToCapture = nullptr;2048    if (Lambda.NumCaptures) {2049      ToCapture = (Capture *)Reader.getContext().Allocate(sizeof(Capture) *2050                                                          Lambda.NumCaptures);2051      Lambda.AddCaptureList(Reader.getContext(), ToCapture);2052    }2053    Lambda.MethodTyInfo = readTypeSourceInfo();2054    for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {2055      SourceLocation Loc = readSourceLocation();2056      BitsUnpacker CaptureBits(Record.readInt());2057      bool IsImplicit = CaptureBits.getNextBit();2058      auto Kind =2059          static_cast<LambdaCaptureKind>(CaptureBits.getNextBits(/*Width=*/3));2060      switch (Kind) {2061      case LCK_StarThis:2062      case LCK_This:2063      case LCK_VLAType:2064        new (ToCapture)2065            Capture(Loc, IsImplicit, Kind, nullptr, SourceLocation());2066        ToCapture++;2067        break;2068      case LCK_ByCopy:2069      case LCK_ByRef:2070        auto *Var = readDeclAs<ValueDecl>();2071        SourceLocation EllipsisLoc = readSourceLocation();2072        new (ToCapture) Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);2073        ToCapture++;2074        break;2075      }2076    }2077  }2078}2079 2080void ASTDeclMerger::MergeDefinitionData(2081    CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {2082  assert(D->DefinitionData &&2083         "merging class definition into non-definition");2084  auto &DD = *D->DefinitionData;2085 2086  if (DD.Definition != MergeDD.Definition) {2087    // Track that we merged the definitions.2088    Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,2089                                                    DD.Definition));2090    Reader.PendingDefinitions.erase(MergeDD.Definition);2091    MergeDD.Definition->demoteThisDefinitionToDeclaration();2092    Reader.mergeDefinitionVisibility(DD.Definition, MergeDD.Definition);2093    assert(!Reader.Lookups.contains(MergeDD.Definition) &&2094           "already loaded pending lookups for merged definition");2095  }2096 2097  auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);2098  if (PFDI != Reader.PendingFakeDefinitionData.end() &&2099      PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {2100    // We faked up this definition data because we found a class for which we'd2101    // not yet loaded the definition. Replace it with the real thing now.2102    assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");2103    PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;2104 2105    // Don't change which declaration is the definition; that is required2106    // to be invariant once we select it.2107    auto *Def = DD.Definition;2108    DD = std::move(MergeDD);2109    DD.Definition = Def;2110    while ((Def = Def->getPreviousDecl()))2111      cast<CXXRecordDecl>(Def)->DefinitionData = &DD;2112    return;2113  }2114 2115  bool DetectedOdrViolation = false;2116 2117  #define FIELD(Name, Width, Merge) Merge(Name)2118  #define MERGE_OR(Field) DD.Field |= MergeDD.Field;2119  #define NO_MERGE(Field) \2120    DetectedOdrViolation |= DD.Field != MergeDD.Field; \2121    MERGE_OR(Field)2122  #include "clang/AST/CXXRecordDeclDefinitionBits.def"2123  NO_MERGE(IsLambda)2124  #undef NO_MERGE2125  #undef MERGE_OR2126 2127  if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)2128    DetectedOdrViolation = true;2129  // FIXME: Issue a diagnostic if the base classes don't match when we come2130  // to lazily load them.2131 2132  // FIXME: Issue a diagnostic if the list of conversion functions doesn't2133  // match when we come to lazily load them.2134  if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {2135    DD.VisibleConversions = std::move(MergeDD.VisibleConversions);2136    DD.ComputedVisibleConversions = true;2137  }2138 2139  // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to2140  // lazily load it.2141 2142  if (DD.IsLambda) {2143    auto &Lambda1 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(DD);2144    auto &Lambda2 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(MergeDD);2145    DetectedOdrViolation |= Lambda1.DependencyKind != Lambda2.DependencyKind;2146    DetectedOdrViolation |= Lambda1.IsGenericLambda != Lambda2.IsGenericLambda;2147    DetectedOdrViolation |= Lambda1.CaptureDefault != Lambda2.CaptureDefault;2148    DetectedOdrViolation |= Lambda1.NumCaptures != Lambda2.NumCaptures;2149    DetectedOdrViolation |=2150        Lambda1.NumExplicitCaptures != Lambda2.NumExplicitCaptures;2151    DetectedOdrViolation |=2152        Lambda1.HasKnownInternalLinkage != Lambda2.HasKnownInternalLinkage;2153    DetectedOdrViolation |= Lambda1.ManglingNumber != Lambda2.ManglingNumber;2154 2155    if (Lambda1.NumCaptures && Lambda1.NumCaptures == Lambda2.NumCaptures) {2156      for (unsigned I = 0, N = Lambda1.NumCaptures; I != N; ++I) {2157        LambdaCapture &Cap1 = Lambda1.Captures.front()[I];2158        LambdaCapture &Cap2 = Lambda2.Captures.front()[I];2159        DetectedOdrViolation |= Cap1.getCaptureKind() != Cap2.getCaptureKind();2160      }2161      Lambda1.AddCaptureList(Reader.getContext(), Lambda2.Captures.front());2162    }2163  }2164 2165  // We don't want to check ODR for decls in the global module fragment.2166  if (shouldSkipCheckingODR(MergeDD.Definition) || shouldSkipCheckingODR(D))2167    return;2168 2169  if (D->getODRHash() != MergeDD.ODRHash) {2170    DetectedOdrViolation = true;2171  }2172 2173  if (DetectedOdrViolation)2174    Reader.PendingOdrMergeFailures[DD.Definition].push_back(2175        {MergeDD.Definition, &MergeDD});2176}2177 2178void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,2179                                            Decl *LambdaContext,2180                                            unsigned IndexInLambdaContext) {2181  struct CXXRecordDecl::DefinitionData *DD;2182  ASTContext &C = Reader.getContext();2183 2184  // Determine whether this is a lambda closure type, so that we can2185  // allocate the appropriate DefinitionData structure.2186  bool IsLambda = Record.readInt();2187  assert(!(IsLambda && Update) &&2188         "lambda definition should not be added by update record");2189  if (IsLambda)2190    DD = new (C) CXXRecordDecl::LambdaDefinitionData(2191        D, nullptr, CXXRecordDecl::LDK_Unknown, false, LCD_None);2192  else2193    DD = new (C) struct CXXRecordDecl::DefinitionData(D);2194 2195  CXXRecordDecl *Canon = D->getCanonicalDecl();2196  // Set decl definition data before reading it, so that during deserialization2197  // when we read CXXRecordDecl, it already has definition data and we don't2198  // set fake one.2199  if (!Canon->DefinitionData)2200    Canon->DefinitionData = DD;2201  D->DefinitionData = Canon->DefinitionData;2202  ReadCXXDefinitionData(*DD, D, LambdaContext, IndexInLambdaContext);2203 2204  // Mark this declaration as being a definition.2205  D->setCompleteDefinition(true);2206 2207  // We might already have a different definition for this record. This can2208  // happen either because we're reading an update record, or because we've2209  // already done some merging. Either way, just merge into it.2210  if (Canon->DefinitionData != DD) {2211    MergeImpl.MergeDefinitionData(Canon, std::move(*DD));2212    return;2213  }2214 2215  // If this is not the first declaration or is an update record, we can have2216  // other redeclarations already. Make a note that we need to propagate the2217  // DefinitionData pointer onto them.2218  if (Update || Canon != D)2219    Reader.PendingDefinitions.insert(D);2220}2221 2222RedeclarableResult ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {2223  RedeclarableResult Redecl = VisitRecordDeclImpl(D);2224 2225  ASTContext &C = Reader.getContext();2226 2227  enum CXXRecKind {2228    CXXRecNotTemplate = 0,2229    CXXRecTemplate,2230    CXXRecMemberSpecialization,2231    CXXLambda2232  };2233 2234  Decl *LambdaContext = nullptr;2235  unsigned IndexInLambdaContext = 0;2236 2237  switch ((CXXRecKind)Record.readInt()) {2238  case CXXRecNotTemplate:2239    // Merged when we merge the folding set entry in the primary template.2240    if (!isa<ClassTemplateSpecializationDecl>(D))2241      mergeRedeclarable(D, Redecl);2242    break;2243  case CXXRecTemplate: {2244    // Merged when we merge the template.2245    auto *Template = readDeclAs<ClassTemplateDecl>();2246    D->TemplateOrInstantiation = Template;2247    break;2248  }2249  case CXXRecMemberSpecialization: {2250    auto *RD = readDeclAs<CXXRecordDecl>();2251    auto TSK = (TemplateSpecializationKind)Record.readInt();2252    SourceLocation POI = readSourceLocation();2253    MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);2254    MSI->setPointOfInstantiation(POI);2255    D->TemplateOrInstantiation = MSI;2256    mergeRedeclarable(D, Redecl);2257    break;2258  }2259  case CXXLambda: {2260    LambdaContext = readDecl();2261    if (LambdaContext)2262      IndexInLambdaContext = Record.readInt();2263    if (LambdaContext)2264      MergeImpl.mergeLambda(D, Redecl, *LambdaContext, IndexInLambdaContext);2265    else2266      // If we don't have a mangling context, treat this like any other2267      // declaration.2268      mergeRedeclarable(D, Redecl);2269    break;2270  }2271  }2272 2273  bool WasDefinition = Record.readInt();2274  if (WasDefinition)2275    ReadCXXRecordDefinition(D, /*Update=*/false, LambdaContext,2276                            IndexInLambdaContext);2277  else2278    // Propagate DefinitionData pointer from the canonical declaration.2279    D->DefinitionData = D->getCanonicalDecl()->DefinitionData;2280 2281  // Lazily load the key function to avoid deserializing every method so we can2282  // compute it.2283  if (WasDefinition) {2284    GlobalDeclID KeyFn = readDeclID();2285    if (KeyFn.isValid() && D->isCompleteDefinition())2286      // FIXME: This is wrong for the ARM ABI, where some other module may have2287      // made this function no longer be a key function. We need an update2288      // record or similar for that case.2289      C.KeyFunctions[D] = KeyFn.getRawValue();2290  }2291 2292  return Redecl;2293}2294 2295void ASTDeclReader::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {2296  D->setExplicitSpecifier(Record.readExplicitSpec());2297  D->Ctor = readDeclAs<CXXConstructorDecl>();2298  VisitFunctionDecl(D);2299  D->setDeductionCandidateKind(2300      static_cast<DeductionCandidate>(Record.readInt()));2301  D->setSourceDeductionGuide(readDeclAs<CXXDeductionGuideDecl>());2302  D->setSourceDeductionGuideKind(2303      static_cast<CXXDeductionGuideDecl::SourceDeductionGuideKind>(2304          Record.readInt()));2305}2306 2307void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {2308  VisitFunctionDecl(D);2309 2310  unsigned NumOverridenMethods = Record.readInt();2311  if (D->isCanonicalDecl()) {2312    while (NumOverridenMethods--) {2313      // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,2314      // MD may be initializing.2315      if (auto *MD = readDeclAs<CXXMethodDecl>())2316        Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());2317    }2318  } else {2319    // We don't care about which declarations this used to override; we get2320    // the relevant information from the canonical declaration.2321    Record.skipInts(NumOverridenMethods);2322  }2323}2324 2325void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {2326  // We need the inherited constructor information to merge the declaration,2327  // so we have to read it before we call VisitCXXMethodDecl.2328  D->setExplicitSpecifier(Record.readExplicitSpec());2329  if (D->isInheritingConstructor()) {2330    auto *Shadow = readDeclAs<ConstructorUsingShadowDecl>();2331    auto *Ctor = readDeclAs<CXXConstructorDecl>();2332    *D->getTrailingObjects<InheritedConstructor>() =2333        InheritedConstructor(Shadow, Ctor);2334  }2335 2336  VisitCXXMethodDecl(D);2337}2338 2339void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {2340  VisitCXXMethodDecl(D);2341 2342  CXXDestructorDecl *Canon = D->getCanonicalDecl();2343  if (auto *OperatorDelete = readDeclAs<FunctionDecl>()) {2344    auto *ThisArg = Record.readExpr();2345    // FIXME: Check consistency if we have an old and new operator delete.2346    if (!Canon->OperatorDelete) {2347      Canon->OperatorDelete = OperatorDelete;2348      Canon->OperatorDeleteThisArg = ThisArg;2349    }2350  }2351  if (auto *OperatorGlobDelete = readDeclAs<FunctionDecl>()) {2352    if (!Canon->OperatorGlobalDelete) {2353      Canon->OperatorGlobalDelete = OperatorGlobDelete;2354    }2355  }2356}2357 2358void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {2359  D->setExplicitSpecifier(Record.readExplicitSpec());2360  VisitCXXMethodDecl(D);2361}2362 2363void ASTDeclReader::VisitImportDecl(ImportDecl *D) {2364  VisitDecl(D);2365  D->ImportedModule = readModule();2366  D->setImportComplete(Record.readInt());2367  auto *StoredLocs = D->getTrailingObjects();2368  for (unsigned I = 0, N = Record.back(); I != N; ++I)2369    StoredLocs[I] = readSourceLocation();2370  Record.skipInts(1); // The number of stored source locations.2371}2372 2373void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {2374  VisitDecl(D);2375  D->setColonLoc(readSourceLocation());2376}2377 2378void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {2379  VisitDecl(D);2380  if (Record.readInt()) // hasFriendDecl2381    D->Friend = readDeclAs<NamedDecl>();2382  else2383    D->Friend = readTypeSourceInfo();2384  for (unsigned i = 0; i != D->NumTPLists; ++i)2385    D->getTrailingObjects()[i] = Record.readTemplateParameterList();2386  D->NextFriend = readDeclID().getRawValue();2387  D->UnsupportedFriend = (Record.readInt() != 0);2388  D->FriendLoc = readSourceLocation();2389  D->EllipsisLoc = readSourceLocation();2390}2391 2392void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {2393  VisitDecl(D);2394  unsigned NumParams = Record.readInt();2395  D->NumParams = NumParams;2396  D->Params = new (Reader.getContext()) TemplateParameterList *[NumParams];2397  for (unsigned i = 0; i != NumParams; ++i)2398    D->Params[i] = Record.readTemplateParameterList();2399  if (Record.readInt()) // HasFriendDecl2400    D->Friend = readDeclAs<NamedDecl>();2401  else2402    D->Friend = readTypeSourceInfo();2403  D->FriendLoc = readSourceLocation();2404}2405 2406void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {2407  VisitNamedDecl(D);2408 2409  assert(!D->TemplateParams && "TemplateParams already set!");2410  D->TemplateParams = Record.readTemplateParameterList();2411  D->init(readDeclAs<NamedDecl>());2412}2413 2414void ASTDeclReader::VisitConceptDecl(ConceptDecl *D) {2415  VisitTemplateDecl(D);2416  D->ConstraintExpr = Record.readExpr();2417  mergeMergeable(D);2418}2419 2420void ASTDeclReader::VisitImplicitConceptSpecializationDecl(2421    ImplicitConceptSpecializationDecl *D) {2422  // The size of the template list was read during creation of the Decl, so we2423  // don't have to re-read it here.2424  VisitDecl(D);2425  llvm::SmallVector<TemplateArgument, 4> Args;2426  for (unsigned I = 0; I < D->NumTemplateArgs; ++I)2427    Args.push_back(Record.readTemplateArgument(/*Canonicalize=*/false));2428  D->setTemplateArguments(Args);2429}2430 2431void ASTDeclReader::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {2432}2433 2434void ASTDeclReader::ReadSpecializations(ModuleFile &M, Decl *D,2435                                        llvm::BitstreamCursor &DeclsCursor,2436                                        bool IsPartial) {2437  uint64_t Offset = ReadLocalOffset();2438  bool Failed =2439      Reader.ReadSpecializations(M, DeclsCursor, Offset, D, IsPartial);2440  (void)Failed;2441  assert(!Failed);2442}2443 2444RedeclarableResult2445ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {2446  RedeclarableResult Redecl = VisitRedeclarable(D);2447 2448  // Make sure we've allocated the Common pointer first. We do this before2449  // VisitTemplateDecl so that getCommonPtr() can be used during initialization.2450  RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();2451  if (!CanonD->Common) {2452    CanonD->Common = CanonD->newCommon(Reader.getContext());2453    Reader.PendingDefinitions.insert(CanonD);2454  }2455  D->Common = CanonD->Common;2456 2457  // If this is the first declaration of the template, fill in the information2458  // for the 'common' pointer.2459  if (ThisDeclID == Redecl.getFirstID()) {2460    if (auto *RTD = readDeclAs<RedeclarableTemplateDecl>()) {2461      assert(RTD->getKind() == D->getKind() &&2462             "InstantiatedFromMemberTemplate kind mismatch");2463      D->setInstantiatedFromMemberTemplate(RTD);2464      if (Record.readInt())2465        D->setMemberSpecialization();2466    }2467  }2468 2469  VisitTemplateDecl(D);2470  D->IdentifierNamespace = Record.readInt();2471 2472  return Redecl;2473}2474 2475void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {2476  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);2477  mergeRedeclarableTemplate(D, Redecl);2478 2479  if (ThisDeclID == Redecl.getFirstID()) {2480    // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of2481    // the specializations.2482    ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/false);2483    ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/true);2484  }2485}2486 2487void ASTDeclReader::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {2488  llvm_unreachable("BuiltinTemplates are not serialized");2489}2490 2491/// TODO: Unify with ClassTemplateDecl version?2492///       May require unifying ClassTemplateDecl and2493///        VarTemplateDecl beyond TemplateDecl...2494void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {2495  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);2496  mergeRedeclarableTemplate(D, Redecl);2497 2498  if (ThisDeclID == Redecl.getFirstID()) {2499    // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of2500    // the specializations.2501    ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/false);2502    ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/true);2503  }2504}2505 2506RedeclarableResult ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(2507    ClassTemplateSpecializationDecl *D) {2508  RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);2509 2510  ASTContext &C = Reader.getContext();2511  if (Decl *InstD = readDecl()) {2512    if (auto *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {2513      D->SpecializedTemplate = CTD;2514    } else {2515      SmallVector<TemplateArgument, 8> TemplArgs;2516      Record.readTemplateArgumentList(TemplArgs);2517      TemplateArgumentList *ArgList2518        = TemplateArgumentList::CreateCopy(C, TemplArgs);2519      auto *PS =2520          new (C) ClassTemplateSpecializationDecl::2521                                             SpecializedPartialSpecialization();2522      PS->PartialSpecialization2523          = cast<ClassTemplatePartialSpecializationDecl>(InstD);2524      PS->TemplateArgs = ArgList;2525      D->SpecializedTemplate = PS;2526    }2527  }2528 2529  SmallVector<TemplateArgument, 8> TemplArgs;2530  Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);2531  D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);2532  D->PointOfInstantiation = readSourceLocation();2533  D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();2534  D->StrictPackMatch = Record.readBool();2535 2536  bool writtenAsCanonicalDecl = Record.readInt();2537  if (writtenAsCanonicalDecl) {2538    auto *CanonPattern = readDeclAs<ClassTemplateDecl>();2539    if (D->isCanonicalDecl()) { // It's kept in the folding set.2540      // Set this as, or find, the canonical declaration for this specialization2541      ClassTemplateSpecializationDecl *CanonSpec;2542      if (auto *Partial = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {2543        CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations2544            .GetOrInsertNode(Partial);2545      } else {2546        CanonSpec =2547            CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);2548      }2549      // If there was already a canonical specialization, merge into it.2550      if (CanonSpec != D) {2551        MergeImpl.mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);2552 2553        // This declaration might be a definition. Merge with any existing2554        // definition.2555        if (auto *DDD = D->DefinitionData) {2556          if (CanonSpec->DefinitionData)2557            MergeImpl.MergeDefinitionData(CanonSpec, std::move(*DDD));2558          else2559            CanonSpec->DefinitionData = D->DefinitionData;2560        }2561        D->DefinitionData = CanonSpec->DefinitionData;2562      }2563    }2564  }2565 2566  // extern/template keyword locations for explicit instantiations2567  if (Record.readBool()) {2568    auto *ExplicitInfo = new (C) ExplicitInstantiationInfo;2569    ExplicitInfo->ExternKeywordLoc = readSourceLocation();2570    ExplicitInfo->TemplateKeywordLoc = readSourceLocation();2571    D->ExplicitInfo = ExplicitInfo;2572  }2573 2574  if (Record.readBool())2575    D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());2576 2577  return Redecl;2578}2579 2580void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(2581                                    ClassTemplatePartialSpecializationDecl *D) {2582  // We need to read the template params first because redeclarable is going to2583  // need them for profiling2584  TemplateParameterList *Params = Record.readTemplateParameterList();2585  D->TemplateParams = Params;2586 2587  RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);2588 2589  // These are read/set from/to the first declaration.2590  if (ThisDeclID == Redecl.getFirstID()) {2591    D->InstantiatedFromMember.setPointer(2592        readDeclAs<ClassTemplatePartialSpecializationDecl>());2593    D->InstantiatedFromMember.setInt(Record.readInt());2594  }2595}2596 2597void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {2598  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);2599 2600  if (ThisDeclID == Redecl.getFirstID()) {2601    // This FunctionTemplateDecl owns a CommonPtr; read it.2602    ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/false);2603  }2604}2605 2606/// TODO: Unify with ClassTemplateSpecializationDecl version?2607///       May require unifying ClassTemplate(Partial)SpecializationDecl and2608///        VarTemplate(Partial)SpecializationDecl with a new data2609///        structure Template(Partial)SpecializationDecl, and2610///        using Template(Partial)SpecializationDecl as input type.2611RedeclarableResult ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(2612    VarTemplateSpecializationDecl *D) {2613  ASTContext &C = Reader.getContext();2614  if (Decl *InstD = readDecl()) {2615    if (auto *VTD = dyn_cast<VarTemplateDecl>(InstD)) {2616      D->SpecializedTemplate = VTD;2617    } else {2618      SmallVector<TemplateArgument, 8> TemplArgs;2619      Record.readTemplateArgumentList(TemplArgs);2620      TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(2621          C, TemplArgs);2622      auto *PS =2623          new (C)2624          VarTemplateSpecializationDecl::SpecializedPartialSpecialization();2625      PS->PartialSpecialization =2626          cast<VarTemplatePartialSpecializationDecl>(InstD);2627      PS->TemplateArgs = ArgList;2628      D->SpecializedTemplate = PS;2629    }2630  }2631 2632  // extern/template keyword locations for explicit instantiations2633  if (Record.readBool()) {2634    auto *ExplicitInfo = new (C) ExplicitInstantiationInfo;2635    ExplicitInfo->ExternKeywordLoc = readSourceLocation();2636    ExplicitInfo->TemplateKeywordLoc = readSourceLocation();2637    D->ExplicitInfo = ExplicitInfo;2638  }2639 2640  if (Record.readBool())2641    D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());2642 2643  SmallVector<TemplateArgument, 8> TemplArgs;2644  Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);2645  D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);2646  D->PointOfInstantiation = readSourceLocation();2647  D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();2648  D->IsCompleteDefinition = Record.readInt();2649 2650  RedeclarableResult Redecl = VisitVarDeclImpl(D);2651 2652  bool writtenAsCanonicalDecl = Record.readInt();2653  if (writtenAsCanonicalDecl) {2654    auto *CanonPattern = readDeclAs<VarTemplateDecl>();2655    if (D->isCanonicalDecl()) { // It's kept in the folding set.2656      VarTemplateSpecializationDecl *CanonSpec;2657      if (auto *Partial = dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {2658        CanonSpec = CanonPattern->getCommonPtr()2659                        ->PartialSpecializations.GetOrInsertNode(Partial);2660      } else {2661        CanonSpec =2662            CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);2663      }2664      // If we already have a matching specialization, merge it.2665      if (CanonSpec != D)2666        MergeImpl.mergeRedeclarable<VarDecl>(D, CanonSpec, Redecl);2667    }2668  }2669 2670  return Redecl;2671}2672 2673/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?2674///       May require unifying ClassTemplate(Partial)SpecializationDecl and2675///        VarTemplate(Partial)SpecializationDecl with a new data2676///        structure Template(Partial)SpecializationDecl, and2677///        using Template(Partial)SpecializationDecl as input type.2678void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(2679    VarTemplatePartialSpecializationDecl *D) {2680  TemplateParameterList *Params = Record.readTemplateParameterList();2681  D->TemplateParams = Params;2682 2683  RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);2684 2685  // These are read/set from/to the first declaration.2686  if (ThisDeclID == Redecl.getFirstID()) {2687    D->InstantiatedFromMember.setPointer(2688        readDeclAs<VarTemplatePartialSpecializationDecl>());2689    D->InstantiatedFromMember.setInt(Record.readInt());2690  }2691}2692 2693void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {2694  VisitTypeDecl(D);2695 2696  D->setDeclaredWithTypename(Record.readInt());2697 2698  bool TypeConstraintInitialized = D->hasTypeConstraint() && Record.readBool();2699  if (TypeConstraintInitialized) {2700    ConceptReference *CR = nullptr;2701    if (Record.readBool())2702      CR = Record.readConceptReference();2703    Expr *ImmediatelyDeclaredConstraint = Record.readExpr();2704    UnsignedOrNone ArgPackSubstIndex = Record.readUnsignedOrNone();2705 2706    D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint, ArgPackSubstIndex);2707    D->NumExpanded = Record.readUnsignedOrNone();2708  }2709 2710  if (Record.readInt())2711    D->setDefaultArgument(Reader.getContext(),2712                          Record.readTemplateArgumentLoc());2713}2714 2715void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {2716  VisitDeclaratorDecl(D);2717  // TemplateParmPosition.2718  D->setDepth(Record.readInt());2719  D->setPosition(Record.readInt());2720  if (D->hasPlaceholderTypeConstraint())2721    D->setPlaceholderTypeConstraint(Record.readExpr());2722  if (D->isExpandedParameterPack()) {2723    auto TypesAndInfos =2724        D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();2725    for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {2726      new (&TypesAndInfos[I].first) QualType(Record.readType());2727      TypesAndInfos[I].second = readTypeSourceInfo();2728    }2729  } else {2730    // Rest of NonTypeTemplateParmDecl.2731    D->ParameterPack = Record.readInt();2732    if (Record.readInt())2733      D->setDefaultArgument(Reader.getContext(),2734                            Record.readTemplateArgumentLoc());2735  }2736}2737 2738void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {2739  VisitTemplateDecl(D);2740  D->ParameterKind = static_cast<TemplateNameKind>(Record.readInt());2741  D->setDeclaredWithTypename(Record.readBool());2742  // TemplateParmPosition.2743  D->setDepth(Record.readInt());2744  D->setPosition(Record.readInt());2745  if (D->isExpandedParameterPack()) {2746    auto **Data = D->getTrailingObjects();2747    for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();2748         I != N; ++I)2749      Data[I] = Record.readTemplateParameterList();2750  } else {2751    // Rest of TemplateTemplateParmDecl.2752    D->ParameterPack = Record.readInt();2753    if (Record.readInt())2754      D->setDefaultArgument(Reader.getContext(),2755                            Record.readTemplateArgumentLoc());2756  }2757}2758 2759void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {2760  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);2761  mergeRedeclarableTemplate(D, Redecl);2762}2763 2764void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {2765  VisitDecl(D);2766  D->AssertExprAndFailed.setPointer(Record.readExpr());2767  D->AssertExprAndFailed.setInt(Record.readInt());2768  D->Message = cast_or_null<StringLiteral>(Record.readExpr());2769  D->RParenLoc = readSourceLocation();2770}2771 2772void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {2773  VisitDecl(D);2774}2775 2776void ASTDeclReader::VisitLifetimeExtendedTemporaryDecl(2777    LifetimeExtendedTemporaryDecl *D) {2778  VisitDecl(D);2779  D->ExtendingDecl = readDeclAs<ValueDecl>();2780  D->ExprWithTemporary = Record.readStmt();2781  if (Record.readInt()) {2782    D->Value = new (D->getASTContext()) APValue(Record.readAPValue());2783    D->getASTContext().addDestruction(D->Value);2784  }2785  D->ManglingNumber = Record.readInt();2786  mergeMergeable(D);2787}2788 2789void ASTDeclReader::VisitDeclContext(DeclContext *DC,2790                                     LookupBlockOffsets &Offsets) {2791  Offsets.LexicalOffset = ReadLocalOffset();2792  Offsets.VisibleOffset = ReadLocalOffset();2793  Offsets.ModuleLocalOffset = ReadLocalOffset();2794  Offsets.TULocalOffset = ReadLocalOffset();2795}2796 2797template <typename T>2798RedeclarableResult ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {2799  GlobalDeclID FirstDeclID = readDeclID();2800  Decl *MergeWith = nullptr;2801 2802  bool IsKeyDecl = ThisDeclID == FirstDeclID;2803  bool IsFirstLocalDecl = false;2804 2805  uint64_t RedeclOffset = 0;2806 2807  // invalid FirstDeclID  indicates that this declaration was the only2808  // declaration of its entity, and is used for space optimization.2809  if (FirstDeclID.isInvalid()) {2810    FirstDeclID = ThisDeclID;2811    IsKeyDecl = true;2812    IsFirstLocalDecl = true;2813  } else if (unsigned N = Record.readInt()) {2814    // This declaration was the first local declaration, but may have imported2815    // other declarations.2816    IsKeyDecl = N == 1;2817    IsFirstLocalDecl = true;2818 2819    // We have some declarations that must be before us in our redeclaration2820    // chain. Read them now, and remember that we ought to merge with one of2821    // them.2822    // FIXME: Provide a known merge target to the second and subsequent such2823    // declaration.2824    for (unsigned I = 0; I != N - 1; ++I)2825      MergeWith = readDecl();2826 2827    RedeclOffset = ReadLocalOffset();2828  } else {2829    // This declaration was not the first local declaration. Read the first2830    // local declaration now, to trigger the import of other redeclarations.2831    (void)readDecl();2832  }2833 2834  auto *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));2835  if (FirstDecl != D) {2836    // We delay loading of the redeclaration chain to avoid deeply nested calls.2837    // We temporarily set the first (canonical) declaration as the previous one2838    // which is the one that matters and mark the real previous DeclID to be2839    // loaded & attached later on.2840    D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);2841    D->First = FirstDecl->getCanonicalDecl();2842  }2843 2844  auto *DAsT = static_cast<T *>(D);2845 2846  // Note that we need to load local redeclarations of this decl and build a2847  // decl chain for them. This must happen *after* we perform the preloading2848  // above; this ensures that the redeclaration chain is built in the correct2849  // order.2850  if (IsFirstLocalDecl)2851    Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));2852 2853  return RedeclarableResult(MergeWith, FirstDeclID, IsKeyDecl);2854}2855 2856/// Attempts to merge the given declaration (D) with another declaration2857/// of the same entity.2858template <typename T>2859void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,2860                                      RedeclarableResult &Redecl) {2861  // If modules are not available, there is no reason to perform this merge.2862  if (!Reader.getContext().getLangOpts().Modules)2863    return;2864 2865  // If we're not the canonical declaration, we don't need to merge.2866  if (!DBase->isFirstDecl())2867    return;2868 2869  auto *D = static_cast<T *>(DBase);2870 2871  if (auto *Existing = Redecl.getKnownMergeTarget())2872    // We already know of an existing declaration we should merge with.2873    MergeImpl.mergeRedeclarable(D, cast<T>(Existing), Redecl);2874  else if (FindExistingResult ExistingRes = findExisting(D))2875    if (T *Existing = ExistingRes)2876      MergeImpl.mergeRedeclarable(D, Existing, Redecl);2877}2878 2879/// Attempt to merge D with a previous declaration of the same lambda, which is2880/// found by its index within its context declaration, if it has one.2881///2882/// We can't look up lambdas in their enclosing lexical or semantic context in2883/// general, because for lambdas in variables, both of those might be a2884/// namespace or the translation unit.2885void ASTDeclMerger::mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl,2886                                Decl &Context, unsigned IndexInContext) {2887  // If modules are not available, there is no reason to perform this merge.2888  if (!Reader.getContext().getLangOpts().Modules)2889    return;2890 2891  // If we're not the canonical declaration, we don't need to merge.2892  if (!D->isFirstDecl())2893    return;2894 2895  if (auto *Existing = Redecl.getKnownMergeTarget())2896    // We already know of an existing declaration we should merge with.2897    mergeRedeclarable(D, cast<TagDecl>(Existing), Redecl);2898 2899  // Look up this lambda to see if we've seen it before. If so, merge with the2900  // one we already loaded.2901  NamedDecl *&Slot = Reader.LambdaDeclarationsForMerging[{2902      Context.getCanonicalDecl(), IndexInContext}];2903  if (Slot)2904    mergeRedeclarable(D, cast<TagDecl>(Slot), Redecl);2905  else2906    Slot = D;2907}2908 2909void ASTDeclReader::mergeRedeclarableTemplate(RedeclarableTemplateDecl *D,2910                                              RedeclarableResult &Redecl) {2911  mergeRedeclarable(D, Redecl);2912  // If we merged the template with a prior declaration chain, merge the2913  // common pointer.2914  // FIXME: Actually merge here, don't just overwrite.2915  D->Common = D->getCanonicalDecl()->Common;2916}2917 2918/// "Cast" to type T, asserting if we don't have an implicit conversion.2919/// We use this to put code in a template that will only be valid for certain2920/// instantiations.2921template<typename T> static T assert_cast(T t) { return t; }2922template<typename T> static T assert_cast(...) {2923  llvm_unreachable("bad assert_cast");2924}2925 2926/// Merge together the pattern declarations from two template2927/// declarations.2928void ASTDeclMerger::mergeTemplatePattern(RedeclarableTemplateDecl *D,2929                                         RedeclarableTemplateDecl *Existing,2930                                         bool IsKeyDecl) {2931  auto *DPattern = D->getTemplatedDecl();2932  auto *ExistingPattern = Existing->getTemplatedDecl();2933  RedeclarableResult Result(2934      /*MergeWith*/ ExistingPattern,2935      DPattern->getCanonicalDecl()->getGlobalID(), IsKeyDecl);2936 2937  if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {2938    // Merge with any existing definition.2939    // FIXME: This is duplicated in several places. Refactor.2940    auto *ExistingClass =2941        cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();2942    if (auto *DDD = DClass->DefinitionData) {2943      if (ExistingClass->DefinitionData) {2944        MergeDefinitionData(ExistingClass, std::move(*DDD));2945      } else {2946        ExistingClass->DefinitionData = DClass->DefinitionData;2947        // We may have skipped this before because we thought that DClass2948        // was the canonical declaration.2949        Reader.PendingDefinitions.insert(DClass);2950      }2951    }2952    DClass->DefinitionData = ExistingClass->DefinitionData;2953 2954    return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),2955                             Result);2956  }2957  if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))2958    return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),2959                             Result);2960  if (auto *DVar = dyn_cast<VarDecl>(DPattern))2961    return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);2962  if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))2963    return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),2964                             Result);2965  llvm_unreachable("merged an unknown kind of redeclarable template");2966}2967 2968/// Attempts to merge the given declaration (D) with another declaration2969/// of the same entity.2970template <typename T>2971void ASTDeclMerger::mergeRedeclarableImpl(Redeclarable<T> *DBase, T *Existing,2972                                          GlobalDeclID KeyDeclID) {2973  auto *D = static_cast<T *>(DBase);2974  T *ExistingCanon = Existing->getCanonicalDecl();2975  T *DCanon = D->getCanonicalDecl();2976  if (ExistingCanon != DCanon) {2977    // Have our redeclaration link point back at the canonical declaration2978    // of the existing declaration, so that this declaration has the2979    // appropriate canonical declaration.2980    D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);2981    D->First = ExistingCanon;2982    ExistingCanon->Used |= D->Used;2983    D->Used = false;2984 2985    bool IsKeyDecl = KeyDeclID.isValid();2986 2987    // When we merge a template, merge its pattern.2988    if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))2989      mergeTemplatePattern(2990          DTemplate, assert_cast<RedeclarableTemplateDecl *>(ExistingCanon),2991          IsKeyDecl);2992 2993    // If this declaration is a key declaration, make a note of that.2994    if (IsKeyDecl)2995      Reader.KeyDecls[ExistingCanon].push_back(KeyDeclID);2996  }2997}2998 2999/// ODR-like semantics for C/ObjC allow us to merge tag types and a structural3000/// check in Sema guarantees the types can be merged (see C11 6.2.7/1 or C893001/// 6.1.2.6/1). Although most merging is done in Sema, we need to guarantee3002/// that some types are mergeable during deserialization, otherwise name3003/// lookup fails. This is the case for EnumConstantDecl.3004static bool allowODRLikeMergeInC(NamedDecl *ND) {3005  if (!ND)3006    return false;3007  // TODO: implement merge for other necessary decls.3008  if (isa<EnumConstantDecl, FieldDecl, IndirectFieldDecl>(ND))3009    return true;3010  return false;3011}3012 3013/// Attempts to merge LifetimeExtendedTemporaryDecl with3014/// identical class definitions from two different modules.3015void ASTDeclReader::mergeMergeable(LifetimeExtendedTemporaryDecl *D) {3016  // If modules are not available, there is no reason to perform this merge.3017  if (!Reader.getContext().getLangOpts().Modules)3018    return;3019 3020  LifetimeExtendedTemporaryDecl *LETDecl = D;3021 3022  LifetimeExtendedTemporaryDecl *&LookupResult =3023      Reader.LETemporaryForMerging[std::make_pair(3024          LETDecl->getExtendingDecl(), LETDecl->getManglingNumber())];3025  if (LookupResult)3026    Reader.getContext().setPrimaryMergedDecl(LETDecl,3027                                             LookupResult->getCanonicalDecl());3028  else3029    LookupResult = LETDecl;3030}3031 3032/// Attempts to merge the given declaration (D) with another declaration3033/// of the same entity, for the case where the entity is not actually3034/// redeclarable. This happens, for instance, when merging the fields of3035/// identical class definitions from two different modules.3036template<typename T>3037void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {3038  // If modules are not available, there is no reason to perform this merge.3039  if (!Reader.getContext().getLangOpts().Modules)3040    return;3041 3042  // ODR-based merging is performed in C++ and in some cases (tag types) in C.3043  // Note that C identically-named things in different translation units are3044  // not redeclarations, but may still have compatible types, where ODR-like3045  // semantics may apply.3046  if (!Reader.getContext().getLangOpts().CPlusPlus &&3047      !allowODRLikeMergeInC(dyn_cast<NamedDecl>(static_cast<T*>(D))))3048    return;3049 3050  if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))3051    if (T *Existing = ExistingRes)3052      Reader.getContext().setPrimaryMergedDecl(static_cast<T *>(D),3053                                               Existing->getCanonicalDecl());3054}3055 3056void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {3057  Record.readOMPChildren(D->Data);3058  VisitDecl(D);3059}3060 3061void ASTDeclReader::VisitOMPAllocateDecl(OMPAllocateDecl *D) {3062  Record.readOMPChildren(D->Data);3063  VisitDecl(D);3064}3065 3066void ASTDeclReader::VisitOMPRequiresDecl(OMPRequiresDecl * D) {3067  Record.readOMPChildren(D->Data);3068  VisitDecl(D);3069}3070 3071void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {3072  VisitValueDecl(D);3073  D->setLocation(readSourceLocation());3074  Expr *In = Record.readExpr();3075  Expr *Out = Record.readExpr();3076  D->setCombinerData(In, Out);3077  Expr *Combiner = Record.readExpr();3078  D->setCombiner(Combiner);3079  Expr *Orig = Record.readExpr();3080  Expr *Priv = Record.readExpr();3081  D->setInitializerData(Orig, Priv);3082  Expr *Init = Record.readExpr();3083  auto IK = static_cast<OMPDeclareReductionInitKind>(Record.readInt());3084  D->setInitializer(Init, IK);3085  D->PrevDeclInScope = readDeclID().getRawValue();3086}3087 3088void ASTDeclReader::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {3089  Record.readOMPChildren(D->Data);3090  VisitValueDecl(D);3091  D->VarName = Record.readDeclarationName();3092  D->PrevDeclInScope = readDeclID().getRawValue();3093}3094 3095void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {3096  VisitVarDecl(D);3097}3098 3099void ASTDeclReader::VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D) {3100  VisitDecl(D);3101  D->DirKind = Record.readEnum<OpenACCDirectiveKind>();3102  D->DirectiveLoc = Record.readSourceLocation();3103  D->EndLoc = Record.readSourceLocation();3104  Record.readOpenACCClauseList(D->Clauses);3105}3106void ASTDeclReader::VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D) {3107  VisitDecl(D);3108  D->DirKind = Record.readEnum<OpenACCDirectiveKind>();3109  D->DirectiveLoc = Record.readSourceLocation();3110  D->EndLoc = Record.readSourceLocation();3111  D->ParensLoc = Record.readSourceRange();3112  D->FuncRef = Record.readExpr();3113  Record.readOpenACCClauseList(D->Clauses);3114}3115 3116//===----------------------------------------------------------------------===//3117// Attribute Reading3118//===----------------------------------------------------------------------===//3119 3120namespace {3121class AttrReader {3122  ASTRecordReader &Reader;3123 3124public:3125  AttrReader(ASTRecordReader &Reader) : Reader(Reader) {}3126 3127  uint64_t readInt() {3128    return Reader.readInt();3129  }3130 3131  bool readBool() { return Reader.readBool(); }3132 3133  SourceRange readSourceRange() {3134    return Reader.readSourceRange();3135  }3136 3137  SourceLocation readSourceLocation() {3138    return Reader.readSourceLocation();3139  }3140 3141  Expr *readExpr() { return Reader.readExpr(); }3142 3143  Attr *readAttr() { return Reader.readAttr(); }3144 3145  std::string readString() {3146    return Reader.readString();3147  }3148 3149  TypeSourceInfo *readTypeSourceInfo() {3150    return Reader.readTypeSourceInfo();3151  }3152 3153  IdentifierInfo *readIdentifier() {3154    return Reader.readIdentifier();3155  }3156 3157  VersionTuple readVersionTuple() {3158    return Reader.readVersionTuple();3159  }3160 3161  OMPTraitInfo *readOMPTraitInfo() { return Reader.readOMPTraitInfo(); }3162 3163  template <typename T> T *readDeclAs() { return Reader.readDeclAs<T>(); }3164};3165}3166 3167Attr *ASTRecordReader::readAttr() {3168  AttrReader Record(*this);3169  auto V = Record.readInt();3170  if (!V)3171    return nullptr;3172 3173  Attr *New = nullptr;3174  // Kind is stored as a 1-based integer because 0 is used to indicate a null3175  // Attr pointer.3176  auto Kind = static_cast<attr::Kind>(V - 1);3177  ASTContext &Context = getContext();3178 3179  IdentifierInfo *AttrName = Record.readIdentifier();3180  IdentifierInfo *ScopeName = Record.readIdentifier();3181  SourceRange AttrRange = Record.readSourceRange();3182  SourceLocation ScopeLoc = Record.readSourceLocation();3183  unsigned ParsedKind = Record.readInt();3184  unsigned Syntax = Record.readInt();3185  unsigned SpellingIndex = Record.readInt();3186  bool IsAlignas = (ParsedKind == AttributeCommonInfo::AT_Aligned &&3187                    Syntax == AttributeCommonInfo::AS_Keyword &&3188                    SpellingIndex == AlignedAttr::Keyword_alignas);3189  bool IsRegularKeywordAttribute = Record.readBool();3190 3191  AttributeCommonInfo Info(AttrName, AttributeScopeInfo(ScopeName, ScopeLoc),3192                           AttrRange, AttributeCommonInfo::Kind(ParsedKind),3193                           {AttributeCommonInfo::Syntax(Syntax), SpellingIndex,3194                            IsAlignas, IsRegularKeywordAttribute});3195 3196#include "clang/Serialization/AttrPCHRead.inc"3197 3198  assert(New && "Unable to decode attribute?");3199  return New;3200}3201 3202/// Reads attributes from the current stream position.3203void ASTRecordReader::readAttributes(AttrVec &Attrs) {3204  for (unsigned I = 0, E = readInt(); I != E; ++I)3205    if (auto *A = readAttr())3206      Attrs.push_back(A);3207}3208 3209//===----------------------------------------------------------------------===//3210// ASTReader Implementation3211//===----------------------------------------------------------------------===//3212 3213/// Note that we have loaded the declaration with the given3214/// Index.3215///3216/// This routine notes that this declaration has already been loaded,3217/// so that future GetDecl calls will return this declaration rather3218/// than trying to load a new declaration.3219inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {3220  assert(!DeclsLoaded[Index] && "Decl loaded twice?");3221  DeclsLoaded[Index] = D;3222}3223 3224/// Determine whether the consumer will be interested in seeing3225/// this declaration (via HandleTopLevelDecl).3226///3227/// This routine should return true for anything that might affect3228/// code generation, e.g., inline function definitions, Objective-C3229/// declarations with metadata, etc.3230bool ASTReader::isConsumerInterestedIn(Decl *D) {3231  // An ObjCMethodDecl is never considered as "interesting" because its3232  // implementation container always is.3233 3234  // An ImportDecl or VarDecl imported from a module map module will get3235  // emitted when we import the relevant module.3236  if (isPartOfPerModuleInitializer(D)) {3237    auto *M = D->getImportedOwningModule();3238    if (M && M->Kind == Module::ModuleMapModule &&3239        getContext().DeclMustBeEmitted(D))3240      return false;3241  }3242 3243  if (isa<FileScopeAsmDecl, TopLevelStmtDecl, ObjCProtocolDecl, ObjCImplDecl,3244          ImportDecl, PragmaCommentDecl, PragmaDetectMismatchDecl>(D))3245    return true;3246  if (isa<OMPThreadPrivateDecl, OMPDeclareReductionDecl, OMPDeclareMapperDecl,3247          OMPAllocateDecl, OMPRequiresDecl>(D))3248    return !D->getDeclContext()->isFunctionOrMethod();3249  if (const auto *Var = dyn_cast<VarDecl>(D))3250    return Var->isFileVarDecl() &&3251           (Var->isThisDeclarationADefinition() == VarDecl::Definition ||3252            OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Var));3253  if (const auto *Func = dyn_cast<FunctionDecl>(D))3254    return Func->doesThisDeclarationHaveABody() || PendingBodies.count(D);3255 3256  if (auto *ES = D->getASTContext().getExternalSource())3257    if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)3258      return true;3259 3260  return false;3261}3262 3263/// Get the correct cursor and offset for loading a declaration.3264ASTReader::RecordLocation ASTReader::DeclCursorForID(GlobalDeclID ID,3265                                                     SourceLocation &Loc) {3266  ModuleFile *M = getOwningModuleFile(ID);3267  assert(M);3268  unsigned LocalDeclIndex = ID.getLocalDeclIndex();3269  const DeclOffset &DOffs = M->DeclOffsets[LocalDeclIndex];3270  Loc = ReadSourceLocation(*M, DOffs.getRawLoc());3271  return RecordLocation(M, DOffs.getBitOffset(M->DeclsBlockStartOffset));3272}3273 3274ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {3275  auto I = GlobalBitOffsetsMap.find(GlobalOffset);3276 3277  assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");3278  return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);3279}3280 3281uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset) {3282  return LocalOffset + M.GlobalBitOffset;3283}3284 3285CXXRecordDecl *3286ASTDeclReader::getOrFakePrimaryClassDefinition(ASTReader &Reader,3287                                               CXXRecordDecl *RD) {3288  // Try to dig out the definition.3289  auto *DD = RD->DefinitionData;3290  if (!DD)3291    DD = RD->getCanonicalDecl()->DefinitionData;3292 3293  // If there's no definition yet, then DC's definition is added by an update3294  // record, but we've not yet loaded that update record. In this case, we3295  // commit to DC being the canonical definition now, and will fix this when3296  // we load the update record.3297  if (!DD) {3298    DD = new (Reader.getContext()) struct CXXRecordDecl::DefinitionData(RD);3299    RD->setCompleteDefinition(true);3300    RD->DefinitionData = DD;3301    RD->getCanonicalDecl()->DefinitionData = DD;3302 3303    // Track that we did this horrible thing so that we can fix it later.3304    Reader.PendingFakeDefinitionData.insert(3305        std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));3306  }3307 3308  return DD->Definition;3309}3310 3311/// Find the context in which we should search for previous declarations when3312/// looking for declarations to merge.3313DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,3314                                                        DeclContext *DC) {3315  if (auto *ND = dyn_cast<NamespaceDecl>(DC))3316    return ND->getFirstDecl();3317 3318  if (auto *RD = dyn_cast<CXXRecordDecl>(DC))3319    return getOrFakePrimaryClassDefinition(Reader, RD);3320 3321  if (auto *RD = dyn_cast<RecordDecl>(DC))3322    return RD->getDefinition();3323 3324  if (auto *ED = dyn_cast<EnumDecl>(DC))3325    return ED->getDefinition();3326 3327  if (auto *OID = dyn_cast<ObjCInterfaceDecl>(DC))3328    return OID->getDefinition();3329 3330  // We can see the TU here only if we have no Sema object. It is possible3331  // we're in clang-repl so we still need to get the primary context.3332  if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))3333    return TU->getPrimaryContext();3334 3335  return nullptr;3336}3337 3338ASTDeclReader::FindExistingResult::~FindExistingResult() {3339  // Record that we had a typedef name for linkage whether or not we merge3340  // with that declaration.3341  if (TypedefNameForLinkage) {3342    DeclContext *DC = New->getDeclContext()->getRedeclContext();3343    Reader.ImportedTypedefNamesForLinkage.insert(3344        std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));3345    return;3346  }3347 3348  if (!AddResult || Existing)3349    return;3350 3351  DeclarationName Name = New->getDeclName();3352  DeclContext *DC = New->getDeclContext()->getRedeclContext();3353  if (needsAnonymousDeclarationNumber(New)) {3354    setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),3355                               AnonymousDeclNumber, New);3356  } else if (DC->isTranslationUnit() &&3357             !Reader.getContext().getLangOpts().CPlusPlus) {3358    if (Reader.getIdResolver().tryAddTopLevelDecl(New, Name))3359      Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]3360            .push_back(New);3361  } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {3362    // Add the declaration to its redeclaration context so later merging3363    // lookups will find it.3364    MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);3365  }3366}3367 3368/// Find the declaration that should be merged into, given the declaration found3369/// by name lookup. If we're merging an anonymous declaration within a typedef,3370/// we need a matching typedef, and we merge with the type inside it.3371static NamedDecl *getDeclForMerging(NamedDecl *Found,3372                                    bool IsTypedefNameForLinkage) {3373  if (!IsTypedefNameForLinkage)3374    return Found;3375 3376  // If we found a typedef declaration that gives a name to some other3377  // declaration, then we want that inner declaration. Declarations from3378  // AST files are handled via ImportedTypedefNamesForLinkage.3379  if (Found->isFromASTFile())3380    return nullptr;3381 3382  if (auto *TND = dyn_cast<TypedefNameDecl>(Found))3383    return TND->getAnonDeclWithTypedefName(/*AnyRedecl*/true);3384 3385  return nullptr;3386}3387 3388/// Find the declaration to use to populate the anonymous declaration table3389/// for the given lexical DeclContext. We only care about finding local3390/// definitions of the context; we'll merge imported ones as we go.3391DeclContext *3392ASTDeclReader::getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC) {3393  // For classes, we track the definition as we merge.3394  if (auto *RD = dyn_cast<CXXRecordDecl>(LexicalDC)) {3395    auto *DD = RD->getCanonicalDecl()->DefinitionData;3396    return DD ? DD->Definition : nullptr;3397  } else if (auto *OID = dyn_cast<ObjCInterfaceDecl>(LexicalDC)) {3398    return OID->getCanonicalDecl()->getDefinition();3399  }3400 3401  // For anything else, walk its merged redeclarations looking for a definition.3402  // Note that we can't just call getDefinition here because the redeclaration3403  // chain isn't wired up.3404  for (auto *D : merged_redecls(cast<Decl>(LexicalDC))) {3405    if (auto *FD = dyn_cast<FunctionDecl>(D))3406      if (FD->isThisDeclarationADefinition())3407        return FD;3408    if (auto *MD = dyn_cast<ObjCMethodDecl>(D))3409      if (MD->isThisDeclarationADefinition())3410        return MD;3411    if (auto *RD = dyn_cast<RecordDecl>(D))3412      if (RD->isThisDeclarationADefinition())3413        return RD;3414  }3415 3416  // No merged definition yet.3417  return nullptr;3418}3419 3420NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,3421                                                     DeclContext *DC,3422                                                     unsigned Index) {3423  // If the lexical context has been merged, look into the now-canonical3424  // definition.3425  auto *CanonDC = cast<Decl>(DC)->getCanonicalDecl();3426 3427  // If we've seen this before, return the canonical declaration.3428  auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];3429  if (Index < Previous.size() && Previous[Index])3430    return Previous[Index];3431 3432  // If this is the first time, but we have parsed a declaration of the context,3433  // build the anonymous declaration list from the parsed declaration.3434  auto *PrimaryDC = getPrimaryDCForAnonymousDecl(DC);3435  auto needToNumberAnonymousDeclsWithin = [](Decl *D) {3436    if (!D->isFromASTFile())3437      return true;3438    // If this is a class template specialization from an AST file, has at least3439    // one field, but none of the fields have been loaded from external storage,3440    // this is a situation where the class template specialization decl3441    // was imported but the definition was instantiated within the source.3442    // In such a case, we still need to number the anonymous decls.3443    auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D);3444    return CTSD && !CTSD->noload_field_empty() &&3445           !CTSD->hasLoadedFieldsFromExternalStorage();3446  };3447  if (PrimaryDC && needToNumberAnonymousDeclsWithin(cast<Decl>(PrimaryDC))) {3448    numberAnonymousDeclsWithin(PrimaryDC, [&](NamedDecl *ND, unsigned Number) {3449      if (Previous.size() == Number)3450        Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));3451      else3452        Previous[Number] = cast<NamedDecl>(ND->getCanonicalDecl());3453    });3454  }3455 3456  return Index < Previous.size() ? Previous[Index] : nullptr;3457}3458 3459void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,3460                                               DeclContext *DC, unsigned Index,3461                                               NamedDecl *D) {3462  auto *CanonDC = cast<Decl>(DC)->getCanonicalDecl();3463 3464  auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];3465  if (Index >= Previous.size())3466    Previous.resize(Index + 1);3467  if (!Previous[Index])3468    Previous[Index] = D;3469}3470 3471ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {3472  DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage3473                                               : D->getDeclName();3474 3475  if (!Name && !needsAnonymousDeclarationNumber(D)) {3476    // Don't bother trying to find unnamed declarations that are in3477    // unmergeable contexts.3478    FindExistingResult Result(Reader, D, /*Existing=*/nullptr,3479                              AnonymousDeclNumber, TypedefNameForLinkage);3480    Result.suppress();3481    return Result;3482  }3483 3484  ASTContext &C = Reader.getContext();3485  DeclContext *DC = D->getDeclContext()->getRedeclContext();3486  if (TypedefNameForLinkage) {3487    auto It = Reader.ImportedTypedefNamesForLinkage.find(3488        std::make_pair(DC, TypedefNameForLinkage));3489    if (It != Reader.ImportedTypedefNamesForLinkage.end())3490      if (C.isSameEntity(It->second, D))3491        return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,3492                                  TypedefNameForLinkage);3493    // Go on to check in other places in case an existing typedef name3494    // was not imported.3495  }3496 3497  if (needsAnonymousDeclarationNumber(D)) {3498    // This is an anonymous declaration that we may need to merge. Look it up3499    // in its context by number.3500    if (auto *Existing = getAnonymousDeclForMerging(3501            Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))3502      if (C.isSameEntity(Existing, D))3503        return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,3504                                  TypedefNameForLinkage);3505  } else if (DC->isTranslationUnit() &&3506             !Reader.getContext().getLangOpts().CPlusPlus) {3507    IdentifierResolver &IdResolver = Reader.getIdResolver();3508 3509    // Temporarily consider the identifier to be up-to-date. We don't want to3510    // cause additional lookups here.3511    class UpToDateIdentifierRAII {3512      IdentifierInfo *II;3513      bool WasOutToDate = false;3514 3515    public:3516      explicit UpToDateIdentifierRAII(IdentifierInfo *II) : II(II) {3517        if (II) {3518          WasOutToDate = II->isOutOfDate();3519          if (WasOutToDate)3520            II->setOutOfDate(false);3521        }3522      }3523 3524      ~UpToDateIdentifierRAII() {3525        if (WasOutToDate)3526          II->setOutOfDate(true);3527      }3528    } UpToDate(Name.getAsIdentifierInfo());3529 3530    for (IdentifierResolver::iterator I = IdResolver.begin(Name),3531                                   IEnd = IdResolver.end();3532         I != IEnd; ++I) {3533      if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))3534        if (C.isSameEntity(Existing, D))3535          return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,3536                                    TypedefNameForLinkage);3537    }3538  } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {3539    DeclContext::lookup_result R = MergeDC->noload_lookup(Name);3540    for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {3541      if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))3542        if (C.isSameEntity(Existing, D))3543          return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,3544                                    TypedefNameForLinkage);3545    }3546  } else {3547    // Not in a mergeable context.3548    return FindExistingResult(Reader);3549  }3550 3551  // If this declaration is from a merged context, make a note that we need to3552  // check that the canonical definition of that context contains the decl.3553  //3554  // Note that we don't perform ODR checks for decls from the global module3555  // fragment.3556  //3557  // FIXME: We should do something similar if we merge two definitions of the3558  // same template specialization into the same CXXRecordDecl.3559  auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());3560  if (MergedDCIt != Reader.MergedDeclContexts.end() &&3561      !shouldSkipCheckingODR(D) && MergedDCIt->second == D->getDeclContext() &&3562      !shouldSkipCheckingODR(cast<Decl>(D->getDeclContext())))3563    Reader.PendingOdrMergeChecks.push_back(D);3564 3565  return FindExistingResult(Reader, D, /*Existing=*/nullptr,3566                            AnonymousDeclNumber, TypedefNameForLinkage);3567}3568 3569template<typename DeclT>3570Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {3571  return D->RedeclLink.getLatestNotUpdated();3572}3573 3574Decl *ASTDeclReader::getMostRecentDeclImpl(...) {3575  llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");3576}3577 3578Decl *ASTDeclReader::getMostRecentDecl(Decl *D) {3579  assert(D);3580 3581  switch (D->getKind()) {3582#define ABSTRACT_DECL(TYPE)3583#define DECL(TYPE, BASE)                               \3584  case Decl::TYPE:                                     \3585    return getMostRecentDeclImpl(cast<TYPE##Decl>(D));3586#include "clang/AST/DeclNodes.inc"3587  }3588  llvm_unreachable("unknown decl kind");3589}3590 3591Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {3592  return ASTDeclReader::getMostRecentDecl(D->getCanonicalDecl());3593}3594 3595namespace {3596void mergeInheritableAttributes(ASTReader &Reader, Decl *D, Decl *Previous) {3597  InheritableAttr *NewAttr = nullptr;3598  ASTContext &Context = Reader.getContext();3599  const auto *IA = Previous->getAttr<MSInheritanceAttr>();3600 3601  if (IA && !D->hasAttr<MSInheritanceAttr>()) {3602    NewAttr = cast<InheritableAttr>(IA->clone(Context));3603    NewAttr->setInherited(true);3604    D->addAttr(NewAttr);3605  }3606 3607  const auto *AA = Previous->getAttr<AvailabilityAttr>();3608  if (AA && !D->hasAttr<AvailabilityAttr>()) {3609    NewAttr = AA->clone(Context);3610    NewAttr->setInherited(true);3611    D->addAttr(NewAttr);3612  }3613}3614} // namespace3615 3616template<typename DeclT>3617void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,3618                                           Redeclarable<DeclT> *D,3619                                           Decl *Previous, Decl *Canon) {3620  D->RedeclLink.setPrevious(cast<DeclT>(Previous));3621  D->First = cast<DeclT>(Previous)->First;3622}3623 3624namespace clang {3625 3626template<>3627void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,3628                                           Redeclarable<VarDecl> *D,3629                                           Decl *Previous, Decl *Canon) {3630  auto *VD = static_cast<VarDecl *>(D);3631  auto *PrevVD = cast<VarDecl>(Previous);3632  D->RedeclLink.setPrevious(PrevVD);3633  D->First = PrevVD->First;3634 3635  // We should keep at most one definition on the chain.3636  // FIXME: Cache the definition once we've found it. Building a chain with3637  // N definitions currently takes O(N^2) time here.3638  if (VD->isThisDeclarationADefinition() == VarDecl::Definition) {3639    for (VarDecl *CurD = PrevVD; CurD; CurD = CurD->getPreviousDecl()) {3640      if (CurD->isThisDeclarationADefinition() == VarDecl::Definition) {3641        Reader.mergeDefinitionVisibility(CurD, VD);3642        VD->demoteThisDefinitionToDeclaration();3643        break;3644      }3645    }3646  }3647}3648 3649static bool isUndeducedReturnType(QualType T) {3650  auto *DT = T->getContainedDeducedType();3651  return DT && !DT->isDeduced();3652}3653 3654template<>3655void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,3656                                           Redeclarable<FunctionDecl> *D,3657                                           Decl *Previous, Decl *Canon) {3658  auto *FD = static_cast<FunctionDecl *>(D);3659  auto *PrevFD = cast<FunctionDecl>(Previous);3660 3661  FD->RedeclLink.setPrevious(PrevFD);3662  FD->First = PrevFD->First;3663 3664  // If the previous declaration is an inline function declaration, then this3665  // declaration is too.3666  if (PrevFD->isInlined() != FD->isInlined()) {3667    // FIXME: [dcl.fct.spec]p4:3668    //   If a function with external linkage is declared inline in one3669    //   translation unit, it shall be declared inline in all translation3670    //   units in which it appears.3671    //3672    // Be careful of this case:3673    //3674    // module A:3675    //   template<typename T> struct X { void f(); };3676    //   template<typename T> inline void X<T>::f() {}3677    //3678    // module B instantiates the declaration of X<int>::f3679    // module C instantiates the definition of X<int>::f3680    //3681    // If module B and C are merged, we do not have a violation of this rule.3682    FD->setImplicitlyInline(true);3683  }3684 3685  auto *FPT = FD->getType()->getAs<FunctionProtoType>();3686  auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();3687  if (FPT && PrevFPT) {3688    // If we need to propagate an exception specification along the redecl3689    // chain, make a note of that so that we can do so later.3690    bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());3691    bool WasUnresolved =3692        isUnresolvedExceptionSpec(PrevFPT->getExceptionSpecType());3693    if (IsUnresolved != WasUnresolved)3694      Reader.PendingExceptionSpecUpdates.insert(3695          {Canon, IsUnresolved ? PrevFD : FD});3696 3697    // If we need to propagate a deduced return type along the redecl chain,3698    // make a note of that so that we can do it later.3699    bool IsUndeduced = isUndeducedReturnType(FPT->getReturnType());3700    bool WasUndeduced = isUndeducedReturnType(PrevFPT->getReturnType());3701    if (IsUndeduced != WasUndeduced)3702      Reader.PendingDeducedTypeUpdates.insert(3703          {cast<FunctionDecl>(Canon),3704           (IsUndeduced ? PrevFPT : FPT)->getReturnType()});3705  }3706}3707 3708} // namespace clang3709 3710void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {3711  llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");3712}3713 3714/// Inherit the default template argument from \p From to \p To. Returns3715/// \c false if there is no default template for \p From.3716template <typename ParmDecl>3717static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From,3718                                           Decl *ToD) {3719  auto *To = cast<ParmDecl>(ToD);3720  if (!From->hasDefaultArgument())3721    return false;3722  To->setInheritedDefaultArgument(Context, From);3723  return true;3724}3725 3726static void inheritDefaultTemplateArguments(ASTContext &Context,3727                                            TemplateDecl *From,3728                                            TemplateDecl *To) {3729  auto *FromTP = From->getTemplateParameters();3730  auto *ToTP = To->getTemplateParameters();3731  assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");3732 3733  for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {3734    NamedDecl *FromParam = FromTP->getParam(I);3735    NamedDecl *ToParam = ToTP->getParam(I);3736 3737    if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam))3738      inheritDefaultTemplateArgument(Context, FTTP, ToParam);3739    else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam))3740      inheritDefaultTemplateArgument(Context, FNTTP, ToParam);3741    else3742      inheritDefaultTemplateArgument(3743              Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam);3744  }3745}3746 3747// [basic.link]/p10:3748//    If two declarations of an entity are attached to different modules,3749//    the program is ill-formed;3750void ASTDeclReader::checkMultipleDefinitionInNamedModules(ASTReader &Reader,3751                                                          Decl *D,3752                                                          Decl *Previous) {3753  // If it is previous implcitly introduced, it is not meaningful to3754  // diagnose it.3755  if (Previous->isImplicit())3756    return;3757 3758  // FIXME: Get rid of the enumeration of decl types once we have an appropriate3759  // abstract for decls of an entity. e.g., the namespace decl and using decl3760  // doesn't introduce an entity.3761  if (!isa<VarDecl, FunctionDecl, TagDecl, RedeclarableTemplateDecl>(Previous))3762    return;3763 3764  // Skip implicit instantiations since it may give false positive diagnostic3765  // messages.3766  // FIXME: Maybe this shows the implicit instantiations may have incorrect3767  // module owner ships. But given we've finished the compilation of a module,3768  // how can we add new entities to that module?3769  if (isa<VarTemplateSpecializationDecl>(Previous))3770    return;3771  if (isa<ClassTemplateSpecializationDecl>(Previous))3772    return;3773  if (auto *Func = dyn_cast<FunctionDecl>(Previous);3774      Func && Func->getTemplateSpecializationInfo())3775    return;3776 3777  // The module ownership of in-class friend declaration is not straightforward.3778  // Avoid diagnosing such cases.3779  if (D->getFriendObjectKind() || Previous->getFriendObjectKind())3780    return;3781 3782  // Skip diagnosing in-class declarations.3783  if (!Previous->getLexicalDeclContext()3784           ->getNonTransparentContext()3785           ->isFileContext() ||3786      !D->getLexicalDeclContext()->getNonTransparentContext()->isFileContext())3787    return;3788 3789  Module *M = Previous->getOwningModule();3790  if (!M)3791    return;3792 3793  // We only forbids merging decls within named modules.3794  if (!M->isNamedModule()) {3795    // Try to warn the case that we merged decls from global module.3796    if (!M->isGlobalModule())3797      return;3798 3799    if (D->getOwningModule() &&3800        M->getTopLevelModule() == D->getOwningModule()->getTopLevelModule())3801      return;3802 3803    Reader.PendingWarningForDuplicatedDefsInModuleUnits.push_back(3804        {D, Previous});3805    return;3806  }3807 3808  // It is fine if they are in the same module.3809  if (Reader.getContext().isInSameModule(M, D->getOwningModule()))3810    return;3811 3812  Reader.Diag(Previous->getLocation(),3813              diag::err_multiple_decl_in_different_modules)3814      << cast<NamedDecl>(Previous) << M->Name;3815  Reader.Diag(D->getLocation(), diag::note_also_found);3816}3817 3818void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,3819                                       Decl *Previous, Decl *Canon) {3820  assert(D && Previous);3821 3822  switch (D->getKind()) {3823#define ABSTRACT_DECL(TYPE)3824#define DECL(TYPE, BASE)                                                  \3825  case Decl::TYPE:                                                        \3826    attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \3827    break;3828#include "clang/AST/DeclNodes.inc"3829  }3830 3831  checkMultipleDefinitionInNamedModules(Reader, D, Previous);3832 3833  // If the declaration was visible in one module, a redeclaration of it in3834  // another module remains visible even if it wouldn't be visible by itself.3835  //3836  // FIXME: In this case, the declaration should only be visible if a module3837  //        that makes it visible has been imported.3838  D->IdentifierNamespace |=3839      Previous->IdentifierNamespace &3840      (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);3841 3842  // If the declaration declares a template, it may inherit default arguments3843  // from the previous declaration.3844  if (auto *TD = dyn_cast<TemplateDecl>(D))3845    inheritDefaultTemplateArguments(Reader.getContext(),3846                                    cast<TemplateDecl>(Previous), TD);3847 3848  // If any of the declaration in the chain contains an Inheritable attribute,3849  // it needs to be added to all the declarations in the redeclarable chain.3850  // FIXME: Only the logic of merging MSInheritableAttr is present, it should3851  // be extended for all inheritable attributes.3852  mergeInheritableAttributes(Reader, D, Previous);3853}3854 3855template<typename DeclT>3856void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {3857  D->RedeclLink.setLatest(cast<DeclT>(Latest));3858}3859 3860void ASTDeclReader::attachLatestDeclImpl(...) {3861  llvm_unreachable("attachLatestDecl on non-redeclarable declaration");3862}3863 3864void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {3865  assert(D && Latest);3866 3867  switch (D->getKind()) {3868#define ABSTRACT_DECL(TYPE)3869#define DECL(TYPE, BASE)                                  \3870  case Decl::TYPE:                                        \3871    attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \3872    break;3873#include "clang/AST/DeclNodes.inc"3874  }3875}3876 3877template<typename DeclT>3878void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {3879  D->RedeclLink.markIncomplete();3880}3881 3882void ASTDeclReader::markIncompleteDeclChainImpl(...) {3883  llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");3884}3885 3886void ASTReader::markIncompleteDeclChain(Decl *D) {3887  switch (D->getKind()) {3888#define ABSTRACT_DECL(TYPE)3889#define DECL(TYPE, BASE)                                             \3890  case Decl::TYPE:                                                   \3891    ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \3892    break;3893#include "clang/AST/DeclNodes.inc"3894  }3895}3896 3897/// Read the declaration at the given offset from the AST file.3898Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {3899  SourceLocation DeclLoc;3900  RecordLocation Loc = DeclCursorForID(ID, DeclLoc);3901  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;3902  // Keep track of where we are in the stream, then jump back there3903  // after reading this declaration.3904  SavedStreamPosition SavedPosition(DeclsCursor);3905 3906  ReadingKindTracker ReadingKind(Read_Decl, *this);3907 3908  // Note that we are loading a declaration record.3909  Deserializing ADecl(this);3910 3911  auto Fail = [](const char *what, llvm::Error &&Err) {3912    llvm::report_fatal_error(Twine("ASTReader::readDeclRecord failed ") + what +3913                             ": " + toString(std::move(Err)));3914  };3915 3916  if (llvm::Error JumpFailed = DeclsCursor.JumpToBit(Loc.Offset))3917    Fail("jumping", std::move(JumpFailed));3918  ASTRecordReader Record(*this, *Loc.F);3919  ASTDeclReader Reader(*this, Record, Loc, ID, DeclLoc);3920  Expected<unsigned> MaybeCode = DeclsCursor.ReadCode();3921  if (!MaybeCode)3922    Fail("reading code", MaybeCode.takeError());3923  unsigned Code = MaybeCode.get();3924 3925  ASTContext &Context = getContext();3926  Decl *D = nullptr;3927  Expected<unsigned> MaybeDeclCode = Record.readRecord(DeclsCursor, Code);3928  if (!MaybeDeclCode)3929    llvm::report_fatal_error(3930        Twine("ASTReader::readDeclRecord failed reading decl code: ") +3931        toString(MaybeDeclCode.takeError()));3932 3933  switch ((DeclCode)MaybeDeclCode.get()) {3934  case DECL_CONTEXT_LEXICAL:3935  case DECL_CONTEXT_VISIBLE:3936  case DECL_CONTEXT_MODULE_LOCAL_VISIBLE:3937  case DECL_CONTEXT_TU_LOCAL_VISIBLE:3938  case DECL_SPECIALIZATIONS:3939  case DECL_PARTIAL_SPECIALIZATIONS:3940    llvm_unreachable("Record cannot be de-serialized with readDeclRecord");3941  case DECL_TYPEDEF:3942    D = TypedefDecl::CreateDeserialized(Context, ID);3943    break;3944  case DECL_TYPEALIAS:3945    D = TypeAliasDecl::CreateDeserialized(Context, ID);3946    break;3947  case DECL_ENUM:3948    D = EnumDecl::CreateDeserialized(Context, ID);3949    break;3950  case DECL_RECORD:3951    D = RecordDecl::CreateDeserialized(Context, ID);3952    break;3953  case DECL_ENUM_CONSTANT:3954    D = EnumConstantDecl::CreateDeserialized(Context, ID);3955    break;3956  case DECL_FUNCTION:3957    D = FunctionDecl::CreateDeserialized(Context, ID);3958    break;3959  case DECL_LINKAGE_SPEC:3960    D = LinkageSpecDecl::CreateDeserialized(Context, ID);3961    break;3962  case DECL_EXPORT:3963    D = ExportDecl::CreateDeserialized(Context, ID);3964    break;3965  case DECL_LABEL:3966    D = LabelDecl::CreateDeserialized(Context, ID);3967    break;3968  case DECL_NAMESPACE:3969    D = NamespaceDecl::CreateDeserialized(Context, ID);3970    break;3971  case DECL_NAMESPACE_ALIAS:3972    D = NamespaceAliasDecl::CreateDeserialized(Context, ID);3973    break;3974  case DECL_USING:3975    D = UsingDecl::CreateDeserialized(Context, ID);3976    break;3977  case DECL_USING_PACK:3978    D = UsingPackDecl::CreateDeserialized(Context, ID, Record.readInt());3979    break;3980  case DECL_USING_SHADOW:3981    D = UsingShadowDecl::CreateDeserialized(Context, ID);3982    break;3983  case DECL_USING_ENUM:3984    D = UsingEnumDecl::CreateDeserialized(Context, ID);3985    break;3986  case DECL_CONSTRUCTOR_USING_SHADOW:3987    D = ConstructorUsingShadowDecl::CreateDeserialized(Context, ID);3988    break;3989  case DECL_USING_DIRECTIVE:3990    D = UsingDirectiveDecl::CreateDeserialized(Context, ID);3991    break;3992  case DECL_UNRESOLVED_USING_VALUE:3993    D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);3994    break;3995  case DECL_UNRESOLVED_USING_TYPENAME:3996    D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);3997    break;3998  case DECL_UNRESOLVED_USING_IF_EXISTS:3999    D = UnresolvedUsingIfExistsDecl::CreateDeserialized(Context, ID);4000    break;4001  case DECL_CXX_RECORD:4002    D = CXXRecordDecl::CreateDeserialized(Context, ID);4003    break;4004  case DECL_CXX_DEDUCTION_GUIDE:4005    D = CXXDeductionGuideDecl::CreateDeserialized(Context, ID);4006    break;4007  case DECL_CXX_METHOD:4008    D = CXXMethodDecl::CreateDeserialized(Context, ID);4009    break;4010  case DECL_CXX_CONSTRUCTOR:4011    D = CXXConstructorDecl::CreateDeserialized(Context, ID, Record.readInt());4012    break;4013  case DECL_CXX_DESTRUCTOR:4014    D = CXXDestructorDecl::CreateDeserialized(Context, ID);4015    break;4016  case DECL_CXX_CONVERSION:4017    D = CXXConversionDecl::CreateDeserialized(Context, ID);4018    break;4019  case DECL_ACCESS_SPEC:4020    D = AccessSpecDecl::CreateDeserialized(Context, ID);4021    break;4022  case DECL_FRIEND:4023    D = FriendDecl::CreateDeserialized(Context, ID, Record.readInt());4024    break;4025  case DECL_FRIEND_TEMPLATE:4026    D = FriendTemplateDecl::CreateDeserialized(Context, ID);4027    break;4028  case DECL_CLASS_TEMPLATE:4029    D = ClassTemplateDecl::CreateDeserialized(Context, ID);4030    break;4031  case DECL_CLASS_TEMPLATE_SPECIALIZATION:4032    D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);4033    break;4034  case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:4035    D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);4036    break;4037  case DECL_VAR_TEMPLATE:4038    D = VarTemplateDecl::CreateDeserialized(Context, ID);4039    break;4040  case DECL_VAR_TEMPLATE_SPECIALIZATION:4041    D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);4042    break;4043  case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:4044    D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);4045    break;4046  case DECL_FUNCTION_TEMPLATE:4047    D = FunctionTemplateDecl::CreateDeserialized(Context, ID);4048    break;4049  case DECL_TEMPLATE_TYPE_PARM: {4050    bool HasTypeConstraint = Record.readInt();4051    D = TemplateTypeParmDecl::CreateDeserialized(Context, ID,4052                                                 HasTypeConstraint);4053    break;4054  }4055  case DECL_NON_TYPE_TEMPLATE_PARM: {4056    bool HasTypeConstraint = Record.readInt();4057    D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID,4058                                                    HasTypeConstraint);4059    break;4060  }4061  case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK: {4062    bool HasTypeConstraint = Record.readInt();4063    D = NonTypeTemplateParmDecl::CreateDeserialized(4064        Context, ID, Record.readInt(), HasTypeConstraint);4065    break;4066  }4067  case DECL_TEMPLATE_TEMPLATE_PARM:4068    D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);4069    break;4070  case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:4071    D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,4072                                                     Record.readInt());4073    break;4074  case DECL_TYPE_ALIAS_TEMPLATE:4075    D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);4076    break;4077  case DECL_CONCEPT:4078    D = ConceptDecl::CreateDeserialized(Context, ID);4079    break;4080  case DECL_REQUIRES_EXPR_BODY:4081    D = RequiresExprBodyDecl::CreateDeserialized(Context, ID);4082    break;4083  case DECL_STATIC_ASSERT:4084    D = StaticAssertDecl::CreateDeserialized(Context, ID);4085    break;4086  case DECL_OBJC_METHOD:4087    D = ObjCMethodDecl::CreateDeserialized(Context, ID);4088    break;4089  case DECL_OBJC_INTERFACE:4090    D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);4091    break;4092  case DECL_OBJC_IVAR:4093    D = ObjCIvarDecl::CreateDeserialized(Context, ID);4094    break;4095  case DECL_OBJC_PROTOCOL:4096    D = ObjCProtocolDecl::CreateDeserialized(Context, ID);4097    break;4098  case DECL_OBJC_AT_DEFS_FIELD:4099    D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);4100    break;4101  case DECL_OBJC_CATEGORY:4102    D = ObjCCategoryDecl::CreateDeserialized(Context, ID);4103    break;4104  case DECL_OBJC_CATEGORY_IMPL:4105    D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);4106    break;4107  case DECL_OBJC_IMPLEMENTATION:4108    D = ObjCImplementationDecl::CreateDeserialized(Context, ID);4109    break;4110  case DECL_OBJC_COMPATIBLE_ALIAS:4111    D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);4112    break;4113  case DECL_OBJC_PROPERTY:4114    D = ObjCPropertyDecl::CreateDeserialized(Context, ID);4115    break;4116  case DECL_OBJC_PROPERTY_IMPL:4117    D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);4118    break;4119  case DECL_FIELD:4120    D = FieldDecl::CreateDeserialized(Context, ID);4121    break;4122  case DECL_INDIRECTFIELD:4123    D = IndirectFieldDecl::CreateDeserialized(Context, ID);4124    break;4125  case DECL_VAR:4126    D = VarDecl::CreateDeserialized(Context, ID);4127    break;4128  case DECL_IMPLICIT_PARAM:4129    D = ImplicitParamDecl::CreateDeserialized(Context, ID);4130    break;4131  case DECL_PARM_VAR:4132    D = ParmVarDecl::CreateDeserialized(Context, ID);4133    break;4134  case DECL_DECOMPOSITION:4135    D = DecompositionDecl::CreateDeserialized(Context, ID, Record.readInt());4136    break;4137  case DECL_BINDING:4138    D = BindingDecl::CreateDeserialized(Context, ID);4139    break;4140  case DECL_FILE_SCOPE_ASM:4141    D = FileScopeAsmDecl::CreateDeserialized(Context, ID);4142    break;4143  case DECL_TOP_LEVEL_STMT_DECL:4144    D = TopLevelStmtDecl::CreateDeserialized(Context, ID);4145    break;4146  case DECL_BLOCK:4147    D = BlockDecl::CreateDeserialized(Context, ID);4148    break;4149  case DECL_MS_PROPERTY:4150    D = MSPropertyDecl::CreateDeserialized(Context, ID);4151    break;4152  case DECL_MS_GUID:4153    D = MSGuidDecl::CreateDeserialized(Context, ID);4154    break;4155  case DECL_UNNAMED_GLOBAL_CONSTANT:4156    D = UnnamedGlobalConstantDecl::CreateDeserialized(Context, ID);4157    break;4158  case DECL_TEMPLATE_PARAM_OBJECT:4159    D = TemplateParamObjectDecl::CreateDeserialized(Context, ID);4160    break;4161  case DECL_OUTLINEDFUNCTION:4162    D = OutlinedFunctionDecl::CreateDeserialized(Context, ID, Record.readInt());4163    break;4164  case DECL_CAPTURED:4165    D = CapturedDecl::CreateDeserialized(Context, ID, Record.readInt());4166    break;4167  case DECL_CXX_BASE_SPECIFIERS:4168    Error("attempt to read a C++ base-specifier record as a declaration");4169    return nullptr;4170  case DECL_CXX_CTOR_INITIALIZERS:4171    Error("attempt to read a C++ ctor initializer record as a declaration");4172    return nullptr;4173  case DECL_IMPORT:4174    // Note: last entry of the ImportDecl record is the number of stored source4175    // locations.4176    D = ImportDecl::CreateDeserialized(Context, ID, Record.back());4177    break;4178  case DECL_OMP_THREADPRIVATE: {4179    Record.skipInts(1);4180    unsigned NumChildren = Record.readInt();4181    Record.skipInts(1);4182    D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, NumChildren);4183    break;4184  }4185  case DECL_OMP_ALLOCATE: {4186    unsigned NumClauses = Record.readInt();4187    unsigned NumVars = Record.readInt();4188    Record.skipInts(1);4189    D = OMPAllocateDecl::CreateDeserialized(Context, ID, NumVars, NumClauses);4190    break;4191  }4192  case DECL_OMP_REQUIRES: {4193    unsigned NumClauses = Record.readInt();4194    Record.skipInts(2);4195    D = OMPRequiresDecl::CreateDeserialized(Context, ID, NumClauses);4196    break;4197  }4198  case DECL_OMP_DECLARE_REDUCTION:4199    D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);4200    break;4201  case DECL_OMP_DECLARE_MAPPER: {4202    unsigned NumClauses = Record.readInt();4203    Record.skipInts(2);4204    D = OMPDeclareMapperDecl::CreateDeserialized(Context, ID, NumClauses);4205    break;4206  }4207  case DECL_OMP_CAPTUREDEXPR:4208    D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);4209    break;4210  case DECL_PRAGMA_COMMENT:4211    D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record.readInt());4212    break;4213  case DECL_PRAGMA_DETECT_MISMATCH:4214    D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,4215                                                     Record.readInt());4216    break;4217  case DECL_EMPTY:4218    D = EmptyDecl::CreateDeserialized(Context, ID);4219    break;4220  case DECL_LIFETIME_EXTENDED_TEMPORARY:4221    D = LifetimeExtendedTemporaryDecl::CreateDeserialized(Context, ID);4222    break;4223  case DECL_OBJC_TYPE_PARAM:4224    D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);4225    break;4226  case DECL_HLSL_BUFFER:4227    D = HLSLBufferDecl::CreateDeserialized(Context, ID);4228    break;4229  case DECL_IMPLICIT_CONCEPT_SPECIALIZATION:4230    D = ImplicitConceptSpecializationDecl::CreateDeserialized(Context, ID,4231                                                              Record.readInt());4232    break;4233  case DECL_OPENACC_DECLARE:4234    D = OpenACCDeclareDecl::CreateDeserialized(Context, ID, Record.readInt());4235    break;4236  case DECL_OPENACC_ROUTINE:4237    D = OpenACCRoutineDecl::CreateDeserialized(Context, ID, Record.readInt());4238    break;4239  }4240 4241  assert(D && "Unknown declaration reading AST file");4242  LoadedDecl(translateGlobalDeclIDToIndex(ID), D);4243  // Set the DeclContext before doing any deserialization, to make sure internal4244  // calls to Decl::getASTContext() by Decl's methods will find the4245  // TranslationUnitDecl without crashing.4246  D->setDeclContext(Context.getTranslationUnitDecl());4247 4248  // Reading some declarations can result in deep recursion.4249  runWithSufficientStackSpace(DeclLoc, [&] { Reader.Visit(D); });4250 4251  // If this declaration is also a declaration context, get the4252  // offsets for its tables of lexical and visible declarations.4253  if (auto *DC = dyn_cast<DeclContext>(D)) {4254    LookupBlockOffsets Offsets;4255 4256    Reader.VisitDeclContext(DC, Offsets);4257 4258    // Get the lexical and visible block for the delayed namespace.4259    // It is sufficient to judge if ID is in DelayedNamespaceOffsetMap.4260    // But it may be more efficient to filter the other cases.4261    if (!Offsets && isa<NamespaceDecl>(D))4262      if (auto Iter = DelayedNamespaceOffsetMap.find(ID);4263          Iter != DelayedNamespaceOffsetMap.end())4264        Offsets = Iter->second;4265 4266    if (Offsets.VisibleOffset &&4267        ReadVisibleDeclContextStorage(4268            *Loc.F, DeclsCursor, Offsets.VisibleOffset, ID,4269            VisibleDeclContextStorageKind::GenerallyVisible))4270      return nullptr;4271    if (Offsets.ModuleLocalOffset &&4272        ReadVisibleDeclContextStorage(4273            *Loc.F, DeclsCursor, Offsets.ModuleLocalOffset, ID,4274            VisibleDeclContextStorageKind::ModuleLocalVisible))4275      return nullptr;4276    if (Offsets.TULocalOffset &&4277        ReadVisibleDeclContextStorage(4278            *Loc.F, DeclsCursor, Offsets.TULocalOffset, ID,4279            VisibleDeclContextStorageKind::TULocalVisible))4280      return nullptr;4281 4282    if (Offsets.LexicalOffset &&4283        ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor,4284                                      Offsets.LexicalOffset, DC))4285      return nullptr;4286  }4287  assert(Record.getIdx() == Record.size());4288 4289  // Load any relevant update records.4290  PendingUpdateRecords.push_back(4291      PendingUpdateRecord(ID, D, /*JustLoaded=*/true));4292 4293  // Load the categories after recursive loading is finished.4294  if (auto *Class = dyn_cast<ObjCInterfaceDecl>(D))4295    // If we already have a definition when deserializing the ObjCInterfaceDecl,4296    // we put the Decl in PendingDefinitions so we can pull the categories here.4297    if (Class->isThisDeclarationADefinition() ||4298        PendingDefinitions.count(Class))4299      loadObjCCategories(ID, Class);4300 4301  // If we have deserialized a declaration that has a definition the4302  // AST consumer might need to know about, queue it.4303  // We don't pass it to the consumer immediately because we may be in recursive4304  // loading, and some declarations may still be initializing.4305  PotentiallyInterestingDecls.push_back(D);4306 4307  return D;4308}4309 4310void ASTReader::PassInterestingDeclsToConsumer() {4311  assert(Consumer);4312 4313  if (!CanPassDeclsToConsumer)4314    return;4315 4316  // Guard variable to avoid recursively redoing the process of passing4317  // decls to consumer.4318  SaveAndRestore GuardPassingDeclsToConsumer(CanPassDeclsToConsumer,4319                                             /*NewValue=*/false);4320 4321  // Ensure that we've loaded all potentially-interesting declarations4322  // that need to be eagerly loaded.4323  for (auto ID : EagerlyDeserializedDecls)4324    GetDecl(ID);4325  EagerlyDeserializedDecls.clear();4326 4327  auto ConsumingPotentialInterestingDecls = [this]() {4328    while (!PotentiallyInterestingDecls.empty()) {4329      Decl *D = PotentiallyInterestingDecls.front();4330      PotentiallyInterestingDecls.pop_front();4331      if (isConsumerInterestedIn(D))4332        PassInterestingDeclToConsumer(D);4333    }4334  };4335  std::deque<Decl *> MaybeInterestingDecls =4336      std::move(PotentiallyInterestingDecls);4337  PotentiallyInterestingDecls.clear();4338  assert(PotentiallyInterestingDecls.empty());4339  while (!MaybeInterestingDecls.empty()) {4340    Decl *D = MaybeInterestingDecls.front();4341    MaybeInterestingDecls.pop_front();4342    // Since we load the variable's initializers lazily, it'd be problematic4343    // if the initializers dependent on each other. So here we try to load the4344    // initializers of static variables to make sure they are passed to code4345    // generator by order. If we read anything interesting, we would consume4346    // that before emitting the current declaration.4347    if (auto *VD = dyn_cast<VarDecl>(D);4348        VD && VD->isFileVarDecl() && !VD->isExternallyVisible())4349      VD->getInit();4350    ConsumingPotentialInterestingDecls();4351    if (isConsumerInterestedIn(D))4352      PassInterestingDeclToConsumer(D);4353  }4354 4355  // If we add any new potential interesting decl in the last call, consume it.4356  ConsumingPotentialInterestingDecls();4357 4358  for (GlobalDeclID ID : VTablesToEmit) {4359    auto *RD = cast<CXXRecordDecl>(GetDecl(ID));4360    assert(!RD->shouldEmitInExternalSource());4361    PassVTableToConsumer(RD);4362  }4363  VTablesToEmit.clear();4364}4365 4366void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) {4367  // The declaration may have been modified by files later in the chain.4368  // If this is the case, read the record containing the updates from each file4369  // and pass it to ASTDeclReader to make the modifications.4370  GlobalDeclID ID = Record.ID;4371  Decl *D = Record.D;4372  ProcessingUpdatesRAIIObj ProcessingUpdates(*this);4373  DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);4374 4375  if (UpdI != DeclUpdateOffsets.end()) {4376    auto UpdateOffsets = std::move(UpdI->second);4377    DeclUpdateOffsets.erase(UpdI);4378 4379    // Check if this decl was interesting to the consumer. If we just loaded4380    // the declaration, then we know it was interesting and we skip the call4381    // to isConsumerInterestedIn because it is unsafe to call in the4382    // current ASTReader state.4383    bool WasInteresting = Record.JustLoaded || isConsumerInterestedIn(D);4384    for (auto &FileAndOffset : UpdateOffsets) {4385      ModuleFile *F = FileAndOffset.first;4386      uint64_t Offset = FileAndOffset.second;4387      llvm::BitstreamCursor &Cursor = F->DeclsCursor;4388      SavedStreamPosition SavedPosition(Cursor);4389      if (llvm::Error JumpFailed = Cursor.JumpToBit(Offset))4390        // FIXME don't do a fatal error.4391        llvm::report_fatal_error(4392            Twine("ASTReader::loadDeclUpdateRecords failed jumping: ") +4393            toString(std::move(JumpFailed)));4394      Expected<unsigned> MaybeCode = Cursor.ReadCode();4395      if (!MaybeCode)4396        llvm::report_fatal_error(4397            Twine("ASTReader::loadDeclUpdateRecords failed reading code: ") +4398            toString(MaybeCode.takeError()));4399      unsigned Code = MaybeCode.get();4400      ASTRecordReader Record(*this, *F);4401      if (Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code))4402        assert(MaybeRecCode.get() == DECL_UPDATES &&4403               "Expected DECL_UPDATES record!");4404      else4405        llvm::report_fatal_error(4406            Twine("ASTReader::loadDeclUpdateRecords failed reading rec code: ") +4407            toString(MaybeCode.takeError()));4408 4409      ASTDeclReader Reader(*this, Record, RecordLocation(F, Offset), ID,4410                           SourceLocation());4411      Reader.UpdateDecl(D);4412 4413      // We might have made this declaration interesting. If so, remember that4414      // we need to hand it off to the consumer.4415      if (!WasInteresting && isConsumerInterestedIn(D)) {4416        PotentiallyInterestingDecls.push_back(D);4417        WasInteresting = true;4418      }4419    }4420  }4421 4422  // Load the pending visible updates for this decl context, if it has any.4423  if (auto I = PendingVisibleUpdates.find(ID);4424      I != PendingVisibleUpdates.end()) {4425    auto VisibleUpdates = std::move(I->second);4426    PendingVisibleUpdates.erase(I);4427 4428    auto *DC = cast<DeclContext>(D)->getPrimaryContext();4429    for (const auto &Update : VisibleUpdates)4430      Lookups[DC].Table.add(4431          Update.Mod, Update.Data,4432          reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));4433    DC->setHasExternalVisibleStorage(true);4434  }4435 4436  if (auto I = PendingModuleLocalVisibleUpdates.find(ID);4437      I != PendingModuleLocalVisibleUpdates.end()) {4438    auto ModuleLocalVisibleUpdates = std::move(I->second);4439    PendingModuleLocalVisibleUpdates.erase(I);4440 4441    auto *DC = cast<DeclContext>(D)->getPrimaryContext();4442    for (const auto &Update : ModuleLocalVisibleUpdates)4443      ModuleLocalLookups[DC].Table.add(4444          Update.Mod, Update.Data,4445          reader::ModuleLocalNameLookupTrait(*this, *Update.Mod));4446    // NOTE: Can we optimize the case that the data being loaded4447    // is not related to current module?4448    DC->setHasExternalVisibleStorage(true);4449  }4450 4451  if (auto I = TULocalUpdates.find(ID); I != TULocalUpdates.end()) {4452    auto Updates = std::move(I->second);4453    TULocalUpdates.erase(I);4454 4455    auto *DC = cast<DeclContext>(D)->getPrimaryContext();4456    for (const auto &Update : Updates)4457      TULocalLookups[DC].Table.add(4458          Update.Mod, Update.Data,4459          reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));4460    DC->setHasExternalVisibleStorage(true);4461  }4462 4463  // Load any pending related decls.4464  if (D->isCanonicalDecl()) {4465    if (auto IT = RelatedDeclsMap.find(ID); IT != RelatedDeclsMap.end()) {4466      for (auto LID : IT->second)4467        GetDecl(LID);4468      RelatedDeclsMap.erase(IT);4469    }4470  }4471 4472  // Load the pending specializations update for this decl, if it has any.4473  if (auto I = PendingSpecializationsUpdates.find(ID);4474      I != PendingSpecializationsUpdates.end()) {4475    auto SpecializationUpdates = std::move(I->second);4476    PendingSpecializationsUpdates.erase(I);4477 4478    for (const auto &Update : SpecializationUpdates)4479      AddSpecializations(D, Update.Data, *Update.Mod, /*IsPartial=*/false);4480  }4481 4482  // Load the pending specializations update for this decl, if it has any.4483  if (auto I = PendingPartialSpecializationsUpdates.find(ID);4484      I != PendingPartialSpecializationsUpdates.end()) {4485    auto SpecializationUpdates = std::move(I->second);4486    PendingPartialSpecializationsUpdates.erase(I);4487 4488    for (const auto &Update : SpecializationUpdates)4489      AddSpecializations(D, Update.Data, *Update.Mod, /*IsPartial=*/true);4490  }4491}4492 4493void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {4494  // Attach FirstLocal to the end of the decl chain.4495  Decl *CanonDecl = FirstLocal->getCanonicalDecl();4496  if (FirstLocal != CanonDecl) {4497    Decl *PrevMostRecent = ASTDeclReader::getMostRecentDecl(CanonDecl);4498    ASTDeclReader::attachPreviousDecl(4499        *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,4500        CanonDecl);4501  }4502 4503  if (!LocalOffset) {4504    ASTDeclReader::attachLatestDecl(CanonDecl, FirstLocal);4505    return;4506  }4507 4508  // Load the list of other redeclarations from this module file.4509  ModuleFile *M = getOwningModuleFile(FirstLocal);4510  assert(M && "imported decl from no module file");4511 4512  llvm::BitstreamCursor &Cursor = M->DeclsCursor;4513  SavedStreamPosition SavedPosition(Cursor);4514  if (llvm::Error JumpFailed = Cursor.JumpToBit(LocalOffset))4515    llvm::report_fatal_error(4516        Twine("ASTReader::loadPendingDeclChain failed jumping: ") +4517        toString(std::move(JumpFailed)));4518 4519  RecordData Record;4520  Expected<unsigned> MaybeCode = Cursor.ReadCode();4521  if (!MaybeCode)4522    llvm::report_fatal_error(4523        Twine("ASTReader::loadPendingDeclChain failed reading code: ") +4524        toString(MaybeCode.takeError()));4525  unsigned Code = MaybeCode.get();4526  if (Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record))4527    assert(MaybeRecCode.get() == LOCAL_REDECLARATIONS &&4528           "expected LOCAL_REDECLARATIONS record!");4529  else4530    llvm::report_fatal_error(4531        Twine("ASTReader::loadPendingDeclChain failed reading rec code: ") +4532        toString(MaybeCode.takeError()));4533 4534  // FIXME: We have several different dispatches on decl kind here; maybe4535  // we should instead generate one loop per kind and dispatch up-front?4536  Decl *MostRecent = FirstLocal;4537  for (unsigned I = 0, N = Record.size(); I != N; ++I) {4538    unsigned Idx = N - I - 1;4539    auto *D = ReadDecl(*M, Record, Idx);4540    ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);4541    MostRecent = D;4542  }4543  ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);4544}4545 4546namespace {4547 4548  /// Given an ObjC interface, goes through the modules and links to the4549  /// interface all the categories for it.4550  class ObjCCategoriesVisitor {4551    ASTReader &Reader;4552    ObjCInterfaceDecl *Interface;4553    llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;4554    ObjCCategoryDecl *Tail = nullptr;4555    llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;4556    GlobalDeclID InterfaceID;4557    unsigned PreviousGeneration;4558 4559    void add(ObjCCategoryDecl *Cat) {4560      // Only process each category once.4561      if (!Deserialized.erase(Cat))4562        return;4563 4564      // Check for duplicate categories.4565      if (Cat->getDeclName()) {4566        ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];4567        if (Existing && Reader.getOwningModuleFile(Existing) !=4568                            Reader.getOwningModuleFile(Cat)) {4569          StructuralEquivalenceContext::NonEquivalentDeclSet NonEquivalentDecls;4570          StructuralEquivalenceContext Ctx(4571              Reader.getContext().getLangOpts(), Cat->getASTContext(),4572              Existing->getASTContext(), NonEquivalentDecls,4573              StructuralEquivalenceKind::Default,4574              /*StrictTypeSpelling=*/false,4575              /*Complain=*/false,4576              /*ErrorOnTagTypeMismatch=*/true);4577          if (!Ctx.IsEquivalent(Cat, Existing)) {4578            // Warn only if the categories with the same name are different.4579            Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)4580                << Interface->getDeclName() << Cat->getDeclName();4581            Reader.Diag(Existing->getLocation(),4582                        diag::note_previous_definition);4583          }4584        } else if (!Existing) {4585          // Record this category.4586          Existing = Cat;4587        }4588      }4589 4590      // Add this category to the end of the chain.4591      if (Tail)4592        ASTDeclReader::setNextObjCCategory(Tail, Cat);4593      else4594        Interface->setCategoryListRaw(Cat);4595      Tail = Cat;4596    }4597 4598  public:4599    ObjCCategoriesVisitor(4600        ASTReader &Reader, ObjCInterfaceDecl *Interface,4601        llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,4602        GlobalDeclID InterfaceID, unsigned PreviousGeneration)4603        : Reader(Reader), Interface(Interface), Deserialized(Deserialized),4604          InterfaceID(InterfaceID), PreviousGeneration(PreviousGeneration) {4605      // Populate the name -> category map with the set of known categories.4606      for (auto *Cat : Interface->known_categories()) {4607        if (Cat->getDeclName())4608          NameCategoryMap[Cat->getDeclName()] = Cat;4609 4610        // Keep track of the tail of the category list.4611        Tail = Cat;4612      }4613    }4614 4615    bool operator()(ModuleFile &M) {4616      // If we've loaded all of the category information we care about from4617      // this module file, we're done.4618      if (M.Generation <= PreviousGeneration)4619        return true;4620 4621      // Map global ID of the definition down to the local ID used in this4622      // module file. If there is no such mapping, we'll find nothing here4623      // (or in any module it imports).4624      LocalDeclID LocalID =4625          Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);4626      if (LocalID.isInvalid())4627        return true;4628 4629      // Perform a binary search to find the local redeclarations for this4630      // declaration (if any).4631      const ObjCCategoriesInfo Compare = {LocalID, 0};4632      const ObjCCategoriesInfo *Result = std::lower_bound(4633          M.ObjCCategoriesMap,4634          M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap, Compare);4635      if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||4636          LocalID != Result->getDefinitionID()) {4637        // We didn't find anything. If the class definition is in this module4638        // file, then the module files it depends on cannot have any categories,4639        // so suppress further lookup.4640        return Reader.isDeclIDFromModule(InterfaceID, M);4641      }4642 4643      // We found something. Dig out all of the categories.4644      unsigned Offset = Result->Offset;4645      unsigned N = M.ObjCCategories[Offset];4646      M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again4647      for (unsigned I = 0; I != N; ++I)4648        add(Reader.ReadDeclAs<ObjCCategoryDecl>(M, M.ObjCCategories, Offset));4649      return true;4650    }4651  };4652 4653} // namespace4654 4655void ASTReader::loadObjCCategories(GlobalDeclID ID, ObjCInterfaceDecl *D,4656                                   unsigned PreviousGeneration) {4657  ObjCCategoriesVisitor Visitor(*this, D, CategoriesDeserialized, ID,4658                                PreviousGeneration);4659  ModuleMgr.visit(Visitor);4660}4661 4662template<typename DeclT, typename Fn>4663static void forAllLaterRedecls(DeclT *D, Fn F) {4664  F(D);4665 4666  // Check whether we've already merged D into its redeclaration chain.4667  // MostRecent may or may not be nullptr if D has not been merged. If4668  // not, walk the merged redecl chain and see if it's there.4669  auto *MostRecent = D->getMostRecentDecl();4670  bool Found = false;4671  for (auto *Redecl = MostRecent; Redecl && !Found;4672       Redecl = Redecl->getPreviousDecl())4673    Found = (Redecl == D);4674 4675  // If this declaration is merged, apply the functor to all later decls.4676  if (Found) {4677    for (auto *Redecl = MostRecent; Redecl != D;4678         Redecl = Redecl->getPreviousDecl())4679      F(Redecl);4680  }4681}4682 4683void ASTDeclReader::UpdateDecl(Decl *D) {4684  while (Record.getIdx() < Record.size()) {4685    switch ((DeclUpdateKind)Record.readInt()) {4686    case DeclUpdateKind::CXXAddedImplicitMember: {4687      auto *RD = cast<CXXRecordDecl>(D);4688      Decl *MD = Record.readDecl();4689      assert(MD && "couldn't read decl from update record");4690      Reader.PendingAddedClassMembers.push_back({RD, MD});4691      break;4692    }4693 4694    case DeclUpdateKind::CXXAddedAnonymousNamespace: {4695      auto *Anon = readDeclAs<NamespaceDecl>();4696 4697      // Each module has its own anonymous namespace, which is disjoint from4698      // any other module's anonymous namespaces, so don't attach the anonymous4699      // namespace at all.4700      if (!Record.isModule()) {4701        if (auto *TU = dyn_cast<TranslationUnitDecl>(D))4702          TU->setAnonymousNamespace(Anon);4703        else4704          cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);4705      }4706      break;4707    }4708 4709    case DeclUpdateKind::CXXAddedVarDefinition: {4710      auto *VD = cast<VarDecl>(D);4711      VD->NonParmVarDeclBits.IsInline = Record.readInt();4712      VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();4713      ReadVarDeclInit(VD);4714      break;4715    }4716 4717    case DeclUpdateKind::CXXPointOfInstantiation: {4718      SourceLocation POI = Record.readSourceLocation();4719      if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D)) {4720        VTSD->setPointOfInstantiation(POI);4721      } else if (auto *VD = dyn_cast<VarDecl>(D)) {4722        MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo();4723        assert(MSInfo && "No member specialization information");4724        MSInfo->setPointOfInstantiation(POI);4725      } else {4726        auto *FD = cast<FunctionDecl>(D);4727        if (auto *FTSInfo = dyn_cast<FunctionTemplateSpecializationInfo *>(4728                FD->TemplateOrSpecialization))4729          FTSInfo->setPointOfInstantiation(POI);4730        else4731          cast<MemberSpecializationInfo *>(FD->TemplateOrSpecialization)4732              ->setPointOfInstantiation(POI);4733      }4734      break;4735    }4736 4737    case DeclUpdateKind::CXXInstantiatedDefaultArgument: {4738      auto *Param = cast<ParmVarDecl>(D);4739 4740      // We have to read the default argument regardless of whether we use it4741      // so that hypothetical further update records aren't messed up.4742      // TODO: Add a function to skip over the next expr record.4743      auto *DefaultArg = Record.readExpr();4744 4745      // Only apply the update if the parameter still has an uninstantiated4746      // default argument.4747      if (Param->hasUninstantiatedDefaultArg())4748        Param->setDefaultArg(DefaultArg);4749      break;4750    }4751 4752    case DeclUpdateKind::CXXInstantiatedDefaultMemberInitializer: {4753      auto *FD = cast<FieldDecl>(D);4754      auto *DefaultInit = Record.readExpr();4755 4756      // Only apply the update if the field still has an uninstantiated4757      // default member initializer.4758      if (FD->hasInClassInitializer() && !FD->hasNonNullInClassInitializer()) {4759        if (DefaultInit)4760          FD->setInClassInitializer(DefaultInit);4761        else4762          // Instantiation failed. We can get here if we serialized an AST for4763          // an invalid program.4764          FD->removeInClassInitializer();4765      }4766      break;4767    }4768 4769    case DeclUpdateKind::CXXAddedFunctionDefinition: {4770      auto *FD = cast<FunctionDecl>(D);4771      if (Reader.PendingBodies[FD]) {4772        // FIXME: Maybe check for ODR violations.4773        // It's safe to stop now because this update record is always last.4774        return;4775      }4776 4777      if (Record.readInt()) {4778        // Maintain AST consistency: any later redeclarations of this function4779        // are inline if this one is. (We might have merged another declaration4780        // into this one.)4781        forAllLaterRedecls(FD, [](FunctionDecl *FD) {4782          FD->setImplicitlyInline();4783        });4784      }4785      FD->setInnerLocStart(readSourceLocation());4786      ReadFunctionDefinition(FD);4787      assert(Record.getIdx() == Record.size() && "lazy body must be last");4788      break;4789    }4790 4791    case DeclUpdateKind::CXXInstantiatedClassDefinition: {4792      auto *RD = cast<CXXRecordDecl>(D);4793      auto *OldDD = RD->getCanonicalDecl()->DefinitionData;4794      bool HadRealDefinition =4795          OldDD && (OldDD->Definition != RD ||4796                    !Reader.PendingFakeDefinitionData.count(OldDD));4797      RD->setParamDestroyedInCallee(Record.readInt());4798      RD->setArgPassingRestrictions(4799          static_cast<RecordArgPassingKind>(Record.readInt()));4800      ReadCXXRecordDefinition(RD, /*Update*/true);4801 4802      // Visible update is handled separately.4803      uint64_t LexicalOffset = ReadLocalOffset();4804      if (!HadRealDefinition && LexicalOffset) {4805        Record.readLexicalDeclContextStorage(LexicalOffset, RD);4806        Reader.PendingFakeDefinitionData.erase(OldDD);4807      }4808 4809      auto TSK = (TemplateSpecializationKind)Record.readInt();4810      SourceLocation POI = readSourceLocation();4811      if (MemberSpecializationInfo *MSInfo =4812              RD->getMemberSpecializationInfo()) {4813        MSInfo->setTemplateSpecializationKind(TSK);4814        MSInfo->setPointOfInstantiation(POI);4815      } else {4816        auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);4817        Spec->setTemplateSpecializationKind(TSK);4818        Spec->setPointOfInstantiation(POI);4819 4820        if (Record.readInt()) {4821          auto *PartialSpec =4822              readDeclAs<ClassTemplatePartialSpecializationDecl>();4823          SmallVector<TemplateArgument, 8> TemplArgs;4824          Record.readTemplateArgumentList(TemplArgs);4825          auto *TemplArgList = TemplateArgumentList::CreateCopy(4826              Reader.getContext(), TemplArgs);4827 4828          // FIXME: If we already have a partial specialization set,4829          // check that it matches.4830          if (!isa<ClassTemplatePartialSpecializationDecl *>(4831                  Spec->getSpecializedTemplateOrPartial()))4832            Spec->setInstantiationOf(PartialSpec, TemplArgList);4833        }4834      }4835 4836      RD->setTagKind(static_cast<TagTypeKind>(Record.readInt()));4837      RD->setLocation(readSourceLocation());4838      RD->setLocStart(readSourceLocation());4839      RD->setBraceRange(readSourceRange());4840 4841      if (Record.readInt()) {4842        AttrVec Attrs;4843        Record.readAttributes(Attrs);4844        // If the declaration already has attributes, we assume that some other4845        // AST file already loaded them.4846        if (!D->hasAttrs())4847          D->setAttrsImpl(Attrs, Reader.getContext());4848      }4849      break;4850    }4851 4852    case DeclUpdateKind::CXXResolvedDtorDelete: {4853      // Set the 'operator delete' directly to avoid emitting another update4854      // record.4855      auto *Del = readDeclAs<FunctionDecl>();4856      auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());4857      auto *ThisArg = Record.readExpr();4858      // FIXME: Check consistency if we have an old and new operator delete.4859      if (!First->OperatorDelete) {4860        First->OperatorDelete = Del;4861        First->OperatorDeleteThisArg = ThisArg;4862      }4863      break;4864    }4865 4866    case DeclUpdateKind::CXXResolvedDtorGlobDelete: {4867      auto *Del = readDeclAs<FunctionDecl>();4868      auto *Canon = cast<CXXDestructorDecl>(D->getCanonicalDecl());4869      if (!Canon->OperatorGlobalDelete)4870        Canon->OperatorGlobalDelete = Del;4871      break;4872    }4873 4874    case DeclUpdateKind::CXXResolvedExceptionSpec: {4875      SmallVector<QualType, 8> ExceptionStorage;4876      auto ESI = Record.readExceptionSpecInfo(ExceptionStorage);4877 4878      // Update this declaration's exception specification, if needed.4879      auto *FD = cast<FunctionDecl>(D);4880      auto *FPT = FD->getType()->castAs<FunctionProtoType>();4881      // FIXME: If the exception specification is already present, check that it4882      // matches.4883      if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {4884        FD->setType(Reader.getContext().getFunctionType(4885            FPT->getReturnType(), FPT->getParamTypes(),4886            FPT->getExtProtoInfo().withExceptionSpec(ESI)));4887 4888        // When we get to the end of deserializing, see if there are other decls4889        // that we need to propagate this exception specification onto.4890        Reader.PendingExceptionSpecUpdates.insert(4891            std::make_pair(FD->getCanonicalDecl(), FD));4892      }4893      break;4894    }4895 4896    case DeclUpdateKind::CXXDeducedReturnType: {4897      auto *FD = cast<FunctionDecl>(D);4898      QualType DeducedResultType = Record.readType();4899      Reader.PendingDeducedTypeUpdates.insert(4900          {FD->getCanonicalDecl(), DeducedResultType});4901      break;4902    }4903 4904    case DeclUpdateKind::DeclMarkedUsed:4905      // Maintain AST consistency: any later redeclarations are used too.4906      D->markUsed(Reader.getContext());4907      break;4908 4909    case DeclUpdateKind::ManglingNumber:4910      Reader.getContext().setManglingNumber(cast<NamedDecl>(D),4911                                            Record.readInt());4912      break;4913 4914    case DeclUpdateKind::StaticLocalNumber:4915      Reader.getContext().setStaticLocalNumber(cast<VarDecl>(D),4916                                               Record.readInt());4917      break;4918 4919    case DeclUpdateKind::DeclMarkedOpenMPThreadPrivate:4920      D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(Reader.getContext(),4921                                                          readSourceRange()));4922      break;4923 4924    case DeclUpdateKind::DeclMarkedOpenMPAllocate: {4925      auto AllocatorKind =4926          static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt());4927      Expr *Allocator = Record.readExpr();4928      Expr *Alignment = Record.readExpr();4929      SourceRange SR = readSourceRange();4930      D->addAttr(OMPAllocateDeclAttr::CreateImplicit(4931          Reader.getContext(), AllocatorKind, Allocator, Alignment, SR));4932      break;4933    }4934 4935    case DeclUpdateKind::DeclExported: {4936      unsigned SubmoduleID = readSubmoduleID();4937      auto *Exported = cast<NamedDecl>(D);4938      Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;4939      Reader.getContext().mergeDefinitionIntoModule(Exported, Owner);4940      Reader.PendingMergedDefinitionsToDeduplicate.insert(Exported);4941      break;4942    }4943 4944    case DeclUpdateKind::DeclMarkedOpenMPDeclareTarget: {4945      auto MapType = Record.readEnum<OMPDeclareTargetDeclAttr::MapTypeTy>();4946      auto DevType = Record.readEnum<OMPDeclareTargetDeclAttr::DevTypeTy>();4947      Expr *IndirectE = Record.readExpr();4948      bool Indirect = Record.readBool();4949      unsigned Level = Record.readInt();4950      D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(4951          Reader.getContext(), MapType, DevType, IndirectE, Indirect, Level,4952          readSourceRange()));4953      break;4954    }4955 4956    case DeclUpdateKind::AddedAttrToRecord:4957      AttrVec Attrs;4958      Record.readAttributes(Attrs);4959      assert(Attrs.size() == 1);4960      D->addAttr(Attrs[0]);4961      break;4962    }4963  }4964}4965