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