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