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