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