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