1//===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the ASTReader::ReadDeclRecord method, which is the 11// entrypoint for loading a decl. 12// 13//===----------------------------------------------------------------------===// 14 15#include "clang/Serialization/ASTReader.h" 16#include "ASTCommon.h" 17#include "ASTReaderInternals.h" 18#include "clang/AST/ASTConsumer.h" 19#include "clang/AST/ASTContext.h" 20#include "clang/AST/DeclCXX.h" 21#include "clang/AST/DeclGroup.h" 22#include "clang/AST/DeclTemplate.h" 23#include "clang/AST/DeclVisitor.h" 24#include "clang/AST/Expr.h" 25#include "clang/Sema/IdentifierResolver.h" 26#include "clang/Sema/Sema.h" 27#include "clang/Sema/SemaDiagnostic.h" 28#include "llvm/Support/SaveAndRestore.h" 29using namespace clang; 30using namespace clang::serialization; 31 32//===----------------------------------------------------------------------===// 33// Declaration deserialization 34//===----------------------------------------------------------------------===// 35 36namespace clang { 37 class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> { 38 ASTReader &Reader; 39 ModuleFile &F; 40 const DeclID ThisDeclID; 41 const unsigned RawLocation; 42 typedef ASTReader::RecordData RecordData; 43 const RecordData &Record; 44 unsigned &Idx; 45 TypeID TypeIDForTypeDecl; 46 47 bool HasPendingBody; 48 49 uint64_t GetCurrentCursorOffset(); 50 51 SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) { 52 return Reader.ReadSourceLocation(F, R, I); 53 } 54 55 SourceRange ReadSourceRange(const RecordData &R, unsigned &I) { 56 return Reader.ReadSourceRange(F, R, I); 57 } 58 59 TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) { 60 return Reader.GetTypeSourceInfo(F, R, I); 61 } 62 63 serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) { 64 return Reader.ReadDeclID(F, R, I); 65 } 66 67 Decl *ReadDecl(const RecordData &R, unsigned &I) { 68 return Reader.ReadDecl(F, R, I); 69 } 70 71 template<typename T> 72 T *ReadDeclAs(const RecordData &R, unsigned &I) { 73 return Reader.ReadDeclAs<T>(F, R, I); 74 } 75 76 void ReadQualifierInfo(QualifierInfo &Info, 77 const RecordData &R, unsigned &I) { 78 Reader.ReadQualifierInfo(F, Info, R, I); 79 } 80 81 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name, 82 const RecordData &R, unsigned &I) { 83 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I); 84 } 85 86 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo, 87 const RecordData &R, unsigned &I) { 88 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I); 89 } 90 91 serialization::SubmoduleID readSubmoduleID(const RecordData &R, 92 unsigned &I) { 93 if (I >= R.size()) 94 return 0; 95 96 return Reader.getGlobalSubmoduleID(F, R[I++]); 97 } 98 99 Module *readModule(const RecordData &R, unsigned &I) { 100 return Reader.getSubmodule(readSubmoduleID(R, I)); 101 } 102 103 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data, 104 const RecordData &R, unsigned &I); 105 106 /// \brief RAII class used to capture the first ID within a redeclaration 107 /// chain and to introduce it into the list of pending redeclaration chains 108 /// on destruction. 109 /// 110 /// The caller can choose not to introduce this ID into the redeclaration 111 /// chain by calling \c suppress(). 112 class RedeclarableResult { 113 ASTReader &Reader; 114 GlobalDeclID FirstID; 115 mutable bool Owning; 116 Decl::Kind DeclKind; 117 118 void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION; 119 120 public: 121 RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID, 122 Decl::Kind DeclKind) 123 : Reader(Reader), FirstID(FirstID), Owning(true), DeclKind(DeclKind) { } 124 125 RedeclarableResult(const RedeclarableResult &Other) 126 : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning) , 127 DeclKind(Other.DeclKind) 128 { 129 Other.Owning = false; 130 } 131 132 ~RedeclarableResult() { 133 if (FirstID && Owning && isRedeclarableDeclKind(DeclKind) && 134 Reader.PendingDeclChainsKnown.insert(FirstID)) 135 Reader.PendingDeclChains.push_back(FirstID); 136 } 137 138 /// \brief Retrieve the first ID. 139 GlobalDeclID getFirstID() const { return FirstID; } 140 141 /// \brief Do not introduce this declaration ID into the set of pending 142 /// declaration chains. 143 void suppress() { 144 Owning = false; 145 } 146 }; 147 148 /// \brief Class used to capture the result of searching for an existing 149 /// declaration of a specific kind and name, along with the ability 150 /// to update the place where this result was found (the declaration 151 /// chain hanging off an identifier or the DeclContext we searched in) 152 /// if requested. 153 class FindExistingResult { 154 ASTReader &Reader; 155 NamedDecl *New; 156 NamedDecl *Existing; 157 mutable bool AddResult; 158 159 void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION; 160 161 public: 162 FindExistingResult(ASTReader &Reader) 163 : Reader(Reader), New(0), Existing(0), AddResult(false) { } 164 165 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing) 166 : Reader(Reader), New(New), Existing(Existing), AddResult(true) { } 167 168 FindExistingResult(const FindExistingResult &Other) 169 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing), 170 AddResult(Other.AddResult) 171 { 172 Other.AddResult = false; 173 } 174 175 ~FindExistingResult(); 176 177 /// \brief Suppress the addition of this result into the known set of 178 /// names. 179 void suppress() { AddResult = false; } 180 181 operator NamedDecl*() const { return Existing; } 182 183 template<typename T> 184 operator T*() const { return dyn_cast_or_null<T>(Existing); } 185 }; 186 187 FindExistingResult findExisting(NamedDecl *D); 188 189 public: 190 ASTDeclReader(ASTReader &Reader, ModuleFile &F, 191 DeclID thisDeclID, 192 unsigned RawLocation, 193 const RecordData &Record, unsigned &Idx) 194 : Reader(Reader), F(F), ThisDeclID(thisDeclID), 195 RawLocation(RawLocation), Record(Record), Idx(Idx), 196 TypeIDForTypeDecl(0), HasPendingBody(false) { } 197 198 static void attachPreviousDecl(Decl *D, Decl *previous); 199 static void attachLatestDecl(Decl *D, Decl *latest); 200 201 /// \brief Determine whether this declaration has a pending body. 202 bool hasPendingBody() const { return HasPendingBody; } 203 204 void Visit(Decl *D); 205 206 void UpdateDecl(Decl *D, ModuleFile &ModuleFile, 207 const RecordData &Record); 208 209 static void setNextObjCCategory(ObjCCategoryDecl *Cat, 210 ObjCCategoryDecl *Next) { 211 Cat->NextClassCategory = Next; 212 } 213 214 void VisitDecl(Decl *D); 215 void VisitTranslationUnitDecl(TranslationUnitDecl *TU); 216 void VisitNamedDecl(NamedDecl *ND); 217 void VisitLabelDecl(LabelDecl *LD); 218 void VisitNamespaceDecl(NamespaceDecl *D); 219 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 220 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 221 void VisitTypeDecl(TypeDecl *TD); 222 void VisitTypedefNameDecl(TypedefNameDecl *TD); 223 void VisitTypedefDecl(TypedefDecl *TD); 224 void VisitTypeAliasDecl(TypeAliasDecl *TD); 225 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 226 void VisitTagDecl(TagDecl *TD); 227 void VisitEnumDecl(EnumDecl *ED); 228 void VisitRecordDecl(RecordDecl *RD); 229 void VisitCXXRecordDecl(CXXRecordDecl *D); 230 void VisitClassTemplateSpecializationDecl( 231 ClassTemplateSpecializationDecl *D); 232 void VisitClassTemplatePartialSpecializationDecl( 233 ClassTemplatePartialSpecializationDecl *D); 234 void VisitClassScopeFunctionSpecializationDecl( 235 ClassScopeFunctionSpecializationDecl *D); 236 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 237 void VisitValueDecl(ValueDecl *VD); 238 void VisitEnumConstantDecl(EnumConstantDecl *ECD); 239 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 240 void VisitDeclaratorDecl(DeclaratorDecl *DD); 241 void VisitFunctionDecl(FunctionDecl *FD); 242 void VisitCXXMethodDecl(CXXMethodDecl *D); 243 void VisitCXXConstructorDecl(CXXConstructorDecl *D); 244 void VisitCXXDestructorDecl(CXXDestructorDecl *D); 245 void VisitCXXConversionDecl(CXXConversionDecl *D); 246 void VisitFieldDecl(FieldDecl *FD); 247 void VisitIndirectFieldDecl(IndirectFieldDecl *FD); 248 void VisitVarDecl(VarDecl *VD); 249 void VisitImplicitParamDecl(ImplicitParamDecl *PD); 250 void VisitParmVarDecl(ParmVarDecl *PD); 251 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 252 void VisitTemplateDecl(TemplateDecl *D); 253 RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); 254 void VisitClassTemplateDecl(ClassTemplateDecl *D); 255 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 256 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 257 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 258 void VisitUsingDecl(UsingDecl *D); 259 void VisitUsingShadowDecl(UsingShadowDecl *D); 260 void VisitLinkageSpecDecl(LinkageSpecDecl *D); 261 void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD); 262 void VisitImportDecl(ImportDecl *D); 263 void VisitAccessSpecDecl(AccessSpecDecl *D); 264 void VisitFriendDecl(FriendDecl *D); 265 void VisitFriendTemplateDecl(FriendTemplateDecl *D); 266 void VisitStaticAssertDecl(StaticAssertDecl *D); 267 void VisitBlockDecl(BlockDecl *BD); 268 void VisitEmptyDecl(EmptyDecl *D); 269 270 std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC); 271 272 template<typename T> 273 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D); 274 275 template<typename T> 276 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl); 277 278 // FIXME: Reorder according to DeclNodes.td? 279 void VisitObjCMethodDecl(ObjCMethodDecl *D); 280 void VisitObjCContainerDecl(ObjCContainerDecl *D); 281 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 282 void VisitObjCIvarDecl(ObjCIvarDecl *D); 283 void VisitObjCProtocolDecl(ObjCProtocolDecl *D); 284 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D); 285 void VisitObjCCategoryDecl(ObjCCategoryDecl *D); 286 void VisitObjCImplDecl(ObjCImplDecl *D); 287 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 288 void VisitObjCImplementationDecl(ObjCImplementationDecl *D); 289 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); 290 void VisitObjCPropertyDecl(ObjCPropertyDecl *D); 291 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 292 }; 293} 294 295uint64_t ASTDeclReader::GetCurrentCursorOffset() { 296 return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset; 297} 298 299void ASTDeclReader::Visit(Decl *D) { 300 DeclVisitor<ASTDeclReader, void>::Visit(D); 301 302 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 303 if (DD->DeclInfo) { 304 DeclaratorDecl::ExtInfo *Info = 305 DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>(); 306 Info->TInfo = 307 GetTypeSourceInfo(Record, Idx); 308 } 309 else { 310 DD->DeclInfo = GetTypeSourceInfo(Record, Idx); 311 } 312 } 313 314 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) { 315 // if we have a fully initialized TypeDecl, we can safely read its type now. 316 TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull()); 317 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 318 // if we have a fully initialized TypeDecl, we can safely read its type now. 319 ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull(); 320 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 321 // FunctionDecl's body was written last after all other Stmts/Exprs. 322 // We only read it if FD doesn't already have a body (e.g., from another 323 // module). 324 // FIXME: Also consider = default and = delete. 325 // FIXME: Can we diagnose ODR violations somehow? 326 if (Record[Idx++]) { 327 Reader.PendingBodies[FD] = GetCurrentCursorOffset(); 328 HasPendingBody = true; 329 } 330 } 331} 332 333void ASTDeclReader::VisitDecl(Decl *D) { 334 if (D->isTemplateParameter()) { 335 // We don't want to deserialize the DeclContext of a template 336 // parameter immediately, because the template parameter might be 337 // used in the formulation of its DeclContext. Use the translation 338 // unit DeclContext as a placeholder. 339 GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx); 340 GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx); 341 Reader.addPendingDeclContextInfo(D, 342 SemaDCIDForTemplateParmDecl, 343 LexicalDCIDForTemplateParmDecl); 344 D->setDeclContext(Reader.getContext().getTranslationUnitDecl()); 345 } else { 346 DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx); 347 DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx); 348 // Avoid calling setLexicalDeclContext() directly because it uses 349 // Decl::getASTContext() internally which is unsafe during derialization. 350 D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext()); 351 } 352 D->setLocation(Reader.ReadSourceLocation(F, RawLocation)); 353 D->setInvalidDecl(Record[Idx++]); 354 if (Record[Idx++]) { // hasAttrs 355 AttrVec Attrs; 356 Reader.ReadAttributes(F, Attrs, Record, Idx); 357 // Avoid calling setAttrs() directly because it uses Decl::getASTContext() 358 // internally which is unsafe during derialization. 359 D->setAttrsImpl(Attrs, Reader.getContext()); 360 } 361 D->setImplicit(Record[Idx++]); 362 D->setUsed(Record[Idx++]); 363 D->setReferenced(Record[Idx++]); 364 D->setTopLevelDeclInObjCContainer(Record[Idx++]); 365 D->setAccess((AccessSpecifier)Record[Idx++]); 366 D->FromASTFile = true; 367 D->setModulePrivate(Record[Idx++]); 368 D->Hidden = D->isModulePrivate(); 369 370 // Determine whether this declaration is part of a (sub)module. If so, it 371 // may not yet be visible. 372 if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) { 373 // Store the owning submodule ID in the declaration. 374 D->setOwningModuleID(SubmoduleID); 375 376 // Module-private declarations are never visible, so there is no work to do. 377 if (!D->isModulePrivate()) { 378 if (Module *Owner = Reader.getSubmodule(SubmoduleID)) { 379 if (Owner->NameVisibility != Module::AllVisible) { 380 // The owning module is not visible. Mark this declaration as hidden. 381 D->Hidden = true; 382 383 // Note that this declaration was hidden because its owning module is 384 // not yet visible. 385 Reader.HiddenNamesMap[Owner].push_back(D); 386 } 387 } 388 } 389 } 390} 391 392void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) { 393 llvm_unreachable("Translation units are not serialized"); 394} 395 396void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) { 397 VisitDecl(ND); 398 ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx)); 399} 400 401void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) { 402 VisitNamedDecl(TD); 403 TD->setLocStart(ReadSourceLocation(Record, Idx)); 404 // Delay type reading until after we have fully initialized the decl. 405 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]); 406} 407 408void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) { 409 RedeclarableResult Redecl = VisitRedeclarable(TD); 410 VisitTypeDecl(TD); 411 412 TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); 413 mergeRedeclarable(TD, Redecl); 414} 415 416void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) { 417 VisitTypedefNameDecl(TD); 418} 419 420void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) { 421 VisitTypedefNameDecl(TD); 422} 423 424void ASTDeclReader::VisitTagDecl(TagDecl *TD) { 425 RedeclarableResult Redecl = VisitRedeclarable(TD); 426 VisitTypeDecl(TD); 427 428 TD->IdentifierNamespace = Record[Idx++]; 429 TD->setTagKind((TagDecl::TagKind)Record[Idx++]); 430 TD->setCompleteDefinition(Record[Idx++]); 431 TD->setEmbeddedInDeclarator(Record[Idx++]); 432 TD->setFreeStanding(Record[Idx++]); 433 TD->setRBraceLoc(ReadSourceLocation(Record, Idx)); 434 435 if (Record[Idx++]) { // hasExtInfo 436 TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo(); 437 ReadQualifierInfo(*Info, Record, Idx); 438 TD->TypedefNameDeclOrQualifier = Info; 439 } else 440 TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx)); 441 442 mergeRedeclarable(TD, Redecl); 443} 444 445void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) { 446 VisitTagDecl(ED); 447 if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx)) 448 ED->setIntegerTypeSourceInfo(TI); 449 else 450 ED->setIntegerType(Reader.readType(F, Record, Idx)); 451 ED->setPromotionType(Reader.readType(F, Record, Idx)); 452 ED->setNumPositiveBits(Record[Idx++]); 453 ED->setNumNegativeBits(Record[Idx++]); 454 ED->IsScoped = Record[Idx++]; 455 ED->IsScopedUsingClassTag = Record[Idx++]; 456 ED->IsFixed = Record[Idx++]; 457 458 if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) { 459 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++]; 460 SourceLocation POI = ReadSourceLocation(Record, Idx); 461 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK); 462 ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI); 463 } 464} 465 466void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) { 467 VisitTagDecl(RD); 468 RD->setHasFlexibleArrayMember(Record[Idx++]); 469 RD->setAnonymousStructOrUnion(Record[Idx++]); 470 RD->setHasObjectMember(Record[Idx++]); 471 RD->setHasVolatileMember(Record[Idx++]); 472} 473 474void ASTDeclReader::VisitValueDecl(ValueDecl *VD) { 475 VisitNamedDecl(VD); 476 VD->setType(Reader.readType(F, Record, Idx)); 477} 478 479void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) { 480 VisitValueDecl(ECD); 481 if (Record[Idx++]) 482 ECD->setInitExpr(Reader.ReadExpr(F)); 483 ECD->setInitVal(Reader.ReadAPSInt(Record, Idx)); 484} 485 486void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) { 487 VisitValueDecl(DD); 488 DD->setInnerLocStart(ReadSourceLocation(Record, Idx)); 489 if (Record[Idx++]) { // hasExtInfo 490 DeclaratorDecl::ExtInfo *Info 491 = new (Reader.getContext()) DeclaratorDecl::ExtInfo(); 492 ReadQualifierInfo(*Info, Record, Idx); 493 DD->DeclInfo = Info; 494 } 495} 496 497void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) { 498 RedeclarableResult Redecl = VisitRedeclarable(FD); 499 VisitDeclaratorDecl(FD); 500 501 ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx); 502 FD->IdentifierNamespace = Record[Idx++]; 503 504 // FunctionDecl's body is handled last at ASTDeclReader::Visit, 505 // after everything else is read. 506 507 FD->SClass = (StorageClass)Record[Idx++]; 508 FD->SClassAsWritten = (StorageClass)Record[Idx++]; 509 FD->IsInline = Record[Idx++]; 510 FD->IsInlineSpecified = Record[Idx++]; 511 FD->IsVirtualAsWritten = Record[Idx++]; 512 FD->IsPure = Record[Idx++]; 513 FD->HasInheritedPrototype = Record[Idx++]; 514 FD->HasWrittenPrototype = Record[Idx++]; 515 FD->IsDeleted = Record[Idx++]; 516 FD->IsTrivial = Record[Idx++]; 517 FD->IsDefaulted = Record[Idx++]; 518 FD->IsExplicitlyDefaulted = Record[Idx++]; 519 FD->HasImplicitReturnZero = Record[Idx++]; 520 FD->IsConstexpr = Record[Idx++]; 521 FD->HasSkippedBody = Record[Idx++]; 522 FD->HasCachedLinkage = true; 523 FD->CachedLinkage = Record[Idx++]; 524 FD->EndRangeLoc = ReadSourceLocation(Record, Idx); 525 526 switch ((FunctionDecl::TemplatedKind)Record[Idx++]) { 527 case FunctionDecl::TK_NonTemplate: 528 mergeRedeclarable(FD, Redecl); 529 break; 530 case FunctionDecl::TK_FunctionTemplate: 531 FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record, 532 Idx)); 533 break; 534 case FunctionDecl::TK_MemberSpecialization: { 535 FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx); 536 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++]; 537 SourceLocation POI = ReadSourceLocation(Record, Idx); 538 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK); 539 FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI); 540 break; 541 } 542 case FunctionDecl::TK_FunctionTemplateSpecialization: { 543 FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record, 544 Idx); 545 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++]; 546 547 // Template arguments. 548 SmallVector<TemplateArgument, 8> TemplArgs; 549 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx); 550 551 // Template args as written. 552 SmallVector<TemplateArgumentLoc, 8> TemplArgLocs; 553 SourceLocation LAngleLoc, RAngleLoc; 554 bool HasTemplateArgumentsAsWritten = Record[Idx++]; 555 if (HasTemplateArgumentsAsWritten) { 556 unsigned NumTemplateArgLocs = Record[Idx++]; 557 TemplArgLocs.reserve(NumTemplateArgLocs); 558 for (unsigned i=0; i != NumTemplateArgLocs; ++i) 559 TemplArgLocs.push_back( 560 Reader.ReadTemplateArgumentLoc(F, Record, Idx)); 561 562 LAngleLoc = ReadSourceLocation(Record, Idx); 563 RAngleLoc = ReadSourceLocation(Record, Idx); 564 } 565 566 SourceLocation POI = ReadSourceLocation(Record, Idx); 567 568 ASTContext &C = Reader.getContext(); 569 TemplateArgumentList *TemplArgList 570 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size()); 571 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc); 572 for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i) 573 TemplArgsInfo.addArgument(TemplArgLocs[i]); 574 FunctionTemplateSpecializationInfo *FTInfo 575 = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK, 576 TemplArgList, 577 HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0, 578 POI); 579 FD->TemplateOrSpecialization = FTInfo; 580 581 if (FD->isCanonicalDecl()) { // if canonical add to template's set. 582 // The template that contains the specializations set. It's not safe to 583 // use getCanonicalDecl on Template since it may still be initializing. 584 FunctionTemplateDecl *CanonTemplate 585 = ReadDeclAs<FunctionTemplateDecl>(Record, Idx); 586 // Get the InsertPos by FindNodeOrInsertPos() instead of calling 587 // InsertNode(FTInfo) directly to avoid the getASTContext() call in 588 // FunctionTemplateSpecializationInfo's Profile(). 589 // We avoid getASTContext because a decl in the parent hierarchy may 590 // be initializing. 591 llvm::FoldingSetNodeID ID; 592 FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(), 593 TemplArgs.size(), C); 594 void *InsertPos = 0; 595 CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 596 if (InsertPos) 597 CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos); 598 else 599 assert(0 && "Another specialization already inserted!"); 600 } 601 break; 602 } 603 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 604 // Templates. 605 UnresolvedSet<8> TemplDecls; 606 unsigned NumTemplates = Record[Idx++]; 607 while (NumTemplates--) 608 TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx)); 609 610 // Templates args. 611 TemplateArgumentListInfo TemplArgs; 612 unsigned NumArgs = Record[Idx++]; 613 while (NumArgs--) 614 TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx)); 615 TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx)); 616 TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx)); 617 618 FD->setDependentTemplateSpecialization(Reader.getContext(), 619 TemplDecls, TemplArgs); 620 break; 621 } 622 } 623 624 // Read in the parameters. 625 unsigned NumParams = Record[Idx++]; 626 SmallVector<ParmVarDecl *, 16> Params; 627 Params.reserve(NumParams); 628 for (unsigned I = 0; I != NumParams; ++I) 629 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx)); 630 FD->setParams(Reader.getContext(), Params); 631} 632 633void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) { 634 VisitNamedDecl(MD); 635 if (Record[Idx++]) { 636 // Load the body on-demand. Most clients won't care, because method 637 // definitions rarely show up in headers. 638 Reader.PendingBodies[MD] = GetCurrentCursorOffset(); 639 HasPendingBody = true; 640 MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx)); 641 MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx)); 642 } 643 MD->setInstanceMethod(Record[Idx++]); 644 MD->setVariadic(Record[Idx++]); 645 MD->setPropertyAccessor(Record[Idx++]); 646 MD->setDefined(Record[Idx++]); 647 MD->IsOverriding = Record[Idx++]; 648 MD->HasSkippedBody = Record[Idx++]; 649 650 MD->IsRedeclaration = Record[Idx++]; 651 MD->HasRedeclaration = Record[Idx++]; 652 if (MD->HasRedeclaration) 653 Reader.getContext().setObjCMethodRedeclaration(MD, 654 ReadDeclAs<ObjCMethodDecl>(Record, Idx)); 655 656 MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]); 657 MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]); 658 MD->SetRelatedResultType(Record[Idx++]); 659 MD->setResultType(Reader.readType(F, Record, Idx)); 660 MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx)); 661 MD->DeclEndLoc = ReadSourceLocation(Record, Idx); 662 unsigned NumParams = Record[Idx++]; 663 SmallVector<ParmVarDecl *, 16> Params; 664 Params.reserve(NumParams); 665 for (unsigned I = 0; I != NumParams; ++I) 666 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx)); 667 668 MD->SelLocsKind = Record[Idx++]; 669 unsigned NumStoredSelLocs = Record[Idx++]; 670 SmallVector<SourceLocation, 16> SelLocs; 671 SelLocs.reserve(NumStoredSelLocs); 672 for (unsigned i = 0; i != NumStoredSelLocs; ++i) 673 SelLocs.push_back(ReadSourceLocation(Record, Idx)); 674 675 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs); 676} 677 678void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) { 679 VisitNamedDecl(CD); 680 CD->setAtStartLoc(ReadSourceLocation(Record, Idx)); 681 CD->setAtEndRange(ReadSourceRange(Record, Idx)); 682} 683 684void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) { 685 RedeclarableResult Redecl = VisitRedeclarable(ID); 686 VisitObjCContainerDecl(ID); 687 TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]); 688 mergeRedeclarable(ID, Redecl); 689 690 if (Record[Idx++]) { 691 // Read the definition. 692 ID->allocateDefinitionData(); 693 694 // Set the definition data of the canonical declaration, so other 695 // redeclarations will see it. 696 ID->getCanonicalDecl()->Data = ID->Data; 697 698 ObjCInterfaceDecl::DefinitionData &Data = ID->data(); 699 700 // Read the superclass. 701 Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx); 702 Data.SuperClassLoc = ReadSourceLocation(Record, Idx); 703 704 Data.EndLoc = ReadSourceLocation(Record, Idx); 705 706 // Read the directly referenced protocols and their SourceLocations. 707 unsigned NumProtocols = Record[Idx++]; 708 SmallVector<ObjCProtocolDecl *, 16> Protocols; 709 Protocols.reserve(NumProtocols); 710 for (unsigned I = 0; I != NumProtocols; ++I) 711 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx)); 712 SmallVector<SourceLocation, 16> ProtoLocs; 713 ProtoLocs.reserve(NumProtocols); 714 for (unsigned I = 0; I != NumProtocols; ++I) 715 ProtoLocs.push_back(ReadSourceLocation(Record, Idx)); 716 ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(), 717 Reader.getContext()); 718 719 // Read the transitive closure of protocols referenced by this class. 720 NumProtocols = Record[Idx++]; 721 Protocols.clear(); 722 Protocols.reserve(NumProtocols); 723 for (unsigned I = 0; I != NumProtocols; ++I) 724 Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx)); 725 ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols, 726 Reader.getContext()); 727 728 // We will rebuild this list lazily. 729 ID->setIvarList(0); 730 731 // Note that we have deserialized a definition. 732 Reader.PendingDefinitions.insert(ID); 733 734 // Note that we've loaded this Objective-C class. 735 Reader.ObjCClassesLoaded.push_back(ID); 736 } else { 737 ID->Data = ID->getCanonicalDecl()->Data; 738 } 739} 740 741void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) { 742 VisitFieldDecl(IVD); 743 IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]); 744 // This field will be built lazily. 745 IVD->setNextIvar(0); 746 bool synth = Record[Idx++]; 747 IVD->setSynthesize(synth); 748} 749 750void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) { 751 RedeclarableResult Redecl = VisitRedeclarable(PD); 752 VisitObjCContainerDecl(PD); 753 mergeRedeclarable(PD, Redecl); 754 755 if (Record[Idx++]) { 756 // Read the definition. 757 PD->allocateDefinitionData(); 758 759 // Set the definition data of the canonical declaration, so other 760 // redeclarations will see it. 761 PD->getCanonicalDecl()->Data = PD->Data; 762 763 unsigned NumProtoRefs = Record[Idx++]; 764 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs; 765 ProtoRefs.reserve(NumProtoRefs); 766 for (unsigned I = 0; I != NumProtoRefs; ++I) 767 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx)); 768 SmallVector<SourceLocation, 16> ProtoLocs; 769 ProtoLocs.reserve(NumProtoRefs); 770 for (unsigned I = 0; I != NumProtoRefs; ++I) 771 ProtoLocs.push_back(ReadSourceLocation(Record, Idx)); 772 PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(), 773 Reader.getContext()); 774 775 // Note that we have deserialized a definition. 776 Reader.PendingDefinitions.insert(PD); 777 } else { 778 PD->Data = PD->getCanonicalDecl()->Data; 779 } 780} 781 782void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) { 783 VisitFieldDecl(FD); 784} 785 786void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) { 787 VisitObjCContainerDecl(CD); 788 CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx)); 789 CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx)); 790 CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx)); 791 792 // Note that this category has been deserialized. We do this before 793 // deserializing the interface declaration, so that it will consider this 794 /// category. 795 Reader.CategoriesDeserialized.insert(CD); 796 797 CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx); 798 unsigned NumProtoRefs = Record[Idx++]; 799 SmallVector<ObjCProtocolDecl *, 16> ProtoRefs; 800 ProtoRefs.reserve(NumProtoRefs); 801 for (unsigned I = 0; I != NumProtoRefs; ++I) 802 ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx)); 803 SmallVector<SourceLocation, 16> ProtoLocs; 804 ProtoLocs.reserve(NumProtoRefs); 805 for (unsigned I = 0; I != NumProtoRefs; ++I) 806 ProtoLocs.push_back(ReadSourceLocation(Record, Idx)); 807 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(), 808 Reader.getContext()); 809} 810 811void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) { 812 VisitNamedDecl(CAD); 813 CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx)); 814} 815 816void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 817 VisitNamedDecl(D); 818 D->setAtLoc(ReadSourceLocation(Record, Idx)); 819 D->setLParenLoc(ReadSourceLocation(Record, Idx)); 820 D->setType(GetTypeSourceInfo(Record, Idx)); 821 // FIXME: stable encoding 822 D->setPropertyAttributes( 823 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]); 824 D->setPropertyAttributesAsWritten( 825 (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]); 826 // FIXME: stable encoding 827 D->setPropertyImplementation( 828 (ObjCPropertyDecl::PropertyControl)Record[Idx++]); 829 D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector()); 830 D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector()); 831 D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx)); 832 D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx)); 833 D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx)); 834} 835 836void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) { 837 VisitObjCContainerDecl(D); 838 D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx)); 839} 840 841void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 842 VisitObjCImplDecl(D); 843 D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx)); 844 D->CategoryNameLoc = ReadSourceLocation(Record, Idx); 845} 846 847void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 848 VisitObjCImplDecl(D); 849 D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx)); 850 D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx)); 851 D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx)); 852 D->setHasNonZeroConstructors(Record[Idx++]); 853 D->setHasDestructors(Record[Idx++]); 854 llvm::tie(D->IvarInitializers, D->NumIvarInitializers) 855 = Reader.ReadCXXCtorInitializers(F, Record, Idx); 856} 857 858 859void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 860 VisitDecl(D); 861 D->setAtLoc(ReadSourceLocation(Record, Idx)); 862 D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx)); 863 D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx); 864 D->IvarLoc = ReadSourceLocation(Record, Idx); 865 D->setGetterCXXConstructor(Reader.ReadExpr(F)); 866 D->setSetterCXXAssignment(Reader.ReadExpr(F)); 867} 868 869void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) { 870 VisitDeclaratorDecl(FD); 871 FD->Mutable = Record[Idx++]; 872 if (int BitWidthOrInitializer = Record[Idx++]) { 873 FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1); 874 FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F)); 875 } 876 if (!FD->getDeclName()) { 877 if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx)) 878 Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl); 879 } 880} 881 882void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) { 883 VisitValueDecl(FD); 884 885 FD->ChainingSize = Record[Idx++]; 886 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2"); 887 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize]; 888 889 for (unsigned I = 0; I != FD->ChainingSize; ++I) 890 FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx); 891} 892 893void ASTDeclReader::VisitVarDecl(VarDecl *VD) { 894 RedeclarableResult Redecl = VisitRedeclarable(VD); 895 VisitDeclaratorDecl(VD); 896 897 VD->VarDeclBits.SClass = (StorageClass)Record[Idx++]; 898 VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++]; 899 VD->VarDeclBits.ThreadSpecified = Record[Idx++]; 900 VD->VarDeclBits.InitStyle = Record[Idx++]; 901 VD->VarDeclBits.ExceptionVar = Record[Idx++]; 902 VD->VarDeclBits.NRVOVariable = Record[Idx++]; 903 VD->VarDeclBits.CXXForRangeDecl = Record[Idx++]; 904 VD->VarDeclBits.ARCPseudoStrong = Record[Idx++]; 905 VD->VarDeclBits.IsConstexpr = Record[Idx++]; 906 VD->HasCachedLinkage = true; 907 VD->CachedLinkage = Record[Idx++]; 908 909 // Only true variables (not parameters or implicit parameters) can be merged. 910 if (VD->getKind() == Decl::Var) 911 mergeRedeclarable(VD, Redecl); 912 913 if (uint64_t Val = Record[Idx++]) { 914 VD->setInit(Reader.ReadExpr(F)); 915 if (Val > 1) { 916 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt(); 917 Eval->CheckedICE = true; 918 Eval->IsICE = Val == 3; 919 } 920 } 921 922 if (Record[Idx++]) { // HasMemberSpecializationInfo. 923 VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx); 924 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++]; 925 SourceLocation POI = ReadSourceLocation(Record, Idx); 926 Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI); 927 } 928} 929 930void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) { 931 VisitVarDecl(PD); 932} 933 934void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) { 935 VisitVarDecl(PD); 936 unsigned isObjCMethodParam = Record[Idx++]; 937 unsigned scopeDepth = Record[Idx++]; 938 unsigned scopeIndex = Record[Idx++]; 939 unsigned declQualifier = Record[Idx++]; 940 if (isObjCMethodParam) { 941 assert(scopeDepth == 0); 942 PD->setObjCMethodScopeInfo(scopeIndex); 943 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier; 944 } else { 945 PD->setScopeInfo(scopeDepth, scopeIndex); 946 } 947 PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++]; 948 PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++]; 949 if (Record[Idx++]) // hasUninstantiatedDefaultArg. 950 PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F)); 951} 952 953void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) { 954 VisitDecl(AD); 955 AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F))); 956 AD->setRParenLoc(ReadSourceLocation(Record, Idx)); 957} 958 959void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) { 960 VisitDecl(BD); 961 BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F))); 962 BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx)); 963 unsigned NumParams = Record[Idx++]; 964 SmallVector<ParmVarDecl *, 16> Params; 965 Params.reserve(NumParams); 966 for (unsigned I = 0; I != NumParams; ++I) 967 Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx)); 968 BD->setParams(Params); 969 970 BD->setIsVariadic(Record[Idx++]); 971 BD->setBlockMissingReturnType(Record[Idx++]); 972 BD->setIsConversionFromLambda(Record[Idx++]); 973 974 bool capturesCXXThis = Record[Idx++]; 975 unsigned numCaptures = Record[Idx++]; 976 SmallVector<BlockDecl::Capture, 16> captures; 977 captures.reserve(numCaptures); 978 for (unsigned i = 0; i != numCaptures; ++i) { 979 VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx); 980 unsigned flags = Record[Idx++]; 981 bool byRef = (flags & 1); 982 bool nested = (flags & 2); 983 Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0); 984 985 captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr)); 986 } 987 BD->setCaptures(Reader.getContext(), captures.begin(), 988 captures.end(), capturesCXXThis); 989} 990 991void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 992 VisitDecl(D); 993 D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]); 994 D->setExternLoc(ReadSourceLocation(Record, Idx)); 995 D->setRBraceLoc(ReadSourceLocation(Record, Idx)); 996} 997 998void ASTDeclReader::VisitLabelDecl(LabelDecl *D) { 999 VisitNamedDecl(D); 1000 D->setLocStart(ReadSourceLocation(Record, Idx)); 1001} 1002 1003 1004void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) { 1005 RedeclarableResult Redecl = VisitRedeclarable(D); 1006 VisitNamedDecl(D); 1007 D->setInline(Record[Idx++]); 1008 D->LocStart = ReadSourceLocation(Record, Idx); 1009 D->RBraceLoc = ReadSourceLocation(Record, Idx); 1010 mergeRedeclarable(D, Redecl); 1011 1012 if (Redecl.getFirstID() == ThisDeclID) { 1013 // Each module has its own anonymous namespace, which is disjoint from 1014 // any other module's anonymous namespaces, so don't attach the anonymous 1015 // namespace at all. 1016 NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx); 1017 if (F.Kind != MK_Module) 1018 D->setAnonymousNamespace(Anon); 1019 } else { 1020 // Link this namespace back to the first declaration, which has already 1021 // been deserialized. 1022 D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration()); 1023 } 1024} 1025 1026void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1027 VisitNamedDecl(D); 1028 D->NamespaceLoc = ReadSourceLocation(Record, Idx); 1029 D->IdentLoc = ReadSourceLocation(Record, Idx); 1030 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1031 D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx); 1032} 1033 1034void ASTDeclReader::VisitUsingDecl(UsingDecl *D) { 1035 VisitNamedDecl(D); 1036 D->setUsingLocation(ReadSourceLocation(Record, Idx)); 1037 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1038 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx); 1039 D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx)); 1040 D->setTypeName(Record[Idx++]); 1041 if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx)) 1042 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern); 1043} 1044 1045void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) { 1046 VisitNamedDecl(D); 1047 D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx)); 1048 D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx); 1049 UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx); 1050 if (Pattern) 1051 Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern); 1052} 1053 1054void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1055 VisitNamedDecl(D); 1056 D->UsingLoc = ReadSourceLocation(Record, Idx); 1057 D->NamespaceLoc = ReadSourceLocation(Record, Idx); 1058 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1059 D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx); 1060 D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx); 1061} 1062 1063void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1064 VisitValueDecl(D); 1065 D->setUsingLoc(ReadSourceLocation(Record, Idx)); 1066 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1067 ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx); 1068} 1069 1070void ASTDeclReader::VisitUnresolvedUsingTypenameDecl( 1071 UnresolvedUsingTypenameDecl *D) { 1072 VisitTypeDecl(D); 1073 D->TypenameLocation = ReadSourceLocation(Record, Idx); 1074 D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx); 1075} 1076 1077void ASTDeclReader::ReadCXXDefinitionData( 1078 struct CXXRecordDecl::DefinitionData &Data, 1079 const RecordData &Record, unsigned &Idx) { 1080 // Note: the caller has deserialized the IsLambda bit already. 1081 Data.UserDeclaredConstructor = Record[Idx++]; 1082 Data.UserDeclaredSpecialMembers = Record[Idx++]; 1083 Data.Aggregate = Record[Idx++]; 1084 Data.PlainOldData = Record[Idx++]; 1085 Data.Empty = Record[Idx++]; 1086 Data.Polymorphic = Record[Idx++]; 1087 Data.Abstract = Record[Idx++]; 1088 Data.IsStandardLayout = Record[Idx++]; 1089 Data.HasNoNonEmptyBases = Record[Idx++]; 1090 Data.HasPrivateFields = Record[Idx++]; 1091 Data.HasProtectedFields = Record[Idx++]; 1092 Data.HasPublicFields = Record[Idx++]; 1093 Data.HasMutableFields = Record[Idx++]; 1094 Data.HasOnlyCMembers = Record[Idx++]; 1095 Data.HasInClassInitializer = Record[Idx++]; 1096 Data.HasUninitializedReferenceMember = Record[Idx++]; 1097 Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++]; 1098 Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++]; 1099 Data.NeedOverloadResolutionForDestructor = Record[Idx++]; 1100 Data.DefaultedMoveConstructorIsDeleted = Record[Idx++]; 1101 Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++]; 1102 Data.DefaultedDestructorIsDeleted = Record[Idx++]; 1103 Data.HasTrivialSpecialMembers = Record[Idx++]; 1104 Data.HasIrrelevantDestructor = Record[Idx++]; 1105 Data.HasConstexprNonCopyMoveConstructor = Record[Idx++]; 1106 Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++]; 1107 Data.HasConstexprDefaultConstructor = Record[Idx++]; 1108 Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++]; 1109 Data.ComputedVisibleConversions = Record[Idx++]; 1110 Data.UserProvidedDefaultConstructor = Record[Idx++]; 1111 Data.DeclaredSpecialMembers = Record[Idx++]; 1112 Data.ImplicitCopyConstructorHasConstParam = Record[Idx++]; 1113 Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++]; 1114 Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++]; 1115 Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++]; 1116 Data.FailedImplicitMoveConstructor = Record[Idx++]; 1117 Data.FailedImplicitMoveAssignment = Record[Idx++]; 1118 1119 Data.NumBases = Record[Idx++]; 1120 if (Data.NumBases) 1121 Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx); 1122 Data.NumVBases = Record[Idx++]; 1123 if (Data.NumVBases) 1124 Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx); 1125 1126 Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx); 1127 Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx); 1128 assert(Data.Definition && "Data.Definition should be already set!"); 1129 Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx); 1130 1131 if (Data.IsLambda) { 1132 typedef LambdaExpr::Capture Capture; 1133 CXXRecordDecl::LambdaDefinitionData &Lambda 1134 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data); 1135 Lambda.Dependent = Record[Idx++]; 1136 Lambda.NumCaptures = Record[Idx++]; 1137 Lambda.NumExplicitCaptures = Record[Idx++]; 1138 Lambda.ManglingNumber = Record[Idx++]; 1139 Lambda.ContextDecl = ReadDecl(Record, Idx); 1140 Lambda.Captures 1141 = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures); 1142 Capture *ToCapture = Lambda.Captures; 1143 Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx); 1144 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) { 1145 SourceLocation Loc = ReadSourceLocation(Record, Idx); 1146 bool IsImplicit = Record[Idx++]; 1147 LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]); 1148 VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx); 1149 SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx); 1150 *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc); 1151 } 1152 } 1153} 1154 1155void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) { 1156 VisitRecordDecl(D); 1157 1158 ASTContext &C = Reader.getContext(); 1159 if (Record[Idx++]) { 1160 // Determine whether this is a lambda closure type, so that we can 1161 // allocate the appropriate DefinitionData structure. 1162 bool IsLambda = Record[Idx++]; 1163 if (IsLambda) 1164 D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, 0, 1165 false); 1166 else 1167 D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D); 1168 1169 // Propagate the DefinitionData pointer to the canonical declaration, so 1170 // that all other deserialized declarations will see it. 1171 // FIXME: Complain if there already is a DefinitionData! 1172 D->getCanonicalDecl()->DefinitionData = D->DefinitionData; 1173 1174 ReadCXXDefinitionData(*D->DefinitionData, Record, Idx); 1175 1176 // Note that we have deserialized a definition. Any declarations 1177 // deserialized before this one will be be given the DefinitionData pointer 1178 // at the end. 1179 Reader.PendingDefinitions.insert(D); 1180 } else { 1181 // Propagate DefinitionData pointer from the canonical declaration. 1182 D->DefinitionData = D->getCanonicalDecl()->DefinitionData; 1183 } 1184 1185 enum CXXRecKind { 1186 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization 1187 }; 1188 switch ((CXXRecKind)Record[Idx++]) { 1189 case CXXRecNotTemplate: 1190 break; 1191 case CXXRecTemplate: 1192 D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx); 1193 break; 1194 case CXXRecMemberSpecialization: { 1195 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx); 1196 TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++]; 1197 SourceLocation POI = ReadSourceLocation(Record, Idx); 1198 MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK); 1199 MSI->setPointOfInstantiation(POI); 1200 D->TemplateOrInstantiation = MSI; 1201 break; 1202 } 1203 } 1204 1205 // Load the key function to avoid deserializing every method so we can 1206 // compute it. 1207 if (D->IsCompleteDefinition) { 1208 if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx)) 1209 C.KeyFunctions[D] = Key; 1210 } 1211} 1212 1213void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) { 1214 VisitFunctionDecl(D); 1215 unsigned NumOverridenMethods = Record[Idx++]; 1216 while (NumOverridenMethods--) { 1217 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod, 1218 // MD may be initializing. 1219 if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx)) 1220 Reader.getContext().addOverriddenMethod(D, MD); 1221 } 1222} 1223 1224void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 1225 VisitCXXMethodDecl(D); 1226 1227 D->IsExplicitSpecified = Record[Idx++]; 1228 D->ImplicitlyDefined = Record[Idx++]; 1229 llvm::tie(D->CtorInitializers, D->NumCtorInitializers) 1230 = Reader.ReadCXXCtorInitializers(F, Record, Idx); 1231} 1232 1233void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 1234 VisitCXXMethodDecl(D); 1235 1236 D->ImplicitlyDefined = Record[Idx++]; 1237 D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx); 1238} 1239 1240void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) { 1241 VisitCXXMethodDecl(D); 1242 D->IsExplicitSpecified = Record[Idx++]; 1243} 1244 1245void ASTDeclReader::VisitImportDecl(ImportDecl *D) { 1246 VisitDecl(D); 1247 D->ImportedAndComplete.setPointer(readModule(Record, Idx)); 1248 D->ImportedAndComplete.setInt(Record[Idx++]); 1249 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1); 1250 for (unsigned I = 0, N = Record.back(); I != N; ++I) 1251 StoredLocs[I] = ReadSourceLocation(Record, Idx); 1252 ++Idx; // The number of stored source locations. 1253} 1254 1255void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) { 1256 VisitDecl(D); 1257 D->setColonLoc(ReadSourceLocation(Record, Idx)); 1258} 1259 1260void ASTDeclReader::VisitFriendDecl(FriendDecl *D) { 1261 VisitDecl(D); 1262 if (Record[Idx++]) // hasFriendDecl 1263 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx); 1264 else 1265 D->Friend = GetTypeSourceInfo(Record, Idx); 1266 for (unsigned i = 0; i != D->NumTPLists; ++i) 1267 D->getTPLists()[i] = Reader.ReadTemplateParameterList(F, Record, Idx); 1268 D->NextFriend = Record[Idx++]; 1269 D->UnsupportedFriend = (Record[Idx++] != 0); 1270 D->FriendLoc = ReadSourceLocation(Record, Idx); 1271} 1272 1273void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) { 1274 VisitDecl(D); 1275 unsigned NumParams = Record[Idx++]; 1276 D->NumParams = NumParams; 1277 D->Params = new TemplateParameterList*[NumParams]; 1278 for (unsigned i = 0; i != NumParams; ++i) 1279 D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx); 1280 if (Record[Idx++]) // HasFriendDecl 1281 D->Friend = ReadDeclAs<NamedDecl>(Record, Idx); 1282 else 1283 D->Friend = GetTypeSourceInfo(Record, Idx); 1284 D->FriendLoc = ReadSourceLocation(Record, Idx); 1285} 1286 1287void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) { 1288 VisitNamedDecl(D); 1289 1290 NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx); 1291 TemplateParameterList* TemplateParams 1292 = Reader.ReadTemplateParameterList(F, Record, Idx); 1293 D->init(TemplatedDecl, TemplateParams); 1294} 1295 1296ASTDeclReader::RedeclarableResult 1297ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { 1298 RedeclarableResult Redecl = VisitRedeclarable(D); 1299 1300 // Make sure we've allocated the Common pointer first. We do this before 1301 // VisitTemplateDecl so that getCommonPtr() can be used during initialization. 1302 RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl(); 1303 if (!CanonD->Common) { 1304 CanonD->Common = CanonD->newCommon(Reader.getContext()); 1305 Reader.PendingDefinitions.insert(CanonD); 1306 } 1307 D->Common = CanonD->Common; 1308 1309 // If this is the first declaration of the template, fill in the information 1310 // for the 'common' pointer. 1311 if (ThisDeclID == Redecl.getFirstID()) { 1312 if (RedeclarableTemplateDecl *RTD 1313 = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) { 1314 assert(RTD->getKind() == D->getKind() && 1315 "InstantiatedFromMemberTemplate kind mismatch"); 1316 D->setInstantiatedFromMemberTemplate(RTD); 1317 if (Record[Idx++]) 1318 D->setMemberSpecialization(); 1319 } 1320 } 1321 1322 VisitTemplateDecl(D); 1323 D->IdentifierNamespace = Record[Idx++]; 1324 1325 mergeRedeclarable(D, Redecl); 1326 1327 return Redecl; 1328} 1329 1330void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) { 1331 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D); 1332 1333 if (ThisDeclID == Redecl.getFirstID()) { 1334 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of 1335 // the specializations. 1336 SmallVector<serialization::DeclID, 2> SpecIDs; 1337 SpecIDs.push_back(0); 1338 1339 // Specializations. 1340 unsigned Size = Record[Idx++]; 1341 SpecIDs[0] += Size; 1342 for (unsigned I = 0; I != Size; ++I) 1343 SpecIDs.push_back(ReadDeclID(Record, Idx)); 1344 1345 // Partial specializations. 1346 Size = Record[Idx++]; 1347 SpecIDs[0] += Size; 1348 for (unsigned I = 0; I != Size; ++I) 1349 SpecIDs.push_back(ReadDeclID(Record, Idx)); 1350 1351 ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr(); 1352 if (SpecIDs[0]) { 1353 typedef serialization::DeclID DeclID; 1354 1355 // FIXME: Append specializations! 1356 CommonPtr->LazySpecializations 1357 = new (Reader.getContext()) DeclID [SpecIDs.size()]; 1358 memcpy(CommonPtr->LazySpecializations, SpecIDs.data(), 1359 SpecIDs.size() * sizeof(DeclID)); 1360 } 1361 1362 CommonPtr->InjectedClassNameType = Reader.readType(F, Record, Idx); 1363 } 1364} 1365 1366void ASTDeclReader::VisitClassTemplateSpecializationDecl( 1367 ClassTemplateSpecializationDecl *D) { 1368 VisitCXXRecordDecl(D); 1369 1370 ASTContext &C = Reader.getContext(); 1371 if (Decl *InstD = ReadDecl(Record, Idx)) { 1372 if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) { 1373 D->SpecializedTemplate = CTD; 1374 } else { 1375 SmallVector<TemplateArgument, 8> TemplArgs; 1376 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx); 1377 TemplateArgumentList *ArgList 1378 = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), 1379 TemplArgs.size()); 1380 ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS 1381 = new (C) ClassTemplateSpecializationDecl:: 1382 SpecializedPartialSpecialization(); 1383 PS->PartialSpecialization 1384 = cast<ClassTemplatePartialSpecializationDecl>(InstD); 1385 PS->TemplateArgs = ArgList; 1386 D->SpecializedTemplate = PS; 1387 } 1388 } 1389 1390 // Explicit info. 1391 if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) { 1392 ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo 1393 = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo; 1394 ExplicitInfo->TypeAsWritten = TyInfo; 1395 ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx); 1396 ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx); 1397 D->ExplicitInfo = ExplicitInfo; 1398 } 1399 1400 SmallVector<TemplateArgument, 8> TemplArgs; 1401 Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx); 1402 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), 1403 TemplArgs.size()); 1404 D->PointOfInstantiation = ReadSourceLocation(Record, Idx); 1405 D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++]; 1406 1407 bool writtenAsCanonicalDecl = Record[Idx++]; 1408 if (writtenAsCanonicalDecl) { 1409 ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx); 1410 if (D->isCanonicalDecl()) { // It's kept in the folding set. 1411 if (ClassTemplatePartialSpecializationDecl *Partial 1412 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) { 1413 CanonPattern->getCommonPtr()->PartialSpecializations.GetOrInsertNode(Partial); 1414 } else { 1415 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D); 1416 } 1417 } 1418 } 1419} 1420 1421void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl( 1422 ClassTemplatePartialSpecializationDecl *D) { 1423 VisitClassTemplateSpecializationDecl(D); 1424 1425 ASTContext &C = Reader.getContext(); 1426 D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx); 1427 1428 unsigned NumArgs = Record[Idx++]; 1429 if (NumArgs) { 1430 D->NumArgsAsWritten = NumArgs; 1431 D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs]; 1432 for (unsigned i=0; i != NumArgs; ++i) 1433 D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx); 1434 } 1435 1436 D->SequenceNumber = Record[Idx++]; 1437 1438 // These are read/set from/to the first declaration. 1439 if (D->getPreviousDecl() == 0) { 1440 D->InstantiatedFromMember.setPointer( 1441 ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx)); 1442 D->InstantiatedFromMember.setInt(Record[Idx++]); 1443 } 1444} 1445 1446void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl( 1447 ClassScopeFunctionSpecializationDecl *D) { 1448 VisitDecl(D); 1449 D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx); 1450} 1451 1452void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 1453 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D); 1454 1455 if (ThisDeclID == Redecl.getFirstID()) { 1456 // This FunctionTemplateDecl owns a CommonPtr; read it. 1457 1458 // Read the function specialization declarations. 1459 // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled 1460 // when reading the specialized FunctionDecl. 1461 unsigned NumSpecs = Record[Idx++]; 1462 while (NumSpecs--) 1463 (void)ReadDecl(Record, Idx); 1464 } 1465} 1466 1467void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 1468 VisitTypeDecl(D); 1469 1470 D->setDeclaredWithTypename(Record[Idx++]); 1471 1472 bool Inherited = Record[Idx++]; 1473 TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx); 1474 D->setDefaultArgument(DefArg, Inherited); 1475} 1476 1477void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 1478 VisitDeclaratorDecl(D); 1479 // TemplateParmPosition. 1480 D->setDepth(Record[Idx++]); 1481 D->setPosition(Record[Idx++]); 1482 if (D->isExpandedParameterPack()) { 1483 void **Data = reinterpret_cast<void **>(D + 1); 1484 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { 1485 Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr(); 1486 Data[2*I + 1] = GetTypeSourceInfo(Record, Idx); 1487 } 1488 } else { 1489 // Rest of NonTypeTemplateParmDecl. 1490 D->ParameterPack = Record[Idx++]; 1491 if (Record[Idx++]) { 1492 Expr *DefArg = Reader.ReadExpr(F); 1493 bool Inherited = Record[Idx++]; 1494 D->setDefaultArgument(DefArg, Inherited); 1495 } 1496 } 1497} 1498 1499void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 1500 VisitTemplateDecl(D); 1501 // TemplateParmPosition. 1502 D->setDepth(Record[Idx++]); 1503 D->setPosition(Record[Idx++]); 1504 if (D->isExpandedParameterPack()) { 1505 void **Data = reinterpret_cast<void **>(D + 1); 1506 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters(); 1507 I != N; ++I) 1508 Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx); 1509 } else { 1510 // Rest of TemplateTemplateParmDecl. 1511 TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx); 1512 bool IsInherited = Record[Idx++]; 1513 D->setDefaultArgument(Arg, IsInherited); 1514 D->ParameterPack = Record[Idx++]; 1515 } 1516} 1517 1518void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 1519 VisitRedeclarableTemplateDecl(D); 1520} 1521 1522void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) { 1523 VisitDecl(D); 1524 D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F)); 1525 D->AssertExprAndFailed.setInt(Record[Idx++]); 1526 D->Message = cast<StringLiteral>(Reader.ReadExpr(F)); 1527 D->RParenLoc = ReadSourceLocation(Record, Idx); 1528} 1529 1530void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) { 1531 VisitDecl(D); 1532} 1533 1534std::pair<uint64_t, uint64_t> 1535ASTDeclReader::VisitDeclContext(DeclContext *DC) { 1536 uint64_t LexicalOffset = Record[Idx++]; 1537 uint64_t VisibleOffset = Record[Idx++]; 1538 return std::make_pair(LexicalOffset, VisibleOffset); 1539} 1540 1541template <typename T> 1542ASTDeclReader::RedeclarableResult 1543ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) { 1544 DeclID FirstDeclID = ReadDeclID(Record, Idx); 1545 1546 // 0 indicates that this declaration was the only declaration of its entity, 1547 // and is used for space optimization. 1548 if (FirstDeclID == 0) 1549 FirstDeclID = ThisDeclID; 1550 1551 T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID)); 1552 if (FirstDecl != D) { 1553 // We delay loading of the redeclaration chain to avoid deeply nested calls. 1554 // We temporarily set the first (canonical) declaration as the previous one 1555 // which is the one that matters and mark the real previous DeclID to be 1556 // loaded & attached later on. 1557 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl); 1558 } 1559 1560 // Note that this declaration has been deserialized. 1561 Reader.RedeclsDeserialized.insert(static_cast<T *>(D)); 1562 1563 // The result structure takes care to note that we need to load the 1564 // other declaration chains for this ID. 1565 return RedeclarableResult(Reader, FirstDeclID, 1566 static_cast<T *>(D)->getKind()); 1567} 1568 1569/// \brief Attempts to merge the given declaration (D) with another declaration 1570/// of the same entity. 1571template<typename T> 1572void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D, 1573 RedeclarableResult &Redecl) { 1574 // If modules are not available, there is no reason to perform this merge. 1575 if (!Reader.getContext().getLangOpts().Modules) 1576 return; 1577 1578 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) { 1579 if (T *Existing = ExistingRes) { 1580 T *ExistingCanon = Existing->getCanonicalDecl(); 1581 T *DCanon = static_cast<T*>(D)->getCanonicalDecl(); 1582 if (ExistingCanon != DCanon) { 1583 // Have our redeclaration link point back at the canonical declaration 1584 // of the existing declaration, so that this declaration has the 1585 // appropriate canonical declaration. 1586 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon); 1587 1588 // When we merge a namespace, update its pointer to the first namespace. 1589 if (NamespaceDecl *Namespace 1590 = dyn_cast<NamespaceDecl>(static_cast<T*>(D))) { 1591 Namespace->AnonOrFirstNamespaceAndInline.setPointer( 1592 static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon))); 1593 } 1594 1595 // Don't introduce DCanon into the set of pending declaration chains. 1596 Redecl.suppress(); 1597 1598 // Introduce ExistingCanon into the set of pending declaration chains, 1599 // if in fact it came from a module file. 1600 if (ExistingCanon->isFromASTFile()) { 1601 GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID(); 1602 assert(ExistingCanonID && "Unrecorded canonical declaration ID?"); 1603 if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID)) 1604 Reader.PendingDeclChains.push_back(ExistingCanonID); 1605 } 1606 1607 // If this declaration was the canonical declaration, make a note of 1608 // that. We accept the linear algorithm here because the number of 1609 // unique canonical declarations of an entity should always be tiny. 1610 if (DCanon == static_cast<T*>(D)) { 1611 SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon]; 1612 if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID()) 1613 == Merged.end()) 1614 Merged.push_back(Redecl.getFirstID()); 1615 1616 // If ExistingCanon did not come from a module file, introduce the 1617 // first declaration that *does* come from a module file to the 1618 // set of pending declaration chains, so that we merge this 1619 // declaration. 1620 if (!ExistingCanon->isFromASTFile() && 1621 Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID())) 1622 Reader.PendingDeclChains.push_back(Merged[0]); 1623 } 1624 } 1625 } 1626 } 1627} 1628 1629//===----------------------------------------------------------------------===// 1630// Attribute Reading 1631//===----------------------------------------------------------------------===// 1632 1633/// \brief Reads attributes from the current stream position. 1634void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs, 1635 const RecordData &Record, unsigned &Idx) { 1636 for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) { 1637 Attr *New = 0; 1638 attr::Kind Kind = (attr::Kind)Record[Idx++]; 1639 SourceRange Range = ReadSourceRange(F, Record, Idx); 1640 1641#include "clang/Serialization/AttrPCHRead.inc" 1642 1643 assert(New && "Unable to decode attribute?"); 1644 Attrs.push_back(New); 1645 } 1646} 1647 1648//===----------------------------------------------------------------------===// 1649// ASTReader Implementation 1650//===----------------------------------------------------------------------===// 1651 1652/// \brief Note that we have loaded the declaration with the given 1653/// Index. 1654/// 1655/// This routine notes that this declaration has already been loaded, 1656/// so that future GetDecl calls will return this declaration rather 1657/// than trying to load a new declaration. 1658inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) { 1659 assert(!DeclsLoaded[Index] && "Decl loaded twice?"); 1660 DeclsLoaded[Index] = D; 1661} 1662 1663 1664/// \brief Determine whether the consumer will be interested in seeing 1665/// this declaration (via HandleTopLevelDecl). 1666/// 1667/// This routine should return true for anything that might affect 1668/// code generation, e.g., inline function definitions, Objective-C 1669/// declarations with metadata, etc. 1670static bool isConsumerInterestedIn(Decl *D, bool HasBody) { 1671 // An ObjCMethodDecl is never considered as "interesting" because its 1672 // implementation container always is. 1673 1674 if (isa<FileScopeAsmDecl>(D) || 1675 isa<ObjCProtocolDecl>(D) || 1676 isa<ObjCImplDecl>(D)) 1677 return true; 1678 if (VarDecl *Var = dyn_cast<VarDecl>(D)) 1679 return Var->isFileVarDecl() && 1680 Var->isThisDeclarationADefinition() == VarDecl::Definition; 1681 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D)) 1682 return Func->doesThisDeclarationHaveABody() || HasBody; 1683 1684 return false; 1685} 1686 1687/// \brief Get the correct cursor and offset for loading a declaration. 1688ASTReader::RecordLocation 1689ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) { 1690 // See if there's an override. 1691 DeclReplacementMap::iterator It = ReplacedDecls.find(ID); 1692 if (It != ReplacedDecls.end()) { 1693 RawLocation = It->second.RawLoc; 1694 return RecordLocation(It->second.Mod, It->second.Offset); 1695 } 1696 1697 GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID); 1698 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 1699 ModuleFile *M = I->second; 1700 const DeclOffset & 1701 DOffs = M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS]; 1702 RawLocation = DOffs.Loc; 1703 return RecordLocation(M, DOffs.BitOffset); 1704} 1705 1706ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) { 1707 ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I 1708 = GlobalBitOffsetsMap.find(GlobalOffset); 1709 1710 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map"); 1711 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset); 1712} 1713 1714uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) { 1715 return LocalOffset + M.GlobalBitOffset; 1716} 1717 1718/// \brief Determine whether the two declarations refer to the same entity. 1719static bool isSameEntity(NamedDecl *X, NamedDecl *Y) { 1720 assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!"); 1721 1722 if (X == Y) 1723 return true; 1724 1725 // Must be in the same context. 1726 if (!X->getDeclContext()->getRedeclContext()->Equals( 1727 Y->getDeclContext()->getRedeclContext())) 1728 return false; 1729 1730 // Two typedefs refer to the same entity if they have the same underlying 1731 // type. 1732 if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X)) 1733 if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y)) 1734 return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(), 1735 TypedefY->getUnderlyingType()); 1736 1737 // Must have the same kind. 1738 if (X->getKind() != Y->getKind()) 1739 return false; 1740 1741 // Objective-C classes and protocols with the same name always match. 1742 if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X)) 1743 return true; 1744 1745 // Compatible tags match. 1746 if (TagDecl *TagX = dyn_cast<TagDecl>(X)) { 1747 TagDecl *TagY = cast<TagDecl>(Y); 1748 return (TagX->getTagKind() == TagY->getTagKind()) || 1749 ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class || 1750 TagX->getTagKind() == TTK_Interface) && 1751 (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class || 1752 TagY->getTagKind() == TTK_Interface)); 1753 } 1754 1755 // Functions with the same type and linkage match. 1756 // FIXME: This needs to cope with function templates, merging of 1757 //prototyped/non-prototyped functions, etc. 1758 if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) { 1759 FunctionDecl *FuncY = cast<FunctionDecl>(Y); 1760 return (FuncX->getLinkage() == FuncY->getLinkage()) && 1761 FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType()); 1762 } 1763 1764 // Variables with the same type and linkage match. 1765 if (VarDecl *VarX = dyn_cast<VarDecl>(X)) { 1766 VarDecl *VarY = cast<VarDecl>(Y); 1767 return (VarX->getLinkage() == VarY->getLinkage()) && 1768 VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType()); 1769 } 1770 1771 // Namespaces with the same name and inlinedness match. 1772 if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) { 1773 NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y); 1774 return NamespaceX->isInline() == NamespaceY->isInline(); 1775 } 1776 1777 // Identical template names and kinds match. 1778 if (isa<TemplateDecl>(X)) 1779 return true; 1780 1781 // FIXME: Many other cases to implement. 1782 return false; 1783} 1784 1785ASTDeclReader::FindExistingResult::~FindExistingResult() { 1786 if (!AddResult || Existing) 1787 return; 1788 1789 if (New->getDeclContext()->getRedeclContext()->isTranslationUnit() 1790 && Reader.SemaObj) { 1791 Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName()); 1792 } else { 1793 DeclContext *DC = New->getLexicalDeclContext(); 1794 if (DC->isNamespace()) 1795 DC->addDecl(New); 1796 } 1797} 1798 1799ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) { 1800 DeclarationName Name = D->getDeclName(); 1801 if (!Name) { 1802 // Don't bother trying to find unnamed declarations. 1803 FindExistingResult Result(Reader, D, /*Existing=*/0); 1804 Result.suppress(); 1805 return Result; 1806 } 1807 1808 DeclContext *DC = D->getDeclContext()->getRedeclContext(); 1809 if (!DC->isFileContext()) 1810 return FindExistingResult(Reader); 1811 1812 if (DC->isTranslationUnit() && Reader.SemaObj) { 1813 IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver; 1814 1815 // Temporarily consider the identifier to be up-to-date. We don't want to 1816 // cause additional lookups here. 1817 class UpToDateIdentifierRAII { 1818 IdentifierInfo *II; 1819 bool WasOutToDate; 1820 1821 public: 1822 explicit UpToDateIdentifierRAII(IdentifierInfo *II) 1823 : II(II), WasOutToDate(false) 1824 { 1825 if (II) { 1826 WasOutToDate = II->isOutOfDate(); 1827 if (WasOutToDate) 1828 II->setOutOfDate(false); 1829 } 1830 } 1831 1832 ~UpToDateIdentifierRAII() { 1833 if (WasOutToDate) 1834 II->setOutOfDate(true); 1835 } 1836 } UpToDate(Name.getAsIdentifierInfo()); 1837 1838 for (IdentifierResolver::iterator I = IdResolver.begin(Name), 1839 IEnd = IdResolver.end(); 1840 I != IEnd; ++I) { 1841 if (isSameEntity(*I, D)) 1842 return FindExistingResult(Reader, D, *I); 1843 } 1844 } 1845 1846 if (DC->isNamespace()) { 1847 DeclContext::lookup_result R = DC->lookup(Name); 1848 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; 1849 ++I) { 1850 if (isSameEntity(*I, D)) 1851 return FindExistingResult(Reader, D, *I); 1852 } 1853 } 1854 1855 return FindExistingResult(Reader, D, /*Existing=*/0); 1856} 1857 1858void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) { 1859 assert(D && previous); 1860 if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 1861 TD->RedeclLink.setNext(cast<TagDecl>(previous)); 1862 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1863 FD->RedeclLink.setNext(cast<FunctionDecl>(previous)); 1864 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 1865 VD->RedeclLink.setNext(cast<VarDecl>(previous)); 1866 } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 1867 TD->RedeclLink.setNext(cast<TypedefNameDecl>(previous)); 1868 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 1869 ID->RedeclLink.setNext(cast<ObjCInterfaceDecl>(previous)); 1870 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { 1871 PD->RedeclLink.setNext(cast<ObjCProtocolDecl>(previous)); 1872 } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) { 1873 ND->RedeclLink.setNext(cast<NamespaceDecl>(previous)); 1874 } else { 1875 RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D); 1876 TD->RedeclLink.setNext(cast<RedeclarableTemplateDecl>(previous)); 1877 } 1878} 1879 1880void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) { 1881 assert(D && Latest); 1882 if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 1883 TD->RedeclLink 1884 = Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest)); 1885 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1886 FD->RedeclLink 1887 = Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest)); 1888 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 1889 VD->RedeclLink 1890 = Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest)); 1891 } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 1892 TD->RedeclLink 1893 = Redeclarable<TypedefNameDecl>::LatestDeclLink( 1894 cast<TypedefNameDecl>(Latest)); 1895 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 1896 ID->RedeclLink 1897 = Redeclarable<ObjCInterfaceDecl>::LatestDeclLink( 1898 cast<ObjCInterfaceDecl>(Latest)); 1899 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { 1900 PD->RedeclLink 1901 = Redeclarable<ObjCProtocolDecl>::LatestDeclLink( 1902 cast<ObjCProtocolDecl>(Latest)); 1903 } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) { 1904 ND->RedeclLink 1905 = Redeclarable<NamespaceDecl>::LatestDeclLink( 1906 cast<NamespaceDecl>(Latest)); 1907 } else { 1908 RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D); 1909 TD->RedeclLink 1910 = Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink( 1911 cast<RedeclarableTemplateDecl>(Latest)); 1912 } 1913} 1914 1915ASTReader::MergedDeclsMap::iterator 1916ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) { 1917 // If we don't have any stored merged declarations, just look in the 1918 // merged declarations set. 1919 StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID); 1920 if (StoredPos == StoredMergedDecls.end()) 1921 return MergedDecls.find(Canon); 1922 1923 // Append the stored merged declarations to the merged declarations set. 1924 MergedDeclsMap::iterator Pos = MergedDecls.find(Canon); 1925 if (Pos == MergedDecls.end()) 1926 Pos = MergedDecls.insert(std::make_pair(Canon, 1927 SmallVector<DeclID, 2>())).first; 1928 Pos->second.append(StoredPos->second.begin(), StoredPos->second.end()); 1929 StoredMergedDecls.erase(StoredPos); 1930 1931 // Sort and uniquify the set of merged declarations. 1932 llvm::array_pod_sort(Pos->second.begin(), Pos->second.end()); 1933 Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()), 1934 Pos->second.end()); 1935 return Pos; 1936} 1937 1938void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) { 1939 Decl *previous = GetDecl(ID); 1940 ASTDeclReader::attachPreviousDecl(D, previous); 1941} 1942 1943/// \brief Read the declaration at the given offset from the AST file. 1944Decl *ASTReader::ReadDeclRecord(DeclID ID) { 1945 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 1946 unsigned RawLocation = 0; 1947 RecordLocation Loc = DeclCursorForID(ID, RawLocation); 1948 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 1949 // Keep track of where we are in the stream, then jump back there 1950 // after reading this declaration. 1951 SavedStreamPosition SavedPosition(DeclsCursor); 1952 1953 ReadingKindTracker ReadingKind(Read_Decl, *this); 1954 1955 // Note that we are loading a declaration record. 1956 Deserializing ADecl(this); 1957 1958 DeclsCursor.JumpToBit(Loc.Offset); 1959 RecordData Record; 1960 unsigned Code = DeclsCursor.ReadCode(); 1961 unsigned Idx = 0; 1962 ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx); 1963 1964 Decl *D = 0; 1965 switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) { 1966 case DECL_CONTEXT_LEXICAL: 1967 case DECL_CONTEXT_VISIBLE: 1968 llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord"); 1969 case DECL_TYPEDEF: 1970 D = TypedefDecl::CreateDeserialized(Context, ID); 1971 break; 1972 case DECL_TYPEALIAS: 1973 D = TypeAliasDecl::CreateDeserialized(Context, ID); 1974 break; 1975 case DECL_ENUM: 1976 D = EnumDecl::CreateDeserialized(Context, ID); 1977 break; 1978 case DECL_RECORD: 1979 D = RecordDecl::CreateDeserialized(Context, ID); 1980 break; 1981 case DECL_ENUM_CONSTANT: 1982 D = EnumConstantDecl::CreateDeserialized(Context, ID); 1983 break; 1984 case DECL_FUNCTION: 1985 D = FunctionDecl::CreateDeserialized(Context, ID); 1986 break; 1987 case DECL_LINKAGE_SPEC: 1988 D = LinkageSpecDecl::CreateDeserialized(Context, ID); 1989 break; 1990 case DECL_LABEL: 1991 D = LabelDecl::CreateDeserialized(Context, ID); 1992 break; 1993 case DECL_NAMESPACE: 1994 D = NamespaceDecl::CreateDeserialized(Context, ID); 1995 break; 1996 case DECL_NAMESPACE_ALIAS: 1997 D = NamespaceAliasDecl::CreateDeserialized(Context, ID); 1998 break; 1999 case DECL_USING: 2000 D = UsingDecl::CreateDeserialized(Context, ID); 2001 break; 2002 case DECL_USING_SHADOW: 2003 D = UsingShadowDecl::CreateDeserialized(Context, ID); 2004 break; 2005 case DECL_USING_DIRECTIVE: 2006 D = UsingDirectiveDecl::CreateDeserialized(Context, ID); 2007 break; 2008 case DECL_UNRESOLVED_USING_VALUE: 2009 D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID); 2010 break; 2011 case DECL_UNRESOLVED_USING_TYPENAME: 2012 D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID); 2013 break; 2014 case DECL_CXX_RECORD: 2015 D = CXXRecordDecl::CreateDeserialized(Context, ID); 2016 break; 2017 case DECL_CXX_METHOD: 2018 D = CXXMethodDecl::CreateDeserialized(Context, ID); 2019 break; 2020 case DECL_CXX_CONSTRUCTOR: 2021 D = CXXConstructorDecl::CreateDeserialized(Context, ID); 2022 break; 2023 case DECL_CXX_DESTRUCTOR: 2024 D = CXXDestructorDecl::CreateDeserialized(Context, ID); 2025 break; 2026 case DECL_CXX_CONVERSION: 2027 D = CXXConversionDecl::CreateDeserialized(Context, ID); 2028 break; 2029 case DECL_ACCESS_SPEC: 2030 D = AccessSpecDecl::CreateDeserialized(Context, ID); 2031 break; 2032 case DECL_FRIEND: 2033 D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]); 2034 break; 2035 case DECL_FRIEND_TEMPLATE: 2036 D = FriendTemplateDecl::CreateDeserialized(Context, ID); 2037 break; 2038 case DECL_CLASS_TEMPLATE: 2039 D = ClassTemplateDecl::CreateDeserialized(Context, ID); 2040 break; 2041 case DECL_CLASS_TEMPLATE_SPECIALIZATION: 2042 D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID); 2043 break; 2044 case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION: 2045 D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID); 2046 break; 2047 case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION: 2048 D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID); 2049 break; 2050 case DECL_FUNCTION_TEMPLATE: 2051 D = FunctionTemplateDecl::CreateDeserialized(Context, ID); 2052 break; 2053 case DECL_TEMPLATE_TYPE_PARM: 2054 D = TemplateTypeParmDecl::CreateDeserialized(Context, ID); 2055 break; 2056 case DECL_NON_TYPE_TEMPLATE_PARM: 2057 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID); 2058 break; 2059 case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK: 2060 D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]); 2061 break; 2062 case DECL_TEMPLATE_TEMPLATE_PARM: 2063 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID); 2064 break; 2065 case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK: 2066 D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID, 2067 Record[Idx++]); 2068 break; 2069 case DECL_TYPE_ALIAS_TEMPLATE: 2070 D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID); 2071 break; 2072 case DECL_STATIC_ASSERT: 2073 D = StaticAssertDecl::CreateDeserialized(Context, ID); 2074 break; 2075 case DECL_OBJC_METHOD: 2076 D = ObjCMethodDecl::CreateDeserialized(Context, ID); 2077 break; 2078 case DECL_OBJC_INTERFACE: 2079 D = ObjCInterfaceDecl::CreateDeserialized(Context, ID); 2080 break; 2081 case DECL_OBJC_IVAR: 2082 D = ObjCIvarDecl::CreateDeserialized(Context, ID); 2083 break; 2084 case DECL_OBJC_PROTOCOL: 2085 D = ObjCProtocolDecl::CreateDeserialized(Context, ID); 2086 break; 2087 case DECL_OBJC_AT_DEFS_FIELD: 2088 D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID); 2089 break; 2090 case DECL_OBJC_CATEGORY: 2091 D = ObjCCategoryDecl::CreateDeserialized(Context, ID); 2092 break; 2093 case DECL_OBJC_CATEGORY_IMPL: 2094 D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID); 2095 break; 2096 case DECL_OBJC_IMPLEMENTATION: 2097 D = ObjCImplementationDecl::CreateDeserialized(Context, ID); 2098 break; 2099 case DECL_OBJC_COMPATIBLE_ALIAS: 2100 D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID); 2101 break; 2102 case DECL_OBJC_PROPERTY: 2103 D = ObjCPropertyDecl::CreateDeserialized(Context, ID); 2104 break; 2105 case DECL_OBJC_PROPERTY_IMPL: 2106 D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID); 2107 break; 2108 case DECL_FIELD: 2109 D = FieldDecl::CreateDeserialized(Context, ID); 2110 break; 2111 case DECL_INDIRECTFIELD: 2112 D = IndirectFieldDecl::CreateDeserialized(Context, ID); 2113 break; 2114 case DECL_VAR: 2115 D = VarDecl::CreateDeserialized(Context, ID); 2116 break; 2117 case DECL_IMPLICIT_PARAM: 2118 D = ImplicitParamDecl::CreateDeserialized(Context, ID); 2119 break; 2120 case DECL_PARM_VAR: 2121 D = ParmVarDecl::CreateDeserialized(Context, ID); 2122 break; 2123 case DECL_FILE_SCOPE_ASM: 2124 D = FileScopeAsmDecl::CreateDeserialized(Context, ID); 2125 break; 2126 case DECL_BLOCK: 2127 D = BlockDecl::CreateDeserialized(Context, ID); 2128 break; 2129 case DECL_CXX_BASE_SPECIFIERS: 2130 Error("attempt to read a C++ base-specifier record as a declaration"); 2131 return 0; 2132 case DECL_IMPORT: 2133 // Note: last entry of the ImportDecl record is the number of stored source 2134 // locations. 2135 D = ImportDecl::CreateDeserialized(Context, ID, Record.back()); 2136 break; 2137 case DECL_EMPTY: 2138 D = EmptyDecl::CreateDeserialized(Context, ID); 2139 break; 2140 } 2141 2142 assert(D && "Unknown declaration reading AST file"); 2143 LoadedDecl(Index, D); 2144 // Set the DeclContext before doing any deserialization, to make sure internal 2145 // calls to Decl::getASTContext() by Decl's methods will find the 2146 // TranslationUnitDecl without crashing. 2147 D->setDeclContext(Context.getTranslationUnitDecl()); 2148 Reader.Visit(D); 2149 2150 // If this declaration is also a declaration context, get the 2151 // offsets for its tables of lexical and visible declarations. 2152 if (DeclContext *DC = dyn_cast<DeclContext>(D)) { 2153 // FIXME: This should really be 2154 // DeclContext *LookupDC = DC->getPrimaryContext(); 2155 // but that can walk the redeclaration chain, which might not work yet. 2156 DeclContext *LookupDC = DC; 2157 if (isa<NamespaceDecl>(DC)) 2158 LookupDC = DC->getPrimaryContext(); 2159 std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC); 2160 if (Offsets.first || Offsets.second) { 2161 if (Offsets.first != 0) 2162 DC->setHasExternalLexicalStorage(true); 2163 if (Offsets.second != 0) 2164 LookupDC->setHasExternalVisibleStorage(true); 2165 if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets, 2166 Loc.F->DeclContextInfos[DC])) 2167 return 0; 2168 } 2169 2170 // Now add the pending visible updates for this decl context, if it has any. 2171 DeclContextVisibleUpdatesPending::iterator I = 2172 PendingVisibleUpdates.find(ID); 2173 if (I != PendingVisibleUpdates.end()) { 2174 // There are updates. This means the context has external visible 2175 // storage, even if the original stored version didn't. 2176 LookupDC->setHasExternalVisibleStorage(true); 2177 DeclContextVisibleUpdates &U = I->second; 2178 for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end(); 2179 UI != UE; ++UI) { 2180 DeclContextInfo &Info = UI->second->DeclContextInfos[DC]; 2181 delete Info.NameLookupTableData; 2182 Info.NameLookupTableData = UI->first; 2183 } 2184 PendingVisibleUpdates.erase(I); 2185 } 2186 2187 if (!LookupDC->hasExternalVisibleStorage() && 2188 DC->hasExternalLexicalStorage()) 2189 LookupDC->setMustBuildLookupTable(); 2190 } 2191 assert(Idx == Record.size()); 2192 2193 // Load any relevant update records. 2194 loadDeclUpdateRecords(ID, D); 2195 2196 // Load the categories after recursive loading is finished. 2197 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D)) 2198 if (Class->isThisDeclarationADefinition()) 2199 loadObjCCategories(ID, Class); 2200 2201 // If we have deserialized a declaration that has a definition the 2202 // AST consumer might need to know about, queue it. 2203 // We don't pass it to the consumer immediately because we may be in recursive 2204 // loading, and some declarations may still be initializing. 2205 if (isConsumerInterestedIn(D, Reader.hasPendingBody())) 2206 InterestingDecls.push_back(D); 2207 2208 return D; 2209} 2210 2211void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) { 2212 // The declaration may have been modified by files later in the chain. 2213 // If this is the case, read the record containing the updates from each file 2214 // and pass it to ASTDeclReader to make the modifications. 2215 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID); 2216 if (UpdI != DeclUpdateOffsets.end()) { 2217 FileOffsetsTy &UpdateOffsets = UpdI->second; 2218 for (FileOffsetsTy::iterator 2219 I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) { 2220 ModuleFile *F = I->first; 2221 uint64_t Offset = I->second; 2222 llvm::BitstreamCursor &Cursor = F->DeclsCursor; 2223 SavedStreamPosition SavedPosition(Cursor); 2224 Cursor.JumpToBit(Offset); 2225 RecordData Record; 2226 unsigned Code = Cursor.ReadCode(); 2227 unsigned RecCode = Cursor.readRecord(Code, Record); 2228 (void)RecCode; 2229 assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!"); 2230 2231 unsigned Idx = 0; 2232 ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx); 2233 Reader.UpdateDecl(D, *F, Record); 2234 } 2235 } 2236} 2237 2238namespace { 2239 struct CompareLocalRedeclarationsInfoToID { 2240 bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) { 2241 return X.FirstID < Y; 2242 } 2243 2244 bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) { 2245 return X < Y.FirstID; 2246 } 2247 2248 bool operator()(const LocalRedeclarationsInfo &X, 2249 const LocalRedeclarationsInfo &Y) { 2250 return X.FirstID < Y.FirstID; 2251 } 2252 bool operator()(DeclID X, DeclID Y) { 2253 return X < Y; 2254 } 2255 }; 2256 2257 /// \brief Module visitor class that finds all of the redeclarations of a 2258 /// 2259 class RedeclChainVisitor { 2260 ASTReader &Reader; 2261 SmallVectorImpl<DeclID> &SearchDecls; 2262 llvm::SmallPtrSet<Decl *, 16> &Deserialized; 2263 GlobalDeclID CanonID; 2264 SmallVector<Decl *, 4> Chain; 2265 2266 public: 2267 RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls, 2268 llvm::SmallPtrSet<Decl *, 16> &Deserialized, 2269 GlobalDeclID CanonID) 2270 : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized), 2271 CanonID(CanonID) { 2272 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I) 2273 addToChain(Reader.GetDecl(SearchDecls[I])); 2274 } 2275 2276 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 2277 if (Preorder) 2278 return false; 2279 2280 return static_cast<RedeclChainVisitor *>(UserData)->visit(M); 2281 } 2282 2283 void addToChain(Decl *D) { 2284 if (!D) 2285 return; 2286 2287 if (Deserialized.erase(D)) 2288 Chain.push_back(D); 2289 } 2290 2291 void searchForID(ModuleFile &M, GlobalDeclID GlobalID) { 2292 // Map global ID of the first declaration down to the local ID 2293 // used in this module file. 2294 DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID); 2295 if (!ID) 2296 return; 2297 2298 // Perform a binary search to find the local redeclarations for this 2299 // declaration (if any). 2300 const LocalRedeclarationsInfo *Result 2301 = std::lower_bound(M.RedeclarationsMap, 2302 M.RedeclarationsMap + M.LocalNumRedeclarationsInMap, 2303 ID, CompareLocalRedeclarationsInfoToID()); 2304 if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap || 2305 Result->FirstID != ID) { 2306 // If we have a previously-canonical singleton declaration that was 2307 // merged into another redeclaration chain, create a trivial chain 2308 // for this single declaration so that it will get wired into the 2309 // complete redeclaration chain. 2310 if (GlobalID != CanonID && 2311 GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID && 2312 GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) { 2313 addToChain(Reader.GetDecl(GlobalID)); 2314 } 2315 2316 return; 2317 } 2318 2319 // Dig out all of the redeclarations. 2320 unsigned Offset = Result->Offset; 2321 unsigned N = M.RedeclarationChains[Offset]; 2322 M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again 2323 for (unsigned I = 0; I != N; ++I) 2324 addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++])); 2325 } 2326 2327 bool visit(ModuleFile &M) { 2328 // Visit each of the declarations. 2329 for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I) 2330 searchForID(M, SearchDecls[I]); 2331 return false; 2332 } 2333 2334 ArrayRef<Decl *> getChain() const { 2335 return Chain; 2336 } 2337 }; 2338} 2339 2340void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) { 2341 Decl *D = GetDecl(ID); 2342 Decl *CanonDecl = D->getCanonicalDecl(); 2343 2344 // Determine the set of declaration IDs we'll be searching for. 2345 SmallVector<DeclID, 1> SearchDecls; 2346 GlobalDeclID CanonID = 0; 2347 if (D == CanonDecl) { 2348 SearchDecls.push_back(ID); // Always first. 2349 CanonID = ID; 2350 } 2351 MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID); 2352 if (MergedPos != MergedDecls.end()) 2353 SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end()); 2354 2355 // Build up the list of redeclarations. 2356 RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID); 2357 ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor); 2358 2359 // Retrieve the chains. 2360 ArrayRef<Decl *> Chain = Visitor.getChain(); 2361 if (Chain.empty()) 2362 return; 2363 2364 // Hook up the chains. 2365 Decl *MostRecent = CanonDecl->getMostRecentDecl(); 2366 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2367 if (Chain[I] == CanonDecl) 2368 continue; 2369 2370 ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent); 2371 MostRecent = Chain[I]; 2372 } 2373 2374 ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent); 2375} 2376 2377namespace { 2378 struct CompareObjCCategoriesInfo { 2379 bool operator()(const ObjCCategoriesInfo &X, DeclID Y) { 2380 return X.DefinitionID < Y; 2381 } 2382 2383 bool operator()(DeclID X, const ObjCCategoriesInfo &Y) { 2384 return X < Y.DefinitionID; 2385 } 2386 2387 bool operator()(const ObjCCategoriesInfo &X, 2388 const ObjCCategoriesInfo &Y) { 2389 return X.DefinitionID < Y.DefinitionID; 2390 } 2391 bool operator()(DeclID X, DeclID Y) { 2392 return X < Y; 2393 } 2394 }; 2395 2396 /// \brief Given an ObjC interface, goes through the modules and links to the 2397 /// interface all the categories for it. 2398 class ObjCCategoriesVisitor { 2399 ASTReader &Reader; 2400 serialization::GlobalDeclID InterfaceID; 2401 ObjCInterfaceDecl *Interface; 2402 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized; 2403 unsigned PreviousGeneration; 2404 ObjCCategoryDecl *Tail; 2405 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap; 2406 2407 void add(ObjCCategoryDecl *Cat) { 2408 // Only process each category once. 2409 if (!Deserialized.erase(Cat)) 2410 return; 2411 2412 // Check for duplicate categories. 2413 if (Cat->getDeclName()) { 2414 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()]; 2415 if (Existing && 2416 Reader.getOwningModuleFile(Existing) 2417 != Reader.getOwningModuleFile(Cat)) { 2418 // FIXME: We should not warn for duplicates in diamond: 2419 // 2420 // MT // 2421 // / \ // 2422 // ML MR // 2423 // \ / // 2424 // MB // 2425 // 2426 // If there are duplicates in ML/MR, there will be warning when 2427 // creating MB *and* when importing MB. We should not warn when 2428 // importing. 2429 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def) 2430 << Interface->getDeclName() << Cat->getDeclName(); 2431 Reader.Diag(Existing->getLocation(), diag::note_previous_definition); 2432 } else if (!Existing) { 2433 // Record this category. 2434 Existing = Cat; 2435 } 2436 } 2437 2438 // Add this category to the end of the chain. 2439 if (Tail) 2440 ASTDeclReader::setNextObjCCategory(Tail, Cat); 2441 else 2442 Interface->setCategoryListRaw(Cat); 2443 Tail = Cat; 2444 } 2445 2446 public: 2447 ObjCCategoriesVisitor(ASTReader &Reader, 2448 serialization::GlobalDeclID InterfaceID, 2449 ObjCInterfaceDecl *Interface, 2450 llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized, 2451 unsigned PreviousGeneration) 2452 : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface), 2453 Deserialized(Deserialized), PreviousGeneration(PreviousGeneration), 2454 Tail(0) 2455 { 2456 // Populate the name -> category map with the set of known categories. 2457 for (ObjCInterfaceDecl::known_categories_iterator 2458 Cat = Interface->known_categories_begin(), 2459 CatEnd = Interface->known_categories_end(); 2460 Cat != CatEnd; ++Cat) { 2461 if (Cat->getDeclName()) 2462 NameCategoryMap[Cat->getDeclName()] = *Cat; 2463 2464 // Keep track of the tail of the category list. 2465 Tail = *Cat; 2466 } 2467 } 2468 2469 static bool visit(ModuleFile &M, void *UserData) { 2470 return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M); 2471 } 2472 2473 bool visit(ModuleFile &M) { 2474 // If we've loaded all of the category information we care about from 2475 // this module file, we're done. 2476 if (M.Generation <= PreviousGeneration) 2477 return true; 2478 2479 // Map global ID of the definition down to the local ID used in this 2480 // module file. If there is no such mapping, we'll find nothing here 2481 // (or in any module it imports). 2482 DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID); 2483 if (!LocalID) 2484 return true; 2485 2486 // Perform a binary search to find the local redeclarations for this 2487 // declaration (if any). 2488 const ObjCCategoriesInfo *Result 2489 = std::lower_bound(M.ObjCCategoriesMap, 2490 M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap, 2491 LocalID, CompareObjCCategoriesInfo()); 2492 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap || 2493 Result->DefinitionID != LocalID) { 2494 // We didn't find anything. If the class definition is in this module 2495 // file, then the module files it depends on cannot have any categories, 2496 // so suppress further lookup. 2497 return Reader.isDeclIDFromModule(InterfaceID, M); 2498 } 2499 2500 // We found something. Dig out all of the categories. 2501 unsigned Offset = Result->Offset; 2502 unsigned N = M.ObjCCategories[Offset]; 2503 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again 2504 for (unsigned I = 0; I != N; ++I) 2505 add(cast_or_null<ObjCCategoryDecl>( 2506 Reader.GetLocalDecl(M, M.ObjCCategories[Offset++]))); 2507 return true; 2508 } 2509 }; 2510} 2511 2512void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID, 2513 ObjCInterfaceDecl *D, 2514 unsigned PreviousGeneration) { 2515 ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized, 2516 PreviousGeneration); 2517 ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor); 2518} 2519 2520void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile, 2521 const RecordData &Record) { 2522 unsigned Idx = 0; 2523 while (Idx < Record.size()) { 2524 switch ((DeclUpdateKind)Record[Idx++]) { 2525 case UPD_CXX_ADDED_IMPLICIT_MEMBER: 2526 cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx)); 2527 break; 2528 2529 case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION: 2530 // It will be added to the template's specializations set when loaded. 2531 (void)Reader.ReadDecl(ModuleFile, Record, Idx); 2532 break; 2533 2534 case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: { 2535 NamespaceDecl *Anon 2536 = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx); 2537 2538 // Each module has its own anonymous namespace, which is disjoint from 2539 // any other module's anonymous namespaces, so don't attach the anonymous 2540 // namespace at all. 2541 if (ModuleFile.Kind != MK_Module) { 2542 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D)) 2543 TU->setAnonymousNamespace(Anon); 2544 else 2545 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon); 2546 } 2547 break; 2548 } 2549 2550 case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER: 2551 cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation( 2552 Reader.ReadSourceLocation(ModuleFile, Record, Idx)); 2553 break; 2554 } 2555 } 2556} 2557