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