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