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