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