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