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