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