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