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