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