ASTReader.cpp revision baa74bd3968028d8e5b10ee9b50d0dceb41e85a9
1//===--- ASTReader.cpp - AST File Reader ----------------------------------===// 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 defines the ASTReader class, which reads AST files. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Serialization/ASTReader.h" 15#include "ASTCommon.h" 16#include "ASTReaderInternals.h" 17#include "clang/AST/ASTConsumer.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/Expr.h" 21#include "clang/AST/ExprCXX.h" 22#include "clang/AST/NestedNameSpecifier.h" 23#include "clang/AST/Type.h" 24#include "clang/AST/TypeLocVisitor.h" 25#include "clang/Basic/FileManager.h" 26#include "clang/Basic/SourceManager.h" 27#include "clang/Basic/SourceManagerInternals.h" 28#include "clang/Basic/TargetInfo.h" 29#include "clang/Basic/TargetOptions.h" 30#include "clang/Basic/Version.h" 31#include "clang/Basic/VersionTuple.h" 32#include "clang/Lex/HeaderSearch.h" 33#include "clang/Lex/HeaderSearchOptions.h" 34#include "clang/Lex/MacroInfo.h" 35#include "clang/Lex/PreprocessingRecord.h" 36#include "clang/Lex/Preprocessor.h" 37#include "clang/Lex/PreprocessorOptions.h" 38#include "clang/Sema/Scope.h" 39#include "clang/Sema/Sema.h" 40#include "clang/Serialization/ASTDeserializationListener.h" 41#include "clang/Serialization/GlobalModuleIndex.h" 42#include "clang/Serialization/ModuleManager.h" 43#include "clang/Serialization/SerializationDiagnostic.h" 44#include "llvm/ADT/Hashing.h" 45#include "llvm/ADT/StringExtras.h" 46#include "llvm/Bitcode/BitstreamReader.h" 47#include "llvm/Support/ErrorHandling.h" 48#include "llvm/Support/FileSystem.h" 49#include "llvm/Support/MemoryBuffer.h" 50#include "llvm/Support/Path.h" 51#include "llvm/Support/SaveAndRestore.h" 52#include "llvm/Support/system_error.h" 53#include <algorithm> 54#include <cstdio> 55#include <iterator> 56 57using namespace clang; 58using namespace clang::serialization; 59using namespace clang::serialization::reader; 60using llvm::BitstreamCursor; 61 62//===----------------------------------------------------------------------===// 63// PCH validator implementation 64//===----------------------------------------------------------------------===// 65 66ASTReaderListener::~ASTReaderListener() {} 67 68/// \brief Compare the given set of language options against an existing set of 69/// language options. 70/// 71/// \param Diags If non-NULL, diagnostics will be emitted via this engine. 72/// 73/// \returns true if the languagae options mis-match, false otherwise. 74static bool checkLanguageOptions(const LangOptions &LangOpts, 75 const LangOptions &ExistingLangOpts, 76 DiagnosticsEngine *Diags) { 77#define LANGOPT(Name, Bits, Default, Description) \ 78 if (ExistingLangOpts.Name != LangOpts.Name) { \ 79 if (Diags) \ 80 Diags->Report(diag::err_pch_langopt_mismatch) \ 81 << Description << LangOpts.Name << ExistingLangOpts.Name; \ 82 return true; \ 83 } 84 85#define VALUE_LANGOPT(Name, Bits, Default, Description) \ 86 if (ExistingLangOpts.Name != LangOpts.Name) { \ 87 if (Diags) \ 88 Diags->Report(diag::err_pch_langopt_value_mismatch) \ 89 << Description; \ 90 return true; \ 91 } 92 93#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 94 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \ 95 if (Diags) \ 96 Diags->Report(diag::err_pch_langopt_value_mismatch) \ 97 << Description; \ 98 return true; \ 99 } 100 101#define BENIGN_LANGOPT(Name, Bits, Default, Description) 102#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) 103#include "clang/Basic/LangOptions.def" 104 105 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) { 106 if (Diags) 107 Diags->Report(diag::err_pch_langopt_value_mismatch) 108 << "target Objective-C runtime"; 109 return true; 110 } 111 112 if (ExistingLangOpts.CommentOpts.BlockCommandNames != 113 LangOpts.CommentOpts.BlockCommandNames) { 114 if (Diags) 115 Diags->Report(diag::err_pch_langopt_value_mismatch) 116 << "block command names"; 117 return true; 118 } 119 120 return false; 121} 122 123/// \brief Compare the given set of target options against an existing set of 124/// target options. 125/// 126/// \param Diags If non-NULL, diagnostics will be emitted via this engine. 127/// 128/// \returns true if the target options mis-match, false otherwise. 129static bool checkTargetOptions(const TargetOptions &TargetOpts, 130 const TargetOptions &ExistingTargetOpts, 131 DiagnosticsEngine *Diags) { 132#define CHECK_TARGET_OPT(Field, Name) \ 133 if (TargetOpts.Field != ExistingTargetOpts.Field) { \ 134 if (Diags) \ 135 Diags->Report(diag::err_pch_targetopt_mismatch) \ 136 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \ 137 return true; \ 138 } 139 140 CHECK_TARGET_OPT(Triple, "target"); 141 CHECK_TARGET_OPT(CPU, "target CPU"); 142 CHECK_TARGET_OPT(ABI, "target ABI"); 143 CHECK_TARGET_OPT(CXXABI, "target C++ ABI"); 144 CHECK_TARGET_OPT(LinkerVersion, "target linker version"); 145#undef CHECK_TARGET_OPT 146 147 // Compare feature sets. 148 SmallVector<StringRef, 4> ExistingFeatures( 149 ExistingTargetOpts.FeaturesAsWritten.begin(), 150 ExistingTargetOpts.FeaturesAsWritten.end()); 151 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(), 152 TargetOpts.FeaturesAsWritten.end()); 153 std::sort(ExistingFeatures.begin(), ExistingFeatures.end()); 154 std::sort(ReadFeatures.begin(), ReadFeatures.end()); 155 156 unsigned ExistingIdx = 0, ExistingN = ExistingFeatures.size(); 157 unsigned ReadIdx = 0, ReadN = ReadFeatures.size(); 158 while (ExistingIdx < ExistingN && ReadIdx < ReadN) { 159 if (ExistingFeatures[ExistingIdx] == ReadFeatures[ReadIdx]) { 160 ++ExistingIdx; 161 ++ReadIdx; 162 continue; 163 } 164 165 if (ReadFeatures[ReadIdx] < ExistingFeatures[ExistingIdx]) { 166 if (Diags) 167 Diags->Report(diag::err_pch_targetopt_feature_mismatch) 168 << false << ReadFeatures[ReadIdx]; 169 return true; 170 } 171 172 if (Diags) 173 Diags->Report(diag::err_pch_targetopt_feature_mismatch) 174 << true << ExistingFeatures[ExistingIdx]; 175 return true; 176 } 177 178 if (ExistingIdx < ExistingN) { 179 if (Diags) 180 Diags->Report(diag::err_pch_targetopt_feature_mismatch) 181 << true << ExistingFeatures[ExistingIdx]; 182 return true; 183 } 184 185 if (ReadIdx < ReadN) { 186 if (Diags) 187 Diags->Report(diag::err_pch_targetopt_feature_mismatch) 188 << false << ReadFeatures[ReadIdx]; 189 return true; 190 } 191 192 return false; 193} 194 195bool 196PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts, 197 bool Complain) { 198 const LangOptions &ExistingLangOpts = PP.getLangOpts(); 199 return checkLanguageOptions(LangOpts, ExistingLangOpts, 200 Complain? &Reader.Diags : 0); 201} 202 203bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts, 204 bool Complain) { 205 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts(); 206 return checkTargetOptions(TargetOpts, ExistingTargetOpts, 207 Complain? &Reader.Diags : 0); 208} 209 210namespace { 211 typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> > 212 MacroDefinitionsMap; 213} 214 215/// \brief Collect the macro definitions provided by the given preprocessor 216/// options. 217static void collectMacroDefinitions(const PreprocessorOptions &PPOpts, 218 MacroDefinitionsMap &Macros, 219 SmallVectorImpl<StringRef> *MacroNames = 0){ 220 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { 221 StringRef Macro = PPOpts.Macros[I].first; 222 bool IsUndef = PPOpts.Macros[I].second; 223 224 std::pair<StringRef, StringRef> MacroPair = Macro.split('='); 225 StringRef MacroName = MacroPair.first; 226 StringRef MacroBody = MacroPair.second; 227 228 // For an #undef'd macro, we only care about the name. 229 if (IsUndef) { 230 if (MacroNames && !Macros.count(MacroName)) 231 MacroNames->push_back(MacroName); 232 233 Macros[MacroName] = std::make_pair("", true); 234 continue; 235 } 236 237 // For a #define'd macro, figure out the actual definition. 238 if (MacroName.size() == Macro.size()) 239 MacroBody = "1"; 240 else { 241 // Note: GCC drops anything following an end-of-line character. 242 StringRef::size_type End = MacroBody.find_first_of("\n\r"); 243 MacroBody = MacroBody.substr(0, End); 244 } 245 246 if (MacroNames && !Macros.count(MacroName)) 247 MacroNames->push_back(MacroName); 248 Macros[MacroName] = std::make_pair(MacroBody, false); 249 } 250} 251 252/// \brief Check the preprocessor options deserialized from the control block 253/// against the preprocessor options in an existing preprocessor. 254/// 255/// \param Diags If non-null, produce diagnostics for any mismatches incurred. 256static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts, 257 const PreprocessorOptions &ExistingPPOpts, 258 DiagnosticsEngine *Diags, 259 FileManager &FileMgr, 260 std::string &SuggestedPredefines) { 261 // Check macro definitions. 262 MacroDefinitionsMap ASTFileMacros; 263 collectMacroDefinitions(PPOpts, ASTFileMacros); 264 MacroDefinitionsMap ExistingMacros; 265 SmallVector<StringRef, 4> ExistingMacroNames; 266 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames); 267 268 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) { 269 // Dig out the macro definition in the existing preprocessor options. 270 StringRef MacroName = ExistingMacroNames[I]; 271 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName]; 272 273 // Check whether we know anything about this macro name or not. 274 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known 275 = ASTFileMacros.find(MacroName); 276 if (Known == ASTFileMacros.end()) { 277 // FIXME: Check whether this identifier was referenced anywhere in the 278 // AST file. If so, we should reject the AST file. Unfortunately, this 279 // information isn't in the control block. What shall we do about it? 280 281 if (Existing.second) { 282 SuggestedPredefines += "#undef "; 283 SuggestedPredefines += MacroName.str(); 284 SuggestedPredefines += '\n'; 285 } else { 286 SuggestedPredefines += "#define "; 287 SuggestedPredefines += MacroName.str(); 288 SuggestedPredefines += ' '; 289 SuggestedPredefines += Existing.first.str(); 290 SuggestedPredefines += '\n'; 291 } 292 continue; 293 } 294 295 // If the macro was defined in one but undef'd in the other, we have a 296 // conflict. 297 if (Existing.second != Known->second.second) { 298 if (Diags) { 299 Diags->Report(diag::err_pch_macro_def_undef) 300 << MacroName << Known->second.second; 301 } 302 return true; 303 } 304 305 // If the macro was #undef'd in both, or if the macro bodies are identical, 306 // it's fine. 307 if (Existing.second || Existing.first == Known->second.first) 308 continue; 309 310 // The macro bodies differ; complain. 311 if (Diags) { 312 Diags->Report(diag::err_pch_macro_def_conflict) 313 << MacroName << Known->second.first << Existing.first; 314 } 315 return true; 316 } 317 318 // Check whether we're using predefines. 319 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) { 320 if (Diags) { 321 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines; 322 } 323 return true; 324 } 325 326 // Compute the #include and #include_macros lines we need. 327 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) { 328 StringRef File = ExistingPPOpts.Includes[I]; 329 if (File == ExistingPPOpts.ImplicitPCHInclude) 330 continue; 331 332 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File) 333 != PPOpts.Includes.end()) 334 continue; 335 336 SuggestedPredefines += "#include \""; 337 SuggestedPredefines += 338 HeaderSearch::NormalizeDashIncludePath(File, FileMgr); 339 SuggestedPredefines += "\"\n"; 340 } 341 342 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) { 343 StringRef File = ExistingPPOpts.MacroIncludes[I]; 344 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(), 345 File) 346 != PPOpts.MacroIncludes.end()) 347 continue; 348 349 SuggestedPredefines += "#__include_macros \""; 350 SuggestedPredefines += 351 HeaderSearch::NormalizeDashIncludePath(File, FileMgr); 352 SuggestedPredefines += "\"\n##\n"; 353 } 354 355 return false; 356} 357 358bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 359 bool Complain, 360 std::string &SuggestedPredefines) { 361 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts(); 362 363 return checkPreprocessorOptions(PPOpts, ExistingPPOpts, 364 Complain? &Reader.Diags : 0, 365 PP.getFileManager(), 366 SuggestedPredefines); 367} 368 369void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 370 unsigned ID) { 371 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 372 ++NumHeaderInfos; 373} 374 375void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) { 376 PP.setCounterValue(Value); 377} 378 379//===----------------------------------------------------------------------===// 380// AST reader implementation 381//===----------------------------------------------------------------------===// 382 383void 384ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 385 DeserializationListener = Listener; 386} 387 388 389 390unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) { 391 return serialization::ComputeHash(Sel); 392} 393 394 395std::pair<unsigned, unsigned> 396ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 397 using namespace clang::io; 398 unsigned KeyLen = ReadUnalignedLE16(d); 399 unsigned DataLen = ReadUnalignedLE16(d); 400 return std::make_pair(KeyLen, DataLen); 401} 402 403ASTSelectorLookupTrait::internal_key_type 404ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) { 405 using namespace clang::io; 406 SelectorTable &SelTable = Reader.getContext().Selectors; 407 unsigned N = ReadUnalignedLE16(d); 408 IdentifierInfo *FirstII 409 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 410 if (N == 0) 411 return SelTable.getNullarySelector(FirstII); 412 else if (N == 1) 413 return SelTable.getUnarySelector(FirstII); 414 415 SmallVector<IdentifierInfo *, 16> Args; 416 Args.push_back(FirstII); 417 for (unsigned I = 1; I != N; ++I) 418 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d))); 419 420 return SelTable.getSelector(N, Args.data()); 421} 422 423ASTSelectorLookupTrait::data_type 424ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d, 425 unsigned DataLen) { 426 using namespace clang::io; 427 428 data_type Result; 429 430 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d)); 431 unsigned NumInstanceMethods = ReadUnalignedLE16(d); 432 unsigned NumFactoryMethods = ReadUnalignedLE16(d); 433 434 // Load instance methods 435 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 436 if (ObjCMethodDecl *Method 437 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d))) 438 Result.Instance.push_back(Method); 439 } 440 441 // Load factory methods 442 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 443 if (ObjCMethodDecl *Method 444 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d))) 445 Result.Factory.push_back(Method); 446 } 447 448 return Result; 449} 450 451unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) { 452 return llvm::HashString(a); 453} 454 455std::pair<unsigned, unsigned> 456ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) { 457 using namespace clang::io; 458 unsigned DataLen = ReadUnalignedLE16(d); 459 unsigned KeyLen = ReadUnalignedLE16(d); 460 return std::make_pair(KeyLen, DataLen); 461} 462 463ASTIdentifierLookupTraitBase::internal_key_type 464ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) { 465 assert(n >= 2 && d[n-1] == '\0'); 466 return StringRef((const char*) d, n-1); 467} 468 469/// \brief Whether the given identifier is "interesting". 470static bool isInterestingIdentifier(IdentifierInfo &II) { 471 return II.isPoisoned() || 472 II.isExtensionToken() || 473 II.getObjCOrBuiltinID() || 474 II.hasRevertedTokenIDToIdentifier() || 475 II.hadMacroDefinition() || 476 II.getFETokenInfo<void>(); 477} 478 479IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k, 480 const unsigned char* d, 481 unsigned DataLen) { 482 using namespace clang::io; 483 unsigned RawID = ReadUnalignedLE32(d); 484 bool IsInteresting = RawID & 0x01; 485 486 // Wipe out the "is interesting" bit. 487 RawID = RawID >> 1; 488 489 IdentID ID = Reader.getGlobalIdentifierID(F, RawID); 490 if (!IsInteresting) { 491 // For uninteresting identifiers, just build the IdentifierInfo 492 // and associate it with the persistent ID. 493 IdentifierInfo *II = KnownII; 494 if (!II) { 495 II = &Reader.getIdentifierTable().getOwn(k); 496 KnownII = II; 497 } 498 Reader.SetIdentifierInfo(ID, II); 499 if (!II->isFromAST()) { 500 bool WasInteresting = isInterestingIdentifier(*II); 501 II->setIsFromAST(); 502 if (WasInteresting) 503 II->setChangedSinceDeserialization(); 504 } 505 Reader.markIdentifierUpToDate(II); 506 return II; 507 } 508 509 unsigned ObjCOrBuiltinID = ReadUnalignedLE16(d); 510 unsigned Bits = ReadUnalignedLE16(d); 511 bool CPlusPlusOperatorKeyword = Bits & 0x01; 512 Bits >>= 1; 513 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 514 Bits >>= 1; 515 bool Poisoned = Bits & 0x01; 516 Bits >>= 1; 517 bool ExtensionToken = Bits & 0x01; 518 Bits >>= 1; 519 bool hadMacroDefinition = Bits & 0x01; 520 Bits >>= 1; 521 522 assert(Bits == 0 && "Extra bits in the identifier?"); 523 DataLen -= 8; 524 525 // Build the IdentifierInfo itself and link the identifier ID with 526 // the new IdentifierInfo. 527 IdentifierInfo *II = KnownII; 528 if (!II) { 529 II = &Reader.getIdentifierTable().getOwn(StringRef(k)); 530 KnownII = II; 531 } 532 Reader.markIdentifierUpToDate(II); 533 if (!II->isFromAST()) { 534 bool WasInteresting = isInterestingIdentifier(*II); 535 II->setIsFromAST(); 536 if (WasInteresting) 537 II->setChangedSinceDeserialization(); 538 } 539 540 // Set or check the various bits in the IdentifierInfo structure. 541 // Token IDs are read-only. 542 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier) 543 II->RevertTokenIDToIdentifier(); 544 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 545 assert(II->isExtensionToken() == ExtensionToken && 546 "Incorrect extension token flag"); 547 (void)ExtensionToken; 548 if (Poisoned) 549 II->setIsPoisoned(true); 550 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 551 "Incorrect C++ operator keyword flag"); 552 (void)CPlusPlusOperatorKeyword; 553 554 // If this identifier is a macro, deserialize the macro 555 // definition. 556 if (hadMacroDefinition) { 557 SmallVector<MacroID, 4> MacroIDs; 558 while (uint32_t LocalID = ReadUnalignedLE32(d)) { 559 MacroIDs.push_back(Reader.getGlobalMacroID(F, LocalID)); 560 DataLen -= 4; 561 } 562 DataLen -= 4; 563 Reader.setIdentifierIsMacro(II, MacroIDs); 564 } 565 566 Reader.SetIdentifierInfo(ID, II); 567 568 // Read all of the declarations visible at global scope with this 569 // name. 570 if (DataLen > 0) { 571 SmallVector<uint32_t, 4> DeclIDs; 572 for (; DataLen > 0; DataLen -= 4) 573 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d))); 574 Reader.SetGloballyVisibleDecls(II, DeclIDs); 575 } 576 577 return II; 578} 579 580unsigned 581ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const { 582 llvm::FoldingSetNodeID ID; 583 ID.AddInteger(Key.Kind); 584 585 switch (Key.Kind) { 586 case DeclarationName::Identifier: 587 case DeclarationName::CXXLiteralOperatorName: 588 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 589 break; 590 case DeclarationName::ObjCZeroArgSelector: 591 case DeclarationName::ObjCOneArgSelector: 592 case DeclarationName::ObjCMultiArgSelector: 593 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 594 break; 595 case DeclarationName::CXXOperatorName: 596 ID.AddInteger((OverloadedOperatorKind)Key.Data); 597 break; 598 case DeclarationName::CXXConstructorName: 599 case DeclarationName::CXXDestructorName: 600 case DeclarationName::CXXConversionFunctionName: 601 case DeclarationName::CXXUsingDirective: 602 break; 603 } 604 605 return ID.ComputeHash(); 606} 607 608ASTDeclContextNameLookupTrait::internal_key_type 609ASTDeclContextNameLookupTrait::GetInternalKey( 610 const external_key_type& Name) const { 611 DeclNameKey Key; 612 Key.Kind = Name.getNameKind(); 613 switch (Name.getNameKind()) { 614 case DeclarationName::Identifier: 615 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 616 break; 617 case DeclarationName::ObjCZeroArgSelector: 618 case DeclarationName::ObjCOneArgSelector: 619 case DeclarationName::ObjCMultiArgSelector: 620 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 621 break; 622 case DeclarationName::CXXOperatorName: 623 Key.Data = Name.getCXXOverloadedOperator(); 624 break; 625 case DeclarationName::CXXLiteralOperatorName: 626 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 627 break; 628 case DeclarationName::CXXConstructorName: 629 case DeclarationName::CXXDestructorName: 630 case DeclarationName::CXXConversionFunctionName: 631 case DeclarationName::CXXUsingDirective: 632 Key.Data = 0; 633 break; 634 } 635 636 return Key; 637} 638 639std::pair<unsigned, unsigned> 640ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 641 using namespace clang::io; 642 unsigned KeyLen = ReadUnalignedLE16(d); 643 unsigned DataLen = ReadUnalignedLE16(d); 644 return std::make_pair(KeyLen, DataLen); 645} 646 647ASTDeclContextNameLookupTrait::internal_key_type 648ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) { 649 using namespace clang::io; 650 651 DeclNameKey Key; 652 Key.Kind = (DeclarationName::NameKind)*d++; 653 switch (Key.Kind) { 654 case DeclarationName::Identifier: 655 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 656 break; 657 case DeclarationName::ObjCZeroArgSelector: 658 case DeclarationName::ObjCOneArgSelector: 659 case DeclarationName::ObjCMultiArgSelector: 660 Key.Data = 661 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d)) 662 .getAsOpaquePtr(); 663 break; 664 case DeclarationName::CXXOperatorName: 665 Key.Data = *d++; // OverloadedOperatorKind 666 break; 667 case DeclarationName::CXXLiteralOperatorName: 668 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 669 break; 670 case DeclarationName::CXXConstructorName: 671 case DeclarationName::CXXDestructorName: 672 case DeclarationName::CXXConversionFunctionName: 673 case DeclarationName::CXXUsingDirective: 674 Key.Data = 0; 675 break; 676 } 677 678 return Key; 679} 680 681ASTDeclContextNameLookupTrait::data_type 682ASTDeclContextNameLookupTrait::ReadData(internal_key_type, 683 const unsigned char* d, 684 unsigned DataLen) { 685 using namespace clang::io; 686 unsigned NumDecls = ReadUnalignedLE16(d); 687 LE32DeclID *Start = reinterpret_cast<LE32DeclID *>( 688 const_cast<unsigned char *>(d)); 689 return std::make_pair(Start, Start + NumDecls); 690} 691 692bool ASTReader::ReadDeclContextStorage(ModuleFile &M, 693 BitstreamCursor &Cursor, 694 const std::pair<uint64_t, uint64_t> &Offsets, 695 DeclContextInfo &Info) { 696 SavedStreamPosition SavedPosition(Cursor); 697 // First the lexical decls. 698 if (Offsets.first != 0) { 699 Cursor.JumpToBit(Offsets.first); 700 701 RecordData Record; 702 StringRef Blob; 703 unsigned Code = Cursor.ReadCode(); 704 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob); 705 if (RecCode != DECL_CONTEXT_LEXICAL) { 706 Error("Expected lexical block"); 707 return true; 708 } 709 710 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob.data()); 711 Info.NumLexicalDecls = Blob.size() / sizeof(KindDeclIDPair); 712 } 713 714 // Now the lookup table. 715 if (Offsets.second != 0) { 716 Cursor.JumpToBit(Offsets.second); 717 718 RecordData Record; 719 StringRef Blob; 720 unsigned Code = Cursor.ReadCode(); 721 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob); 722 if (RecCode != DECL_CONTEXT_VISIBLE) { 723 Error("Expected visible lookup table block"); 724 return true; 725 } 726 Info.NameLookupTableData 727 = ASTDeclContextNameLookupTable::Create( 728 (const unsigned char *)Blob.data() + Record[0], 729 (const unsigned char *)Blob.data(), 730 ASTDeclContextNameLookupTrait(*this, M)); 731 } 732 733 return false; 734} 735 736void ASTReader::Error(StringRef Msg) { 737 Error(diag::err_fe_pch_malformed, Msg); 738} 739 740void ASTReader::Error(unsigned DiagID, 741 StringRef Arg1, StringRef Arg2) { 742 if (Diags.isDiagnosticInFlight()) 743 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2); 744 else 745 Diag(DiagID) << Arg1 << Arg2; 746} 747 748//===----------------------------------------------------------------------===// 749// Source Manager Deserialization 750//===----------------------------------------------------------------------===// 751 752/// \brief Read the line table in the source manager block. 753/// \returns true if there was an error. 754bool ASTReader::ParseLineTable(ModuleFile &F, 755 SmallVectorImpl<uint64_t> &Record) { 756 unsigned Idx = 0; 757 LineTableInfo &LineTable = SourceMgr.getLineTable(); 758 759 // Parse the file names 760 std::map<int, int> FileIDs; 761 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 762 // Extract the file name 763 unsigned FilenameLen = Record[Idx++]; 764 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 765 Idx += FilenameLen; 766 MaybeAddSystemRootToFilename(F, Filename); 767 FileIDs[I] = LineTable.getLineTableFilenameID(Filename); 768 } 769 770 // Parse the line entries 771 std::vector<LineEntry> Entries; 772 while (Idx < Record.size()) { 773 int FID = Record[Idx++]; 774 assert(FID >= 0 && "Serialized line entries for non-local file."); 775 // Remap FileID from 1-based old view. 776 FID += F.SLocEntryBaseID - 1; 777 778 // Extract the line entries 779 unsigned NumEntries = Record[Idx++]; 780 assert(NumEntries && "Numentries is 00000"); 781 Entries.clear(); 782 Entries.reserve(NumEntries); 783 for (unsigned I = 0; I != NumEntries; ++I) { 784 unsigned FileOffset = Record[Idx++]; 785 unsigned LineNo = Record[Idx++]; 786 int FilenameID = FileIDs[Record[Idx++]]; 787 SrcMgr::CharacteristicKind FileKind 788 = (SrcMgr::CharacteristicKind)Record[Idx++]; 789 unsigned IncludeOffset = Record[Idx++]; 790 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 791 FileKind, IncludeOffset)); 792 } 793 LineTable.AddEntry(FileID::get(FID), Entries); 794 } 795 796 return false; 797} 798 799/// \brief Read a source manager block 800bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) { 801 using namespace SrcMgr; 802 803 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 804 805 // Set the source-location entry cursor to the current position in 806 // the stream. This cursor will be used to read the contents of the 807 // source manager block initially, and then lazily read 808 // source-location entries as needed. 809 SLocEntryCursor = F.Stream; 810 811 // The stream itself is going to skip over the source manager block. 812 if (F.Stream.SkipBlock()) { 813 Error("malformed block record in AST file"); 814 return true; 815 } 816 817 // Enter the source manager block. 818 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 819 Error("malformed source manager block record in AST file"); 820 return true; 821 } 822 823 RecordData Record; 824 while (true) { 825 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks(); 826 827 switch (E.Kind) { 828 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 829 case llvm::BitstreamEntry::Error: 830 Error("malformed block record in AST file"); 831 return true; 832 case llvm::BitstreamEntry::EndBlock: 833 return false; 834 case llvm::BitstreamEntry::Record: 835 // The interesting case. 836 break; 837 } 838 839 // Read a record. 840 Record.clear(); 841 StringRef Blob; 842 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) { 843 default: // Default behavior: ignore. 844 break; 845 846 case SM_SLOC_FILE_ENTRY: 847 case SM_SLOC_BUFFER_ENTRY: 848 case SM_SLOC_EXPANSION_ENTRY: 849 // Once we hit one of the source location entries, we're done. 850 return false; 851 } 852 } 853} 854 855/// \brief If a header file is not found at the path that we expect it to be 856/// and the PCH file was moved from its original location, try to resolve the 857/// file by assuming that header+PCH were moved together and the header is in 858/// the same place relative to the PCH. 859static std::string 860resolveFileRelativeToOriginalDir(const std::string &Filename, 861 const std::string &OriginalDir, 862 const std::string &CurrDir) { 863 assert(OriginalDir != CurrDir && 864 "No point trying to resolve the file if the PCH dir didn't change"); 865 using namespace llvm::sys; 866 SmallString<128> filePath(Filename); 867 fs::make_absolute(filePath); 868 assert(path::is_absolute(OriginalDir)); 869 SmallString<128> currPCHPath(CurrDir); 870 871 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 872 fileDirE = path::end(path::parent_path(filePath)); 873 path::const_iterator origDirI = path::begin(OriginalDir), 874 origDirE = path::end(OriginalDir); 875 // Skip the common path components from filePath and OriginalDir. 876 while (fileDirI != fileDirE && origDirI != origDirE && 877 *fileDirI == *origDirI) { 878 ++fileDirI; 879 ++origDirI; 880 } 881 for (; origDirI != origDirE; ++origDirI) 882 path::append(currPCHPath, ".."); 883 path::append(currPCHPath, fileDirI, fileDirE); 884 path::append(currPCHPath, path::filename(Filename)); 885 return currPCHPath.str(); 886} 887 888bool ASTReader::ReadSLocEntry(int ID) { 889 if (ID == 0) 890 return false; 891 892 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 893 Error("source location entry ID out-of-range for AST file"); 894 return true; 895 } 896 897 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second; 898 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]); 899 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 900 unsigned BaseOffset = F->SLocEntryBaseOffset; 901 902 ++NumSLocEntriesRead; 903 llvm::BitstreamEntry Entry = SLocEntryCursor.advance(); 904 if (Entry.Kind != llvm::BitstreamEntry::Record) { 905 Error("incorrectly-formatted source location entry in AST file"); 906 return true; 907 } 908 909 RecordData Record; 910 StringRef Blob; 911 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) { 912 default: 913 Error("incorrectly-formatted source location entry in AST file"); 914 return true; 915 916 case SM_SLOC_FILE_ENTRY: { 917 // We will detect whether a file changed and return 'Failure' for it, but 918 // we will also try to fail gracefully by setting up the SLocEntry. 919 unsigned InputID = Record[4]; 920 InputFile IF = getInputFile(*F, InputID); 921 const FileEntry *File = IF.getFile(); 922 bool OverriddenBuffer = IF.isOverridden(); 923 924 // Note that we only check if a File was returned. If it was out-of-date 925 // we have complained but we will continue creating a FileID to recover 926 // gracefully. 927 if (!File) 928 return true; 929 930 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 931 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) { 932 // This is the module's main file. 933 IncludeLoc = getImportLocation(F); 934 } 935 SrcMgr::CharacteristicKind 936 FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; 937 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter, 938 ID, BaseOffset + Record[0]); 939 SrcMgr::FileInfo &FileInfo = 940 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()); 941 FileInfo.NumCreatedFIDs = Record[5]; 942 if (Record[3]) 943 FileInfo.setHasLineDirectives(); 944 945 const DeclID *FirstDecl = F->FileSortedDecls + Record[6]; 946 unsigned NumFileDecls = Record[7]; 947 if (NumFileDecls) { 948 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?"); 949 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl, 950 NumFileDecls)); 951 } 952 953 const SrcMgr::ContentCache *ContentCache 954 = SourceMgr.getOrCreateContentCache(File, 955 /*isSystemFile=*/FileCharacter != SrcMgr::C_User); 956 if (OverriddenBuffer && !ContentCache->BufferOverridden && 957 ContentCache->ContentsEntry == ContentCache->OrigEntry) { 958 unsigned Code = SLocEntryCursor.ReadCode(); 959 Record.clear(); 960 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob); 961 962 if (RecCode != SM_SLOC_BUFFER_BLOB) { 963 Error("AST record has invalid code"); 964 return true; 965 } 966 967 llvm::MemoryBuffer *Buffer 968 = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName()); 969 SourceMgr.overrideFileContents(File, Buffer); 970 } 971 972 break; 973 } 974 975 case SM_SLOC_BUFFER_ENTRY: { 976 const char *Name = Blob.data(); 977 unsigned Offset = Record[0]; 978 SrcMgr::CharacteristicKind 979 FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; 980 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 981 if (IncludeLoc.isInvalid() && F->Kind == MK_Module) { 982 IncludeLoc = getImportLocation(F); 983 } 984 unsigned Code = SLocEntryCursor.ReadCode(); 985 Record.clear(); 986 unsigned RecCode 987 = SLocEntryCursor.readRecord(Code, Record, &Blob); 988 989 if (RecCode != SM_SLOC_BUFFER_BLOB) { 990 Error("AST record has invalid code"); 991 return true; 992 } 993 994 llvm::MemoryBuffer *Buffer 995 = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name); 996 SourceMgr.createFileIDForMemBuffer(Buffer, FileCharacter, ID, 997 BaseOffset + Offset, IncludeLoc); 998 break; 999 } 1000 1001 case SM_SLOC_EXPANSION_ENTRY: { 1002 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1003 SourceMgr.createExpansionLoc(SpellingLoc, 1004 ReadSourceLocation(*F, Record[2]), 1005 ReadSourceLocation(*F, Record[3]), 1006 Record[4], 1007 ID, 1008 BaseOffset + Record[0]); 1009 break; 1010 } 1011 } 1012 1013 return false; 1014} 1015 1016std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) { 1017 if (ID == 0) 1018 return std::make_pair(SourceLocation(), ""); 1019 1020 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1021 Error("source location entry ID out-of-range for AST file"); 1022 return std::make_pair(SourceLocation(), ""); 1023 } 1024 1025 // Find which module file this entry lands in. 1026 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second; 1027 if (M->Kind != MK_Module) 1028 return std::make_pair(SourceLocation(), ""); 1029 1030 // FIXME: Can we map this down to a particular submodule? That would be 1031 // ideal. 1032 return std::make_pair(M->ImportLoc, llvm::sys::path::stem(M->FileName)); 1033} 1034 1035/// \brief Find the location where the module F is imported. 1036SourceLocation ASTReader::getImportLocation(ModuleFile *F) { 1037 if (F->ImportLoc.isValid()) 1038 return F->ImportLoc; 1039 1040 // Otherwise we have a PCH. It's considered to be "imported" at the first 1041 // location of its includer. 1042 if (F->ImportedBy.empty() || !F->ImportedBy[0]) { 1043 // Main file is the importer. We assume that it is the first entry in the 1044 // entry table. We can't ask the manager, because at the time of PCH loading 1045 // the main file entry doesn't exist yet. 1046 // The very first entry is the invalid instantiation loc, which takes up 1047 // offsets 0 and 1. 1048 return SourceLocation::getFromRawEncoding(2U); 1049 } 1050 //return F->Loaders[0]->FirstLoc; 1051 return F->ImportedBy[0]->FirstLoc; 1052} 1053 1054/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1055/// specified cursor. Read the abbreviations that are at the top of the block 1056/// and then leave the cursor pointing into the block. 1057bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) { 1058 if (Cursor.EnterSubBlock(BlockID)) { 1059 Error("malformed block record in AST file"); 1060 return Failure; 1061 } 1062 1063 while (true) { 1064 uint64_t Offset = Cursor.GetCurrentBitNo(); 1065 unsigned Code = Cursor.ReadCode(); 1066 1067 // We expect all abbrevs to be at the start of the block. 1068 if (Code != llvm::bitc::DEFINE_ABBREV) { 1069 Cursor.JumpToBit(Offset); 1070 return false; 1071 } 1072 Cursor.ReadAbbrevRecord(); 1073 } 1074} 1075 1076void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset, 1077 MacroDirective *Hint) { 1078 BitstreamCursor &Stream = F.MacroCursor; 1079 1080 // Keep track of where we are in the stream, then jump back there 1081 // after reading this macro. 1082 SavedStreamPosition SavedPosition(Stream); 1083 1084 Stream.JumpToBit(Offset); 1085 RecordData Record; 1086 SmallVector<IdentifierInfo*, 16> MacroArgs; 1087 MacroInfo *Macro = 0; 1088 1089 // RAII object to add the loaded macro information once we're done 1090 // adding tokens. 1091 struct AddLoadedMacroInfoRAII { 1092 Preprocessor &PP; 1093 MacroDirective *Hint; 1094 MacroDirective *MD; 1095 IdentifierInfo *II; 1096 1097 AddLoadedMacroInfoRAII(Preprocessor &PP, MacroDirective *Hint) 1098 : PP(PP), Hint(Hint), MD(), II() { } 1099 ~AddLoadedMacroInfoRAII( ) { 1100 if (MD) { 1101 // Finally, install the macro. 1102 PP.addLoadedMacroInfo(II, MD, Hint); 1103 } 1104 } 1105 } AddLoadedMacroInfo(PP, Hint); 1106 1107 while (true) { 1108 // Advance to the next record, but if we get to the end of the block, don't 1109 // pop it (removing all the abbreviations from the cursor) since we want to 1110 // be able to reseek within the block and read entries. 1111 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd; 1112 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags); 1113 1114 switch (Entry.Kind) { 1115 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1116 case llvm::BitstreamEntry::Error: 1117 Error("malformed block record in AST file"); 1118 return; 1119 case llvm::BitstreamEntry::EndBlock: 1120 return; 1121 case llvm::BitstreamEntry::Record: 1122 // The interesting case. 1123 break; 1124 } 1125 1126 // Read a record. 1127 Record.clear(); 1128 PreprocessorRecordTypes RecType = 1129 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record); 1130 switch (RecType) { 1131 case PP_MACRO_OBJECT_LIKE: 1132 case PP_MACRO_FUNCTION_LIKE: { 1133 // If we already have a macro, that means that we've hit the end 1134 // of the definition of the macro we were looking for. We're 1135 // done. 1136 if (Macro) 1137 return; 1138 1139 IdentifierInfo *II = getLocalIdentifier(F, Record[0]); 1140 if (II == 0) { 1141 Error("macro must have a name in AST file"); 1142 return; 1143 } 1144 1145 unsigned GlobalID = getGlobalMacroID(F, Record[1]); 1146 1147 // If this macro has already been loaded, don't do so again. 1148 if (MacrosLoaded[GlobalID - NUM_PREDEF_MACRO_IDS]) 1149 return; 1150 1151 SubmoduleID GlobalSubmoduleID = getGlobalSubmoduleID(F, Record[2]); 1152 unsigned NextIndex = 3; 1153 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex); 1154 MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, GlobalSubmoduleID); 1155 // FIXME: Location should be import location in case of module. 1156 MacroDirective *MD = PP.AllocateMacroDirective(MI, Loc, 1157 /*isImported=*/true); 1158 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex)); 1159 1160 // Record this macro. 1161 MacrosLoaded[GlobalID - NUM_PREDEF_MACRO_IDS] = MD; 1162 1163 SourceLocation UndefLoc = ReadSourceLocation(F, Record, NextIndex); 1164 if (UndefLoc.isValid()) 1165 MD->setUndefLoc(UndefLoc); 1166 1167 MI->setIsUsed(Record[NextIndex++]); 1168 1169 bool IsPublic = Record[NextIndex++]; 1170 MD->setVisibility(IsPublic, ReadSourceLocation(F, Record, NextIndex)); 1171 1172 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1173 // Decode function-like macro info. 1174 bool isC99VarArgs = Record[NextIndex++]; 1175 bool isGNUVarArgs = Record[NextIndex++]; 1176 bool hasCommaPasting = Record[NextIndex++]; 1177 MacroArgs.clear(); 1178 unsigned NumArgs = Record[NextIndex++]; 1179 for (unsigned i = 0; i != NumArgs; ++i) 1180 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++])); 1181 1182 // Install function-like macro info. 1183 MI->setIsFunctionLike(); 1184 if (isC99VarArgs) MI->setIsC99Varargs(); 1185 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1186 if (hasCommaPasting) MI->setHasCommaPasting(); 1187 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1188 PP.getPreprocessorAllocator()); 1189 } 1190 1191 if (DeserializationListener) 1192 DeserializationListener->MacroRead(GlobalID, MD); 1193 1194 // If an update record marked this as undefined, do so now. 1195 // FIXME: Only if the submodule this update came from is visible? 1196 MacroUpdatesMap::iterator Update = MacroUpdates.find(GlobalID); 1197 if (Update != MacroUpdates.end()) { 1198 if (MD->getUndefLoc().isInvalid()) { 1199 for (unsigned I = 0, N = Update->second.size(); I != N; ++I) { 1200 bool Hidden = false; 1201 if (unsigned SubmoduleID = Update->second[I].first) { 1202 if (Module *Owner = getSubmodule(SubmoduleID)) { 1203 if (Owner->NameVisibility == Module::Hidden) { 1204 // Note that this #undef is hidden. 1205 Hidden = true; 1206 1207 // Record this hiding for later. 1208 HiddenNamesMap[Owner].push_back( 1209 HiddenName(II, MD, Update->second[I].second.UndefLoc)); 1210 } 1211 } 1212 } 1213 1214 if (!Hidden) { 1215 MD->setUndefLoc(Update->second[I].second.UndefLoc); 1216 if (PPMutationListener *Listener = PP.getPPMutationListener()) 1217 Listener->UndefinedMacro(MD); 1218 break; 1219 } 1220 } 1221 } 1222 MacroUpdates.erase(Update); 1223 } 1224 1225 // Determine whether this macro definition is visible. 1226 bool Hidden = !MD->isPublic(); 1227 if (!Hidden && GlobalSubmoduleID) { 1228 if (Module *Owner = getSubmodule(GlobalSubmoduleID)) { 1229 if (Owner->NameVisibility == Module::Hidden) { 1230 // The owning module is not visible, and this macro definition 1231 // should not be, either. 1232 Hidden = true; 1233 1234 // Note that this macro definition was hidden because its owning 1235 // module is not yet visible. 1236 HiddenNamesMap[Owner].push_back(HiddenName(II, MD)); 1237 } 1238 } 1239 } 1240 MD->setHidden(Hidden); 1241 1242 // Make sure we install the macro once we're done. 1243 AddLoadedMacroInfo.MD = MD; 1244 AddLoadedMacroInfo.II = II; 1245 1246 // Remember that we saw this macro last so that we add the tokens that 1247 // form its body to it. 1248 Macro = MI; 1249 1250 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() && 1251 Record[NextIndex]) { 1252 // We have a macro definition. Register the association 1253 PreprocessedEntityID 1254 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]); 1255 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 1256 PreprocessingRecord::PPEntityID 1257 PPID = PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true); 1258 MacroDefinition *PPDef = 1259 cast_or_null<MacroDefinition>(PPRec.getPreprocessedEntity(PPID)); 1260 if (PPDef) 1261 PPRec.RegisterMacroDefinition(Macro, PPDef); 1262 } 1263 1264 ++NumMacrosRead; 1265 break; 1266 } 1267 1268 case PP_TOKEN: { 1269 // If we see a TOKEN before a PP_MACRO_*, then the file is 1270 // erroneous, just pretend we didn't see this. 1271 if (Macro == 0) break; 1272 1273 Token Tok; 1274 Tok.startToken(); 1275 Tok.setLocation(ReadSourceLocation(F, Record[0])); 1276 Tok.setLength(Record[1]); 1277 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2])) 1278 Tok.setIdentifierInfo(II); 1279 Tok.setKind((tok::TokenKind)Record[3]); 1280 Tok.setFlag((Token::TokenFlags)Record[4]); 1281 Macro->AddTokenToBody(Tok); 1282 break; 1283 } 1284 } 1285 } 1286} 1287 1288PreprocessedEntityID 1289ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const { 1290 ContinuousRangeMap<uint32_t, int, 2>::const_iterator 1291 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS); 1292 assert(I != M.PreprocessedEntityRemap.end() 1293 && "Invalid index into preprocessed entity index remap"); 1294 1295 return LocalID + I->second; 1296} 1297 1298unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) { 1299 return llvm::hash_combine(ikey.Size, ikey.ModTime); 1300} 1301 1302HeaderFileInfoTrait::internal_key_type 1303HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) { 1304 internal_key_type ikey = { FE->getSize(), FE->getModificationTime(), 1305 FE->getName() }; 1306 return ikey; 1307} 1308 1309bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) { 1310 if (a.Size != b.Size || a.ModTime != b.ModTime) 1311 return false; 1312 1313 if (strcmp(a.Filename, b.Filename) == 0) 1314 return true; 1315 1316 // Determine whether the actual files are equivalent. 1317 FileManager &FileMgr = Reader.getFileManager(); 1318 const FileEntry *FEA = FileMgr.getFile(a.Filename); 1319 const FileEntry *FEB = FileMgr.getFile(b.Filename); 1320 return (FEA && FEA == FEB); 1321} 1322 1323std::pair<unsigned, unsigned> 1324HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) { 1325 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1326 unsigned DataLen = (unsigned) *d++; 1327 return std::make_pair(KeyLen, DataLen); 1328} 1329 1330HeaderFileInfoTrait::internal_key_type 1331HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) { 1332 internal_key_type ikey; 1333 ikey.Size = off_t(clang::io::ReadUnalignedLE64(d)); 1334 ikey.ModTime = time_t(clang::io::ReadUnalignedLE64(d)); 1335 ikey.Filename = (const char *)d; 1336 return ikey; 1337} 1338 1339HeaderFileInfoTrait::data_type 1340HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d, 1341 unsigned DataLen) { 1342 const unsigned char *End = d + DataLen; 1343 using namespace clang::io; 1344 HeaderFileInfo HFI; 1345 unsigned Flags = *d++; 1346 HFI.isImport = (Flags >> 5) & 0x01; 1347 HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1348 HFI.DirInfo = (Flags >> 2) & 0x03; 1349 HFI.Resolved = (Flags >> 1) & 0x01; 1350 HFI.IndexHeaderMapHeader = Flags & 0x01; 1351 HFI.NumIncludes = ReadUnalignedLE16(d); 1352 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(M, 1353 ReadUnalignedLE32(d)); 1354 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) { 1355 // The framework offset is 1 greater than the actual offset, 1356 // since 0 is used as an indicator for "no framework name". 1357 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1358 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1359 } 1360 1361 if (d != End) { 1362 uint32_t LocalSMID = ReadUnalignedLE32(d); 1363 if (LocalSMID) { 1364 // This header is part of a module. Associate it with the module to enable 1365 // implicit module import. 1366 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID); 1367 Module *Mod = Reader.getSubmodule(GlobalSMID); 1368 HFI.isModuleHeader = true; 1369 FileManager &FileMgr = Reader.getFileManager(); 1370 ModuleMap &ModMap = 1371 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 1372 ModMap.addHeader(Mod, FileMgr.getFile(key.Filename), /*Excluded=*/false); 1373 } 1374 } 1375 1376 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1377 (void)End; 1378 1379 // This HeaderFileInfo was externally loaded. 1380 HFI.External = true; 1381 return HFI; 1382} 1383 1384void ASTReader::setIdentifierIsMacro(IdentifierInfo *II, ArrayRef<MacroID> IDs){ 1385 II->setHadMacroDefinition(true); 1386 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); 1387 PendingMacroIDs[II].append(IDs.begin(), IDs.end()); 1388} 1389 1390void ASTReader::ReadDefinedMacros() { 1391 // Note that we are loading defined macros. 1392 Deserializing Macros(this); 1393 1394 for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1395 E = ModuleMgr.rend(); I != E; ++I) { 1396 BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1397 1398 // If there was no preprocessor block, skip this file. 1399 if (!MacroCursor.getBitStreamReader()) 1400 continue; 1401 1402 BitstreamCursor Cursor = MacroCursor; 1403 Cursor.JumpToBit((*I)->MacroStartOffset); 1404 1405 RecordData Record; 1406 while (true) { 1407 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks(); 1408 1409 switch (E.Kind) { 1410 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1411 case llvm::BitstreamEntry::Error: 1412 Error("malformed block record in AST file"); 1413 return; 1414 case llvm::BitstreamEntry::EndBlock: 1415 goto NextCursor; 1416 1417 case llvm::BitstreamEntry::Record: 1418 Record.clear(); 1419 switch (Cursor.readRecord(E.ID, Record)) { 1420 default: // Default behavior: ignore. 1421 break; 1422 1423 case PP_MACRO_OBJECT_LIKE: 1424 case PP_MACRO_FUNCTION_LIKE: 1425 getLocalIdentifier(**I, Record[0]); 1426 break; 1427 1428 case PP_TOKEN: 1429 // Ignore tokens. 1430 break; 1431 } 1432 break; 1433 } 1434 } 1435 NextCursor: ; 1436 } 1437} 1438 1439namespace { 1440 /// \brief Visitor class used to look up identifirs in an AST file. 1441 class IdentifierLookupVisitor { 1442 StringRef Name; 1443 unsigned PriorGeneration; 1444 unsigned &NumIdentifierLookups; 1445 unsigned &NumIdentifierLookupHits; 1446 IdentifierInfo *Found; 1447 1448 public: 1449 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration, 1450 unsigned &NumIdentifierLookups, 1451 unsigned &NumIdentifierLookupHits) 1452 : Name(Name), PriorGeneration(PriorGeneration), 1453 NumIdentifierLookups(NumIdentifierLookups), 1454 NumIdentifierLookupHits(NumIdentifierLookupHits), 1455 Found() 1456 { 1457 } 1458 1459 static bool visit(ModuleFile &M, void *UserData) { 1460 IdentifierLookupVisitor *This 1461 = static_cast<IdentifierLookupVisitor *>(UserData); 1462 1463 // If we've already searched this module file, skip it now. 1464 if (M.Generation <= This->PriorGeneration) 1465 return true; 1466 1467 ASTIdentifierLookupTable *IdTable 1468 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable; 1469 if (!IdTable) 1470 return false; 1471 1472 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), 1473 M, This->Found); 1474 ++This->NumIdentifierLookups; 1475 ASTIdentifierLookupTable::iterator Pos = IdTable->find(This->Name,&Trait); 1476 if (Pos == IdTable->end()) 1477 return false; 1478 1479 // Dereferencing the iterator has the effect of building the 1480 // IdentifierInfo node and populating it with the various 1481 // declarations it needs. 1482 ++This->NumIdentifierLookupHits; 1483 This->Found = *Pos; 1484 return true; 1485 } 1486 1487 // \brief Retrieve the identifier info found within the module 1488 // files. 1489 IdentifierInfo *getIdentifierInfo() const { return Found; } 1490 }; 1491} 1492 1493void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) { 1494 // Note that we are loading an identifier. 1495 Deserializing AnIdentifier(this); 1496 1497 unsigned PriorGeneration = 0; 1498 if (getContext().getLangOpts().Modules) 1499 PriorGeneration = IdentifierGeneration[&II]; 1500 1501 // If there is a global index, look there first to determine which modules 1502 // provably do not have any results for this identifier. 1503 GlobalModuleIndex::HitSet Hits; 1504 GlobalModuleIndex::HitSet *HitsPtr = 0; 1505 if (!loadGlobalIndex()) { 1506 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) { 1507 HitsPtr = &Hits; 1508 } 1509 } 1510 1511 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration, 1512 NumIdentifierLookups, 1513 NumIdentifierLookupHits); 1514 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 1515 markIdentifierUpToDate(&II); 1516} 1517 1518void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) { 1519 if (!II) 1520 return; 1521 1522 II->setOutOfDate(false); 1523 1524 // Update the generation for this identifier. 1525 if (getContext().getLangOpts().Modules) 1526 IdentifierGeneration[II] = CurrentGeneration; 1527} 1528 1529InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) { 1530 // If this ID is bogus, just return an empty input file. 1531 if (ID == 0 || ID > F.InputFilesLoaded.size()) 1532 return InputFile(); 1533 1534 // If we've already loaded this input file, return it. 1535 if (F.InputFilesLoaded[ID-1].getFile()) 1536 return F.InputFilesLoaded[ID-1]; 1537 1538 // Go find this input file. 1539 BitstreamCursor &Cursor = F.InputFilesCursor; 1540 SavedStreamPosition SavedPosition(Cursor); 1541 Cursor.JumpToBit(F.InputFileOffsets[ID-1]); 1542 1543 unsigned Code = Cursor.ReadCode(); 1544 RecordData Record; 1545 StringRef Blob; 1546 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) { 1547 case INPUT_FILE: { 1548 unsigned StoredID = Record[0]; 1549 assert(ID == StoredID && "Bogus stored ID or offset"); 1550 (void)StoredID; 1551 off_t StoredSize = (off_t)Record[1]; 1552 time_t StoredTime = (time_t)Record[2]; 1553 bool Overridden = (bool)Record[3]; 1554 1555 // Get the file entry for this input file. 1556 StringRef OrigFilename = Blob; 1557 std::string Filename = OrigFilename; 1558 MaybeAddSystemRootToFilename(F, Filename); 1559 const FileEntry *File 1560 = Overridden? FileMgr.getVirtualFile(Filename, StoredSize, StoredTime) 1561 : FileMgr.getFile(Filename, /*OpenFile=*/false); 1562 1563 // If we didn't find the file, resolve it relative to the 1564 // original directory from which this AST file was created. 1565 if (File == 0 && !F.OriginalDir.empty() && !CurrentDir.empty() && 1566 F.OriginalDir != CurrentDir) { 1567 std::string Resolved = resolveFileRelativeToOriginalDir(Filename, 1568 F.OriginalDir, 1569 CurrentDir); 1570 if (!Resolved.empty()) 1571 File = FileMgr.getFile(Resolved); 1572 } 1573 1574 // For an overridden file, create a virtual file with the stored 1575 // size/timestamp. 1576 if (Overridden && File == 0) { 1577 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime); 1578 } 1579 1580 if (File == 0) { 1581 if (Complain) { 1582 std::string ErrorStr = "could not find file '"; 1583 ErrorStr += Filename; 1584 ErrorStr += "' referenced by AST file"; 1585 Error(ErrorStr.c_str()); 1586 } 1587 return InputFile(); 1588 } 1589 1590 // Check if there was a request to override the contents of the file 1591 // that was part of the precompiled header. Overridding such a file 1592 // can lead to problems when lexing using the source locations from the 1593 // PCH. 1594 SourceManager &SM = getSourceManager(); 1595 if (!Overridden && SM.isFileOverridden(File)) { 1596 if (Complain) 1597 Error(diag::err_fe_pch_file_overridden, Filename); 1598 // After emitting the diagnostic, recover by disabling the override so 1599 // that the original file will be used. 1600 SM.disableFileContentsOverride(File); 1601 // The FileEntry is a virtual file entry with the size of the contents 1602 // that would override the original contents. Set it to the original's 1603 // size/time. 1604 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File), 1605 StoredSize, StoredTime); 1606 } 1607 1608 bool IsOutOfDate = false; 1609 1610 // For an overridden file, there is nothing to validate. 1611 if (!Overridden && (StoredSize != File->getSize() 1612#if !defined(LLVM_ON_WIN32) 1613 // In our regression testing, the Windows file system seems to 1614 // have inconsistent modification times that sometimes 1615 // erroneously trigger this error-handling path. 1616 || StoredTime != File->getModificationTime() 1617#endif 1618 )) { 1619 if (Complain) { 1620 Error(diag::err_fe_pch_file_modified, Filename, F.FileName); 1621 } 1622 1623 IsOutOfDate = true; 1624 } 1625 1626 InputFile IF = InputFile(File, Overridden, IsOutOfDate); 1627 1628 // Note that we've loaded this input file. 1629 F.InputFilesLoaded[ID-1] = IF; 1630 return IF; 1631 } 1632 } 1633 1634 return InputFile(); 1635} 1636 1637const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) { 1638 ModuleFile &M = ModuleMgr.getPrimaryModule(); 1639 std::string Filename = filenameStrRef; 1640 MaybeAddSystemRootToFilename(M, Filename); 1641 const FileEntry *File = FileMgr.getFile(Filename); 1642 if (File == 0 && !M.OriginalDir.empty() && !CurrentDir.empty() && 1643 M.OriginalDir != CurrentDir) { 1644 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1645 M.OriginalDir, 1646 CurrentDir); 1647 if (!resolved.empty()) 1648 File = FileMgr.getFile(resolved); 1649 } 1650 1651 return File; 1652} 1653 1654/// \brief If we are loading a relocatable PCH file, and the filename is 1655/// not an absolute path, add the system root to the beginning of the file 1656/// name. 1657void ASTReader::MaybeAddSystemRootToFilename(ModuleFile &M, 1658 std::string &Filename) { 1659 // If this is not a relocatable PCH file, there's nothing to do. 1660 if (!M.RelocatablePCH) 1661 return; 1662 1663 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1664 return; 1665 1666 if (isysroot.empty()) { 1667 // If no system root was given, default to '/' 1668 Filename.insert(Filename.begin(), '/'); 1669 return; 1670 } 1671 1672 unsigned Length = isysroot.size(); 1673 if (isysroot[Length - 1] != '/') 1674 Filename.insert(Filename.begin(), '/'); 1675 1676 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end()); 1677} 1678 1679ASTReader::ASTReadResult 1680ASTReader::ReadControlBlock(ModuleFile &F, 1681 SmallVectorImpl<ImportedModule> &Loaded, 1682 unsigned ClientLoadCapabilities) { 1683 BitstreamCursor &Stream = F.Stream; 1684 1685 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) { 1686 Error("malformed block record in AST file"); 1687 return Failure; 1688 } 1689 1690 // Read all of the records and blocks in the control block. 1691 RecordData Record; 1692 while (1) { 1693 llvm::BitstreamEntry Entry = Stream.advance(); 1694 1695 switch (Entry.Kind) { 1696 case llvm::BitstreamEntry::Error: 1697 Error("malformed block record in AST file"); 1698 return Failure; 1699 case llvm::BitstreamEntry::EndBlock: 1700 // Validate all of the non-system input files. 1701 if (!DisableValidation) { 1702 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0; 1703 // All user input files reside at the index range [0, Record[1]). 1704 // Record is the one from INPUT_FILE_OFFSETS. 1705 for (unsigned I = 0, N = Record[1]; I < N; ++I) { 1706 InputFile IF = getInputFile(F, I+1, Complain); 1707 if (!IF.getFile() || IF.isOutOfDate()) 1708 return OutOfDate; 1709 } 1710 } 1711 return Success; 1712 1713 case llvm::BitstreamEntry::SubBlock: 1714 switch (Entry.ID) { 1715 case INPUT_FILES_BLOCK_ID: 1716 F.InputFilesCursor = Stream; 1717 if (Stream.SkipBlock() || // Skip with the main cursor 1718 // Read the abbreviations 1719 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) { 1720 Error("malformed block record in AST file"); 1721 return Failure; 1722 } 1723 continue; 1724 1725 default: 1726 if (Stream.SkipBlock()) { 1727 Error("malformed block record in AST file"); 1728 return Failure; 1729 } 1730 continue; 1731 } 1732 1733 case llvm::BitstreamEntry::Record: 1734 // The interesting case. 1735 break; 1736 } 1737 1738 // Read and process a record. 1739 Record.clear(); 1740 StringRef Blob; 1741 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) { 1742 case METADATA: { 1743 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1744 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 1745 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1746 : diag::warn_pch_version_too_new); 1747 return VersionMismatch; 1748 } 1749 1750 bool hasErrors = Record[5]; 1751 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) { 1752 Diag(diag::err_pch_with_compiler_errors); 1753 return HadErrors; 1754 } 1755 1756 F.RelocatablePCH = Record[4]; 1757 1758 const std::string &CurBranch = getClangFullRepositoryVersion(); 1759 StringRef ASTBranch = Blob; 1760 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 1761 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 1762 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 1763 return VersionMismatch; 1764 } 1765 break; 1766 } 1767 1768 case IMPORTS: { 1769 // Load each of the imported PCH files. 1770 unsigned Idx = 0, N = Record.size(); 1771 while (Idx < N) { 1772 // Read information about the AST file. 1773 ModuleKind ImportedKind = (ModuleKind)Record[Idx++]; 1774 // The import location will be the local one for now; we will adjust 1775 // all import locations of module imports after the global source 1776 // location info are setup. 1777 SourceLocation ImportLoc = 1778 SourceLocation::getFromRawEncoding(Record[Idx++]); 1779 off_t StoredSize = (off_t)Record[Idx++]; 1780 time_t StoredModTime = (time_t)Record[Idx++]; 1781 unsigned Length = Record[Idx++]; 1782 SmallString<128> ImportedFile(Record.begin() + Idx, 1783 Record.begin() + Idx + Length); 1784 Idx += Length; 1785 1786 // Load the AST file. 1787 switch(ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F, Loaded, 1788 StoredSize, StoredModTime, 1789 ClientLoadCapabilities)) { 1790 case Failure: return Failure; 1791 // If we have to ignore the dependency, we'll have to ignore this too. 1792 case Missing: 1793 case OutOfDate: return OutOfDate; 1794 case VersionMismatch: return VersionMismatch; 1795 case ConfigurationMismatch: return ConfigurationMismatch; 1796 case HadErrors: return HadErrors; 1797 case Success: break; 1798 } 1799 } 1800 break; 1801 } 1802 1803 case LANGUAGE_OPTIONS: { 1804 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0; 1805 if (Listener && &F == *ModuleMgr.begin() && 1806 ParseLanguageOptions(Record, Complain, *Listener) && 1807 !DisableValidation) 1808 return ConfigurationMismatch; 1809 break; 1810 } 1811 1812 case TARGET_OPTIONS: { 1813 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1814 if (Listener && &F == *ModuleMgr.begin() && 1815 ParseTargetOptions(Record, Complain, *Listener) && 1816 !DisableValidation) 1817 return ConfigurationMismatch; 1818 break; 1819 } 1820 1821 case DIAGNOSTIC_OPTIONS: { 1822 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1823 if (Listener && &F == *ModuleMgr.begin() && 1824 ParseDiagnosticOptions(Record, Complain, *Listener) && 1825 !DisableValidation) 1826 return ConfigurationMismatch; 1827 break; 1828 } 1829 1830 case FILE_SYSTEM_OPTIONS: { 1831 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1832 if (Listener && &F == *ModuleMgr.begin() && 1833 ParseFileSystemOptions(Record, Complain, *Listener) && 1834 !DisableValidation) 1835 return ConfigurationMismatch; 1836 break; 1837 } 1838 1839 case HEADER_SEARCH_OPTIONS: { 1840 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1841 if (Listener && &F == *ModuleMgr.begin() && 1842 ParseHeaderSearchOptions(Record, Complain, *Listener) && 1843 !DisableValidation) 1844 return ConfigurationMismatch; 1845 break; 1846 } 1847 1848 case PREPROCESSOR_OPTIONS: { 1849 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1850 if (Listener && &F == *ModuleMgr.begin() && 1851 ParsePreprocessorOptions(Record, Complain, *Listener, 1852 SuggestedPredefines) && 1853 !DisableValidation) 1854 return ConfigurationMismatch; 1855 break; 1856 } 1857 1858 case ORIGINAL_FILE: 1859 F.OriginalSourceFileID = FileID::get(Record[0]); 1860 F.ActualOriginalSourceFileName = Blob; 1861 F.OriginalSourceFileName = F.ActualOriginalSourceFileName; 1862 MaybeAddSystemRootToFilename(F, F.OriginalSourceFileName); 1863 break; 1864 1865 case ORIGINAL_FILE_ID: 1866 F.OriginalSourceFileID = FileID::get(Record[0]); 1867 break; 1868 1869 case ORIGINAL_PCH_DIR: 1870 F.OriginalDir = Blob; 1871 break; 1872 1873 case INPUT_FILE_OFFSETS: 1874 F.InputFileOffsets = (const uint32_t *)Blob.data(); 1875 F.InputFilesLoaded.resize(Record[0]); 1876 break; 1877 } 1878 } 1879} 1880 1881bool ASTReader::ReadASTBlock(ModuleFile &F) { 1882 BitstreamCursor &Stream = F.Stream; 1883 1884 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1885 Error("malformed block record in AST file"); 1886 return true; 1887 } 1888 1889 // Read all of the records and blocks for the AST file. 1890 RecordData Record; 1891 while (1) { 1892 llvm::BitstreamEntry Entry = Stream.advance(); 1893 1894 switch (Entry.Kind) { 1895 case llvm::BitstreamEntry::Error: 1896 Error("error at end of module block in AST file"); 1897 return true; 1898 case llvm::BitstreamEntry::EndBlock: { 1899 DeclContext *DC = Context.getTranslationUnitDecl(); 1900 if (!DC->hasExternalVisibleStorage() && DC->hasExternalLexicalStorage()) 1901 DC->setMustBuildLookupTable(); 1902 1903 return false; 1904 } 1905 case llvm::BitstreamEntry::SubBlock: 1906 switch (Entry.ID) { 1907 case DECLTYPES_BLOCK_ID: 1908 // We lazily load the decls block, but we want to set up the 1909 // DeclsCursor cursor to point into it. Clone our current bitcode 1910 // cursor to it, enter the block and read the abbrevs in that block. 1911 // With the main cursor, we just skip over it. 1912 F.DeclsCursor = Stream; 1913 if (Stream.SkipBlock() || // Skip with the main cursor. 1914 // Read the abbrevs. 1915 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1916 Error("malformed block record in AST file"); 1917 return true; 1918 } 1919 break; 1920 1921 case DECL_UPDATES_BLOCK_ID: 1922 if (Stream.SkipBlock()) { 1923 Error("malformed block record in AST file"); 1924 return true; 1925 } 1926 break; 1927 1928 case PREPROCESSOR_BLOCK_ID: 1929 F.MacroCursor = Stream; 1930 if (!PP.getExternalSource()) 1931 PP.setExternalSource(this); 1932 1933 if (Stream.SkipBlock() || 1934 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1935 Error("malformed block record in AST file"); 1936 return true; 1937 } 1938 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1939 break; 1940 1941 case PREPROCESSOR_DETAIL_BLOCK_ID: 1942 F.PreprocessorDetailCursor = Stream; 1943 if (Stream.SkipBlock() || 1944 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 1945 PREPROCESSOR_DETAIL_BLOCK_ID)) { 1946 Error("malformed preprocessor detail record in AST file"); 1947 return true; 1948 } 1949 F.PreprocessorDetailStartOffset 1950 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 1951 1952 if (!PP.getPreprocessingRecord()) 1953 PP.createPreprocessingRecord(); 1954 if (!PP.getPreprocessingRecord()->getExternalSource()) 1955 PP.getPreprocessingRecord()->SetExternalSource(*this); 1956 break; 1957 1958 case SOURCE_MANAGER_BLOCK_ID: 1959 if (ReadSourceManagerBlock(F)) 1960 return true; 1961 break; 1962 1963 case SUBMODULE_BLOCK_ID: 1964 if (ReadSubmoduleBlock(F)) 1965 return true; 1966 break; 1967 1968 case COMMENTS_BLOCK_ID: { 1969 BitstreamCursor C = Stream; 1970 if (Stream.SkipBlock() || 1971 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) { 1972 Error("malformed comments block in AST file"); 1973 return true; 1974 } 1975 CommentsCursors.push_back(std::make_pair(C, &F)); 1976 break; 1977 } 1978 1979 default: 1980 if (Stream.SkipBlock()) { 1981 Error("malformed block record in AST file"); 1982 return true; 1983 } 1984 break; 1985 } 1986 continue; 1987 1988 case llvm::BitstreamEntry::Record: 1989 // The interesting case. 1990 break; 1991 } 1992 1993 // Read and process a record. 1994 Record.clear(); 1995 StringRef Blob; 1996 switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) { 1997 default: // Default behavior: ignore. 1998 break; 1999 2000 case TYPE_OFFSET: { 2001 if (F.LocalNumTypes != 0) { 2002 Error("duplicate TYPE_OFFSET record in AST file"); 2003 return true; 2004 } 2005 F.TypeOffsets = (const uint32_t *)Blob.data(); 2006 F.LocalNumTypes = Record[0]; 2007 unsigned LocalBaseTypeIndex = Record[1]; 2008 F.BaseTypeIndex = getTotalNumTypes(); 2009 2010 if (F.LocalNumTypes > 0) { 2011 // Introduce the global -> local mapping for types within this module. 2012 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 2013 2014 // Introduce the local -> global mapping for types within this module. 2015 F.TypeRemap.insertOrReplace( 2016 std::make_pair(LocalBaseTypeIndex, 2017 F.BaseTypeIndex - LocalBaseTypeIndex)); 2018 2019 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 2020 } 2021 break; 2022 } 2023 2024 case DECL_OFFSET: { 2025 if (F.LocalNumDecls != 0) { 2026 Error("duplicate DECL_OFFSET record in AST file"); 2027 return true; 2028 } 2029 F.DeclOffsets = (const DeclOffset *)Blob.data(); 2030 F.LocalNumDecls = Record[0]; 2031 unsigned LocalBaseDeclID = Record[1]; 2032 F.BaseDeclID = getTotalNumDecls(); 2033 2034 if (F.LocalNumDecls > 0) { 2035 // Introduce the global -> local mapping for declarations within this 2036 // module. 2037 GlobalDeclMap.insert( 2038 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 2039 2040 // Introduce the local -> global mapping for declarations within this 2041 // module. 2042 F.DeclRemap.insertOrReplace( 2043 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID)); 2044 2045 // Introduce the global -> local mapping for declarations within this 2046 // module. 2047 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID; 2048 2049 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 2050 } 2051 break; 2052 } 2053 2054 case TU_UPDATE_LEXICAL: { 2055 DeclContext *TU = Context.getTranslationUnitDecl(); 2056 DeclContextInfo &Info = F.DeclContextInfos[TU]; 2057 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(Blob.data()); 2058 Info.NumLexicalDecls 2059 = static_cast<unsigned int>(Blob.size() / sizeof(KindDeclIDPair)); 2060 TU->setHasExternalLexicalStorage(true); 2061 break; 2062 } 2063 2064 case UPDATE_VISIBLE: { 2065 unsigned Idx = 0; 2066 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 2067 ASTDeclContextNameLookupTable *Table = 2068 ASTDeclContextNameLookupTable::Create( 2069 (const unsigned char *)Blob.data() + Record[Idx++], 2070 (const unsigned char *)Blob.data(), 2071 ASTDeclContextNameLookupTrait(*this, F)); 2072 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU? 2073 DeclContext *TU = Context.getTranslationUnitDecl(); 2074 F.DeclContextInfos[TU].NameLookupTableData = Table; 2075 TU->setHasExternalVisibleStorage(true); 2076 } else 2077 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 2078 break; 2079 } 2080 2081 case IDENTIFIER_TABLE: 2082 F.IdentifierTableData = Blob.data(); 2083 if (Record[0]) { 2084 F.IdentifierLookupTable 2085 = ASTIdentifierLookupTable::Create( 2086 (const unsigned char *)F.IdentifierTableData + Record[0], 2087 (const unsigned char *)F.IdentifierTableData, 2088 ASTIdentifierLookupTrait(*this, F)); 2089 2090 PP.getIdentifierTable().setExternalIdentifierLookup(this); 2091 } 2092 break; 2093 2094 case IDENTIFIER_OFFSET: { 2095 if (F.LocalNumIdentifiers != 0) { 2096 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2097 return true; 2098 } 2099 F.IdentifierOffsets = (const uint32_t *)Blob.data(); 2100 F.LocalNumIdentifiers = Record[0]; 2101 unsigned LocalBaseIdentifierID = Record[1]; 2102 F.BaseIdentifierID = getTotalNumIdentifiers(); 2103 2104 if (F.LocalNumIdentifiers > 0) { 2105 // Introduce the global -> local mapping for identifiers within this 2106 // module. 2107 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 2108 &F)); 2109 2110 // Introduce the local -> global mapping for identifiers within this 2111 // module. 2112 F.IdentifierRemap.insertOrReplace( 2113 std::make_pair(LocalBaseIdentifierID, 2114 F.BaseIdentifierID - LocalBaseIdentifierID)); 2115 2116 IdentifiersLoaded.resize(IdentifiersLoaded.size() 2117 + F.LocalNumIdentifiers); 2118 } 2119 break; 2120 } 2121 2122 case EXTERNAL_DEFINITIONS: 2123 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2124 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2125 break; 2126 2127 case SPECIAL_TYPES: 2128 if (SpecialTypes.empty()) { 2129 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2130 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 2131 break; 2132 } 2133 2134 if (SpecialTypes.size() != Record.size()) { 2135 Error("invalid special-types record"); 2136 return true; 2137 } 2138 2139 for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2140 serialization::TypeID ID = getGlobalTypeID(F, Record[I]); 2141 if (!SpecialTypes[I]) 2142 SpecialTypes[I] = ID; 2143 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate 2144 // merge step? 2145 } 2146 break; 2147 2148 case STATISTICS: 2149 TotalNumStatements += Record[0]; 2150 TotalNumMacros += Record[1]; 2151 TotalLexicalDeclContexts += Record[2]; 2152 TotalVisibleDeclContexts += Record[3]; 2153 break; 2154 2155 case UNUSED_FILESCOPED_DECLS: 2156 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2157 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 2158 break; 2159 2160 case DELEGATING_CTORS: 2161 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2162 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 2163 break; 2164 2165 case WEAK_UNDECLARED_IDENTIFIERS: 2166 if (Record.size() % 4 != 0) { 2167 Error("invalid weak identifiers record"); 2168 return true; 2169 } 2170 2171 // FIXME: Ignore weak undeclared identifiers from non-original PCH 2172 // files. This isn't the way to do it :) 2173 WeakUndeclaredIdentifiers.clear(); 2174 2175 // Translate the weak, undeclared identifiers into global IDs. 2176 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 2177 WeakUndeclaredIdentifiers.push_back( 2178 getGlobalIdentifierID(F, Record[I++])); 2179 WeakUndeclaredIdentifiers.push_back( 2180 getGlobalIdentifierID(F, Record[I++])); 2181 WeakUndeclaredIdentifiers.push_back( 2182 ReadSourceLocation(F, Record, I).getRawEncoding()); 2183 WeakUndeclaredIdentifiers.push_back(Record[I++]); 2184 } 2185 break; 2186 2187 case LOCALLY_SCOPED_EXTERN_C_DECLS: 2188 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2189 LocallyScopedExternCDecls.push_back(getGlobalDeclID(F, Record[I])); 2190 break; 2191 2192 case SELECTOR_OFFSETS: { 2193 F.SelectorOffsets = (const uint32_t *)Blob.data(); 2194 F.LocalNumSelectors = Record[0]; 2195 unsigned LocalBaseSelectorID = Record[1]; 2196 F.BaseSelectorID = getTotalNumSelectors(); 2197 2198 if (F.LocalNumSelectors > 0) { 2199 // Introduce the global -> local mapping for selectors within this 2200 // module. 2201 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2202 2203 // Introduce the local -> global mapping for selectors within this 2204 // module. 2205 F.SelectorRemap.insertOrReplace( 2206 std::make_pair(LocalBaseSelectorID, 2207 F.BaseSelectorID - LocalBaseSelectorID)); 2208 2209 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2210 } 2211 break; 2212 } 2213 2214 case METHOD_POOL: 2215 F.SelectorLookupTableData = (const unsigned char *)Blob.data(); 2216 if (Record[0]) 2217 F.SelectorLookupTable 2218 = ASTSelectorLookupTable::Create( 2219 F.SelectorLookupTableData + Record[0], 2220 F.SelectorLookupTableData, 2221 ASTSelectorLookupTrait(*this, F)); 2222 TotalNumMethodPoolEntries += Record[1]; 2223 break; 2224 2225 case REFERENCED_SELECTOR_POOL: 2226 if (!Record.empty()) { 2227 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2228 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2229 Record[Idx++])); 2230 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2231 getRawEncoding()); 2232 } 2233 } 2234 break; 2235 2236 case PP_COUNTER_VALUE: 2237 if (!Record.empty() && Listener) 2238 Listener->ReadCounter(F, Record[0]); 2239 break; 2240 2241 case FILE_SORTED_DECLS: 2242 F.FileSortedDecls = (const DeclID *)Blob.data(); 2243 F.NumFileSortedDecls = Record[0]; 2244 break; 2245 2246 case SOURCE_LOCATION_OFFSETS: { 2247 F.SLocEntryOffsets = (const uint32_t *)Blob.data(); 2248 F.LocalNumSLocEntries = Record[0]; 2249 unsigned SLocSpaceSize = Record[1]; 2250 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2251 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, 2252 SLocSpaceSize); 2253 // Make our entry in the range map. BaseID is negative and growing, so 2254 // we invert it. Because we invert it, though, we need the other end of 2255 // the range. 2256 unsigned RangeStart = 2257 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2258 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2259 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2260 2261 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing. 2262 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0); 2263 GlobalSLocOffsetMap.insert( 2264 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset 2265 - SLocSpaceSize,&F)); 2266 2267 // Initialize the remapping table. 2268 // Invalid stays invalid. 2269 F.SLocRemap.insert(std::make_pair(0U, 0)); 2270 // This module. Base was 2 when being compiled. 2271 F.SLocRemap.insert(std::make_pair(2U, 2272 static_cast<int>(F.SLocEntryBaseOffset - 2))); 2273 2274 TotalNumSLocEntries += F.LocalNumSLocEntries; 2275 break; 2276 } 2277 2278 case MODULE_OFFSET_MAP: { 2279 // Additional remapping information. 2280 const unsigned char *Data = (const unsigned char*)Blob.data(); 2281 const unsigned char *DataEnd = Data + Blob.size(); 2282 2283 // Continuous range maps we may be updating in our module. 2284 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 2285 ContinuousRangeMap<uint32_t, int, 2>::Builder 2286 IdentifierRemap(F.IdentifierRemap); 2287 ContinuousRangeMap<uint32_t, int, 2>::Builder 2288 MacroRemap(F.MacroRemap); 2289 ContinuousRangeMap<uint32_t, int, 2>::Builder 2290 PreprocessedEntityRemap(F.PreprocessedEntityRemap); 2291 ContinuousRangeMap<uint32_t, int, 2>::Builder 2292 SubmoduleRemap(F.SubmoduleRemap); 2293 ContinuousRangeMap<uint32_t, int, 2>::Builder 2294 SelectorRemap(F.SelectorRemap); 2295 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 2296 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 2297 2298 while(Data < DataEnd) { 2299 uint16_t Len = io::ReadUnalignedLE16(Data); 2300 StringRef Name = StringRef((const char*)Data, Len); 2301 Data += Len; 2302 ModuleFile *OM = ModuleMgr.lookup(Name); 2303 if (!OM) { 2304 Error("SourceLocation remap refers to unknown module"); 2305 return true; 2306 } 2307 2308 uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 2309 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 2310 uint32_t MacroIDOffset = io::ReadUnalignedLE32(Data); 2311 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 2312 uint32_t SubmoduleIDOffset = io::ReadUnalignedLE32(Data); 2313 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 2314 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 2315 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2316 2317 // Source location offset is mapped to OM->SLocEntryBaseOffset. 2318 SLocRemap.insert(std::make_pair(SLocOffset, 2319 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2320 IdentifierRemap.insert( 2321 std::make_pair(IdentifierIDOffset, 2322 OM->BaseIdentifierID - IdentifierIDOffset)); 2323 MacroRemap.insert(std::make_pair(MacroIDOffset, 2324 OM->BaseMacroID - MacroIDOffset)); 2325 PreprocessedEntityRemap.insert( 2326 std::make_pair(PreprocessedEntityIDOffset, 2327 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); 2328 SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset, 2329 OM->BaseSubmoduleID - SubmoduleIDOffset)); 2330 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2331 OM->BaseSelectorID - SelectorIDOffset)); 2332 DeclRemap.insert(std::make_pair(DeclIDOffset, 2333 OM->BaseDeclID - DeclIDOffset)); 2334 2335 TypeRemap.insert(std::make_pair(TypeIndexOffset, 2336 OM->BaseTypeIndex - TypeIndexOffset)); 2337 2338 // Global -> local mappings. 2339 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset; 2340 } 2341 break; 2342 } 2343 2344 case SOURCE_MANAGER_LINE_TABLE: 2345 if (ParseLineTable(F, Record)) 2346 return true; 2347 break; 2348 2349 case SOURCE_LOCATION_PRELOADS: { 2350 // Need to transform from the local view (1-based IDs) to the global view, 2351 // which is based off F.SLocEntryBaseID. 2352 if (!F.PreloadSLocEntries.empty()) { 2353 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file"); 2354 return true; 2355 } 2356 2357 F.PreloadSLocEntries.swap(Record); 2358 break; 2359 } 2360 2361 case EXT_VECTOR_DECLS: 2362 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2363 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2364 break; 2365 2366 case VTABLE_USES: 2367 if (Record.size() % 3 != 0) { 2368 Error("Invalid VTABLE_USES record"); 2369 return true; 2370 } 2371 2372 // Later tables overwrite earlier ones. 2373 // FIXME: Modules will have some trouble with this. This is clearly not 2374 // the right way to do this. 2375 VTableUses.clear(); 2376 2377 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2378 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2379 VTableUses.push_back( 2380 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2381 VTableUses.push_back(Record[Idx++]); 2382 } 2383 break; 2384 2385 case DYNAMIC_CLASSES: 2386 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2387 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2388 break; 2389 2390 case PENDING_IMPLICIT_INSTANTIATIONS: 2391 if (PendingInstantiations.size() % 2 != 0) { 2392 Error("Invalid existing PendingInstantiations"); 2393 return true; 2394 } 2395 2396 if (Record.size() % 2 != 0) { 2397 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2398 return true; 2399 } 2400 2401 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2402 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2403 PendingInstantiations.push_back( 2404 ReadSourceLocation(F, Record, I).getRawEncoding()); 2405 } 2406 break; 2407 2408 case SEMA_DECL_REFS: 2409 // Later tables overwrite earlier ones. 2410 // FIXME: Modules will have some trouble with this. 2411 SemaDeclRefs.clear(); 2412 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2413 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2414 break; 2415 2416 case PPD_ENTITIES_OFFSETS: { 2417 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data(); 2418 assert(Blob.size() % sizeof(PPEntityOffset) == 0); 2419 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset); 2420 2421 unsigned LocalBasePreprocessedEntityID = Record[0]; 2422 2423 unsigned StartingID; 2424 if (!PP.getPreprocessingRecord()) 2425 PP.createPreprocessingRecord(); 2426 if (!PP.getPreprocessingRecord()->getExternalSource()) 2427 PP.getPreprocessingRecord()->SetExternalSource(*this); 2428 StartingID 2429 = PP.getPreprocessingRecord() 2430 ->allocateLoadedEntities(F.NumPreprocessedEntities); 2431 F.BasePreprocessedEntityID = StartingID; 2432 2433 if (F.NumPreprocessedEntities > 0) { 2434 // Introduce the global -> local mapping for preprocessed entities in 2435 // this module. 2436 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2437 2438 // Introduce the local -> global mapping for preprocessed entities in 2439 // this module. 2440 F.PreprocessedEntityRemap.insertOrReplace( 2441 std::make_pair(LocalBasePreprocessedEntityID, 2442 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 2443 } 2444 2445 break; 2446 } 2447 2448 case DECL_UPDATE_OFFSETS: { 2449 if (Record.size() % 2 != 0) { 2450 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2451 return true; 2452 } 2453 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2454 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2455 .push_back(std::make_pair(&F, Record[I+1])); 2456 break; 2457 } 2458 2459 case DECL_REPLACEMENTS: { 2460 if (Record.size() % 3 != 0) { 2461 Error("invalid DECL_REPLACEMENTS block in AST file"); 2462 return true; 2463 } 2464 for (unsigned I = 0, N = Record.size(); I != N; I += 3) 2465 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2466 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]); 2467 break; 2468 } 2469 2470 case OBJC_CATEGORIES_MAP: { 2471 if (F.LocalNumObjCCategoriesInMap != 0) { 2472 Error("duplicate OBJC_CATEGORIES_MAP record in AST file"); 2473 return true; 2474 } 2475 2476 F.LocalNumObjCCategoriesInMap = Record[0]; 2477 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data(); 2478 break; 2479 } 2480 2481 case OBJC_CATEGORIES: 2482 F.ObjCCategories.swap(Record); 2483 break; 2484 2485 case CXX_BASE_SPECIFIER_OFFSETS: { 2486 if (F.LocalNumCXXBaseSpecifiers != 0) { 2487 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2488 return true; 2489 } 2490 2491 F.LocalNumCXXBaseSpecifiers = Record[0]; 2492 F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data(); 2493 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2494 break; 2495 } 2496 2497 case DIAG_PRAGMA_MAPPINGS: 2498 if (F.PragmaDiagMappings.empty()) 2499 F.PragmaDiagMappings.swap(Record); 2500 else 2501 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2502 Record.begin(), Record.end()); 2503 break; 2504 2505 case CUDA_SPECIAL_DECL_REFS: 2506 // Later tables overwrite earlier ones. 2507 // FIXME: Modules will have trouble with this. 2508 CUDASpecialDeclRefs.clear(); 2509 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2510 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2511 break; 2512 2513 case HEADER_SEARCH_TABLE: { 2514 F.HeaderFileInfoTableData = Blob.data(); 2515 F.LocalNumHeaderFileInfos = Record[1]; 2516 if (Record[0]) { 2517 F.HeaderFileInfoTable 2518 = HeaderFileInfoLookupTable::Create( 2519 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2520 (const unsigned char *)F.HeaderFileInfoTableData, 2521 HeaderFileInfoTrait(*this, F, 2522 &PP.getHeaderSearchInfo(), 2523 Blob.data() + Record[2])); 2524 2525 PP.getHeaderSearchInfo().SetExternalSource(this); 2526 if (!PP.getHeaderSearchInfo().getExternalLookup()) 2527 PP.getHeaderSearchInfo().SetExternalLookup(this); 2528 } 2529 break; 2530 } 2531 2532 case FP_PRAGMA_OPTIONS: 2533 // Later tables overwrite earlier ones. 2534 FPPragmaOptions.swap(Record); 2535 break; 2536 2537 case OPENCL_EXTENSIONS: 2538 // Later tables overwrite earlier ones. 2539 OpenCLExtensions.swap(Record); 2540 break; 2541 2542 case TENTATIVE_DEFINITIONS: 2543 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2544 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2545 break; 2546 2547 case KNOWN_NAMESPACES: 2548 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2549 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2550 break; 2551 2552 case UNDEFINED_BUT_USED: 2553 if (UndefinedButUsed.size() % 2 != 0) { 2554 Error("Invalid existing UndefinedButUsed"); 2555 return true; 2556 } 2557 2558 if (Record.size() % 2 != 0) { 2559 Error("invalid undefined-but-used record"); 2560 return true; 2561 } 2562 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2563 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++])); 2564 UndefinedButUsed.push_back( 2565 ReadSourceLocation(F, Record, I).getRawEncoding()); 2566 } 2567 break; 2568 2569 case IMPORTED_MODULES: { 2570 if (F.Kind != MK_Module) { 2571 // If we aren't loading a module (which has its own exports), make 2572 // all of the imported modules visible. 2573 // FIXME: Deal with macros-only imports. 2574 for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2575 if (unsigned GlobalID = getGlobalSubmoduleID(F, Record[I])) 2576 ImportedModules.push_back(GlobalID); 2577 } 2578 } 2579 break; 2580 } 2581 2582 case LOCAL_REDECLARATIONS: { 2583 F.RedeclarationChains.swap(Record); 2584 break; 2585 } 2586 2587 case LOCAL_REDECLARATIONS_MAP: { 2588 if (F.LocalNumRedeclarationsInMap != 0) { 2589 Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file"); 2590 return true; 2591 } 2592 2593 F.LocalNumRedeclarationsInMap = Record[0]; 2594 F.RedeclarationsMap = (const LocalRedeclarationsInfo *)Blob.data(); 2595 break; 2596 } 2597 2598 case MERGED_DECLARATIONS: { 2599 for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) { 2600 GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]); 2601 SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID]; 2602 for (unsigned N = Record[Idx++]; N > 0; --N) 2603 Decls.push_back(getGlobalDeclID(F, Record[Idx++])); 2604 } 2605 break; 2606 } 2607 2608 case MACRO_OFFSET: { 2609 if (F.LocalNumMacros != 0) { 2610 Error("duplicate MACRO_OFFSET record in AST file"); 2611 return true; 2612 } 2613 F.MacroOffsets = (const uint32_t *)Blob.data(); 2614 F.LocalNumMacros = Record[0]; 2615 unsigned LocalBaseMacroID = Record[1]; 2616 F.BaseMacroID = getTotalNumMacros(); 2617 2618 if (F.LocalNumMacros > 0) { 2619 // Introduce the global -> local mapping for macros within this module. 2620 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F)); 2621 2622 // Introduce the local -> global mapping for macros within this module. 2623 F.MacroRemap.insertOrReplace( 2624 std::make_pair(LocalBaseMacroID, 2625 F.BaseMacroID - LocalBaseMacroID)); 2626 2627 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros); 2628 } 2629 break; 2630 } 2631 2632 case MACRO_UPDATES: { 2633 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2634 MacroID ID = getGlobalMacroID(F, Record[I++]); 2635 if (I == N) 2636 break; 2637 2638 SourceLocation UndefLoc = ReadSourceLocation(F, Record, I); 2639 SubmoduleID SubmoduleID = getGlobalSubmoduleID(F, Record[I++]);; 2640 MacroUpdate Update; 2641 Update.UndefLoc = UndefLoc; 2642 MacroUpdates[ID].push_back(std::make_pair(SubmoduleID, Update)); 2643 } 2644 break; 2645 } 2646 } 2647 } 2648} 2649 2650/// \brief Move the given method to the back of the global list of methods. 2651static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) { 2652 // Find the entry for this selector in the method pool. 2653 Sema::GlobalMethodPool::iterator Known 2654 = S.MethodPool.find(Method->getSelector()); 2655 if (Known == S.MethodPool.end()) 2656 return; 2657 2658 // Retrieve the appropriate method list. 2659 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first 2660 : Known->second.second; 2661 bool Found = false; 2662 for (ObjCMethodList *List = &Start; List; List = List->Next) { 2663 if (!Found) { 2664 if (List->Method == Method) { 2665 Found = true; 2666 } else { 2667 // Keep searching. 2668 continue; 2669 } 2670 } 2671 2672 if (List->Next) 2673 List->Method = List->Next->Method; 2674 else 2675 List->Method = Method; 2676 } 2677} 2678 2679void ASTReader::makeNamesVisible(const HiddenNames &Names) { 2680 for (unsigned I = 0, N = Names.size(); I != N; ++I) { 2681 switch (Names[I].getKind()) { 2682 case HiddenName::Declaration: { 2683 Decl *D = Names[I].getDecl(); 2684 bool wasHidden = D->Hidden; 2685 D->Hidden = false; 2686 2687 if (wasHidden && SemaObj) { 2688 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) { 2689 moveMethodToBackOfGlobalList(*SemaObj, Method); 2690 } 2691 } 2692 break; 2693 } 2694 case HiddenName::MacroVisibility: { 2695 std::pair<IdentifierInfo *, MacroDirective *> Macro = Names[I].getMacro(); 2696 Macro.second->setHidden(!Macro.second->isPublic()); 2697 if (Macro.second->isDefined()) { 2698 PP.makeLoadedMacroInfoVisible(Macro.first, Macro.second); 2699 } 2700 break; 2701 } 2702 2703 case HiddenName::MacroUndef: { 2704 std::pair<IdentifierInfo *, MacroDirective *> Macro = Names[I].getMacro(); 2705 if (Macro.second->isDefined()) { 2706 Macro.second->setUndefLoc(Names[I].getMacroUndefLoc()); 2707 if (PPMutationListener *Listener = PP.getPPMutationListener()) 2708 Listener->UndefinedMacro(Macro.second); 2709 PP.makeLoadedMacroInfoVisible(Macro.first, Macro.second); 2710 } 2711 break; 2712 } 2713 } 2714 } 2715} 2716 2717void ASTReader::makeModuleVisible(Module *Mod, 2718 Module::NameVisibilityKind NameVisibility, 2719 SourceLocation ImportLoc, 2720 bool Complain) { 2721 llvm::SmallPtrSet<Module *, 4> Visited; 2722 SmallVector<Module *, 4> Stack; 2723 Stack.push_back(Mod); 2724 while (!Stack.empty()) { 2725 Mod = Stack.back(); 2726 Stack.pop_back(); 2727 2728 if (NameVisibility <= Mod->NameVisibility) { 2729 // This module already has this level of visibility (or greater), so 2730 // there is nothing more to do. 2731 continue; 2732 } 2733 2734 if (!Mod->isAvailable()) { 2735 // Modules that aren't available cannot be made visible. 2736 continue; 2737 } 2738 2739 // Update the module's name visibility. 2740 Mod->NameVisibility = NameVisibility; 2741 2742 // If we've already deserialized any names from this module, 2743 // mark them as visible. 2744 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 2745 if (Hidden != HiddenNamesMap.end()) { 2746 makeNamesVisible(Hidden->second); 2747 HiddenNamesMap.erase(Hidden); 2748 } 2749 2750 // Push any non-explicit submodules onto the stack to be marked as 2751 // visible. 2752 for (Module::submodule_iterator Sub = Mod->submodule_begin(), 2753 SubEnd = Mod->submodule_end(); 2754 Sub != SubEnd; ++Sub) { 2755 if (!(*Sub)->IsExplicit && Visited.insert(*Sub)) 2756 Stack.push_back(*Sub); 2757 } 2758 2759 // Push any exported modules onto the stack to be marked as visible. 2760 SmallVector<Module *, 16> Exports; 2761 Mod->getExportedModules(Exports); 2762 for (SmallVectorImpl<Module *>::iterator 2763 I = Exports.begin(), E = Exports.end(); I != E; ++I) { 2764 Module *Exported = *I; 2765 if (Visited.insert(Exported)) 2766 Stack.push_back(Exported); 2767 } 2768 2769 // Detect any conflicts. 2770 if (Complain) { 2771 assert(ImportLoc.isValid() && "Missing import location"); 2772 for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { 2773 if (Mod->Conflicts[I].Other->NameVisibility >= NameVisibility) { 2774 Diag(ImportLoc, diag::warn_module_conflict) 2775 << Mod->getFullModuleName() 2776 << Mod->Conflicts[I].Other->getFullModuleName() 2777 << Mod->Conflicts[I].Message; 2778 // FIXME: Need note where the other module was imported. 2779 } 2780 } 2781 } 2782 } 2783} 2784 2785bool ASTReader::loadGlobalIndex() { 2786 if (GlobalIndex) 2787 return false; 2788 2789 if (TriedLoadingGlobalIndex || !UseGlobalIndex || 2790 !Context.getLangOpts().Modules) 2791 return true; 2792 2793 // Try to load the global index. 2794 TriedLoadingGlobalIndex = true; 2795 StringRef ModuleCachePath 2796 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath(); 2797 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result 2798 = GlobalModuleIndex::readIndex(ModuleCachePath); 2799 if (!Result.first) 2800 return true; 2801 2802 GlobalIndex.reset(Result.first); 2803 ModuleMgr.setGlobalIndex(GlobalIndex.get()); 2804 return false; 2805} 2806 2807bool ASTReader::isGlobalIndexUnavailable() const { 2808 return Context.getLangOpts().Modules && UseGlobalIndex && 2809 !hasGlobalIndex() && TriedLoadingGlobalIndex; 2810} 2811 2812ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2813 ModuleKind Type, 2814 SourceLocation ImportLoc, 2815 unsigned ClientLoadCapabilities) { 2816 // Bump the generation number. 2817 unsigned PreviousGeneration = CurrentGeneration++; 2818 2819 unsigned NumModules = ModuleMgr.size(); 2820 SmallVector<ImportedModule, 4> Loaded; 2821 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc, 2822 /*ImportedBy=*/0, Loaded, 2823 0, 0, 2824 ClientLoadCapabilities)) { 2825 case Failure: 2826 case Missing: 2827 case OutOfDate: 2828 case VersionMismatch: 2829 case ConfigurationMismatch: 2830 case HadErrors: 2831 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(), 2832 Context.getLangOpts().Modules 2833 ? &PP.getHeaderSearchInfo().getModuleMap() 2834 : 0); 2835 2836 // If we find that any modules are unusable, the global index is going 2837 // to be out-of-date. Just remove it. 2838 GlobalIndex.reset(); 2839 ModuleMgr.setGlobalIndex(0); 2840 return ReadResult; 2841 2842 case Success: 2843 break; 2844 } 2845 2846 // Here comes stuff that we only do once the entire chain is loaded. 2847 2848 // Load the AST blocks of all of the modules that we loaded. 2849 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 2850 MEnd = Loaded.end(); 2851 M != MEnd; ++M) { 2852 ModuleFile &F = *M->Mod; 2853 2854 // Read the AST block. 2855 if (ReadASTBlock(F)) 2856 return Failure; 2857 2858 // Once read, set the ModuleFile bit base offset and update the size in 2859 // bits of all files we've seen. 2860 F.GlobalBitOffset = TotalModulesSizeInBits; 2861 TotalModulesSizeInBits += F.SizeInBits; 2862 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2863 2864 // Preload SLocEntries. 2865 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) { 2866 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2867 // Load it through the SourceManager and don't call ReadSLocEntry() 2868 // directly because the entry may have already been loaded in which case 2869 // calling ReadSLocEntry() directly would trigger an assertion in 2870 // SourceManager. 2871 SourceMgr.getLoadedSLocEntryByID(Index); 2872 } 2873 } 2874 2875 // Setup the import locations and notify the module manager that we've 2876 // committed to these module files. 2877 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 2878 MEnd = Loaded.end(); 2879 M != MEnd; ++M) { 2880 ModuleFile &F = *M->Mod; 2881 2882 ModuleMgr.moduleFileAccepted(&F); 2883 2884 // Set the import location. 2885 F.DirectImportLoc = ImportLoc; 2886 if (!M->ImportedBy) 2887 F.ImportLoc = M->ImportLoc; 2888 else 2889 F.ImportLoc = ReadSourceLocation(*M->ImportedBy, 2890 M->ImportLoc.getRawEncoding()); 2891 } 2892 2893 // Mark all of the identifiers in the identifier table as being out of date, 2894 // so that various accessors know to check the loaded modules when the 2895 // identifier is used. 2896 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2897 IdEnd = PP.getIdentifierTable().end(); 2898 Id != IdEnd; ++Id) 2899 Id->second->setOutOfDate(true); 2900 2901 // Resolve any unresolved module exports. 2902 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) { 2903 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I]; 2904 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 2905 Module *ResolvedMod = getSubmodule(GlobalID); 2906 2907 switch (Unresolved.Kind) { 2908 case UnresolvedModuleRef::Conflict: 2909 if (ResolvedMod) { 2910 Module::Conflict Conflict; 2911 Conflict.Other = ResolvedMod; 2912 Conflict.Message = Unresolved.String.str(); 2913 Unresolved.Mod->Conflicts.push_back(Conflict); 2914 } 2915 continue; 2916 2917 case UnresolvedModuleRef::Import: 2918 if (ResolvedMod) 2919 Unresolved.Mod->Imports.push_back(ResolvedMod); 2920 continue; 2921 2922 case UnresolvedModuleRef::Export: 2923 if (ResolvedMod || Unresolved.IsWildcard) 2924 Unresolved.Mod->Exports.push_back( 2925 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 2926 continue; 2927 } 2928 } 2929 UnresolvedModuleRefs.clear(); 2930 2931 InitializeContext(); 2932 2933 if (DeserializationListener) 2934 DeserializationListener->ReaderInitialized(this); 2935 2936 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule(); 2937 if (!PrimaryModule.OriginalSourceFileID.isInvalid()) { 2938 PrimaryModule.OriginalSourceFileID 2939 = FileID::get(PrimaryModule.SLocEntryBaseID 2940 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1); 2941 2942 // If this AST file is a precompiled preamble, then set the 2943 // preamble file ID of the source manager to the file source file 2944 // from which the preamble was built. 2945 if (Type == MK_Preamble) { 2946 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID); 2947 } else if (Type == MK_MainFile) { 2948 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID); 2949 } 2950 } 2951 2952 // For any Objective-C class definitions we have already loaded, make sure 2953 // that we load any additional categories. 2954 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) { 2955 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(), 2956 ObjCClassesLoaded[I], 2957 PreviousGeneration); 2958 } 2959 2960 return Success; 2961} 2962 2963ASTReader::ASTReadResult 2964ASTReader::ReadASTCore(StringRef FileName, 2965 ModuleKind Type, 2966 SourceLocation ImportLoc, 2967 ModuleFile *ImportedBy, 2968 SmallVectorImpl<ImportedModule> &Loaded, 2969 off_t ExpectedSize, time_t ExpectedModTime, 2970 unsigned ClientLoadCapabilities) { 2971 ModuleFile *M; 2972 std::string ErrorStr; 2973 ModuleManager::AddModuleResult AddResult 2974 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy, 2975 CurrentGeneration, ExpectedSize, ExpectedModTime, 2976 M, ErrorStr); 2977 2978 switch (AddResult) { 2979 case ModuleManager::AlreadyLoaded: 2980 return Success; 2981 2982 case ModuleManager::NewlyLoaded: 2983 // Load module file below. 2984 break; 2985 2986 case ModuleManager::Missing: 2987 // The module file was missing; if the client handle handle, that, return 2988 // it. 2989 if (ClientLoadCapabilities & ARR_Missing) 2990 return Missing; 2991 2992 // Otherwise, return an error. 2993 { 2994 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2995 + ErrorStr; 2996 Error(Msg); 2997 } 2998 return Failure; 2999 3000 case ModuleManager::OutOfDate: 3001 // We couldn't load the module file because it is out-of-date. If the 3002 // client can handle out-of-date, return it. 3003 if (ClientLoadCapabilities & ARR_OutOfDate) 3004 return OutOfDate; 3005 3006 // Otherwise, return an error. 3007 { 3008 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 3009 + ErrorStr; 3010 Error(Msg); 3011 } 3012 return Failure; 3013 } 3014 3015 assert(M && "Missing module file"); 3016 3017 // FIXME: This seems rather a hack. Should CurrentDir be part of the 3018 // module? 3019 if (FileName != "-") { 3020 CurrentDir = llvm::sys::path::parent_path(FileName); 3021 if (CurrentDir.empty()) CurrentDir = "."; 3022 } 3023 3024 ModuleFile &F = *M; 3025 BitstreamCursor &Stream = F.Stream; 3026 Stream.init(F.StreamFile); 3027 F.SizeInBits = F.Buffer->getBufferSize() * 8; 3028 3029 // Sniff for the signature. 3030 if (Stream.Read(8) != 'C' || 3031 Stream.Read(8) != 'P' || 3032 Stream.Read(8) != 'C' || 3033 Stream.Read(8) != 'H') { 3034 Diag(diag::err_not_a_pch_file) << FileName; 3035 return Failure; 3036 } 3037 3038 // This is used for compatibility with older PCH formats. 3039 bool HaveReadControlBlock = false; 3040 3041 while (1) { 3042 llvm::BitstreamEntry Entry = Stream.advance(); 3043 3044 switch (Entry.Kind) { 3045 case llvm::BitstreamEntry::Error: 3046 case llvm::BitstreamEntry::EndBlock: 3047 case llvm::BitstreamEntry::Record: 3048 Error("invalid record at top-level of AST file"); 3049 return Failure; 3050 3051 case llvm::BitstreamEntry::SubBlock: 3052 break; 3053 } 3054 3055 // We only know the control subblock ID. 3056 switch (Entry.ID) { 3057 case llvm::bitc::BLOCKINFO_BLOCK_ID: 3058 if (Stream.ReadBlockInfoBlock()) { 3059 Error("malformed BlockInfoBlock in AST file"); 3060 return Failure; 3061 } 3062 break; 3063 case CONTROL_BLOCK_ID: 3064 HaveReadControlBlock = true; 3065 switch (ReadControlBlock(F, Loaded, ClientLoadCapabilities)) { 3066 case Success: 3067 break; 3068 3069 case Failure: return Failure; 3070 case Missing: return Missing; 3071 case OutOfDate: return OutOfDate; 3072 case VersionMismatch: return VersionMismatch; 3073 case ConfigurationMismatch: return ConfigurationMismatch; 3074 case HadErrors: return HadErrors; 3075 } 3076 break; 3077 case AST_BLOCK_ID: 3078 if (!HaveReadControlBlock) { 3079 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 3080 Diag(diag::warn_pch_version_too_old); 3081 return VersionMismatch; 3082 } 3083 3084 // Record that we've loaded this module. 3085 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc)); 3086 return Success; 3087 3088 default: 3089 if (Stream.SkipBlock()) { 3090 Error("malformed block record in AST file"); 3091 return Failure; 3092 } 3093 break; 3094 } 3095 } 3096 3097 return Success; 3098} 3099 3100void ASTReader::InitializeContext() { 3101 // If there's a listener, notify them that we "read" the translation unit. 3102 if (DeserializationListener) 3103 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 3104 Context.getTranslationUnitDecl()); 3105 3106 // Make sure we load the declaration update records for the translation unit, 3107 // if there are any. 3108 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 3109 Context.getTranslationUnitDecl()); 3110 3111 // FIXME: Find a better way to deal with collisions between these 3112 // built-in types. Right now, we just ignore the problem. 3113 3114 // Load the special types. 3115 if (SpecialTypes.size() >= NumSpecialTypeIDs) { 3116 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 3117 if (!Context.CFConstantStringTypeDecl) 3118 Context.setCFConstantStringType(GetType(String)); 3119 } 3120 3121 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 3122 QualType FileType = GetType(File); 3123 if (FileType.isNull()) { 3124 Error("FILE type is NULL"); 3125 return; 3126 } 3127 3128 if (!Context.FILEDecl) { 3129 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 3130 Context.setFILEDecl(Typedef->getDecl()); 3131 else { 3132 const TagType *Tag = FileType->getAs<TagType>(); 3133 if (!Tag) { 3134 Error("Invalid FILE type in AST file"); 3135 return; 3136 } 3137 Context.setFILEDecl(Tag->getDecl()); 3138 } 3139 } 3140 } 3141 3142 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 3143 QualType Jmp_bufType = GetType(Jmp_buf); 3144 if (Jmp_bufType.isNull()) { 3145 Error("jmp_buf type is NULL"); 3146 return; 3147 } 3148 3149 if (!Context.jmp_bufDecl) { 3150 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 3151 Context.setjmp_bufDecl(Typedef->getDecl()); 3152 else { 3153 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 3154 if (!Tag) { 3155 Error("Invalid jmp_buf type in AST file"); 3156 return; 3157 } 3158 Context.setjmp_bufDecl(Tag->getDecl()); 3159 } 3160 } 3161 } 3162 3163 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 3164 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 3165 if (Sigjmp_bufType.isNull()) { 3166 Error("sigjmp_buf type is NULL"); 3167 return; 3168 } 3169 3170 if (!Context.sigjmp_bufDecl) { 3171 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 3172 Context.setsigjmp_bufDecl(Typedef->getDecl()); 3173 else { 3174 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 3175 assert(Tag && "Invalid sigjmp_buf type in AST file"); 3176 Context.setsigjmp_bufDecl(Tag->getDecl()); 3177 } 3178 } 3179 } 3180 3181 if (unsigned ObjCIdRedef 3182 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 3183 if (Context.ObjCIdRedefinitionType.isNull()) 3184 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 3185 } 3186 3187 if (unsigned ObjCClassRedef 3188 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 3189 if (Context.ObjCClassRedefinitionType.isNull()) 3190 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 3191 } 3192 3193 if (unsigned ObjCSelRedef 3194 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 3195 if (Context.ObjCSelRedefinitionType.isNull()) 3196 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3197 } 3198 3199 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 3200 QualType Ucontext_tType = GetType(Ucontext_t); 3201 if (Ucontext_tType.isNull()) { 3202 Error("ucontext_t type is NULL"); 3203 return; 3204 } 3205 3206 if (!Context.ucontext_tDecl) { 3207 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 3208 Context.setucontext_tDecl(Typedef->getDecl()); 3209 else { 3210 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 3211 assert(Tag && "Invalid ucontext_t type in AST file"); 3212 Context.setucontext_tDecl(Tag->getDecl()); 3213 } 3214 } 3215 } 3216 } 3217 3218 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 3219 3220 // If there were any CUDA special declarations, deserialize them. 3221 if (!CUDASpecialDeclRefs.empty()) { 3222 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3223 Context.setcudaConfigureCallDecl( 3224 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3225 } 3226 3227 // Re-export any modules that were imported by a non-module AST file. 3228 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 3229 if (Module *Imported = getSubmodule(ImportedModules[I])) 3230 makeModuleVisible(Imported, Module::AllVisible, 3231 /*ImportLoc=*/SourceLocation(), 3232 /*Complain=*/false); 3233 } 3234 ImportedModules.clear(); 3235} 3236 3237void ASTReader::finalizeForWriting() { 3238 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 3239 HiddenEnd = HiddenNamesMap.end(); 3240 Hidden != HiddenEnd; ++Hidden) { 3241 makeNamesVisible(Hidden->second); 3242 } 3243 HiddenNamesMap.clear(); 3244} 3245 3246/// SkipCursorToControlBlock - Given a cursor at the start of an AST file, scan 3247/// ahead and drop the cursor into the start of the CONTROL_BLOCK, returning 3248/// false on success and true on failure. 3249static bool SkipCursorToControlBlock(BitstreamCursor &Cursor) { 3250 while (1) { 3251 llvm::BitstreamEntry Entry = Cursor.advance(); 3252 switch (Entry.Kind) { 3253 case llvm::BitstreamEntry::Error: 3254 case llvm::BitstreamEntry::EndBlock: 3255 return true; 3256 3257 case llvm::BitstreamEntry::Record: 3258 // Ignore top-level records. 3259 Cursor.skipRecord(Entry.ID); 3260 break; 3261 3262 case llvm::BitstreamEntry::SubBlock: 3263 if (Entry.ID == CONTROL_BLOCK_ID) { 3264 if (Cursor.EnterSubBlock(CONTROL_BLOCK_ID)) 3265 return true; 3266 // Found it! 3267 return false; 3268 } 3269 3270 if (Cursor.SkipBlock()) 3271 return true; 3272 } 3273 } 3274} 3275 3276/// \brief Retrieve the name of the original source file name 3277/// directly from the AST file, without actually loading the AST 3278/// file. 3279std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3280 FileManager &FileMgr, 3281 DiagnosticsEngine &Diags) { 3282 // Open the AST file. 3283 std::string ErrStr; 3284 OwningPtr<llvm::MemoryBuffer> Buffer; 3285 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3286 if (!Buffer) { 3287 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ASTFileName << ErrStr; 3288 return std::string(); 3289 } 3290 3291 // Initialize the stream 3292 llvm::BitstreamReader StreamFile; 3293 BitstreamCursor Stream; 3294 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3295 (const unsigned char *)Buffer->getBufferEnd()); 3296 Stream.init(StreamFile); 3297 3298 // Sniff for the signature. 3299 if (Stream.Read(8) != 'C' || 3300 Stream.Read(8) != 'P' || 3301 Stream.Read(8) != 'C' || 3302 Stream.Read(8) != 'H') { 3303 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3304 return std::string(); 3305 } 3306 3307 // Scan for the CONTROL_BLOCK_ID block. 3308 if (SkipCursorToControlBlock(Stream)) { 3309 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3310 return std::string(); 3311 } 3312 3313 // Scan for ORIGINAL_FILE inside the control block. 3314 RecordData Record; 3315 while (1) { 3316 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 3317 if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 3318 return std::string(); 3319 3320 if (Entry.Kind != llvm::BitstreamEntry::Record) { 3321 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3322 return std::string(); 3323 } 3324 3325 Record.clear(); 3326 StringRef Blob; 3327 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE) 3328 return Blob.str(); 3329 } 3330} 3331 3332namespace { 3333 class SimplePCHValidator : public ASTReaderListener { 3334 const LangOptions &ExistingLangOpts; 3335 const TargetOptions &ExistingTargetOpts; 3336 const PreprocessorOptions &ExistingPPOpts; 3337 FileManager &FileMgr; 3338 3339 public: 3340 SimplePCHValidator(const LangOptions &ExistingLangOpts, 3341 const TargetOptions &ExistingTargetOpts, 3342 const PreprocessorOptions &ExistingPPOpts, 3343 FileManager &FileMgr) 3344 : ExistingLangOpts(ExistingLangOpts), 3345 ExistingTargetOpts(ExistingTargetOpts), 3346 ExistingPPOpts(ExistingPPOpts), 3347 FileMgr(FileMgr) 3348 { 3349 } 3350 3351 virtual bool ReadLanguageOptions(const LangOptions &LangOpts, 3352 bool Complain) { 3353 return checkLanguageOptions(ExistingLangOpts, LangOpts, 0); 3354 } 3355 virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, 3356 bool Complain) { 3357 return checkTargetOptions(ExistingTargetOpts, TargetOpts, 0); 3358 } 3359 virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 3360 bool Complain, 3361 std::string &SuggestedPredefines) { 3362 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, 0, FileMgr, 3363 SuggestedPredefines); 3364 } 3365 }; 3366} 3367 3368bool ASTReader::readASTFileControlBlock(StringRef Filename, 3369 FileManager &FileMgr, 3370 ASTReaderListener &Listener) { 3371 // Open the AST file. 3372 std::string ErrStr; 3373 OwningPtr<llvm::MemoryBuffer> Buffer; 3374 Buffer.reset(FileMgr.getBufferForFile(Filename, &ErrStr)); 3375 if (!Buffer) { 3376 return true; 3377 } 3378 3379 // Initialize the stream 3380 llvm::BitstreamReader StreamFile; 3381 BitstreamCursor Stream; 3382 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3383 (const unsigned char *)Buffer->getBufferEnd()); 3384 Stream.init(StreamFile); 3385 3386 // Sniff for the signature. 3387 if (Stream.Read(8) != 'C' || 3388 Stream.Read(8) != 'P' || 3389 Stream.Read(8) != 'C' || 3390 Stream.Read(8) != 'H') { 3391 return true; 3392 } 3393 3394 // Scan for the CONTROL_BLOCK_ID block. 3395 if (SkipCursorToControlBlock(Stream)) 3396 return true; 3397 3398 // Scan for ORIGINAL_FILE inside the control block. 3399 RecordData Record; 3400 while (1) { 3401 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 3402 if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 3403 return false; 3404 3405 if (Entry.Kind != llvm::BitstreamEntry::Record) 3406 return true; 3407 3408 Record.clear(); 3409 StringRef Blob; 3410 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob); 3411 switch ((ControlRecordTypes)RecCode) { 3412 case METADATA: { 3413 if (Record[0] != VERSION_MAJOR) 3414 return true; 3415 3416 const std::string &CurBranch = getClangFullRepositoryVersion(); 3417 if (StringRef(CurBranch) != Blob) 3418 return true; 3419 3420 break; 3421 } 3422 case LANGUAGE_OPTIONS: 3423 if (ParseLanguageOptions(Record, false, Listener)) 3424 return true; 3425 break; 3426 3427 case TARGET_OPTIONS: 3428 if (ParseTargetOptions(Record, false, Listener)) 3429 return true; 3430 break; 3431 3432 case DIAGNOSTIC_OPTIONS: 3433 if (ParseDiagnosticOptions(Record, false, Listener)) 3434 return true; 3435 break; 3436 3437 case FILE_SYSTEM_OPTIONS: 3438 if (ParseFileSystemOptions(Record, false, Listener)) 3439 return true; 3440 break; 3441 3442 case HEADER_SEARCH_OPTIONS: 3443 if (ParseHeaderSearchOptions(Record, false, Listener)) 3444 return true; 3445 break; 3446 3447 case PREPROCESSOR_OPTIONS: { 3448 std::string IgnoredSuggestedPredefines; 3449 if (ParsePreprocessorOptions(Record, false, Listener, 3450 IgnoredSuggestedPredefines)) 3451 return true; 3452 break; 3453 } 3454 3455 default: 3456 // No other validation to perform. 3457 break; 3458 } 3459 } 3460} 3461 3462 3463bool ASTReader::isAcceptableASTFile(StringRef Filename, 3464 FileManager &FileMgr, 3465 const LangOptions &LangOpts, 3466 const TargetOptions &TargetOpts, 3467 const PreprocessorOptions &PPOpts) { 3468 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, FileMgr); 3469 return !readASTFileControlBlock(Filename, FileMgr, validator); 3470} 3471 3472bool ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 3473 // Enter the submodule block. 3474 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 3475 Error("malformed submodule block record in AST file"); 3476 return true; 3477 } 3478 3479 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 3480 bool First = true; 3481 Module *CurrentModule = 0; 3482 RecordData Record; 3483 while (true) { 3484 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks(); 3485 3486 switch (Entry.Kind) { 3487 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 3488 case llvm::BitstreamEntry::Error: 3489 Error("malformed block record in AST file"); 3490 return true; 3491 case llvm::BitstreamEntry::EndBlock: 3492 return false; 3493 case llvm::BitstreamEntry::Record: 3494 // The interesting case. 3495 break; 3496 } 3497 3498 // Read a record. 3499 StringRef Blob; 3500 Record.clear(); 3501 switch (F.Stream.readRecord(Entry.ID, Record, &Blob)) { 3502 default: // Default behavior: ignore. 3503 break; 3504 3505 case SUBMODULE_DEFINITION: { 3506 if (First) { 3507 Error("missing submodule metadata record at beginning of block"); 3508 return true; 3509 } 3510 3511 if (Record.size() < 8) { 3512 Error("malformed module definition"); 3513 return true; 3514 } 3515 3516 StringRef Name = Blob; 3517 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]); 3518 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]); 3519 bool IsFramework = Record[2]; 3520 bool IsExplicit = Record[3]; 3521 bool IsSystem = Record[4]; 3522 bool InferSubmodules = Record[5]; 3523 bool InferExplicitSubmodules = Record[6]; 3524 bool InferExportWildcard = Record[7]; 3525 bool ConfigMacrosExhaustive = Record[8]; 3526 3527 Module *ParentModule = 0; 3528 if (Parent) 3529 ParentModule = getSubmodule(Parent); 3530 3531 // Retrieve this (sub)module from the module map, creating it if 3532 // necessary. 3533 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3534 IsFramework, 3535 IsExplicit).first; 3536 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 3537 if (GlobalIndex >= SubmodulesLoaded.size() || 3538 SubmodulesLoaded[GlobalIndex]) { 3539 Error("too many submodules"); 3540 return true; 3541 } 3542 3543 if (!ParentModule) { 3544 if (const FileEntry *CurFile = CurrentModule->getASTFile()) { 3545 if (CurFile != F.File) { 3546 if (!Diags.isDiagnosticInFlight()) { 3547 Diag(diag::err_module_file_conflict) 3548 << CurrentModule->getTopLevelModuleName() 3549 << CurFile->getName() 3550 << F.File->getName(); 3551 } 3552 return true; 3553 } 3554 } 3555 3556 CurrentModule->setASTFile(F.File); 3557 } 3558 3559 CurrentModule->IsFromModuleFile = true; 3560 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem; 3561 CurrentModule->InferSubmodules = InferSubmodules; 3562 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 3563 CurrentModule->InferExportWildcard = InferExportWildcard; 3564 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive; 3565 if (DeserializationListener) 3566 DeserializationListener->ModuleRead(GlobalID, CurrentModule); 3567 3568 SubmodulesLoaded[GlobalIndex] = CurrentModule; 3569 3570 // Clear out data that will be replaced by what is the module file. 3571 CurrentModule->LinkLibraries.clear(); 3572 CurrentModule->ConfigMacros.clear(); 3573 CurrentModule->UnresolvedConflicts.clear(); 3574 CurrentModule->Conflicts.clear(); 3575 break; 3576 } 3577 3578 case SUBMODULE_UMBRELLA_HEADER: { 3579 if (First) { 3580 Error("missing submodule metadata record at beginning of block"); 3581 return true; 3582 } 3583 3584 if (!CurrentModule) 3585 break; 3586 3587 if (const FileEntry *Umbrella = PP.getFileManager().getFile(Blob)) { 3588 if (!CurrentModule->getUmbrellaHeader()) 3589 ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 3590 else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 3591 Error("mismatched umbrella headers in submodule"); 3592 return true; 3593 } 3594 } 3595 break; 3596 } 3597 3598 case SUBMODULE_HEADER: { 3599 if (First) { 3600 Error("missing submodule metadata record at beginning of block"); 3601 return true; 3602 } 3603 3604 if (!CurrentModule) 3605 break; 3606 3607 // We lazily associate headers with their modules via the HeaderInfoTable. 3608 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3609 // of complete filenames or remove it entirely. 3610 break; 3611 } 3612 3613 case SUBMODULE_EXCLUDED_HEADER: { 3614 if (First) { 3615 Error("missing submodule metadata record at beginning of block"); 3616 return true; 3617 } 3618 3619 if (!CurrentModule) 3620 break; 3621 3622 // We lazily associate headers with their modules via the HeaderInfoTable. 3623 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3624 // of complete filenames or remove it entirely. 3625 break; 3626 } 3627 3628 case SUBMODULE_TOPHEADER: { 3629 if (First) { 3630 Error("missing submodule metadata record at beginning of block"); 3631 return true; 3632 } 3633 3634 if (!CurrentModule) 3635 break; 3636 3637 CurrentModule->addTopHeaderFilename(Blob); 3638 break; 3639 } 3640 3641 case SUBMODULE_UMBRELLA_DIR: { 3642 if (First) { 3643 Error("missing submodule metadata record at beginning of block"); 3644 return true; 3645 } 3646 3647 if (!CurrentModule) 3648 break; 3649 3650 if (const DirectoryEntry *Umbrella 3651 = PP.getFileManager().getDirectory(Blob)) { 3652 if (!CurrentModule->getUmbrellaDir()) 3653 ModMap.setUmbrellaDir(CurrentModule, Umbrella); 3654 else if (CurrentModule->getUmbrellaDir() != Umbrella) { 3655 Error("mismatched umbrella directories in submodule"); 3656 return true; 3657 } 3658 } 3659 break; 3660 } 3661 3662 case SUBMODULE_METADATA: { 3663 if (!First) { 3664 Error("submodule metadata record not at beginning of block"); 3665 return true; 3666 } 3667 First = false; 3668 3669 F.BaseSubmoduleID = getTotalNumSubmodules(); 3670 F.LocalNumSubmodules = Record[0]; 3671 unsigned LocalBaseSubmoduleID = Record[1]; 3672 if (F.LocalNumSubmodules > 0) { 3673 // Introduce the global -> local mapping for submodules within this 3674 // module. 3675 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3676 3677 // Introduce the local -> global mapping for submodules within this 3678 // module. 3679 F.SubmoduleRemap.insertOrReplace( 3680 std::make_pair(LocalBaseSubmoduleID, 3681 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3682 3683 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3684 } 3685 break; 3686 } 3687 3688 case SUBMODULE_IMPORTS: { 3689 if (First) { 3690 Error("missing submodule metadata record at beginning of block"); 3691 return true; 3692 } 3693 3694 if (!CurrentModule) 3695 break; 3696 3697 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3698 UnresolvedModuleRef Unresolved; 3699 Unresolved.File = &F; 3700 Unresolved.Mod = CurrentModule; 3701 Unresolved.ID = Record[Idx]; 3702 Unresolved.Kind = UnresolvedModuleRef::Import; 3703 Unresolved.IsWildcard = false; 3704 UnresolvedModuleRefs.push_back(Unresolved); 3705 } 3706 break; 3707 } 3708 3709 case SUBMODULE_EXPORTS: { 3710 if (First) { 3711 Error("missing submodule metadata record at beginning of block"); 3712 return true; 3713 } 3714 3715 if (!CurrentModule) 3716 break; 3717 3718 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3719 UnresolvedModuleRef Unresolved; 3720 Unresolved.File = &F; 3721 Unresolved.Mod = CurrentModule; 3722 Unresolved.ID = Record[Idx]; 3723 Unresolved.Kind = UnresolvedModuleRef::Export; 3724 Unresolved.IsWildcard = Record[Idx + 1]; 3725 UnresolvedModuleRefs.push_back(Unresolved); 3726 } 3727 3728 // Once we've loaded the set of exports, there's no reason to keep 3729 // the parsed, unresolved exports around. 3730 CurrentModule->UnresolvedExports.clear(); 3731 break; 3732 } 3733 case SUBMODULE_REQUIRES: { 3734 if (First) { 3735 Error("missing submodule metadata record at beginning of block"); 3736 return true; 3737 } 3738 3739 if (!CurrentModule) 3740 break; 3741 3742 CurrentModule->addRequirement(Blob, Context.getLangOpts(), 3743 Context.getTargetInfo()); 3744 break; 3745 } 3746 3747 case SUBMODULE_LINK_LIBRARY: 3748 if (First) { 3749 Error("missing submodule metadata record at beginning of block"); 3750 return true; 3751 } 3752 3753 if (!CurrentModule) 3754 break; 3755 3756 CurrentModule->LinkLibraries.push_back( 3757 Module::LinkLibrary(Blob, Record[0])); 3758 break; 3759 3760 case SUBMODULE_CONFIG_MACRO: 3761 if (First) { 3762 Error("missing submodule metadata record at beginning of block"); 3763 return true; 3764 } 3765 3766 if (!CurrentModule) 3767 break; 3768 3769 CurrentModule->ConfigMacros.push_back(Blob.str()); 3770 break; 3771 3772 case SUBMODULE_CONFLICT: { 3773 if (First) { 3774 Error("missing submodule metadata record at beginning of block"); 3775 return true; 3776 } 3777 3778 if (!CurrentModule) 3779 break; 3780 3781 UnresolvedModuleRef Unresolved; 3782 Unresolved.File = &F; 3783 Unresolved.Mod = CurrentModule; 3784 Unresolved.ID = Record[0]; 3785 Unresolved.Kind = UnresolvedModuleRef::Conflict; 3786 Unresolved.IsWildcard = false; 3787 Unresolved.String = Blob; 3788 UnresolvedModuleRefs.push_back(Unresolved); 3789 break; 3790 } 3791 } 3792 } 3793} 3794 3795/// \brief Parse the record that corresponds to a LangOptions data 3796/// structure. 3797/// 3798/// This routine parses the language options from the AST file and then gives 3799/// them to the AST listener if one is set. 3800/// 3801/// \returns true if the listener deems the file unacceptable, false otherwise. 3802bool ASTReader::ParseLanguageOptions(const RecordData &Record, 3803 bool Complain, 3804 ASTReaderListener &Listener) { 3805 LangOptions LangOpts; 3806 unsigned Idx = 0; 3807#define LANGOPT(Name, Bits, Default, Description) \ 3808 LangOpts.Name = Record[Idx++]; 3809#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3810 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3811#include "clang/Basic/LangOptions.def" 3812#define SANITIZER(NAME, ID) LangOpts.Sanitize.ID = Record[Idx++]; 3813#include "clang/Basic/Sanitizers.def" 3814 3815 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++]; 3816 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx); 3817 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion); 3818 3819 unsigned Length = Record[Idx++]; 3820 LangOpts.CurrentModule.assign(Record.begin() + Idx, 3821 Record.begin() + Idx + Length); 3822 3823 Idx += Length; 3824 3825 // Comment options. 3826 for (unsigned N = Record[Idx++]; N; --N) { 3827 LangOpts.CommentOpts.BlockCommandNames.push_back( 3828 ReadString(Record, Idx)); 3829 } 3830 3831 return Listener.ReadLanguageOptions(LangOpts, Complain); 3832} 3833 3834bool ASTReader::ParseTargetOptions(const RecordData &Record, 3835 bool Complain, 3836 ASTReaderListener &Listener) { 3837 unsigned Idx = 0; 3838 TargetOptions TargetOpts; 3839 TargetOpts.Triple = ReadString(Record, Idx); 3840 TargetOpts.CPU = ReadString(Record, Idx); 3841 TargetOpts.ABI = ReadString(Record, Idx); 3842 TargetOpts.CXXABI = ReadString(Record, Idx); 3843 TargetOpts.LinkerVersion = ReadString(Record, Idx); 3844 for (unsigned N = Record[Idx++]; N; --N) { 3845 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx)); 3846 } 3847 for (unsigned N = Record[Idx++]; N; --N) { 3848 TargetOpts.Features.push_back(ReadString(Record, Idx)); 3849 } 3850 3851 return Listener.ReadTargetOptions(TargetOpts, Complain); 3852} 3853 3854bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain, 3855 ASTReaderListener &Listener) { 3856 DiagnosticOptions DiagOpts; 3857 unsigned Idx = 0; 3858#define DIAGOPT(Name, Bits, Default) DiagOpts.Name = Record[Idx++]; 3859#define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 3860 DiagOpts.set##Name(static_cast<Type>(Record[Idx++])); 3861#include "clang/Basic/DiagnosticOptions.def" 3862 3863 for (unsigned N = Record[Idx++]; N; --N) { 3864 DiagOpts.Warnings.push_back(ReadString(Record, Idx)); 3865 } 3866 3867 return Listener.ReadDiagnosticOptions(DiagOpts, Complain); 3868} 3869 3870bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain, 3871 ASTReaderListener &Listener) { 3872 FileSystemOptions FSOpts; 3873 unsigned Idx = 0; 3874 FSOpts.WorkingDir = ReadString(Record, Idx); 3875 return Listener.ReadFileSystemOptions(FSOpts, Complain); 3876} 3877 3878bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record, 3879 bool Complain, 3880 ASTReaderListener &Listener) { 3881 HeaderSearchOptions HSOpts; 3882 unsigned Idx = 0; 3883 HSOpts.Sysroot = ReadString(Record, Idx); 3884 3885 // Include entries. 3886 for (unsigned N = Record[Idx++]; N; --N) { 3887 std::string Path = ReadString(Record, Idx); 3888 frontend::IncludeDirGroup Group 3889 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]); 3890 bool IsFramework = Record[Idx++]; 3891 bool IgnoreSysRoot = Record[Idx++]; 3892 HSOpts.UserEntries.push_back( 3893 HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot)); 3894 } 3895 3896 // System header prefixes. 3897 for (unsigned N = Record[Idx++]; N; --N) { 3898 std::string Prefix = ReadString(Record, Idx); 3899 bool IsSystemHeader = Record[Idx++]; 3900 HSOpts.SystemHeaderPrefixes.push_back( 3901 HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader)); 3902 } 3903 3904 HSOpts.ResourceDir = ReadString(Record, Idx); 3905 HSOpts.ModuleCachePath = ReadString(Record, Idx); 3906 HSOpts.DisableModuleHash = Record[Idx++]; 3907 HSOpts.UseBuiltinIncludes = Record[Idx++]; 3908 HSOpts.UseStandardSystemIncludes = Record[Idx++]; 3909 HSOpts.UseStandardCXXIncludes = Record[Idx++]; 3910 HSOpts.UseLibcxx = Record[Idx++]; 3911 3912 return Listener.ReadHeaderSearchOptions(HSOpts, Complain); 3913} 3914 3915bool ASTReader::ParsePreprocessorOptions(const RecordData &Record, 3916 bool Complain, 3917 ASTReaderListener &Listener, 3918 std::string &SuggestedPredefines) { 3919 PreprocessorOptions PPOpts; 3920 unsigned Idx = 0; 3921 3922 // Macro definitions/undefs 3923 for (unsigned N = Record[Idx++]; N; --N) { 3924 std::string Macro = ReadString(Record, Idx); 3925 bool IsUndef = Record[Idx++]; 3926 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef)); 3927 } 3928 3929 // Includes 3930 for (unsigned N = Record[Idx++]; N; --N) { 3931 PPOpts.Includes.push_back(ReadString(Record, Idx)); 3932 } 3933 3934 // Macro Includes 3935 for (unsigned N = Record[Idx++]; N; --N) { 3936 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx)); 3937 } 3938 3939 PPOpts.UsePredefines = Record[Idx++]; 3940 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx); 3941 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx); 3942 PPOpts.ObjCXXARCStandardLibrary = 3943 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]); 3944 SuggestedPredefines.clear(); 3945 return Listener.ReadPreprocessorOptions(PPOpts, Complain, 3946 SuggestedPredefines); 3947} 3948 3949std::pair<ModuleFile *, unsigned> 3950ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 3951 GlobalPreprocessedEntityMapType::iterator 3952 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 3953 assert(I != GlobalPreprocessedEntityMap.end() && 3954 "Corrupted global preprocessed entity map"); 3955 ModuleFile *M = I->second; 3956 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 3957 return std::make_pair(M, LocalIndex); 3958} 3959 3960std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 3961ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const { 3962 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord()) 3963 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID, 3964 Mod.NumPreprocessedEntities); 3965 3966 return std::make_pair(PreprocessingRecord::iterator(), 3967 PreprocessingRecord::iterator()); 3968} 3969 3970std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator> 3971ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) { 3972 return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls), 3973 ModuleDeclIterator(this, &Mod, 3974 Mod.FileSortedDecls + Mod.NumFileSortedDecls)); 3975} 3976 3977PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 3978 PreprocessedEntityID PPID = Index+1; 3979 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3980 ModuleFile &M = *PPInfo.first; 3981 unsigned LocalIndex = PPInfo.second; 3982 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3983 3984 if (!PP.getPreprocessingRecord()) { 3985 Error("no preprocessing record"); 3986 return 0; 3987 } 3988 3989 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 3990 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 3991 3992 llvm::BitstreamEntry Entry = 3993 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd); 3994 if (Entry.Kind != llvm::BitstreamEntry::Record) 3995 return 0; 3996 3997 // Read the record. 3998 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 3999 ReadSourceLocation(M, PPOffs.End)); 4000 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 4001 StringRef Blob; 4002 RecordData Record; 4003 PreprocessorDetailRecordTypes RecType = 4004 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord( 4005 Entry.ID, Record, &Blob); 4006 switch (RecType) { 4007 case PPD_MACRO_EXPANSION: { 4008 bool isBuiltin = Record[0]; 4009 IdentifierInfo *Name = 0; 4010 MacroDefinition *Def = 0; 4011 if (isBuiltin) 4012 Name = getLocalIdentifier(M, Record[1]); 4013 else { 4014 PreprocessedEntityID 4015 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 4016 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 4017 } 4018 4019 MacroExpansion *ME; 4020 if (isBuiltin) 4021 ME = new (PPRec) MacroExpansion(Name, Range); 4022 else 4023 ME = new (PPRec) MacroExpansion(Def, Range); 4024 4025 return ME; 4026 } 4027 4028 case PPD_MACRO_DEFINITION: { 4029 // Decode the identifier info and then check again; if the macro is 4030 // still defined and associated with the identifier, 4031 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 4032 MacroDefinition *MD 4033 = new (PPRec) MacroDefinition(II, Range); 4034 4035 if (DeserializationListener) 4036 DeserializationListener->MacroDefinitionRead(PPID, MD); 4037 4038 return MD; 4039 } 4040 4041 case PPD_INCLUSION_DIRECTIVE: { 4042 const char *FullFileNameStart = Blob.data() + Record[0]; 4043 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]); 4044 const FileEntry *File = 0; 4045 if (!FullFileName.empty()) 4046 File = PP.getFileManager().getFile(FullFileName); 4047 4048 // FIXME: Stable encoding 4049 InclusionDirective::InclusionKind Kind 4050 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 4051 InclusionDirective *ID 4052 = new (PPRec) InclusionDirective(PPRec, Kind, 4053 StringRef(Blob.data(), Record[0]), 4054 Record[1], Record[3], 4055 File, 4056 Range); 4057 return ID; 4058 } 4059 } 4060 4061 llvm_unreachable("Invalid PreprocessorDetailRecordTypes"); 4062} 4063 4064/// \brief \arg SLocMapI points at a chunk of a module that contains no 4065/// preprocessed entities or the entities it contains are not the ones we are 4066/// looking for. Find the next module that contains entities and return the ID 4067/// of the first entry. 4068PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 4069 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 4070 ++SLocMapI; 4071 for (GlobalSLocOffsetMapType::const_iterator 4072 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 4073 ModuleFile &M = *SLocMapI->second; 4074 if (M.NumPreprocessedEntities) 4075 return M.BasePreprocessedEntityID; 4076 } 4077 4078 return getTotalNumPreprocessedEntities(); 4079} 4080 4081namespace { 4082 4083template <unsigned PPEntityOffset::*PPLoc> 4084struct PPEntityComp { 4085 const ASTReader &Reader; 4086 ModuleFile &M; 4087 4088 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 4089 4090 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 4091 SourceLocation LHS = getLoc(L); 4092 SourceLocation RHS = getLoc(R); 4093 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4094 } 4095 4096 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 4097 SourceLocation LHS = getLoc(L); 4098 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4099 } 4100 4101 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 4102 SourceLocation RHS = getLoc(R); 4103 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4104 } 4105 4106 SourceLocation getLoc(const PPEntityOffset &PPE) const { 4107 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 4108 } 4109}; 4110 4111} 4112 4113/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 4114PreprocessedEntityID 4115ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 4116 if (SourceMgr.isLocalSourceLocation(BLoc)) 4117 return getTotalNumPreprocessedEntities(); 4118 4119 GlobalSLocOffsetMapType::const_iterator 4120 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4121 BLoc.getOffset() - 1); 4122 assert(SLocMapI != GlobalSLocOffsetMap.end() && 4123 "Corrupted global sloc offset map"); 4124 4125 if (SLocMapI->second->NumPreprocessedEntities == 0) 4126 return findNextPreprocessedEntity(SLocMapI); 4127 4128 ModuleFile &M = *SLocMapI->second; 4129 typedef const PPEntityOffset *pp_iterator; 4130 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4131 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4132 4133 size_t Count = M.NumPreprocessedEntities; 4134 size_t Half; 4135 pp_iterator First = pp_begin; 4136 pp_iterator PPI; 4137 4138 // Do a binary search manually instead of using std::lower_bound because 4139 // The end locations of entities may be unordered (when a macro expansion 4140 // is inside another macro argument), but for this case it is not important 4141 // whether we get the first macro expansion or its containing macro. 4142 while (Count > 0) { 4143 Half = Count/2; 4144 PPI = First; 4145 std::advance(PPI, Half); 4146 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 4147 BLoc)){ 4148 First = PPI; 4149 ++First; 4150 Count = Count - Half - 1; 4151 } else 4152 Count = Half; 4153 } 4154 4155 if (PPI == pp_end) 4156 return findNextPreprocessedEntity(SLocMapI); 4157 4158 return M.BasePreprocessedEntityID + (PPI - pp_begin); 4159} 4160 4161/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 4162PreprocessedEntityID 4163ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 4164 if (SourceMgr.isLocalSourceLocation(ELoc)) 4165 return getTotalNumPreprocessedEntities(); 4166 4167 GlobalSLocOffsetMapType::const_iterator 4168 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4169 ELoc.getOffset() - 1); 4170 assert(SLocMapI != GlobalSLocOffsetMap.end() && 4171 "Corrupted global sloc offset map"); 4172 4173 if (SLocMapI->second->NumPreprocessedEntities == 0) 4174 return findNextPreprocessedEntity(SLocMapI); 4175 4176 ModuleFile &M = *SLocMapI->second; 4177 typedef const PPEntityOffset *pp_iterator; 4178 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4179 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4180 pp_iterator PPI = 4181 std::upper_bound(pp_begin, pp_end, ELoc, 4182 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 4183 4184 if (PPI == pp_end) 4185 return findNextPreprocessedEntity(SLocMapI); 4186 4187 return M.BasePreprocessedEntityID + (PPI - pp_begin); 4188} 4189 4190/// \brief Returns a pair of [Begin, End) indices of preallocated 4191/// preprocessed entities that \arg Range encompasses. 4192std::pair<unsigned, unsigned> 4193 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 4194 if (Range.isInvalid()) 4195 return std::make_pair(0,0); 4196 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 4197 4198 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 4199 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 4200 return std::make_pair(BeginID, EndID); 4201} 4202 4203/// \brief Optionally returns true or false if the preallocated preprocessed 4204/// entity with index \arg Index came from file \arg FID. 4205Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 4206 FileID FID) { 4207 if (FID.isInvalid()) 4208 return false; 4209 4210 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 4211 ModuleFile &M = *PPInfo.first; 4212 unsigned LocalIndex = PPInfo.second; 4213 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 4214 4215 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 4216 if (Loc.isInvalid()) 4217 return false; 4218 4219 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 4220 return true; 4221 else 4222 return false; 4223} 4224 4225namespace { 4226 /// \brief Visitor used to search for information about a header file. 4227 class HeaderFileInfoVisitor { 4228 const FileEntry *FE; 4229 4230 Optional<HeaderFileInfo> HFI; 4231 4232 public: 4233 explicit HeaderFileInfoVisitor(const FileEntry *FE) 4234 : FE(FE) { } 4235 4236 static bool visit(ModuleFile &M, void *UserData) { 4237 HeaderFileInfoVisitor *This 4238 = static_cast<HeaderFileInfoVisitor *>(UserData); 4239 4240 HeaderFileInfoLookupTable *Table 4241 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 4242 if (!Table) 4243 return false; 4244 4245 // Look in the on-disk hash table for an entry for this file name. 4246 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE); 4247 if (Pos == Table->end()) 4248 return false; 4249 4250 This->HFI = *Pos; 4251 return true; 4252 } 4253 4254 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 4255 }; 4256} 4257 4258HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 4259 HeaderFileInfoVisitor Visitor(FE); 4260 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 4261 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 4262 if (Listener) 4263 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 4264 return *HFI; 4265 } 4266 4267 return HeaderFileInfo(); 4268} 4269 4270void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 4271 // FIXME: Make it work properly with modules. 4272 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates; 4273 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4274 ModuleFile &F = *(*I); 4275 unsigned Idx = 0; 4276 DiagStates.clear(); 4277 assert(!Diag.DiagStates.empty()); 4278 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one. 4279 while (Idx < F.PragmaDiagMappings.size()) { 4280 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 4281 unsigned DiagStateID = F.PragmaDiagMappings[Idx++]; 4282 if (DiagStateID != 0) { 4283 Diag.DiagStatePoints.push_back( 4284 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1], 4285 FullSourceLoc(Loc, SourceMgr))); 4286 continue; 4287 } 4288 4289 assert(DiagStateID == 0); 4290 // A new DiagState was created here. 4291 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 4292 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back(); 4293 DiagStates.push_back(NewState); 4294 Diag.DiagStatePoints.push_back( 4295 DiagnosticsEngine::DiagStatePoint(NewState, 4296 FullSourceLoc(Loc, SourceMgr))); 4297 while (1) { 4298 assert(Idx < F.PragmaDiagMappings.size() && 4299 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 4300 if (Idx >= F.PragmaDiagMappings.size()) { 4301 break; // Something is messed up but at least avoid infinite loop in 4302 // release build. 4303 } 4304 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 4305 if (DiagID == (unsigned)-1) { 4306 break; // no more diag/map pairs for this location. 4307 } 4308 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 4309 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 4310 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 4311 } 4312 } 4313 } 4314} 4315 4316/// \brief Get the correct cursor and offset for loading a type. 4317ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 4318 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 4319 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 4320 ModuleFile *M = I->second; 4321 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 4322} 4323 4324/// \brief Read and return the type with the given index.. 4325/// 4326/// The index is the type ID, shifted and minus the number of predefs. This 4327/// routine actually reads the record corresponding to the type at the given 4328/// location. It is a helper routine for GetType, which deals with reading type 4329/// IDs. 4330QualType ASTReader::readTypeRecord(unsigned Index) { 4331 RecordLocation Loc = TypeCursorForIndex(Index); 4332 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 4333 4334 // Keep track of where we are in the stream, then jump back there 4335 // after reading this type. 4336 SavedStreamPosition SavedPosition(DeclsCursor); 4337 4338 ReadingKindTracker ReadingKind(Read_Type, *this); 4339 4340 // Note that we are loading a type record. 4341 Deserializing AType(this); 4342 4343 unsigned Idx = 0; 4344 DeclsCursor.JumpToBit(Loc.Offset); 4345 RecordData Record; 4346 unsigned Code = DeclsCursor.ReadCode(); 4347 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) { 4348 case TYPE_EXT_QUAL: { 4349 if (Record.size() != 2) { 4350 Error("Incorrect encoding of extended qualifier type"); 4351 return QualType(); 4352 } 4353 QualType Base = readType(*Loc.F, Record, Idx); 4354 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 4355 return Context.getQualifiedType(Base, Quals); 4356 } 4357 4358 case TYPE_COMPLEX: { 4359 if (Record.size() != 1) { 4360 Error("Incorrect encoding of complex type"); 4361 return QualType(); 4362 } 4363 QualType ElemType = readType(*Loc.F, Record, Idx); 4364 return Context.getComplexType(ElemType); 4365 } 4366 4367 case TYPE_POINTER: { 4368 if (Record.size() != 1) { 4369 Error("Incorrect encoding of pointer type"); 4370 return QualType(); 4371 } 4372 QualType PointeeType = readType(*Loc.F, Record, Idx); 4373 return Context.getPointerType(PointeeType); 4374 } 4375 4376 case TYPE_BLOCK_POINTER: { 4377 if (Record.size() != 1) { 4378 Error("Incorrect encoding of block pointer type"); 4379 return QualType(); 4380 } 4381 QualType PointeeType = readType(*Loc.F, Record, Idx); 4382 return Context.getBlockPointerType(PointeeType); 4383 } 4384 4385 case TYPE_LVALUE_REFERENCE: { 4386 if (Record.size() != 2) { 4387 Error("Incorrect encoding of lvalue reference type"); 4388 return QualType(); 4389 } 4390 QualType PointeeType = readType(*Loc.F, Record, Idx); 4391 return Context.getLValueReferenceType(PointeeType, Record[1]); 4392 } 4393 4394 case TYPE_RVALUE_REFERENCE: { 4395 if (Record.size() != 1) { 4396 Error("Incorrect encoding of rvalue reference type"); 4397 return QualType(); 4398 } 4399 QualType PointeeType = readType(*Loc.F, Record, Idx); 4400 return Context.getRValueReferenceType(PointeeType); 4401 } 4402 4403 case TYPE_MEMBER_POINTER: { 4404 if (Record.size() != 2) { 4405 Error("Incorrect encoding of member pointer type"); 4406 return QualType(); 4407 } 4408 QualType PointeeType = readType(*Loc.F, Record, Idx); 4409 QualType ClassType = readType(*Loc.F, Record, Idx); 4410 if (PointeeType.isNull() || ClassType.isNull()) 4411 return QualType(); 4412 4413 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 4414 } 4415 4416 case TYPE_CONSTANT_ARRAY: { 4417 QualType ElementType = readType(*Loc.F, Record, Idx); 4418 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4419 unsigned IndexTypeQuals = Record[2]; 4420 unsigned Idx = 3; 4421 llvm::APInt Size = ReadAPInt(Record, Idx); 4422 return Context.getConstantArrayType(ElementType, Size, 4423 ASM, IndexTypeQuals); 4424 } 4425 4426 case TYPE_INCOMPLETE_ARRAY: { 4427 QualType ElementType = readType(*Loc.F, Record, Idx); 4428 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4429 unsigned IndexTypeQuals = Record[2]; 4430 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 4431 } 4432 4433 case TYPE_VARIABLE_ARRAY: { 4434 QualType ElementType = readType(*Loc.F, Record, Idx); 4435 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4436 unsigned IndexTypeQuals = Record[2]; 4437 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 4438 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 4439 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 4440 ASM, IndexTypeQuals, 4441 SourceRange(LBLoc, RBLoc)); 4442 } 4443 4444 case TYPE_VECTOR: { 4445 if (Record.size() != 3) { 4446 Error("incorrect encoding of vector type in AST file"); 4447 return QualType(); 4448 } 4449 4450 QualType ElementType = readType(*Loc.F, Record, Idx); 4451 unsigned NumElements = Record[1]; 4452 unsigned VecKind = Record[2]; 4453 return Context.getVectorType(ElementType, NumElements, 4454 (VectorType::VectorKind)VecKind); 4455 } 4456 4457 case TYPE_EXT_VECTOR: { 4458 if (Record.size() != 3) { 4459 Error("incorrect encoding of extended vector type in AST file"); 4460 return QualType(); 4461 } 4462 4463 QualType ElementType = readType(*Loc.F, Record, Idx); 4464 unsigned NumElements = Record[1]; 4465 return Context.getExtVectorType(ElementType, NumElements); 4466 } 4467 4468 case TYPE_FUNCTION_NO_PROTO: { 4469 if (Record.size() != 6) { 4470 Error("incorrect encoding of no-proto function type"); 4471 return QualType(); 4472 } 4473 QualType ResultType = readType(*Loc.F, Record, Idx); 4474 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 4475 (CallingConv)Record[4], Record[5]); 4476 return Context.getFunctionNoProtoType(ResultType, Info); 4477 } 4478 4479 case TYPE_FUNCTION_PROTO: { 4480 QualType ResultType = readType(*Loc.F, Record, Idx); 4481 4482 FunctionProtoType::ExtProtoInfo EPI; 4483 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 4484 /*hasregparm*/ Record[2], 4485 /*regparm*/ Record[3], 4486 static_cast<CallingConv>(Record[4]), 4487 /*produces*/ Record[5]); 4488 4489 unsigned Idx = 6; 4490 unsigned NumParams = Record[Idx++]; 4491 SmallVector<QualType, 16> ParamTypes; 4492 for (unsigned I = 0; I != NumParams; ++I) 4493 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 4494 4495 EPI.Variadic = Record[Idx++]; 4496 EPI.HasTrailingReturn = Record[Idx++]; 4497 EPI.TypeQuals = Record[Idx++]; 4498 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 4499 ExceptionSpecificationType EST = 4500 static_cast<ExceptionSpecificationType>(Record[Idx++]); 4501 EPI.ExceptionSpecType = EST; 4502 SmallVector<QualType, 2> Exceptions; 4503 if (EST == EST_Dynamic) { 4504 EPI.NumExceptions = Record[Idx++]; 4505 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 4506 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 4507 EPI.Exceptions = Exceptions.data(); 4508 } else if (EST == EST_ComputedNoexcept) { 4509 EPI.NoexceptExpr = ReadExpr(*Loc.F); 4510 } else if (EST == EST_Uninstantiated) { 4511 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4512 EPI.ExceptionSpecTemplate = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4513 } else if (EST == EST_Unevaluated) { 4514 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4515 } 4516 return Context.getFunctionType(ResultType, ParamTypes, EPI); 4517 } 4518 4519 case TYPE_UNRESOLVED_USING: { 4520 unsigned Idx = 0; 4521 return Context.getTypeDeclType( 4522 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 4523 } 4524 4525 case TYPE_TYPEDEF: { 4526 if (Record.size() != 2) { 4527 Error("incorrect encoding of typedef type"); 4528 return QualType(); 4529 } 4530 unsigned Idx = 0; 4531 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 4532 QualType Canonical = readType(*Loc.F, Record, Idx); 4533 if (!Canonical.isNull()) 4534 Canonical = Context.getCanonicalType(Canonical); 4535 return Context.getTypedefType(Decl, Canonical); 4536 } 4537 4538 case TYPE_TYPEOF_EXPR: 4539 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 4540 4541 case TYPE_TYPEOF: { 4542 if (Record.size() != 1) { 4543 Error("incorrect encoding of typeof(type) in AST file"); 4544 return QualType(); 4545 } 4546 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4547 return Context.getTypeOfType(UnderlyingType); 4548 } 4549 4550 case TYPE_DECLTYPE: { 4551 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4552 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType); 4553 } 4554 4555 case TYPE_UNARY_TRANSFORM: { 4556 QualType BaseType = readType(*Loc.F, Record, Idx); 4557 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4558 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 4559 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 4560 } 4561 4562 case TYPE_AUTO: 4563 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 4564 4565 case TYPE_RECORD: { 4566 if (Record.size() != 2) { 4567 Error("incorrect encoding of record type"); 4568 return QualType(); 4569 } 4570 unsigned Idx = 0; 4571 bool IsDependent = Record[Idx++]; 4572 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx); 4573 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl()); 4574 QualType T = Context.getRecordType(RD); 4575 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4576 return T; 4577 } 4578 4579 case TYPE_ENUM: { 4580 if (Record.size() != 2) { 4581 Error("incorrect encoding of enum type"); 4582 return QualType(); 4583 } 4584 unsigned Idx = 0; 4585 bool IsDependent = Record[Idx++]; 4586 QualType T 4587 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 4588 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4589 return T; 4590 } 4591 4592 case TYPE_ATTRIBUTED: { 4593 if (Record.size() != 3) { 4594 Error("incorrect encoding of attributed type"); 4595 return QualType(); 4596 } 4597 QualType modifiedType = readType(*Loc.F, Record, Idx); 4598 QualType equivalentType = readType(*Loc.F, Record, Idx); 4599 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 4600 return Context.getAttributedType(kind, modifiedType, equivalentType); 4601 } 4602 4603 case TYPE_PAREN: { 4604 if (Record.size() != 1) { 4605 Error("incorrect encoding of paren type"); 4606 return QualType(); 4607 } 4608 QualType InnerType = readType(*Loc.F, Record, Idx); 4609 return Context.getParenType(InnerType); 4610 } 4611 4612 case TYPE_PACK_EXPANSION: { 4613 if (Record.size() != 2) { 4614 Error("incorrect encoding of pack expansion type"); 4615 return QualType(); 4616 } 4617 QualType Pattern = readType(*Loc.F, Record, Idx); 4618 if (Pattern.isNull()) 4619 return QualType(); 4620 Optional<unsigned> NumExpansions; 4621 if (Record[1]) 4622 NumExpansions = Record[1] - 1; 4623 return Context.getPackExpansionType(Pattern, NumExpansions); 4624 } 4625 4626 case TYPE_ELABORATED: { 4627 unsigned Idx = 0; 4628 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4629 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4630 QualType NamedType = readType(*Loc.F, Record, Idx); 4631 return Context.getElaboratedType(Keyword, NNS, NamedType); 4632 } 4633 4634 case TYPE_OBJC_INTERFACE: { 4635 unsigned Idx = 0; 4636 ObjCInterfaceDecl *ItfD 4637 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 4638 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl()); 4639 } 4640 4641 case TYPE_OBJC_OBJECT: { 4642 unsigned Idx = 0; 4643 QualType Base = readType(*Loc.F, Record, Idx); 4644 unsigned NumProtos = Record[Idx++]; 4645 SmallVector<ObjCProtocolDecl*, 4> Protos; 4646 for (unsigned I = 0; I != NumProtos; ++I) 4647 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 4648 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 4649 } 4650 4651 case TYPE_OBJC_OBJECT_POINTER: { 4652 unsigned Idx = 0; 4653 QualType Pointee = readType(*Loc.F, Record, Idx); 4654 return Context.getObjCObjectPointerType(Pointee); 4655 } 4656 4657 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 4658 unsigned Idx = 0; 4659 QualType Parm = readType(*Loc.F, Record, Idx); 4660 QualType Replacement = readType(*Loc.F, Record, Idx); 4661 return 4662 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 4663 Replacement); 4664 } 4665 4666 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 4667 unsigned Idx = 0; 4668 QualType Parm = readType(*Loc.F, Record, Idx); 4669 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 4670 return Context.getSubstTemplateTypeParmPackType( 4671 cast<TemplateTypeParmType>(Parm), 4672 ArgPack); 4673 } 4674 4675 case TYPE_INJECTED_CLASS_NAME: { 4676 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 4677 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 4678 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 4679 // for AST reading, too much interdependencies. 4680 return 4681 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 4682 } 4683 4684 case TYPE_TEMPLATE_TYPE_PARM: { 4685 unsigned Idx = 0; 4686 unsigned Depth = Record[Idx++]; 4687 unsigned Index = Record[Idx++]; 4688 bool Pack = Record[Idx++]; 4689 TemplateTypeParmDecl *D 4690 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 4691 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 4692 } 4693 4694 case TYPE_DEPENDENT_NAME: { 4695 unsigned Idx = 0; 4696 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4697 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4698 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4699 QualType Canon = readType(*Loc.F, Record, Idx); 4700 if (!Canon.isNull()) 4701 Canon = Context.getCanonicalType(Canon); 4702 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 4703 } 4704 4705 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 4706 unsigned Idx = 0; 4707 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4708 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4709 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4710 unsigned NumArgs = Record[Idx++]; 4711 SmallVector<TemplateArgument, 8> Args; 4712 Args.reserve(NumArgs); 4713 while (NumArgs--) 4714 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 4715 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 4716 Args.size(), Args.data()); 4717 } 4718 4719 case TYPE_DEPENDENT_SIZED_ARRAY: { 4720 unsigned Idx = 0; 4721 4722 // ArrayType 4723 QualType ElementType = readType(*Loc.F, Record, Idx); 4724 ArrayType::ArraySizeModifier ASM 4725 = (ArrayType::ArraySizeModifier)Record[Idx++]; 4726 unsigned IndexTypeQuals = Record[Idx++]; 4727 4728 // DependentSizedArrayType 4729 Expr *NumElts = ReadExpr(*Loc.F); 4730 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 4731 4732 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 4733 IndexTypeQuals, Brackets); 4734 } 4735 4736 case TYPE_TEMPLATE_SPECIALIZATION: { 4737 unsigned Idx = 0; 4738 bool IsDependent = Record[Idx++]; 4739 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 4740 SmallVector<TemplateArgument, 8> Args; 4741 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 4742 QualType Underlying = readType(*Loc.F, Record, Idx); 4743 QualType T; 4744 if (Underlying.isNull()) 4745 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 4746 Args.size()); 4747 else 4748 T = Context.getTemplateSpecializationType(Name, Args.data(), 4749 Args.size(), Underlying); 4750 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4751 return T; 4752 } 4753 4754 case TYPE_ATOMIC: { 4755 if (Record.size() != 1) { 4756 Error("Incorrect encoding of atomic type"); 4757 return QualType(); 4758 } 4759 QualType ValueType = readType(*Loc.F, Record, Idx); 4760 return Context.getAtomicType(ValueType); 4761 } 4762 } 4763 llvm_unreachable("Invalid TypeCode!"); 4764} 4765 4766class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 4767 ASTReader &Reader; 4768 ModuleFile &F; 4769 const ASTReader::RecordData &Record; 4770 unsigned &Idx; 4771 4772 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4773 unsigned &I) { 4774 return Reader.ReadSourceLocation(F, R, I); 4775 } 4776 4777 template<typename T> 4778 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4779 return Reader.ReadDeclAs<T>(F, Record, Idx); 4780 } 4781 4782public: 4783 TypeLocReader(ASTReader &Reader, ModuleFile &F, 4784 const ASTReader::RecordData &Record, unsigned &Idx) 4785 : Reader(Reader), F(F), Record(Record), Idx(Idx) 4786 { } 4787 4788 // We want compile-time assurance that we've enumerated all of 4789 // these, so unfortunately we have to declare them first, then 4790 // define them out-of-line. 4791#define ABSTRACT_TYPELOC(CLASS, PARENT) 4792#define TYPELOC(CLASS, PARENT) \ 4793 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4794#include "clang/AST/TypeLocNodes.def" 4795 4796 void VisitFunctionTypeLoc(FunctionTypeLoc); 4797 void VisitArrayTypeLoc(ArrayTypeLoc); 4798}; 4799 4800void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4801 // nothing to do 4802} 4803void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4804 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4805 if (TL.needsExtraLocalData()) { 4806 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4807 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4808 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4809 TL.setModeAttr(Record[Idx++]); 4810 } 4811} 4812void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4813 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4814} 4815void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4816 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4817} 4818void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4819 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4820} 4821void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4822 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4823} 4824void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4825 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4826} 4827void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4828 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4829 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4830} 4831void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4832 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4833 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4834 if (Record[Idx++]) 4835 TL.setSizeExpr(Reader.ReadExpr(F)); 4836 else 4837 TL.setSizeExpr(0); 4838} 4839void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4840 VisitArrayTypeLoc(TL); 4841} 4842void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4843 VisitArrayTypeLoc(TL); 4844} 4845void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4846 VisitArrayTypeLoc(TL); 4847} 4848void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4849 DependentSizedArrayTypeLoc TL) { 4850 VisitArrayTypeLoc(TL); 4851} 4852void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4853 DependentSizedExtVectorTypeLoc TL) { 4854 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4855} 4856void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4857 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4858} 4859void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4860 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4861} 4862void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4863 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4864 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4865 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4866 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4867 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4868 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4869 } 4870} 4871void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4872 VisitFunctionTypeLoc(TL); 4873} 4874void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4875 VisitFunctionTypeLoc(TL); 4876} 4877void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4878 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4879} 4880void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4881 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4882} 4883void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4884 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4885 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4886 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4887} 4888void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4889 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4890 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4891 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4892 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4893} 4894void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4895 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4896} 4897void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4898 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4899 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4900 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4901 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4902} 4903void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4904 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4905} 4906void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4907 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4908} 4909void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4910 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4911} 4912void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4913 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4914 if (TL.hasAttrOperand()) { 4915 SourceRange range; 4916 range.setBegin(ReadSourceLocation(Record, Idx)); 4917 range.setEnd(ReadSourceLocation(Record, Idx)); 4918 TL.setAttrOperandParensRange(range); 4919 } 4920 if (TL.hasAttrExprOperand()) { 4921 if (Record[Idx++]) 4922 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4923 else 4924 TL.setAttrExprOperand(0); 4925 } else if (TL.hasAttrEnumOperand()) 4926 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4927} 4928void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4929 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4930} 4931void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4932 SubstTemplateTypeParmTypeLoc TL) { 4933 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4934} 4935void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4936 SubstTemplateTypeParmPackTypeLoc TL) { 4937 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4938} 4939void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4940 TemplateSpecializationTypeLoc TL) { 4941 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4942 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4943 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4944 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4945 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4946 TL.setArgLocInfo(i, 4947 Reader.GetTemplateArgumentLocInfo(F, 4948 TL.getTypePtr()->getArg(i).getKind(), 4949 Record, Idx)); 4950} 4951void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4952 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4953 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4954} 4955void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4956 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4957 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4958} 4959void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4960 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4961} 4962void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4963 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4964 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4965 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4966} 4967void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4968 DependentTemplateSpecializationTypeLoc TL) { 4969 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4970 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4971 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4972 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4973 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4974 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4975 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4976 TL.setArgLocInfo(I, 4977 Reader.GetTemplateArgumentLocInfo(F, 4978 TL.getTypePtr()->getArg(I).getKind(), 4979 Record, Idx)); 4980} 4981void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4982 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4983} 4984void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4985 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4986} 4987void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4988 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4989 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4990 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4991 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4992 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4993} 4994void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4995 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4996} 4997void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4998 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4999 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5000 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5001} 5002 5003TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 5004 const RecordData &Record, 5005 unsigned &Idx) { 5006 QualType InfoTy = readType(F, Record, Idx); 5007 if (InfoTy.isNull()) 5008 return 0; 5009 5010 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 5011 TypeLocReader TLR(*this, F, Record, Idx); 5012 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 5013 TLR.Visit(TL); 5014 return TInfo; 5015} 5016 5017QualType ASTReader::GetType(TypeID ID) { 5018 unsigned FastQuals = ID & Qualifiers::FastMask; 5019 unsigned Index = ID >> Qualifiers::FastWidth; 5020 5021 if (Index < NUM_PREDEF_TYPE_IDS) { 5022 QualType T; 5023 switch ((PredefinedTypeIDs)Index) { 5024 case PREDEF_TYPE_NULL_ID: return QualType(); 5025 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 5026 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 5027 5028 case PREDEF_TYPE_CHAR_U_ID: 5029 case PREDEF_TYPE_CHAR_S_ID: 5030 // FIXME: Check that the signedness of CharTy is correct! 5031 T = Context.CharTy; 5032 break; 5033 5034 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 5035 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 5036 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 5037 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 5038 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 5039 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 5040 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 5041 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 5042 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 5043 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 5044 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 5045 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 5046 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 5047 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 5048 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 5049 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 5050 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 5051 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 5052 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 5053 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 5054 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 5055 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 5056 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 5057 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 5058 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 5059 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 5060 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 5061 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 5062 case PREDEF_TYPE_IMAGE1D_ID: T = Context.OCLImage1dTy; break; 5063 case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break; 5064 case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break; 5065 case PREDEF_TYPE_IMAGE2D_ID: T = Context.OCLImage2dTy; break; 5066 case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break; 5067 case PREDEF_TYPE_IMAGE3D_ID: T = Context.OCLImage3dTy; break; 5068 case PREDEF_TYPE_SAMPLER_ID: T = Context.OCLSamplerTy; break; 5069 case PREDEF_TYPE_EVENT_ID: T = Context.OCLEventTy; break; 5070 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 5071 5072 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 5073 T = Context.getAutoRRefDeductType(); 5074 break; 5075 5076 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 5077 T = Context.ARCUnbridgedCastTy; 5078 break; 5079 5080 case PREDEF_TYPE_VA_LIST_TAG: 5081 T = Context.getVaListTagType(); 5082 break; 5083 5084 case PREDEF_TYPE_BUILTIN_FN: 5085 T = Context.BuiltinFnTy; 5086 break; 5087 } 5088 5089 assert(!T.isNull() && "Unknown predefined type"); 5090 return T.withFastQualifiers(FastQuals); 5091 } 5092 5093 Index -= NUM_PREDEF_TYPE_IDS; 5094 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 5095 if (TypesLoaded[Index].isNull()) { 5096 TypesLoaded[Index] = readTypeRecord(Index); 5097 if (TypesLoaded[Index].isNull()) 5098 return QualType(); 5099 5100 TypesLoaded[Index]->setFromAST(); 5101 if (DeserializationListener) 5102 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 5103 TypesLoaded[Index]); 5104 } 5105 5106 return TypesLoaded[Index].withFastQualifiers(FastQuals); 5107} 5108 5109QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 5110 return GetType(getGlobalTypeID(F, LocalID)); 5111} 5112 5113serialization::TypeID 5114ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 5115 unsigned FastQuals = LocalID & Qualifiers::FastMask; 5116 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 5117 5118 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 5119 return LocalID; 5120 5121 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5122 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 5123 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 5124 5125 unsigned GlobalIndex = LocalIndex + I->second; 5126 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 5127} 5128 5129TemplateArgumentLocInfo 5130ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 5131 TemplateArgument::ArgKind Kind, 5132 const RecordData &Record, 5133 unsigned &Index) { 5134 switch (Kind) { 5135 case TemplateArgument::Expression: 5136 return ReadExpr(F); 5137 case TemplateArgument::Type: 5138 return GetTypeSourceInfo(F, Record, Index); 5139 case TemplateArgument::Template: { 5140 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5141 Index); 5142 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5143 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5144 SourceLocation()); 5145 } 5146 case TemplateArgument::TemplateExpansion: { 5147 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5148 Index); 5149 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5150 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 5151 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5152 EllipsisLoc); 5153 } 5154 case TemplateArgument::Null: 5155 case TemplateArgument::Integral: 5156 case TemplateArgument::Declaration: 5157 case TemplateArgument::NullPtr: 5158 case TemplateArgument::Pack: 5159 // FIXME: Is this right? 5160 return TemplateArgumentLocInfo(); 5161 } 5162 llvm_unreachable("unexpected template argument loc"); 5163} 5164 5165TemplateArgumentLoc 5166ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 5167 const RecordData &Record, unsigned &Index) { 5168 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 5169 5170 if (Arg.getKind() == TemplateArgument::Expression) { 5171 if (Record[Index++]) // bool InfoHasSameExpr. 5172 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 5173 } 5174 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 5175 Record, Index)); 5176} 5177 5178Decl *ASTReader::GetExternalDecl(uint32_t ID) { 5179 return GetDecl(ID); 5180} 5181 5182uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 5183 unsigned &Idx){ 5184 if (Idx >= Record.size()) 5185 return 0; 5186 5187 unsigned LocalID = Record[Idx++]; 5188 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 5189} 5190 5191CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 5192 RecordLocation Loc = getLocalBitOffset(Offset); 5193 BitstreamCursor &Cursor = Loc.F->DeclsCursor; 5194 SavedStreamPosition SavedPosition(Cursor); 5195 Cursor.JumpToBit(Loc.Offset); 5196 ReadingKindTracker ReadingKind(Read_Decl, *this); 5197 RecordData Record; 5198 unsigned Code = Cursor.ReadCode(); 5199 unsigned RecCode = Cursor.readRecord(Code, Record); 5200 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 5201 Error("Malformed AST file: missing C++ base specifiers"); 5202 return 0; 5203 } 5204 5205 unsigned Idx = 0; 5206 unsigned NumBases = Record[Idx++]; 5207 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 5208 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 5209 for (unsigned I = 0; I != NumBases; ++I) 5210 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 5211 return Bases; 5212} 5213 5214serialization::DeclID 5215ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const { 5216 if (LocalID < NUM_PREDEF_DECL_IDS) 5217 return LocalID; 5218 5219 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5220 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 5221 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 5222 5223 return LocalID + I->second; 5224} 5225 5226bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 5227 ModuleFile &M) const { 5228 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 5229 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5230 return &M == I->second; 5231} 5232 5233ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) { 5234 if (!D->isFromASTFile()) 5235 return 0; 5236 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID()); 5237 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5238 return I->second; 5239} 5240 5241SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 5242 if (ID < NUM_PREDEF_DECL_IDS) 5243 return SourceLocation(); 5244 5245 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5246 5247 if (Index > DeclsLoaded.size()) { 5248 Error("declaration ID out-of-range for AST file"); 5249 return SourceLocation(); 5250 } 5251 5252 if (Decl *D = DeclsLoaded[Index]) 5253 return D->getLocation(); 5254 5255 unsigned RawLocation = 0; 5256 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 5257 return ReadSourceLocation(*Rec.F, RawLocation); 5258} 5259 5260Decl *ASTReader::GetDecl(DeclID ID) { 5261 if (ID < NUM_PREDEF_DECL_IDS) { 5262 switch ((PredefinedDeclIDs)ID) { 5263 case PREDEF_DECL_NULL_ID: 5264 return 0; 5265 5266 case PREDEF_DECL_TRANSLATION_UNIT_ID: 5267 return Context.getTranslationUnitDecl(); 5268 5269 case PREDEF_DECL_OBJC_ID_ID: 5270 return Context.getObjCIdDecl(); 5271 5272 case PREDEF_DECL_OBJC_SEL_ID: 5273 return Context.getObjCSelDecl(); 5274 5275 case PREDEF_DECL_OBJC_CLASS_ID: 5276 return Context.getObjCClassDecl(); 5277 5278 case PREDEF_DECL_OBJC_PROTOCOL_ID: 5279 return Context.getObjCProtocolDecl(); 5280 5281 case PREDEF_DECL_INT_128_ID: 5282 return Context.getInt128Decl(); 5283 5284 case PREDEF_DECL_UNSIGNED_INT_128_ID: 5285 return Context.getUInt128Decl(); 5286 5287 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 5288 return Context.getObjCInstanceTypeDecl(); 5289 5290 case PREDEF_DECL_BUILTIN_VA_LIST_ID: 5291 return Context.getBuiltinVaListDecl(); 5292 } 5293 } 5294 5295 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5296 5297 if (Index >= DeclsLoaded.size()) { 5298 assert(0 && "declaration ID out-of-range for AST file"); 5299 Error("declaration ID out-of-range for AST file"); 5300 return 0; 5301 } 5302 5303 if (!DeclsLoaded[Index]) { 5304 ReadDeclRecord(ID); 5305 if (DeserializationListener) 5306 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 5307 } 5308 5309 return DeclsLoaded[Index]; 5310} 5311 5312DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 5313 DeclID GlobalID) { 5314 if (GlobalID < NUM_PREDEF_DECL_IDS) 5315 return GlobalID; 5316 5317 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 5318 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5319 ModuleFile *Owner = I->second; 5320 5321 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 5322 = M.GlobalToLocalDeclIDs.find(Owner); 5323 if (Pos == M.GlobalToLocalDeclIDs.end()) 5324 return 0; 5325 5326 return GlobalID - Owner->BaseDeclID + Pos->second; 5327} 5328 5329serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 5330 const RecordData &Record, 5331 unsigned &Idx) { 5332 if (Idx >= Record.size()) { 5333 Error("Corrupted AST file"); 5334 return 0; 5335 } 5336 5337 return getGlobalDeclID(F, Record[Idx++]); 5338} 5339 5340/// \brief Resolve the offset of a statement into a statement. 5341/// 5342/// This operation will read a new statement from the external 5343/// source each time it is called, and is meant to be used via a 5344/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 5345Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 5346 // Switch case IDs are per Decl. 5347 ClearSwitchCaseIDs(); 5348 5349 // Offset here is a global offset across the entire chain. 5350 RecordLocation Loc = getLocalBitOffset(Offset); 5351 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 5352 return ReadStmtFromStream(*Loc.F); 5353} 5354 5355namespace { 5356 class FindExternalLexicalDeclsVisitor { 5357 ASTReader &Reader; 5358 const DeclContext *DC; 5359 bool (*isKindWeWant)(Decl::Kind); 5360 5361 SmallVectorImpl<Decl*> &Decls; 5362 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 5363 5364 public: 5365 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 5366 bool (*isKindWeWant)(Decl::Kind), 5367 SmallVectorImpl<Decl*> &Decls) 5368 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 5369 { 5370 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 5371 PredefsVisited[I] = false; 5372 } 5373 5374 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 5375 if (Preorder) 5376 return false; 5377 5378 FindExternalLexicalDeclsVisitor *This 5379 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 5380 5381 ModuleFile::DeclContextInfosMap::iterator Info 5382 = M.DeclContextInfos.find(This->DC); 5383 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 5384 return false; 5385 5386 // Load all of the declaration IDs 5387 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 5388 *IDE = ID + Info->second.NumLexicalDecls; 5389 ID != IDE; ++ID) { 5390 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 5391 continue; 5392 5393 // Don't add predefined declarations to the lexical context more 5394 // than once. 5395 if (ID->second < NUM_PREDEF_DECL_IDS) { 5396 if (This->PredefsVisited[ID->second]) 5397 continue; 5398 5399 This->PredefsVisited[ID->second] = true; 5400 } 5401 5402 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 5403 if (!This->DC->isDeclInLexicalTraversal(D)) 5404 This->Decls.push_back(D); 5405 } 5406 } 5407 5408 return false; 5409 } 5410 }; 5411} 5412 5413ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 5414 bool (*isKindWeWant)(Decl::Kind), 5415 SmallVectorImpl<Decl*> &Decls) { 5416 // There might be lexical decls in multiple modules, for the TU at 5417 // least. Walk all of the modules in the order they were loaded. 5418 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 5419 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 5420 ++NumLexicalDeclContextsRead; 5421 return ELR_Success; 5422} 5423 5424namespace { 5425 5426class DeclIDComp { 5427 ASTReader &Reader; 5428 ModuleFile &Mod; 5429 5430public: 5431 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 5432 5433 bool operator()(LocalDeclID L, LocalDeclID R) const { 5434 SourceLocation LHS = getLocation(L); 5435 SourceLocation RHS = getLocation(R); 5436 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5437 } 5438 5439 bool operator()(SourceLocation LHS, LocalDeclID R) const { 5440 SourceLocation RHS = getLocation(R); 5441 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5442 } 5443 5444 bool operator()(LocalDeclID L, SourceLocation RHS) const { 5445 SourceLocation LHS = getLocation(L); 5446 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5447 } 5448 5449 SourceLocation getLocation(LocalDeclID ID) const { 5450 return Reader.getSourceManager().getFileLoc( 5451 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 5452 } 5453}; 5454 5455} 5456 5457void ASTReader::FindFileRegionDecls(FileID File, 5458 unsigned Offset, unsigned Length, 5459 SmallVectorImpl<Decl *> &Decls) { 5460 SourceManager &SM = getSourceManager(); 5461 5462 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 5463 if (I == FileDeclIDs.end()) 5464 return; 5465 5466 FileDeclsInfo &DInfo = I->second; 5467 if (DInfo.Decls.empty()) 5468 return; 5469 5470 SourceLocation 5471 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 5472 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 5473 5474 DeclIDComp DIDComp(*this, *DInfo.Mod); 5475 ArrayRef<serialization::LocalDeclID>::iterator 5476 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5477 BeginLoc, DIDComp); 5478 if (BeginIt != DInfo.Decls.begin()) 5479 --BeginIt; 5480 5481 // If we are pointing at a top-level decl inside an objc container, we need 5482 // to backtrack until we find it otherwise we will fail to report that the 5483 // region overlaps with an objc container. 5484 while (BeginIt != DInfo.Decls.begin() && 5485 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 5486 ->isTopLevelDeclInObjCContainer()) 5487 --BeginIt; 5488 5489 ArrayRef<serialization::LocalDeclID>::iterator 5490 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5491 EndLoc, DIDComp); 5492 if (EndIt != DInfo.Decls.end()) 5493 ++EndIt; 5494 5495 for (ArrayRef<serialization::LocalDeclID>::iterator 5496 DIt = BeginIt; DIt != EndIt; ++DIt) 5497 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 5498} 5499 5500namespace { 5501 /// \brief ModuleFile visitor used to perform name lookup into a 5502 /// declaration context. 5503 class DeclContextNameLookupVisitor { 5504 ASTReader &Reader; 5505 SmallVectorImpl<const DeclContext *> &Contexts; 5506 DeclarationName Name; 5507 SmallVectorImpl<NamedDecl *> &Decls; 5508 5509 public: 5510 DeclContextNameLookupVisitor(ASTReader &Reader, 5511 SmallVectorImpl<const DeclContext *> &Contexts, 5512 DeclarationName Name, 5513 SmallVectorImpl<NamedDecl *> &Decls) 5514 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { } 5515 5516 static bool visit(ModuleFile &M, void *UserData) { 5517 DeclContextNameLookupVisitor *This 5518 = static_cast<DeclContextNameLookupVisitor *>(UserData); 5519 5520 // Check whether we have any visible declaration information for 5521 // this context in this module. 5522 ModuleFile::DeclContextInfosMap::iterator Info; 5523 bool FoundInfo = false; 5524 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5525 Info = M.DeclContextInfos.find(This->Contexts[I]); 5526 if (Info != M.DeclContextInfos.end() && 5527 Info->second.NameLookupTableData) { 5528 FoundInfo = true; 5529 break; 5530 } 5531 } 5532 5533 if (!FoundInfo) 5534 return false; 5535 5536 // Look for this name within this module. 5537 ASTDeclContextNameLookupTable *LookupTable = 5538 Info->second.NameLookupTableData; 5539 ASTDeclContextNameLookupTable::iterator Pos 5540 = LookupTable->find(This->Name); 5541 if (Pos == LookupTable->end()) 5542 return false; 5543 5544 bool FoundAnything = false; 5545 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 5546 for (; Data.first != Data.second; ++Data.first) { 5547 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 5548 if (!ND) 5549 continue; 5550 5551 if (ND->getDeclName() != This->Name) { 5552 // A name might be null because the decl's redeclarable part is 5553 // currently read before reading its name. The lookup is triggered by 5554 // building that decl (likely indirectly), and so it is later in the 5555 // sense of "already existing" and can be ignored here. 5556 continue; 5557 } 5558 5559 // Record this declaration. 5560 FoundAnything = true; 5561 This->Decls.push_back(ND); 5562 } 5563 5564 return FoundAnything; 5565 } 5566 }; 5567} 5568 5569/// \brief Retrieve the "definitive" module file for the definition of the 5570/// given declaration context, if there is one. 5571/// 5572/// The "definitive" module file is the only place where we need to look to 5573/// find information about the declarations within the given declaration 5574/// context. For example, C++ and Objective-C classes, C structs/unions, and 5575/// Objective-C protocols, categories, and extensions are all defined in a 5576/// single place in the source code, so they have definitive module files 5577/// associated with them. C++ namespaces, on the other hand, can have 5578/// definitions in multiple different module files. 5579/// 5580/// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's 5581/// NDEBUG checking. 5582static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC, 5583 ASTReader &Reader) { 5584 if (const DeclContext *DefDC = getDefinitiveDeclContext(DC)) 5585 return Reader.getOwningModuleFile(cast<Decl>(DefDC)); 5586 5587 return 0; 5588} 5589 5590bool 5591ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 5592 DeclarationName Name) { 5593 assert(DC->hasExternalVisibleStorage() && 5594 "DeclContext has no visible decls in storage"); 5595 if (!Name) 5596 return false; 5597 5598 SmallVector<NamedDecl *, 64> Decls; 5599 5600 // Compute the declaration contexts we need to look into. Multiple such 5601 // declaration contexts occur when two declaration contexts from disjoint 5602 // modules get merged, e.g., when two namespaces with the same name are 5603 // independently defined in separate modules. 5604 SmallVector<const DeclContext *, 2> Contexts; 5605 Contexts.push_back(DC); 5606 5607 if (DC->isNamespace()) { 5608 MergedDeclsMap::iterator Merged 5609 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5610 if (Merged != MergedDecls.end()) { 5611 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5612 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5613 } 5614 } 5615 5616 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls); 5617 5618 // If we can definitively determine which module file to look into, 5619 // only look there. Otherwise, look in all module files. 5620 ModuleFile *Definitive; 5621 if (Contexts.size() == 1 && 5622 (Definitive = getDefinitiveModuleFileFor(DC, *this))) { 5623 DeclContextNameLookupVisitor::visit(*Definitive, &Visitor); 5624 } else { 5625 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 5626 } 5627 ++NumVisibleDeclContextsRead; 5628 SetExternalVisibleDeclsForName(DC, Name, Decls); 5629 return !Decls.empty(); 5630} 5631 5632namespace { 5633 /// \brief ModuleFile visitor used to retrieve all visible names in a 5634 /// declaration context. 5635 class DeclContextAllNamesVisitor { 5636 ASTReader &Reader; 5637 SmallVectorImpl<const DeclContext *> &Contexts; 5638 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls; 5639 bool VisitAll; 5640 5641 public: 5642 DeclContextAllNamesVisitor(ASTReader &Reader, 5643 SmallVectorImpl<const DeclContext *> &Contexts, 5644 llvm::DenseMap<DeclarationName, 5645 SmallVector<NamedDecl *, 8> > &Decls, 5646 bool VisitAll) 5647 : Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { } 5648 5649 static bool visit(ModuleFile &M, void *UserData) { 5650 DeclContextAllNamesVisitor *This 5651 = static_cast<DeclContextAllNamesVisitor *>(UserData); 5652 5653 // Check whether we have any visible declaration information for 5654 // this context in this module. 5655 ModuleFile::DeclContextInfosMap::iterator Info; 5656 bool FoundInfo = false; 5657 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5658 Info = M.DeclContextInfos.find(This->Contexts[I]); 5659 if (Info != M.DeclContextInfos.end() && 5660 Info->second.NameLookupTableData) { 5661 FoundInfo = true; 5662 break; 5663 } 5664 } 5665 5666 if (!FoundInfo) 5667 return false; 5668 5669 ASTDeclContextNameLookupTable *LookupTable = 5670 Info->second.NameLookupTableData; 5671 bool FoundAnything = false; 5672 for (ASTDeclContextNameLookupTable::data_iterator 5673 I = LookupTable->data_begin(), E = LookupTable->data_end(); 5674 I != E; 5675 ++I) { 5676 ASTDeclContextNameLookupTrait::data_type Data = *I; 5677 for (; Data.first != Data.second; ++Data.first) { 5678 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, 5679 *Data.first); 5680 if (!ND) 5681 continue; 5682 5683 // Record this declaration. 5684 FoundAnything = true; 5685 This->Decls[ND->getDeclName()].push_back(ND); 5686 } 5687 } 5688 5689 return FoundAnything && !This->VisitAll; 5690 } 5691 }; 5692} 5693 5694void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) { 5695 if (!DC->hasExternalVisibleStorage()) 5696 return; 5697 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > Decls; 5698 5699 // Compute the declaration contexts we need to look into. Multiple such 5700 // declaration contexts occur when two declaration contexts from disjoint 5701 // modules get merged, e.g., when two namespaces with the same name are 5702 // independently defined in separate modules. 5703 SmallVector<const DeclContext *, 2> Contexts; 5704 Contexts.push_back(DC); 5705 5706 if (DC->isNamespace()) { 5707 MergedDeclsMap::iterator Merged 5708 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5709 if (Merged != MergedDecls.end()) { 5710 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5711 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5712 } 5713 } 5714 5715 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls, 5716 /*VisitAll=*/DC->isFileContext()); 5717 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor); 5718 ++NumVisibleDeclContextsRead; 5719 5720 for (llvm::DenseMap<DeclarationName, 5721 SmallVector<NamedDecl *, 8> >::iterator 5722 I = Decls.begin(), E = Decls.end(); I != E; ++I) { 5723 SetExternalVisibleDeclsForName(DC, I->first, I->second); 5724 } 5725 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false); 5726} 5727 5728/// \brief Under non-PCH compilation the consumer receives the objc methods 5729/// before receiving the implementation, and codegen depends on this. 5730/// We simulate this by deserializing and passing to consumer the methods of the 5731/// implementation before passing the deserialized implementation decl. 5732static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 5733 ASTConsumer *Consumer) { 5734 assert(ImplD && Consumer); 5735 5736 for (ObjCImplDecl::method_iterator 5737 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 5738 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 5739 5740 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 5741} 5742 5743void ASTReader::PassInterestingDeclsToConsumer() { 5744 assert(Consumer); 5745 while (!InterestingDecls.empty()) { 5746 Decl *D = InterestingDecls.front(); 5747 InterestingDecls.pop_front(); 5748 5749 PassInterestingDeclToConsumer(D); 5750 } 5751} 5752 5753void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 5754 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 5755 PassObjCImplDeclToConsumer(ImplD, Consumer); 5756 else 5757 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 5758} 5759 5760void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 5761 this->Consumer = Consumer; 5762 5763 if (!Consumer) 5764 return; 5765 5766 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 5767 // Force deserialization of this decl, which will cause it to be queued for 5768 // passing to the consumer. 5769 GetDecl(ExternalDefinitions[I]); 5770 } 5771 ExternalDefinitions.clear(); 5772 5773 PassInterestingDeclsToConsumer(); 5774} 5775 5776void ASTReader::PrintStats() { 5777 std::fprintf(stderr, "*** AST File Statistics:\n"); 5778 5779 unsigned NumTypesLoaded 5780 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 5781 QualType()); 5782 unsigned NumDeclsLoaded 5783 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 5784 (Decl *)0); 5785 unsigned NumIdentifiersLoaded 5786 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 5787 IdentifiersLoaded.end(), 5788 (IdentifierInfo *)0); 5789 unsigned NumMacrosLoaded 5790 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(), 5791 MacrosLoaded.end(), 5792 (MacroDirective *)0); 5793 unsigned NumSelectorsLoaded 5794 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 5795 SelectorsLoaded.end(), 5796 Selector()); 5797 5798 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 5799 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 5800 NumSLocEntriesRead, TotalNumSLocEntries, 5801 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 5802 if (!TypesLoaded.empty()) 5803 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 5804 NumTypesLoaded, (unsigned)TypesLoaded.size(), 5805 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 5806 if (!DeclsLoaded.empty()) 5807 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 5808 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 5809 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 5810 if (!IdentifiersLoaded.empty()) 5811 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 5812 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 5813 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 5814 if (!MacrosLoaded.empty()) 5815 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5816 NumMacrosLoaded, (unsigned)MacrosLoaded.size(), 5817 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100)); 5818 if (!SelectorsLoaded.empty()) 5819 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 5820 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 5821 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 5822 if (TotalNumStatements) 5823 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 5824 NumStatementsRead, TotalNumStatements, 5825 ((float)NumStatementsRead/TotalNumStatements * 100)); 5826 if (TotalNumMacros) 5827 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5828 NumMacrosRead, TotalNumMacros, 5829 ((float)NumMacrosRead/TotalNumMacros * 100)); 5830 if (TotalLexicalDeclContexts) 5831 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 5832 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 5833 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 5834 * 100)); 5835 if (TotalVisibleDeclContexts) 5836 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 5837 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 5838 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 5839 * 100)); 5840 if (TotalNumMethodPoolEntries) { 5841 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 5842 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 5843 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 5844 * 100)); 5845 } 5846 if (NumMethodPoolLookups) { 5847 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n", 5848 NumMethodPoolHits, NumMethodPoolLookups, 5849 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0)); 5850 } 5851 if (NumMethodPoolTableLookups) { 5852 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n", 5853 NumMethodPoolTableHits, NumMethodPoolTableLookups, 5854 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups 5855 * 100.0)); 5856 } 5857 5858 if (NumIdentifierLookupHits) { 5859 std::fprintf(stderr, 5860 " %u / %u identifier table lookups succeeded (%f%%)\n", 5861 NumIdentifierLookupHits, NumIdentifierLookups, 5862 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups); 5863 } 5864 5865 if (GlobalIndex) { 5866 std::fprintf(stderr, "\n"); 5867 GlobalIndex->printStats(); 5868 } 5869 5870 std::fprintf(stderr, "\n"); 5871 dump(); 5872 std::fprintf(stderr, "\n"); 5873} 5874 5875template<typename Key, typename ModuleFile, unsigned InitialCapacity> 5876static void 5877dumpModuleIDMap(StringRef Name, 5878 const ContinuousRangeMap<Key, ModuleFile *, 5879 InitialCapacity> &Map) { 5880 if (Map.begin() == Map.end()) 5881 return; 5882 5883 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 5884 llvm::errs() << Name << ":\n"; 5885 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5886 I != IEnd; ++I) { 5887 llvm::errs() << " " << I->first << " -> " << I->second->FileName 5888 << "\n"; 5889 } 5890} 5891 5892void ASTReader::dump() { 5893 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 5894 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 5895 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 5896 dumpModuleIDMap("Global type map", GlobalTypeMap); 5897 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 5898 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 5899 dumpModuleIDMap("Global macro map", GlobalMacroMap); 5900 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 5901 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 5902 dumpModuleIDMap("Global preprocessed entity map", 5903 GlobalPreprocessedEntityMap); 5904 5905 llvm::errs() << "\n*** PCH/Modules Loaded:"; 5906 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 5907 MEnd = ModuleMgr.end(); 5908 M != MEnd; ++M) 5909 (*M)->dump(); 5910} 5911 5912/// Return the amount of memory used by memory buffers, breaking down 5913/// by heap-backed versus mmap'ed memory. 5914void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 5915 for (ModuleConstIterator I = ModuleMgr.begin(), 5916 E = ModuleMgr.end(); I != E; ++I) { 5917 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 5918 size_t bytes = buf->getBufferSize(); 5919 switch (buf->getBufferKind()) { 5920 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 5921 sizes.malloc_bytes += bytes; 5922 break; 5923 case llvm::MemoryBuffer::MemoryBuffer_MMap: 5924 sizes.mmap_bytes += bytes; 5925 break; 5926 } 5927 } 5928 } 5929} 5930 5931void ASTReader::InitializeSema(Sema &S) { 5932 SemaObj = &S; 5933 S.addExternalSource(this); 5934 5935 // Makes sure any declarations that were deserialized "too early" 5936 // still get added to the identifier's declaration chains. 5937 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 5938 NamedDecl *ND = cast<NamedDecl>(PreloadedDecls[I]->getMostRecentDecl()); 5939 SemaObj->pushExternalDeclIntoScope(ND, PreloadedDecls[I]->getDeclName()); 5940 } 5941 PreloadedDecls.clear(); 5942 5943 // Load the offsets of the declarations that Sema references. 5944 // They will be lazily deserialized when needed. 5945 if (!SemaDeclRefs.empty()) { 5946 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 5947 if (!SemaObj->StdNamespace) 5948 SemaObj->StdNamespace = SemaDeclRefs[0]; 5949 if (!SemaObj->StdBadAlloc) 5950 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 5951 } 5952 5953 if (!FPPragmaOptions.empty()) { 5954 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 5955 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 5956 } 5957 5958 if (!OpenCLExtensions.empty()) { 5959 unsigned I = 0; 5960#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 5961#include "clang/Basic/OpenCLExtensions.def" 5962 5963 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 5964 } 5965} 5966 5967IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 5968 // Note that we are loading an identifier. 5969 Deserializing AnIdentifier(this); 5970 StringRef Name(NameStart, NameEnd - NameStart); 5971 5972 // If there is a global index, look there first to determine which modules 5973 // provably do not have any results for this identifier. 5974 GlobalModuleIndex::HitSet Hits; 5975 GlobalModuleIndex::HitSet *HitsPtr = 0; 5976 if (!loadGlobalIndex()) { 5977 if (GlobalIndex->lookupIdentifier(Name, Hits)) { 5978 HitsPtr = &Hits; 5979 } 5980 } 5981 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0, 5982 NumIdentifierLookups, 5983 NumIdentifierLookupHits); 5984 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 5985 IdentifierInfo *II = Visitor.getIdentifierInfo(); 5986 markIdentifierUpToDate(II); 5987 return II; 5988} 5989 5990namespace clang { 5991 /// \brief An identifier-lookup iterator that enumerates all of the 5992 /// identifiers stored within a set of AST files. 5993 class ASTIdentifierIterator : public IdentifierIterator { 5994 /// \brief The AST reader whose identifiers are being enumerated. 5995 const ASTReader &Reader; 5996 5997 /// \brief The current index into the chain of AST files stored in 5998 /// the AST reader. 5999 unsigned Index; 6000 6001 /// \brief The current position within the identifier lookup table 6002 /// of the current AST file. 6003 ASTIdentifierLookupTable::key_iterator Current; 6004 6005 /// \brief The end position within the identifier lookup table of 6006 /// the current AST file. 6007 ASTIdentifierLookupTable::key_iterator End; 6008 6009 public: 6010 explicit ASTIdentifierIterator(const ASTReader &Reader); 6011 6012 virtual StringRef Next(); 6013 }; 6014} 6015 6016ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 6017 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 6018 ASTIdentifierLookupTable *IdTable 6019 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 6020 Current = IdTable->key_begin(); 6021 End = IdTable->key_end(); 6022} 6023 6024StringRef ASTIdentifierIterator::Next() { 6025 while (Current == End) { 6026 // If we have exhausted all of our AST files, we're done. 6027 if (Index == 0) 6028 return StringRef(); 6029 6030 --Index; 6031 ASTIdentifierLookupTable *IdTable 6032 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 6033 IdentifierLookupTable; 6034 Current = IdTable->key_begin(); 6035 End = IdTable->key_end(); 6036 } 6037 6038 // We have any identifiers remaining in the current AST file; return 6039 // the next one. 6040 StringRef Result = *Current; 6041 ++Current; 6042 return Result; 6043} 6044 6045IdentifierIterator *ASTReader::getIdentifiers() const { 6046 return new ASTIdentifierIterator(*this); 6047} 6048 6049namespace clang { namespace serialization { 6050 class ReadMethodPoolVisitor { 6051 ASTReader &Reader; 6052 Selector Sel; 6053 unsigned PriorGeneration; 6054 SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 6055 SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 6056 6057 public: 6058 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, 6059 unsigned PriorGeneration) 6060 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { } 6061 6062 static bool visit(ModuleFile &M, void *UserData) { 6063 ReadMethodPoolVisitor *This 6064 = static_cast<ReadMethodPoolVisitor *>(UserData); 6065 6066 if (!M.SelectorLookupTable) 6067 return false; 6068 6069 // If we've already searched this module file, skip it now. 6070 if (M.Generation <= This->PriorGeneration) 6071 return true; 6072 6073 ++This->Reader.NumMethodPoolTableLookups; 6074 ASTSelectorLookupTable *PoolTable 6075 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 6076 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 6077 if (Pos == PoolTable->end()) 6078 return false; 6079 6080 ++This->Reader.NumMethodPoolTableHits; 6081 ++This->Reader.NumSelectorsRead; 6082 // FIXME: Not quite happy with the statistics here. We probably should 6083 // disable this tracking when called via LoadSelector. 6084 // Also, should entries without methods count as misses? 6085 ++This->Reader.NumMethodPoolEntriesRead; 6086 ASTSelectorLookupTrait::data_type Data = *Pos; 6087 if (This->Reader.DeserializationListener) 6088 This->Reader.DeserializationListener->SelectorRead(Data.ID, 6089 This->Sel); 6090 6091 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 6092 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 6093 return true; 6094 } 6095 6096 /// \brief Retrieve the instance methods found by this visitor. 6097 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const { 6098 return InstanceMethods; 6099 } 6100 6101 /// \brief Retrieve the instance methods found by this visitor. 6102 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const { 6103 return FactoryMethods; 6104 } 6105 }; 6106} } // end namespace clang::serialization 6107 6108/// \brief Add the given set of methods to the method list. 6109static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods, 6110 ObjCMethodList &List) { 6111 for (unsigned I = 0, N = Methods.size(); I != N; ++I) { 6112 S.addMethodToGlobalList(&List, Methods[I]); 6113 } 6114} 6115 6116void ASTReader::ReadMethodPool(Selector Sel) { 6117 // Get the selector generation and update it to the current generation. 6118 unsigned &Generation = SelectorGeneration[Sel]; 6119 unsigned PriorGeneration = Generation; 6120 Generation = CurrentGeneration; 6121 6122 // Search for methods defined with this selector. 6123 ++NumMethodPoolLookups; 6124 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration); 6125 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 6126 6127 if (Visitor.getInstanceMethods().empty() && 6128 Visitor.getFactoryMethods().empty()) 6129 return; 6130 6131 ++NumMethodPoolHits; 6132 6133 if (!getSema()) 6134 return; 6135 6136 Sema &S = *getSema(); 6137 Sema::GlobalMethodPool::iterator Pos 6138 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first; 6139 6140 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first); 6141 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second); 6142} 6143 6144void ASTReader::ReadKnownNamespaces( 6145 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 6146 Namespaces.clear(); 6147 6148 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 6149 if (NamespaceDecl *Namespace 6150 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 6151 Namespaces.push_back(Namespace); 6152 } 6153} 6154 6155void ASTReader::ReadUndefinedButUsed( 6156 llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) { 6157 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) { 6158 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++])); 6159 SourceLocation Loc = 6160 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]); 6161 Undefined.insert(std::make_pair(D, Loc)); 6162 } 6163} 6164 6165void ASTReader::ReadTentativeDefinitions( 6166 SmallVectorImpl<VarDecl *> &TentativeDefs) { 6167 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 6168 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 6169 if (Var) 6170 TentativeDefs.push_back(Var); 6171 } 6172 TentativeDefinitions.clear(); 6173} 6174 6175void ASTReader::ReadUnusedFileScopedDecls( 6176 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 6177 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 6178 DeclaratorDecl *D 6179 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 6180 if (D) 6181 Decls.push_back(D); 6182 } 6183 UnusedFileScopedDecls.clear(); 6184} 6185 6186void ASTReader::ReadDelegatingConstructors( 6187 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 6188 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 6189 CXXConstructorDecl *D 6190 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 6191 if (D) 6192 Decls.push_back(D); 6193 } 6194 DelegatingCtorDecls.clear(); 6195} 6196 6197void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 6198 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 6199 TypedefNameDecl *D 6200 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 6201 if (D) 6202 Decls.push_back(D); 6203 } 6204 ExtVectorDecls.clear(); 6205} 6206 6207void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 6208 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 6209 CXXRecordDecl *D 6210 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 6211 if (D) 6212 Decls.push_back(D); 6213 } 6214 DynamicClasses.clear(); 6215} 6216 6217void 6218ASTReader::ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl *> &Decls) { 6219 for (unsigned I = 0, N = LocallyScopedExternCDecls.size(); I != N; ++I) { 6220 NamedDecl *D 6221 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternCDecls[I])); 6222 if (D) 6223 Decls.push_back(D); 6224 } 6225 LocallyScopedExternCDecls.clear(); 6226} 6227 6228void ASTReader::ReadReferencedSelectors( 6229 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 6230 if (ReferencedSelectorsData.empty()) 6231 return; 6232 6233 // If there are @selector references added them to its pool. This is for 6234 // implementation of -Wselector. 6235 unsigned int DataSize = ReferencedSelectorsData.size()-1; 6236 unsigned I = 0; 6237 while (I < DataSize) { 6238 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 6239 SourceLocation SelLoc 6240 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 6241 Sels.push_back(std::make_pair(Sel, SelLoc)); 6242 } 6243 ReferencedSelectorsData.clear(); 6244} 6245 6246void ASTReader::ReadWeakUndeclaredIdentifiers( 6247 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 6248 if (WeakUndeclaredIdentifiers.empty()) 6249 return; 6250 6251 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 6252 IdentifierInfo *WeakId 6253 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6254 IdentifierInfo *AliasId 6255 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6256 SourceLocation Loc 6257 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 6258 bool Used = WeakUndeclaredIdentifiers[I++]; 6259 WeakInfo WI(AliasId, Loc); 6260 WI.setUsed(Used); 6261 WeakIDs.push_back(std::make_pair(WeakId, WI)); 6262 } 6263 WeakUndeclaredIdentifiers.clear(); 6264} 6265 6266void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 6267 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 6268 ExternalVTableUse VT; 6269 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 6270 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 6271 VT.DefinitionRequired = VTableUses[Idx++]; 6272 VTables.push_back(VT); 6273 } 6274 6275 VTableUses.clear(); 6276} 6277 6278void ASTReader::ReadPendingInstantiations( 6279 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 6280 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 6281 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 6282 SourceLocation Loc 6283 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 6284 6285 Pending.push_back(std::make_pair(D, Loc)); 6286 } 6287 PendingInstantiations.clear(); 6288} 6289 6290void ASTReader::LoadSelector(Selector Sel) { 6291 // It would be complicated to avoid reading the methods anyway. So don't. 6292 ReadMethodPool(Sel); 6293} 6294 6295void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 6296 assert(ID && "Non-zero identifier ID required"); 6297 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 6298 IdentifiersLoaded[ID - 1] = II; 6299 if (DeserializationListener) 6300 DeserializationListener->IdentifierRead(ID, II); 6301} 6302 6303/// \brief Set the globally-visible declarations associated with the given 6304/// identifier. 6305/// 6306/// If the AST reader is currently in a state where the given declaration IDs 6307/// cannot safely be resolved, they are queued until it is safe to resolve 6308/// them. 6309/// 6310/// \param II an IdentifierInfo that refers to one or more globally-visible 6311/// declarations. 6312/// 6313/// \param DeclIDs the set of declaration IDs with the name @p II that are 6314/// visible at global scope. 6315/// 6316/// \param Decls if non-null, this vector will be populated with the set of 6317/// deserialized declarations. These declarations will not be pushed into 6318/// scope. 6319void 6320ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 6321 const SmallVectorImpl<uint32_t> &DeclIDs, 6322 SmallVectorImpl<Decl *> *Decls) { 6323 if (NumCurrentElementsDeserializing && !Decls) { 6324 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end()); 6325 return; 6326 } 6327 6328 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 6329 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 6330 if (SemaObj) { 6331 // If we're simply supposed to record the declarations, do so now. 6332 if (Decls) { 6333 Decls->push_back(D); 6334 continue; 6335 } 6336 6337 // Introduce this declaration into the translation-unit scope 6338 // and add it to the declaration chain for this identifier, so 6339 // that (unqualified) name lookup will find it. 6340 NamedDecl *ND = cast<NamedDecl>(D->getMostRecentDecl()); 6341 SemaObj->pushExternalDeclIntoScope(ND, II); 6342 } else { 6343 // Queue this declaration so that it will be added to the 6344 // translation unit scope and identifier's declaration chain 6345 // once a Sema object is known. 6346 PreloadedDecls.push_back(D); 6347 } 6348 } 6349} 6350 6351IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 6352 if (ID == 0) 6353 return 0; 6354 6355 if (IdentifiersLoaded.empty()) { 6356 Error("no identifier table in AST file"); 6357 return 0; 6358 } 6359 6360 ID -= 1; 6361 if (!IdentifiersLoaded[ID]) { 6362 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 6363 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 6364 ModuleFile *M = I->second; 6365 unsigned Index = ID - M->BaseIdentifierID; 6366 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 6367 6368 // All of the strings in the AST file are preceded by a 16-bit length. 6369 // Extract that 16-bit length to avoid having to execute strlen(). 6370 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 6371 // unsigned integers. This is important to avoid integer overflow when 6372 // we cast them to 'unsigned'. 6373 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 6374 unsigned StrLen = (((unsigned) StrLenPtr[0]) 6375 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 6376 IdentifiersLoaded[ID] 6377 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 6378 if (DeserializationListener) 6379 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 6380 } 6381 6382 return IdentifiersLoaded[ID]; 6383} 6384 6385IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 6386 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 6387} 6388 6389IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 6390 if (LocalID < NUM_PREDEF_IDENT_IDS) 6391 return LocalID; 6392 6393 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6394 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 6395 assert(I != M.IdentifierRemap.end() 6396 && "Invalid index into identifier index remap"); 6397 6398 return LocalID + I->second; 6399} 6400 6401MacroDirective *ASTReader::getMacro(MacroID ID, MacroDirective *Hint) { 6402 if (ID == 0) 6403 return 0; 6404 6405 if (MacrosLoaded.empty()) { 6406 Error("no macro table in AST file"); 6407 return 0; 6408 } 6409 6410 ID -= NUM_PREDEF_MACRO_IDS; 6411 if (!MacrosLoaded[ID]) { 6412 GlobalMacroMapType::iterator I 6413 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS); 6414 assert(I != GlobalMacroMap.end() && "Corrupted global macro map"); 6415 ModuleFile *M = I->second; 6416 unsigned Index = ID - M->BaseMacroID; 6417 ReadMacroRecord(*M, M->MacroOffsets[Index], Hint); 6418 } 6419 6420 return MacrosLoaded[ID]; 6421} 6422 6423MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) { 6424 if (LocalID < NUM_PREDEF_MACRO_IDS) 6425 return LocalID; 6426 6427 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6428 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS); 6429 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap"); 6430 6431 return LocalID + I->second; 6432} 6433 6434serialization::SubmoduleID 6435ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 6436 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 6437 return LocalID; 6438 6439 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6440 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 6441 assert(I != M.SubmoduleRemap.end() 6442 && "Invalid index into submodule index remap"); 6443 6444 return LocalID + I->second; 6445} 6446 6447Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 6448 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 6449 assert(GlobalID == 0 && "Unhandled global submodule ID"); 6450 return 0; 6451 } 6452 6453 if (GlobalID > SubmodulesLoaded.size()) { 6454 Error("submodule ID out of range in AST file"); 6455 return 0; 6456 } 6457 6458 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 6459} 6460 6461Module *ASTReader::getModule(unsigned ID) { 6462 return getSubmodule(ID); 6463} 6464 6465Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 6466 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 6467} 6468 6469Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 6470 if (ID == 0) 6471 return Selector(); 6472 6473 if (ID > SelectorsLoaded.size()) { 6474 Error("selector ID out of range in AST file"); 6475 return Selector(); 6476 } 6477 6478 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 6479 // Load this selector from the selector table. 6480 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 6481 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 6482 ModuleFile &M = *I->second; 6483 ASTSelectorLookupTrait Trait(*this, M); 6484 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 6485 SelectorsLoaded[ID - 1] = 6486 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 6487 if (DeserializationListener) 6488 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 6489 } 6490 6491 return SelectorsLoaded[ID - 1]; 6492} 6493 6494Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 6495 return DecodeSelector(ID); 6496} 6497 6498uint32_t ASTReader::GetNumExternalSelectors() { 6499 // ID 0 (the null selector) is considered an external selector. 6500 return getTotalNumSelectors() + 1; 6501} 6502 6503serialization::SelectorID 6504ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 6505 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 6506 return LocalID; 6507 6508 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6509 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 6510 assert(I != M.SelectorRemap.end() 6511 && "Invalid index into selector index remap"); 6512 6513 return LocalID + I->second; 6514} 6515 6516DeclarationName 6517ASTReader::ReadDeclarationName(ModuleFile &F, 6518 const RecordData &Record, unsigned &Idx) { 6519 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 6520 switch (Kind) { 6521 case DeclarationName::Identifier: 6522 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 6523 6524 case DeclarationName::ObjCZeroArgSelector: 6525 case DeclarationName::ObjCOneArgSelector: 6526 case DeclarationName::ObjCMultiArgSelector: 6527 return DeclarationName(ReadSelector(F, Record, Idx)); 6528 6529 case DeclarationName::CXXConstructorName: 6530 return Context.DeclarationNames.getCXXConstructorName( 6531 Context.getCanonicalType(readType(F, Record, Idx))); 6532 6533 case DeclarationName::CXXDestructorName: 6534 return Context.DeclarationNames.getCXXDestructorName( 6535 Context.getCanonicalType(readType(F, Record, Idx))); 6536 6537 case DeclarationName::CXXConversionFunctionName: 6538 return Context.DeclarationNames.getCXXConversionFunctionName( 6539 Context.getCanonicalType(readType(F, Record, Idx))); 6540 6541 case DeclarationName::CXXOperatorName: 6542 return Context.DeclarationNames.getCXXOperatorName( 6543 (OverloadedOperatorKind)Record[Idx++]); 6544 6545 case DeclarationName::CXXLiteralOperatorName: 6546 return Context.DeclarationNames.getCXXLiteralOperatorName( 6547 GetIdentifierInfo(F, Record, Idx)); 6548 6549 case DeclarationName::CXXUsingDirective: 6550 return DeclarationName::getUsingDirectiveName(); 6551 } 6552 6553 llvm_unreachable("Invalid NameKind!"); 6554} 6555 6556void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 6557 DeclarationNameLoc &DNLoc, 6558 DeclarationName Name, 6559 const RecordData &Record, unsigned &Idx) { 6560 switch (Name.getNameKind()) { 6561 case DeclarationName::CXXConstructorName: 6562 case DeclarationName::CXXDestructorName: 6563 case DeclarationName::CXXConversionFunctionName: 6564 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 6565 break; 6566 6567 case DeclarationName::CXXOperatorName: 6568 DNLoc.CXXOperatorName.BeginOpNameLoc 6569 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6570 DNLoc.CXXOperatorName.EndOpNameLoc 6571 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6572 break; 6573 6574 case DeclarationName::CXXLiteralOperatorName: 6575 DNLoc.CXXLiteralOperatorName.OpNameLoc 6576 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6577 break; 6578 6579 case DeclarationName::Identifier: 6580 case DeclarationName::ObjCZeroArgSelector: 6581 case DeclarationName::ObjCOneArgSelector: 6582 case DeclarationName::ObjCMultiArgSelector: 6583 case DeclarationName::CXXUsingDirective: 6584 break; 6585 } 6586} 6587 6588void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 6589 DeclarationNameInfo &NameInfo, 6590 const RecordData &Record, unsigned &Idx) { 6591 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 6592 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 6593 DeclarationNameLoc DNLoc; 6594 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 6595 NameInfo.setInfo(DNLoc); 6596} 6597 6598void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 6599 const RecordData &Record, unsigned &Idx) { 6600 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 6601 unsigned NumTPLists = Record[Idx++]; 6602 Info.NumTemplParamLists = NumTPLists; 6603 if (NumTPLists) { 6604 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 6605 for (unsigned i=0; i != NumTPLists; ++i) 6606 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 6607 } 6608} 6609 6610TemplateName 6611ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 6612 unsigned &Idx) { 6613 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 6614 switch (Kind) { 6615 case TemplateName::Template: 6616 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 6617 6618 case TemplateName::OverloadedTemplate: { 6619 unsigned size = Record[Idx++]; 6620 UnresolvedSet<8> Decls; 6621 while (size--) 6622 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6623 6624 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 6625 } 6626 6627 case TemplateName::QualifiedTemplate: { 6628 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6629 bool hasTemplKeyword = Record[Idx++]; 6630 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 6631 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 6632 } 6633 6634 case TemplateName::DependentTemplate: { 6635 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6636 if (Record[Idx++]) // isIdentifier 6637 return Context.getDependentTemplateName(NNS, 6638 GetIdentifierInfo(F, Record, 6639 Idx)); 6640 return Context.getDependentTemplateName(NNS, 6641 (OverloadedOperatorKind)Record[Idx++]); 6642 } 6643 6644 case TemplateName::SubstTemplateTemplateParm: { 6645 TemplateTemplateParmDecl *param 6646 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6647 if (!param) return TemplateName(); 6648 TemplateName replacement = ReadTemplateName(F, Record, Idx); 6649 return Context.getSubstTemplateTemplateParm(param, replacement); 6650 } 6651 6652 case TemplateName::SubstTemplateTemplateParmPack: { 6653 TemplateTemplateParmDecl *Param 6654 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6655 if (!Param) 6656 return TemplateName(); 6657 6658 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 6659 if (ArgPack.getKind() != TemplateArgument::Pack) 6660 return TemplateName(); 6661 6662 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 6663 } 6664 } 6665 6666 llvm_unreachable("Unhandled template name kind!"); 6667} 6668 6669TemplateArgument 6670ASTReader::ReadTemplateArgument(ModuleFile &F, 6671 const RecordData &Record, unsigned &Idx) { 6672 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 6673 switch (Kind) { 6674 case TemplateArgument::Null: 6675 return TemplateArgument(); 6676 case TemplateArgument::Type: 6677 return TemplateArgument(readType(F, Record, Idx)); 6678 case TemplateArgument::Declaration: { 6679 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx); 6680 bool ForReferenceParam = Record[Idx++]; 6681 return TemplateArgument(D, ForReferenceParam); 6682 } 6683 case TemplateArgument::NullPtr: 6684 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true); 6685 case TemplateArgument::Integral: { 6686 llvm::APSInt Value = ReadAPSInt(Record, Idx); 6687 QualType T = readType(F, Record, Idx); 6688 return TemplateArgument(Context, Value, T); 6689 } 6690 case TemplateArgument::Template: 6691 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 6692 case TemplateArgument::TemplateExpansion: { 6693 TemplateName Name = ReadTemplateName(F, Record, Idx); 6694 Optional<unsigned> NumTemplateExpansions; 6695 if (unsigned NumExpansions = Record[Idx++]) 6696 NumTemplateExpansions = NumExpansions - 1; 6697 return TemplateArgument(Name, NumTemplateExpansions); 6698 } 6699 case TemplateArgument::Expression: 6700 return TemplateArgument(ReadExpr(F)); 6701 case TemplateArgument::Pack: { 6702 unsigned NumArgs = Record[Idx++]; 6703 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 6704 for (unsigned I = 0; I != NumArgs; ++I) 6705 Args[I] = ReadTemplateArgument(F, Record, Idx); 6706 return TemplateArgument(Args, NumArgs); 6707 } 6708 } 6709 6710 llvm_unreachable("Unhandled template argument kind!"); 6711} 6712 6713TemplateParameterList * 6714ASTReader::ReadTemplateParameterList(ModuleFile &F, 6715 const RecordData &Record, unsigned &Idx) { 6716 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 6717 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 6718 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 6719 6720 unsigned NumParams = Record[Idx++]; 6721 SmallVector<NamedDecl *, 16> Params; 6722 Params.reserve(NumParams); 6723 while (NumParams--) 6724 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6725 6726 TemplateParameterList* TemplateParams = 6727 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 6728 Params.data(), Params.size(), RAngleLoc); 6729 return TemplateParams; 6730} 6731 6732void 6733ASTReader:: 6734ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 6735 ModuleFile &F, const RecordData &Record, 6736 unsigned &Idx) { 6737 unsigned NumTemplateArgs = Record[Idx++]; 6738 TemplArgs.reserve(NumTemplateArgs); 6739 while (NumTemplateArgs--) 6740 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 6741} 6742 6743/// \brief Read a UnresolvedSet structure. 6744void ASTReader::ReadUnresolvedSet(ModuleFile &F, ASTUnresolvedSet &Set, 6745 const RecordData &Record, unsigned &Idx) { 6746 unsigned NumDecls = Record[Idx++]; 6747 Set.reserve(Context, NumDecls); 6748 while (NumDecls--) { 6749 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 6750 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 6751 Set.addDecl(Context, D, AS); 6752 } 6753} 6754 6755CXXBaseSpecifier 6756ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 6757 const RecordData &Record, unsigned &Idx) { 6758 bool isVirtual = static_cast<bool>(Record[Idx++]); 6759 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 6760 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 6761 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 6762 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 6763 SourceRange Range = ReadSourceRange(F, Record, Idx); 6764 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 6765 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 6766 EllipsisLoc); 6767 Result.setInheritConstructors(inheritConstructors); 6768 return Result; 6769} 6770 6771std::pair<CXXCtorInitializer **, unsigned> 6772ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 6773 unsigned &Idx) { 6774 CXXCtorInitializer **CtorInitializers = 0; 6775 unsigned NumInitializers = Record[Idx++]; 6776 if (NumInitializers) { 6777 CtorInitializers 6778 = new (Context) CXXCtorInitializer*[NumInitializers]; 6779 for (unsigned i=0; i != NumInitializers; ++i) { 6780 TypeSourceInfo *TInfo = 0; 6781 bool IsBaseVirtual = false; 6782 FieldDecl *Member = 0; 6783 IndirectFieldDecl *IndirectMember = 0; 6784 6785 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 6786 switch (Type) { 6787 case CTOR_INITIALIZER_BASE: 6788 TInfo = GetTypeSourceInfo(F, Record, Idx); 6789 IsBaseVirtual = Record[Idx++]; 6790 break; 6791 6792 case CTOR_INITIALIZER_DELEGATING: 6793 TInfo = GetTypeSourceInfo(F, Record, Idx); 6794 break; 6795 6796 case CTOR_INITIALIZER_MEMBER: 6797 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 6798 break; 6799 6800 case CTOR_INITIALIZER_INDIRECT_MEMBER: 6801 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 6802 break; 6803 } 6804 6805 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 6806 Expr *Init = ReadExpr(F); 6807 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 6808 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 6809 bool IsWritten = Record[Idx++]; 6810 unsigned SourceOrderOrNumArrayIndices; 6811 SmallVector<VarDecl *, 8> Indices; 6812 if (IsWritten) { 6813 SourceOrderOrNumArrayIndices = Record[Idx++]; 6814 } else { 6815 SourceOrderOrNumArrayIndices = Record[Idx++]; 6816 Indices.reserve(SourceOrderOrNumArrayIndices); 6817 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 6818 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 6819 } 6820 6821 CXXCtorInitializer *BOMInit; 6822 if (Type == CTOR_INITIALIZER_BASE) { 6823 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 6824 LParenLoc, Init, RParenLoc, 6825 MemberOrEllipsisLoc); 6826 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 6827 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 6828 Init, RParenLoc); 6829 } else if (IsWritten) { 6830 if (Member) 6831 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 6832 LParenLoc, Init, RParenLoc); 6833 else 6834 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 6835 MemberOrEllipsisLoc, LParenLoc, 6836 Init, RParenLoc); 6837 } else { 6838 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 6839 LParenLoc, Init, RParenLoc, 6840 Indices.data(), Indices.size()); 6841 } 6842 6843 if (IsWritten) 6844 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 6845 CtorInitializers[i] = BOMInit; 6846 } 6847 } 6848 6849 return std::make_pair(CtorInitializers, NumInitializers); 6850} 6851 6852NestedNameSpecifier * 6853ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 6854 const RecordData &Record, unsigned &Idx) { 6855 unsigned N = Record[Idx++]; 6856 NestedNameSpecifier *NNS = 0, *Prev = 0; 6857 for (unsigned I = 0; I != N; ++I) { 6858 NestedNameSpecifier::SpecifierKind Kind 6859 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6860 switch (Kind) { 6861 case NestedNameSpecifier::Identifier: { 6862 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6863 NNS = NestedNameSpecifier::Create(Context, Prev, II); 6864 break; 6865 } 6866 6867 case NestedNameSpecifier::Namespace: { 6868 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6869 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 6870 break; 6871 } 6872 6873 case NestedNameSpecifier::NamespaceAlias: { 6874 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6875 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 6876 break; 6877 } 6878 6879 case NestedNameSpecifier::TypeSpec: 6880 case NestedNameSpecifier::TypeSpecWithTemplate: { 6881 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 6882 if (!T) 6883 return 0; 6884 6885 bool Template = Record[Idx++]; 6886 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 6887 break; 6888 } 6889 6890 case NestedNameSpecifier::Global: { 6891 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 6892 // No associated value, and there can't be a prefix. 6893 break; 6894 } 6895 } 6896 Prev = NNS; 6897 } 6898 return NNS; 6899} 6900 6901NestedNameSpecifierLoc 6902ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 6903 unsigned &Idx) { 6904 unsigned N = Record[Idx++]; 6905 NestedNameSpecifierLocBuilder Builder; 6906 for (unsigned I = 0; I != N; ++I) { 6907 NestedNameSpecifier::SpecifierKind Kind 6908 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6909 switch (Kind) { 6910 case NestedNameSpecifier::Identifier: { 6911 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6912 SourceRange Range = ReadSourceRange(F, Record, Idx); 6913 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 6914 break; 6915 } 6916 6917 case NestedNameSpecifier::Namespace: { 6918 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6919 SourceRange Range = ReadSourceRange(F, Record, Idx); 6920 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 6921 break; 6922 } 6923 6924 case NestedNameSpecifier::NamespaceAlias: { 6925 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6926 SourceRange Range = ReadSourceRange(F, Record, Idx); 6927 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 6928 break; 6929 } 6930 6931 case NestedNameSpecifier::TypeSpec: 6932 case NestedNameSpecifier::TypeSpecWithTemplate: { 6933 bool Template = Record[Idx++]; 6934 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 6935 if (!T) 6936 return NestedNameSpecifierLoc(); 6937 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6938 6939 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 6940 Builder.Extend(Context, 6941 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 6942 T->getTypeLoc(), ColonColonLoc); 6943 break; 6944 } 6945 6946 case NestedNameSpecifier::Global: { 6947 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6948 Builder.MakeGlobal(Context, ColonColonLoc); 6949 break; 6950 } 6951 } 6952 } 6953 6954 return Builder.getWithLocInContext(Context); 6955} 6956 6957SourceRange 6958ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 6959 unsigned &Idx) { 6960 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 6961 SourceLocation end = ReadSourceLocation(F, Record, Idx); 6962 return SourceRange(beg, end); 6963} 6964 6965/// \brief Read an integral value 6966llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 6967 unsigned BitWidth = Record[Idx++]; 6968 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 6969 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 6970 Idx += NumWords; 6971 return Result; 6972} 6973 6974/// \brief Read a signed integral value 6975llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 6976 bool isUnsigned = Record[Idx++]; 6977 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 6978} 6979 6980/// \brief Read a floating-point value 6981llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, 6982 const llvm::fltSemantics &Sem, 6983 unsigned &Idx) { 6984 return llvm::APFloat(Sem, ReadAPInt(Record, Idx)); 6985} 6986 6987// \brief Read a string 6988std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 6989 unsigned Len = Record[Idx++]; 6990 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 6991 Idx += Len; 6992 return Result; 6993} 6994 6995VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 6996 unsigned &Idx) { 6997 unsigned Major = Record[Idx++]; 6998 unsigned Minor = Record[Idx++]; 6999 unsigned Subminor = Record[Idx++]; 7000 if (Minor == 0) 7001 return VersionTuple(Major); 7002 if (Subminor == 0) 7003 return VersionTuple(Major, Minor - 1); 7004 return VersionTuple(Major, Minor - 1, Subminor - 1); 7005} 7006 7007CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 7008 const RecordData &Record, 7009 unsigned &Idx) { 7010 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 7011 return CXXTemporary::Create(Context, Decl); 7012} 7013 7014DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 7015 return Diag(SourceLocation(), DiagID); 7016} 7017 7018DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 7019 return Diags.Report(Loc, DiagID); 7020} 7021 7022/// \brief Retrieve the identifier table associated with the 7023/// preprocessor. 7024IdentifierTable &ASTReader::getIdentifierTable() { 7025 return PP.getIdentifierTable(); 7026} 7027 7028/// \brief Record that the given ID maps to the given switch-case 7029/// statement. 7030void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 7031 assert((*CurrSwitchCaseStmts)[ID] == 0 && 7032 "Already have a SwitchCase with this ID"); 7033 (*CurrSwitchCaseStmts)[ID] = SC; 7034} 7035 7036/// \brief Retrieve the switch-case statement with the given ID. 7037SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 7038 assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID"); 7039 return (*CurrSwitchCaseStmts)[ID]; 7040} 7041 7042void ASTReader::ClearSwitchCaseIDs() { 7043 CurrSwitchCaseStmts->clear(); 7044} 7045 7046void ASTReader::ReadComments() { 7047 std::vector<RawComment *> Comments; 7048 for (SmallVectorImpl<std::pair<BitstreamCursor, 7049 serialization::ModuleFile *> >::iterator 7050 I = CommentsCursors.begin(), 7051 E = CommentsCursors.end(); 7052 I != E; ++I) { 7053 BitstreamCursor &Cursor = I->first; 7054 serialization::ModuleFile &F = *I->second; 7055 SavedStreamPosition SavedPosition(Cursor); 7056 7057 RecordData Record; 7058 while (true) { 7059 llvm::BitstreamEntry Entry = 7060 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd); 7061 7062 switch (Entry.Kind) { 7063 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 7064 case llvm::BitstreamEntry::Error: 7065 Error("malformed block record in AST file"); 7066 return; 7067 case llvm::BitstreamEntry::EndBlock: 7068 goto NextCursor; 7069 case llvm::BitstreamEntry::Record: 7070 // The interesting case. 7071 break; 7072 } 7073 7074 // Read a record. 7075 Record.clear(); 7076 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) { 7077 case COMMENTS_RAW_COMMENT: { 7078 unsigned Idx = 0; 7079 SourceRange SR = ReadSourceRange(F, Record, Idx); 7080 RawComment::CommentKind Kind = 7081 (RawComment::CommentKind) Record[Idx++]; 7082 bool IsTrailingComment = Record[Idx++]; 7083 bool IsAlmostTrailingComment = Record[Idx++]; 7084 Comments.push_back(new (Context) RawComment(SR, Kind, 7085 IsTrailingComment, 7086 IsAlmostTrailingComment)); 7087 break; 7088 } 7089 } 7090 } 7091 NextCursor:; 7092 } 7093 Context.Comments.addCommentsToFront(Comments); 7094} 7095 7096void ASTReader::finishPendingActions() { 7097 while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty() || 7098 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty()) { 7099 // If any identifiers with corresponding top-level declarations have 7100 // been loaded, load those declarations now. 7101 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> > TopLevelDecls; 7102 while (!PendingIdentifierInfos.empty()) { 7103 // FIXME: std::move 7104 IdentifierInfo *II = PendingIdentifierInfos.back().first; 7105 SmallVector<uint32_t, 4> DeclIDs = PendingIdentifierInfos.back().second; 7106 PendingIdentifierInfos.pop_back(); 7107 7108 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]); 7109 } 7110 7111 // Load pending declaration chains. 7112 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 7113 loadPendingDeclChain(PendingDeclChains[I]); 7114 PendingDeclChainsKnown.erase(PendingDeclChains[I]); 7115 } 7116 PendingDeclChains.clear(); 7117 7118 // Make the most recent of the top-level declarations visible. 7119 for (llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >::iterator 7120 TLD = TopLevelDecls.begin(), TLDEnd = TopLevelDecls.end(); 7121 TLD != TLDEnd; ++TLD) { 7122 IdentifierInfo *II = TLD->first; 7123 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) { 7124 NamedDecl *ND = cast<NamedDecl>(TLD->second[I]->getMostRecentDecl()); 7125 SemaObj->pushExternalDeclIntoScope(ND, II); 7126 } 7127 } 7128 7129 // Load any pending macro definitions. 7130 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) { 7131 // FIXME: std::move here 7132 SmallVector<MacroID, 2> GlobalIDs = PendingMacroIDs.begin()[I].second; 7133 MacroDirective *Hint = 0; 7134 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 7135 ++IDIdx) { 7136 Hint = getMacro(GlobalIDs[IDIdx], Hint); 7137 } 7138 } 7139 PendingMacroIDs.clear(); 7140 7141 // Wire up the DeclContexts for Decls that we delayed setting until 7142 // recursive loading is completed. 7143 while (!PendingDeclContextInfos.empty()) { 7144 PendingDeclContextInfo Info = PendingDeclContextInfos.front(); 7145 PendingDeclContextInfos.pop_front(); 7146 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC)); 7147 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC)); 7148 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext()); 7149 } 7150 } 7151 7152 // If we deserialized any C++ or Objective-C class definitions, any 7153 // Objective-C protocol definitions, or any redeclarable templates, make sure 7154 // that all redeclarations point to the definitions. Note that this can only 7155 // happen now, after the redeclaration chains have been fully wired. 7156 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(), 7157 DEnd = PendingDefinitions.end(); 7158 D != DEnd; ++D) { 7159 if (TagDecl *TD = dyn_cast<TagDecl>(*D)) { 7160 if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) { 7161 // Make sure that the TagType points at the definition. 7162 const_cast<TagType*>(TagT)->decl = TD; 7163 } 7164 7165 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) { 7166 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(), 7167 REnd = RD->redecls_end(); 7168 R != REnd; ++R) 7169 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData; 7170 7171 } 7172 7173 continue; 7174 } 7175 7176 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) { 7177 // Make sure that the ObjCInterfaceType points at the definition. 7178 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl)) 7179 ->Decl = ID; 7180 7181 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(), 7182 REnd = ID->redecls_end(); 7183 R != REnd; ++R) 7184 R->Data = ID->Data; 7185 7186 continue; 7187 } 7188 7189 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) { 7190 for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(), 7191 REnd = PD->redecls_end(); 7192 R != REnd; ++R) 7193 R->Data = PD->Data; 7194 7195 continue; 7196 } 7197 7198 RedeclarableTemplateDecl *RTD 7199 = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl(); 7200 for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(), 7201 REnd = RTD->redecls_end(); 7202 R != REnd; ++R) 7203 R->Common = RTD->Common; 7204 } 7205 PendingDefinitions.clear(); 7206 7207 // Load the bodies of any functions or methods we've encountered. We do 7208 // this now (delayed) so that we can be sure that the declaration chains 7209 // have been fully wired up. 7210 for (PendingBodiesMap::iterator PB = PendingBodies.begin(), 7211 PBEnd = PendingBodies.end(); 7212 PB != PBEnd; ++PB) { 7213 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) { 7214 // FIXME: Check for =delete/=default? 7215 // FIXME: Complain about ODR violations here? 7216 if (!getContext().getLangOpts().Modules || !FD->hasBody()) 7217 FD->setLazyBody(PB->second); 7218 continue; 7219 } 7220 7221 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first); 7222 if (!getContext().getLangOpts().Modules || !MD->hasBody()) 7223 MD->setLazyBody(PB->second); 7224 } 7225 PendingBodies.clear(); 7226} 7227 7228void ASTReader::FinishedDeserializing() { 7229 assert(NumCurrentElementsDeserializing && 7230 "FinishedDeserializing not paired with StartedDeserializing"); 7231 if (NumCurrentElementsDeserializing == 1) { 7232 // We decrease NumCurrentElementsDeserializing only after pending actions 7233 // are finished, to avoid recursively re-calling finishPendingActions(). 7234 finishPendingActions(); 7235 } 7236 --NumCurrentElementsDeserializing; 7237 7238 if (NumCurrentElementsDeserializing == 0 && 7239 Consumer && !PassingDeclsToConsumer) { 7240 // Guard variable to avoid recursively redoing the process of passing 7241 // decls to consumer. 7242 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer, 7243 true); 7244 7245 while (!InterestingDecls.empty()) { 7246 // We are not in recursive loading, so it's safe to pass the "interesting" 7247 // decls to the consumer. 7248 Decl *D = InterestingDecls.front(); 7249 InterestingDecls.pop_front(); 7250 PassInterestingDeclToConsumer(D); 7251 } 7252 } 7253} 7254 7255ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 7256 StringRef isysroot, bool DisableValidation, 7257 bool AllowASTWithCompilerErrors, bool UseGlobalIndex) 7258 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 7259 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 7260 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 7261 Consumer(0), ModuleMgr(PP.getFileManager()), 7262 isysroot(isysroot), DisableValidation(DisableValidation), 7263 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), 7264 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false), 7265 CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts), 7266 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 7267 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 7268 TotalNumMacros(0), NumIdentifierLookups(0), NumIdentifierLookupHits(0), 7269 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 7270 NumMethodPoolLookups(0), NumMethodPoolHits(0), 7271 NumMethodPoolTableLookups(0), NumMethodPoolTableHits(0), 7272 TotalNumMethodPoolEntries(0), 7273 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 7274 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 7275 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 7276 PassingDeclsToConsumer(false), 7277 NumCXXBaseSpecifiersLoaded(0) 7278{ 7279 SourceMgr.setExternalSLocEntrySource(this); 7280} 7281 7282ASTReader::~ASTReader() { 7283 for (DeclContextVisibleUpdatesPending::iterator 7284 I = PendingVisibleUpdates.begin(), 7285 E = PendingVisibleUpdates.end(); 7286 I != E; ++I) { 7287 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 7288 F = I->second.end(); 7289 J != F; ++J) 7290 delete J->first; 7291 } 7292} 7293