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