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