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