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