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