ASTReader.cpp revision facde171ae4b8926622a1bffa833732a06f1875b
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 const ASTReader::RecordData &Record; 4148 unsigned &Idx; 4149 4150 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4151 unsigned &I) { 4152 return Reader.ReadSourceLocation(F, R, I); 4153 } 4154 4155 template<typename T> 4156 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4157 return Reader.ReadDeclAs<T>(F, Record, Idx); 4158 } 4159 4160public: 4161 TypeLocReader(ASTReader &Reader, ModuleFile &F, 4162 const ASTReader::RecordData &Record, unsigned &Idx) 4163 : Reader(Reader), F(F), Record(Record), Idx(Idx) 4164 { } 4165 4166 // We want compile-time assurance that we've enumerated all of 4167 // these, so unfortunately we have to declare them first, then 4168 // define them out-of-line. 4169#define ABSTRACT_TYPELOC(CLASS, PARENT) 4170#define TYPELOC(CLASS, PARENT) \ 4171 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4172#include "clang/AST/TypeLocNodes.def" 4173 4174 void VisitFunctionTypeLoc(FunctionTypeLoc); 4175 void VisitArrayTypeLoc(ArrayTypeLoc); 4176}; 4177 4178void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4179 // nothing to do 4180} 4181void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4182 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4183 if (TL.needsExtraLocalData()) { 4184 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4185 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4186 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4187 TL.setModeAttr(Record[Idx++]); 4188 } 4189} 4190void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4191 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4192} 4193void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4194 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4195} 4196void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4197 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4198} 4199void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4200 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4201} 4202void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4203 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4204} 4205void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4206 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4207 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4208} 4209void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4210 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4211 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4212 if (Record[Idx++]) 4213 TL.setSizeExpr(Reader.ReadExpr(F)); 4214 else 4215 TL.setSizeExpr(0); 4216} 4217void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4218 VisitArrayTypeLoc(TL); 4219} 4220void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4221 VisitArrayTypeLoc(TL); 4222} 4223void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4224 VisitArrayTypeLoc(TL); 4225} 4226void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4227 DependentSizedArrayTypeLoc TL) { 4228 VisitArrayTypeLoc(TL); 4229} 4230void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4231 DependentSizedExtVectorTypeLoc TL) { 4232 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4233} 4234void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4235 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4236} 4237void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4238 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4239} 4240void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4241 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4242 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4243 TL.setTrailingReturn(Record[Idx++]); 4244 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4245 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4246 } 4247} 4248void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4249 VisitFunctionTypeLoc(TL); 4250} 4251void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4252 VisitFunctionTypeLoc(TL); 4253} 4254void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4255 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4256} 4257void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4258 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4259} 4260void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4261 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4262 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4263 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4264} 4265void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4266 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4267 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4268 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4269 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4270} 4271void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4272 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4273} 4274void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4275 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4276 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4277 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4278 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4279} 4280void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4281 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4282} 4283void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4284 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4285} 4286void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4287 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4288} 4289void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4290 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4291 if (TL.hasAttrOperand()) { 4292 SourceRange range; 4293 range.setBegin(ReadSourceLocation(Record, Idx)); 4294 range.setEnd(ReadSourceLocation(Record, Idx)); 4295 TL.setAttrOperandParensRange(range); 4296 } 4297 if (TL.hasAttrExprOperand()) { 4298 if (Record[Idx++]) 4299 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4300 else 4301 TL.setAttrExprOperand(0); 4302 } else if (TL.hasAttrEnumOperand()) 4303 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4304} 4305void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4306 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4307} 4308void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4309 SubstTemplateTypeParmTypeLoc TL) { 4310 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4311} 4312void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4313 SubstTemplateTypeParmPackTypeLoc TL) { 4314 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4315} 4316void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4317 TemplateSpecializationTypeLoc TL) { 4318 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4319 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4320 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4321 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4322 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4323 TL.setArgLocInfo(i, 4324 Reader.GetTemplateArgumentLocInfo(F, 4325 TL.getTypePtr()->getArg(i).getKind(), 4326 Record, Idx)); 4327} 4328void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4329 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4330 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4331} 4332void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4333 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4334 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4335} 4336void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4337 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4338} 4339void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4340 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4341 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4342 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4343} 4344void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4345 DependentTemplateSpecializationTypeLoc TL) { 4346 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4347 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4348 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4349 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4350 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4351 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4352 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4353 TL.setArgLocInfo(I, 4354 Reader.GetTemplateArgumentLocInfo(F, 4355 TL.getTypePtr()->getArg(I).getKind(), 4356 Record, Idx)); 4357} 4358void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4359 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4360} 4361void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4362 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4363} 4364void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4365 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4366 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4367 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4368 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4369 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4370} 4371void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4372 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4373} 4374void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4375 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4376 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4377 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4378} 4379 4380TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 4381 const RecordData &Record, 4382 unsigned &Idx) { 4383 QualType InfoTy = readType(F, Record, Idx); 4384 if (InfoTy.isNull()) 4385 return 0; 4386 4387 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 4388 TypeLocReader TLR(*this, F, Record, Idx); 4389 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4390 TLR.Visit(TL); 4391 return TInfo; 4392} 4393 4394QualType ASTReader::GetType(TypeID ID) { 4395 unsigned FastQuals = ID & Qualifiers::FastMask; 4396 unsigned Index = ID >> Qualifiers::FastWidth; 4397 4398 if (Index < NUM_PREDEF_TYPE_IDS) { 4399 QualType T; 4400 switch ((PredefinedTypeIDs)Index) { 4401 case PREDEF_TYPE_NULL_ID: return QualType(); 4402 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 4403 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 4404 4405 case PREDEF_TYPE_CHAR_U_ID: 4406 case PREDEF_TYPE_CHAR_S_ID: 4407 // FIXME: Check that the signedness of CharTy is correct! 4408 T = Context.CharTy; 4409 break; 4410 4411 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 4412 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 4413 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 4414 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 4415 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 4416 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 4417 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 4418 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 4419 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 4420 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 4421 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 4422 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 4423 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 4424 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 4425 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 4426 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 4427 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 4428 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 4429 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 4430 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 4431 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 4432 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 4433 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 4434 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 4435 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 4436 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 4437 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 4438 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 4439 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 4440 4441 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 4442 T = Context.getAutoRRefDeductType(); 4443 break; 4444 4445 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 4446 T = Context.ARCUnbridgedCastTy; 4447 break; 4448 4449 } 4450 4451 assert(!T.isNull() && "Unknown predefined type"); 4452 return T.withFastQualifiers(FastQuals); 4453 } 4454 4455 Index -= NUM_PREDEF_TYPE_IDS; 4456 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4457 if (TypesLoaded[Index].isNull()) { 4458 TypesLoaded[Index] = readTypeRecord(Index); 4459 if (TypesLoaded[Index].isNull()) 4460 return QualType(); 4461 4462 TypesLoaded[Index]->setFromAST(); 4463 if (DeserializationListener) 4464 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4465 TypesLoaded[Index]); 4466 } 4467 4468 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4469} 4470 4471QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 4472 return GetType(getGlobalTypeID(F, LocalID)); 4473} 4474 4475serialization::TypeID 4476ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 4477 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4478 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4479 4480 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4481 return LocalID; 4482 4483 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4484 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4485 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4486 4487 unsigned GlobalIndex = LocalIndex + I->second; 4488 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4489} 4490 4491TemplateArgumentLocInfo 4492ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 4493 TemplateArgument::ArgKind Kind, 4494 const RecordData &Record, 4495 unsigned &Index) { 4496 switch (Kind) { 4497 case TemplateArgument::Expression: 4498 return ReadExpr(F); 4499 case TemplateArgument::Type: 4500 return GetTypeSourceInfo(F, Record, Index); 4501 case TemplateArgument::Template: { 4502 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4503 Index); 4504 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4505 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4506 SourceLocation()); 4507 } 4508 case TemplateArgument::TemplateExpansion: { 4509 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4510 Index); 4511 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4512 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4513 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4514 EllipsisLoc); 4515 } 4516 case TemplateArgument::Null: 4517 case TemplateArgument::Integral: 4518 case TemplateArgument::Declaration: 4519 case TemplateArgument::Pack: 4520 return TemplateArgumentLocInfo(); 4521 } 4522 llvm_unreachable("unexpected template argument loc"); 4523} 4524 4525TemplateArgumentLoc 4526ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 4527 const RecordData &Record, unsigned &Index) { 4528 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4529 4530 if (Arg.getKind() == TemplateArgument::Expression) { 4531 if (Record[Index++]) // bool InfoHasSameExpr. 4532 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4533 } 4534 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4535 Record, Index)); 4536} 4537 4538Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4539 return GetDecl(ID); 4540} 4541 4542uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 4543 unsigned &Idx){ 4544 if (Idx >= Record.size()) 4545 return 0; 4546 4547 unsigned LocalID = Record[Idx++]; 4548 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4549} 4550 4551CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4552 RecordLocation Loc = getLocalBitOffset(Offset); 4553 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4554 SavedStreamPosition SavedPosition(Cursor); 4555 Cursor.JumpToBit(Loc.Offset); 4556 ReadingKindTracker ReadingKind(Read_Decl, *this); 4557 RecordData Record; 4558 unsigned Code = Cursor.ReadCode(); 4559 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4560 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4561 Error("Malformed AST file: missing C++ base specifiers"); 4562 return 0; 4563 } 4564 4565 unsigned Idx = 0; 4566 unsigned NumBases = Record[Idx++]; 4567 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4568 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4569 for (unsigned I = 0; I != NumBases; ++I) 4570 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4571 return Bases; 4572} 4573 4574serialization::DeclID 4575ASTReader::getGlobalDeclID(ModuleFile &F, unsigned LocalID) const { 4576 if (LocalID < NUM_PREDEF_DECL_IDS) 4577 return LocalID; 4578 4579 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4580 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4581 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4582 4583 return LocalID + I->second; 4584} 4585 4586bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 4587 ModuleFile &M) const { 4588 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 4589 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4590 return &M == I->second; 4591} 4592 4593ModuleFile *ASTReader::getOwningModuleFile(Decl *D) { 4594 if (!D->isFromASTFile()) 4595 return 0; 4596 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID()); 4597 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4598 return I->second; 4599} 4600 4601SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 4602 if (ID < NUM_PREDEF_DECL_IDS) 4603 return SourceLocation(); 4604 4605 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4606 4607 if (Index > DeclsLoaded.size()) { 4608 Error("declaration ID out-of-range for AST file"); 4609 return SourceLocation(); 4610 } 4611 4612 if (Decl *D = DeclsLoaded[Index]) 4613 return D->getLocation(); 4614 4615 unsigned RawLocation = 0; 4616 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 4617 return ReadSourceLocation(*Rec.F, RawLocation); 4618} 4619 4620Decl *ASTReader::GetDecl(DeclID ID) { 4621 if (ID < NUM_PREDEF_DECL_IDS) { 4622 switch ((PredefinedDeclIDs)ID) { 4623 case PREDEF_DECL_NULL_ID: 4624 return 0; 4625 4626 case PREDEF_DECL_TRANSLATION_UNIT_ID: 4627 return Context.getTranslationUnitDecl(); 4628 4629 case PREDEF_DECL_OBJC_ID_ID: 4630 return Context.getObjCIdDecl(); 4631 4632 case PREDEF_DECL_OBJC_SEL_ID: 4633 return Context.getObjCSelDecl(); 4634 4635 case PREDEF_DECL_OBJC_CLASS_ID: 4636 return Context.getObjCClassDecl(); 4637 4638 case PREDEF_DECL_OBJC_PROTOCOL_ID: 4639 return Context.getObjCProtocolDecl(); 4640 4641 case PREDEF_DECL_INT_128_ID: 4642 return Context.getInt128Decl(); 4643 4644 case PREDEF_DECL_UNSIGNED_INT_128_ID: 4645 return Context.getUInt128Decl(); 4646 4647 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 4648 return Context.getObjCInstanceTypeDecl(); 4649 } 4650 } 4651 4652 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4653 4654 if (Index >= DeclsLoaded.size()) { 4655 Error("declaration ID out-of-range for AST file"); 4656 } 4657 4658 if (!DeclsLoaded[Index]) { 4659 ReadDeclRecord(ID); 4660 if (DeserializationListener) 4661 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4662 } 4663 4664 return DeclsLoaded[Index]; 4665} 4666 4667DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 4668 DeclID GlobalID) { 4669 if (GlobalID < NUM_PREDEF_DECL_IDS) 4670 return GlobalID; 4671 4672 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 4673 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4674 ModuleFile *Owner = I->second; 4675 4676 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 4677 = M.GlobalToLocalDeclIDs.find(Owner); 4678 if (Pos == M.GlobalToLocalDeclIDs.end()) 4679 return 0; 4680 4681 return GlobalID - Owner->BaseDeclID + Pos->second; 4682} 4683 4684serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 4685 const RecordData &Record, 4686 unsigned &Idx) { 4687 if (Idx >= Record.size()) { 4688 Error("Corrupted AST file"); 4689 return 0; 4690 } 4691 4692 return getGlobalDeclID(F, Record[Idx++]); 4693} 4694 4695/// \brief Resolve the offset of a statement into a statement. 4696/// 4697/// This operation will read a new statement from the external 4698/// source each time it is called, and is meant to be used via a 4699/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4700Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4701 // Switch case IDs are per Decl. 4702 ClearSwitchCaseIDs(); 4703 4704 // Offset here is a global offset across the entire chain. 4705 RecordLocation Loc = getLocalBitOffset(Offset); 4706 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4707 return ReadStmtFromStream(*Loc.F); 4708} 4709 4710namespace { 4711 class FindExternalLexicalDeclsVisitor { 4712 ASTReader &Reader; 4713 const DeclContext *DC; 4714 bool (*isKindWeWant)(Decl::Kind); 4715 4716 SmallVectorImpl<Decl*> &Decls; 4717 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 4718 4719 public: 4720 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 4721 bool (*isKindWeWant)(Decl::Kind), 4722 SmallVectorImpl<Decl*> &Decls) 4723 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 4724 { 4725 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 4726 PredefsVisited[I] = false; 4727 } 4728 4729 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 4730 if (Preorder) 4731 return false; 4732 4733 FindExternalLexicalDeclsVisitor *This 4734 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 4735 4736 ModuleFile::DeclContextInfosMap::iterator Info 4737 = M.DeclContextInfos.find(This->DC); 4738 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 4739 return false; 4740 4741 // Load all of the declaration IDs 4742 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 4743 *IDE = ID + Info->second.NumLexicalDecls; 4744 ID != IDE; ++ID) { 4745 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 4746 continue; 4747 4748 // Don't add predefined declarations to the lexical context more 4749 // than once. 4750 if (ID->second < NUM_PREDEF_DECL_IDS) { 4751 if (This->PredefsVisited[ID->second]) 4752 continue; 4753 4754 This->PredefsVisited[ID->second] = true; 4755 } 4756 4757 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 4758 if (!This->DC->isDeclInLexicalTraversal(D)) 4759 This->Decls.push_back(D); 4760 } 4761 } 4762 4763 return false; 4764 } 4765 }; 4766} 4767 4768ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4769 bool (*isKindWeWant)(Decl::Kind), 4770 SmallVectorImpl<Decl*> &Decls) { 4771 // There might be lexical decls in multiple modules, for the TU at 4772 // least. Walk all of the modules in the order they were loaded. 4773 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 4774 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 4775 ++NumLexicalDeclContextsRead; 4776 return ELR_Success; 4777} 4778 4779namespace { 4780 4781class DeclIDComp { 4782 ASTReader &Reader; 4783 ModuleFile &Mod; 4784 4785public: 4786 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 4787 4788 bool operator()(LocalDeclID L, LocalDeclID R) const { 4789 SourceLocation LHS = getLocation(L); 4790 SourceLocation RHS = getLocation(R); 4791 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4792 } 4793 4794 bool operator()(SourceLocation LHS, LocalDeclID R) const { 4795 SourceLocation RHS = getLocation(R); 4796 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4797 } 4798 4799 bool operator()(LocalDeclID L, SourceLocation RHS) const { 4800 SourceLocation LHS = getLocation(L); 4801 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4802 } 4803 4804 SourceLocation getLocation(LocalDeclID ID) const { 4805 return Reader.getSourceManager().getFileLoc( 4806 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 4807 } 4808}; 4809 4810} 4811 4812void ASTReader::FindFileRegionDecls(FileID File, 4813 unsigned Offset, unsigned Length, 4814 SmallVectorImpl<Decl *> &Decls) { 4815 SourceManager &SM = getSourceManager(); 4816 4817 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 4818 if (I == FileDeclIDs.end()) 4819 return; 4820 4821 FileDeclsInfo &DInfo = I->second; 4822 if (DInfo.Decls.empty()) 4823 return; 4824 4825 SourceLocation 4826 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 4827 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 4828 4829 DeclIDComp DIDComp(*this, *DInfo.Mod); 4830 ArrayRef<serialization::LocalDeclID>::iterator 4831 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4832 BeginLoc, DIDComp); 4833 if (BeginIt != DInfo.Decls.begin()) 4834 --BeginIt; 4835 4836 // If we are pointing at a top-level decl inside an objc container, we need 4837 // to backtrack until we find it otherwise we will fail to report that the 4838 // region overlaps with an objc container. 4839 while (BeginIt != DInfo.Decls.begin() && 4840 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 4841 ->isTopLevelDeclInObjCContainer()) 4842 --BeginIt; 4843 4844 ArrayRef<serialization::LocalDeclID>::iterator 4845 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4846 EndLoc, DIDComp); 4847 if (EndIt != DInfo.Decls.end()) 4848 ++EndIt; 4849 4850 for (ArrayRef<serialization::LocalDeclID>::iterator 4851 DIt = BeginIt; DIt != EndIt; ++DIt) 4852 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 4853} 4854 4855namespace { 4856 /// \brief ModuleFile visitor used to perform name lookup into a 4857 /// declaration context. 4858 class DeclContextNameLookupVisitor { 4859 ASTReader &Reader; 4860 llvm::SmallVectorImpl<const DeclContext *> &Contexts; 4861 DeclarationName Name; 4862 SmallVectorImpl<NamedDecl *> &Decls; 4863 4864 public: 4865 DeclContextNameLookupVisitor(ASTReader &Reader, 4866 SmallVectorImpl<const DeclContext *> &Contexts, 4867 DeclarationName Name, 4868 SmallVectorImpl<NamedDecl *> &Decls) 4869 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { } 4870 4871 static bool visit(ModuleFile &M, void *UserData) { 4872 DeclContextNameLookupVisitor *This 4873 = static_cast<DeclContextNameLookupVisitor *>(UserData); 4874 4875 // Check whether we have any visible declaration information for 4876 // this context in this module. 4877 ModuleFile::DeclContextInfosMap::iterator Info; 4878 bool FoundInfo = false; 4879 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 4880 Info = M.DeclContextInfos.find(This->Contexts[I]); 4881 if (Info != M.DeclContextInfos.end() && 4882 Info->second.NameLookupTableData) { 4883 FoundInfo = true; 4884 break; 4885 } 4886 } 4887 4888 if (!FoundInfo) 4889 return false; 4890 4891 // Look for this name within this module. 4892 ASTDeclContextNameLookupTable *LookupTable = 4893 Info->second.NameLookupTableData; 4894 ASTDeclContextNameLookupTable::iterator Pos 4895 = LookupTable->find(This->Name); 4896 if (Pos == LookupTable->end()) 4897 return false; 4898 4899 bool FoundAnything = false; 4900 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4901 for (; Data.first != Data.second; ++Data.first) { 4902 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 4903 if (!ND) 4904 continue; 4905 4906 if (ND->getDeclName() != This->Name) { 4907 assert(!This->Name.getCXXNameType().isNull() && 4908 "Name mismatch without a type"); 4909 continue; 4910 } 4911 4912 // Record this declaration. 4913 FoundAnything = true; 4914 This->Decls.push_back(ND); 4915 } 4916 4917 return FoundAnything; 4918 } 4919 }; 4920} 4921 4922DeclContext::lookup_result 4923ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4924 DeclarationName Name) { 4925 assert(DC->hasExternalVisibleStorage() && 4926 "DeclContext has no visible decls in storage"); 4927 if (!Name) 4928 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4929 DeclContext::lookup_iterator(0)); 4930 4931 SmallVector<NamedDecl *, 64> Decls; 4932 4933 // Compute the declaration contexts we need to look into. Multiple such 4934 // declaration contexts occur when two declaration contexts from disjoint 4935 // modules get merged, e.g., when two namespaces with the same name are 4936 // independently defined in separate modules. 4937 SmallVector<const DeclContext *, 2> Contexts; 4938 Contexts.push_back(DC); 4939 4940 if (DC->isNamespace()) { 4941 MergedDeclsMap::iterator Merged 4942 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 4943 if (Merged != MergedDecls.end()) { 4944 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 4945 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 4946 } 4947 } 4948 4949 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls); 4950 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 4951 ++NumVisibleDeclContextsRead; 4952 SetExternalVisibleDeclsForName(DC, Name, Decls); 4953 return const_cast<DeclContext*>(DC)->lookup(Name); 4954} 4955 4956namespace { 4957 /// \brief ModuleFile visitor used to retrieve all visible names in a 4958 /// declaration context. 4959 class DeclContextAllNamesVisitor { 4960 ASTReader &Reader; 4961 llvm::SmallVectorImpl<const DeclContext *> &Contexts; 4962 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls; 4963 4964 public: 4965 DeclContextAllNamesVisitor(ASTReader &Reader, 4966 SmallVectorImpl<const DeclContext *> &Contexts, 4967 llvm::DenseMap<DeclarationName, 4968 SmallVector<NamedDecl *, 8> > &Decls) 4969 : Reader(Reader), Contexts(Contexts), Decls(Decls) { } 4970 4971 static bool visit(ModuleFile &M, void *UserData) { 4972 DeclContextAllNamesVisitor *This 4973 = static_cast<DeclContextAllNamesVisitor *>(UserData); 4974 4975 // Check whether we have any visible declaration information for 4976 // this context in this module. 4977 ModuleFile::DeclContextInfosMap::iterator Info; 4978 bool FoundInfo = false; 4979 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 4980 Info = M.DeclContextInfos.find(This->Contexts[I]); 4981 if (Info != M.DeclContextInfos.end() && 4982 Info->second.NameLookupTableData) { 4983 FoundInfo = true; 4984 break; 4985 } 4986 } 4987 4988 if (!FoundInfo) 4989 return false; 4990 4991 ASTDeclContextNameLookupTable *LookupTable = 4992 Info->second.NameLookupTableData; 4993 bool FoundAnything = false; 4994 for (ASTDeclContextNameLookupTable::data_iterator 4995 I = LookupTable->data_begin(), E = LookupTable->data_end(); 4996 I != E; ++I) { 4997 ASTDeclContextNameLookupTrait::data_type Data = *I; 4998 for (; Data.first != Data.second; ++Data.first) { 4999 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, 5000 *Data.first); 5001 if (!ND) 5002 continue; 5003 5004 // Record this declaration. 5005 FoundAnything = true; 5006 This->Decls[ND->getDeclName()].push_back(ND); 5007 } 5008 } 5009 5010 return FoundAnything; 5011 } 5012 }; 5013} 5014 5015void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) { 5016 if (!DC->hasExternalVisibleStorage()) 5017 return; 5018 llvm::DenseMap<DeclarationName, llvm::SmallVector<NamedDecl*, 8> > Decls; 5019 5020 // Compute the declaration contexts we need to look into. Multiple such 5021 // declaration contexts occur when two declaration contexts from disjoint 5022 // modules get merged, e.g., when two namespaces with the same name are 5023 // independently defined in separate modules. 5024 SmallVector<const DeclContext *, 2> Contexts; 5025 Contexts.push_back(DC); 5026 5027 if (DC->isNamespace()) { 5028 MergedDeclsMap::iterator Merged 5029 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5030 if (Merged != MergedDecls.end()) { 5031 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5032 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5033 } 5034 } 5035 5036 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls); 5037 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor); 5038 ++NumVisibleDeclContextsRead; 5039 5040 for (llvm::DenseMap<DeclarationName, 5041 llvm::SmallVector<NamedDecl*, 8> >::iterator 5042 I = Decls.begin(), E = Decls.end(); I != E; ++I) { 5043 SetExternalVisibleDeclsForName(DC, I->first, I->second); 5044 } 5045 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false); 5046} 5047 5048/// \brief Under non-PCH compilation the consumer receives the objc methods 5049/// before receiving the implementation, and codegen depends on this. 5050/// We simulate this by deserializing and passing to consumer the methods of the 5051/// implementation before passing the deserialized implementation decl. 5052static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 5053 ASTConsumer *Consumer) { 5054 assert(ImplD && Consumer); 5055 5056 for (ObjCImplDecl::method_iterator 5057 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 5058 Consumer->HandleInterestingDecl(DeclGroupRef(&*I)); 5059 5060 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 5061} 5062 5063void ASTReader::PassInterestingDeclsToConsumer() { 5064 assert(Consumer); 5065 while (!InterestingDecls.empty()) { 5066 Decl *D = InterestingDecls.front(); 5067 InterestingDecls.pop_front(); 5068 5069 PassInterestingDeclToConsumer(D); 5070 } 5071} 5072 5073void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 5074 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 5075 PassObjCImplDeclToConsumer(ImplD, Consumer); 5076 else 5077 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 5078} 5079 5080void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 5081 this->Consumer = Consumer; 5082 5083 if (!Consumer) 5084 return; 5085 5086 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 5087 // Force deserialization of this decl, which will cause it to be queued for 5088 // passing to the consumer. 5089 GetDecl(ExternalDefinitions[I]); 5090 } 5091 ExternalDefinitions.clear(); 5092 5093 PassInterestingDeclsToConsumer(); 5094} 5095 5096void ASTReader::PrintStats() { 5097 std::fprintf(stderr, "*** AST File Statistics:\n"); 5098 5099 unsigned NumTypesLoaded 5100 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 5101 QualType()); 5102 unsigned NumDeclsLoaded 5103 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 5104 (Decl *)0); 5105 unsigned NumIdentifiersLoaded 5106 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 5107 IdentifiersLoaded.end(), 5108 (IdentifierInfo *)0); 5109 unsigned NumSelectorsLoaded 5110 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 5111 SelectorsLoaded.end(), 5112 Selector()); 5113 5114 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 5115 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 5116 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 5117 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 5118 NumSLocEntriesRead, TotalNumSLocEntries, 5119 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 5120 if (!TypesLoaded.empty()) 5121 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 5122 NumTypesLoaded, (unsigned)TypesLoaded.size(), 5123 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 5124 if (!DeclsLoaded.empty()) 5125 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 5126 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 5127 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 5128 if (!IdentifiersLoaded.empty()) 5129 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 5130 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 5131 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 5132 if (!SelectorsLoaded.empty()) 5133 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 5134 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 5135 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 5136 if (TotalNumStatements) 5137 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 5138 NumStatementsRead, TotalNumStatements, 5139 ((float)NumStatementsRead/TotalNumStatements * 100)); 5140 if (TotalNumMacros) 5141 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5142 NumMacrosRead, TotalNumMacros, 5143 ((float)NumMacrosRead/TotalNumMacros * 100)); 5144 if (TotalLexicalDeclContexts) 5145 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 5146 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 5147 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 5148 * 100)); 5149 if (TotalVisibleDeclContexts) 5150 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 5151 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 5152 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 5153 * 100)); 5154 if (TotalNumMethodPoolEntries) { 5155 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 5156 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 5157 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 5158 * 100)); 5159 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 5160 } 5161 std::fprintf(stderr, "\n"); 5162 dump(); 5163 std::fprintf(stderr, "\n"); 5164} 5165 5166template<typename Key, typename ModuleFile, unsigned InitialCapacity> 5167static void 5168dumpModuleIDMap(StringRef Name, 5169 const ContinuousRangeMap<Key, ModuleFile *, 5170 InitialCapacity> &Map) { 5171 if (Map.begin() == Map.end()) 5172 return; 5173 5174 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 5175 llvm::errs() << Name << ":\n"; 5176 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5177 I != IEnd; ++I) { 5178 llvm::errs() << " " << I->first << " -> " << I->second->FileName 5179 << "\n"; 5180 } 5181} 5182 5183void ASTReader::dump() { 5184 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 5185 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 5186 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 5187 dumpModuleIDMap("Global type map", GlobalTypeMap); 5188 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 5189 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 5190 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 5191 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 5192 dumpModuleIDMap("Global preprocessed entity map", 5193 GlobalPreprocessedEntityMap); 5194 5195 llvm::errs() << "\n*** PCH/Modules Loaded:"; 5196 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 5197 MEnd = ModuleMgr.end(); 5198 M != MEnd; ++M) 5199 (*M)->dump(); 5200} 5201 5202/// Return the amount of memory used by memory buffers, breaking down 5203/// by heap-backed versus mmap'ed memory. 5204void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 5205 for (ModuleConstIterator I = ModuleMgr.begin(), 5206 E = ModuleMgr.end(); I != E; ++I) { 5207 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 5208 size_t bytes = buf->getBufferSize(); 5209 switch (buf->getBufferKind()) { 5210 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 5211 sizes.malloc_bytes += bytes; 5212 break; 5213 case llvm::MemoryBuffer::MemoryBuffer_MMap: 5214 sizes.mmap_bytes += bytes; 5215 break; 5216 } 5217 } 5218 } 5219} 5220 5221void ASTReader::InitializeSema(Sema &S) { 5222 SemaObj = &S; 5223 S.ExternalSource = this; 5224 5225 // Makes sure any declarations that were deserialized "too early" 5226 // still get added to the identifier's declaration chains. 5227 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 5228 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I], 5229 PreloadedDecls[I]->getDeclName()); 5230 } 5231 PreloadedDecls.clear(); 5232 5233 // Load the offsets of the declarations that Sema references. 5234 // They will be lazily deserialized when needed. 5235 if (!SemaDeclRefs.empty()) { 5236 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 5237 if (!SemaObj->StdNamespace) 5238 SemaObj->StdNamespace = SemaDeclRefs[0]; 5239 if (!SemaObj->StdBadAlloc) 5240 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 5241 } 5242 5243 if (!FPPragmaOptions.empty()) { 5244 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 5245 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 5246 } 5247 5248 if (!OpenCLExtensions.empty()) { 5249 unsigned I = 0; 5250#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 5251#include "clang/Basic/OpenCLExtensions.def" 5252 5253 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 5254 } 5255} 5256 5257IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 5258 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart), 5259 /*PriorGeneration=*/0); 5260 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 5261 IdentifierInfo *II = Visitor.getIdentifierInfo(); 5262 markIdentifierUpToDate(II); 5263 return II; 5264} 5265 5266namespace clang { 5267 /// \brief An identifier-lookup iterator that enumerates all of the 5268 /// identifiers stored within a set of AST files. 5269 class ASTIdentifierIterator : public IdentifierIterator { 5270 /// \brief The AST reader whose identifiers are being enumerated. 5271 const ASTReader &Reader; 5272 5273 /// \brief The current index into the chain of AST files stored in 5274 /// the AST reader. 5275 unsigned Index; 5276 5277 /// \brief The current position within the identifier lookup table 5278 /// of the current AST file. 5279 ASTIdentifierLookupTable::key_iterator Current; 5280 5281 /// \brief The end position within the identifier lookup table of 5282 /// the current AST file. 5283 ASTIdentifierLookupTable::key_iterator End; 5284 5285 public: 5286 explicit ASTIdentifierIterator(const ASTReader &Reader); 5287 5288 virtual StringRef Next(); 5289 }; 5290} 5291 5292ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 5293 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 5294 ASTIdentifierLookupTable *IdTable 5295 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 5296 Current = IdTable->key_begin(); 5297 End = IdTable->key_end(); 5298} 5299 5300StringRef ASTIdentifierIterator::Next() { 5301 while (Current == End) { 5302 // If we have exhausted all of our AST files, we're done. 5303 if (Index == 0) 5304 return StringRef(); 5305 5306 --Index; 5307 ASTIdentifierLookupTable *IdTable 5308 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 5309 IdentifierLookupTable; 5310 Current = IdTable->key_begin(); 5311 End = IdTable->key_end(); 5312 } 5313 5314 // We have any identifiers remaining in the current AST file; return 5315 // the next one. 5316 std::pair<const char*, unsigned> Key = *Current; 5317 ++Current; 5318 return StringRef(Key.first, Key.second); 5319} 5320 5321IdentifierIterator *ASTReader::getIdentifiers() const { 5322 return new ASTIdentifierIterator(*this); 5323} 5324 5325namespace clang { namespace serialization { 5326 class ReadMethodPoolVisitor { 5327 ASTReader &Reader; 5328 Selector Sel; 5329 unsigned PriorGeneration; 5330 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 5331 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 5332 5333 public: 5334 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, 5335 unsigned PriorGeneration) 5336 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { } 5337 5338 static bool visit(ModuleFile &M, void *UserData) { 5339 ReadMethodPoolVisitor *This 5340 = static_cast<ReadMethodPoolVisitor *>(UserData); 5341 5342 if (!M.SelectorLookupTable) 5343 return false; 5344 5345 // If we've already searched this module file, skip it now. 5346 if (M.Generation <= This->PriorGeneration) 5347 return true; 5348 5349 ASTSelectorLookupTable *PoolTable 5350 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 5351 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 5352 if (Pos == PoolTable->end()) 5353 return false; 5354 5355 ++This->Reader.NumSelectorsRead; 5356 // FIXME: Not quite happy with the statistics here. We probably should 5357 // disable this tracking when called via LoadSelector. 5358 // Also, should entries without methods count as misses? 5359 ++This->Reader.NumMethodPoolEntriesRead; 5360 ASTSelectorLookupTrait::data_type Data = *Pos; 5361 if (This->Reader.DeserializationListener) 5362 This->Reader.DeserializationListener->SelectorRead(Data.ID, 5363 This->Sel); 5364 5365 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 5366 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 5367 return true; 5368 } 5369 5370 /// \brief Retrieve the instance methods found by this visitor. 5371 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const { 5372 return InstanceMethods; 5373 } 5374 5375 /// \brief Retrieve the instance methods found by this visitor. 5376 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const { 5377 return FactoryMethods; 5378 } 5379 }; 5380} } // end namespace clang::serialization 5381 5382/// \brief Add the given set of methods to the method list. 5383static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods, 5384 ObjCMethodList &List) { 5385 for (unsigned I = 0, N = Methods.size(); I != N; ++I) { 5386 S.addMethodToGlobalList(&List, Methods[I]); 5387 } 5388} 5389 5390void ASTReader::ReadMethodPool(Selector Sel) { 5391 // Get the selector generation and update it to the current generation. 5392 unsigned &Generation = SelectorGeneration[Sel]; 5393 unsigned PriorGeneration = Generation; 5394 Generation = CurrentGeneration; 5395 5396 // Search for methods defined with this selector. 5397 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration); 5398 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 5399 5400 if (Visitor.getInstanceMethods().empty() && 5401 Visitor.getFactoryMethods().empty()) { 5402 ++NumMethodPoolMisses; 5403 return; 5404 } 5405 5406 if (!getSema()) 5407 return; 5408 5409 Sema &S = *getSema(); 5410 Sema::GlobalMethodPool::iterator Pos 5411 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first; 5412 5413 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first); 5414 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second); 5415} 5416 5417void ASTReader::ReadKnownNamespaces( 5418 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 5419 Namespaces.clear(); 5420 5421 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 5422 if (NamespaceDecl *Namespace 5423 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 5424 Namespaces.push_back(Namespace); 5425 } 5426} 5427 5428void ASTReader::ReadTentativeDefinitions( 5429 SmallVectorImpl<VarDecl *> &TentativeDefs) { 5430 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 5431 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 5432 if (Var) 5433 TentativeDefs.push_back(Var); 5434 } 5435 TentativeDefinitions.clear(); 5436} 5437 5438void ASTReader::ReadUnusedFileScopedDecls( 5439 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 5440 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 5441 DeclaratorDecl *D 5442 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 5443 if (D) 5444 Decls.push_back(D); 5445 } 5446 UnusedFileScopedDecls.clear(); 5447} 5448 5449void ASTReader::ReadDelegatingConstructors( 5450 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 5451 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 5452 CXXConstructorDecl *D 5453 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 5454 if (D) 5455 Decls.push_back(D); 5456 } 5457 DelegatingCtorDecls.clear(); 5458} 5459 5460void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 5461 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 5462 TypedefNameDecl *D 5463 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 5464 if (D) 5465 Decls.push_back(D); 5466 } 5467 ExtVectorDecls.clear(); 5468} 5469 5470void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 5471 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 5472 CXXRecordDecl *D 5473 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 5474 if (D) 5475 Decls.push_back(D); 5476 } 5477 DynamicClasses.clear(); 5478} 5479 5480void 5481ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 5482 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 5483 NamedDecl *D 5484 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 5485 if (D) 5486 Decls.push_back(D); 5487 } 5488 LocallyScopedExternalDecls.clear(); 5489} 5490 5491void ASTReader::ReadReferencedSelectors( 5492 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 5493 if (ReferencedSelectorsData.empty()) 5494 return; 5495 5496 // If there are @selector references added them to its pool. This is for 5497 // implementation of -Wselector. 5498 unsigned int DataSize = ReferencedSelectorsData.size()-1; 5499 unsigned I = 0; 5500 while (I < DataSize) { 5501 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 5502 SourceLocation SelLoc 5503 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 5504 Sels.push_back(std::make_pair(Sel, SelLoc)); 5505 } 5506 ReferencedSelectorsData.clear(); 5507} 5508 5509void ASTReader::ReadWeakUndeclaredIdentifiers( 5510 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 5511 if (WeakUndeclaredIdentifiers.empty()) 5512 return; 5513 5514 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 5515 IdentifierInfo *WeakId 5516 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5517 IdentifierInfo *AliasId 5518 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5519 SourceLocation Loc 5520 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 5521 bool Used = WeakUndeclaredIdentifiers[I++]; 5522 WeakInfo WI(AliasId, Loc); 5523 WI.setUsed(Used); 5524 WeakIDs.push_back(std::make_pair(WeakId, WI)); 5525 } 5526 WeakUndeclaredIdentifiers.clear(); 5527} 5528 5529void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 5530 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 5531 ExternalVTableUse VT; 5532 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 5533 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 5534 VT.DefinitionRequired = VTableUses[Idx++]; 5535 VTables.push_back(VT); 5536 } 5537 5538 VTableUses.clear(); 5539} 5540 5541void ASTReader::ReadPendingInstantiations( 5542 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 5543 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 5544 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 5545 SourceLocation Loc 5546 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 5547 Pending.push_back(std::make_pair(D, Loc)); 5548 } 5549 PendingInstantiations.clear(); 5550} 5551 5552void ASTReader::LoadSelector(Selector Sel) { 5553 // It would be complicated to avoid reading the methods anyway. So don't. 5554 ReadMethodPool(Sel); 5555} 5556 5557void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 5558 assert(ID && "Non-zero identifier ID required"); 5559 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 5560 IdentifiersLoaded[ID - 1] = II; 5561 if (DeserializationListener) 5562 DeserializationListener->IdentifierRead(ID, II); 5563} 5564 5565/// \brief Set the globally-visible declarations associated with the given 5566/// identifier. 5567/// 5568/// If the AST reader is currently in a state where the given declaration IDs 5569/// cannot safely be resolved, they are queued until it is safe to resolve 5570/// them. 5571/// 5572/// \param II an IdentifierInfo that refers to one or more globally-visible 5573/// declarations. 5574/// 5575/// \param DeclIDs the set of declaration IDs with the name @p II that are 5576/// visible at global scope. 5577/// 5578/// \param Nonrecursive should be true to indicate that the caller knows that 5579/// this call is non-recursive, and therefore the globally-visible declarations 5580/// will not be placed onto the pending queue. 5581void 5582ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 5583 const SmallVectorImpl<uint32_t> &DeclIDs, 5584 bool Nonrecursive) { 5585 if (NumCurrentElementsDeserializing && !Nonrecursive) { 5586 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 5587 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 5588 PII.II = II; 5589 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 5590 return; 5591 } 5592 5593 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 5594 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 5595 if (SemaObj) { 5596 // Introduce this declaration into the translation-unit scope 5597 // and add it to the declaration chain for this identifier, so 5598 // that (unqualified) name lookup will find it. 5599 SemaObj->pushExternalDeclIntoScope(D, II); 5600 } else { 5601 // Queue this declaration so that it will be added to the 5602 // translation unit scope and identifier's declaration chain 5603 // once a Sema object is known. 5604 PreloadedDecls.push_back(D); 5605 } 5606 } 5607} 5608 5609IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 5610 if (ID == 0) 5611 return 0; 5612 5613 if (IdentifiersLoaded.empty()) { 5614 Error("no identifier table in AST file"); 5615 return 0; 5616 } 5617 5618 ID -= 1; 5619 if (!IdentifiersLoaded[ID]) { 5620 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 5621 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 5622 ModuleFile *M = I->second; 5623 unsigned Index = ID - M->BaseIdentifierID; 5624 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 5625 5626 // All of the strings in the AST file are preceded by a 16-bit length. 5627 // Extract that 16-bit length to avoid having to execute strlen(). 5628 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 5629 // unsigned integers. This is important to avoid integer overflow when 5630 // we cast them to 'unsigned'. 5631 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 5632 unsigned StrLen = (((unsigned) StrLenPtr[0]) 5633 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 5634 IdentifiersLoaded[ID] 5635 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 5636 if (DeserializationListener) 5637 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 5638 } 5639 5640 return IdentifiersLoaded[ID]; 5641} 5642 5643IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 5644 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 5645} 5646 5647IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 5648 if (LocalID < NUM_PREDEF_IDENT_IDS) 5649 return LocalID; 5650 5651 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5652 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 5653 assert(I != M.IdentifierRemap.end() 5654 && "Invalid index into identifier index remap"); 5655 5656 return LocalID + I->second; 5657} 5658 5659bool ASTReader::ReadSLocEntry(int ID) { 5660 return ReadSLocEntryRecord(ID) != Success; 5661} 5662 5663serialization::SubmoduleID 5664ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 5665 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 5666 return LocalID; 5667 5668 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5669 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 5670 assert(I != M.SubmoduleRemap.end() 5671 && "Invalid index into identifier index remap"); 5672 5673 return LocalID + I->second; 5674} 5675 5676Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 5677 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 5678 assert(GlobalID == 0 && "Unhandled global submodule ID"); 5679 return 0; 5680 } 5681 5682 if (GlobalID > SubmodulesLoaded.size()) { 5683 Error("submodule ID out of range in AST file"); 5684 return 0; 5685 } 5686 5687 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 5688} 5689 5690Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 5691 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 5692} 5693 5694Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 5695 if (ID == 0) 5696 return Selector(); 5697 5698 if (ID > SelectorsLoaded.size()) { 5699 Error("selector ID out of range in AST file"); 5700 return Selector(); 5701 } 5702 5703 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 5704 // Load this selector from the selector table. 5705 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 5706 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 5707 ModuleFile &M = *I->second; 5708 ASTSelectorLookupTrait Trait(*this, M); 5709 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 5710 SelectorsLoaded[ID - 1] = 5711 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 5712 if (DeserializationListener) 5713 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 5714 } 5715 5716 return SelectorsLoaded[ID - 1]; 5717} 5718 5719Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 5720 return DecodeSelector(ID); 5721} 5722 5723uint32_t ASTReader::GetNumExternalSelectors() { 5724 // ID 0 (the null selector) is considered an external selector. 5725 return getTotalNumSelectors() + 1; 5726} 5727 5728serialization::SelectorID 5729ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 5730 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 5731 return LocalID; 5732 5733 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5734 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 5735 assert(I != M.SelectorRemap.end() 5736 && "Invalid index into identifier index remap"); 5737 5738 return LocalID + I->second; 5739} 5740 5741DeclarationName 5742ASTReader::ReadDeclarationName(ModuleFile &F, 5743 const RecordData &Record, unsigned &Idx) { 5744 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 5745 switch (Kind) { 5746 case DeclarationName::Identifier: 5747 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 5748 5749 case DeclarationName::ObjCZeroArgSelector: 5750 case DeclarationName::ObjCOneArgSelector: 5751 case DeclarationName::ObjCMultiArgSelector: 5752 return DeclarationName(ReadSelector(F, Record, Idx)); 5753 5754 case DeclarationName::CXXConstructorName: 5755 return Context.DeclarationNames.getCXXConstructorName( 5756 Context.getCanonicalType(readType(F, Record, Idx))); 5757 5758 case DeclarationName::CXXDestructorName: 5759 return Context.DeclarationNames.getCXXDestructorName( 5760 Context.getCanonicalType(readType(F, Record, Idx))); 5761 5762 case DeclarationName::CXXConversionFunctionName: 5763 return Context.DeclarationNames.getCXXConversionFunctionName( 5764 Context.getCanonicalType(readType(F, Record, Idx))); 5765 5766 case DeclarationName::CXXOperatorName: 5767 return Context.DeclarationNames.getCXXOperatorName( 5768 (OverloadedOperatorKind)Record[Idx++]); 5769 5770 case DeclarationName::CXXLiteralOperatorName: 5771 return Context.DeclarationNames.getCXXLiteralOperatorName( 5772 GetIdentifierInfo(F, Record, Idx)); 5773 5774 case DeclarationName::CXXUsingDirective: 5775 return DeclarationName::getUsingDirectiveName(); 5776 } 5777 5778 llvm_unreachable("Invalid NameKind!"); 5779} 5780 5781void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 5782 DeclarationNameLoc &DNLoc, 5783 DeclarationName Name, 5784 const RecordData &Record, unsigned &Idx) { 5785 switch (Name.getNameKind()) { 5786 case DeclarationName::CXXConstructorName: 5787 case DeclarationName::CXXDestructorName: 5788 case DeclarationName::CXXConversionFunctionName: 5789 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 5790 break; 5791 5792 case DeclarationName::CXXOperatorName: 5793 DNLoc.CXXOperatorName.BeginOpNameLoc 5794 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5795 DNLoc.CXXOperatorName.EndOpNameLoc 5796 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5797 break; 5798 5799 case DeclarationName::CXXLiteralOperatorName: 5800 DNLoc.CXXLiteralOperatorName.OpNameLoc 5801 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5802 break; 5803 5804 case DeclarationName::Identifier: 5805 case DeclarationName::ObjCZeroArgSelector: 5806 case DeclarationName::ObjCOneArgSelector: 5807 case DeclarationName::ObjCMultiArgSelector: 5808 case DeclarationName::CXXUsingDirective: 5809 break; 5810 } 5811} 5812 5813void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 5814 DeclarationNameInfo &NameInfo, 5815 const RecordData &Record, unsigned &Idx) { 5816 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 5817 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 5818 DeclarationNameLoc DNLoc; 5819 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5820 NameInfo.setInfo(DNLoc); 5821} 5822 5823void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 5824 const RecordData &Record, unsigned &Idx) { 5825 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5826 unsigned NumTPLists = Record[Idx++]; 5827 Info.NumTemplParamLists = NumTPLists; 5828 if (NumTPLists) { 5829 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 5830 for (unsigned i=0; i != NumTPLists; ++i) 5831 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5832 } 5833} 5834 5835TemplateName 5836ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 5837 unsigned &Idx) { 5838 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5839 switch (Kind) { 5840 case TemplateName::Template: 5841 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5842 5843 case TemplateName::OverloadedTemplate: { 5844 unsigned size = Record[Idx++]; 5845 UnresolvedSet<8> Decls; 5846 while (size--) 5847 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5848 5849 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 5850 } 5851 5852 case TemplateName::QualifiedTemplate: { 5853 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5854 bool hasTemplKeyword = Record[Idx++]; 5855 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5856 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5857 } 5858 5859 case TemplateName::DependentTemplate: { 5860 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5861 if (Record[Idx++]) // isIdentifier 5862 return Context.getDependentTemplateName(NNS, 5863 GetIdentifierInfo(F, Record, 5864 Idx)); 5865 return Context.getDependentTemplateName(NNS, 5866 (OverloadedOperatorKind)Record[Idx++]); 5867 } 5868 5869 case TemplateName::SubstTemplateTemplateParm: { 5870 TemplateTemplateParmDecl *param 5871 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5872 if (!param) return TemplateName(); 5873 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5874 return Context.getSubstTemplateTemplateParm(param, replacement); 5875 } 5876 5877 case TemplateName::SubstTemplateTemplateParmPack: { 5878 TemplateTemplateParmDecl *Param 5879 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5880 if (!Param) 5881 return TemplateName(); 5882 5883 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5884 if (ArgPack.getKind() != TemplateArgument::Pack) 5885 return TemplateName(); 5886 5887 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 5888 } 5889 } 5890 5891 llvm_unreachable("Unhandled template name kind!"); 5892} 5893 5894TemplateArgument 5895ASTReader::ReadTemplateArgument(ModuleFile &F, 5896 const RecordData &Record, unsigned &Idx) { 5897 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5898 switch (Kind) { 5899 case TemplateArgument::Null: 5900 return TemplateArgument(); 5901 case TemplateArgument::Type: 5902 return TemplateArgument(readType(F, Record, Idx)); 5903 case TemplateArgument::Declaration: 5904 return TemplateArgument(ReadDecl(F, Record, Idx)); 5905 case TemplateArgument::Integral: { 5906 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5907 QualType T = readType(F, Record, Idx); 5908 return TemplateArgument(Value, T); 5909 } 5910 case TemplateArgument::Template: 5911 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5912 case TemplateArgument::TemplateExpansion: { 5913 TemplateName Name = ReadTemplateName(F, Record, Idx); 5914 llvm::Optional<unsigned> NumTemplateExpansions; 5915 if (unsigned NumExpansions = Record[Idx++]) 5916 NumTemplateExpansions = NumExpansions - 1; 5917 return TemplateArgument(Name, NumTemplateExpansions); 5918 } 5919 case TemplateArgument::Expression: 5920 return TemplateArgument(ReadExpr(F)); 5921 case TemplateArgument::Pack: { 5922 unsigned NumArgs = Record[Idx++]; 5923 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 5924 for (unsigned I = 0; I != NumArgs; ++I) 5925 Args[I] = ReadTemplateArgument(F, Record, Idx); 5926 return TemplateArgument(Args, NumArgs); 5927 } 5928 } 5929 5930 llvm_unreachable("Unhandled template argument kind!"); 5931} 5932 5933TemplateParameterList * 5934ASTReader::ReadTemplateParameterList(ModuleFile &F, 5935 const RecordData &Record, unsigned &Idx) { 5936 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5937 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5938 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5939 5940 unsigned NumParams = Record[Idx++]; 5941 SmallVector<NamedDecl *, 16> Params; 5942 Params.reserve(NumParams); 5943 while (NumParams--) 5944 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5945 5946 TemplateParameterList* TemplateParams = 5947 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 5948 Params.data(), Params.size(), RAngleLoc); 5949 return TemplateParams; 5950} 5951 5952void 5953ASTReader:: 5954ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5955 ModuleFile &F, const RecordData &Record, 5956 unsigned &Idx) { 5957 unsigned NumTemplateArgs = Record[Idx++]; 5958 TemplArgs.reserve(NumTemplateArgs); 5959 while (NumTemplateArgs--) 5960 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5961} 5962 5963/// \brief Read a UnresolvedSet structure. 5964void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set, 5965 const RecordData &Record, unsigned &Idx) { 5966 unsigned NumDecls = Record[Idx++]; 5967 while (NumDecls--) { 5968 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5969 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5970 Set.addDecl(D, AS); 5971 } 5972} 5973 5974CXXBaseSpecifier 5975ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 5976 const RecordData &Record, unsigned &Idx) { 5977 bool isVirtual = static_cast<bool>(Record[Idx++]); 5978 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5979 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5980 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5981 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5982 SourceRange Range = ReadSourceRange(F, Record, Idx); 5983 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5984 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5985 EllipsisLoc); 5986 Result.setInheritConstructors(inheritConstructors); 5987 return Result; 5988} 5989 5990std::pair<CXXCtorInitializer **, unsigned> 5991ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 5992 unsigned &Idx) { 5993 CXXCtorInitializer **CtorInitializers = 0; 5994 unsigned NumInitializers = Record[Idx++]; 5995 if (NumInitializers) { 5996 CtorInitializers 5997 = new (Context) CXXCtorInitializer*[NumInitializers]; 5998 for (unsigned i=0; i != NumInitializers; ++i) { 5999 TypeSourceInfo *TInfo = 0; 6000 bool IsBaseVirtual = false; 6001 FieldDecl *Member = 0; 6002 IndirectFieldDecl *IndirectMember = 0; 6003 6004 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 6005 switch (Type) { 6006 case CTOR_INITIALIZER_BASE: 6007 TInfo = GetTypeSourceInfo(F, Record, Idx); 6008 IsBaseVirtual = Record[Idx++]; 6009 break; 6010 6011 case CTOR_INITIALIZER_DELEGATING: 6012 TInfo = GetTypeSourceInfo(F, Record, Idx); 6013 break; 6014 6015 case CTOR_INITIALIZER_MEMBER: 6016 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 6017 break; 6018 6019 case CTOR_INITIALIZER_INDIRECT_MEMBER: 6020 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 6021 break; 6022 } 6023 6024 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 6025 Expr *Init = ReadExpr(F); 6026 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 6027 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 6028 bool IsWritten = Record[Idx++]; 6029 unsigned SourceOrderOrNumArrayIndices; 6030 SmallVector<VarDecl *, 8> Indices; 6031 if (IsWritten) { 6032 SourceOrderOrNumArrayIndices = Record[Idx++]; 6033 } else { 6034 SourceOrderOrNumArrayIndices = Record[Idx++]; 6035 Indices.reserve(SourceOrderOrNumArrayIndices); 6036 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 6037 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 6038 } 6039 6040 CXXCtorInitializer *BOMInit; 6041 if (Type == CTOR_INITIALIZER_BASE) { 6042 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 6043 LParenLoc, Init, RParenLoc, 6044 MemberOrEllipsisLoc); 6045 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 6046 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 6047 Init, RParenLoc); 6048 } else if (IsWritten) { 6049 if (Member) 6050 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 6051 LParenLoc, Init, RParenLoc); 6052 else 6053 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 6054 MemberOrEllipsisLoc, LParenLoc, 6055 Init, RParenLoc); 6056 } else { 6057 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 6058 LParenLoc, Init, RParenLoc, 6059 Indices.data(), Indices.size()); 6060 } 6061 6062 if (IsWritten) 6063 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 6064 CtorInitializers[i] = BOMInit; 6065 } 6066 } 6067 6068 return std::make_pair(CtorInitializers, NumInitializers); 6069} 6070 6071NestedNameSpecifier * 6072ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 6073 const RecordData &Record, unsigned &Idx) { 6074 unsigned N = Record[Idx++]; 6075 NestedNameSpecifier *NNS = 0, *Prev = 0; 6076 for (unsigned I = 0; I != N; ++I) { 6077 NestedNameSpecifier::SpecifierKind Kind 6078 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6079 switch (Kind) { 6080 case NestedNameSpecifier::Identifier: { 6081 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6082 NNS = NestedNameSpecifier::Create(Context, Prev, II); 6083 break; 6084 } 6085 6086 case NestedNameSpecifier::Namespace: { 6087 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6088 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 6089 break; 6090 } 6091 6092 case NestedNameSpecifier::NamespaceAlias: { 6093 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6094 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 6095 break; 6096 } 6097 6098 case NestedNameSpecifier::TypeSpec: 6099 case NestedNameSpecifier::TypeSpecWithTemplate: { 6100 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 6101 if (!T) 6102 return 0; 6103 6104 bool Template = Record[Idx++]; 6105 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 6106 break; 6107 } 6108 6109 case NestedNameSpecifier::Global: { 6110 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 6111 // No associated value, and there can't be a prefix. 6112 break; 6113 } 6114 } 6115 Prev = NNS; 6116 } 6117 return NNS; 6118} 6119 6120NestedNameSpecifierLoc 6121ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 6122 unsigned &Idx) { 6123 unsigned N = Record[Idx++]; 6124 NestedNameSpecifierLocBuilder Builder; 6125 for (unsigned I = 0; I != N; ++I) { 6126 NestedNameSpecifier::SpecifierKind Kind 6127 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6128 switch (Kind) { 6129 case NestedNameSpecifier::Identifier: { 6130 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6131 SourceRange Range = ReadSourceRange(F, Record, Idx); 6132 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 6133 break; 6134 } 6135 6136 case NestedNameSpecifier::Namespace: { 6137 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6138 SourceRange Range = ReadSourceRange(F, Record, Idx); 6139 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 6140 break; 6141 } 6142 6143 case NestedNameSpecifier::NamespaceAlias: { 6144 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6145 SourceRange Range = ReadSourceRange(F, Record, Idx); 6146 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 6147 break; 6148 } 6149 6150 case NestedNameSpecifier::TypeSpec: 6151 case NestedNameSpecifier::TypeSpecWithTemplate: { 6152 bool Template = Record[Idx++]; 6153 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 6154 if (!T) 6155 return NestedNameSpecifierLoc(); 6156 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6157 6158 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 6159 Builder.Extend(Context, 6160 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 6161 T->getTypeLoc(), ColonColonLoc); 6162 break; 6163 } 6164 6165 case NestedNameSpecifier::Global: { 6166 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6167 Builder.MakeGlobal(Context, ColonColonLoc); 6168 break; 6169 } 6170 } 6171 } 6172 6173 return Builder.getWithLocInContext(Context); 6174} 6175 6176SourceRange 6177ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 6178 unsigned &Idx) { 6179 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 6180 SourceLocation end = ReadSourceLocation(F, Record, Idx); 6181 return SourceRange(beg, end); 6182} 6183 6184/// \brief Read an integral value 6185llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 6186 unsigned BitWidth = Record[Idx++]; 6187 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 6188 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 6189 Idx += NumWords; 6190 return Result; 6191} 6192 6193/// \brief Read a signed integral value 6194llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 6195 bool isUnsigned = Record[Idx++]; 6196 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 6197} 6198 6199/// \brief Read a floating-point value 6200llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 6201 return llvm::APFloat(ReadAPInt(Record, Idx)); 6202} 6203 6204// \brief Read a string 6205std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 6206 unsigned Len = Record[Idx++]; 6207 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 6208 Idx += Len; 6209 return Result; 6210} 6211 6212VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 6213 unsigned &Idx) { 6214 unsigned Major = Record[Idx++]; 6215 unsigned Minor = Record[Idx++]; 6216 unsigned Subminor = Record[Idx++]; 6217 if (Minor == 0) 6218 return VersionTuple(Major); 6219 if (Subminor == 0) 6220 return VersionTuple(Major, Minor - 1); 6221 return VersionTuple(Major, Minor - 1, Subminor - 1); 6222} 6223 6224CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 6225 const RecordData &Record, 6226 unsigned &Idx) { 6227 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 6228 return CXXTemporary::Create(Context, Decl); 6229} 6230 6231DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 6232 return Diag(SourceLocation(), DiagID); 6233} 6234 6235DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 6236 return Diags.Report(Loc, DiagID); 6237} 6238 6239/// \brief Retrieve the identifier table associated with the 6240/// preprocessor. 6241IdentifierTable &ASTReader::getIdentifierTable() { 6242 return PP.getIdentifierTable(); 6243} 6244 6245/// \brief Record that the given ID maps to the given switch-case 6246/// statement. 6247void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 6248 assert((*CurrSwitchCaseStmts)[ID] == 0 && 6249 "Already have a SwitchCase with this ID"); 6250 (*CurrSwitchCaseStmts)[ID] = SC; 6251} 6252 6253/// \brief Retrieve the switch-case statement with the given ID. 6254SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 6255 assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID"); 6256 return (*CurrSwitchCaseStmts)[ID]; 6257} 6258 6259void ASTReader::ClearSwitchCaseIDs() { 6260 CurrSwitchCaseStmts->clear(); 6261} 6262 6263void ASTReader::finishPendingActions() { 6264 while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty()) { 6265 // If any identifiers with corresponding top-level declarations have 6266 // been loaded, load those declarations now. 6267 while (!PendingIdentifierInfos.empty()) { 6268 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 6269 PendingIdentifierInfos.front().DeclIDs, true); 6270 PendingIdentifierInfos.pop_front(); 6271 } 6272 6273 // Load pending declaration chains. 6274 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 6275 loadPendingDeclChain(PendingDeclChains[I]); 6276 PendingDeclChainsKnown.erase(PendingDeclChains[I]); 6277 } 6278 PendingDeclChains.clear(); 6279 } 6280 6281 // If we deserialized any C++ or Objective-C class definitions, any 6282 // Objective-C protocol definitions, or any redeclarable templates, make sure 6283 // that all redeclarations point to the definitions. Note that this can only 6284 // happen now, after the redeclaration chains have been fully wired. 6285 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(), 6286 DEnd = PendingDefinitions.end(); 6287 D != DEnd; ++D) { 6288 if (TagDecl *TD = dyn_cast<TagDecl>(*D)) { 6289 if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) { 6290 // Make sure that the TagType points at the definition. 6291 const_cast<TagType*>(TagT)->decl = TD; 6292 } 6293 6294 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) { 6295 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(), 6296 REnd = RD->redecls_end(); 6297 R != REnd; ++R) 6298 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData; 6299 6300 } 6301 6302 continue; 6303 } 6304 6305 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) { 6306 // Make sure that the ObjCInterfaceType points at the definition. 6307 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl)) 6308 ->Decl = ID; 6309 6310 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(), 6311 REnd = ID->redecls_end(); 6312 R != REnd; ++R) 6313 R->Data = ID->Data; 6314 6315 continue; 6316 } 6317 6318 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) { 6319 for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(), 6320 REnd = PD->redecls_end(); 6321 R != REnd; ++R) 6322 R->Data = PD->Data; 6323 6324 continue; 6325 } 6326 6327 RedeclarableTemplateDecl *RTD 6328 = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl(); 6329 for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(), 6330 REnd = RTD->redecls_end(); 6331 R != REnd; ++R) 6332 R->Common = RTD->Common; 6333 } 6334 PendingDefinitions.clear(); 6335} 6336 6337void ASTReader::FinishedDeserializing() { 6338 assert(NumCurrentElementsDeserializing && 6339 "FinishedDeserializing not paired with StartedDeserializing"); 6340 if (NumCurrentElementsDeserializing == 1) { 6341 // We decrease NumCurrentElementsDeserializing only after pending actions 6342 // are finished, to avoid recursively re-calling finishPendingActions(). 6343 finishPendingActions(); 6344 } 6345 --NumCurrentElementsDeserializing; 6346 6347 if (NumCurrentElementsDeserializing == 0 && 6348 Consumer && !PassingDeclsToConsumer) { 6349 // Guard variable to avoid recursively redoing the process of passing 6350 // decls to consumer. 6351 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer, 6352 true); 6353 6354 while (!InterestingDecls.empty()) { 6355 // We are not in recursive loading, so it's safe to pass the "interesting" 6356 // decls to the consumer. 6357 Decl *D = InterestingDecls.front(); 6358 InterestingDecls.pop_front(); 6359 PassInterestingDeclToConsumer(D); 6360 } 6361 } 6362} 6363 6364ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 6365 StringRef isysroot, bool DisableValidation, 6366 bool DisableStatCache, bool AllowASTWithCompilerErrors) 6367 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 6368 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 6369 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 6370 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 6371 RelocatablePCH(false), isysroot(isysroot), 6372 DisableValidation(DisableValidation), 6373 DisableStatCache(DisableStatCache), 6374 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), 6375 CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts), 6376 NumStatHits(0), NumStatMisses(0), 6377 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 6378 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 6379 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 6380 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 6381 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 6382 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 6383 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 6384 PassingDeclsToConsumer(false), 6385 NumCXXBaseSpecifiersLoaded(0) 6386{ 6387 SourceMgr.setExternalSLocEntrySource(this); 6388} 6389 6390ASTReader::~ASTReader() { 6391 for (DeclContextVisibleUpdatesPending::iterator 6392 I = PendingVisibleUpdates.begin(), 6393 E = PendingVisibleUpdates.end(); 6394 I != E; ++I) { 6395 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 6396 F = I->second.end(); 6397 J != F; ++J) 6398 delete J->first; 6399 } 6400} 6401