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