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