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