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