ASTReader.cpp revision b86b8dc7ef89405205f94635c1073cdb1a7093eb
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 unsigned Length = Record[Idx++]; 2793 LangOpts.CurrentModule.assign(Record.begin() + Idx, 2794 Record.begin() + Idx + Length); 2795 Idx += Length; 2796 return Listener->ReadLanguageOptions(LangOpts); 2797 } 2798 2799 return false; 2800} 2801 2802std::pair<Module *, unsigned> 2803ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 2804 GlobalPreprocessedEntityMapType::iterator 2805 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 2806 assert(I != GlobalPreprocessedEntityMap.end() && 2807 "Corrupted global preprocessed entity map"); 2808 Module *M = I->second; 2809 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 2810 return std::make_pair(M, LocalIndex); 2811} 2812 2813PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 2814 PreprocessedEntityID PPID = Index+1; 2815 std::pair<Module *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 2816 Module &M = *PPInfo.first; 2817 unsigned LocalIndex = PPInfo.second; 2818 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 2819 2820 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 2821 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 2822 2823 unsigned Code = M.PreprocessorDetailCursor.ReadCode(); 2824 switch (Code) { 2825 case llvm::bitc::END_BLOCK: 2826 return 0; 2827 2828 case llvm::bitc::ENTER_SUBBLOCK: 2829 Error("unexpected subblock record in preprocessor detail block"); 2830 return 0; 2831 2832 case llvm::bitc::DEFINE_ABBREV: 2833 Error("unexpected abbrevation record in preprocessor detail block"); 2834 return 0; 2835 2836 default: 2837 break; 2838 } 2839 2840 if (!PP.getPreprocessingRecord()) { 2841 Error("no preprocessing record"); 2842 return 0; 2843 } 2844 2845 // Read the record. 2846 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 2847 ReadSourceLocation(M, PPOffs.End)); 2848 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 2849 const char *BlobStart = 0; 2850 unsigned BlobLen = 0; 2851 RecordData Record; 2852 PreprocessorDetailRecordTypes RecType = 2853 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord( 2854 Code, Record, BlobStart, BlobLen); 2855 switch (RecType) { 2856 case PPD_MACRO_EXPANSION: { 2857 bool isBuiltin = Record[0]; 2858 IdentifierInfo *Name = 0; 2859 MacroDefinition *Def = 0; 2860 if (isBuiltin) 2861 Name = getLocalIdentifier(M, Record[1]); 2862 else { 2863 PreprocessedEntityID 2864 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 2865 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 2866 } 2867 2868 MacroExpansion *ME; 2869 if (isBuiltin) 2870 ME = new (PPRec) MacroExpansion(Name, Range); 2871 else 2872 ME = new (PPRec) MacroExpansion(Def, Range); 2873 2874 return ME; 2875 } 2876 2877 case PPD_MACRO_DEFINITION: { 2878 // Decode the identifier info and then check again; if the macro is 2879 // still defined and associated with the identifier, 2880 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 2881 MacroDefinition *MD 2882 = new (PPRec) MacroDefinition(II, Range); 2883 2884 if (DeserializationListener) 2885 DeserializationListener->MacroDefinitionRead(PPID, MD); 2886 2887 return MD; 2888 } 2889 2890 case PPD_INCLUSION_DIRECTIVE: { 2891 const char *FullFileNameStart = BlobStart + Record[0]; 2892 const FileEntry *File 2893 = PP.getFileManager().getFile(StringRef(FullFileNameStart, 2894 BlobLen - Record[0])); 2895 2896 // FIXME: Stable encoding 2897 InclusionDirective::InclusionKind Kind 2898 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 2899 InclusionDirective *ID 2900 = new (PPRec) InclusionDirective(PPRec, Kind, 2901 StringRef(BlobStart, Record[0]), 2902 Record[1], 2903 File, 2904 Range); 2905 return ID; 2906 } 2907 } 2908 2909 Error("invalid offset in preprocessor detail block"); 2910 return 0; 2911} 2912 2913/// \brief \arg SLocMapI points at a chunk of a module that contains no 2914/// preprocessed entities or the entities it contains are not the ones we are 2915/// looking for. Find the next module that contains entities and return the ID 2916/// of the first entry. 2917PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 2918 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 2919 ++SLocMapI; 2920 for (GlobalSLocOffsetMapType::const_iterator 2921 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 2922 Module &M = *SLocMapI->second; 2923 if (M.NumPreprocessedEntities) 2924 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID); 2925 } 2926 2927 return getTotalNumPreprocessedEntities(); 2928} 2929 2930namespace { 2931 2932template <unsigned PPEntityOffset::*PPLoc> 2933struct PPEntityComp { 2934 const ASTReader &Reader; 2935 Module &M; 2936 2937 PPEntityComp(const ASTReader &Reader, Module &M) : Reader(Reader), M(M) { } 2938 2939 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 2940 SourceLocation LHS = getLoc(L); 2941 SourceLocation RHS = getLoc(R); 2942 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 2943 } 2944 2945 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 2946 SourceLocation LHS = getLoc(L); 2947 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 2948 } 2949 2950 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 2951 SourceLocation RHS = getLoc(R); 2952 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 2953 } 2954 2955 SourceLocation getLoc(const PPEntityOffset &PPE) const { 2956 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 2957 } 2958}; 2959 2960} 2961 2962/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 2963PreprocessedEntityID 2964ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 2965 if (SourceMgr.isLocalSourceLocation(BLoc)) 2966 return getTotalNumPreprocessedEntities(); 2967 2968 GlobalSLocOffsetMapType::const_iterator 2969 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 2970 BLoc.getOffset()); 2971 assert(SLocMapI != GlobalSLocOffsetMap.end() && 2972 "Corrupted global sloc offset map"); 2973 2974 if (SLocMapI->second->NumPreprocessedEntities == 0) 2975 return findNextPreprocessedEntity(SLocMapI); 2976 2977 Module &M = *SLocMapI->second; 2978 typedef const PPEntityOffset *pp_iterator; 2979 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 2980 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 2981 2982 size_t Count = M.NumPreprocessedEntities; 2983 size_t Half; 2984 pp_iterator First = pp_begin; 2985 pp_iterator PPI; 2986 2987 // Do a binary search manually instead of using std::lower_bound because 2988 // The end locations of entities may be unordered (when a macro expansion 2989 // is inside another macro argument), but for this case it is not important 2990 // whether we get the first macro expansion or its containing macro. 2991 while (Count > 0) { 2992 Half = Count/2; 2993 PPI = First; 2994 std::advance(PPI, Half); 2995 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 2996 BLoc)){ 2997 First = PPI; 2998 ++First; 2999 Count = Count - Half - 1; 3000 } else 3001 Count = Half; 3002 } 3003 3004 if (PPI == pp_end) 3005 return findNextPreprocessedEntity(SLocMapI); 3006 3007 return getGlobalPreprocessedEntityID(M, 3008 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3009} 3010 3011/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 3012PreprocessedEntityID 3013ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 3014 if (SourceMgr.isLocalSourceLocation(ELoc)) 3015 return getTotalNumPreprocessedEntities(); 3016 3017 GlobalSLocOffsetMapType::const_iterator 3018 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3019 ELoc.getOffset()); 3020 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3021 "Corrupted global sloc offset map"); 3022 3023 if (SLocMapI->second->NumPreprocessedEntities == 0) 3024 return findNextPreprocessedEntity(SLocMapI); 3025 3026 Module &M = *SLocMapI->second; 3027 typedef const PPEntityOffset *pp_iterator; 3028 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3029 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3030 pp_iterator PPI = 3031 std::upper_bound(pp_begin, pp_end, ELoc, 3032 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 3033 3034 if (PPI == pp_end) 3035 return findNextPreprocessedEntity(SLocMapI); 3036 3037 return getGlobalPreprocessedEntityID(M, 3038 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3039} 3040 3041/// \brief Returns a pair of [Begin, End) indices of preallocated 3042/// preprocessed entities that \arg Range encompasses. 3043std::pair<unsigned, unsigned> 3044 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 3045 if (Range.isInvalid()) 3046 return std::make_pair(0,0); 3047 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 3048 3049 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 3050 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 3051 return std::make_pair(BeginID, EndID); 3052} 3053 3054/// \brief Optionally returns true or false if the preallocated preprocessed 3055/// entity with index \arg Index came from file \arg FID. 3056llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 3057 FileID FID) { 3058 if (FID.isInvalid()) 3059 return false; 3060 3061 std::pair<Module *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3062 Module &M = *PPInfo.first; 3063 unsigned LocalIndex = PPInfo.second; 3064 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3065 3066 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 3067 if (Loc.isInvalid()) 3068 return false; 3069 3070 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 3071 return true; 3072 else 3073 return false; 3074} 3075 3076namespace { 3077 /// \brief Visitor used to search for information about a header file. 3078 class HeaderFileInfoVisitor { 3079 ASTReader &Reader; 3080 const FileEntry *FE; 3081 3082 llvm::Optional<HeaderFileInfo> HFI; 3083 3084 public: 3085 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) 3086 : Reader(Reader), FE(FE) { } 3087 3088 static bool visit(Module &M, void *UserData) { 3089 HeaderFileInfoVisitor *This 3090 = static_cast<HeaderFileInfoVisitor *>(UserData); 3091 3092 HeaderFileInfoTrait Trait(This->Reader, M, 3093 &This->Reader.getPreprocessor().getHeaderSearchInfo(), 3094 M.HeaderFileFrameworkStrings, 3095 This->FE->getName()); 3096 3097 HeaderFileInfoLookupTable *Table 3098 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 3099 if (!Table) 3100 return false; 3101 3102 // Look in the on-disk hash table for an entry for this file name. 3103 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(), 3104 &Trait); 3105 if (Pos == Table->end()) 3106 return false; 3107 3108 This->HFI = *Pos; 3109 return true; 3110 } 3111 3112 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 3113 }; 3114} 3115 3116HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3117 HeaderFileInfoVisitor Visitor(*this, FE); 3118 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 3119 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 3120 if (Listener) 3121 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 3122 return *HFI; 3123 } 3124 3125 return HeaderFileInfo(); 3126} 3127 3128void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 3129 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3130 Module &F = *(*I); 3131 unsigned Idx = 0; 3132 while (Idx < F.PragmaDiagMappings.size()) { 3133 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3134 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 3135 Diag.DiagStatePoints.push_back( 3136 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(), 3137 FullSourceLoc(Loc, SourceMgr))); 3138 while (1) { 3139 assert(Idx < F.PragmaDiagMappings.size() && 3140 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3141 if (Idx >= F.PragmaDiagMappings.size()) { 3142 break; // Something is messed up but at least avoid infinite loop in 3143 // release build. 3144 } 3145 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3146 if (DiagID == (unsigned)-1) { 3147 break; // no more diag/map pairs for this location. 3148 } 3149 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3150 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 3151 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 3152 } 3153 } 3154 } 3155} 3156 3157/// \brief Get the correct cursor and offset for loading a type. 3158ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3159 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3160 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3161 Module *M = I->second; 3162 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3163} 3164 3165/// \brief Read and return the type with the given index.. 3166/// 3167/// The index is the type ID, shifted and minus the number of predefs. This 3168/// routine actually reads the record corresponding to the type at the given 3169/// location. It is a helper routine for GetType, which deals with reading type 3170/// IDs. 3171QualType ASTReader::readTypeRecord(unsigned Index) { 3172 RecordLocation Loc = TypeCursorForIndex(Index); 3173 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3174 3175 // Keep track of where we are in the stream, then jump back there 3176 // after reading this type. 3177 SavedStreamPosition SavedPosition(DeclsCursor); 3178 3179 ReadingKindTracker ReadingKind(Read_Type, *this); 3180 3181 // Note that we are loading a type record. 3182 Deserializing AType(this); 3183 3184 unsigned Idx = 0; 3185 DeclsCursor.JumpToBit(Loc.Offset); 3186 RecordData Record; 3187 unsigned Code = DeclsCursor.ReadCode(); 3188 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3189 case TYPE_EXT_QUAL: { 3190 if (Record.size() != 2) { 3191 Error("Incorrect encoding of extended qualifier type"); 3192 return QualType(); 3193 } 3194 QualType Base = readType(*Loc.F, Record, Idx); 3195 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3196 return Context.getQualifiedType(Base, Quals); 3197 } 3198 3199 case TYPE_COMPLEX: { 3200 if (Record.size() != 1) { 3201 Error("Incorrect encoding of complex type"); 3202 return QualType(); 3203 } 3204 QualType ElemType = readType(*Loc.F, Record, Idx); 3205 return Context.getComplexType(ElemType); 3206 } 3207 3208 case TYPE_POINTER: { 3209 if (Record.size() != 1) { 3210 Error("Incorrect encoding of pointer type"); 3211 return QualType(); 3212 } 3213 QualType PointeeType = readType(*Loc.F, Record, Idx); 3214 return Context.getPointerType(PointeeType); 3215 } 3216 3217 case TYPE_BLOCK_POINTER: { 3218 if (Record.size() != 1) { 3219 Error("Incorrect encoding of block pointer type"); 3220 return QualType(); 3221 } 3222 QualType PointeeType = readType(*Loc.F, Record, Idx); 3223 return Context.getBlockPointerType(PointeeType); 3224 } 3225 3226 case TYPE_LVALUE_REFERENCE: { 3227 if (Record.size() != 2) { 3228 Error("Incorrect encoding of lvalue reference type"); 3229 return QualType(); 3230 } 3231 QualType PointeeType = readType(*Loc.F, Record, Idx); 3232 return Context.getLValueReferenceType(PointeeType, Record[1]); 3233 } 3234 3235 case TYPE_RVALUE_REFERENCE: { 3236 if (Record.size() != 1) { 3237 Error("Incorrect encoding of rvalue reference type"); 3238 return QualType(); 3239 } 3240 QualType PointeeType = readType(*Loc.F, Record, Idx); 3241 return Context.getRValueReferenceType(PointeeType); 3242 } 3243 3244 case TYPE_MEMBER_POINTER: { 3245 if (Record.size() != 2) { 3246 Error("Incorrect encoding of member pointer type"); 3247 return QualType(); 3248 } 3249 QualType PointeeType = readType(*Loc.F, Record, Idx); 3250 QualType ClassType = readType(*Loc.F, Record, Idx); 3251 if (PointeeType.isNull() || ClassType.isNull()) 3252 return QualType(); 3253 3254 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3255 } 3256 3257 case TYPE_CONSTANT_ARRAY: { 3258 QualType ElementType = readType(*Loc.F, Record, Idx); 3259 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3260 unsigned IndexTypeQuals = Record[2]; 3261 unsigned Idx = 3; 3262 llvm::APInt Size = ReadAPInt(Record, Idx); 3263 return Context.getConstantArrayType(ElementType, Size, 3264 ASM, IndexTypeQuals); 3265 } 3266 3267 case TYPE_INCOMPLETE_ARRAY: { 3268 QualType ElementType = readType(*Loc.F, Record, Idx); 3269 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3270 unsigned IndexTypeQuals = Record[2]; 3271 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3272 } 3273 3274 case TYPE_VARIABLE_ARRAY: { 3275 QualType ElementType = readType(*Loc.F, Record, Idx); 3276 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3277 unsigned IndexTypeQuals = Record[2]; 3278 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3279 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3280 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3281 ASM, IndexTypeQuals, 3282 SourceRange(LBLoc, RBLoc)); 3283 } 3284 3285 case TYPE_VECTOR: { 3286 if (Record.size() != 3) { 3287 Error("incorrect encoding of vector type in AST file"); 3288 return QualType(); 3289 } 3290 3291 QualType ElementType = readType(*Loc.F, Record, Idx); 3292 unsigned NumElements = Record[1]; 3293 unsigned VecKind = Record[2]; 3294 return Context.getVectorType(ElementType, NumElements, 3295 (VectorType::VectorKind)VecKind); 3296 } 3297 3298 case TYPE_EXT_VECTOR: { 3299 if (Record.size() != 3) { 3300 Error("incorrect encoding of extended vector type in AST file"); 3301 return QualType(); 3302 } 3303 3304 QualType ElementType = readType(*Loc.F, Record, Idx); 3305 unsigned NumElements = Record[1]; 3306 return Context.getExtVectorType(ElementType, NumElements); 3307 } 3308 3309 case TYPE_FUNCTION_NO_PROTO: { 3310 if (Record.size() != 6) { 3311 Error("incorrect encoding of no-proto function type"); 3312 return QualType(); 3313 } 3314 QualType ResultType = readType(*Loc.F, Record, Idx); 3315 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3316 (CallingConv)Record[4], Record[5]); 3317 return Context.getFunctionNoProtoType(ResultType, Info); 3318 } 3319 3320 case TYPE_FUNCTION_PROTO: { 3321 QualType ResultType = readType(*Loc.F, Record, Idx); 3322 3323 FunctionProtoType::ExtProtoInfo EPI; 3324 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3325 /*hasregparm*/ Record[2], 3326 /*regparm*/ Record[3], 3327 static_cast<CallingConv>(Record[4]), 3328 /*produces*/ Record[5]); 3329 3330 unsigned Idx = 6; 3331 unsigned NumParams = Record[Idx++]; 3332 SmallVector<QualType, 16> ParamTypes; 3333 for (unsigned I = 0; I != NumParams; ++I) 3334 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3335 3336 EPI.Variadic = Record[Idx++]; 3337 EPI.TypeQuals = Record[Idx++]; 3338 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3339 ExceptionSpecificationType EST = 3340 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3341 EPI.ExceptionSpecType = EST; 3342 if (EST == EST_Dynamic) { 3343 EPI.NumExceptions = Record[Idx++]; 3344 SmallVector<QualType, 2> Exceptions; 3345 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3346 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3347 EPI.Exceptions = Exceptions.data(); 3348 } else if (EST == EST_ComputedNoexcept) { 3349 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3350 } 3351 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams, 3352 EPI); 3353 } 3354 3355 case TYPE_UNRESOLVED_USING: { 3356 unsigned Idx = 0; 3357 return Context.getTypeDeclType( 3358 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3359 } 3360 3361 case TYPE_TYPEDEF: { 3362 if (Record.size() != 2) { 3363 Error("incorrect encoding of typedef type"); 3364 return QualType(); 3365 } 3366 unsigned Idx = 0; 3367 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3368 QualType Canonical = readType(*Loc.F, Record, Idx); 3369 if (!Canonical.isNull()) 3370 Canonical = Context.getCanonicalType(Canonical); 3371 return Context.getTypedefType(Decl, Canonical); 3372 } 3373 3374 case TYPE_TYPEOF_EXPR: 3375 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 3376 3377 case TYPE_TYPEOF: { 3378 if (Record.size() != 1) { 3379 Error("incorrect encoding of typeof(type) in AST file"); 3380 return QualType(); 3381 } 3382 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3383 return Context.getTypeOfType(UnderlyingType); 3384 } 3385 3386 case TYPE_DECLTYPE: 3387 return Context.getDecltypeType(ReadExpr(*Loc.F)); 3388 3389 case TYPE_UNARY_TRANSFORM: { 3390 QualType BaseType = readType(*Loc.F, Record, Idx); 3391 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3392 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3393 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 3394 } 3395 3396 case TYPE_AUTO: 3397 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 3398 3399 case TYPE_RECORD: { 3400 if (Record.size() != 2) { 3401 Error("incorrect encoding of record type"); 3402 return QualType(); 3403 } 3404 unsigned Idx = 0; 3405 bool IsDependent = Record[Idx++]; 3406 QualType T 3407 = Context.getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3408 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3409 return T; 3410 } 3411 3412 case TYPE_ENUM: { 3413 if (Record.size() != 2) { 3414 Error("incorrect encoding of enum type"); 3415 return QualType(); 3416 } 3417 unsigned Idx = 0; 3418 bool IsDependent = Record[Idx++]; 3419 QualType T 3420 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3421 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3422 return T; 3423 } 3424 3425 case TYPE_ATTRIBUTED: { 3426 if (Record.size() != 3) { 3427 Error("incorrect encoding of attributed type"); 3428 return QualType(); 3429 } 3430 QualType modifiedType = readType(*Loc.F, Record, Idx); 3431 QualType equivalentType = readType(*Loc.F, Record, Idx); 3432 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3433 return Context.getAttributedType(kind, modifiedType, equivalentType); 3434 } 3435 3436 case TYPE_PAREN: { 3437 if (Record.size() != 1) { 3438 Error("incorrect encoding of paren type"); 3439 return QualType(); 3440 } 3441 QualType InnerType = readType(*Loc.F, Record, Idx); 3442 return Context.getParenType(InnerType); 3443 } 3444 3445 case TYPE_PACK_EXPANSION: { 3446 if (Record.size() != 2) { 3447 Error("incorrect encoding of pack expansion type"); 3448 return QualType(); 3449 } 3450 QualType Pattern = readType(*Loc.F, Record, Idx); 3451 if (Pattern.isNull()) 3452 return QualType(); 3453 llvm::Optional<unsigned> NumExpansions; 3454 if (Record[1]) 3455 NumExpansions = Record[1] - 1; 3456 return Context.getPackExpansionType(Pattern, NumExpansions); 3457 } 3458 3459 case TYPE_ELABORATED: { 3460 unsigned Idx = 0; 3461 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3462 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3463 QualType NamedType = readType(*Loc.F, Record, Idx); 3464 return Context.getElaboratedType(Keyword, NNS, NamedType); 3465 } 3466 3467 case TYPE_OBJC_INTERFACE: { 3468 unsigned Idx = 0; 3469 ObjCInterfaceDecl *ItfD 3470 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3471 return Context.getObjCInterfaceType(ItfD); 3472 } 3473 3474 case TYPE_OBJC_OBJECT: { 3475 unsigned Idx = 0; 3476 QualType Base = readType(*Loc.F, Record, Idx); 3477 unsigned NumProtos = Record[Idx++]; 3478 SmallVector<ObjCProtocolDecl*, 4> Protos; 3479 for (unsigned I = 0; I != NumProtos; ++I) 3480 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3481 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 3482 } 3483 3484 case TYPE_OBJC_OBJECT_POINTER: { 3485 unsigned Idx = 0; 3486 QualType Pointee = readType(*Loc.F, Record, Idx); 3487 return Context.getObjCObjectPointerType(Pointee); 3488 } 3489 3490 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3491 unsigned Idx = 0; 3492 QualType Parm = readType(*Loc.F, Record, Idx); 3493 QualType Replacement = readType(*Loc.F, Record, Idx); 3494 return 3495 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3496 Replacement); 3497 } 3498 3499 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3500 unsigned Idx = 0; 3501 QualType Parm = readType(*Loc.F, Record, Idx); 3502 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3503 return Context.getSubstTemplateTypeParmPackType( 3504 cast<TemplateTypeParmType>(Parm), 3505 ArgPack); 3506 } 3507 3508 case TYPE_INJECTED_CLASS_NAME: { 3509 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3510 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3511 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3512 // for AST reading, too much interdependencies. 3513 return 3514 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3515 } 3516 3517 case TYPE_TEMPLATE_TYPE_PARM: { 3518 unsigned Idx = 0; 3519 unsigned Depth = Record[Idx++]; 3520 unsigned Index = Record[Idx++]; 3521 bool Pack = Record[Idx++]; 3522 TemplateTypeParmDecl *D 3523 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3524 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 3525 } 3526 3527 case TYPE_DEPENDENT_NAME: { 3528 unsigned Idx = 0; 3529 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3530 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3531 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3532 QualType Canon = readType(*Loc.F, Record, Idx); 3533 if (!Canon.isNull()) 3534 Canon = Context.getCanonicalType(Canon); 3535 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 3536 } 3537 3538 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3539 unsigned Idx = 0; 3540 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3541 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3542 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3543 unsigned NumArgs = Record[Idx++]; 3544 SmallVector<TemplateArgument, 8> Args; 3545 Args.reserve(NumArgs); 3546 while (NumArgs--) 3547 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3548 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 3549 Args.size(), Args.data()); 3550 } 3551 3552 case TYPE_DEPENDENT_SIZED_ARRAY: { 3553 unsigned Idx = 0; 3554 3555 // ArrayType 3556 QualType ElementType = readType(*Loc.F, Record, Idx); 3557 ArrayType::ArraySizeModifier ASM 3558 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3559 unsigned IndexTypeQuals = Record[Idx++]; 3560 3561 // DependentSizedArrayType 3562 Expr *NumElts = ReadExpr(*Loc.F); 3563 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3564 3565 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 3566 IndexTypeQuals, Brackets); 3567 } 3568 3569 case TYPE_TEMPLATE_SPECIALIZATION: { 3570 unsigned Idx = 0; 3571 bool IsDependent = Record[Idx++]; 3572 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3573 SmallVector<TemplateArgument, 8> Args; 3574 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3575 QualType Underlying = readType(*Loc.F, Record, Idx); 3576 QualType T; 3577 if (Underlying.isNull()) 3578 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 3579 Args.size()); 3580 else 3581 T = Context.getTemplateSpecializationType(Name, Args.data(), 3582 Args.size(), Underlying); 3583 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3584 return T; 3585 } 3586 3587 case TYPE_ATOMIC: { 3588 if (Record.size() != 1) { 3589 Error("Incorrect encoding of atomic type"); 3590 return QualType(); 3591 } 3592 QualType ValueType = readType(*Loc.F, Record, Idx); 3593 return Context.getAtomicType(ValueType); 3594 } 3595 } 3596 // Suppress a GCC warning 3597 return QualType(); 3598} 3599 3600class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3601 ASTReader &Reader; 3602 Module &F; 3603 llvm::BitstreamCursor &DeclsCursor; 3604 const ASTReader::RecordData &Record; 3605 unsigned &Idx; 3606 3607 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3608 unsigned &I) { 3609 return Reader.ReadSourceLocation(F, R, I); 3610 } 3611 3612 template<typename T> 3613 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 3614 return Reader.ReadDeclAs<T>(F, Record, Idx); 3615 } 3616 3617public: 3618 TypeLocReader(ASTReader &Reader, Module &F, 3619 const ASTReader::RecordData &Record, unsigned &Idx) 3620 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3621 { } 3622 3623 // We want compile-time assurance that we've enumerated all of 3624 // these, so unfortunately we have to declare them first, then 3625 // define them out-of-line. 3626#define ABSTRACT_TYPELOC(CLASS, PARENT) 3627#define TYPELOC(CLASS, PARENT) \ 3628 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3629#include "clang/AST/TypeLocNodes.def" 3630 3631 void VisitFunctionTypeLoc(FunctionTypeLoc); 3632 void VisitArrayTypeLoc(ArrayTypeLoc); 3633}; 3634 3635void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3636 // nothing to do 3637} 3638void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3639 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3640 if (TL.needsExtraLocalData()) { 3641 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3642 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3643 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3644 TL.setModeAttr(Record[Idx++]); 3645 } 3646} 3647void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3648 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3649} 3650void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3651 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3652} 3653void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3654 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3655} 3656void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3657 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3658} 3659void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3660 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3661} 3662void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3663 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3664 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3665} 3666void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3667 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3668 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3669 if (Record[Idx++]) 3670 TL.setSizeExpr(Reader.ReadExpr(F)); 3671 else 3672 TL.setSizeExpr(0); 3673} 3674void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3675 VisitArrayTypeLoc(TL); 3676} 3677void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3678 VisitArrayTypeLoc(TL); 3679} 3680void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3681 VisitArrayTypeLoc(TL); 3682} 3683void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3684 DependentSizedArrayTypeLoc TL) { 3685 VisitArrayTypeLoc(TL); 3686} 3687void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3688 DependentSizedExtVectorTypeLoc TL) { 3689 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3690} 3691void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3692 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3693} 3694void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3695 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3696} 3697void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3698 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3699 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3700 TL.setTrailingReturn(Record[Idx++]); 3701 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3702 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 3703 } 3704} 3705void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3706 VisitFunctionTypeLoc(TL); 3707} 3708void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3709 VisitFunctionTypeLoc(TL); 3710} 3711void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3712 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3713} 3714void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3715 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3716} 3717void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3718 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3719 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3720 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3721} 3722void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3723 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3724 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3725 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3726 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3727} 3728void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3729 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3730} 3731void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 3732 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3733 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3734 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3735 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3736} 3737void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3738 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3739} 3740void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3741 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3742} 3743void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3744 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3745} 3746void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3747 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3748 if (TL.hasAttrOperand()) { 3749 SourceRange range; 3750 range.setBegin(ReadSourceLocation(Record, Idx)); 3751 range.setEnd(ReadSourceLocation(Record, Idx)); 3752 TL.setAttrOperandParensRange(range); 3753 } 3754 if (TL.hasAttrExprOperand()) { 3755 if (Record[Idx++]) 3756 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3757 else 3758 TL.setAttrExprOperand(0); 3759 } else if (TL.hasAttrEnumOperand()) 3760 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3761} 3762void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3763 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3764} 3765void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3766 SubstTemplateTypeParmTypeLoc TL) { 3767 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3768} 3769void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3770 SubstTemplateTypeParmPackTypeLoc TL) { 3771 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3772} 3773void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3774 TemplateSpecializationTypeLoc TL) { 3775 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3776 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3777 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3778 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3779 TL.setArgLocInfo(i, 3780 Reader.GetTemplateArgumentLocInfo(F, 3781 TL.getTypePtr()->getArg(i).getKind(), 3782 Record, Idx)); 3783} 3784void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3785 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3786 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3787} 3788void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3789 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3790 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3791} 3792void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3793 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3794} 3795void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3796 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3797 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3798 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3799} 3800void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3801 DependentTemplateSpecializationTypeLoc TL) { 3802 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3803 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3804 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3805 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3806 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3807 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3808 TL.setArgLocInfo(I, 3809 Reader.GetTemplateArgumentLocInfo(F, 3810 TL.getTypePtr()->getArg(I).getKind(), 3811 Record, Idx)); 3812} 3813void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3814 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3815} 3816void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3817 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3818} 3819void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3820 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3821 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3822 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3823 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3824 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3825} 3826void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3827 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3828} 3829void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 3830 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3831 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3832 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3833} 3834 3835TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F, 3836 const RecordData &Record, 3837 unsigned &Idx) { 3838 QualType InfoTy = readType(F, Record, Idx); 3839 if (InfoTy.isNull()) 3840 return 0; 3841 3842 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 3843 TypeLocReader TLR(*this, F, Record, Idx); 3844 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3845 TLR.Visit(TL); 3846 return TInfo; 3847} 3848 3849QualType ASTReader::GetType(TypeID ID) { 3850 unsigned FastQuals = ID & Qualifiers::FastMask; 3851 unsigned Index = ID >> Qualifiers::FastWidth; 3852 3853 if (Index < NUM_PREDEF_TYPE_IDS) { 3854 QualType T; 3855 switch ((PredefinedTypeIDs)Index) { 3856 case PREDEF_TYPE_NULL_ID: return QualType(); 3857 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 3858 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 3859 3860 case PREDEF_TYPE_CHAR_U_ID: 3861 case PREDEF_TYPE_CHAR_S_ID: 3862 // FIXME: Check that the signedness of CharTy is correct! 3863 T = Context.CharTy; 3864 break; 3865 3866 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 3867 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 3868 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 3869 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 3870 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 3871 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 3872 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 3873 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 3874 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 3875 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 3876 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 3877 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 3878 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 3879 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 3880 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 3881 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 3882 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 3883 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 3884 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 3885 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 3886 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 3887 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 3888 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 3889 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 3890 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 3891 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 3892 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 3893 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 3894 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 3895 3896 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 3897 T = Context.getAutoRRefDeductType(); 3898 break; 3899 3900 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 3901 T = Context.ARCUnbridgedCastTy; 3902 break; 3903 3904 } 3905 3906 assert(!T.isNull() && "Unknown predefined type"); 3907 return T.withFastQualifiers(FastQuals); 3908 } 3909 3910 Index -= NUM_PREDEF_TYPE_IDS; 3911 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3912 if (TypesLoaded[Index].isNull()) { 3913 TypesLoaded[Index] = readTypeRecord(Index); 3914 if (TypesLoaded[Index].isNull()) 3915 return QualType(); 3916 3917 TypesLoaded[Index]->setFromAST(); 3918 if (DeserializationListener) 3919 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3920 TypesLoaded[Index]); 3921 } 3922 3923 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3924} 3925 3926QualType ASTReader::getLocalType(Module &F, unsigned LocalID) { 3927 return GetType(getGlobalTypeID(F, LocalID)); 3928} 3929 3930serialization::TypeID 3931ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const { 3932 unsigned FastQuals = LocalID & Qualifiers::FastMask; 3933 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 3934 3935 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 3936 return LocalID; 3937 3938 ContinuousRangeMap<uint32_t, int, 2>::iterator I 3939 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 3940 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 3941 3942 unsigned GlobalIndex = LocalIndex + I->second; 3943 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 3944} 3945 3946TemplateArgumentLocInfo 3947ASTReader::GetTemplateArgumentLocInfo(Module &F, 3948 TemplateArgument::ArgKind Kind, 3949 const RecordData &Record, 3950 unsigned &Index) { 3951 switch (Kind) { 3952 case TemplateArgument::Expression: 3953 return ReadExpr(F); 3954 case TemplateArgument::Type: 3955 return GetTypeSourceInfo(F, Record, Index); 3956 case TemplateArgument::Template: { 3957 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3958 Index); 3959 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3960 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3961 SourceLocation()); 3962 } 3963 case TemplateArgument::TemplateExpansion: { 3964 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3965 Index); 3966 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3967 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 3968 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3969 EllipsisLoc); 3970 } 3971 case TemplateArgument::Null: 3972 case TemplateArgument::Integral: 3973 case TemplateArgument::Declaration: 3974 case TemplateArgument::Pack: 3975 return TemplateArgumentLocInfo(); 3976 } 3977 llvm_unreachable("unexpected template argument loc"); 3978 return TemplateArgumentLocInfo(); 3979} 3980 3981TemplateArgumentLoc 3982ASTReader::ReadTemplateArgumentLoc(Module &F, 3983 const RecordData &Record, unsigned &Index) { 3984 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 3985 3986 if (Arg.getKind() == TemplateArgument::Expression) { 3987 if (Record[Index++]) // bool InfoHasSameExpr. 3988 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3989 } 3990 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 3991 Record, Index)); 3992} 3993 3994Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3995 return GetDecl(ID); 3996} 3997 3998uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record, 3999 unsigned &Idx){ 4000 if (Idx >= Record.size()) 4001 return 0; 4002 4003 unsigned LocalID = Record[Idx++]; 4004 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4005} 4006 4007CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4008 RecordLocation Loc = getLocalBitOffset(Offset); 4009 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4010 SavedStreamPosition SavedPosition(Cursor); 4011 Cursor.JumpToBit(Loc.Offset); 4012 ReadingKindTracker ReadingKind(Read_Decl, *this); 4013 RecordData Record; 4014 unsigned Code = Cursor.ReadCode(); 4015 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4016 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4017 Error("Malformed AST file: missing C++ base specifiers"); 4018 return 0; 4019 } 4020 4021 unsigned Idx = 0; 4022 unsigned NumBases = Record[Idx++]; 4023 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4024 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4025 for (unsigned I = 0; I != NumBases; ++I) 4026 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4027 return Bases; 4028} 4029 4030serialization::DeclID 4031ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const { 4032 if (LocalID < NUM_PREDEF_DECL_IDS) 4033 return LocalID; 4034 4035 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4036 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4037 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4038 4039 return LocalID + I->second; 4040} 4041 4042bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 4043 Module &M) const { 4044 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 4045 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4046 return &M == I->second; 4047} 4048 4049SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 4050 if (ID < NUM_PREDEF_DECL_IDS) 4051 return SourceLocation(); 4052 4053 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4054 4055 if (Index > DeclsLoaded.size()) { 4056 Error("declaration ID out-of-range for AST file"); 4057 return SourceLocation(); 4058 } 4059 4060 if (Decl *D = DeclsLoaded[Index]) 4061 return D->getLocation(); 4062 4063 unsigned RawLocation = 0; 4064 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 4065 return ReadSourceLocation(*Rec.F, RawLocation); 4066} 4067 4068Decl *ASTReader::GetDecl(DeclID ID) { 4069 if (ID < NUM_PREDEF_DECL_IDS) { 4070 switch ((PredefinedDeclIDs)ID) { 4071 case PREDEF_DECL_NULL_ID: 4072 return 0; 4073 4074 case PREDEF_DECL_TRANSLATION_UNIT_ID: 4075 return Context.getTranslationUnitDecl(); 4076 4077 case PREDEF_DECL_OBJC_ID_ID: 4078 return Context.getObjCIdDecl(); 4079 4080 case PREDEF_DECL_OBJC_SEL_ID: 4081 return Context.getObjCSelDecl(); 4082 4083 case PREDEF_DECL_OBJC_CLASS_ID: 4084 return Context.getObjCClassDecl(); 4085 4086 case PREDEF_DECL_INT_128_ID: 4087 return Context.getInt128Decl(); 4088 4089 case PREDEF_DECL_UNSIGNED_INT_128_ID: 4090 return Context.getUInt128Decl(); 4091 4092 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 4093 return Context.getObjCInstanceTypeDecl(); 4094 } 4095 4096 return 0; 4097 } 4098 4099 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4100 4101 if (Index > DeclsLoaded.size()) { 4102 Error("declaration ID out-of-range for AST file"); 4103 return 0; 4104 } 4105 4106if (!DeclsLoaded[Index]) { 4107 ReadDeclRecord(ID); 4108 if (DeserializationListener) 4109 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4110 } 4111 4112 return DeclsLoaded[Index]; 4113} 4114 4115serialization::DeclID ASTReader::ReadDeclID(Module &F, 4116 const RecordData &Record, 4117 unsigned &Idx) { 4118 if (Idx >= Record.size()) { 4119 Error("Corrupted AST file"); 4120 return 0; 4121 } 4122 4123 return getGlobalDeclID(F, Record[Idx++]); 4124} 4125 4126/// \brief Resolve the offset of a statement into a statement. 4127/// 4128/// This operation will read a new statement from the external 4129/// source each time it is called, and is meant to be used via a 4130/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4131Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4132 // Switch case IDs are per Decl. 4133 ClearSwitchCaseIDs(); 4134 4135 // Offset here is a global offset across the entire chain. 4136 RecordLocation Loc = getLocalBitOffset(Offset); 4137 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4138 return ReadStmtFromStream(*Loc.F); 4139} 4140 4141namespace { 4142 class FindExternalLexicalDeclsVisitor { 4143 ASTReader &Reader; 4144 const DeclContext *DC; 4145 bool (*isKindWeWant)(Decl::Kind); 4146 4147 SmallVectorImpl<Decl*> &Decls; 4148 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 4149 4150 public: 4151 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 4152 bool (*isKindWeWant)(Decl::Kind), 4153 SmallVectorImpl<Decl*> &Decls) 4154 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 4155 { 4156 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 4157 PredefsVisited[I] = false; 4158 } 4159 4160 static bool visit(Module &M, bool Preorder, void *UserData) { 4161 if (Preorder) 4162 return false; 4163 4164 FindExternalLexicalDeclsVisitor *This 4165 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 4166 4167 Module::DeclContextInfosMap::iterator Info 4168 = M.DeclContextInfos.find(This->DC); 4169 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 4170 return false; 4171 4172 // Load all of the declaration IDs 4173 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 4174 *IDE = ID + Info->second.NumLexicalDecls; 4175 ID != IDE; ++ID) { 4176 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 4177 continue; 4178 4179 // Don't add predefined declarations to the lexical context more 4180 // than once. 4181 if (ID->second < NUM_PREDEF_DECL_IDS) { 4182 if (This->PredefsVisited[ID->second]) 4183 continue; 4184 4185 This->PredefsVisited[ID->second] = true; 4186 } 4187 4188 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 4189 if (!This->DC->isDeclInLexicalTraversal(D)) 4190 This->Decls.push_back(D); 4191 } 4192 } 4193 4194 return false; 4195 } 4196 }; 4197} 4198 4199ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4200 bool (*isKindWeWant)(Decl::Kind), 4201 SmallVectorImpl<Decl*> &Decls) { 4202 // There might be lexical decls in multiple modules, for the TU at 4203 // least. Walk all of the modules in the order they were loaded. 4204 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 4205 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 4206 ++NumLexicalDeclContextsRead; 4207 return ELR_Success; 4208} 4209 4210namespace { 4211 4212class DeclIDComp { 4213 ASTReader &Reader; 4214 Module &Mod; 4215 4216public: 4217 DeclIDComp(ASTReader &Reader, Module &M) : Reader(Reader), Mod(M) {} 4218 4219 bool operator()(LocalDeclID L, LocalDeclID R) const { 4220 SourceLocation LHS = getLocation(L); 4221 SourceLocation RHS = getLocation(R); 4222 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4223 } 4224 4225 bool operator()(SourceLocation LHS, LocalDeclID R) const { 4226 SourceLocation RHS = getLocation(R); 4227 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4228 } 4229 4230 bool operator()(LocalDeclID L, SourceLocation RHS) const { 4231 SourceLocation LHS = getLocation(L); 4232 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4233 } 4234 4235 SourceLocation getLocation(LocalDeclID ID) const { 4236 return Reader.getSourceManager().getFileLoc( 4237 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 4238 } 4239}; 4240 4241} 4242 4243void ASTReader::FindFileRegionDecls(FileID File, 4244 unsigned Offset, unsigned Length, 4245 SmallVectorImpl<Decl *> &Decls) { 4246 SourceManager &SM = getSourceManager(); 4247 4248 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 4249 if (I == FileDeclIDs.end()) 4250 return; 4251 4252 FileDeclsInfo &DInfo = I->second; 4253 if (DInfo.Decls.empty()) 4254 return; 4255 4256 SourceLocation 4257 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 4258 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 4259 4260 DeclIDComp DIDComp(*this, *DInfo.Mod); 4261 ArrayRef<serialization::LocalDeclID>::iterator 4262 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4263 BeginLoc, DIDComp); 4264 if (BeginIt != DInfo.Decls.begin()) 4265 --BeginIt; 4266 4267 ArrayRef<serialization::LocalDeclID>::iterator 4268 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4269 EndLoc, DIDComp); 4270 if (EndIt != DInfo.Decls.end()) 4271 ++EndIt; 4272 4273 for (ArrayRef<serialization::LocalDeclID>::iterator 4274 DIt = BeginIt; DIt != EndIt; ++DIt) 4275 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 4276} 4277 4278namespace { 4279 /// \brief Module visitor used to perform name lookup into a 4280 /// declaration context. 4281 class DeclContextNameLookupVisitor { 4282 ASTReader &Reader; 4283 const DeclContext *DC; 4284 DeclarationName Name; 4285 SmallVectorImpl<NamedDecl *> &Decls; 4286 4287 public: 4288 DeclContextNameLookupVisitor(ASTReader &Reader, 4289 const DeclContext *DC, DeclarationName Name, 4290 SmallVectorImpl<NamedDecl *> &Decls) 4291 : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { } 4292 4293 static bool visit(Module &M, void *UserData) { 4294 DeclContextNameLookupVisitor *This 4295 = static_cast<DeclContextNameLookupVisitor *>(UserData); 4296 4297 // Check whether we have any visible declaration information for 4298 // this context in this module. 4299 Module::DeclContextInfosMap::iterator Info 4300 = M.DeclContextInfos.find(This->DC); 4301 if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData) 4302 return false; 4303 4304 // Look for this name within this module. 4305 ASTDeclContextNameLookupTable *LookupTable = 4306 (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData; 4307 ASTDeclContextNameLookupTable::iterator Pos 4308 = LookupTable->find(This->Name); 4309 if (Pos == LookupTable->end()) 4310 return false; 4311 4312 bool FoundAnything = false; 4313 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4314 for (; Data.first != Data.second; ++Data.first) { 4315 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 4316 if (!ND) 4317 continue; 4318 4319 if (ND->getDeclName() != This->Name) { 4320 assert(!This->Name.getCXXNameType().isNull() && 4321 "Name mismatch without a type"); 4322 continue; 4323 } 4324 4325 // Record this declaration. 4326 FoundAnything = true; 4327 This->Decls.push_back(ND); 4328 } 4329 4330 return FoundAnything; 4331 } 4332 }; 4333} 4334 4335DeclContext::lookup_result 4336ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4337 DeclarationName Name) { 4338 assert(DC->hasExternalVisibleStorage() && 4339 "DeclContext has no visible decls in storage"); 4340 if (!Name) 4341 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4342 DeclContext::lookup_iterator(0)); 4343 4344 SmallVector<NamedDecl *, 64> Decls; 4345 DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls); 4346 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 4347 ++NumVisibleDeclContextsRead; 4348 SetExternalVisibleDeclsForName(DC, Name, Decls); 4349 return const_cast<DeclContext*>(DC)->lookup(Name); 4350} 4351 4352/// \brief Under non-PCH compilation the consumer receives the objc methods 4353/// before receiving the implementation, and codegen depends on this. 4354/// We simulate this by deserializing and passing to consumer the methods of the 4355/// implementation before passing the deserialized implementation decl. 4356static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 4357 ASTConsumer *Consumer) { 4358 assert(ImplD && Consumer); 4359 4360 for (ObjCImplDecl::method_iterator 4361 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 4362 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 4363 4364 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 4365} 4366 4367void ASTReader::PassInterestingDeclsToConsumer() { 4368 assert(Consumer); 4369 while (!InterestingDecls.empty()) { 4370 Decl *D = InterestingDecls.front(); 4371 InterestingDecls.pop_front(); 4372 4373 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4374 PassObjCImplDeclToConsumer(ImplD, Consumer); 4375 else 4376 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 4377 } 4378} 4379 4380void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4381 this->Consumer = Consumer; 4382 4383 if (!Consumer) 4384 return; 4385 4386 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4387 // Force deserialization of this decl, which will cause it to be queued for 4388 // passing to the consumer. 4389 GetDecl(ExternalDefinitions[I]); 4390 } 4391 ExternalDefinitions.clear(); 4392 4393 PassInterestingDeclsToConsumer(); 4394} 4395 4396void ASTReader::PrintStats() { 4397 std::fprintf(stderr, "*** AST File Statistics:\n"); 4398 4399 unsigned NumTypesLoaded 4400 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4401 QualType()); 4402 unsigned NumDeclsLoaded 4403 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4404 (Decl *)0); 4405 unsigned NumIdentifiersLoaded 4406 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4407 IdentifiersLoaded.end(), 4408 (IdentifierInfo *)0); 4409 unsigned NumSelectorsLoaded 4410 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4411 SelectorsLoaded.end(), 4412 Selector()); 4413 4414 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4415 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4416 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4417 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4418 NumSLocEntriesRead, TotalNumSLocEntries, 4419 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4420 if (!TypesLoaded.empty()) 4421 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4422 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4423 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4424 if (!DeclsLoaded.empty()) 4425 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4426 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4427 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4428 if (!IdentifiersLoaded.empty()) 4429 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4430 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4431 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4432 if (!SelectorsLoaded.empty()) 4433 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4434 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4435 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4436 if (TotalNumStatements) 4437 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4438 NumStatementsRead, TotalNumStatements, 4439 ((float)NumStatementsRead/TotalNumStatements * 100)); 4440 if (TotalNumMacros) 4441 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4442 NumMacrosRead, TotalNumMacros, 4443 ((float)NumMacrosRead/TotalNumMacros * 100)); 4444 if (TotalLexicalDeclContexts) 4445 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4446 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4447 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4448 * 100)); 4449 if (TotalVisibleDeclContexts) 4450 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4451 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4452 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4453 * 100)); 4454 if (TotalNumMethodPoolEntries) { 4455 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4456 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4457 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4458 * 100)); 4459 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4460 } 4461 std::fprintf(stderr, "\n"); 4462 dump(); 4463 std::fprintf(stderr, "\n"); 4464} 4465 4466template<typename Key, typename Module, unsigned InitialCapacity> 4467static void 4468dumpModuleIDMap(StringRef Name, 4469 const ContinuousRangeMap<Key, Module *, 4470 InitialCapacity> &Map) { 4471 if (Map.begin() == Map.end()) 4472 return; 4473 4474 typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType; 4475 llvm::errs() << Name << ":\n"; 4476 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4477 I != IEnd; ++I) { 4478 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4479 << "\n"; 4480 } 4481} 4482 4483void ASTReader::dump() { 4484 llvm::errs() << "*** PCH/Module Remappings:\n"; 4485 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4486 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4487 dumpModuleIDMap("Global type map", GlobalTypeMap); 4488 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4489 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4490 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4491 dumpModuleIDMap("Global preprocessed entity map", 4492 GlobalPreprocessedEntityMap); 4493 4494 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4495 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4496 MEnd = ModuleMgr.end(); 4497 M != MEnd; ++M) 4498 (*M)->dump(); 4499} 4500 4501/// Return the amount of memory used by memory buffers, breaking down 4502/// by heap-backed versus mmap'ed memory. 4503void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4504 for (ModuleConstIterator I = ModuleMgr.begin(), 4505 E = ModuleMgr.end(); I != E; ++I) { 4506 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4507 size_t bytes = buf->getBufferSize(); 4508 switch (buf->getBufferKind()) { 4509 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4510 sizes.malloc_bytes += bytes; 4511 break; 4512 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4513 sizes.mmap_bytes += bytes; 4514 break; 4515 } 4516 } 4517 } 4518} 4519 4520void ASTReader::InitializeSema(Sema &S) { 4521 SemaObj = &S; 4522 S.ExternalSource = this; 4523 4524 // Makes sure any declarations that were deserialized "too early" 4525 // still get added to the identifier's declaration chains. 4526 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4527 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I], 4528 PreloadedDecls[I]->getDeclName()); 4529 } 4530 PreloadedDecls.clear(); 4531 4532 // Load the offsets of the declarations that Sema references. 4533 // They will be lazily deserialized when needed. 4534 if (!SemaDeclRefs.empty()) { 4535 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4536 if (!SemaObj->StdNamespace) 4537 SemaObj->StdNamespace = SemaDeclRefs[0]; 4538 if (!SemaObj->StdBadAlloc) 4539 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4540 } 4541 4542 if (!FPPragmaOptions.empty()) { 4543 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4544 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4545 } 4546 4547 if (!OpenCLExtensions.empty()) { 4548 unsigned I = 0; 4549#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4550#include "clang/Basic/OpenCLExtensions.def" 4551 4552 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4553 } 4554} 4555 4556IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4557 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart)); 4558 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 4559 IdentifierInfo *II = Visitor.getIdentifierInfo(); 4560 if (II) 4561 II->setOutOfDate(false); 4562 return II; 4563} 4564 4565namespace clang { 4566 /// \brief An identifier-lookup iterator that enumerates all of the 4567 /// identifiers stored within a set of AST files. 4568 class ASTIdentifierIterator : public IdentifierIterator { 4569 /// \brief The AST reader whose identifiers are being enumerated. 4570 const ASTReader &Reader; 4571 4572 /// \brief The current index into the chain of AST files stored in 4573 /// the AST reader. 4574 unsigned Index; 4575 4576 /// \brief The current position within the identifier lookup table 4577 /// of the current AST file. 4578 ASTIdentifierLookupTable::key_iterator Current; 4579 4580 /// \brief The end position within the identifier lookup table of 4581 /// the current AST file. 4582 ASTIdentifierLookupTable::key_iterator End; 4583 4584 public: 4585 explicit ASTIdentifierIterator(const ASTReader &Reader); 4586 4587 virtual StringRef Next(); 4588 }; 4589} 4590 4591ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4592 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 4593 ASTIdentifierLookupTable *IdTable 4594 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 4595 Current = IdTable->key_begin(); 4596 End = IdTable->key_end(); 4597} 4598 4599StringRef ASTIdentifierIterator::Next() { 4600 while (Current == End) { 4601 // If we have exhausted all of our AST files, we're done. 4602 if (Index == 0) 4603 return StringRef(); 4604 4605 --Index; 4606 ASTIdentifierLookupTable *IdTable 4607 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 4608 IdentifierLookupTable; 4609 Current = IdTable->key_begin(); 4610 End = IdTable->key_end(); 4611 } 4612 4613 // We have any identifiers remaining in the current AST file; return 4614 // the next one. 4615 std::pair<const char*, unsigned> Key = *Current; 4616 ++Current; 4617 return StringRef(Key.first, Key.second); 4618} 4619 4620IdentifierIterator *ASTReader::getIdentifiers() const { 4621 return new ASTIdentifierIterator(*this); 4622} 4623 4624namespace clang { namespace serialization { 4625 class ReadMethodPoolVisitor { 4626 ASTReader &Reader; 4627 Selector Sel; 4628 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 4629 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 4630 4631 /// \brief Build an ObjCMethodList from a vector of Objective-C method 4632 /// declarations. 4633 ObjCMethodList 4634 buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const 4635 { 4636 ObjCMethodList List; 4637 ObjCMethodList *Prev = 0; 4638 for (unsigned I = 0, N = Vec.size(); I != N; ++I) { 4639 if (!List.Method) { 4640 // This is the first method, which is the easy case. 4641 List.Method = Vec[I]; 4642 Prev = &List; 4643 continue; 4644 } 4645 4646 ObjCMethodList *Mem = 4647 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 4648 Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0); 4649 Prev = Prev->Next; 4650 } 4651 4652 return List; 4653 } 4654 4655 public: 4656 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel) 4657 : Reader(Reader), Sel(Sel) { } 4658 4659 static bool visit(Module &M, void *UserData) { 4660 ReadMethodPoolVisitor *This 4661 = static_cast<ReadMethodPoolVisitor *>(UserData); 4662 4663 if (!M.SelectorLookupTable) 4664 return false; 4665 4666 ASTSelectorLookupTable *PoolTable 4667 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 4668 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 4669 if (Pos == PoolTable->end()) 4670 return false; 4671 4672 ++This->Reader.NumSelectorsRead; 4673 // FIXME: Not quite happy with the statistics here. We probably should 4674 // disable this tracking when called via LoadSelector. 4675 // Also, should entries without methods count as misses? 4676 ++This->Reader.NumMethodPoolEntriesRead; 4677 ASTSelectorLookupTrait::data_type Data = *Pos; 4678 if (This->Reader.DeserializationListener) 4679 This->Reader.DeserializationListener->SelectorRead(Data.ID, 4680 This->Sel); 4681 4682 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 4683 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 4684 return true; 4685 } 4686 4687 /// \brief Retrieve the instance methods found by this visitor. 4688 ObjCMethodList getInstanceMethods() const { 4689 return buildObjCMethodList(InstanceMethods); 4690 } 4691 4692 /// \brief Retrieve the instance methods found by this visitor. 4693 ObjCMethodList getFactoryMethods() const { 4694 return buildObjCMethodList(FactoryMethods); 4695 } 4696 }; 4697} } // end namespace clang::serialization 4698 4699std::pair<ObjCMethodList, ObjCMethodList> 4700ASTReader::ReadMethodPool(Selector Sel) { 4701 ReadMethodPoolVisitor Visitor(*this, Sel); 4702 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 4703 std::pair<ObjCMethodList, ObjCMethodList> Result; 4704 Result.first = Visitor.getInstanceMethods(); 4705 Result.second = Visitor.getFactoryMethods(); 4706 4707 if (!Result.first.Method && !Result.second.Method) 4708 ++NumMethodPoolMisses; 4709 return Result; 4710} 4711 4712void ASTReader::ReadKnownNamespaces( 4713 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 4714 Namespaces.clear(); 4715 4716 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 4717 if (NamespaceDecl *Namespace 4718 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 4719 Namespaces.push_back(Namespace); 4720 } 4721} 4722 4723void ASTReader::ReadTentativeDefinitions( 4724 SmallVectorImpl<VarDecl *> &TentativeDefs) { 4725 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4726 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 4727 if (Var) 4728 TentativeDefs.push_back(Var); 4729 } 4730 TentativeDefinitions.clear(); 4731} 4732 4733void ASTReader::ReadUnusedFileScopedDecls( 4734 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 4735 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4736 DeclaratorDecl *D 4737 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4738 if (D) 4739 Decls.push_back(D); 4740 } 4741 UnusedFileScopedDecls.clear(); 4742} 4743 4744void ASTReader::ReadDelegatingConstructors( 4745 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 4746 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 4747 CXXConstructorDecl *D 4748 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 4749 if (D) 4750 Decls.push_back(D); 4751 } 4752 DelegatingCtorDecls.clear(); 4753} 4754 4755void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 4756 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 4757 TypedefNameDecl *D 4758 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 4759 if (D) 4760 Decls.push_back(D); 4761 } 4762 ExtVectorDecls.clear(); 4763} 4764 4765void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 4766 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 4767 CXXRecordDecl *D 4768 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 4769 if (D) 4770 Decls.push_back(D); 4771 } 4772 DynamicClasses.clear(); 4773} 4774 4775void 4776ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 4777 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4778 NamedDecl *D 4779 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4780 if (D) 4781 Decls.push_back(D); 4782 } 4783 LocallyScopedExternalDecls.clear(); 4784} 4785 4786void ASTReader::ReadReferencedSelectors( 4787 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 4788 if (ReferencedSelectorsData.empty()) 4789 return; 4790 4791 // If there are @selector references added them to its pool. This is for 4792 // implementation of -Wselector. 4793 unsigned int DataSize = ReferencedSelectorsData.size()-1; 4794 unsigned I = 0; 4795 while (I < DataSize) { 4796 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 4797 SourceLocation SelLoc 4798 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 4799 Sels.push_back(std::make_pair(Sel, SelLoc)); 4800 } 4801 ReferencedSelectorsData.clear(); 4802} 4803 4804void ASTReader::ReadWeakUndeclaredIdentifiers( 4805 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 4806 if (WeakUndeclaredIdentifiers.empty()) 4807 return; 4808 4809 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 4810 IdentifierInfo *WeakId 4811 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4812 IdentifierInfo *AliasId 4813 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4814 SourceLocation Loc 4815 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 4816 bool Used = WeakUndeclaredIdentifiers[I++]; 4817 WeakInfo WI(AliasId, Loc); 4818 WI.setUsed(Used); 4819 WeakIDs.push_back(std::make_pair(WeakId, WI)); 4820 } 4821 WeakUndeclaredIdentifiers.clear(); 4822} 4823 4824void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 4825 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 4826 ExternalVTableUse VT; 4827 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4828 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 4829 VT.DefinitionRequired = VTableUses[Idx++]; 4830 VTables.push_back(VT); 4831 } 4832 4833 VTableUses.clear(); 4834} 4835 4836void ASTReader::ReadPendingInstantiations( 4837 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 4838 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 4839 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 4840 SourceLocation Loc 4841 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 4842 Pending.push_back(std::make_pair(D, Loc)); 4843 } 4844 PendingInstantiations.clear(); 4845} 4846 4847void ASTReader::LoadSelector(Selector Sel) { 4848 // It would be complicated to avoid reading the methods anyway. So don't. 4849 ReadMethodPool(Sel); 4850} 4851 4852void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 4853 assert(ID && "Non-zero identifier ID required"); 4854 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4855 IdentifiersLoaded[ID - 1] = II; 4856 if (DeserializationListener) 4857 DeserializationListener->IdentifierRead(ID, II); 4858} 4859 4860/// \brief Set the globally-visible declarations associated with the given 4861/// identifier. 4862/// 4863/// If the AST reader is currently in a state where the given declaration IDs 4864/// cannot safely be resolved, they are queued until it is safe to resolve 4865/// them. 4866/// 4867/// \param II an IdentifierInfo that refers to one or more globally-visible 4868/// declarations. 4869/// 4870/// \param DeclIDs the set of declaration IDs with the name @p II that are 4871/// visible at global scope. 4872/// 4873/// \param Nonrecursive should be true to indicate that the caller knows that 4874/// this call is non-recursive, and therefore the globally-visible declarations 4875/// will not be placed onto the pending queue. 4876void 4877ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4878 const SmallVectorImpl<uint32_t> &DeclIDs, 4879 bool Nonrecursive) { 4880 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4881 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4882 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4883 PII.II = II; 4884 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4885 return; 4886 } 4887 4888 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4889 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4890 if (SemaObj) { 4891 // Introduce this declaration into the translation-unit scope 4892 // and add it to the declaration chain for this identifier, so 4893 // that (unqualified) name lookup will find it. 4894 SemaObj->pushExternalDeclIntoScope(D, II); 4895 } else { 4896 // Queue this declaration so that it will be added to the 4897 // translation unit scope and identifier's declaration chain 4898 // once a Sema object is known. 4899 PreloadedDecls.push_back(D); 4900 } 4901 } 4902} 4903 4904IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 4905 if (ID == 0) 4906 return 0; 4907 4908 if (IdentifiersLoaded.empty()) { 4909 Error("no identifier table in AST file"); 4910 return 0; 4911 } 4912 4913 ID -= 1; 4914 if (!IdentifiersLoaded[ID]) { 4915 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 4916 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 4917 Module *M = I->second; 4918 unsigned Index = ID - M->BaseIdentifierID; 4919 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 4920 4921 // All of the strings in the AST file are preceded by a 16-bit length. 4922 // Extract that 16-bit length to avoid having to execute strlen(). 4923 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4924 // unsigned integers. This is important to avoid integer overflow when 4925 // we cast them to 'unsigned'. 4926 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4927 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4928 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4929 IdentifiersLoaded[ID] 4930 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 4931 if (DeserializationListener) 4932 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4933 } 4934 4935 return IdentifiersLoaded[ID]; 4936} 4937 4938IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) { 4939 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 4940} 4941 4942IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) { 4943 if (LocalID < NUM_PREDEF_IDENT_IDS) 4944 return LocalID; 4945 4946 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4947 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 4948 assert(I != M.IdentifierRemap.end() 4949 && "Invalid index into identifier index remap"); 4950 4951 return LocalID + I->second; 4952} 4953 4954bool ASTReader::ReadSLocEntry(int ID) { 4955 return ReadSLocEntryRecord(ID) != Success; 4956} 4957 4958Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) { 4959 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 4960} 4961 4962Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 4963 if (ID == 0) 4964 return Selector(); 4965 4966 if (ID > SelectorsLoaded.size()) { 4967 Error("selector ID out of range in AST file"); 4968 return Selector(); 4969 } 4970 4971 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4972 // Load this selector from the selector table. 4973 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 4974 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 4975 Module &M = *I->second; 4976 ASTSelectorLookupTrait Trait(*this, M); 4977 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 4978 SelectorsLoaded[ID - 1] = 4979 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 4980 if (DeserializationListener) 4981 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4982 } 4983 4984 return SelectorsLoaded[ID - 1]; 4985} 4986 4987Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 4988 return DecodeSelector(ID); 4989} 4990 4991uint32_t ASTReader::GetNumExternalSelectors() { 4992 // ID 0 (the null selector) is considered an external selector. 4993 return getTotalNumSelectors() + 1; 4994} 4995 4996serialization::SelectorID 4997ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const { 4998 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 4999 return LocalID; 5000 5001 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5002 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 5003 assert(I != M.SelectorRemap.end() 5004 && "Invalid index into identifier index remap"); 5005 5006 return LocalID + I->second; 5007} 5008 5009DeclarationName 5010ASTReader::ReadDeclarationName(Module &F, 5011 const RecordData &Record, unsigned &Idx) { 5012 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 5013 switch (Kind) { 5014 case DeclarationName::Identifier: 5015 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 5016 5017 case DeclarationName::ObjCZeroArgSelector: 5018 case DeclarationName::ObjCOneArgSelector: 5019 case DeclarationName::ObjCMultiArgSelector: 5020 return DeclarationName(ReadSelector(F, Record, Idx)); 5021 5022 case DeclarationName::CXXConstructorName: 5023 return Context.DeclarationNames.getCXXConstructorName( 5024 Context.getCanonicalType(readType(F, Record, Idx))); 5025 5026 case DeclarationName::CXXDestructorName: 5027 return Context.DeclarationNames.getCXXDestructorName( 5028 Context.getCanonicalType(readType(F, Record, Idx))); 5029 5030 case DeclarationName::CXXConversionFunctionName: 5031 return Context.DeclarationNames.getCXXConversionFunctionName( 5032 Context.getCanonicalType(readType(F, Record, Idx))); 5033 5034 case DeclarationName::CXXOperatorName: 5035 return Context.DeclarationNames.getCXXOperatorName( 5036 (OverloadedOperatorKind)Record[Idx++]); 5037 5038 case DeclarationName::CXXLiteralOperatorName: 5039 return Context.DeclarationNames.getCXXLiteralOperatorName( 5040 GetIdentifierInfo(F, Record, Idx)); 5041 5042 case DeclarationName::CXXUsingDirective: 5043 return DeclarationName::getUsingDirectiveName(); 5044 } 5045 5046 // Required to silence GCC warning 5047 return DeclarationName(); 5048} 5049 5050void ASTReader::ReadDeclarationNameLoc(Module &F, 5051 DeclarationNameLoc &DNLoc, 5052 DeclarationName Name, 5053 const RecordData &Record, unsigned &Idx) { 5054 switch (Name.getNameKind()) { 5055 case DeclarationName::CXXConstructorName: 5056 case DeclarationName::CXXDestructorName: 5057 case DeclarationName::CXXConversionFunctionName: 5058 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 5059 break; 5060 5061 case DeclarationName::CXXOperatorName: 5062 DNLoc.CXXOperatorName.BeginOpNameLoc 5063 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5064 DNLoc.CXXOperatorName.EndOpNameLoc 5065 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5066 break; 5067 5068 case DeclarationName::CXXLiteralOperatorName: 5069 DNLoc.CXXLiteralOperatorName.OpNameLoc 5070 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5071 break; 5072 5073 case DeclarationName::Identifier: 5074 case DeclarationName::ObjCZeroArgSelector: 5075 case DeclarationName::ObjCOneArgSelector: 5076 case DeclarationName::ObjCMultiArgSelector: 5077 case DeclarationName::CXXUsingDirective: 5078 break; 5079 } 5080} 5081 5082void ASTReader::ReadDeclarationNameInfo(Module &F, 5083 DeclarationNameInfo &NameInfo, 5084 const RecordData &Record, unsigned &Idx) { 5085 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 5086 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 5087 DeclarationNameLoc DNLoc; 5088 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5089 NameInfo.setInfo(DNLoc); 5090} 5091 5092void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info, 5093 const RecordData &Record, unsigned &Idx) { 5094 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5095 unsigned NumTPLists = Record[Idx++]; 5096 Info.NumTemplParamLists = NumTPLists; 5097 if (NumTPLists) { 5098 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 5099 for (unsigned i=0; i != NumTPLists; ++i) 5100 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5101 } 5102} 5103 5104TemplateName 5105ASTReader::ReadTemplateName(Module &F, const RecordData &Record, 5106 unsigned &Idx) { 5107 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5108 switch (Kind) { 5109 case TemplateName::Template: 5110 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5111 5112 case TemplateName::OverloadedTemplate: { 5113 unsigned size = Record[Idx++]; 5114 UnresolvedSet<8> Decls; 5115 while (size--) 5116 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5117 5118 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 5119 } 5120 5121 case TemplateName::QualifiedTemplate: { 5122 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5123 bool hasTemplKeyword = Record[Idx++]; 5124 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5125 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5126 } 5127 5128 case TemplateName::DependentTemplate: { 5129 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5130 if (Record[Idx++]) // isIdentifier 5131 return Context.getDependentTemplateName(NNS, 5132 GetIdentifierInfo(F, Record, 5133 Idx)); 5134 return Context.getDependentTemplateName(NNS, 5135 (OverloadedOperatorKind)Record[Idx++]); 5136 } 5137 5138 case TemplateName::SubstTemplateTemplateParm: { 5139 TemplateTemplateParmDecl *param 5140 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5141 if (!param) return TemplateName(); 5142 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5143 return Context.getSubstTemplateTemplateParm(param, replacement); 5144 } 5145 5146 case TemplateName::SubstTemplateTemplateParmPack: { 5147 TemplateTemplateParmDecl *Param 5148 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5149 if (!Param) 5150 return TemplateName(); 5151 5152 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5153 if (ArgPack.getKind() != TemplateArgument::Pack) 5154 return TemplateName(); 5155 5156 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 5157 } 5158 } 5159 5160 llvm_unreachable("Unhandled template name kind!"); 5161} 5162 5163TemplateArgument 5164ASTReader::ReadTemplateArgument(Module &F, 5165 const RecordData &Record, unsigned &Idx) { 5166 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5167 switch (Kind) { 5168 case TemplateArgument::Null: 5169 return TemplateArgument(); 5170 case TemplateArgument::Type: 5171 return TemplateArgument(readType(F, Record, Idx)); 5172 case TemplateArgument::Declaration: 5173 return TemplateArgument(ReadDecl(F, Record, Idx)); 5174 case TemplateArgument::Integral: { 5175 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5176 QualType T = readType(F, Record, Idx); 5177 return TemplateArgument(Value, T); 5178 } 5179 case TemplateArgument::Template: 5180 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5181 case TemplateArgument::TemplateExpansion: { 5182 TemplateName Name = ReadTemplateName(F, Record, Idx); 5183 llvm::Optional<unsigned> NumTemplateExpansions; 5184 if (unsigned NumExpansions = Record[Idx++]) 5185 NumTemplateExpansions = NumExpansions - 1; 5186 return TemplateArgument(Name, NumTemplateExpansions); 5187 } 5188 case TemplateArgument::Expression: 5189 return TemplateArgument(ReadExpr(F)); 5190 case TemplateArgument::Pack: { 5191 unsigned NumArgs = Record[Idx++]; 5192 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 5193 for (unsigned I = 0; I != NumArgs; ++I) 5194 Args[I] = ReadTemplateArgument(F, Record, Idx); 5195 return TemplateArgument(Args, NumArgs); 5196 } 5197 } 5198 5199 llvm_unreachable("Unhandled template argument kind!"); 5200} 5201 5202TemplateParameterList * 5203ASTReader::ReadTemplateParameterList(Module &F, 5204 const RecordData &Record, unsigned &Idx) { 5205 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5206 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5207 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5208 5209 unsigned NumParams = Record[Idx++]; 5210 SmallVector<NamedDecl *, 16> Params; 5211 Params.reserve(NumParams); 5212 while (NumParams--) 5213 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5214 5215 TemplateParameterList* TemplateParams = 5216 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 5217 Params.data(), Params.size(), RAngleLoc); 5218 return TemplateParams; 5219} 5220 5221void 5222ASTReader:: 5223ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5224 Module &F, const RecordData &Record, 5225 unsigned &Idx) { 5226 unsigned NumTemplateArgs = Record[Idx++]; 5227 TemplArgs.reserve(NumTemplateArgs); 5228 while (NumTemplateArgs--) 5229 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5230} 5231 5232/// \brief Read a UnresolvedSet structure. 5233void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set, 5234 const RecordData &Record, unsigned &Idx) { 5235 unsigned NumDecls = Record[Idx++]; 5236 while (NumDecls--) { 5237 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5238 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5239 Set.addDecl(D, AS); 5240 } 5241} 5242 5243CXXBaseSpecifier 5244ASTReader::ReadCXXBaseSpecifier(Module &F, 5245 const RecordData &Record, unsigned &Idx) { 5246 bool isVirtual = static_cast<bool>(Record[Idx++]); 5247 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5248 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5249 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5250 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5251 SourceRange Range = ReadSourceRange(F, Record, Idx); 5252 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5253 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5254 EllipsisLoc); 5255 Result.setInheritConstructors(inheritConstructors); 5256 return Result; 5257} 5258 5259std::pair<CXXCtorInitializer **, unsigned> 5260ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record, 5261 unsigned &Idx) { 5262 CXXCtorInitializer **CtorInitializers = 0; 5263 unsigned NumInitializers = Record[Idx++]; 5264 if (NumInitializers) { 5265 CtorInitializers 5266 = new (Context) CXXCtorInitializer*[NumInitializers]; 5267 for (unsigned i=0; i != NumInitializers; ++i) { 5268 TypeSourceInfo *TInfo = 0; 5269 bool IsBaseVirtual = false; 5270 FieldDecl *Member = 0; 5271 IndirectFieldDecl *IndirectMember = 0; 5272 5273 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5274 switch (Type) { 5275 case CTOR_INITIALIZER_BASE: 5276 TInfo = GetTypeSourceInfo(F, Record, Idx); 5277 IsBaseVirtual = Record[Idx++]; 5278 break; 5279 5280 case CTOR_INITIALIZER_DELEGATING: 5281 TInfo = GetTypeSourceInfo(F, Record, Idx); 5282 break; 5283 5284 case CTOR_INITIALIZER_MEMBER: 5285 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5286 break; 5287 5288 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5289 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5290 break; 5291 } 5292 5293 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5294 Expr *Init = ReadExpr(F); 5295 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5296 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5297 bool IsWritten = Record[Idx++]; 5298 unsigned SourceOrderOrNumArrayIndices; 5299 SmallVector<VarDecl *, 8> Indices; 5300 if (IsWritten) { 5301 SourceOrderOrNumArrayIndices = Record[Idx++]; 5302 } else { 5303 SourceOrderOrNumArrayIndices = Record[Idx++]; 5304 Indices.reserve(SourceOrderOrNumArrayIndices); 5305 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5306 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5307 } 5308 5309 CXXCtorInitializer *BOMInit; 5310 if (Type == CTOR_INITIALIZER_BASE) { 5311 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 5312 LParenLoc, Init, RParenLoc, 5313 MemberOrEllipsisLoc); 5314 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5315 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 5316 Init, RParenLoc); 5317 } else if (IsWritten) { 5318 if (Member) 5319 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 5320 LParenLoc, Init, RParenLoc); 5321 else 5322 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 5323 MemberOrEllipsisLoc, LParenLoc, 5324 Init, RParenLoc); 5325 } else { 5326 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 5327 LParenLoc, Init, RParenLoc, 5328 Indices.data(), Indices.size()); 5329 } 5330 5331 if (IsWritten) 5332 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5333 CtorInitializers[i] = BOMInit; 5334 } 5335 } 5336 5337 return std::make_pair(CtorInitializers, NumInitializers); 5338} 5339 5340NestedNameSpecifier * 5341ASTReader::ReadNestedNameSpecifier(Module &F, 5342 const RecordData &Record, unsigned &Idx) { 5343 unsigned N = Record[Idx++]; 5344 NestedNameSpecifier *NNS = 0, *Prev = 0; 5345 for (unsigned I = 0; I != N; ++I) { 5346 NestedNameSpecifier::SpecifierKind Kind 5347 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5348 switch (Kind) { 5349 case NestedNameSpecifier::Identifier: { 5350 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5351 NNS = NestedNameSpecifier::Create(Context, Prev, II); 5352 break; 5353 } 5354 5355 case NestedNameSpecifier::Namespace: { 5356 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5357 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 5358 break; 5359 } 5360 5361 case NestedNameSpecifier::NamespaceAlias: { 5362 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5363 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 5364 break; 5365 } 5366 5367 case NestedNameSpecifier::TypeSpec: 5368 case NestedNameSpecifier::TypeSpecWithTemplate: { 5369 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5370 if (!T) 5371 return 0; 5372 5373 bool Template = Record[Idx++]; 5374 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 5375 break; 5376 } 5377 5378 case NestedNameSpecifier::Global: { 5379 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 5380 // No associated value, and there can't be a prefix. 5381 break; 5382 } 5383 } 5384 Prev = NNS; 5385 } 5386 return NNS; 5387} 5388 5389NestedNameSpecifierLoc 5390ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record, 5391 unsigned &Idx) { 5392 unsigned N = Record[Idx++]; 5393 NestedNameSpecifierLocBuilder Builder; 5394 for (unsigned I = 0; I != N; ++I) { 5395 NestedNameSpecifier::SpecifierKind Kind 5396 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5397 switch (Kind) { 5398 case NestedNameSpecifier::Identifier: { 5399 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5400 SourceRange Range = ReadSourceRange(F, Record, Idx); 5401 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 5402 break; 5403 } 5404 5405 case NestedNameSpecifier::Namespace: { 5406 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5407 SourceRange Range = ReadSourceRange(F, Record, Idx); 5408 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 5409 break; 5410 } 5411 5412 case NestedNameSpecifier::NamespaceAlias: { 5413 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5414 SourceRange Range = ReadSourceRange(F, Record, Idx); 5415 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 5416 break; 5417 } 5418 5419 case NestedNameSpecifier::TypeSpec: 5420 case NestedNameSpecifier::TypeSpecWithTemplate: { 5421 bool Template = Record[Idx++]; 5422 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5423 if (!T) 5424 return NestedNameSpecifierLoc(); 5425 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5426 5427 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5428 Builder.Extend(Context, 5429 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5430 T->getTypeLoc(), ColonColonLoc); 5431 break; 5432 } 5433 5434 case NestedNameSpecifier::Global: { 5435 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5436 Builder.MakeGlobal(Context, ColonColonLoc); 5437 break; 5438 } 5439 } 5440 } 5441 5442 return Builder.getWithLocInContext(Context); 5443} 5444 5445SourceRange 5446ASTReader::ReadSourceRange(Module &F, const RecordData &Record, 5447 unsigned &Idx) { 5448 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5449 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5450 return SourceRange(beg, end); 5451} 5452 5453/// \brief Read an integral value 5454llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5455 unsigned BitWidth = Record[Idx++]; 5456 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5457 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5458 Idx += NumWords; 5459 return Result; 5460} 5461 5462/// \brief Read a signed integral value 5463llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5464 bool isUnsigned = Record[Idx++]; 5465 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5466} 5467 5468/// \brief Read a floating-point value 5469llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5470 return llvm::APFloat(ReadAPInt(Record, Idx)); 5471} 5472 5473// \brief Read a string 5474std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5475 unsigned Len = Record[Idx++]; 5476 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5477 Idx += Len; 5478 return Result; 5479} 5480 5481VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5482 unsigned &Idx) { 5483 unsigned Major = Record[Idx++]; 5484 unsigned Minor = Record[Idx++]; 5485 unsigned Subminor = Record[Idx++]; 5486 if (Minor == 0) 5487 return VersionTuple(Major); 5488 if (Subminor == 0) 5489 return VersionTuple(Major, Minor - 1); 5490 return VersionTuple(Major, Minor - 1, Subminor - 1); 5491} 5492 5493CXXTemporary *ASTReader::ReadCXXTemporary(Module &F, 5494 const RecordData &Record, 5495 unsigned &Idx) { 5496 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5497 return CXXTemporary::Create(Context, Decl); 5498} 5499 5500DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5501 return Diag(SourceLocation(), DiagID); 5502} 5503 5504DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5505 return Diags.Report(Loc, DiagID); 5506} 5507 5508/// \brief Retrieve the identifier table associated with the 5509/// preprocessor. 5510IdentifierTable &ASTReader::getIdentifierTable() { 5511 return PP.getIdentifierTable(); 5512} 5513 5514/// \brief Record that the given ID maps to the given switch-case 5515/// statement. 5516void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5517 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5518 SwitchCaseStmts[ID] = SC; 5519} 5520 5521/// \brief Retrieve the switch-case statement with the given ID. 5522SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5523 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5524 return SwitchCaseStmts[ID]; 5525} 5526 5527void ASTReader::ClearSwitchCaseIDs() { 5528 SwitchCaseStmts.clear(); 5529} 5530 5531void ASTReader::FinishedDeserializing() { 5532 assert(NumCurrentElementsDeserializing && 5533 "FinishedDeserializing not paired with StartedDeserializing"); 5534 if (NumCurrentElementsDeserializing == 1) { 5535 // If any identifiers with corresponding top-level declarations have 5536 // been loaded, load those declarations now. 5537 while (!PendingIdentifierInfos.empty()) { 5538 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5539 PendingIdentifierInfos.front().DeclIDs, true); 5540 PendingIdentifierInfos.pop_front(); 5541 } 5542 5543 // Ready to load previous declarations of Decls that were delayed. 5544 while (!PendingPreviousDecls.empty()) { 5545 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5546 PendingPreviousDecls.front().second); 5547 PendingPreviousDecls.pop_front(); 5548 } 5549 5550 for (std::vector<std::pair<ObjCInterfaceDecl *, 5551 serialization::DeclID> >::iterator 5552 I = PendingChainedObjCCategories.begin(), 5553 E = PendingChainedObjCCategories.end(); I != E; ++I) { 5554 loadObjCChainedCategories(I->second, I->first); 5555 } 5556 PendingChainedObjCCategories.clear(); 5557 5558 // We are not in recursive loading, so it's safe to pass the "interesting" 5559 // decls to the consumer. 5560 if (Consumer) 5561 PassInterestingDeclsToConsumer(); 5562 5563 assert(PendingForwardRefs.size() == 0 && 5564 "Some forward refs did not get linked to the definition!"); 5565 } 5566 --NumCurrentElementsDeserializing; 5567} 5568 5569ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 5570 StringRef isysroot, bool DisableValidation, 5571 bool DisableStatCache) 5572 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 5573 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 5574 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 5575 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5576 RelocatablePCH(false), isysroot(isysroot), 5577 DisableValidation(DisableValidation), 5578 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 5579 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 5580 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 5581 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 5582 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 5583 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 5584 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 5585 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 5586 NumCXXBaseSpecifiersLoaded(0) 5587{ 5588 SourceMgr.setExternalSLocEntrySource(this); 5589} 5590 5591ASTReader::~ASTReader() { 5592 for (DeclContextVisibleUpdatesPending::iterator 5593 I = PendingVisibleUpdates.begin(), 5594 E = PendingVisibleUpdates.end(); 5595 I != E; ++I) { 5596 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5597 F = I->second.end(); 5598 J != F; ++J) 5599 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 5600 } 5601} 5602