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