ASTReader.cpp revision ac39f135ea0d45bc37d1154fa8380d46aac0547d
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.AllocateMacroInfo(Loc); 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 llvm::SmallPtrSet<Module *, 4> Visited; 2721 SmallVector<Module *, 4> Stack; 2722 Stack.push_back(Mod); 2723 while (!Stack.empty()) { 2724 Mod = Stack.back(); 2725 Stack.pop_back(); 2726 2727 if (NameVisibility <= Mod->NameVisibility) { 2728 // This module already has this level of visibility (or greater), so 2729 // there is nothing more to do. 2730 continue; 2731 } 2732 2733 if (!Mod->isAvailable()) { 2734 // Modules that aren't available cannot be made visible. 2735 continue; 2736 } 2737 2738 // Update the module's name visibility. 2739 Mod->NameVisibility = NameVisibility; 2740 2741 // If we've already deserialized any names from this module, 2742 // mark them as visible. 2743 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 2744 if (Hidden != HiddenNamesMap.end()) { 2745 makeNamesVisible(Hidden->second); 2746 HiddenNamesMap.erase(Hidden); 2747 } 2748 2749 // Push any non-explicit submodules onto the stack to be marked as 2750 // visible. 2751 for (Module::submodule_iterator Sub = Mod->submodule_begin(), 2752 SubEnd = Mod->submodule_end(); 2753 Sub != SubEnd; ++Sub) { 2754 if (!(*Sub)->IsExplicit && Visited.insert(*Sub)) 2755 Stack.push_back(*Sub); 2756 } 2757 2758 // Push any exported modules onto the stack to be marked as visible. 2759 SmallVector<Module *, 16> Exports; 2760 Mod->getExportedModules(Exports); 2761 for (SmallVectorImpl<Module *>::iterator 2762 I = Exports.begin(), E = Exports.end(); I != E; ++I) { 2763 Module *Exported = *I; 2764 if (Visited.insert(Exported)) 2765 Stack.push_back(Exported); 2766 } 2767 } 2768} 2769 2770bool ASTReader::loadGlobalIndex() { 2771 if (GlobalIndex) 2772 return false; 2773 2774 if (TriedLoadingGlobalIndex || !UseGlobalIndex || 2775 !Context.getLangOpts().Modules) 2776 return true; 2777 2778 // Try to load the global index. 2779 TriedLoadingGlobalIndex = true; 2780 StringRef ModuleCachePath 2781 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath(); 2782 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result 2783 = GlobalModuleIndex::readIndex(ModuleCachePath); 2784 if (!Result.first) 2785 return true; 2786 2787 GlobalIndex.reset(Result.first); 2788 ModuleMgr.setGlobalIndex(GlobalIndex.get()); 2789 return false; 2790} 2791 2792bool ASTReader::isGlobalIndexUnavailable() const { 2793 return Context.getLangOpts().Modules && UseGlobalIndex && 2794 !hasGlobalIndex() && TriedLoadingGlobalIndex; 2795} 2796 2797ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2798 ModuleKind Type, 2799 SourceLocation ImportLoc, 2800 unsigned ClientLoadCapabilities) { 2801 // Bump the generation number. 2802 unsigned PreviousGeneration = CurrentGeneration++; 2803 2804 unsigned NumModules = ModuleMgr.size(); 2805 SmallVector<ImportedModule, 4> Loaded; 2806 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc, 2807 /*ImportedBy=*/0, Loaded, 2808 0, 0, 2809 ClientLoadCapabilities)) { 2810 case Failure: 2811 case Missing: 2812 case OutOfDate: 2813 case VersionMismatch: 2814 case ConfigurationMismatch: 2815 case HadErrors: 2816 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(), 2817 Context.getLangOpts().Modules 2818 ? &PP.getHeaderSearchInfo().getModuleMap() 2819 : 0); 2820 2821 // If we find that any modules are unusable, the global index is going 2822 // to be out-of-date. Just remove it. 2823 GlobalIndex.reset(); 2824 ModuleMgr.setGlobalIndex(0); 2825 return ReadResult; 2826 2827 case Success: 2828 break; 2829 } 2830 2831 // Here comes stuff that we only do once the entire chain is loaded. 2832 2833 // Load the AST blocks of all of the modules that we loaded. 2834 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 2835 MEnd = Loaded.end(); 2836 M != MEnd; ++M) { 2837 ModuleFile &F = *M->Mod; 2838 2839 // Read the AST block. 2840 if (ReadASTBlock(F)) 2841 return Failure; 2842 2843 // Once read, set the ModuleFile bit base offset and update the size in 2844 // bits of all files we've seen. 2845 F.GlobalBitOffset = TotalModulesSizeInBits; 2846 TotalModulesSizeInBits += F.SizeInBits; 2847 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2848 2849 // Preload SLocEntries. 2850 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) { 2851 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2852 // Load it through the SourceManager and don't call ReadSLocEntry() 2853 // directly because the entry may have already been loaded in which case 2854 // calling ReadSLocEntry() directly would trigger an assertion in 2855 // SourceManager. 2856 SourceMgr.getLoadedSLocEntryByID(Index); 2857 } 2858 } 2859 2860 // Setup the import locations. 2861 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 2862 MEnd = Loaded.end(); 2863 M != MEnd; ++M) { 2864 ModuleFile &F = *M->Mod; 2865 F.DirectImportLoc = ImportLoc; 2866 if (!M->ImportedBy) 2867 F.ImportLoc = M->ImportLoc; 2868 else 2869 F.ImportLoc = ReadSourceLocation(*M->ImportedBy, 2870 M->ImportLoc.getRawEncoding()); 2871 } 2872 2873 // Mark all of the identifiers in the identifier table as being out of date, 2874 // so that various accessors know to check the loaded modules when the 2875 // identifier is used. 2876 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2877 IdEnd = PP.getIdentifierTable().end(); 2878 Id != IdEnd; ++Id) 2879 Id->second->setOutOfDate(true); 2880 2881 // Resolve any unresolved module exports. 2882 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) { 2883 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I]; 2884 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 2885 Module *ResolvedMod = getSubmodule(GlobalID); 2886 2887 if (Unresolved.IsImport) { 2888 if (ResolvedMod) 2889 Unresolved.Mod->Imports.push_back(ResolvedMod); 2890 continue; 2891 } 2892 2893 if (ResolvedMod || Unresolved.IsWildcard) 2894 Unresolved.Mod->Exports.push_back( 2895 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 2896 } 2897 UnresolvedModuleImportExports.clear(); 2898 2899 InitializeContext(); 2900 2901 if (DeserializationListener) 2902 DeserializationListener->ReaderInitialized(this); 2903 2904 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule(); 2905 if (!PrimaryModule.OriginalSourceFileID.isInvalid()) { 2906 PrimaryModule.OriginalSourceFileID 2907 = FileID::get(PrimaryModule.SLocEntryBaseID 2908 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1); 2909 2910 // If this AST file is a precompiled preamble, then set the 2911 // preamble file ID of the source manager to the file source file 2912 // from which the preamble was built. 2913 if (Type == MK_Preamble) { 2914 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID); 2915 } else if (Type == MK_MainFile) { 2916 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID); 2917 } 2918 } 2919 2920 // For any Objective-C class definitions we have already loaded, make sure 2921 // that we load any additional categories. 2922 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) { 2923 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(), 2924 ObjCClassesLoaded[I], 2925 PreviousGeneration); 2926 } 2927 2928 return Success; 2929} 2930 2931ASTReader::ASTReadResult 2932ASTReader::ReadASTCore(StringRef FileName, 2933 ModuleKind Type, 2934 SourceLocation ImportLoc, 2935 ModuleFile *ImportedBy, 2936 SmallVectorImpl<ImportedModule> &Loaded, 2937 off_t ExpectedSize, time_t ExpectedModTime, 2938 unsigned ClientLoadCapabilities) { 2939 ModuleFile *M; 2940 std::string ErrorStr; 2941 ModuleManager::AddModuleResult AddResult 2942 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy, 2943 CurrentGeneration, ExpectedSize, ExpectedModTime, 2944 M, ErrorStr); 2945 2946 switch (AddResult) { 2947 case ModuleManager::AlreadyLoaded: 2948 return Success; 2949 2950 case ModuleManager::NewlyLoaded: 2951 // Load module file below. 2952 break; 2953 2954 case ModuleManager::Missing: 2955 // The module file was missing; if the client handle handle, that, return 2956 // it. 2957 if (ClientLoadCapabilities & ARR_Missing) 2958 return Missing; 2959 2960 // Otherwise, return an error. 2961 { 2962 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2963 + ErrorStr; 2964 Error(Msg); 2965 } 2966 return Failure; 2967 2968 case ModuleManager::OutOfDate: 2969 // We couldn't load the module file because it is out-of-date. If the 2970 // client can handle out-of-date, return it. 2971 if (ClientLoadCapabilities & ARR_OutOfDate) 2972 return OutOfDate; 2973 2974 // Otherwise, return an error. 2975 { 2976 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2977 + ErrorStr; 2978 Error(Msg); 2979 } 2980 return Failure; 2981 } 2982 2983 assert(M && "Missing module file"); 2984 2985 // FIXME: This seems rather a hack. Should CurrentDir be part of the 2986 // module? 2987 if (FileName != "-") { 2988 CurrentDir = llvm::sys::path::parent_path(FileName); 2989 if (CurrentDir.empty()) CurrentDir = "."; 2990 } 2991 2992 ModuleFile &F = *M; 2993 BitstreamCursor &Stream = F.Stream; 2994 Stream.init(F.StreamFile); 2995 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2996 2997 // Sniff for the signature. 2998 if (Stream.Read(8) != 'C' || 2999 Stream.Read(8) != 'P' || 3000 Stream.Read(8) != 'C' || 3001 Stream.Read(8) != 'H') { 3002 Diag(diag::err_not_a_pch_file) << FileName; 3003 return Failure; 3004 } 3005 3006 // This is used for compatibility with older PCH formats. 3007 bool HaveReadControlBlock = false; 3008 3009 while (1) { 3010 llvm::BitstreamEntry Entry = Stream.advance(); 3011 3012 switch (Entry.Kind) { 3013 case llvm::BitstreamEntry::Error: 3014 case llvm::BitstreamEntry::EndBlock: 3015 case llvm::BitstreamEntry::Record: 3016 Error("invalid record at top-level of AST file"); 3017 return Failure; 3018 3019 case llvm::BitstreamEntry::SubBlock: 3020 break; 3021 } 3022 3023 // We only know the control subblock ID. 3024 switch (Entry.ID) { 3025 case llvm::bitc::BLOCKINFO_BLOCK_ID: 3026 if (Stream.ReadBlockInfoBlock()) { 3027 Error("malformed BlockInfoBlock in AST file"); 3028 return Failure; 3029 } 3030 break; 3031 case CONTROL_BLOCK_ID: 3032 HaveReadControlBlock = true; 3033 switch (ReadControlBlock(F, Loaded, ClientLoadCapabilities)) { 3034 case Success: 3035 break; 3036 3037 case Failure: return Failure; 3038 case Missing: return Missing; 3039 case OutOfDate: return OutOfDate; 3040 case VersionMismatch: return VersionMismatch; 3041 case ConfigurationMismatch: return ConfigurationMismatch; 3042 case HadErrors: return HadErrors; 3043 } 3044 break; 3045 case AST_BLOCK_ID: 3046 if (!HaveReadControlBlock) { 3047 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 3048 Diag(diag::warn_pch_version_too_old); 3049 return VersionMismatch; 3050 } 3051 3052 // Record that we've loaded this module. 3053 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc)); 3054 return Success; 3055 3056 default: 3057 if (Stream.SkipBlock()) { 3058 Error("malformed block record in AST file"); 3059 return Failure; 3060 } 3061 break; 3062 } 3063 } 3064 3065 return Success; 3066} 3067 3068void ASTReader::InitializeContext() { 3069 // If there's a listener, notify them that we "read" the translation unit. 3070 if (DeserializationListener) 3071 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 3072 Context.getTranslationUnitDecl()); 3073 3074 // Make sure we load the declaration update records for the translation unit, 3075 // if there are any. 3076 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 3077 Context.getTranslationUnitDecl()); 3078 3079 // FIXME: Find a better way to deal with collisions between these 3080 // built-in types. Right now, we just ignore the problem. 3081 3082 // Load the special types. 3083 if (SpecialTypes.size() >= NumSpecialTypeIDs) { 3084 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 3085 if (!Context.CFConstantStringTypeDecl) 3086 Context.setCFConstantStringType(GetType(String)); 3087 } 3088 3089 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 3090 QualType FileType = GetType(File); 3091 if (FileType.isNull()) { 3092 Error("FILE type is NULL"); 3093 return; 3094 } 3095 3096 if (!Context.FILEDecl) { 3097 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 3098 Context.setFILEDecl(Typedef->getDecl()); 3099 else { 3100 const TagType *Tag = FileType->getAs<TagType>(); 3101 if (!Tag) { 3102 Error("Invalid FILE type in AST file"); 3103 return; 3104 } 3105 Context.setFILEDecl(Tag->getDecl()); 3106 } 3107 } 3108 } 3109 3110 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 3111 QualType Jmp_bufType = GetType(Jmp_buf); 3112 if (Jmp_bufType.isNull()) { 3113 Error("jmp_buf type is NULL"); 3114 return; 3115 } 3116 3117 if (!Context.jmp_bufDecl) { 3118 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 3119 Context.setjmp_bufDecl(Typedef->getDecl()); 3120 else { 3121 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 3122 if (!Tag) { 3123 Error("Invalid jmp_buf type in AST file"); 3124 return; 3125 } 3126 Context.setjmp_bufDecl(Tag->getDecl()); 3127 } 3128 } 3129 } 3130 3131 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 3132 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 3133 if (Sigjmp_bufType.isNull()) { 3134 Error("sigjmp_buf type is NULL"); 3135 return; 3136 } 3137 3138 if (!Context.sigjmp_bufDecl) { 3139 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 3140 Context.setsigjmp_bufDecl(Typedef->getDecl()); 3141 else { 3142 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 3143 assert(Tag && "Invalid sigjmp_buf type in AST file"); 3144 Context.setsigjmp_bufDecl(Tag->getDecl()); 3145 } 3146 } 3147 } 3148 3149 if (unsigned ObjCIdRedef 3150 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 3151 if (Context.ObjCIdRedefinitionType.isNull()) 3152 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 3153 } 3154 3155 if (unsigned ObjCClassRedef 3156 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 3157 if (Context.ObjCClassRedefinitionType.isNull()) 3158 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 3159 } 3160 3161 if (unsigned ObjCSelRedef 3162 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 3163 if (Context.ObjCSelRedefinitionType.isNull()) 3164 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3165 } 3166 3167 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 3168 QualType Ucontext_tType = GetType(Ucontext_t); 3169 if (Ucontext_tType.isNull()) { 3170 Error("ucontext_t type is NULL"); 3171 return; 3172 } 3173 3174 if (!Context.ucontext_tDecl) { 3175 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 3176 Context.setucontext_tDecl(Typedef->getDecl()); 3177 else { 3178 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 3179 assert(Tag && "Invalid ucontext_t type in AST file"); 3180 Context.setucontext_tDecl(Tag->getDecl()); 3181 } 3182 } 3183 } 3184 } 3185 3186 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 3187 3188 // If there were any CUDA special declarations, deserialize them. 3189 if (!CUDASpecialDeclRefs.empty()) { 3190 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3191 Context.setcudaConfigureCallDecl( 3192 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3193 } 3194 3195 // Re-export any modules that were imported by a non-module AST file. 3196 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 3197 if (Module *Imported = getSubmodule(ImportedModules[I])) 3198 makeModuleVisible(Imported, Module::AllVisible, 3199 /*ImportLoc=*/SourceLocation()); 3200 } 3201 ImportedModules.clear(); 3202} 3203 3204void ASTReader::finalizeForWriting() { 3205 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 3206 HiddenEnd = HiddenNamesMap.end(); 3207 Hidden != HiddenEnd; ++Hidden) { 3208 makeNamesVisible(Hidden->second); 3209 } 3210 HiddenNamesMap.clear(); 3211} 3212 3213/// SkipCursorToControlBlock - Given a cursor at the start of an AST file, scan 3214/// ahead and drop the cursor into the start of the CONTROL_BLOCK, returning 3215/// false on success and true on failure. 3216static bool SkipCursorToControlBlock(BitstreamCursor &Cursor) { 3217 while (1) { 3218 llvm::BitstreamEntry Entry = Cursor.advance(); 3219 switch (Entry.Kind) { 3220 case llvm::BitstreamEntry::Error: 3221 case llvm::BitstreamEntry::EndBlock: 3222 return true; 3223 3224 case llvm::BitstreamEntry::Record: 3225 // Ignore top-level records. 3226 Cursor.skipRecord(Entry.ID); 3227 break; 3228 3229 case llvm::BitstreamEntry::SubBlock: 3230 if (Entry.ID == CONTROL_BLOCK_ID) { 3231 if (Cursor.EnterSubBlock(CONTROL_BLOCK_ID)) 3232 return true; 3233 // Found it! 3234 return false; 3235 } 3236 3237 if (Cursor.SkipBlock()) 3238 return true; 3239 } 3240 } 3241} 3242 3243/// \brief Retrieve the name of the original source file name 3244/// directly from the AST file, without actually loading the AST 3245/// file. 3246std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3247 FileManager &FileMgr, 3248 DiagnosticsEngine &Diags) { 3249 // Open the AST file. 3250 std::string ErrStr; 3251 OwningPtr<llvm::MemoryBuffer> Buffer; 3252 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3253 if (!Buffer) { 3254 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ASTFileName << ErrStr; 3255 return std::string(); 3256 } 3257 3258 // Initialize the stream 3259 llvm::BitstreamReader StreamFile; 3260 BitstreamCursor Stream; 3261 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3262 (const unsigned char *)Buffer->getBufferEnd()); 3263 Stream.init(StreamFile); 3264 3265 // Sniff for the signature. 3266 if (Stream.Read(8) != 'C' || 3267 Stream.Read(8) != 'P' || 3268 Stream.Read(8) != 'C' || 3269 Stream.Read(8) != 'H') { 3270 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3271 return std::string(); 3272 } 3273 3274 // Scan for the CONTROL_BLOCK_ID block. 3275 if (SkipCursorToControlBlock(Stream)) { 3276 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3277 return std::string(); 3278 } 3279 3280 // Scan for ORIGINAL_FILE inside the control block. 3281 RecordData Record; 3282 while (1) { 3283 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 3284 if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 3285 return std::string(); 3286 3287 if (Entry.Kind != llvm::BitstreamEntry::Record) { 3288 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3289 return std::string(); 3290 } 3291 3292 Record.clear(); 3293 StringRef Blob; 3294 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE) 3295 return Blob.str(); 3296 } 3297} 3298 3299namespace { 3300 class SimplePCHValidator : public ASTReaderListener { 3301 const LangOptions &ExistingLangOpts; 3302 const TargetOptions &ExistingTargetOpts; 3303 const PreprocessorOptions &ExistingPPOpts; 3304 FileManager &FileMgr; 3305 3306 public: 3307 SimplePCHValidator(const LangOptions &ExistingLangOpts, 3308 const TargetOptions &ExistingTargetOpts, 3309 const PreprocessorOptions &ExistingPPOpts, 3310 FileManager &FileMgr) 3311 : ExistingLangOpts(ExistingLangOpts), 3312 ExistingTargetOpts(ExistingTargetOpts), 3313 ExistingPPOpts(ExistingPPOpts), 3314 FileMgr(FileMgr) 3315 { 3316 } 3317 3318 virtual bool ReadLanguageOptions(const LangOptions &LangOpts, 3319 bool Complain) { 3320 return checkLanguageOptions(ExistingLangOpts, LangOpts, 0); 3321 } 3322 virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, 3323 bool Complain) { 3324 return checkTargetOptions(ExistingTargetOpts, TargetOpts, 0); 3325 } 3326 virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 3327 bool Complain, 3328 std::string &SuggestedPredefines) { 3329 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, 0, FileMgr, 3330 SuggestedPredefines); 3331 } 3332 }; 3333} 3334 3335bool ASTReader::readASTFileControlBlock(StringRef Filename, 3336 FileManager &FileMgr, 3337 ASTReaderListener &Listener) { 3338 // Open the AST file. 3339 std::string ErrStr; 3340 OwningPtr<llvm::MemoryBuffer> Buffer; 3341 Buffer.reset(FileMgr.getBufferForFile(Filename, &ErrStr)); 3342 if (!Buffer) { 3343 return true; 3344 } 3345 3346 // Initialize the stream 3347 llvm::BitstreamReader StreamFile; 3348 BitstreamCursor Stream; 3349 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3350 (const unsigned char *)Buffer->getBufferEnd()); 3351 Stream.init(StreamFile); 3352 3353 // Sniff for the signature. 3354 if (Stream.Read(8) != 'C' || 3355 Stream.Read(8) != 'P' || 3356 Stream.Read(8) != 'C' || 3357 Stream.Read(8) != 'H') { 3358 return true; 3359 } 3360 3361 // Scan for the CONTROL_BLOCK_ID block. 3362 if (SkipCursorToControlBlock(Stream)) 3363 return true; 3364 3365 // Scan for ORIGINAL_FILE inside the control block. 3366 RecordData Record; 3367 while (1) { 3368 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 3369 if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 3370 return false; 3371 3372 if (Entry.Kind != llvm::BitstreamEntry::Record) 3373 return true; 3374 3375 Record.clear(); 3376 StringRef Blob; 3377 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob); 3378 switch ((ControlRecordTypes)RecCode) { 3379 case METADATA: { 3380 if (Record[0] != VERSION_MAJOR) 3381 return true; 3382 3383 const std::string &CurBranch = getClangFullRepositoryVersion(); 3384 if (StringRef(CurBranch) != Blob) 3385 return true; 3386 3387 break; 3388 } 3389 case LANGUAGE_OPTIONS: 3390 if (ParseLanguageOptions(Record, false, Listener)) 3391 return true; 3392 break; 3393 3394 case TARGET_OPTIONS: 3395 if (ParseTargetOptions(Record, false, Listener)) 3396 return true; 3397 break; 3398 3399 case DIAGNOSTIC_OPTIONS: 3400 if (ParseDiagnosticOptions(Record, false, Listener)) 3401 return true; 3402 break; 3403 3404 case FILE_SYSTEM_OPTIONS: 3405 if (ParseFileSystemOptions(Record, false, Listener)) 3406 return true; 3407 break; 3408 3409 case HEADER_SEARCH_OPTIONS: 3410 if (ParseHeaderSearchOptions(Record, false, Listener)) 3411 return true; 3412 break; 3413 3414 case PREPROCESSOR_OPTIONS: { 3415 std::string IgnoredSuggestedPredefines; 3416 if (ParsePreprocessorOptions(Record, false, Listener, 3417 IgnoredSuggestedPredefines)) 3418 return true; 3419 break; 3420 } 3421 3422 default: 3423 // No other validation to perform. 3424 break; 3425 } 3426 } 3427} 3428 3429 3430bool ASTReader::isAcceptableASTFile(StringRef Filename, 3431 FileManager &FileMgr, 3432 const LangOptions &LangOpts, 3433 const TargetOptions &TargetOpts, 3434 const PreprocessorOptions &PPOpts) { 3435 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, FileMgr); 3436 return !readASTFileControlBlock(Filename, FileMgr, validator); 3437} 3438 3439bool ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 3440 // Enter the submodule block. 3441 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 3442 Error("malformed submodule block record in AST file"); 3443 return true; 3444 } 3445 3446 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 3447 bool First = true; 3448 Module *CurrentModule = 0; 3449 RecordData Record; 3450 while (true) { 3451 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks(); 3452 3453 switch (Entry.Kind) { 3454 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 3455 case llvm::BitstreamEntry::Error: 3456 Error("malformed block record in AST file"); 3457 return true; 3458 case llvm::BitstreamEntry::EndBlock: 3459 return false; 3460 case llvm::BitstreamEntry::Record: 3461 // The interesting case. 3462 break; 3463 } 3464 3465 // Read a record. 3466 StringRef Blob; 3467 Record.clear(); 3468 switch (F.Stream.readRecord(Entry.ID, Record, &Blob)) { 3469 default: // Default behavior: ignore. 3470 break; 3471 3472 case SUBMODULE_DEFINITION: { 3473 if (First) { 3474 Error("missing submodule metadata record at beginning of block"); 3475 return true; 3476 } 3477 3478 if (Record.size() < 7) { 3479 Error("malformed module definition"); 3480 return true; 3481 } 3482 3483 StringRef Name = Blob; 3484 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]); 3485 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]); 3486 bool IsFramework = Record[2]; 3487 bool IsExplicit = Record[3]; 3488 bool IsSystem = Record[4]; 3489 bool InferSubmodules = Record[5]; 3490 bool InferExplicitSubmodules = Record[6]; 3491 bool InferExportWildcard = Record[7]; 3492 3493 Module *ParentModule = 0; 3494 if (Parent) 3495 ParentModule = getSubmodule(Parent); 3496 3497 // Retrieve this (sub)module from the module map, creating it if 3498 // necessary. 3499 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3500 IsFramework, 3501 IsExplicit).first; 3502 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 3503 if (GlobalIndex >= SubmodulesLoaded.size() || 3504 SubmodulesLoaded[GlobalIndex]) { 3505 Error("too many submodules"); 3506 return true; 3507 } 3508 3509 if (!ParentModule) { 3510 if (const FileEntry *CurFile = CurrentModule->getASTFile()) { 3511 if (CurFile != F.File) { 3512 if (!Diags.isDiagnosticInFlight()) { 3513 Diag(diag::err_module_file_conflict) 3514 << CurrentModule->getTopLevelModuleName() 3515 << CurFile->getName() 3516 << F.File->getName(); 3517 } 3518 return true; 3519 } 3520 } 3521 3522 CurrentModule->setASTFile(F.File); 3523 } 3524 3525 CurrentModule->IsFromModuleFile = true; 3526 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem; 3527 CurrentModule->InferSubmodules = InferSubmodules; 3528 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 3529 CurrentModule->InferExportWildcard = InferExportWildcard; 3530 if (DeserializationListener) 3531 DeserializationListener->ModuleRead(GlobalID, CurrentModule); 3532 3533 SubmodulesLoaded[GlobalIndex] = CurrentModule; 3534 3535 // Clear out link libraries; the module file has them. 3536 CurrentModule->LinkLibraries.clear(); 3537 break; 3538 } 3539 3540 case SUBMODULE_UMBRELLA_HEADER: { 3541 if (First) { 3542 Error("missing submodule metadata record at beginning of block"); 3543 return true; 3544 } 3545 3546 if (!CurrentModule) 3547 break; 3548 3549 if (const FileEntry *Umbrella = PP.getFileManager().getFile(Blob)) { 3550 if (!CurrentModule->getUmbrellaHeader()) 3551 ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 3552 else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 3553 Error("mismatched umbrella headers in submodule"); 3554 return true; 3555 } 3556 } 3557 break; 3558 } 3559 3560 case SUBMODULE_HEADER: { 3561 if (First) { 3562 Error("missing submodule metadata record at beginning of block"); 3563 return true; 3564 } 3565 3566 if (!CurrentModule) 3567 break; 3568 3569 // We lazily associate headers with their modules via the HeaderInfoTable. 3570 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3571 // of complete filenames or remove it entirely. 3572 break; 3573 } 3574 3575 case SUBMODULE_EXCLUDED_HEADER: { 3576 if (First) { 3577 Error("missing submodule metadata record at beginning of block"); 3578 return true; 3579 } 3580 3581 if (!CurrentModule) 3582 break; 3583 3584 // We lazily associate headers with their modules via the HeaderInfoTable. 3585 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3586 // of complete filenames or remove it entirely. 3587 break; 3588 } 3589 3590 case SUBMODULE_TOPHEADER: { 3591 if (First) { 3592 Error("missing submodule metadata record at beginning of block"); 3593 return true; 3594 } 3595 3596 if (!CurrentModule) 3597 break; 3598 3599 CurrentModule->addTopHeaderFilename(Blob); 3600 break; 3601 } 3602 3603 case SUBMODULE_UMBRELLA_DIR: { 3604 if (First) { 3605 Error("missing submodule metadata record at beginning of block"); 3606 return true; 3607 } 3608 3609 if (!CurrentModule) 3610 break; 3611 3612 if (const DirectoryEntry *Umbrella 3613 = PP.getFileManager().getDirectory(Blob)) { 3614 if (!CurrentModule->getUmbrellaDir()) 3615 ModMap.setUmbrellaDir(CurrentModule, Umbrella); 3616 else if (CurrentModule->getUmbrellaDir() != Umbrella) { 3617 Error("mismatched umbrella directories in submodule"); 3618 return true; 3619 } 3620 } 3621 break; 3622 } 3623 3624 case SUBMODULE_METADATA: { 3625 if (!First) { 3626 Error("submodule metadata record not at beginning of block"); 3627 return true; 3628 } 3629 First = false; 3630 3631 F.BaseSubmoduleID = getTotalNumSubmodules(); 3632 F.LocalNumSubmodules = Record[0]; 3633 unsigned LocalBaseSubmoduleID = Record[1]; 3634 if (F.LocalNumSubmodules > 0) { 3635 // Introduce the global -> local mapping for submodules within this 3636 // module. 3637 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3638 3639 // Introduce the local -> global mapping for submodules within this 3640 // module. 3641 F.SubmoduleRemap.insertOrReplace( 3642 std::make_pair(LocalBaseSubmoduleID, 3643 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3644 3645 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3646 } 3647 break; 3648 } 3649 3650 case SUBMODULE_IMPORTS: { 3651 if (First) { 3652 Error("missing submodule metadata record at beginning of block"); 3653 return true; 3654 } 3655 3656 if (!CurrentModule) 3657 break; 3658 3659 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3660 UnresolvedModuleImportExport Unresolved; 3661 Unresolved.File = &F; 3662 Unresolved.Mod = CurrentModule; 3663 Unresolved.ID = Record[Idx]; 3664 Unresolved.IsImport = true; 3665 Unresolved.IsWildcard = false; 3666 UnresolvedModuleImportExports.push_back(Unresolved); 3667 } 3668 break; 3669 } 3670 3671 case SUBMODULE_EXPORTS: { 3672 if (First) { 3673 Error("missing submodule metadata record at beginning of block"); 3674 return true; 3675 } 3676 3677 if (!CurrentModule) 3678 break; 3679 3680 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3681 UnresolvedModuleImportExport Unresolved; 3682 Unresolved.File = &F; 3683 Unresolved.Mod = CurrentModule; 3684 Unresolved.ID = Record[Idx]; 3685 Unresolved.IsImport = false; 3686 Unresolved.IsWildcard = Record[Idx + 1]; 3687 UnresolvedModuleImportExports.push_back(Unresolved); 3688 } 3689 3690 // Once we've loaded the set of exports, there's no reason to keep 3691 // the parsed, unresolved exports around. 3692 CurrentModule->UnresolvedExports.clear(); 3693 break; 3694 } 3695 case SUBMODULE_REQUIRES: { 3696 if (First) { 3697 Error("missing submodule metadata record at beginning of block"); 3698 return true; 3699 } 3700 3701 if (!CurrentModule) 3702 break; 3703 3704 CurrentModule->addRequirement(Blob, Context.getLangOpts(), 3705 Context.getTargetInfo()); 3706 break; 3707 } 3708 3709 case SUBMODULE_LINK_LIBRARY: 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 CurrentModule->LinkLibraries.push_back( 3719 Module::LinkLibrary(Blob, Record[0])); 3720 break; 3721 } 3722 } 3723} 3724 3725/// \brief Parse the record that corresponds to a LangOptions data 3726/// structure. 3727/// 3728/// This routine parses the language options from the AST file and then gives 3729/// them to the AST listener if one is set. 3730/// 3731/// \returns true if the listener deems the file unacceptable, false otherwise. 3732bool ASTReader::ParseLanguageOptions(const RecordData &Record, 3733 bool Complain, 3734 ASTReaderListener &Listener) { 3735 LangOptions LangOpts; 3736 unsigned Idx = 0; 3737#define LANGOPT(Name, Bits, Default, Description) \ 3738 LangOpts.Name = Record[Idx++]; 3739#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3740 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3741#include "clang/Basic/LangOptions.def" 3742#define SANITIZER(NAME, ID) LangOpts.Sanitize.ID = Record[Idx++]; 3743#include "clang/Basic/Sanitizers.def" 3744 3745 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++]; 3746 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx); 3747 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion); 3748 3749 unsigned Length = Record[Idx++]; 3750 LangOpts.CurrentModule.assign(Record.begin() + Idx, 3751 Record.begin() + Idx + Length); 3752 3753 Idx += Length; 3754 3755 // Comment options. 3756 for (unsigned N = Record[Idx++]; N; --N) { 3757 LangOpts.CommentOpts.BlockCommandNames.push_back( 3758 ReadString(Record, Idx)); 3759 } 3760 3761 return Listener.ReadLanguageOptions(LangOpts, Complain); 3762} 3763 3764bool ASTReader::ParseTargetOptions(const RecordData &Record, 3765 bool Complain, 3766 ASTReaderListener &Listener) { 3767 unsigned Idx = 0; 3768 TargetOptions TargetOpts; 3769 TargetOpts.Triple = ReadString(Record, Idx); 3770 TargetOpts.CPU = ReadString(Record, Idx); 3771 TargetOpts.ABI = ReadString(Record, Idx); 3772 TargetOpts.CXXABI = ReadString(Record, Idx); 3773 TargetOpts.LinkerVersion = ReadString(Record, Idx); 3774 for (unsigned N = Record[Idx++]; N; --N) { 3775 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx)); 3776 } 3777 for (unsigned N = Record[Idx++]; N; --N) { 3778 TargetOpts.Features.push_back(ReadString(Record, Idx)); 3779 } 3780 3781 return Listener.ReadTargetOptions(TargetOpts, Complain); 3782} 3783 3784bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain, 3785 ASTReaderListener &Listener) { 3786 DiagnosticOptions DiagOpts; 3787 unsigned Idx = 0; 3788#define DIAGOPT(Name, Bits, Default) DiagOpts.Name = Record[Idx++]; 3789#define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 3790 DiagOpts.set##Name(static_cast<Type>(Record[Idx++])); 3791#include "clang/Basic/DiagnosticOptions.def" 3792 3793 for (unsigned N = Record[Idx++]; N; --N) { 3794 DiagOpts.Warnings.push_back(ReadString(Record, Idx)); 3795 } 3796 3797 return Listener.ReadDiagnosticOptions(DiagOpts, Complain); 3798} 3799 3800bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain, 3801 ASTReaderListener &Listener) { 3802 FileSystemOptions FSOpts; 3803 unsigned Idx = 0; 3804 FSOpts.WorkingDir = ReadString(Record, Idx); 3805 return Listener.ReadFileSystemOptions(FSOpts, Complain); 3806} 3807 3808bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record, 3809 bool Complain, 3810 ASTReaderListener &Listener) { 3811 HeaderSearchOptions HSOpts; 3812 unsigned Idx = 0; 3813 HSOpts.Sysroot = ReadString(Record, Idx); 3814 3815 // Include entries. 3816 for (unsigned N = Record[Idx++]; N; --N) { 3817 std::string Path = ReadString(Record, Idx); 3818 frontend::IncludeDirGroup Group 3819 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]); 3820 bool IsFramework = Record[Idx++]; 3821 bool IgnoreSysRoot = Record[Idx++]; 3822 HSOpts.UserEntries.push_back( 3823 HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot)); 3824 } 3825 3826 // System header prefixes. 3827 for (unsigned N = Record[Idx++]; N; --N) { 3828 std::string Prefix = ReadString(Record, Idx); 3829 bool IsSystemHeader = Record[Idx++]; 3830 HSOpts.SystemHeaderPrefixes.push_back( 3831 HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader)); 3832 } 3833 3834 HSOpts.ResourceDir = ReadString(Record, Idx); 3835 HSOpts.ModuleCachePath = ReadString(Record, Idx); 3836 HSOpts.DisableModuleHash = Record[Idx++]; 3837 HSOpts.UseBuiltinIncludes = Record[Idx++]; 3838 HSOpts.UseStandardSystemIncludes = Record[Idx++]; 3839 HSOpts.UseStandardCXXIncludes = Record[Idx++]; 3840 HSOpts.UseLibcxx = Record[Idx++]; 3841 3842 return Listener.ReadHeaderSearchOptions(HSOpts, Complain); 3843} 3844 3845bool ASTReader::ParsePreprocessorOptions(const RecordData &Record, 3846 bool Complain, 3847 ASTReaderListener &Listener, 3848 std::string &SuggestedPredefines) { 3849 PreprocessorOptions PPOpts; 3850 unsigned Idx = 0; 3851 3852 // Macro definitions/undefs 3853 for (unsigned N = Record[Idx++]; N; --N) { 3854 std::string Macro = ReadString(Record, Idx); 3855 bool IsUndef = Record[Idx++]; 3856 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef)); 3857 } 3858 3859 // Includes 3860 for (unsigned N = Record[Idx++]; N; --N) { 3861 PPOpts.Includes.push_back(ReadString(Record, Idx)); 3862 } 3863 3864 // Macro Includes 3865 for (unsigned N = Record[Idx++]; N; --N) { 3866 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx)); 3867 } 3868 3869 PPOpts.UsePredefines = Record[Idx++]; 3870 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx); 3871 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx); 3872 PPOpts.ObjCXXARCStandardLibrary = 3873 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]); 3874 SuggestedPredefines.clear(); 3875 return Listener.ReadPreprocessorOptions(PPOpts, Complain, 3876 SuggestedPredefines); 3877} 3878 3879std::pair<ModuleFile *, unsigned> 3880ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 3881 GlobalPreprocessedEntityMapType::iterator 3882 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 3883 assert(I != GlobalPreprocessedEntityMap.end() && 3884 "Corrupted global preprocessed entity map"); 3885 ModuleFile *M = I->second; 3886 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 3887 return std::make_pair(M, LocalIndex); 3888} 3889 3890std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 3891ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const { 3892 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord()) 3893 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID, 3894 Mod.NumPreprocessedEntities); 3895 3896 return std::make_pair(PreprocessingRecord::iterator(), 3897 PreprocessingRecord::iterator()); 3898} 3899 3900std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator> 3901ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) { 3902 return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls), 3903 ModuleDeclIterator(this, &Mod, 3904 Mod.FileSortedDecls + Mod.NumFileSortedDecls)); 3905} 3906 3907PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 3908 PreprocessedEntityID PPID = Index+1; 3909 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3910 ModuleFile &M = *PPInfo.first; 3911 unsigned LocalIndex = PPInfo.second; 3912 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3913 3914 if (!PP.getPreprocessingRecord()) { 3915 Error("no preprocessing record"); 3916 return 0; 3917 } 3918 3919 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 3920 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 3921 3922 llvm::BitstreamEntry Entry = 3923 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd); 3924 if (Entry.Kind != llvm::BitstreamEntry::Record) 3925 return 0; 3926 3927 // Read the record. 3928 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 3929 ReadSourceLocation(M, PPOffs.End)); 3930 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 3931 StringRef Blob; 3932 RecordData Record; 3933 PreprocessorDetailRecordTypes RecType = 3934 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord( 3935 Entry.ID, Record, &Blob); 3936 switch (RecType) { 3937 case PPD_MACRO_EXPANSION: { 3938 bool isBuiltin = Record[0]; 3939 IdentifierInfo *Name = 0; 3940 MacroDefinition *Def = 0; 3941 if (isBuiltin) 3942 Name = getLocalIdentifier(M, Record[1]); 3943 else { 3944 PreprocessedEntityID 3945 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 3946 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 3947 } 3948 3949 MacroExpansion *ME; 3950 if (isBuiltin) 3951 ME = new (PPRec) MacroExpansion(Name, Range); 3952 else 3953 ME = new (PPRec) MacroExpansion(Def, Range); 3954 3955 return ME; 3956 } 3957 3958 case PPD_MACRO_DEFINITION: { 3959 // Decode the identifier info and then check again; if the macro is 3960 // still defined and associated with the identifier, 3961 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 3962 MacroDefinition *MD 3963 = new (PPRec) MacroDefinition(II, Range); 3964 3965 if (DeserializationListener) 3966 DeserializationListener->MacroDefinitionRead(PPID, MD); 3967 3968 return MD; 3969 } 3970 3971 case PPD_INCLUSION_DIRECTIVE: { 3972 const char *FullFileNameStart = Blob.data() + Record[0]; 3973 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]); 3974 const FileEntry *File = 0; 3975 if (!FullFileName.empty()) 3976 File = PP.getFileManager().getFile(FullFileName); 3977 3978 // FIXME: Stable encoding 3979 InclusionDirective::InclusionKind Kind 3980 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 3981 InclusionDirective *ID 3982 = new (PPRec) InclusionDirective(PPRec, Kind, 3983 StringRef(Blob.data(), Record[0]), 3984 Record[1], Record[3], 3985 File, 3986 Range); 3987 return ID; 3988 } 3989 } 3990 3991 llvm_unreachable("Invalid PreprocessorDetailRecordTypes"); 3992} 3993 3994/// \brief \arg SLocMapI points at a chunk of a module that contains no 3995/// preprocessed entities or the entities it contains are not the ones we are 3996/// looking for. Find the next module that contains entities and return the ID 3997/// of the first entry. 3998PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 3999 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 4000 ++SLocMapI; 4001 for (GlobalSLocOffsetMapType::const_iterator 4002 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 4003 ModuleFile &M = *SLocMapI->second; 4004 if (M.NumPreprocessedEntities) 4005 return M.BasePreprocessedEntityID; 4006 } 4007 4008 return getTotalNumPreprocessedEntities(); 4009} 4010 4011namespace { 4012 4013template <unsigned PPEntityOffset::*PPLoc> 4014struct PPEntityComp { 4015 const ASTReader &Reader; 4016 ModuleFile &M; 4017 4018 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 4019 4020 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 4021 SourceLocation LHS = getLoc(L); 4022 SourceLocation RHS = getLoc(R); 4023 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4024 } 4025 4026 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 4027 SourceLocation LHS = getLoc(L); 4028 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4029 } 4030 4031 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 4032 SourceLocation RHS = getLoc(R); 4033 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4034 } 4035 4036 SourceLocation getLoc(const PPEntityOffset &PPE) const { 4037 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 4038 } 4039}; 4040 4041} 4042 4043/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 4044PreprocessedEntityID 4045ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 4046 if (SourceMgr.isLocalSourceLocation(BLoc)) 4047 return getTotalNumPreprocessedEntities(); 4048 4049 GlobalSLocOffsetMapType::const_iterator 4050 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4051 BLoc.getOffset() - 1); 4052 assert(SLocMapI != GlobalSLocOffsetMap.end() && 4053 "Corrupted global sloc offset map"); 4054 4055 if (SLocMapI->second->NumPreprocessedEntities == 0) 4056 return findNextPreprocessedEntity(SLocMapI); 4057 4058 ModuleFile &M = *SLocMapI->second; 4059 typedef const PPEntityOffset *pp_iterator; 4060 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4061 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4062 4063 size_t Count = M.NumPreprocessedEntities; 4064 size_t Half; 4065 pp_iterator First = pp_begin; 4066 pp_iterator PPI; 4067 4068 // Do a binary search manually instead of using std::lower_bound because 4069 // The end locations of entities may be unordered (when a macro expansion 4070 // is inside another macro argument), but for this case it is not important 4071 // whether we get the first macro expansion or its containing macro. 4072 while (Count > 0) { 4073 Half = Count/2; 4074 PPI = First; 4075 std::advance(PPI, Half); 4076 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 4077 BLoc)){ 4078 First = PPI; 4079 ++First; 4080 Count = Count - Half - 1; 4081 } else 4082 Count = Half; 4083 } 4084 4085 if (PPI == pp_end) 4086 return findNextPreprocessedEntity(SLocMapI); 4087 4088 return M.BasePreprocessedEntityID + (PPI - pp_begin); 4089} 4090 4091/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 4092PreprocessedEntityID 4093ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 4094 if (SourceMgr.isLocalSourceLocation(ELoc)) 4095 return getTotalNumPreprocessedEntities(); 4096 4097 GlobalSLocOffsetMapType::const_iterator 4098 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4099 ELoc.getOffset() - 1); 4100 assert(SLocMapI != GlobalSLocOffsetMap.end() && 4101 "Corrupted global sloc offset map"); 4102 4103 if (SLocMapI->second->NumPreprocessedEntities == 0) 4104 return findNextPreprocessedEntity(SLocMapI); 4105 4106 ModuleFile &M = *SLocMapI->second; 4107 typedef const PPEntityOffset *pp_iterator; 4108 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4109 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4110 pp_iterator PPI = 4111 std::upper_bound(pp_begin, pp_end, ELoc, 4112 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 4113 4114 if (PPI == pp_end) 4115 return findNextPreprocessedEntity(SLocMapI); 4116 4117 return M.BasePreprocessedEntityID + (PPI - pp_begin); 4118} 4119 4120/// \brief Returns a pair of [Begin, End) indices of preallocated 4121/// preprocessed entities that \arg Range encompasses. 4122std::pair<unsigned, unsigned> 4123 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 4124 if (Range.isInvalid()) 4125 return std::make_pair(0,0); 4126 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 4127 4128 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 4129 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 4130 return std::make_pair(BeginID, EndID); 4131} 4132 4133/// \brief Optionally returns true or false if the preallocated preprocessed 4134/// entity with index \arg Index came from file \arg FID. 4135Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 4136 FileID FID) { 4137 if (FID.isInvalid()) 4138 return false; 4139 4140 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 4141 ModuleFile &M = *PPInfo.first; 4142 unsigned LocalIndex = PPInfo.second; 4143 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 4144 4145 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 4146 if (Loc.isInvalid()) 4147 return false; 4148 4149 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 4150 return true; 4151 else 4152 return false; 4153} 4154 4155namespace { 4156 /// \brief Visitor used to search for information about a header file. 4157 class HeaderFileInfoVisitor { 4158 const FileEntry *FE; 4159 4160 Optional<HeaderFileInfo> HFI; 4161 4162 public: 4163 explicit HeaderFileInfoVisitor(const FileEntry *FE) 4164 : FE(FE) { } 4165 4166 static bool visit(ModuleFile &M, void *UserData) { 4167 HeaderFileInfoVisitor *This 4168 = static_cast<HeaderFileInfoVisitor *>(UserData); 4169 4170 HeaderFileInfoLookupTable *Table 4171 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 4172 if (!Table) 4173 return false; 4174 4175 // Look in the on-disk hash table for an entry for this file name. 4176 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE); 4177 if (Pos == Table->end()) 4178 return false; 4179 4180 This->HFI = *Pos; 4181 return true; 4182 } 4183 4184 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 4185 }; 4186} 4187 4188HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 4189 HeaderFileInfoVisitor Visitor(FE); 4190 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 4191 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 4192 if (Listener) 4193 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 4194 return *HFI; 4195 } 4196 4197 return HeaderFileInfo(); 4198} 4199 4200void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 4201 // FIXME: Make it work properly with modules. 4202 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates; 4203 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4204 ModuleFile &F = *(*I); 4205 unsigned Idx = 0; 4206 DiagStates.clear(); 4207 assert(!Diag.DiagStates.empty()); 4208 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one. 4209 while (Idx < F.PragmaDiagMappings.size()) { 4210 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 4211 unsigned DiagStateID = F.PragmaDiagMappings[Idx++]; 4212 if (DiagStateID != 0) { 4213 Diag.DiagStatePoints.push_back( 4214 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1], 4215 FullSourceLoc(Loc, SourceMgr))); 4216 continue; 4217 } 4218 4219 assert(DiagStateID == 0); 4220 // A new DiagState was created here. 4221 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 4222 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back(); 4223 DiagStates.push_back(NewState); 4224 Diag.DiagStatePoints.push_back( 4225 DiagnosticsEngine::DiagStatePoint(NewState, 4226 FullSourceLoc(Loc, SourceMgr))); 4227 while (1) { 4228 assert(Idx < F.PragmaDiagMappings.size() && 4229 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 4230 if (Idx >= F.PragmaDiagMappings.size()) { 4231 break; // Something is messed up but at least avoid infinite loop in 4232 // release build. 4233 } 4234 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 4235 if (DiagID == (unsigned)-1) { 4236 break; // no more diag/map pairs for this location. 4237 } 4238 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 4239 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 4240 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 4241 } 4242 } 4243 } 4244} 4245 4246/// \brief Get the correct cursor and offset for loading a type. 4247ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 4248 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 4249 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 4250 ModuleFile *M = I->second; 4251 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 4252} 4253 4254/// \brief Read and return the type with the given index.. 4255/// 4256/// The index is the type ID, shifted and minus the number of predefs. This 4257/// routine actually reads the record corresponding to the type at the given 4258/// location. It is a helper routine for GetType, which deals with reading type 4259/// IDs. 4260QualType ASTReader::readTypeRecord(unsigned Index) { 4261 RecordLocation Loc = TypeCursorForIndex(Index); 4262 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 4263 4264 // Keep track of where we are in the stream, then jump back there 4265 // after reading this type. 4266 SavedStreamPosition SavedPosition(DeclsCursor); 4267 4268 ReadingKindTracker ReadingKind(Read_Type, *this); 4269 4270 // Note that we are loading a type record. 4271 Deserializing AType(this); 4272 4273 unsigned Idx = 0; 4274 DeclsCursor.JumpToBit(Loc.Offset); 4275 RecordData Record; 4276 unsigned Code = DeclsCursor.ReadCode(); 4277 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) { 4278 case TYPE_EXT_QUAL: { 4279 if (Record.size() != 2) { 4280 Error("Incorrect encoding of extended qualifier type"); 4281 return QualType(); 4282 } 4283 QualType Base = readType(*Loc.F, Record, Idx); 4284 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 4285 return Context.getQualifiedType(Base, Quals); 4286 } 4287 4288 case TYPE_COMPLEX: { 4289 if (Record.size() != 1) { 4290 Error("Incorrect encoding of complex type"); 4291 return QualType(); 4292 } 4293 QualType ElemType = readType(*Loc.F, Record, Idx); 4294 return Context.getComplexType(ElemType); 4295 } 4296 4297 case TYPE_POINTER: { 4298 if (Record.size() != 1) { 4299 Error("Incorrect encoding of pointer type"); 4300 return QualType(); 4301 } 4302 QualType PointeeType = readType(*Loc.F, Record, Idx); 4303 return Context.getPointerType(PointeeType); 4304 } 4305 4306 case TYPE_BLOCK_POINTER: { 4307 if (Record.size() != 1) { 4308 Error("Incorrect encoding of block pointer type"); 4309 return QualType(); 4310 } 4311 QualType PointeeType = readType(*Loc.F, Record, Idx); 4312 return Context.getBlockPointerType(PointeeType); 4313 } 4314 4315 case TYPE_LVALUE_REFERENCE: { 4316 if (Record.size() != 2) { 4317 Error("Incorrect encoding of lvalue reference type"); 4318 return QualType(); 4319 } 4320 QualType PointeeType = readType(*Loc.F, Record, Idx); 4321 return Context.getLValueReferenceType(PointeeType, Record[1]); 4322 } 4323 4324 case TYPE_RVALUE_REFERENCE: { 4325 if (Record.size() != 1) { 4326 Error("Incorrect encoding of rvalue reference type"); 4327 return QualType(); 4328 } 4329 QualType PointeeType = readType(*Loc.F, Record, Idx); 4330 return Context.getRValueReferenceType(PointeeType); 4331 } 4332 4333 case TYPE_MEMBER_POINTER: { 4334 if (Record.size() != 2) { 4335 Error("Incorrect encoding of member pointer type"); 4336 return QualType(); 4337 } 4338 QualType PointeeType = readType(*Loc.F, Record, Idx); 4339 QualType ClassType = readType(*Loc.F, Record, Idx); 4340 if (PointeeType.isNull() || ClassType.isNull()) 4341 return QualType(); 4342 4343 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 4344 } 4345 4346 case TYPE_CONSTANT_ARRAY: { 4347 QualType ElementType = readType(*Loc.F, Record, Idx); 4348 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4349 unsigned IndexTypeQuals = Record[2]; 4350 unsigned Idx = 3; 4351 llvm::APInt Size = ReadAPInt(Record, Idx); 4352 return Context.getConstantArrayType(ElementType, Size, 4353 ASM, IndexTypeQuals); 4354 } 4355 4356 case TYPE_INCOMPLETE_ARRAY: { 4357 QualType ElementType = readType(*Loc.F, Record, Idx); 4358 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4359 unsigned IndexTypeQuals = Record[2]; 4360 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 4361 } 4362 4363 case TYPE_VARIABLE_ARRAY: { 4364 QualType ElementType = readType(*Loc.F, Record, Idx); 4365 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4366 unsigned IndexTypeQuals = Record[2]; 4367 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 4368 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 4369 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 4370 ASM, IndexTypeQuals, 4371 SourceRange(LBLoc, RBLoc)); 4372 } 4373 4374 case TYPE_VECTOR: { 4375 if (Record.size() != 3) { 4376 Error("incorrect encoding of vector type in AST file"); 4377 return QualType(); 4378 } 4379 4380 QualType ElementType = readType(*Loc.F, Record, Idx); 4381 unsigned NumElements = Record[1]; 4382 unsigned VecKind = Record[2]; 4383 return Context.getVectorType(ElementType, NumElements, 4384 (VectorType::VectorKind)VecKind); 4385 } 4386 4387 case TYPE_EXT_VECTOR: { 4388 if (Record.size() != 3) { 4389 Error("incorrect encoding of extended vector type in AST file"); 4390 return QualType(); 4391 } 4392 4393 QualType ElementType = readType(*Loc.F, Record, Idx); 4394 unsigned NumElements = Record[1]; 4395 return Context.getExtVectorType(ElementType, NumElements); 4396 } 4397 4398 case TYPE_FUNCTION_NO_PROTO: { 4399 if (Record.size() != 6) { 4400 Error("incorrect encoding of no-proto function type"); 4401 return QualType(); 4402 } 4403 QualType ResultType = readType(*Loc.F, Record, Idx); 4404 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 4405 (CallingConv)Record[4], Record[5]); 4406 return Context.getFunctionNoProtoType(ResultType, Info); 4407 } 4408 4409 case TYPE_FUNCTION_PROTO: { 4410 QualType ResultType = readType(*Loc.F, Record, Idx); 4411 4412 FunctionProtoType::ExtProtoInfo EPI; 4413 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 4414 /*hasregparm*/ Record[2], 4415 /*regparm*/ Record[3], 4416 static_cast<CallingConv>(Record[4]), 4417 /*produces*/ Record[5]); 4418 4419 unsigned Idx = 6; 4420 unsigned NumParams = Record[Idx++]; 4421 SmallVector<QualType, 16> ParamTypes; 4422 for (unsigned I = 0; I != NumParams; ++I) 4423 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 4424 4425 EPI.Variadic = Record[Idx++]; 4426 EPI.HasTrailingReturn = Record[Idx++]; 4427 EPI.TypeQuals = Record[Idx++]; 4428 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 4429 ExceptionSpecificationType EST = 4430 static_cast<ExceptionSpecificationType>(Record[Idx++]); 4431 EPI.ExceptionSpecType = EST; 4432 SmallVector<QualType, 2> Exceptions; 4433 if (EST == EST_Dynamic) { 4434 EPI.NumExceptions = Record[Idx++]; 4435 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 4436 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 4437 EPI.Exceptions = Exceptions.data(); 4438 } else if (EST == EST_ComputedNoexcept) { 4439 EPI.NoexceptExpr = ReadExpr(*Loc.F); 4440 } else if (EST == EST_Uninstantiated) { 4441 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4442 EPI.ExceptionSpecTemplate = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4443 } else if (EST == EST_Unevaluated) { 4444 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4445 } 4446 return Context.getFunctionType(ResultType, ParamTypes, EPI); 4447 } 4448 4449 case TYPE_UNRESOLVED_USING: { 4450 unsigned Idx = 0; 4451 return Context.getTypeDeclType( 4452 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 4453 } 4454 4455 case TYPE_TYPEDEF: { 4456 if (Record.size() != 2) { 4457 Error("incorrect encoding of typedef type"); 4458 return QualType(); 4459 } 4460 unsigned Idx = 0; 4461 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 4462 QualType Canonical = readType(*Loc.F, Record, Idx); 4463 if (!Canonical.isNull()) 4464 Canonical = Context.getCanonicalType(Canonical); 4465 return Context.getTypedefType(Decl, Canonical); 4466 } 4467 4468 case TYPE_TYPEOF_EXPR: 4469 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 4470 4471 case TYPE_TYPEOF: { 4472 if (Record.size() != 1) { 4473 Error("incorrect encoding of typeof(type) in AST file"); 4474 return QualType(); 4475 } 4476 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4477 return Context.getTypeOfType(UnderlyingType); 4478 } 4479 4480 case TYPE_DECLTYPE: { 4481 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4482 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType); 4483 } 4484 4485 case TYPE_UNARY_TRANSFORM: { 4486 QualType BaseType = readType(*Loc.F, Record, Idx); 4487 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4488 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 4489 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 4490 } 4491 4492 case TYPE_AUTO: 4493 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 4494 4495 case TYPE_RECORD: { 4496 if (Record.size() != 2) { 4497 Error("incorrect encoding of record type"); 4498 return QualType(); 4499 } 4500 unsigned Idx = 0; 4501 bool IsDependent = Record[Idx++]; 4502 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx); 4503 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl()); 4504 QualType T = Context.getRecordType(RD); 4505 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4506 return T; 4507 } 4508 4509 case TYPE_ENUM: { 4510 if (Record.size() != 2) { 4511 Error("incorrect encoding of enum type"); 4512 return QualType(); 4513 } 4514 unsigned Idx = 0; 4515 bool IsDependent = Record[Idx++]; 4516 QualType T 4517 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 4518 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4519 return T; 4520 } 4521 4522 case TYPE_ATTRIBUTED: { 4523 if (Record.size() != 3) { 4524 Error("incorrect encoding of attributed type"); 4525 return QualType(); 4526 } 4527 QualType modifiedType = readType(*Loc.F, Record, Idx); 4528 QualType equivalentType = readType(*Loc.F, Record, Idx); 4529 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 4530 return Context.getAttributedType(kind, modifiedType, equivalentType); 4531 } 4532 4533 case TYPE_PAREN: { 4534 if (Record.size() != 1) { 4535 Error("incorrect encoding of paren type"); 4536 return QualType(); 4537 } 4538 QualType InnerType = readType(*Loc.F, Record, Idx); 4539 return Context.getParenType(InnerType); 4540 } 4541 4542 case TYPE_PACK_EXPANSION: { 4543 if (Record.size() != 2) { 4544 Error("incorrect encoding of pack expansion type"); 4545 return QualType(); 4546 } 4547 QualType Pattern = readType(*Loc.F, Record, Idx); 4548 if (Pattern.isNull()) 4549 return QualType(); 4550 Optional<unsigned> NumExpansions; 4551 if (Record[1]) 4552 NumExpansions = Record[1] - 1; 4553 return Context.getPackExpansionType(Pattern, NumExpansions); 4554 } 4555 4556 case TYPE_ELABORATED: { 4557 unsigned Idx = 0; 4558 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4559 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4560 QualType NamedType = readType(*Loc.F, Record, Idx); 4561 return Context.getElaboratedType(Keyword, NNS, NamedType); 4562 } 4563 4564 case TYPE_OBJC_INTERFACE: { 4565 unsigned Idx = 0; 4566 ObjCInterfaceDecl *ItfD 4567 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 4568 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl()); 4569 } 4570 4571 case TYPE_OBJC_OBJECT: { 4572 unsigned Idx = 0; 4573 QualType Base = readType(*Loc.F, Record, Idx); 4574 unsigned NumProtos = Record[Idx++]; 4575 SmallVector<ObjCProtocolDecl*, 4> Protos; 4576 for (unsigned I = 0; I != NumProtos; ++I) 4577 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 4578 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 4579 } 4580 4581 case TYPE_OBJC_OBJECT_POINTER: { 4582 unsigned Idx = 0; 4583 QualType Pointee = readType(*Loc.F, Record, Idx); 4584 return Context.getObjCObjectPointerType(Pointee); 4585 } 4586 4587 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 4588 unsigned Idx = 0; 4589 QualType Parm = readType(*Loc.F, Record, Idx); 4590 QualType Replacement = readType(*Loc.F, Record, Idx); 4591 return 4592 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 4593 Replacement); 4594 } 4595 4596 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 4597 unsigned Idx = 0; 4598 QualType Parm = readType(*Loc.F, Record, Idx); 4599 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 4600 return Context.getSubstTemplateTypeParmPackType( 4601 cast<TemplateTypeParmType>(Parm), 4602 ArgPack); 4603 } 4604 4605 case TYPE_INJECTED_CLASS_NAME: { 4606 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 4607 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 4608 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 4609 // for AST reading, too much interdependencies. 4610 return 4611 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 4612 } 4613 4614 case TYPE_TEMPLATE_TYPE_PARM: { 4615 unsigned Idx = 0; 4616 unsigned Depth = Record[Idx++]; 4617 unsigned Index = Record[Idx++]; 4618 bool Pack = Record[Idx++]; 4619 TemplateTypeParmDecl *D 4620 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 4621 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 4622 } 4623 4624 case TYPE_DEPENDENT_NAME: { 4625 unsigned Idx = 0; 4626 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4627 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4628 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4629 QualType Canon = readType(*Loc.F, Record, Idx); 4630 if (!Canon.isNull()) 4631 Canon = Context.getCanonicalType(Canon); 4632 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 4633 } 4634 4635 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 4636 unsigned Idx = 0; 4637 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4638 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4639 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4640 unsigned NumArgs = Record[Idx++]; 4641 SmallVector<TemplateArgument, 8> Args; 4642 Args.reserve(NumArgs); 4643 while (NumArgs--) 4644 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 4645 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 4646 Args.size(), Args.data()); 4647 } 4648 4649 case TYPE_DEPENDENT_SIZED_ARRAY: { 4650 unsigned Idx = 0; 4651 4652 // ArrayType 4653 QualType ElementType = readType(*Loc.F, Record, Idx); 4654 ArrayType::ArraySizeModifier ASM 4655 = (ArrayType::ArraySizeModifier)Record[Idx++]; 4656 unsigned IndexTypeQuals = Record[Idx++]; 4657 4658 // DependentSizedArrayType 4659 Expr *NumElts = ReadExpr(*Loc.F); 4660 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 4661 4662 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 4663 IndexTypeQuals, Brackets); 4664 } 4665 4666 case TYPE_TEMPLATE_SPECIALIZATION: { 4667 unsigned Idx = 0; 4668 bool IsDependent = Record[Idx++]; 4669 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 4670 SmallVector<TemplateArgument, 8> Args; 4671 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 4672 QualType Underlying = readType(*Loc.F, Record, Idx); 4673 QualType T; 4674 if (Underlying.isNull()) 4675 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 4676 Args.size()); 4677 else 4678 T = Context.getTemplateSpecializationType(Name, Args.data(), 4679 Args.size(), Underlying); 4680 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4681 return T; 4682 } 4683 4684 case TYPE_ATOMIC: { 4685 if (Record.size() != 1) { 4686 Error("Incorrect encoding of atomic type"); 4687 return QualType(); 4688 } 4689 QualType ValueType = readType(*Loc.F, Record, Idx); 4690 return Context.getAtomicType(ValueType); 4691 } 4692 } 4693 llvm_unreachable("Invalid TypeCode!"); 4694} 4695 4696class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 4697 ASTReader &Reader; 4698 ModuleFile &F; 4699 const ASTReader::RecordData &Record; 4700 unsigned &Idx; 4701 4702 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4703 unsigned &I) { 4704 return Reader.ReadSourceLocation(F, R, I); 4705 } 4706 4707 template<typename T> 4708 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4709 return Reader.ReadDeclAs<T>(F, Record, Idx); 4710 } 4711 4712public: 4713 TypeLocReader(ASTReader &Reader, ModuleFile &F, 4714 const ASTReader::RecordData &Record, unsigned &Idx) 4715 : Reader(Reader), F(F), Record(Record), Idx(Idx) 4716 { } 4717 4718 // We want compile-time assurance that we've enumerated all of 4719 // these, so unfortunately we have to declare them first, then 4720 // define them out-of-line. 4721#define ABSTRACT_TYPELOC(CLASS, PARENT) 4722#define TYPELOC(CLASS, PARENT) \ 4723 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4724#include "clang/AST/TypeLocNodes.def" 4725 4726 void VisitFunctionTypeLoc(FunctionTypeLoc); 4727 void VisitArrayTypeLoc(ArrayTypeLoc); 4728}; 4729 4730void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4731 // nothing to do 4732} 4733void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4734 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4735 if (TL.needsExtraLocalData()) { 4736 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4737 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4738 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4739 TL.setModeAttr(Record[Idx++]); 4740 } 4741} 4742void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4743 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4744} 4745void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4746 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4747} 4748void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4749 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4750} 4751void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4752 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4753} 4754void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4755 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4756} 4757void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4758 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4759 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4760} 4761void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4762 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4763 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4764 if (Record[Idx++]) 4765 TL.setSizeExpr(Reader.ReadExpr(F)); 4766 else 4767 TL.setSizeExpr(0); 4768} 4769void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4770 VisitArrayTypeLoc(TL); 4771} 4772void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4773 VisitArrayTypeLoc(TL); 4774} 4775void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4776 VisitArrayTypeLoc(TL); 4777} 4778void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4779 DependentSizedArrayTypeLoc TL) { 4780 VisitArrayTypeLoc(TL); 4781} 4782void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4783 DependentSizedExtVectorTypeLoc TL) { 4784 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4785} 4786void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4787 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4788} 4789void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4790 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4791} 4792void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4793 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4794 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4795 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4796 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4797 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4798 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4799 } 4800} 4801void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4802 VisitFunctionTypeLoc(TL); 4803} 4804void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4805 VisitFunctionTypeLoc(TL); 4806} 4807void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4808 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4809} 4810void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4811 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4812} 4813void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4814 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4815 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4816 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4817} 4818void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4819 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4820 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4821 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4822 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4823} 4824void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4825 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4826} 4827void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4828 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4829 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4830 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4831 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4832} 4833void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4834 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4835} 4836void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4837 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4838} 4839void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4840 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4841} 4842void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4843 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4844 if (TL.hasAttrOperand()) { 4845 SourceRange range; 4846 range.setBegin(ReadSourceLocation(Record, Idx)); 4847 range.setEnd(ReadSourceLocation(Record, Idx)); 4848 TL.setAttrOperandParensRange(range); 4849 } 4850 if (TL.hasAttrExprOperand()) { 4851 if (Record[Idx++]) 4852 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4853 else 4854 TL.setAttrExprOperand(0); 4855 } else if (TL.hasAttrEnumOperand()) 4856 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4857} 4858void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4859 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4860} 4861void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4862 SubstTemplateTypeParmTypeLoc TL) { 4863 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4864} 4865void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4866 SubstTemplateTypeParmPackTypeLoc TL) { 4867 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4868} 4869void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4870 TemplateSpecializationTypeLoc TL) { 4871 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4872 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4873 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4874 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4875 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4876 TL.setArgLocInfo(i, 4877 Reader.GetTemplateArgumentLocInfo(F, 4878 TL.getTypePtr()->getArg(i).getKind(), 4879 Record, Idx)); 4880} 4881void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4882 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4883 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4884} 4885void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4886 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4887 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4888} 4889void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4890 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4891} 4892void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4893 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4894 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4895 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4896} 4897void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4898 DependentTemplateSpecializationTypeLoc TL) { 4899 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4900 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4901 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4902 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4903 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4904 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4905 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4906 TL.setArgLocInfo(I, 4907 Reader.GetTemplateArgumentLocInfo(F, 4908 TL.getTypePtr()->getArg(I).getKind(), 4909 Record, Idx)); 4910} 4911void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4912 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4913} 4914void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4915 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4916} 4917void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4918 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4919 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4920 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4921 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4922 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4923} 4924void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4925 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4926} 4927void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4928 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4929 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4930 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4931} 4932 4933TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 4934 const RecordData &Record, 4935 unsigned &Idx) { 4936 QualType InfoTy = readType(F, Record, Idx); 4937 if (InfoTy.isNull()) 4938 return 0; 4939 4940 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 4941 TypeLocReader TLR(*this, F, Record, Idx); 4942 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4943 TLR.Visit(TL); 4944 return TInfo; 4945} 4946 4947QualType ASTReader::GetType(TypeID ID) { 4948 unsigned FastQuals = ID & Qualifiers::FastMask; 4949 unsigned Index = ID >> Qualifiers::FastWidth; 4950 4951 if (Index < NUM_PREDEF_TYPE_IDS) { 4952 QualType T; 4953 switch ((PredefinedTypeIDs)Index) { 4954 case PREDEF_TYPE_NULL_ID: return QualType(); 4955 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 4956 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 4957 4958 case PREDEF_TYPE_CHAR_U_ID: 4959 case PREDEF_TYPE_CHAR_S_ID: 4960 // FIXME: Check that the signedness of CharTy is correct! 4961 T = Context.CharTy; 4962 break; 4963 4964 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 4965 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 4966 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 4967 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 4968 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 4969 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 4970 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 4971 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 4972 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 4973 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 4974 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 4975 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 4976 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 4977 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 4978 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 4979 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 4980 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 4981 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 4982 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 4983 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 4984 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 4985 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 4986 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 4987 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 4988 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 4989 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 4990 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 4991 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 4992 case PREDEF_TYPE_IMAGE1D_ID: T = Context.OCLImage1dTy; break; 4993 case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break; 4994 case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break; 4995 case PREDEF_TYPE_IMAGE2D_ID: T = Context.OCLImage2dTy; break; 4996 case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break; 4997 case PREDEF_TYPE_IMAGE3D_ID: T = Context.OCLImage3dTy; break; 4998 case PREDEF_TYPE_SAMPLER_ID: T = Context.OCLSamplerTy; break; 4999 case PREDEF_TYPE_EVENT_ID: T = Context.OCLEventTy; break; 5000 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 5001 5002 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 5003 T = Context.getAutoRRefDeductType(); 5004 break; 5005 5006 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 5007 T = Context.ARCUnbridgedCastTy; 5008 break; 5009 5010 case PREDEF_TYPE_VA_LIST_TAG: 5011 T = Context.getVaListTagType(); 5012 break; 5013 5014 case PREDEF_TYPE_BUILTIN_FN: 5015 T = Context.BuiltinFnTy; 5016 break; 5017 } 5018 5019 assert(!T.isNull() && "Unknown predefined type"); 5020 return T.withFastQualifiers(FastQuals); 5021 } 5022 5023 Index -= NUM_PREDEF_TYPE_IDS; 5024 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 5025 if (TypesLoaded[Index].isNull()) { 5026 TypesLoaded[Index] = readTypeRecord(Index); 5027 if (TypesLoaded[Index].isNull()) 5028 return QualType(); 5029 5030 TypesLoaded[Index]->setFromAST(); 5031 if (DeserializationListener) 5032 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 5033 TypesLoaded[Index]); 5034 } 5035 5036 return TypesLoaded[Index].withFastQualifiers(FastQuals); 5037} 5038 5039QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 5040 return GetType(getGlobalTypeID(F, LocalID)); 5041} 5042 5043serialization::TypeID 5044ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 5045 unsigned FastQuals = LocalID & Qualifiers::FastMask; 5046 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 5047 5048 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 5049 return LocalID; 5050 5051 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5052 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 5053 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 5054 5055 unsigned GlobalIndex = LocalIndex + I->second; 5056 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 5057} 5058 5059TemplateArgumentLocInfo 5060ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 5061 TemplateArgument::ArgKind Kind, 5062 const RecordData &Record, 5063 unsigned &Index) { 5064 switch (Kind) { 5065 case TemplateArgument::Expression: 5066 return ReadExpr(F); 5067 case TemplateArgument::Type: 5068 return GetTypeSourceInfo(F, Record, Index); 5069 case TemplateArgument::Template: { 5070 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5071 Index); 5072 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5073 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5074 SourceLocation()); 5075 } 5076 case TemplateArgument::TemplateExpansion: { 5077 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5078 Index); 5079 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5080 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 5081 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5082 EllipsisLoc); 5083 } 5084 case TemplateArgument::Null: 5085 case TemplateArgument::Integral: 5086 case TemplateArgument::Declaration: 5087 case TemplateArgument::NullPtr: 5088 case TemplateArgument::Pack: 5089 // FIXME: Is this right? 5090 return TemplateArgumentLocInfo(); 5091 } 5092 llvm_unreachable("unexpected template argument loc"); 5093} 5094 5095TemplateArgumentLoc 5096ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 5097 const RecordData &Record, unsigned &Index) { 5098 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 5099 5100 if (Arg.getKind() == TemplateArgument::Expression) { 5101 if (Record[Index++]) // bool InfoHasSameExpr. 5102 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 5103 } 5104 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 5105 Record, Index)); 5106} 5107 5108Decl *ASTReader::GetExternalDecl(uint32_t ID) { 5109 return GetDecl(ID); 5110} 5111 5112uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 5113 unsigned &Idx){ 5114 if (Idx >= Record.size()) 5115 return 0; 5116 5117 unsigned LocalID = Record[Idx++]; 5118 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 5119} 5120 5121CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 5122 RecordLocation Loc = getLocalBitOffset(Offset); 5123 BitstreamCursor &Cursor = Loc.F->DeclsCursor; 5124 SavedStreamPosition SavedPosition(Cursor); 5125 Cursor.JumpToBit(Loc.Offset); 5126 ReadingKindTracker ReadingKind(Read_Decl, *this); 5127 RecordData Record; 5128 unsigned Code = Cursor.ReadCode(); 5129 unsigned RecCode = Cursor.readRecord(Code, Record); 5130 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 5131 Error("Malformed AST file: missing C++ base specifiers"); 5132 return 0; 5133 } 5134 5135 unsigned Idx = 0; 5136 unsigned NumBases = Record[Idx++]; 5137 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 5138 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 5139 for (unsigned I = 0; I != NumBases; ++I) 5140 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 5141 return Bases; 5142} 5143 5144serialization::DeclID 5145ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const { 5146 if (LocalID < NUM_PREDEF_DECL_IDS) 5147 return LocalID; 5148 5149 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5150 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 5151 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 5152 5153 return LocalID + I->second; 5154} 5155 5156bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 5157 ModuleFile &M) const { 5158 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 5159 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5160 return &M == I->second; 5161} 5162 5163ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) { 5164 if (!D->isFromASTFile()) 5165 return 0; 5166 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID()); 5167 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5168 return I->second; 5169} 5170 5171SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 5172 if (ID < NUM_PREDEF_DECL_IDS) 5173 return SourceLocation(); 5174 5175 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5176 5177 if (Index > DeclsLoaded.size()) { 5178 Error("declaration ID out-of-range for AST file"); 5179 return SourceLocation(); 5180 } 5181 5182 if (Decl *D = DeclsLoaded[Index]) 5183 return D->getLocation(); 5184 5185 unsigned RawLocation = 0; 5186 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 5187 return ReadSourceLocation(*Rec.F, RawLocation); 5188} 5189 5190Decl *ASTReader::GetDecl(DeclID ID) { 5191 if (ID < NUM_PREDEF_DECL_IDS) { 5192 switch ((PredefinedDeclIDs)ID) { 5193 case PREDEF_DECL_NULL_ID: 5194 return 0; 5195 5196 case PREDEF_DECL_TRANSLATION_UNIT_ID: 5197 return Context.getTranslationUnitDecl(); 5198 5199 case PREDEF_DECL_OBJC_ID_ID: 5200 return Context.getObjCIdDecl(); 5201 5202 case PREDEF_DECL_OBJC_SEL_ID: 5203 return Context.getObjCSelDecl(); 5204 5205 case PREDEF_DECL_OBJC_CLASS_ID: 5206 return Context.getObjCClassDecl(); 5207 5208 case PREDEF_DECL_OBJC_PROTOCOL_ID: 5209 return Context.getObjCProtocolDecl(); 5210 5211 case PREDEF_DECL_INT_128_ID: 5212 return Context.getInt128Decl(); 5213 5214 case PREDEF_DECL_UNSIGNED_INT_128_ID: 5215 return Context.getUInt128Decl(); 5216 5217 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 5218 return Context.getObjCInstanceTypeDecl(); 5219 5220 case PREDEF_DECL_BUILTIN_VA_LIST_ID: 5221 return Context.getBuiltinVaListDecl(); 5222 } 5223 } 5224 5225 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5226 5227 if (Index >= DeclsLoaded.size()) { 5228 assert(0 && "declaration ID out-of-range for AST file"); 5229 Error("declaration ID out-of-range for AST file"); 5230 return 0; 5231 } 5232 5233 if (!DeclsLoaded[Index]) { 5234 ReadDeclRecord(ID); 5235 if (DeserializationListener) 5236 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 5237 } 5238 5239 return DeclsLoaded[Index]; 5240} 5241 5242DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 5243 DeclID GlobalID) { 5244 if (GlobalID < NUM_PREDEF_DECL_IDS) 5245 return GlobalID; 5246 5247 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 5248 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5249 ModuleFile *Owner = I->second; 5250 5251 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 5252 = M.GlobalToLocalDeclIDs.find(Owner); 5253 if (Pos == M.GlobalToLocalDeclIDs.end()) 5254 return 0; 5255 5256 return GlobalID - Owner->BaseDeclID + Pos->second; 5257} 5258 5259serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 5260 const RecordData &Record, 5261 unsigned &Idx) { 5262 if (Idx >= Record.size()) { 5263 Error("Corrupted AST file"); 5264 return 0; 5265 } 5266 5267 return getGlobalDeclID(F, Record[Idx++]); 5268} 5269 5270/// \brief Resolve the offset of a statement into a statement. 5271/// 5272/// This operation will read a new statement from the external 5273/// source each time it is called, and is meant to be used via a 5274/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 5275Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 5276 // Switch case IDs are per Decl. 5277 ClearSwitchCaseIDs(); 5278 5279 // Offset here is a global offset across the entire chain. 5280 RecordLocation Loc = getLocalBitOffset(Offset); 5281 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 5282 return ReadStmtFromStream(*Loc.F); 5283} 5284 5285namespace { 5286 class FindExternalLexicalDeclsVisitor { 5287 ASTReader &Reader; 5288 const DeclContext *DC; 5289 bool (*isKindWeWant)(Decl::Kind); 5290 5291 SmallVectorImpl<Decl*> &Decls; 5292 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 5293 5294 public: 5295 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 5296 bool (*isKindWeWant)(Decl::Kind), 5297 SmallVectorImpl<Decl*> &Decls) 5298 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 5299 { 5300 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 5301 PredefsVisited[I] = false; 5302 } 5303 5304 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 5305 if (Preorder) 5306 return false; 5307 5308 FindExternalLexicalDeclsVisitor *This 5309 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 5310 5311 ModuleFile::DeclContextInfosMap::iterator Info 5312 = M.DeclContextInfos.find(This->DC); 5313 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 5314 return false; 5315 5316 // Load all of the declaration IDs 5317 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 5318 *IDE = ID + Info->second.NumLexicalDecls; 5319 ID != IDE; ++ID) { 5320 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 5321 continue; 5322 5323 // Don't add predefined declarations to the lexical context more 5324 // than once. 5325 if (ID->second < NUM_PREDEF_DECL_IDS) { 5326 if (This->PredefsVisited[ID->second]) 5327 continue; 5328 5329 This->PredefsVisited[ID->second] = true; 5330 } 5331 5332 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 5333 if (!This->DC->isDeclInLexicalTraversal(D)) 5334 This->Decls.push_back(D); 5335 } 5336 } 5337 5338 return false; 5339 } 5340 }; 5341} 5342 5343ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 5344 bool (*isKindWeWant)(Decl::Kind), 5345 SmallVectorImpl<Decl*> &Decls) { 5346 // There might be lexical decls in multiple modules, for the TU at 5347 // least. Walk all of the modules in the order they were loaded. 5348 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 5349 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 5350 ++NumLexicalDeclContextsRead; 5351 return ELR_Success; 5352} 5353 5354namespace { 5355 5356class DeclIDComp { 5357 ASTReader &Reader; 5358 ModuleFile &Mod; 5359 5360public: 5361 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 5362 5363 bool operator()(LocalDeclID L, LocalDeclID R) const { 5364 SourceLocation LHS = getLocation(L); 5365 SourceLocation RHS = getLocation(R); 5366 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5367 } 5368 5369 bool operator()(SourceLocation LHS, LocalDeclID R) const { 5370 SourceLocation RHS = getLocation(R); 5371 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5372 } 5373 5374 bool operator()(LocalDeclID L, SourceLocation RHS) const { 5375 SourceLocation LHS = getLocation(L); 5376 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5377 } 5378 5379 SourceLocation getLocation(LocalDeclID ID) const { 5380 return Reader.getSourceManager().getFileLoc( 5381 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 5382 } 5383}; 5384 5385} 5386 5387void ASTReader::FindFileRegionDecls(FileID File, 5388 unsigned Offset, unsigned Length, 5389 SmallVectorImpl<Decl *> &Decls) { 5390 SourceManager &SM = getSourceManager(); 5391 5392 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 5393 if (I == FileDeclIDs.end()) 5394 return; 5395 5396 FileDeclsInfo &DInfo = I->second; 5397 if (DInfo.Decls.empty()) 5398 return; 5399 5400 SourceLocation 5401 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 5402 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 5403 5404 DeclIDComp DIDComp(*this, *DInfo.Mod); 5405 ArrayRef<serialization::LocalDeclID>::iterator 5406 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5407 BeginLoc, DIDComp); 5408 if (BeginIt != DInfo.Decls.begin()) 5409 --BeginIt; 5410 5411 // If we are pointing at a top-level decl inside an objc container, we need 5412 // to backtrack until we find it otherwise we will fail to report that the 5413 // region overlaps with an objc container. 5414 while (BeginIt != DInfo.Decls.begin() && 5415 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 5416 ->isTopLevelDeclInObjCContainer()) 5417 --BeginIt; 5418 5419 ArrayRef<serialization::LocalDeclID>::iterator 5420 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5421 EndLoc, DIDComp); 5422 if (EndIt != DInfo.Decls.end()) 5423 ++EndIt; 5424 5425 for (ArrayRef<serialization::LocalDeclID>::iterator 5426 DIt = BeginIt; DIt != EndIt; ++DIt) 5427 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 5428} 5429 5430namespace { 5431 /// \brief ModuleFile visitor used to perform name lookup into a 5432 /// declaration context. 5433 class DeclContextNameLookupVisitor { 5434 ASTReader &Reader; 5435 SmallVectorImpl<const DeclContext *> &Contexts; 5436 DeclarationName Name; 5437 SmallVectorImpl<NamedDecl *> &Decls; 5438 5439 public: 5440 DeclContextNameLookupVisitor(ASTReader &Reader, 5441 SmallVectorImpl<const DeclContext *> &Contexts, 5442 DeclarationName Name, 5443 SmallVectorImpl<NamedDecl *> &Decls) 5444 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { } 5445 5446 static bool visit(ModuleFile &M, void *UserData) { 5447 DeclContextNameLookupVisitor *This 5448 = static_cast<DeclContextNameLookupVisitor *>(UserData); 5449 5450 // Check whether we have any visible declaration information for 5451 // this context in this module. 5452 ModuleFile::DeclContextInfosMap::iterator Info; 5453 bool FoundInfo = false; 5454 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5455 Info = M.DeclContextInfos.find(This->Contexts[I]); 5456 if (Info != M.DeclContextInfos.end() && 5457 Info->second.NameLookupTableData) { 5458 FoundInfo = true; 5459 break; 5460 } 5461 } 5462 5463 if (!FoundInfo) 5464 return false; 5465 5466 // Look for this name within this module. 5467 ASTDeclContextNameLookupTable *LookupTable = 5468 Info->second.NameLookupTableData; 5469 ASTDeclContextNameLookupTable::iterator Pos 5470 = LookupTable->find(This->Name); 5471 if (Pos == LookupTable->end()) 5472 return false; 5473 5474 bool FoundAnything = false; 5475 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 5476 for (; Data.first != Data.second; ++Data.first) { 5477 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 5478 if (!ND) 5479 continue; 5480 5481 if (ND->getDeclName() != This->Name) { 5482 // A name might be null because the decl's redeclarable part is 5483 // currently read before reading its name. The lookup is triggered by 5484 // building that decl (likely indirectly), and so it is later in the 5485 // sense of "already existing" and can be ignored here. 5486 continue; 5487 } 5488 5489 // Record this declaration. 5490 FoundAnything = true; 5491 This->Decls.push_back(ND); 5492 } 5493 5494 return FoundAnything; 5495 } 5496 }; 5497} 5498 5499/// \brief Retrieve the "definitive" module file for the definition of the 5500/// given declaration context, if there is one. 5501/// 5502/// The "definitive" module file is the only place where we need to look to 5503/// find information about the declarations within the given declaration 5504/// context. For example, C++ and Objective-C classes, C structs/unions, and 5505/// Objective-C protocols, categories, and extensions are all defined in a 5506/// single place in the source code, so they have definitive module files 5507/// associated with them. C++ namespaces, on the other hand, can have 5508/// definitions in multiple different module files. 5509/// 5510/// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's 5511/// NDEBUG checking. 5512static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC, 5513 ASTReader &Reader) { 5514 if (const DeclContext *DefDC = getDefinitiveDeclContext(DC)) 5515 return Reader.getOwningModuleFile(cast<Decl>(DefDC)); 5516 5517 return 0; 5518} 5519 5520bool 5521ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 5522 DeclarationName Name) { 5523 assert(DC->hasExternalVisibleStorage() && 5524 "DeclContext has no visible decls in storage"); 5525 if (!Name) 5526 return false; 5527 5528 SmallVector<NamedDecl *, 64> Decls; 5529 5530 // Compute the declaration contexts we need to look into. Multiple such 5531 // declaration contexts occur when two declaration contexts from disjoint 5532 // modules get merged, e.g., when two namespaces with the same name are 5533 // independently defined in separate modules. 5534 SmallVector<const DeclContext *, 2> Contexts; 5535 Contexts.push_back(DC); 5536 5537 if (DC->isNamespace()) { 5538 MergedDeclsMap::iterator Merged 5539 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5540 if (Merged != MergedDecls.end()) { 5541 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5542 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5543 } 5544 } 5545 5546 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls); 5547 5548 // If we can definitively determine which module file to look into, 5549 // only look there. Otherwise, look in all module files. 5550 ModuleFile *Definitive; 5551 if (Contexts.size() == 1 && 5552 (Definitive = getDefinitiveModuleFileFor(DC, *this))) { 5553 DeclContextNameLookupVisitor::visit(*Definitive, &Visitor); 5554 } else { 5555 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 5556 } 5557 ++NumVisibleDeclContextsRead; 5558 SetExternalVisibleDeclsForName(DC, Name, Decls); 5559 return !Decls.empty(); 5560} 5561 5562namespace { 5563 /// \brief ModuleFile visitor used to retrieve all visible names in a 5564 /// declaration context. 5565 class DeclContextAllNamesVisitor { 5566 ASTReader &Reader; 5567 SmallVectorImpl<const DeclContext *> &Contexts; 5568 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls; 5569 bool VisitAll; 5570 5571 public: 5572 DeclContextAllNamesVisitor(ASTReader &Reader, 5573 SmallVectorImpl<const DeclContext *> &Contexts, 5574 llvm::DenseMap<DeclarationName, 5575 SmallVector<NamedDecl *, 8> > &Decls, 5576 bool VisitAll) 5577 : Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { } 5578 5579 static bool visit(ModuleFile &M, void *UserData) { 5580 DeclContextAllNamesVisitor *This 5581 = static_cast<DeclContextAllNamesVisitor *>(UserData); 5582 5583 // Check whether we have any visible declaration information for 5584 // this context in this module. 5585 ModuleFile::DeclContextInfosMap::iterator Info; 5586 bool FoundInfo = false; 5587 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5588 Info = M.DeclContextInfos.find(This->Contexts[I]); 5589 if (Info != M.DeclContextInfos.end() && 5590 Info->second.NameLookupTableData) { 5591 FoundInfo = true; 5592 break; 5593 } 5594 } 5595 5596 if (!FoundInfo) 5597 return false; 5598 5599 ASTDeclContextNameLookupTable *LookupTable = 5600 Info->second.NameLookupTableData; 5601 bool FoundAnything = false; 5602 for (ASTDeclContextNameLookupTable::data_iterator 5603 I = LookupTable->data_begin(), E = LookupTable->data_end(); 5604 I != E; 5605 ++I) { 5606 ASTDeclContextNameLookupTrait::data_type Data = *I; 5607 for (; Data.first != Data.second; ++Data.first) { 5608 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, 5609 *Data.first); 5610 if (!ND) 5611 continue; 5612 5613 // Record this declaration. 5614 FoundAnything = true; 5615 This->Decls[ND->getDeclName()].push_back(ND); 5616 } 5617 } 5618 5619 return FoundAnything && !This->VisitAll; 5620 } 5621 }; 5622} 5623 5624void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) { 5625 if (!DC->hasExternalVisibleStorage()) 5626 return; 5627 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > Decls; 5628 5629 // Compute the declaration contexts we need to look into. Multiple such 5630 // declaration contexts occur when two declaration contexts from disjoint 5631 // modules get merged, e.g., when two namespaces with the same name are 5632 // independently defined in separate modules. 5633 SmallVector<const DeclContext *, 2> Contexts; 5634 Contexts.push_back(DC); 5635 5636 if (DC->isNamespace()) { 5637 MergedDeclsMap::iterator Merged 5638 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5639 if (Merged != MergedDecls.end()) { 5640 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5641 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5642 } 5643 } 5644 5645 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls, 5646 /*VisitAll=*/DC->isFileContext()); 5647 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor); 5648 ++NumVisibleDeclContextsRead; 5649 5650 for (llvm::DenseMap<DeclarationName, 5651 SmallVector<NamedDecl *, 8> >::iterator 5652 I = Decls.begin(), E = Decls.end(); I != E; ++I) { 5653 SetExternalVisibleDeclsForName(DC, I->first, I->second); 5654 } 5655 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false); 5656} 5657 5658/// \brief Under non-PCH compilation the consumer receives the objc methods 5659/// before receiving the implementation, and codegen depends on this. 5660/// We simulate this by deserializing and passing to consumer the methods of the 5661/// implementation before passing the deserialized implementation decl. 5662static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 5663 ASTConsumer *Consumer) { 5664 assert(ImplD && Consumer); 5665 5666 for (ObjCImplDecl::method_iterator 5667 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 5668 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 5669 5670 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 5671} 5672 5673void ASTReader::PassInterestingDeclsToConsumer() { 5674 assert(Consumer); 5675 while (!InterestingDecls.empty()) { 5676 Decl *D = InterestingDecls.front(); 5677 InterestingDecls.pop_front(); 5678 5679 PassInterestingDeclToConsumer(D); 5680 } 5681} 5682 5683void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 5684 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 5685 PassObjCImplDeclToConsumer(ImplD, Consumer); 5686 else 5687 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 5688} 5689 5690void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 5691 this->Consumer = Consumer; 5692 5693 if (!Consumer) 5694 return; 5695 5696 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 5697 // Force deserialization of this decl, which will cause it to be queued for 5698 // passing to the consumer. 5699 GetDecl(ExternalDefinitions[I]); 5700 } 5701 ExternalDefinitions.clear(); 5702 5703 PassInterestingDeclsToConsumer(); 5704} 5705 5706void ASTReader::PrintStats() { 5707 std::fprintf(stderr, "*** AST File Statistics:\n"); 5708 5709 unsigned NumTypesLoaded 5710 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 5711 QualType()); 5712 unsigned NumDeclsLoaded 5713 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 5714 (Decl *)0); 5715 unsigned NumIdentifiersLoaded 5716 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 5717 IdentifiersLoaded.end(), 5718 (IdentifierInfo *)0); 5719 unsigned NumMacrosLoaded 5720 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(), 5721 MacrosLoaded.end(), 5722 (MacroDirective *)0); 5723 unsigned NumSelectorsLoaded 5724 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 5725 SelectorsLoaded.end(), 5726 Selector()); 5727 5728 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 5729 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 5730 NumSLocEntriesRead, TotalNumSLocEntries, 5731 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 5732 if (!TypesLoaded.empty()) 5733 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 5734 NumTypesLoaded, (unsigned)TypesLoaded.size(), 5735 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 5736 if (!DeclsLoaded.empty()) 5737 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 5738 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 5739 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 5740 if (!IdentifiersLoaded.empty()) 5741 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 5742 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 5743 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 5744 if (!MacrosLoaded.empty()) 5745 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5746 NumMacrosLoaded, (unsigned)MacrosLoaded.size(), 5747 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100)); 5748 if (!SelectorsLoaded.empty()) 5749 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 5750 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 5751 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 5752 if (TotalNumStatements) 5753 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 5754 NumStatementsRead, TotalNumStatements, 5755 ((float)NumStatementsRead/TotalNumStatements * 100)); 5756 if (TotalNumMacros) 5757 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5758 NumMacrosRead, TotalNumMacros, 5759 ((float)NumMacrosRead/TotalNumMacros * 100)); 5760 if (TotalLexicalDeclContexts) 5761 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 5762 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 5763 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 5764 * 100)); 5765 if (TotalVisibleDeclContexts) 5766 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 5767 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 5768 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 5769 * 100)); 5770 if (TotalNumMethodPoolEntries) { 5771 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 5772 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 5773 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 5774 * 100)); 5775 } 5776 if (NumMethodPoolLookups) { 5777 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n", 5778 NumMethodPoolHits, NumMethodPoolLookups, 5779 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0)); 5780 } 5781 if (NumMethodPoolTableLookups) { 5782 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n", 5783 NumMethodPoolTableHits, NumMethodPoolTableLookups, 5784 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups 5785 * 100.0)); 5786 } 5787 5788 if (NumIdentifierLookupHits) { 5789 std::fprintf(stderr, 5790 " %u / %u identifier table lookups succeeded (%f%%)\n", 5791 NumIdentifierLookupHits, NumIdentifierLookups, 5792 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups); 5793 } 5794 5795 if (GlobalIndex) { 5796 std::fprintf(stderr, "\n"); 5797 GlobalIndex->printStats(); 5798 } 5799 5800 std::fprintf(stderr, "\n"); 5801 dump(); 5802 std::fprintf(stderr, "\n"); 5803} 5804 5805template<typename Key, typename ModuleFile, unsigned InitialCapacity> 5806static void 5807dumpModuleIDMap(StringRef Name, 5808 const ContinuousRangeMap<Key, ModuleFile *, 5809 InitialCapacity> &Map) { 5810 if (Map.begin() == Map.end()) 5811 return; 5812 5813 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 5814 llvm::errs() << Name << ":\n"; 5815 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5816 I != IEnd; ++I) { 5817 llvm::errs() << " " << I->first << " -> " << I->second->FileName 5818 << "\n"; 5819 } 5820} 5821 5822void ASTReader::dump() { 5823 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 5824 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 5825 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 5826 dumpModuleIDMap("Global type map", GlobalTypeMap); 5827 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 5828 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 5829 dumpModuleIDMap("Global macro map", GlobalMacroMap); 5830 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 5831 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 5832 dumpModuleIDMap("Global preprocessed entity map", 5833 GlobalPreprocessedEntityMap); 5834 5835 llvm::errs() << "\n*** PCH/Modules Loaded:"; 5836 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 5837 MEnd = ModuleMgr.end(); 5838 M != MEnd; ++M) 5839 (*M)->dump(); 5840} 5841 5842/// Return the amount of memory used by memory buffers, breaking down 5843/// by heap-backed versus mmap'ed memory. 5844void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 5845 for (ModuleConstIterator I = ModuleMgr.begin(), 5846 E = ModuleMgr.end(); I != E; ++I) { 5847 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 5848 size_t bytes = buf->getBufferSize(); 5849 switch (buf->getBufferKind()) { 5850 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 5851 sizes.malloc_bytes += bytes; 5852 break; 5853 case llvm::MemoryBuffer::MemoryBuffer_MMap: 5854 sizes.mmap_bytes += bytes; 5855 break; 5856 } 5857 } 5858 } 5859} 5860 5861void ASTReader::InitializeSema(Sema &S) { 5862 SemaObj = &S; 5863 S.addExternalSource(this); 5864 5865 // Makes sure any declarations that were deserialized "too early" 5866 // still get added to the identifier's declaration chains. 5867 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 5868 NamedDecl *ND = cast<NamedDecl>(PreloadedDecls[I]->getMostRecentDecl()); 5869 SemaObj->pushExternalDeclIntoScope(ND, PreloadedDecls[I]->getDeclName()); 5870 } 5871 PreloadedDecls.clear(); 5872 5873 // Load the offsets of the declarations that Sema references. 5874 // They will be lazily deserialized when needed. 5875 if (!SemaDeclRefs.empty()) { 5876 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 5877 if (!SemaObj->StdNamespace) 5878 SemaObj->StdNamespace = SemaDeclRefs[0]; 5879 if (!SemaObj->StdBadAlloc) 5880 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 5881 } 5882 5883 if (!FPPragmaOptions.empty()) { 5884 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 5885 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 5886 } 5887 5888 if (!OpenCLExtensions.empty()) { 5889 unsigned I = 0; 5890#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 5891#include "clang/Basic/OpenCLExtensions.def" 5892 5893 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 5894 } 5895} 5896 5897IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 5898 // Note that we are loading an identifier. 5899 Deserializing AnIdentifier(this); 5900 StringRef Name(NameStart, NameEnd - NameStart); 5901 5902 // If there is a global index, look there first to determine which modules 5903 // provably do not have any results for this identifier. 5904 GlobalModuleIndex::HitSet Hits; 5905 GlobalModuleIndex::HitSet *HitsPtr = 0; 5906 if (!loadGlobalIndex()) { 5907 if (GlobalIndex->lookupIdentifier(Name, Hits)) { 5908 HitsPtr = &Hits; 5909 } 5910 } 5911 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0, 5912 NumIdentifierLookups, 5913 NumIdentifierLookupHits); 5914 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 5915 IdentifierInfo *II = Visitor.getIdentifierInfo(); 5916 markIdentifierUpToDate(II); 5917 return II; 5918} 5919 5920namespace clang { 5921 /// \brief An identifier-lookup iterator that enumerates all of the 5922 /// identifiers stored within a set of AST files. 5923 class ASTIdentifierIterator : public IdentifierIterator { 5924 /// \brief The AST reader whose identifiers are being enumerated. 5925 const ASTReader &Reader; 5926 5927 /// \brief The current index into the chain of AST files stored in 5928 /// the AST reader. 5929 unsigned Index; 5930 5931 /// \brief The current position within the identifier lookup table 5932 /// of the current AST file. 5933 ASTIdentifierLookupTable::key_iterator Current; 5934 5935 /// \brief The end position within the identifier lookup table of 5936 /// the current AST file. 5937 ASTIdentifierLookupTable::key_iterator End; 5938 5939 public: 5940 explicit ASTIdentifierIterator(const ASTReader &Reader); 5941 5942 virtual StringRef Next(); 5943 }; 5944} 5945 5946ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 5947 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 5948 ASTIdentifierLookupTable *IdTable 5949 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 5950 Current = IdTable->key_begin(); 5951 End = IdTable->key_end(); 5952} 5953 5954StringRef ASTIdentifierIterator::Next() { 5955 while (Current == End) { 5956 // If we have exhausted all of our AST files, we're done. 5957 if (Index == 0) 5958 return StringRef(); 5959 5960 --Index; 5961 ASTIdentifierLookupTable *IdTable 5962 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 5963 IdentifierLookupTable; 5964 Current = IdTable->key_begin(); 5965 End = IdTable->key_end(); 5966 } 5967 5968 // We have any identifiers remaining in the current AST file; return 5969 // the next one. 5970 StringRef Result = *Current; 5971 ++Current; 5972 return Result; 5973} 5974 5975IdentifierIterator *ASTReader::getIdentifiers() const { 5976 return new ASTIdentifierIterator(*this); 5977} 5978 5979namespace clang { namespace serialization { 5980 class ReadMethodPoolVisitor { 5981 ASTReader &Reader; 5982 Selector Sel; 5983 unsigned PriorGeneration; 5984 SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 5985 SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 5986 5987 public: 5988 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, 5989 unsigned PriorGeneration) 5990 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { } 5991 5992 static bool visit(ModuleFile &M, void *UserData) { 5993 ReadMethodPoolVisitor *This 5994 = static_cast<ReadMethodPoolVisitor *>(UserData); 5995 5996 if (!M.SelectorLookupTable) 5997 return false; 5998 5999 // If we've already searched this module file, skip it now. 6000 if (M.Generation <= This->PriorGeneration) 6001 return true; 6002 6003 ++This->Reader.NumMethodPoolTableLookups; 6004 ASTSelectorLookupTable *PoolTable 6005 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 6006 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 6007 if (Pos == PoolTable->end()) 6008 return false; 6009 6010 ++This->Reader.NumMethodPoolTableHits; 6011 ++This->Reader.NumSelectorsRead; 6012 // FIXME: Not quite happy with the statistics here. We probably should 6013 // disable this tracking when called via LoadSelector. 6014 // Also, should entries without methods count as misses? 6015 ++This->Reader.NumMethodPoolEntriesRead; 6016 ASTSelectorLookupTrait::data_type Data = *Pos; 6017 if (This->Reader.DeserializationListener) 6018 This->Reader.DeserializationListener->SelectorRead(Data.ID, 6019 This->Sel); 6020 6021 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 6022 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 6023 return true; 6024 } 6025 6026 /// \brief Retrieve the instance methods found by this visitor. 6027 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const { 6028 return InstanceMethods; 6029 } 6030 6031 /// \brief Retrieve the instance methods found by this visitor. 6032 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const { 6033 return FactoryMethods; 6034 } 6035 }; 6036} } // end namespace clang::serialization 6037 6038/// \brief Add the given set of methods to the method list. 6039static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods, 6040 ObjCMethodList &List) { 6041 for (unsigned I = 0, N = Methods.size(); I != N; ++I) { 6042 S.addMethodToGlobalList(&List, Methods[I]); 6043 } 6044} 6045 6046void ASTReader::ReadMethodPool(Selector Sel) { 6047 // Get the selector generation and update it to the current generation. 6048 unsigned &Generation = SelectorGeneration[Sel]; 6049 unsigned PriorGeneration = Generation; 6050 Generation = CurrentGeneration; 6051 6052 // Search for methods defined with this selector. 6053 ++NumMethodPoolLookups; 6054 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration); 6055 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 6056 6057 if (Visitor.getInstanceMethods().empty() && 6058 Visitor.getFactoryMethods().empty()) 6059 return; 6060 6061 ++NumMethodPoolHits; 6062 6063 if (!getSema()) 6064 return; 6065 6066 Sema &S = *getSema(); 6067 Sema::GlobalMethodPool::iterator Pos 6068 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first; 6069 6070 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first); 6071 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second); 6072} 6073 6074void ASTReader::ReadKnownNamespaces( 6075 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 6076 Namespaces.clear(); 6077 6078 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 6079 if (NamespaceDecl *Namespace 6080 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 6081 Namespaces.push_back(Namespace); 6082 } 6083} 6084 6085void ASTReader::ReadUndefinedButUsed( 6086 llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) { 6087 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) { 6088 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++])); 6089 SourceLocation Loc = 6090 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]); 6091 Undefined.insert(std::make_pair(D, Loc)); 6092 } 6093} 6094 6095void ASTReader::ReadTentativeDefinitions( 6096 SmallVectorImpl<VarDecl *> &TentativeDefs) { 6097 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 6098 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 6099 if (Var) 6100 TentativeDefs.push_back(Var); 6101 } 6102 TentativeDefinitions.clear(); 6103} 6104 6105void ASTReader::ReadUnusedFileScopedDecls( 6106 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 6107 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 6108 DeclaratorDecl *D 6109 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 6110 if (D) 6111 Decls.push_back(D); 6112 } 6113 UnusedFileScopedDecls.clear(); 6114} 6115 6116void ASTReader::ReadDelegatingConstructors( 6117 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 6118 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 6119 CXXConstructorDecl *D 6120 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 6121 if (D) 6122 Decls.push_back(D); 6123 } 6124 DelegatingCtorDecls.clear(); 6125} 6126 6127void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 6128 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 6129 TypedefNameDecl *D 6130 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 6131 if (D) 6132 Decls.push_back(D); 6133 } 6134 ExtVectorDecls.clear(); 6135} 6136 6137void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 6138 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 6139 CXXRecordDecl *D 6140 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 6141 if (D) 6142 Decls.push_back(D); 6143 } 6144 DynamicClasses.clear(); 6145} 6146 6147void 6148ASTReader::ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl *> &Decls) { 6149 for (unsigned I = 0, N = LocallyScopedExternCDecls.size(); I != N; ++I) { 6150 NamedDecl *D 6151 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternCDecls[I])); 6152 if (D) 6153 Decls.push_back(D); 6154 } 6155 LocallyScopedExternCDecls.clear(); 6156} 6157 6158void ASTReader::ReadReferencedSelectors( 6159 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 6160 if (ReferencedSelectorsData.empty()) 6161 return; 6162 6163 // If there are @selector references added them to its pool. This is for 6164 // implementation of -Wselector. 6165 unsigned int DataSize = ReferencedSelectorsData.size()-1; 6166 unsigned I = 0; 6167 while (I < DataSize) { 6168 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 6169 SourceLocation SelLoc 6170 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 6171 Sels.push_back(std::make_pair(Sel, SelLoc)); 6172 } 6173 ReferencedSelectorsData.clear(); 6174} 6175 6176void ASTReader::ReadWeakUndeclaredIdentifiers( 6177 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 6178 if (WeakUndeclaredIdentifiers.empty()) 6179 return; 6180 6181 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 6182 IdentifierInfo *WeakId 6183 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6184 IdentifierInfo *AliasId 6185 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6186 SourceLocation Loc 6187 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 6188 bool Used = WeakUndeclaredIdentifiers[I++]; 6189 WeakInfo WI(AliasId, Loc); 6190 WI.setUsed(Used); 6191 WeakIDs.push_back(std::make_pair(WeakId, WI)); 6192 } 6193 WeakUndeclaredIdentifiers.clear(); 6194} 6195 6196void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 6197 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 6198 ExternalVTableUse VT; 6199 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 6200 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 6201 VT.DefinitionRequired = VTableUses[Idx++]; 6202 VTables.push_back(VT); 6203 } 6204 6205 VTableUses.clear(); 6206} 6207 6208void ASTReader::ReadPendingInstantiations( 6209 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 6210 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 6211 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 6212 SourceLocation Loc 6213 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 6214 6215 Pending.push_back(std::make_pair(D, Loc)); 6216 } 6217 PendingInstantiations.clear(); 6218} 6219 6220void ASTReader::LoadSelector(Selector Sel) { 6221 // It would be complicated to avoid reading the methods anyway. So don't. 6222 ReadMethodPool(Sel); 6223} 6224 6225void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 6226 assert(ID && "Non-zero identifier ID required"); 6227 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 6228 IdentifiersLoaded[ID - 1] = II; 6229 if (DeserializationListener) 6230 DeserializationListener->IdentifierRead(ID, II); 6231} 6232 6233/// \brief Set the globally-visible declarations associated with the given 6234/// identifier. 6235/// 6236/// If the AST reader is currently in a state where the given declaration IDs 6237/// cannot safely be resolved, they are queued until it is safe to resolve 6238/// them. 6239/// 6240/// \param II an IdentifierInfo that refers to one or more globally-visible 6241/// declarations. 6242/// 6243/// \param DeclIDs the set of declaration IDs with the name @p II that are 6244/// visible at global scope. 6245/// 6246/// \param Decls if non-null, this vector will be populated with the set of 6247/// deserialized declarations. These declarations will not be pushed into 6248/// scope. 6249void 6250ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 6251 const SmallVectorImpl<uint32_t> &DeclIDs, 6252 SmallVectorImpl<Decl *> *Decls) { 6253 if (NumCurrentElementsDeserializing && !Decls) { 6254 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end()); 6255 return; 6256 } 6257 6258 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 6259 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 6260 if (SemaObj) { 6261 // If we're simply supposed to record the declarations, do so now. 6262 if (Decls) { 6263 Decls->push_back(D); 6264 continue; 6265 } 6266 6267 // Introduce this declaration into the translation-unit scope 6268 // and add it to the declaration chain for this identifier, so 6269 // that (unqualified) name lookup will find it. 6270 NamedDecl *ND = cast<NamedDecl>(D->getMostRecentDecl()); 6271 SemaObj->pushExternalDeclIntoScope(ND, II); 6272 } else { 6273 // Queue this declaration so that it will be added to the 6274 // translation unit scope and identifier's declaration chain 6275 // once a Sema object is known. 6276 PreloadedDecls.push_back(D); 6277 } 6278 } 6279} 6280 6281IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 6282 if (ID == 0) 6283 return 0; 6284 6285 if (IdentifiersLoaded.empty()) { 6286 Error("no identifier table in AST file"); 6287 return 0; 6288 } 6289 6290 ID -= 1; 6291 if (!IdentifiersLoaded[ID]) { 6292 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 6293 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 6294 ModuleFile *M = I->second; 6295 unsigned Index = ID - M->BaseIdentifierID; 6296 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 6297 6298 // All of the strings in the AST file are preceded by a 16-bit length. 6299 // Extract that 16-bit length to avoid having to execute strlen(). 6300 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 6301 // unsigned integers. This is important to avoid integer overflow when 6302 // we cast them to 'unsigned'. 6303 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 6304 unsigned StrLen = (((unsigned) StrLenPtr[0]) 6305 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 6306 IdentifiersLoaded[ID] 6307 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 6308 if (DeserializationListener) 6309 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 6310 } 6311 6312 return IdentifiersLoaded[ID]; 6313} 6314 6315IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 6316 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 6317} 6318 6319IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 6320 if (LocalID < NUM_PREDEF_IDENT_IDS) 6321 return LocalID; 6322 6323 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6324 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 6325 assert(I != M.IdentifierRemap.end() 6326 && "Invalid index into identifier index remap"); 6327 6328 return LocalID + I->second; 6329} 6330 6331MacroDirective *ASTReader::getMacro(MacroID ID, MacroDirective *Hint) { 6332 if (ID == 0) 6333 return 0; 6334 6335 if (MacrosLoaded.empty()) { 6336 Error("no macro table in AST file"); 6337 return 0; 6338 } 6339 6340 ID -= NUM_PREDEF_MACRO_IDS; 6341 if (!MacrosLoaded[ID]) { 6342 GlobalMacroMapType::iterator I 6343 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS); 6344 assert(I != GlobalMacroMap.end() && "Corrupted global macro map"); 6345 ModuleFile *M = I->second; 6346 unsigned Index = ID - M->BaseMacroID; 6347 ReadMacroRecord(*M, M->MacroOffsets[Index], Hint); 6348 } 6349 6350 return MacrosLoaded[ID]; 6351} 6352 6353MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) { 6354 if (LocalID < NUM_PREDEF_MACRO_IDS) 6355 return LocalID; 6356 6357 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6358 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS); 6359 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap"); 6360 6361 return LocalID + I->second; 6362} 6363 6364serialization::SubmoduleID 6365ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 6366 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 6367 return LocalID; 6368 6369 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6370 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 6371 assert(I != M.SubmoduleRemap.end() 6372 && "Invalid index into submodule index remap"); 6373 6374 return LocalID + I->second; 6375} 6376 6377Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 6378 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 6379 assert(GlobalID == 0 && "Unhandled global submodule ID"); 6380 return 0; 6381 } 6382 6383 if (GlobalID > SubmodulesLoaded.size()) { 6384 Error("submodule ID out of range in AST file"); 6385 return 0; 6386 } 6387 6388 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 6389} 6390 6391Module *ASTReader::getModule(unsigned ID) { 6392 return getSubmodule(ID); 6393} 6394 6395Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 6396 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 6397} 6398 6399Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 6400 if (ID == 0) 6401 return Selector(); 6402 6403 if (ID > SelectorsLoaded.size()) { 6404 Error("selector ID out of range in AST file"); 6405 return Selector(); 6406 } 6407 6408 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 6409 // Load this selector from the selector table. 6410 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 6411 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 6412 ModuleFile &M = *I->second; 6413 ASTSelectorLookupTrait Trait(*this, M); 6414 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 6415 SelectorsLoaded[ID - 1] = 6416 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 6417 if (DeserializationListener) 6418 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 6419 } 6420 6421 return SelectorsLoaded[ID - 1]; 6422} 6423 6424Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 6425 return DecodeSelector(ID); 6426} 6427 6428uint32_t ASTReader::GetNumExternalSelectors() { 6429 // ID 0 (the null selector) is considered an external selector. 6430 return getTotalNumSelectors() + 1; 6431} 6432 6433serialization::SelectorID 6434ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 6435 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 6436 return LocalID; 6437 6438 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6439 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 6440 assert(I != M.SelectorRemap.end() 6441 && "Invalid index into selector index remap"); 6442 6443 return LocalID + I->second; 6444} 6445 6446DeclarationName 6447ASTReader::ReadDeclarationName(ModuleFile &F, 6448 const RecordData &Record, unsigned &Idx) { 6449 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 6450 switch (Kind) { 6451 case DeclarationName::Identifier: 6452 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 6453 6454 case DeclarationName::ObjCZeroArgSelector: 6455 case DeclarationName::ObjCOneArgSelector: 6456 case DeclarationName::ObjCMultiArgSelector: 6457 return DeclarationName(ReadSelector(F, Record, Idx)); 6458 6459 case DeclarationName::CXXConstructorName: 6460 return Context.DeclarationNames.getCXXConstructorName( 6461 Context.getCanonicalType(readType(F, Record, Idx))); 6462 6463 case DeclarationName::CXXDestructorName: 6464 return Context.DeclarationNames.getCXXDestructorName( 6465 Context.getCanonicalType(readType(F, Record, Idx))); 6466 6467 case DeclarationName::CXXConversionFunctionName: 6468 return Context.DeclarationNames.getCXXConversionFunctionName( 6469 Context.getCanonicalType(readType(F, Record, Idx))); 6470 6471 case DeclarationName::CXXOperatorName: 6472 return Context.DeclarationNames.getCXXOperatorName( 6473 (OverloadedOperatorKind)Record[Idx++]); 6474 6475 case DeclarationName::CXXLiteralOperatorName: 6476 return Context.DeclarationNames.getCXXLiteralOperatorName( 6477 GetIdentifierInfo(F, Record, Idx)); 6478 6479 case DeclarationName::CXXUsingDirective: 6480 return DeclarationName::getUsingDirectiveName(); 6481 } 6482 6483 llvm_unreachable("Invalid NameKind!"); 6484} 6485 6486void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 6487 DeclarationNameLoc &DNLoc, 6488 DeclarationName Name, 6489 const RecordData &Record, unsigned &Idx) { 6490 switch (Name.getNameKind()) { 6491 case DeclarationName::CXXConstructorName: 6492 case DeclarationName::CXXDestructorName: 6493 case DeclarationName::CXXConversionFunctionName: 6494 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 6495 break; 6496 6497 case DeclarationName::CXXOperatorName: 6498 DNLoc.CXXOperatorName.BeginOpNameLoc 6499 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6500 DNLoc.CXXOperatorName.EndOpNameLoc 6501 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6502 break; 6503 6504 case DeclarationName::CXXLiteralOperatorName: 6505 DNLoc.CXXLiteralOperatorName.OpNameLoc 6506 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6507 break; 6508 6509 case DeclarationName::Identifier: 6510 case DeclarationName::ObjCZeroArgSelector: 6511 case DeclarationName::ObjCOneArgSelector: 6512 case DeclarationName::ObjCMultiArgSelector: 6513 case DeclarationName::CXXUsingDirective: 6514 break; 6515 } 6516} 6517 6518void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 6519 DeclarationNameInfo &NameInfo, 6520 const RecordData &Record, unsigned &Idx) { 6521 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 6522 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 6523 DeclarationNameLoc DNLoc; 6524 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 6525 NameInfo.setInfo(DNLoc); 6526} 6527 6528void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 6529 const RecordData &Record, unsigned &Idx) { 6530 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 6531 unsigned NumTPLists = Record[Idx++]; 6532 Info.NumTemplParamLists = NumTPLists; 6533 if (NumTPLists) { 6534 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 6535 for (unsigned i=0; i != NumTPLists; ++i) 6536 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 6537 } 6538} 6539 6540TemplateName 6541ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 6542 unsigned &Idx) { 6543 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 6544 switch (Kind) { 6545 case TemplateName::Template: 6546 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 6547 6548 case TemplateName::OverloadedTemplate: { 6549 unsigned size = Record[Idx++]; 6550 UnresolvedSet<8> Decls; 6551 while (size--) 6552 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6553 6554 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 6555 } 6556 6557 case TemplateName::QualifiedTemplate: { 6558 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6559 bool hasTemplKeyword = Record[Idx++]; 6560 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 6561 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 6562 } 6563 6564 case TemplateName::DependentTemplate: { 6565 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6566 if (Record[Idx++]) // isIdentifier 6567 return Context.getDependentTemplateName(NNS, 6568 GetIdentifierInfo(F, Record, 6569 Idx)); 6570 return Context.getDependentTemplateName(NNS, 6571 (OverloadedOperatorKind)Record[Idx++]); 6572 } 6573 6574 case TemplateName::SubstTemplateTemplateParm: { 6575 TemplateTemplateParmDecl *param 6576 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6577 if (!param) return TemplateName(); 6578 TemplateName replacement = ReadTemplateName(F, Record, Idx); 6579 return Context.getSubstTemplateTemplateParm(param, replacement); 6580 } 6581 6582 case TemplateName::SubstTemplateTemplateParmPack: { 6583 TemplateTemplateParmDecl *Param 6584 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6585 if (!Param) 6586 return TemplateName(); 6587 6588 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 6589 if (ArgPack.getKind() != TemplateArgument::Pack) 6590 return TemplateName(); 6591 6592 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 6593 } 6594 } 6595 6596 llvm_unreachable("Unhandled template name kind!"); 6597} 6598 6599TemplateArgument 6600ASTReader::ReadTemplateArgument(ModuleFile &F, 6601 const RecordData &Record, unsigned &Idx) { 6602 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 6603 switch (Kind) { 6604 case TemplateArgument::Null: 6605 return TemplateArgument(); 6606 case TemplateArgument::Type: 6607 return TemplateArgument(readType(F, Record, Idx)); 6608 case TemplateArgument::Declaration: { 6609 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx); 6610 bool ForReferenceParam = Record[Idx++]; 6611 return TemplateArgument(D, ForReferenceParam); 6612 } 6613 case TemplateArgument::NullPtr: 6614 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true); 6615 case TemplateArgument::Integral: { 6616 llvm::APSInt Value = ReadAPSInt(Record, Idx); 6617 QualType T = readType(F, Record, Idx); 6618 return TemplateArgument(Context, Value, T); 6619 } 6620 case TemplateArgument::Template: 6621 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 6622 case TemplateArgument::TemplateExpansion: { 6623 TemplateName Name = ReadTemplateName(F, Record, Idx); 6624 Optional<unsigned> NumTemplateExpansions; 6625 if (unsigned NumExpansions = Record[Idx++]) 6626 NumTemplateExpansions = NumExpansions - 1; 6627 return TemplateArgument(Name, NumTemplateExpansions); 6628 } 6629 case TemplateArgument::Expression: 6630 return TemplateArgument(ReadExpr(F)); 6631 case TemplateArgument::Pack: { 6632 unsigned NumArgs = Record[Idx++]; 6633 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 6634 for (unsigned I = 0; I != NumArgs; ++I) 6635 Args[I] = ReadTemplateArgument(F, Record, Idx); 6636 return TemplateArgument(Args, NumArgs); 6637 } 6638 } 6639 6640 llvm_unreachable("Unhandled template argument kind!"); 6641} 6642 6643TemplateParameterList * 6644ASTReader::ReadTemplateParameterList(ModuleFile &F, 6645 const RecordData &Record, unsigned &Idx) { 6646 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 6647 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 6648 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 6649 6650 unsigned NumParams = Record[Idx++]; 6651 SmallVector<NamedDecl *, 16> Params; 6652 Params.reserve(NumParams); 6653 while (NumParams--) 6654 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6655 6656 TemplateParameterList* TemplateParams = 6657 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 6658 Params.data(), Params.size(), RAngleLoc); 6659 return TemplateParams; 6660} 6661 6662void 6663ASTReader:: 6664ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 6665 ModuleFile &F, const RecordData &Record, 6666 unsigned &Idx) { 6667 unsigned NumTemplateArgs = Record[Idx++]; 6668 TemplArgs.reserve(NumTemplateArgs); 6669 while (NumTemplateArgs--) 6670 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 6671} 6672 6673/// \brief Read a UnresolvedSet structure. 6674void ASTReader::ReadUnresolvedSet(ModuleFile &F, ASTUnresolvedSet &Set, 6675 const RecordData &Record, unsigned &Idx) { 6676 unsigned NumDecls = Record[Idx++]; 6677 Set.reserve(Context, NumDecls); 6678 while (NumDecls--) { 6679 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 6680 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 6681 Set.addDecl(Context, D, AS); 6682 } 6683} 6684 6685CXXBaseSpecifier 6686ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 6687 const RecordData &Record, unsigned &Idx) { 6688 bool isVirtual = static_cast<bool>(Record[Idx++]); 6689 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 6690 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 6691 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 6692 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 6693 SourceRange Range = ReadSourceRange(F, Record, Idx); 6694 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 6695 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 6696 EllipsisLoc); 6697 Result.setInheritConstructors(inheritConstructors); 6698 return Result; 6699} 6700 6701std::pair<CXXCtorInitializer **, unsigned> 6702ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 6703 unsigned &Idx) { 6704 CXXCtorInitializer **CtorInitializers = 0; 6705 unsigned NumInitializers = Record[Idx++]; 6706 if (NumInitializers) { 6707 CtorInitializers 6708 = new (Context) CXXCtorInitializer*[NumInitializers]; 6709 for (unsigned i=0; i != NumInitializers; ++i) { 6710 TypeSourceInfo *TInfo = 0; 6711 bool IsBaseVirtual = false; 6712 FieldDecl *Member = 0; 6713 IndirectFieldDecl *IndirectMember = 0; 6714 6715 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 6716 switch (Type) { 6717 case CTOR_INITIALIZER_BASE: 6718 TInfo = GetTypeSourceInfo(F, Record, Idx); 6719 IsBaseVirtual = Record[Idx++]; 6720 break; 6721 6722 case CTOR_INITIALIZER_DELEGATING: 6723 TInfo = GetTypeSourceInfo(F, Record, Idx); 6724 break; 6725 6726 case CTOR_INITIALIZER_MEMBER: 6727 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 6728 break; 6729 6730 case CTOR_INITIALIZER_INDIRECT_MEMBER: 6731 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 6732 break; 6733 } 6734 6735 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 6736 Expr *Init = ReadExpr(F); 6737 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 6738 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 6739 bool IsWritten = Record[Idx++]; 6740 unsigned SourceOrderOrNumArrayIndices; 6741 SmallVector<VarDecl *, 8> Indices; 6742 if (IsWritten) { 6743 SourceOrderOrNumArrayIndices = Record[Idx++]; 6744 } else { 6745 SourceOrderOrNumArrayIndices = Record[Idx++]; 6746 Indices.reserve(SourceOrderOrNumArrayIndices); 6747 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 6748 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 6749 } 6750 6751 CXXCtorInitializer *BOMInit; 6752 if (Type == CTOR_INITIALIZER_BASE) { 6753 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 6754 LParenLoc, Init, RParenLoc, 6755 MemberOrEllipsisLoc); 6756 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 6757 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 6758 Init, RParenLoc); 6759 } else if (IsWritten) { 6760 if (Member) 6761 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 6762 LParenLoc, Init, RParenLoc); 6763 else 6764 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 6765 MemberOrEllipsisLoc, LParenLoc, 6766 Init, RParenLoc); 6767 } else { 6768 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 6769 LParenLoc, Init, RParenLoc, 6770 Indices.data(), Indices.size()); 6771 } 6772 6773 if (IsWritten) 6774 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 6775 CtorInitializers[i] = BOMInit; 6776 } 6777 } 6778 6779 return std::make_pair(CtorInitializers, NumInitializers); 6780} 6781 6782NestedNameSpecifier * 6783ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 6784 const RecordData &Record, unsigned &Idx) { 6785 unsigned N = Record[Idx++]; 6786 NestedNameSpecifier *NNS = 0, *Prev = 0; 6787 for (unsigned I = 0; I != N; ++I) { 6788 NestedNameSpecifier::SpecifierKind Kind 6789 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6790 switch (Kind) { 6791 case NestedNameSpecifier::Identifier: { 6792 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6793 NNS = NestedNameSpecifier::Create(Context, Prev, II); 6794 break; 6795 } 6796 6797 case NestedNameSpecifier::Namespace: { 6798 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6799 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 6800 break; 6801 } 6802 6803 case NestedNameSpecifier::NamespaceAlias: { 6804 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6805 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 6806 break; 6807 } 6808 6809 case NestedNameSpecifier::TypeSpec: 6810 case NestedNameSpecifier::TypeSpecWithTemplate: { 6811 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 6812 if (!T) 6813 return 0; 6814 6815 bool Template = Record[Idx++]; 6816 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 6817 break; 6818 } 6819 6820 case NestedNameSpecifier::Global: { 6821 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 6822 // No associated value, and there can't be a prefix. 6823 break; 6824 } 6825 } 6826 Prev = NNS; 6827 } 6828 return NNS; 6829} 6830 6831NestedNameSpecifierLoc 6832ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 6833 unsigned &Idx) { 6834 unsigned N = Record[Idx++]; 6835 NestedNameSpecifierLocBuilder Builder; 6836 for (unsigned I = 0; I != N; ++I) { 6837 NestedNameSpecifier::SpecifierKind Kind 6838 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6839 switch (Kind) { 6840 case NestedNameSpecifier::Identifier: { 6841 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6842 SourceRange Range = ReadSourceRange(F, Record, Idx); 6843 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 6844 break; 6845 } 6846 6847 case NestedNameSpecifier::Namespace: { 6848 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6849 SourceRange Range = ReadSourceRange(F, Record, Idx); 6850 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 6851 break; 6852 } 6853 6854 case NestedNameSpecifier::NamespaceAlias: { 6855 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6856 SourceRange Range = ReadSourceRange(F, Record, Idx); 6857 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 6858 break; 6859 } 6860 6861 case NestedNameSpecifier::TypeSpec: 6862 case NestedNameSpecifier::TypeSpecWithTemplate: { 6863 bool Template = Record[Idx++]; 6864 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 6865 if (!T) 6866 return NestedNameSpecifierLoc(); 6867 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6868 6869 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 6870 Builder.Extend(Context, 6871 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 6872 T->getTypeLoc(), ColonColonLoc); 6873 break; 6874 } 6875 6876 case NestedNameSpecifier::Global: { 6877 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6878 Builder.MakeGlobal(Context, ColonColonLoc); 6879 break; 6880 } 6881 } 6882 } 6883 6884 return Builder.getWithLocInContext(Context); 6885} 6886 6887SourceRange 6888ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 6889 unsigned &Idx) { 6890 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 6891 SourceLocation end = ReadSourceLocation(F, Record, Idx); 6892 return SourceRange(beg, end); 6893} 6894 6895/// \brief Read an integral value 6896llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 6897 unsigned BitWidth = Record[Idx++]; 6898 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 6899 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 6900 Idx += NumWords; 6901 return Result; 6902} 6903 6904/// \brief Read a signed integral value 6905llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 6906 bool isUnsigned = Record[Idx++]; 6907 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 6908} 6909 6910/// \brief Read a floating-point value 6911llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, 6912 const llvm::fltSemantics &Sem, 6913 unsigned &Idx) { 6914 return llvm::APFloat(Sem, ReadAPInt(Record, Idx)); 6915} 6916 6917// \brief Read a string 6918std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 6919 unsigned Len = Record[Idx++]; 6920 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 6921 Idx += Len; 6922 return Result; 6923} 6924 6925VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 6926 unsigned &Idx) { 6927 unsigned Major = Record[Idx++]; 6928 unsigned Minor = Record[Idx++]; 6929 unsigned Subminor = Record[Idx++]; 6930 if (Minor == 0) 6931 return VersionTuple(Major); 6932 if (Subminor == 0) 6933 return VersionTuple(Major, Minor - 1); 6934 return VersionTuple(Major, Minor - 1, Subminor - 1); 6935} 6936 6937CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 6938 const RecordData &Record, 6939 unsigned &Idx) { 6940 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 6941 return CXXTemporary::Create(Context, Decl); 6942} 6943 6944DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 6945 return Diag(SourceLocation(), DiagID); 6946} 6947 6948DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 6949 return Diags.Report(Loc, DiagID); 6950} 6951 6952/// \brief Retrieve the identifier table associated with the 6953/// preprocessor. 6954IdentifierTable &ASTReader::getIdentifierTable() { 6955 return PP.getIdentifierTable(); 6956} 6957 6958/// \brief Record that the given ID maps to the given switch-case 6959/// statement. 6960void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 6961 assert((*CurrSwitchCaseStmts)[ID] == 0 && 6962 "Already have a SwitchCase with this ID"); 6963 (*CurrSwitchCaseStmts)[ID] = SC; 6964} 6965 6966/// \brief Retrieve the switch-case statement with the given ID. 6967SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 6968 assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID"); 6969 return (*CurrSwitchCaseStmts)[ID]; 6970} 6971 6972void ASTReader::ClearSwitchCaseIDs() { 6973 CurrSwitchCaseStmts->clear(); 6974} 6975 6976void ASTReader::ReadComments() { 6977 std::vector<RawComment *> Comments; 6978 for (SmallVectorImpl<std::pair<BitstreamCursor, 6979 serialization::ModuleFile *> >::iterator 6980 I = CommentsCursors.begin(), 6981 E = CommentsCursors.end(); 6982 I != E; ++I) { 6983 BitstreamCursor &Cursor = I->first; 6984 serialization::ModuleFile &F = *I->second; 6985 SavedStreamPosition SavedPosition(Cursor); 6986 6987 RecordData Record; 6988 while (true) { 6989 llvm::BitstreamEntry Entry = 6990 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd); 6991 6992 switch (Entry.Kind) { 6993 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 6994 case llvm::BitstreamEntry::Error: 6995 Error("malformed block record in AST file"); 6996 return; 6997 case llvm::BitstreamEntry::EndBlock: 6998 goto NextCursor; 6999 case llvm::BitstreamEntry::Record: 7000 // The interesting case. 7001 break; 7002 } 7003 7004 // Read a record. 7005 Record.clear(); 7006 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) { 7007 case COMMENTS_RAW_COMMENT: { 7008 unsigned Idx = 0; 7009 SourceRange SR = ReadSourceRange(F, Record, Idx); 7010 RawComment::CommentKind Kind = 7011 (RawComment::CommentKind) Record[Idx++]; 7012 bool IsTrailingComment = Record[Idx++]; 7013 bool IsAlmostTrailingComment = Record[Idx++]; 7014 Comments.push_back(new (Context) RawComment(SR, Kind, 7015 IsTrailingComment, 7016 IsAlmostTrailingComment)); 7017 break; 7018 } 7019 } 7020 } 7021 NextCursor:; 7022 } 7023 Context.Comments.addCommentsToFront(Comments); 7024} 7025 7026void ASTReader::finishPendingActions() { 7027 while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty() || 7028 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty()) { 7029 // If any identifiers with corresponding top-level declarations have 7030 // been loaded, load those declarations now. 7031 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> > TopLevelDecls; 7032 while (!PendingIdentifierInfos.empty()) { 7033 // FIXME: std::move 7034 IdentifierInfo *II = PendingIdentifierInfos.back().first; 7035 SmallVector<uint32_t, 4> DeclIDs = PendingIdentifierInfos.back().second; 7036 PendingIdentifierInfos.pop_back(); 7037 7038 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]); 7039 } 7040 7041 // Load pending declaration chains. 7042 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 7043 loadPendingDeclChain(PendingDeclChains[I]); 7044 PendingDeclChainsKnown.erase(PendingDeclChains[I]); 7045 } 7046 PendingDeclChains.clear(); 7047 7048 // Make the most recent of the top-level declarations visible. 7049 for (llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >::iterator 7050 TLD = TopLevelDecls.begin(), TLDEnd = TopLevelDecls.end(); 7051 TLD != TLDEnd; ++TLD) { 7052 IdentifierInfo *II = TLD->first; 7053 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) { 7054 NamedDecl *ND = cast<NamedDecl>(TLD->second[I]->getMostRecentDecl()); 7055 SemaObj->pushExternalDeclIntoScope(ND, II); 7056 } 7057 } 7058 7059 // Load any pending macro definitions. 7060 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) { 7061 // FIXME: std::move here 7062 SmallVector<MacroID, 2> GlobalIDs = PendingMacroIDs.begin()[I].second; 7063 MacroDirective *Hint = 0; 7064 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 7065 ++IDIdx) { 7066 Hint = getMacro(GlobalIDs[IDIdx], Hint); 7067 } 7068 } 7069 PendingMacroIDs.clear(); 7070 7071 // Wire up the DeclContexts for Decls that we delayed setting until 7072 // recursive loading is completed. 7073 while (!PendingDeclContextInfos.empty()) { 7074 PendingDeclContextInfo Info = PendingDeclContextInfos.front(); 7075 PendingDeclContextInfos.pop_front(); 7076 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC)); 7077 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC)); 7078 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext()); 7079 } 7080 } 7081 7082 // If we deserialized any C++ or Objective-C class definitions, any 7083 // Objective-C protocol definitions, or any redeclarable templates, make sure 7084 // that all redeclarations point to the definitions. Note that this can only 7085 // happen now, after the redeclaration chains have been fully wired. 7086 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(), 7087 DEnd = PendingDefinitions.end(); 7088 D != DEnd; ++D) { 7089 if (TagDecl *TD = dyn_cast<TagDecl>(*D)) { 7090 if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) { 7091 // Make sure that the TagType points at the definition. 7092 const_cast<TagType*>(TagT)->decl = TD; 7093 } 7094 7095 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) { 7096 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(), 7097 REnd = RD->redecls_end(); 7098 R != REnd; ++R) 7099 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData; 7100 7101 } 7102 7103 continue; 7104 } 7105 7106 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) { 7107 // Make sure that the ObjCInterfaceType points at the definition. 7108 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl)) 7109 ->Decl = ID; 7110 7111 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(), 7112 REnd = ID->redecls_end(); 7113 R != REnd; ++R) 7114 R->Data = ID->Data; 7115 7116 continue; 7117 } 7118 7119 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) { 7120 for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(), 7121 REnd = PD->redecls_end(); 7122 R != REnd; ++R) 7123 R->Data = PD->Data; 7124 7125 continue; 7126 } 7127 7128 RedeclarableTemplateDecl *RTD 7129 = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl(); 7130 for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(), 7131 REnd = RTD->redecls_end(); 7132 R != REnd; ++R) 7133 R->Common = RTD->Common; 7134 } 7135 PendingDefinitions.clear(); 7136 7137 // Load the bodies of any functions or methods we've encountered. We do 7138 // this now (delayed) so that we can be sure that the declaration chains 7139 // have been fully wired up. 7140 for (PendingBodiesMap::iterator PB = PendingBodies.begin(), 7141 PBEnd = PendingBodies.end(); 7142 PB != PBEnd; ++PB) { 7143 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) { 7144 // FIXME: Check for =delete/=default? 7145 // FIXME: Complain about ODR violations here? 7146 if (!getContext().getLangOpts().Modules || !FD->hasBody()) 7147 FD->setLazyBody(PB->second); 7148 continue; 7149 } 7150 7151 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first); 7152 if (!getContext().getLangOpts().Modules || !MD->hasBody()) 7153 MD->setLazyBody(PB->second); 7154 } 7155 PendingBodies.clear(); 7156} 7157 7158void ASTReader::FinishedDeserializing() { 7159 assert(NumCurrentElementsDeserializing && 7160 "FinishedDeserializing not paired with StartedDeserializing"); 7161 if (NumCurrentElementsDeserializing == 1) { 7162 // We decrease NumCurrentElementsDeserializing only after pending actions 7163 // are finished, to avoid recursively re-calling finishPendingActions(). 7164 finishPendingActions(); 7165 } 7166 --NumCurrentElementsDeserializing; 7167 7168 if (NumCurrentElementsDeserializing == 0 && 7169 Consumer && !PassingDeclsToConsumer) { 7170 // Guard variable to avoid recursively redoing the process of passing 7171 // decls to consumer. 7172 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer, 7173 true); 7174 7175 while (!InterestingDecls.empty()) { 7176 // We are not in recursive loading, so it's safe to pass the "interesting" 7177 // decls to the consumer. 7178 Decl *D = InterestingDecls.front(); 7179 InterestingDecls.pop_front(); 7180 PassInterestingDeclToConsumer(D); 7181 } 7182 } 7183} 7184 7185ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 7186 StringRef isysroot, bool DisableValidation, 7187 bool AllowASTWithCompilerErrors, bool UseGlobalIndex) 7188 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 7189 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 7190 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 7191 Consumer(0), ModuleMgr(PP.getFileManager()), 7192 isysroot(isysroot), DisableValidation(DisableValidation), 7193 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), 7194 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false), 7195 CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts), 7196 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 7197 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 7198 TotalNumMacros(0), NumIdentifierLookups(0), NumIdentifierLookupHits(0), 7199 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 7200 NumMethodPoolLookups(0), NumMethodPoolHits(0), 7201 NumMethodPoolTableLookups(0), NumMethodPoolTableHits(0), 7202 TotalNumMethodPoolEntries(0), 7203 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 7204 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 7205 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 7206 PassingDeclsToConsumer(false), 7207 NumCXXBaseSpecifiersLoaded(0) 7208{ 7209 SourceMgr.setExternalSLocEntrySource(this); 7210} 7211 7212ASTReader::~ASTReader() { 7213 for (DeclContextVisibleUpdatesPending::iterator 7214 I = PendingVisibleUpdates.begin(), 7215 E = PendingVisibleUpdates.end(); 7216 I != E; ++I) { 7217 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 7218 F = I->second.end(); 7219 J != F; ++J) 7220 delete J->first; 7221 } 7222} 7223