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