ASTReader.cpp revision 77d029f6a24dbf70d97e61757945df53fb250ea0
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 "ASTCommon.h" 18#include "ASTReaderInternals.h" 19#include "clang/Frontend/FrontendDiagnostic.h" 20#include "clang/Frontend/Utils.h" 21#include "clang/Sema/Sema.h" 22#include "clang/Sema/Scope.h" 23#include "clang/AST/ASTConsumer.h" 24#include "clang/AST/ASTContext.h" 25#include "clang/AST/DeclTemplate.h" 26#include "clang/AST/Expr.h" 27#include "clang/AST/ExprCXX.h" 28#include "clang/AST/NestedNameSpecifier.h" 29#include "clang/AST/Type.h" 30#include "clang/AST/TypeLocVisitor.h" 31#include "clang/Lex/MacroInfo.h" 32#include "clang/Lex/PreprocessingRecord.h" 33#include "clang/Lex/Preprocessor.h" 34#include "clang/Lex/HeaderSearch.h" 35#include "clang/Basic/OnDiskHashTable.h" 36#include "clang/Basic/SourceManager.h" 37#include "clang/Basic/SourceManagerInternals.h" 38#include "clang/Basic/FileManager.h" 39#include "clang/Basic/FileSystemStatCache.h" 40#include "clang/Basic/TargetInfo.h" 41#include "clang/Basic/Version.h" 42#include "clang/Basic/VersionTuple.h" 43#include "llvm/ADT/StringExtras.h" 44#include "llvm/Bitcode/BitstreamReader.h" 45#include "llvm/Support/MemoryBuffer.h" 46#include "llvm/Support/ErrorHandling.h" 47#include "llvm/Support/FileSystem.h" 48#include "llvm/Support/Path.h" 49#include "llvm/Support/system_error.h" 50#include <algorithm> 51#include <iterator> 52#include <cstdio> 53#include <sys/stat.h> 54 55using namespace clang; 56using namespace clang::serialization; 57using namespace clang::serialization::reader; 58 59//===----------------------------------------------------------------------===// 60// PCH validator implementation 61//===----------------------------------------------------------------------===// 62 63ASTReaderListener::~ASTReaderListener() {} 64 65bool 66PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 67 const LangOptions &PPLangOpts = PP.getLangOptions(); 68 69#define LANGOPT(Name, Bits, Default, Description) \ 70 if (PPLangOpts.Name != LangOpts.Name) { \ 71 Reader.Diag(diag::err_pch_langopt_mismatch) \ 72 << Description << LangOpts.Name << PPLangOpts.Name; \ 73 return true; \ 74 } 75 76#define VALUE_LANGOPT(Name, Bits, Default, Description) \ 77 if (PPLangOpts.Name != LangOpts.Name) { \ 78 Reader.Diag(diag::err_pch_langopt_value_mismatch) \ 79 << Description; \ 80 return true; \ 81} 82 83#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 84 if (PPLangOpts.get##Name() != LangOpts.get##Name()) { \ 85 Reader.Diag(diag::err_pch_langopt_value_mismatch) \ 86 << Description; \ 87 return true; \ 88 } 89 90#define BENIGN_LANGOPT(Name, Bits, Default, Description) 91#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) 92#include "clang/Basic/LangOptions.def" 93 94 return false; 95} 96 97bool PCHValidator::ReadTargetTriple(StringRef Triple) { 98 if (Triple == PP.getTargetInfo().getTriple().str()) 99 return false; 100 101 Reader.Diag(diag::warn_pch_target_triple) 102 << Triple << PP.getTargetInfo().getTriple().str(); 103 return true; 104} 105 106namespace { 107 struct EmptyStringRef { 108 bool operator ()(StringRef r) const { return r.empty(); } 109 }; 110 struct EmptyBlock { 111 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();} 112 }; 113} 114 115static bool EqualConcatenations(SmallVector<StringRef, 2> L, 116 PCHPredefinesBlocks R) { 117 // First, sum up the lengths. 118 unsigned LL = 0, RL = 0; 119 for (unsigned I = 0, N = L.size(); I != N; ++I) { 120 LL += L[I].size(); 121 } 122 for (unsigned I = 0, N = R.size(); I != N; ++I) { 123 RL += R[I].Data.size(); 124 } 125 if (LL != RL) 126 return false; 127 if (LL == 0 && RL == 0) 128 return true; 129 130 // Kick out empty parts, they confuse the algorithm below. 131 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 132 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 133 134 // Do it the hard way. At this point, both vectors must be non-empty. 135 StringRef LR = L[0], RR = R[0].Data; 136 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 137 (void) RN; 138 for (;;) { 139 // Compare the current pieces. 140 if (LR.size() == RR.size()) { 141 // If they're the same length, it's pretty easy. 142 if (LR != RR) 143 return false; 144 // Both pieces are done, advance. 145 ++LI; 146 ++RI; 147 // If either string is done, they're both done, since they're the same 148 // length. 149 if (LI == LN) { 150 assert(RI == RN && "Strings not the same length after all?"); 151 return true; 152 } 153 LR = L[LI]; 154 RR = R[RI].Data; 155 } else if (LR.size() < RR.size()) { 156 // Right piece is longer. 157 if (!RR.startswith(LR)) 158 return false; 159 ++LI; 160 assert(LI != LN && "Strings not the same length after all?"); 161 RR = RR.substr(LR.size()); 162 LR = L[LI]; 163 } else { 164 // Left piece is longer. 165 if (!LR.startswith(RR)) 166 return false; 167 ++RI; 168 assert(RI != RN && "Strings not the same length after all?"); 169 LR = LR.substr(RR.size()); 170 RR = R[RI].Data; 171 } 172 } 173} 174 175static std::pair<FileID, StringRef::size_type> 176FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) { 177 std::pair<FileID, StringRef::size_type> Res; 178 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 179 Res.second = Buffers[I].Data.find(MacroDef); 180 if (Res.second != StringRef::npos) { 181 Res.first = Buffers[I].BufferID; 182 break; 183 } 184 } 185 return Res; 186} 187 188bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 189 StringRef OriginalFileName, 190 std::string &SuggestedPredefines, 191 FileManager &FileMgr) { 192 // We are in the context of an implicit include, so the predefines buffer will 193 // have a #include entry for the PCH file itself (as normalized by the 194 // preprocessor initialization). Find it and skip over it in the checking 195 // below. 196 llvm::SmallString<256> PCHInclude; 197 PCHInclude += "#include \""; 198 PCHInclude += NormalizeDashIncludePath(OriginalFileName, 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 II->setOutOfDate(false); 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 & 0x3FF; 533 Bits >>= 10; 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 II->setOutOfDate(false); 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 DeclID *Start = (DeclID *)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 return; 1405} 1406 1407PreprocessedEntityID 1408ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const { 1409 ContinuousRangeMap<uint32_t, int, 2>::const_iterator 1410 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS); 1411 assert(I != M.PreprocessedEntityRemap.end() 1412 && "Invalid index into preprocessed entity index remap"); 1413 1414 return LocalID + I->second; 1415} 1416 1417unsigned HeaderFileInfoTrait::ComputeHash(const char *path) { 1418 return llvm::HashString(llvm::sys::path::filename(path)); 1419} 1420 1421HeaderFileInfoTrait::internal_key_type 1422HeaderFileInfoTrait::GetInternalKey(const char *path) { return path; } 1423 1424bool HeaderFileInfoTrait::EqualKey(internal_key_type a, internal_key_type b) { 1425 if (strcmp(a, b) == 0) 1426 return true; 1427 1428 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b)) 1429 return false; 1430 1431 // The file names match, but the path names don't. stat() the files to 1432 // see if they are the same. 1433 struct stat StatBufA, StatBufB; 1434 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB)) 1435 return false; 1436 1437 return StatBufA.st_ino == StatBufB.st_ino; 1438} 1439 1440std::pair<unsigned, unsigned> 1441HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) { 1442 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1443 unsigned DataLen = (unsigned) *d++; 1444 return std::make_pair(KeyLen + 1, DataLen); 1445} 1446 1447HeaderFileInfoTrait::data_type 1448HeaderFileInfoTrait::ReadData(const internal_key_type, const unsigned char *d, 1449 unsigned DataLen) { 1450 const unsigned char *End = d + DataLen; 1451 using namespace clang::io; 1452 HeaderFileInfo HFI; 1453 unsigned Flags = *d++; 1454 HFI.isImport = (Flags >> 5) & 0x01; 1455 HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1456 HFI.DirInfo = (Flags >> 2) & 0x03; 1457 HFI.Resolved = (Flags >> 1) & 0x01; 1458 HFI.IndexHeaderMapHeader = Flags & 0x01; 1459 HFI.NumIncludes = ReadUnalignedLE16(d); 1460 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(M, 1461 ReadUnalignedLE32(d)); 1462 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) { 1463 // The framework offset is 1 greater than the actual offset, 1464 // since 0 is used as an indicator for "no framework name". 1465 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1466 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1467 } 1468 1469 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1470 (void)End; 1471 1472 // This HeaderFileInfo was externally loaded. 1473 HFI.External = true; 1474 return HFI; 1475} 1476 1477void ASTReader::setIdentifierIsMacro(IdentifierInfo *II, ModuleFile &F, 1478 uint64_t LocalOffset, bool Visible) { 1479 if (Visible) { 1480 // Note that this identifier has a macro definition. 1481 II->setHasMacroDefinition(true); 1482 } 1483 1484 // Adjust the offset to a global offset. 1485 UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset; 1486} 1487 1488void ASTReader::ReadDefinedMacros() { 1489 for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1490 E = ModuleMgr.rend(); I != E; ++I) { 1491 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1492 1493 // If there was no preprocessor block, skip this file. 1494 if (!MacroCursor.getBitStreamReader()) 1495 continue; 1496 1497 llvm::BitstreamCursor Cursor = MacroCursor; 1498 Cursor.JumpToBit((*I)->MacroStartOffset); 1499 1500 RecordData Record; 1501 while (true) { 1502 unsigned Code = Cursor.ReadCode(); 1503 if (Code == llvm::bitc::END_BLOCK) 1504 break; 1505 1506 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1507 // No known subblocks, always skip them. 1508 Cursor.ReadSubBlockID(); 1509 if (Cursor.SkipBlock()) { 1510 Error("malformed block record in AST file"); 1511 return; 1512 } 1513 continue; 1514 } 1515 1516 if (Code == llvm::bitc::DEFINE_ABBREV) { 1517 Cursor.ReadAbbrevRecord(); 1518 continue; 1519 } 1520 1521 // Read a record. 1522 const char *BlobStart; 1523 unsigned BlobLen; 1524 Record.clear(); 1525 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1526 default: // Default behavior: ignore. 1527 break; 1528 1529 case PP_MACRO_OBJECT_LIKE: 1530 case PP_MACRO_FUNCTION_LIKE: 1531 getLocalIdentifier(**I, Record[0]); 1532 break; 1533 1534 case PP_TOKEN: 1535 // Ignore tokens. 1536 break; 1537 } 1538 } 1539 } 1540 1541 // Drain the unread macro-record offsets map. 1542 while (!UnreadMacroRecordOffsets.empty()) 1543 LoadMacroDefinition(UnreadMacroRecordOffsets.begin()); 1544} 1545 1546void ASTReader::LoadMacroDefinition( 1547 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) { 1548 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition"); 1549 uint64_t Offset = Pos->second; 1550 UnreadMacroRecordOffsets.erase(Pos); 1551 1552 RecordLocation Loc = getLocalBitOffset(Offset); 1553 ReadMacroRecord(*Loc.F, Loc.Offset); 1554} 1555 1556void ASTReader::LoadMacroDefinition(IdentifierInfo *II) { 1557 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos 1558 = UnreadMacroRecordOffsets.find(II); 1559 LoadMacroDefinition(Pos); 1560} 1561 1562namespace { 1563 /// \brief Visitor class used to look up identifirs in an AST file. 1564 class IdentifierLookupVisitor { 1565 StringRef Name; 1566 IdentifierInfo *Found; 1567 public: 1568 explicit IdentifierLookupVisitor(StringRef Name) : Name(Name), Found() { } 1569 1570 static bool visit(ModuleFile &M, void *UserData) { 1571 IdentifierLookupVisitor *This 1572 = static_cast<IdentifierLookupVisitor *>(UserData); 1573 1574 ASTIdentifierLookupTable *IdTable 1575 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable; 1576 if (!IdTable) 1577 return false; 1578 1579 std::pair<const char*, unsigned> Key(This->Name.begin(), 1580 This->Name.size()); 1581 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 1582 if (Pos == IdTable->end()) 1583 return false; 1584 1585 // Dereferencing the iterator has the effect of building the 1586 // IdentifierInfo node and populating it with the various 1587 // declarations it needs. 1588 This->Found = *Pos; 1589 return true; 1590 } 1591 1592 // \brief Retrieve the identifier info found within the module 1593 // files. 1594 IdentifierInfo *getIdentifierInfo() const { return Found; } 1595 }; 1596} 1597 1598void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) { 1599 get(II.getName()); 1600} 1601 1602const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) { 1603 std::string Filename = filenameStrRef; 1604 MaybeAddSystemRootToFilename(Filename); 1605 const FileEntry *File = FileMgr.getFile(Filename); 1606 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1607 OriginalDir != CurrentDir) { 1608 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1609 OriginalDir, 1610 CurrentDir); 1611 if (!resolved.empty()) 1612 File = FileMgr.getFile(resolved); 1613 } 1614 1615 return File; 1616} 1617 1618/// \brief If we are loading a relocatable PCH file, and the filename is 1619/// not an absolute path, add the system root to the beginning of the file 1620/// name. 1621void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 1622 // If this is not a relocatable PCH file, there's nothing to do. 1623 if (!RelocatablePCH) 1624 return; 1625 1626 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1627 return; 1628 1629 if (isysroot.empty()) { 1630 // If no system root was given, default to '/' 1631 Filename.insert(Filename.begin(), '/'); 1632 return; 1633 } 1634 1635 unsigned Length = isysroot.size(); 1636 if (isysroot[Length - 1] != '/') 1637 Filename.insert(Filename.begin(), '/'); 1638 1639 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end()); 1640} 1641 1642ASTReader::ASTReadResult 1643ASTReader::ReadASTBlock(ModuleFile &F) { 1644 llvm::BitstreamCursor &Stream = F.Stream; 1645 1646 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1647 Error("malformed block record in AST file"); 1648 return Failure; 1649 } 1650 1651 // Read all of the records and blocks for the ASt file. 1652 RecordData Record; 1653 while (!Stream.AtEndOfStream()) { 1654 unsigned Code = Stream.ReadCode(); 1655 if (Code == llvm::bitc::END_BLOCK) { 1656 if (Stream.ReadBlockEnd()) { 1657 Error("error at end of module block in AST file"); 1658 return Failure; 1659 } 1660 1661 return Success; 1662 } 1663 1664 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1665 switch (Stream.ReadSubBlockID()) { 1666 case DECLTYPES_BLOCK_ID: 1667 // We lazily load the decls block, but we want to set up the 1668 // DeclsCursor cursor to point into it. Clone our current bitcode 1669 // cursor to it, enter the block and read the abbrevs in that block. 1670 // With the main cursor, we just skip over it. 1671 F.DeclsCursor = Stream; 1672 if (Stream.SkipBlock() || // Skip with the main cursor. 1673 // Read the abbrevs. 1674 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1675 Error("malformed block record in AST file"); 1676 return Failure; 1677 } 1678 break; 1679 1680 case DECL_UPDATES_BLOCK_ID: 1681 if (Stream.SkipBlock()) { 1682 Error("malformed block record in AST file"); 1683 return Failure; 1684 } 1685 break; 1686 1687 case PREPROCESSOR_BLOCK_ID: 1688 F.MacroCursor = Stream; 1689 if (!PP.getExternalSource()) 1690 PP.setExternalSource(this); 1691 1692 if (Stream.SkipBlock() || 1693 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1694 Error("malformed block record in AST file"); 1695 return Failure; 1696 } 1697 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1698 break; 1699 1700 case PREPROCESSOR_DETAIL_BLOCK_ID: 1701 F.PreprocessorDetailCursor = Stream; 1702 if (Stream.SkipBlock() || 1703 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 1704 PREPROCESSOR_DETAIL_BLOCK_ID)) { 1705 Error("malformed preprocessor detail record in AST file"); 1706 return Failure; 1707 } 1708 F.PreprocessorDetailStartOffset 1709 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 1710 1711 if (!PP.getPreprocessingRecord()) 1712 PP.createPreprocessingRecord(true); 1713 if (!PP.getPreprocessingRecord()->getExternalSource()) 1714 PP.getPreprocessingRecord()->SetExternalSource(*this); 1715 break; 1716 1717 case SOURCE_MANAGER_BLOCK_ID: 1718 switch (ReadSourceManagerBlock(F)) { 1719 case Success: 1720 break; 1721 1722 case Failure: 1723 Error("malformed source manager block in AST file"); 1724 return Failure; 1725 1726 case IgnorePCH: 1727 return IgnorePCH; 1728 } 1729 break; 1730 1731 case SUBMODULE_BLOCK_ID: 1732 switch (ReadSubmoduleBlock(F)) { 1733 case Success: 1734 break; 1735 1736 case Failure: 1737 Error("malformed submodule block in AST file"); 1738 return Failure; 1739 1740 case IgnorePCH: 1741 return IgnorePCH; 1742 } 1743 break; 1744 1745 default: 1746 if (!Stream.SkipBlock()) 1747 break; 1748 Error("malformed block record in AST file"); 1749 return Failure; 1750 } 1751 continue; 1752 } 1753 1754 if (Code == llvm::bitc::DEFINE_ABBREV) { 1755 Stream.ReadAbbrevRecord(); 1756 continue; 1757 } 1758 1759 // Read and process a record. 1760 Record.clear(); 1761 const char *BlobStart = 0; 1762 unsigned BlobLen = 0; 1763 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 1764 &BlobStart, &BlobLen)) { 1765 default: // Default behavior: ignore. 1766 break; 1767 1768 case METADATA: { 1769 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1770 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1771 : diag::warn_pch_version_too_new); 1772 return IgnorePCH; 1773 } 1774 1775 RelocatablePCH = Record[4]; 1776 if (Listener) { 1777 std::string TargetTriple(BlobStart, BlobLen); 1778 if (Listener->ReadTargetTriple(TargetTriple)) 1779 return IgnorePCH; 1780 } 1781 break; 1782 } 1783 1784 case IMPORTS: { 1785 // Load each of the imported PCH files. 1786 unsigned Idx = 0, N = Record.size(); 1787 while (Idx < N) { 1788 // Read information about the AST file. 1789 ModuleKind ImportedKind = (ModuleKind)Record[Idx++]; 1790 unsigned Length = Record[Idx++]; 1791 llvm::SmallString<128> ImportedFile(Record.begin() + Idx, 1792 Record.begin() + Idx + Length); 1793 Idx += Length; 1794 1795 // Load the AST file. 1796 switch(ReadASTCore(ImportedFile, ImportedKind, &F)) { 1797 case Failure: return Failure; 1798 // If we have to ignore the dependency, we'll have to ignore this too. 1799 case IgnorePCH: return IgnorePCH; 1800 case Success: break; 1801 } 1802 } 1803 break; 1804 } 1805 1806 case TYPE_OFFSET: { 1807 if (F.LocalNumTypes != 0) { 1808 Error("duplicate TYPE_OFFSET record in AST file"); 1809 return Failure; 1810 } 1811 F.TypeOffsets = (const uint32_t *)BlobStart; 1812 F.LocalNumTypes = Record[0]; 1813 unsigned LocalBaseTypeIndex = Record[1]; 1814 F.BaseTypeIndex = getTotalNumTypes(); 1815 1816 if (F.LocalNumTypes > 0) { 1817 // Introduce the global -> local mapping for types within this module. 1818 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 1819 1820 // Introduce the local -> global mapping for types within this module. 1821 F.TypeRemap.insert(std::make_pair(LocalBaseTypeIndex, 1822 F.BaseTypeIndex - LocalBaseTypeIndex)); 1823 1824 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 1825 } 1826 break; 1827 } 1828 1829 case DECL_OFFSET: { 1830 if (F.LocalNumDecls != 0) { 1831 Error("duplicate DECL_OFFSET record in AST file"); 1832 return Failure; 1833 } 1834 F.DeclOffsets = (const DeclOffset *)BlobStart; 1835 F.LocalNumDecls = Record[0]; 1836 unsigned LocalBaseDeclID = Record[1]; 1837 F.BaseDeclID = getTotalNumDecls(); 1838 1839 if (F.LocalNumDecls > 0) { 1840 // Introduce the global -> local mapping for declarations within this 1841 // module. 1842 GlobalDeclMap.insert( 1843 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 1844 1845 // Introduce the local -> global mapping for declarations within this 1846 // module. 1847 F.DeclRemap.insert(std::make_pair(LocalBaseDeclID, 1848 F.BaseDeclID - LocalBaseDeclID)); 1849 1850 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 1851 } 1852 break; 1853 } 1854 1855 case TU_UPDATE_LEXICAL: { 1856 DeclContext *TU = Context.getTranslationUnitDecl(); 1857 DeclContextInfo &Info = F.DeclContextInfos[TU]; 1858 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(BlobStart); 1859 Info.NumLexicalDecls 1860 = static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair)); 1861 TU->setHasExternalLexicalStorage(true); 1862 break; 1863 } 1864 1865 case UPDATE_VISIBLE: { 1866 unsigned Idx = 0; 1867 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 1868 void *Table = ASTDeclContextNameLookupTable::Create( 1869 (const unsigned char *)BlobStart + Record[Idx++], 1870 (const unsigned char *)BlobStart, 1871 ASTDeclContextNameLookupTrait(*this, F)); 1872 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU? 1873 DeclContext *TU = Context.getTranslationUnitDecl(); 1874 F.DeclContextInfos[TU].NameLookupTableData = Table; 1875 TU->setHasExternalVisibleStorage(true); 1876 } else 1877 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 1878 break; 1879 } 1880 1881 case REDECLS_UPDATE_LATEST: { 1882 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 1883 for (unsigned i = 0, e = Record.size(); i < e; /* in loop */) { 1884 DeclID First = ReadDeclID(F, Record, i); 1885 DeclID Latest = ReadDeclID(F, Record, i); 1886 FirstLatestDeclIDs[First] = Latest; 1887 } 1888 break; 1889 } 1890 1891 case LANGUAGE_OPTIONS: 1892 if (ParseLanguageOptions(Record) && !DisableValidation) 1893 return IgnorePCH; 1894 break; 1895 1896 case IDENTIFIER_TABLE: 1897 F.IdentifierTableData = BlobStart; 1898 if (Record[0]) { 1899 F.IdentifierLookupTable 1900 = ASTIdentifierLookupTable::Create( 1901 (const unsigned char *)F.IdentifierTableData + Record[0], 1902 (const unsigned char *)F.IdentifierTableData, 1903 ASTIdentifierLookupTrait(*this, F)); 1904 1905 PP.getIdentifierTable().setExternalIdentifierLookup(this); 1906 } 1907 break; 1908 1909 case IDENTIFIER_OFFSET: { 1910 if (F.LocalNumIdentifiers != 0) { 1911 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 1912 return Failure; 1913 } 1914 F.IdentifierOffsets = (const uint32_t *)BlobStart; 1915 F.LocalNumIdentifiers = Record[0]; 1916 unsigned LocalBaseIdentifierID = Record[1]; 1917 F.BaseIdentifierID = getTotalNumIdentifiers(); 1918 1919 if (F.LocalNumIdentifiers > 0) { 1920 // Introduce the global -> local mapping for identifiers within this 1921 // module. 1922 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 1923 &F)); 1924 1925 // Introduce the local -> global mapping for identifiers within this 1926 // module. 1927 F.IdentifierRemap.insert( 1928 std::make_pair(LocalBaseIdentifierID, 1929 F.BaseIdentifierID - LocalBaseIdentifierID)); 1930 1931 IdentifiersLoaded.resize(IdentifiersLoaded.size() 1932 + F.LocalNumIdentifiers); 1933 } 1934 break; 1935 } 1936 1937 case EXTERNAL_DEFINITIONS: 1938 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1939 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 1940 break; 1941 1942 case SPECIAL_TYPES: 1943 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1944 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 1945 break; 1946 1947 case STATISTICS: 1948 TotalNumStatements += Record[0]; 1949 TotalNumMacros += Record[1]; 1950 TotalLexicalDeclContexts += Record[2]; 1951 TotalVisibleDeclContexts += Record[3]; 1952 break; 1953 1954 case UNUSED_FILESCOPED_DECLS: 1955 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1956 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 1957 break; 1958 1959 case DELEGATING_CTORS: 1960 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1961 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 1962 break; 1963 1964 case WEAK_UNDECLARED_IDENTIFIERS: 1965 if (Record.size() % 4 != 0) { 1966 Error("invalid weak identifiers record"); 1967 return Failure; 1968 } 1969 1970 // FIXME: Ignore weak undeclared identifiers from non-original PCH 1971 // files. This isn't the way to do it :) 1972 WeakUndeclaredIdentifiers.clear(); 1973 1974 // Translate the weak, undeclared identifiers into global IDs. 1975 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 1976 WeakUndeclaredIdentifiers.push_back( 1977 getGlobalIdentifierID(F, Record[I++])); 1978 WeakUndeclaredIdentifiers.push_back( 1979 getGlobalIdentifierID(F, Record[I++])); 1980 WeakUndeclaredIdentifiers.push_back( 1981 ReadSourceLocation(F, Record, I).getRawEncoding()); 1982 WeakUndeclaredIdentifiers.push_back(Record[I++]); 1983 } 1984 break; 1985 1986 case LOCALLY_SCOPED_EXTERNAL_DECLS: 1987 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1988 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I])); 1989 break; 1990 1991 case SELECTOR_OFFSETS: { 1992 F.SelectorOffsets = (const uint32_t *)BlobStart; 1993 F.LocalNumSelectors = Record[0]; 1994 unsigned LocalBaseSelectorID = Record[1]; 1995 F.BaseSelectorID = getTotalNumSelectors(); 1996 1997 if (F.LocalNumSelectors > 0) { 1998 // Introduce the global -> local mapping for selectors within this 1999 // module. 2000 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2001 2002 // Introduce the local -> global mapping for selectors within this 2003 // module. 2004 F.SelectorRemap.insert(std::make_pair(LocalBaseSelectorID, 2005 F.BaseSelectorID - LocalBaseSelectorID)); 2006 2007 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2008 } 2009 break; 2010 } 2011 2012 case METHOD_POOL: 2013 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 2014 if (Record[0]) 2015 F.SelectorLookupTable 2016 = ASTSelectorLookupTable::Create( 2017 F.SelectorLookupTableData + Record[0], 2018 F.SelectorLookupTableData, 2019 ASTSelectorLookupTrait(*this, F)); 2020 TotalNumMethodPoolEntries += Record[1]; 2021 break; 2022 2023 case REFERENCED_SELECTOR_POOL: 2024 if (!Record.empty()) { 2025 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2026 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2027 Record[Idx++])); 2028 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2029 getRawEncoding()); 2030 } 2031 } 2032 break; 2033 2034 case PP_COUNTER_VALUE: 2035 if (!Record.empty() && Listener) 2036 Listener->ReadCounter(Record[0]); 2037 break; 2038 2039 case FILE_SORTED_DECLS: 2040 F.FileSortedDecls = (const DeclID *)BlobStart; 2041 break; 2042 2043 case SOURCE_LOCATION_OFFSETS: { 2044 F.SLocEntryOffsets = (const uint32_t *)BlobStart; 2045 F.LocalNumSLocEntries = Record[0]; 2046 unsigned SLocSpaceSize = Record[1]; 2047 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2048 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, 2049 SLocSpaceSize); 2050 // Make our entry in the range map. BaseID is negative and growing, so 2051 // we invert it. Because we invert it, though, we need the other end of 2052 // the range. 2053 unsigned RangeStart = 2054 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2055 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2056 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2057 2058 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing. 2059 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0); 2060 GlobalSLocOffsetMap.insert( 2061 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset 2062 - SLocSpaceSize,&F)); 2063 2064 // Initialize the remapping table. 2065 // Invalid stays invalid. 2066 F.SLocRemap.insert(std::make_pair(0U, 0)); 2067 // This module. Base was 2 when being compiled. 2068 F.SLocRemap.insert(std::make_pair(2U, 2069 static_cast<int>(F.SLocEntryBaseOffset - 2))); 2070 2071 TotalNumSLocEntries += F.LocalNumSLocEntries; 2072 break; 2073 } 2074 2075 case MODULE_OFFSET_MAP: { 2076 // Additional remapping information. 2077 const unsigned char *Data = (const unsigned char*)BlobStart; 2078 const unsigned char *DataEnd = Data + BlobLen; 2079 2080 // Continuous range maps we may be updating in our module. 2081 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 2082 ContinuousRangeMap<uint32_t, int, 2>::Builder 2083 IdentifierRemap(F.IdentifierRemap); 2084 ContinuousRangeMap<uint32_t, int, 2>::Builder 2085 PreprocessedEntityRemap(F.PreprocessedEntityRemap); 2086 ContinuousRangeMap<uint32_t, int, 2>::Builder 2087 SubmoduleRemap(F.SubmoduleRemap); 2088 ContinuousRangeMap<uint32_t, int, 2>::Builder 2089 SelectorRemap(F.SelectorRemap); 2090 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 2091 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 2092 2093 while(Data < DataEnd) { 2094 uint16_t Len = io::ReadUnalignedLE16(Data); 2095 StringRef Name = StringRef((const char*)Data, Len); 2096 Data += Len; 2097 ModuleFile *OM = ModuleMgr.lookup(Name); 2098 if (!OM) { 2099 Error("SourceLocation remap refers to unknown module"); 2100 return Failure; 2101 } 2102 2103 uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 2104 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 2105 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 2106 uint32_t SubmoduleIDOffset = io::ReadUnalignedLE32(Data); 2107 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 2108 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 2109 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2110 2111 // Source location offset is mapped to OM->SLocEntryBaseOffset. 2112 SLocRemap.insert(std::make_pair(SLocOffset, 2113 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2114 IdentifierRemap.insert( 2115 std::make_pair(IdentifierIDOffset, 2116 OM->BaseIdentifierID - IdentifierIDOffset)); 2117 PreprocessedEntityRemap.insert( 2118 std::make_pair(PreprocessedEntityIDOffset, 2119 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); 2120 SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset, 2121 OM->BaseSubmoduleID - SubmoduleIDOffset)); 2122 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2123 OM->BaseSelectorID - SelectorIDOffset)); 2124 DeclRemap.insert(std::make_pair(DeclIDOffset, 2125 OM->BaseDeclID - DeclIDOffset)); 2126 2127 TypeRemap.insert(std::make_pair(TypeIndexOffset, 2128 OM->BaseTypeIndex - TypeIndexOffset)); 2129 } 2130 break; 2131 } 2132 2133 case SOURCE_MANAGER_LINE_TABLE: 2134 if (ParseLineTable(F, Record)) 2135 return Failure; 2136 break; 2137 2138 case FILE_SOURCE_LOCATION_OFFSETS: 2139 F.SLocFileOffsets = (const uint32_t *)BlobStart; 2140 F.LocalNumSLocFileEntries = Record[0]; 2141 break; 2142 2143 case SOURCE_LOCATION_PRELOADS: { 2144 // Need to transform from the local view (1-based IDs) to the global view, 2145 // which is based off F.SLocEntryBaseID. 2146 if (!F.PreloadSLocEntries.empty()) { 2147 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file"); 2148 return Failure; 2149 } 2150 2151 F.PreloadSLocEntries.swap(Record); 2152 break; 2153 } 2154 2155 case STAT_CACHE: { 2156 if (!DisableStatCache) { 2157 ASTStatCache *MyStatCache = 2158 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2159 (const unsigned char *)BlobStart, 2160 NumStatHits, NumStatMisses); 2161 FileMgr.addStatCache(MyStatCache); 2162 F.StatCache = MyStatCache; 2163 } 2164 break; 2165 } 2166 2167 case EXT_VECTOR_DECLS: 2168 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2169 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2170 break; 2171 2172 case VTABLE_USES: 2173 if (Record.size() % 3 != 0) { 2174 Error("Invalid VTABLE_USES record"); 2175 return Failure; 2176 } 2177 2178 // Later tables overwrite earlier ones. 2179 // FIXME: Modules will have some trouble with this. This is clearly not 2180 // the right way to do this. 2181 VTableUses.clear(); 2182 2183 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2184 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2185 VTableUses.push_back( 2186 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2187 VTableUses.push_back(Record[Idx++]); 2188 } 2189 break; 2190 2191 case DYNAMIC_CLASSES: 2192 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2193 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2194 break; 2195 2196 case PENDING_IMPLICIT_INSTANTIATIONS: 2197 if (PendingInstantiations.size() % 2 != 0) { 2198 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2199 return Failure; 2200 } 2201 2202 // Later lists of pending instantiations overwrite earlier ones. 2203 // FIXME: This is most certainly wrong for modules. 2204 PendingInstantiations.clear(); 2205 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2206 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2207 PendingInstantiations.push_back( 2208 ReadSourceLocation(F, Record, I).getRawEncoding()); 2209 } 2210 break; 2211 2212 case SEMA_DECL_REFS: 2213 // Later tables overwrite earlier ones. 2214 // FIXME: Modules will have some trouble with this. 2215 SemaDeclRefs.clear(); 2216 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2217 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2218 break; 2219 2220 case ORIGINAL_FILE_NAME: 2221 // The primary AST will be the last to get here, so it will be the one 2222 // that's used. 2223 ActualOriginalFileName.assign(BlobStart, BlobLen); 2224 OriginalFileName = ActualOriginalFileName; 2225 MaybeAddSystemRootToFilename(OriginalFileName); 2226 break; 2227 2228 case ORIGINAL_FILE_ID: 2229 OriginalFileID = FileID::get(Record[0]); 2230 break; 2231 2232 case ORIGINAL_PCH_DIR: 2233 // The primary AST will be the last to get here, so it will be the one 2234 // that's used. 2235 OriginalDir.assign(BlobStart, BlobLen); 2236 break; 2237 2238 case VERSION_CONTROL_BRANCH_REVISION: { 2239 const std::string &CurBranch = getClangFullRepositoryVersion(); 2240 StringRef ASTBranch(BlobStart, BlobLen); 2241 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2242 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2243 return IgnorePCH; 2244 } 2245 break; 2246 } 2247 2248 case PPD_ENTITIES_OFFSETS: { 2249 F.PreprocessedEntityOffsets = (const PPEntityOffset *)BlobStart; 2250 assert(BlobLen % sizeof(PPEntityOffset) == 0); 2251 F.NumPreprocessedEntities = BlobLen / sizeof(PPEntityOffset); 2252 2253 unsigned LocalBasePreprocessedEntityID = Record[0]; 2254 2255 unsigned StartingID; 2256 if (!PP.getPreprocessingRecord()) 2257 PP.createPreprocessingRecord(true); 2258 if (!PP.getPreprocessingRecord()->getExternalSource()) 2259 PP.getPreprocessingRecord()->SetExternalSource(*this); 2260 StartingID 2261 = PP.getPreprocessingRecord() 2262 ->allocateLoadedEntities(F.NumPreprocessedEntities); 2263 F.BasePreprocessedEntityID = StartingID; 2264 2265 if (F.NumPreprocessedEntities > 0) { 2266 // Introduce the global -> local mapping for preprocessed entities in 2267 // this module. 2268 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2269 2270 // Introduce the local -> global mapping for preprocessed entities in 2271 // this module. 2272 F.PreprocessedEntityRemap.insert( 2273 std::make_pair(LocalBasePreprocessedEntityID, 2274 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 2275 } 2276 2277 break; 2278 } 2279 2280 case DECL_UPDATE_OFFSETS: { 2281 if (Record.size() % 2 != 0) { 2282 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2283 return Failure; 2284 } 2285 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2286 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2287 .push_back(std::make_pair(&F, Record[I+1])); 2288 break; 2289 } 2290 2291 case DECL_REPLACEMENTS: { 2292 if (Record.size() % 3 != 0) { 2293 Error("invalid DECL_REPLACEMENTS block in AST file"); 2294 return Failure; 2295 } 2296 for (unsigned I = 0, N = Record.size(); I != N; I += 3) 2297 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2298 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]); 2299 break; 2300 } 2301 2302 case OBJC_CHAINED_CATEGORIES: { 2303 if (Record.size() % 3 != 0) { 2304 Error("invalid OBJC_CHAINED_CATEGORIES block in AST file"); 2305 return Failure; 2306 } 2307 for (unsigned I = 0, N = Record.size(); I != N; I += 3) { 2308 serialization::GlobalDeclID GlobID = getGlobalDeclID(F, Record[I]); 2309 F.ChainedObjCCategories[GlobID] = std::make_pair(Record[I+1], 2310 Record[I+2]); 2311 ObjCChainedCategoriesInterfaces.insert(GlobID); 2312 } 2313 break; 2314 } 2315 2316 case CXX_BASE_SPECIFIER_OFFSETS: { 2317 if (F.LocalNumCXXBaseSpecifiers != 0) { 2318 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2319 return Failure; 2320 } 2321 2322 F.LocalNumCXXBaseSpecifiers = Record[0]; 2323 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2324 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2325 break; 2326 } 2327 2328 case DIAG_PRAGMA_MAPPINGS: 2329 if (Record.size() % 2 != 0) { 2330 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2331 return Failure; 2332 } 2333 2334 if (F.PragmaDiagMappings.empty()) 2335 F.PragmaDiagMappings.swap(Record); 2336 else 2337 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2338 Record.begin(), Record.end()); 2339 break; 2340 2341 case CUDA_SPECIAL_DECL_REFS: 2342 // Later tables overwrite earlier ones. 2343 // FIXME: Modules will have trouble with this. 2344 CUDASpecialDeclRefs.clear(); 2345 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2346 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2347 break; 2348 2349 case HEADER_SEARCH_TABLE: { 2350 F.HeaderFileInfoTableData = BlobStart; 2351 F.LocalNumHeaderFileInfos = Record[1]; 2352 F.HeaderFileFrameworkStrings = BlobStart + Record[2]; 2353 if (Record[0]) { 2354 F.HeaderFileInfoTable 2355 = HeaderFileInfoLookupTable::Create( 2356 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2357 (const unsigned char *)F.HeaderFileInfoTableData, 2358 HeaderFileInfoTrait(*this, F, 2359 &PP.getHeaderSearchInfo(), 2360 BlobStart + Record[2])); 2361 2362 PP.getHeaderSearchInfo().SetExternalSource(this); 2363 if (!PP.getHeaderSearchInfo().getExternalLookup()) 2364 PP.getHeaderSearchInfo().SetExternalLookup(this); 2365 } 2366 break; 2367 } 2368 2369 case FP_PRAGMA_OPTIONS: 2370 // Later tables overwrite earlier ones. 2371 FPPragmaOptions.swap(Record); 2372 break; 2373 2374 case OPENCL_EXTENSIONS: 2375 // Later tables overwrite earlier ones. 2376 OpenCLExtensions.swap(Record); 2377 break; 2378 2379 case TENTATIVE_DEFINITIONS: 2380 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2381 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2382 break; 2383 2384 case KNOWN_NAMESPACES: 2385 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2386 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2387 break; 2388 2389 case IMPORTED_MODULES: { 2390 if (F.Kind != MK_Module) { 2391 // If we aren't loading a module (which has its own exports), make 2392 // all of the imported modules visible. 2393 // FIXME: Deal with macros-only imports. 2394 for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2395 if (unsigned GlobalID = getGlobalSubmoduleID(F, Record[I])) 2396 ImportedModules.push_back(GlobalID); 2397 } 2398 } 2399 break; 2400 2401 } 2402 } 2403 } 2404 Error("premature end of bitstream in AST file"); 2405 return Failure; 2406} 2407 2408ASTReader::ASTReadResult ASTReader::validateFileEntries(ModuleFile &M) { 2409 llvm::BitstreamCursor &SLocEntryCursor = M.SLocEntryCursor; 2410 2411 for (unsigned i = 0, e = M.LocalNumSLocFileEntries; i != e; ++i) { 2412 SLocEntryCursor.JumpToBit(M.SLocFileOffsets[i]); 2413 unsigned Code = SLocEntryCursor.ReadCode(); 2414 if (Code == llvm::bitc::END_BLOCK || 2415 Code == llvm::bitc::ENTER_SUBBLOCK || 2416 Code == llvm::bitc::DEFINE_ABBREV) { 2417 Error("incorrectly-formatted source location entry in AST file"); 2418 return Failure; 2419 } 2420 2421 RecordData Record; 2422 const char *BlobStart; 2423 unsigned BlobLen; 2424 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2425 default: 2426 Error("incorrectly-formatted source location entry in AST file"); 2427 return Failure; 2428 2429 case SM_SLOC_FILE_ENTRY: { 2430 // If the buffer was overridden, the file need not exist. 2431 if (Record[6]) 2432 break; 2433 2434 StringRef Filename(BlobStart, BlobLen); 2435 const FileEntry *File = getFileEntry(Filename); 2436 2437 if (File == 0) { 2438 std::string ErrorStr = "could not find file '"; 2439 ErrorStr += Filename; 2440 ErrorStr += "' referenced by AST file"; 2441 Error(ErrorStr.c_str()); 2442 return IgnorePCH; 2443 } 2444 2445 if (Record.size() < 7) { 2446 Error("source location entry is incorrect"); 2447 return Failure; 2448 } 2449 2450 // The stat info from the FileEntry came from the cached stat 2451 // info of the PCH, so we cannot trust it. 2452 struct stat StatBuf; 2453 if (::stat(File->getName(), &StatBuf) != 0) { 2454 StatBuf.st_size = File->getSize(); 2455 StatBuf.st_mtime = File->getModificationTime(); 2456 } 2457 2458 if (((off_t)Record[4] != StatBuf.st_size 2459#if !defined(LLVM_ON_WIN32) 2460 // In our regression testing, the Windows file system seems to 2461 // have inconsistent modification times that sometimes 2462 // erroneously trigger this error-handling path. 2463 || (time_t)Record[5] != StatBuf.st_mtime 2464#endif 2465 )) { 2466 Error(diag::err_fe_pch_file_modified, Filename); 2467 return IgnorePCH; 2468 } 2469 2470 break; 2471 } 2472 } 2473 } 2474 2475 return Success; 2476} 2477 2478void ASTReader::makeNamesVisible(const HiddenNames &Names) { 2479 for (unsigned I = 0, N = Names.size(); I != N; ++I) { 2480 if (Decl *D = Names[I].dyn_cast<Decl *>()) 2481 D->ModulePrivate = false; 2482 else 2483 Names[I].get<IdentifierInfo *>()->setHasMacroDefinition(true); 2484 } 2485} 2486 2487void ASTReader::makeModuleVisible(Module *Mod, 2488 Module::NameVisibilityKind NameVisibility) { 2489 llvm::SmallPtrSet<Module *, 4> Visited; 2490 llvm::SmallVector<Module *, 4> Stack; 2491 Stack.push_back(Mod); 2492 while (!Stack.empty()) { 2493 Mod = Stack.back(); 2494 Stack.pop_back(); 2495 2496 if (NameVisibility <= Mod->NameVisibility) { 2497 // This module already has this level of visibility (or greater), so 2498 // there is nothing more to do. 2499 continue; 2500 } 2501 2502 // Update the module's name visibility. 2503 Mod->NameVisibility = NameVisibility; 2504 2505 // If we've already deserialized any names from this module, 2506 // mark them as visible. 2507 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 2508 if (Hidden != HiddenNamesMap.end()) { 2509 makeNamesVisible(Hidden->second); 2510 HiddenNamesMap.erase(Hidden); 2511 } 2512 2513 // Push any non-explicit submodules onto the stack to be marked as 2514 // visible. 2515 for (llvm::StringMap<Module *>::iterator Sub = Mod->SubModules.begin(), 2516 SubEnd = Mod->SubModules.end(); 2517 Sub != SubEnd; ++Sub) { 2518 if (!Sub->getValue()->IsExplicit && Visited.insert(Sub->getValue())) 2519 Stack.push_back(Sub->getValue()); 2520 } 2521 2522 // Push any exported modules onto the stack to be marked as visible. 2523 bool AnyWildcard = false; 2524 bool UnrestrictedWildcard = false; 2525 llvm::SmallVector<Module *, 4> WildcardRestrictions; 2526 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { 2527 Module *Exported = Mod->Exports[I].getPointer(); 2528 if (!Mod->Exports[I].getInt()) { 2529 // Export a named module directly; no wildcards involved. 2530 if (Visited.insert(Exported)) 2531 Stack.push_back(Exported); 2532 2533 continue; 2534 } 2535 2536 // Wildcard export: export all of the imported modules that match 2537 // the given pattern. 2538 AnyWildcard = true; 2539 if (UnrestrictedWildcard) 2540 continue; 2541 2542 if (Module *Restriction = Mod->Exports[I].getPointer()) 2543 WildcardRestrictions.push_back(Restriction); 2544 else { 2545 WildcardRestrictions.clear(); 2546 UnrestrictedWildcard = true; 2547 } 2548 } 2549 2550 // If there were any wildcards, push any imported modules that were 2551 // re-exported by the wildcard restriction. 2552 if (!AnyWildcard) 2553 continue; 2554 2555 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { 2556 Module *Imported = Mod->Imports[I]; 2557 if (Visited.count(Imported)) 2558 continue; 2559 2560 bool Acceptable = UnrestrictedWildcard; 2561 if (!Acceptable) { 2562 // Check whether this module meets one of the restrictions. 2563 for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) { 2564 Module *Restriction = WildcardRestrictions[R]; 2565 if (Imported == Restriction || Imported->isSubModuleOf(Restriction)) { 2566 Acceptable = true; 2567 break; 2568 } 2569 } 2570 } 2571 2572 if (!Acceptable) 2573 continue; 2574 2575 Visited.insert(Imported); 2576 Stack.push_back(Imported); 2577 } 2578 } 2579} 2580 2581ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2582 ModuleKind Type) { 2583 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) { 2584 case Failure: return Failure; 2585 case IgnorePCH: return IgnorePCH; 2586 case Success: break; 2587 } 2588 2589 // Here comes stuff that we only do once the entire chain is loaded. 2590 2591 // Check the predefines buffers. 2592 if (!DisableValidation && Type == MK_PCH && 2593 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines; 2594 // if DisableValidation is true, defines that were set on command-line 2595 // but not in the PCH file will not be added to SuggestedPredefines. 2596 CheckPredefinesBuffers()) 2597 return IgnorePCH; 2598 2599 // Mark all of the identifiers in the identifier table as being out of date, 2600 // so that various accessors know to check the loaded modules when the 2601 // identifier is used. 2602 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2603 IdEnd = PP.getIdentifierTable().end(); 2604 Id != IdEnd; ++Id) 2605 Id->second->setOutOfDate(true); 2606 2607 // Resolve any unresolved module exports. 2608 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) { 2609 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I]; 2610 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 2611 Module *ResolvedMod = getSubmodule(GlobalID); 2612 2613 if (Unresolved.IsImport) { 2614 if (ResolvedMod) 2615 Unresolved.Mod->Imports.push_back(ResolvedMod); 2616 continue; 2617 } 2618 2619 if (ResolvedMod || Unresolved.IsWildcard) 2620 Unresolved.Mod->Exports.push_back( 2621 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 2622 } 2623 UnresolvedModuleImportExports.clear(); 2624 2625 InitializeContext(); 2626 2627 if (DeserializationListener) 2628 DeserializationListener->ReaderInitialized(this); 2629 2630 // If this AST file is a precompiled preamble, then set the preamble file ID 2631 // of the source manager to the file source file from which the preamble was 2632 // built. 2633 if (Type == MK_Preamble) { 2634 if (!OriginalFileID.isInvalid()) { 2635 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2636 + OriginalFileID.getOpaqueValue() - 1); 2637 SourceMgr.setPreambleFileID(OriginalFileID); 2638 } 2639 } 2640 2641 return Success; 2642} 2643 2644ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2645 ModuleKind Type, 2646 ModuleFile *ImportedBy) { 2647 ModuleFile *M; 2648 bool NewModule; 2649 std::string ErrorStr; 2650 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy, 2651 ErrorStr); 2652 2653 if (!M) { 2654 // We couldn't load the module. 2655 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2656 + ErrorStr; 2657 Error(Msg); 2658 return Failure; 2659 } 2660 2661 if (!NewModule) { 2662 // We've already loaded this module. 2663 return Success; 2664 } 2665 2666 // FIXME: This seems rather a hack. Should CurrentDir be part of the 2667 // module? 2668 if (FileName != "-") { 2669 CurrentDir = llvm::sys::path::parent_path(FileName); 2670 if (CurrentDir.empty()) CurrentDir = "."; 2671 } 2672 2673 ModuleFile &F = *M; 2674 llvm::BitstreamCursor &Stream = F.Stream; 2675 Stream.init(F.StreamFile); 2676 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2677 2678 // Sniff for the signature. 2679 if (Stream.Read(8) != 'C' || 2680 Stream.Read(8) != 'P' || 2681 Stream.Read(8) != 'C' || 2682 Stream.Read(8) != 'H') { 2683 Diag(diag::err_not_a_pch_file) << FileName; 2684 return Failure; 2685 } 2686 2687 while (!Stream.AtEndOfStream()) { 2688 unsigned Code = Stream.ReadCode(); 2689 2690 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2691 Error("invalid record at top-level of AST file"); 2692 return Failure; 2693 } 2694 2695 unsigned BlockID = Stream.ReadSubBlockID(); 2696 2697 // We only know the AST subblock ID. 2698 switch (BlockID) { 2699 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2700 if (Stream.ReadBlockInfoBlock()) { 2701 Error("malformed BlockInfoBlock in AST file"); 2702 return Failure; 2703 } 2704 break; 2705 case AST_BLOCK_ID: 2706 switch (ReadASTBlock(F)) { 2707 case Success: 2708 break; 2709 2710 case Failure: 2711 return Failure; 2712 2713 case IgnorePCH: 2714 // FIXME: We could consider reading through to the end of this 2715 // AST block, skipping subblocks, to see if there are other 2716 // AST blocks elsewhere. 2717 2718 // FIXME: We can't clear loaded slocentries anymore. 2719 //SourceMgr.ClearPreallocatedSLocEntries(); 2720 2721 // Remove the stat cache. 2722 if (F.StatCache) 2723 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2724 2725 return IgnorePCH; 2726 } 2727 break; 2728 default: 2729 if (Stream.SkipBlock()) { 2730 Error("malformed block record in AST file"); 2731 return Failure; 2732 } 2733 break; 2734 } 2735 } 2736 2737 // Once read, set the ModuleFile bit base offset and update the size in 2738 // bits of all files we've seen. 2739 F.GlobalBitOffset = TotalModulesSizeInBits; 2740 TotalModulesSizeInBits += F.SizeInBits; 2741 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2742 2743 // Make sure that the files this module was built against are still available. 2744 if (!DisableValidation) { 2745 switch(validateFileEntries(*M)) { 2746 case Failure: return Failure; 2747 case IgnorePCH: return IgnorePCH; 2748 case Success: break; 2749 } 2750 } 2751 2752 // Preload SLocEntries. 2753 for (unsigned I = 0, N = M->PreloadSLocEntries.size(); I != N; ++I) { 2754 int Index = int(M->PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2755 // Load it through the SourceManager and don't call ReadSLocEntryRecord() 2756 // directly because the entry may have already been loaded in which case 2757 // calling ReadSLocEntryRecord() directly would trigger an assertion in 2758 // SourceManager. 2759 SourceMgr.getLoadedSLocEntryByID(Index); 2760 } 2761 2762 2763 return Success; 2764} 2765 2766void ASTReader::InitializeContext() { 2767 // If there's a listener, notify them that we "read" the translation unit. 2768 if (DeserializationListener) 2769 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 2770 Context.getTranslationUnitDecl()); 2771 2772 // Make sure we load the declaration update records for the translation unit, 2773 // if there are any. 2774 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 2775 Context.getTranslationUnitDecl()); 2776 2777 // FIXME: Find a better way to deal with collisions between these 2778 // built-in types. Right now, we just ignore the problem. 2779 2780 // Load the special types. 2781 if (SpecialTypes.size() > NumSpecialTypeIDs) { 2782 if (Context.getBuiltinVaListType().isNull()) { 2783 Context.setBuiltinVaListType( 2784 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2785 } 2786 2787 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) { 2788 if (Context.ObjCProtoType.isNull()) 2789 Context.ObjCProtoType = GetType(Proto); 2790 } 2791 2792 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 2793 if (!Context.CFConstantStringTypeDecl) 2794 Context.setCFConstantStringType(GetType(String)); 2795 } 2796 2797 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2798 QualType FileType = GetType(File); 2799 if (FileType.isNull()) { 2800 Error("FILE type is NULL"); 2801 return; 2802 } 2803 2804 if (!Context.FILEDecl) { 2805 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2806 Context.setFILEDecl(Typedef->getDecl()); 2807 else { 2808 const TagType *Tag = FileType->getAs<TagType>(); 2809 if (!Tag) { 2810 Error("Invalid FILE type in AST file"); 2811 return; 2812 } 2813 Context.setFILEDecl(Tag->getDecl()); 2814 } 2815 } 2816 } 2817 2818 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 2819 QualType Jmp_bufType = GetType(Jmp_buf); 2820 if (Jmp_bufType.isNull()) { 2821 Error("jmp_buf type is NULL"); 2822 return; 2823 } 2824 2825 if (!Context.jmp_bufDecl) { 2826 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2827 Context.setjmp_bufDecl(Typedef->getDecl()); 2828 else { 2829 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2830 if (!Tag) { 2831 Error("Invalid jmp_buf type in AST file"); 2832 return; 2833 } 2834 Context.setjmp_bufDecl(Tag->getDecl()); 2835 } 2836 } 2837 } 2838 2839 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 2840 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2841 if (Sigjmp_bufType.isNull()) { 2842 Error("sigjmp_buf type is NULL"); 2843 return; 2844 } 2845 2846 if (!Context.sigjmp_bufDecl) { 2847 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2848 Context.setsigjmp_bufDecl(Typedef->getDecl()); 2849 else { 2850 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2851 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2852 Context.setsigjmp_bufDecl(Tag->getDecl()); 2853 } 2854 } 2855 } 2856 2857 if (unsigned ObjCIdRedef 2858 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 2859 if (Context.ObjCIdRedefinitionType.isNull()) 2860 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2861 } 2862 2863 if (unsigned ObjCClassRedef 2864 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 2865 if (Context.ObjCClassRedefinitionType.isNull()) 2866 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2867 } 2868 2869 if (unsigned ObjCSelRedef 2870 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 2871 if (Context.ObjCSelRedefinitionType.isNull()) 2872 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2873 } 2874 2875 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 2876 QualType Ucontext_tType = GetType(Ucontext_t); 2877 if (Ucontext_tType.isNull()) { 2878 Error("ucontext_t type is NULL"); 2879 return; 2880 } 2881 2882 if (!Context.ucontext_tDecl) { 2883 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 2884 Context.setucontext_tDecl(Typedef->getDecl()); 2885 else { 2886 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 2887 assert(Tag && "Invalid ucontext_t type in AST file"); 2888 Context.setucontext_tDecl(Tag->getDecl()); 2889 } 2890 } 2891 } 2892 } 2893 2894 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 2895 2896 // If there were any CUDA special declarations, deserialize them. 2897 if (!CUDASpecialDeclRefs.empty()) { 2898 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 2899 Context.setcudaConfigureCallDecl( 2900 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 2901 } 2902 2903 // Re-export any modules that were imported by a non-module AST file. 2904 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 2905 if (Module *Imported = getSubmodule(ImportedModules[I])) 2906 makeModuleVisible(Imported, Module::AllVisible); 2907 } 2908 ImportedModules.clear(); 2909} 2910 2911void ASTReader::finalizeForWriting() { 2912 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 2913 HiddenEnd = HiddenNamesMap.end(); 2914 Hidden != HiddenEnd; ++Hidden) { 2915 makeNamesVisible(Hidden->second); 2916 } 2917 HiddenNamesMap.clear(); 2918} 2919 2920/// \brief Retrieve the name of the original source file name 2921/// directly from the AST file, without actually loading the AST 2922/// file. 2923std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2924 FileManager &FileMgr, 2925 DiagnosticsEngine &Diags) { 2926 // Open the AST file. 2927 std::string ErrStr; 2928 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2929 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 2930 if (!Buffer) { 2931 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2932 return std::string(); 2933 } 2934 2935 // Initialize the stream 2936 llvm::BitstreamReader StreamFile; 2937 llvm::BitstreamCursor Stream; 2938 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2939 (const unsigned char *)Buffer->getBufferEnd()); 2940 Stream.init(StreamFile); 2941 2942 // Sniff for the signature. 2943 if (Stream.Read(8) != 'C' || 2944 Stream.Read(8) != 'P' || 2945 Stream.Read(8) != 'C' || 2946 Stream.Read(8) != 'H') { 2947 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2948 return std::string(); 2949 } 2950 2951 RecordData Record; 2952 while (!Stream.AtEndOfStream()) { 2953 unsigned Code = Stream.ReadCode(); 2954 2955 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2956 unsigned BlockID = Stream.ReadSubBlockID(); 2957 2958 // We only know the AST subblock ID. 2959 switch (BlockID) { 2960 case AST_BLOCK_ID: 2961 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2962 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2963 return std::string(); 2964 } 2965 break; 2966 2967 default: 2968 if (Stream.SkipBlock()) { 2969 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2970 return std::string(); 2971 } 2972 break; 2973 } 2974 continue; 2975 } 2976 2977 if (Code == llvm::bitc::END_BLOCK) { 2978 if (Stream.ReadBlockEnd()) { 2979 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2980 return std::string(); 2981 } 2982 continue; 2983 } 2984 2985 if (Code == llvm::bitc::DEFINE_ABBREV) { 2986 Stream.ReadAbbrevRecord(); 2987 continue; 2988 } 2989 2990 Record.clear(); 2991 const char *BlobStart = 0; 2992 unsigned BlobLen = 0; 2993 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 2994 == ORIGINAL_FILE_NAME) 2995 return std::string(BlobStart, BlobLen); 2996 } 2997 2998 return std::string(); 2999} 3000 3001ASTReader::ASTReadResult ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 3002 // Enter the submodule block. 3003 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 3004 Error("malformed submodule block record in AST file"); 3005 return Failure; 3006 } 3007 3008 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 3009 bool First = true; 3010 Module *CurrentModule = 0; 3011 RecordData Record; 3012 while (true) { 3013 unsigned Code = F.Stream.ReadCode(); 3014 if (Code == llvm::bitc::END_BLOCK) { 3015 if (F.Stream.ReadBlockEnd()) { 3016 Error("error at end of submodule block in AST file"); 3017 return Failure; 3018 } 3019 return Success; 3020 } 3021 3022 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3023 // No known subblocks, always skip them. 3024 F.Stream.ReadSubBlockID(); 3025 if (F.Stream.SkipBlock()) { 3026 Error("malformed block record in AST file"); 3027 return Failure; 3028 } 3029 continue; 3030 } 3031 3032 if (Code == llvm::bitc::DEFINE_ABBREV) { 3033 F.Stream.ReadAbbrevRecord(); 3034 continue; 3035 } 3036 3037 // Read a record. 3038 const char *BlobStart; 3039 unsigned BlobLen; 3040 Record.clear(); 3041 switch (F.Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 3042 default: // Default behavior: ignore. 3043 break; 3044 3045 case SUBMODULE_DEFINITION: { 3046 if (First) { 3047 Error("missing submodule metadata record at beginning of block"); 3048 return Failure; 3049 } 3050 3051 if (Record.size() < 7) { 3052 Error("malformed module definition"); 3053 return Failure; 3054 } 3055 3056 StringRef Name(BlobStart, BlobLen); 3057 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]); 3058 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]); 3059 bool IsFramework = Record[2]; 3060 bool IsExplicit = Record[3]; 3061 bool InferSubmodules = Record[4]; 3062 bool InferExplicitSubmodules = Record[5]; 3063 bool InferExportWildcard = Record[6]; 3064 3065 Module *ParentModule = 0; 3066 if (Parent) 3067 ParentModule = getSubmodule(Parent); 3068 3069 // Retrieve this (sub)module from the module map, creating it if 3070 // necessary. 3071 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3072 IsFramework, 3073 IsExplicit).first; 3074 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 3075 if (GlobalIndex >= SubmodulesLoaded.size() || 3076 SubmodulesLoaded[GlobalIndex]) { 3077 Error("too many submodules"); 3078 return Failure; 3079 } 3080 3081 CurrentModule->InferSubmodules = InferSubmodules; 3082 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 3083 CurrentModule->InferExportWildcard = InferExportWildcard; 3084 if (DeserializationListener) 3085 DeserializationListener->ModuleRead(GlobalID, CurrentModule); 3086 3087 SubmodulesLoaded[GlobalIndex] = CurrentModule; 3088 break; 3089 } 3090 3091 case SUBMODULE_UMBRELLA_HEADER: { 3092 if (First) { 3093 Error("missing submodule metadata record at beginning of block"); 3094 return Failure; 3095 } 3096 3097 if (!CurrentModule) 3098 break; 3099 3100 StringRef FileName(BlobStart, BlobLen); 3101 if (const FileEntry *Umbrella = PP.getFileManager().getFile(FileName)) { 3102 if (!CurrentModule->getUmbrellaHeader()) 3103 ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 3104 else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 3105 Error("mismatched umbrella headers in submodule"); 3106 return Failure; 3107 } 3108 } 3109 break; 3110 } 3111 3112 case SUBMODULE_HEADER: { 3113 if (First) { 3114 Error("missing submodule metadata record at beginning of block"); 3115 return Failure; 3116 } 3117 3118 if (!CurrentModule) 3119 break; 3120 3121 // FIXME: Be more lazy about this! 3122 StringRef FileName(BlobStart, BlobLen); 3123 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) { 3124 if (std::find(CurrentModule->Headers.begin(), 3125 CurrentModule->Headers.end(), 3126 File) == CurrentModule->Headers.end()) 3127 ModMap.addHeader(CurrentModule, File); 3128 } 3129 break; 3130 } 3131 3132 case SUBMODULE_UMBRELLA_DIR: { 3133 if (First) { 3134 Error("missing submodule metadata record at beginning of block"); 3135 return Failure; 3136 } 3137 3138 if (!CurrentModule) 3139 break; 3140 3141 StringRef DirName(BlobStart, BlobLen); 3142 if (const DirectoryEntry *Umbrella 3143 = PP.getFileManager().getDirectory(DirName)) { 3144 if (!CurrentModule->getUmbrellaDir()) 3145 ModMap.setUmbrellaDir(CurrentModule, Umbrella); 3146 else if (CurrentModule->getUmbrellaDir() != Umbrella) { 3147 Error("mismatched umbrella directories in submodule"); 3148 return Failure; 3149 } 3150 } 3151 break; 3152 } 3153 3154 case SUBMODULE_METADATA: { 3155 if (!First) { 3156 Error("submodule metadata record not at beginning of block"); 3157 return Failure; 3158 } 3159 First = false; 3160 3161 F.BaseSubmoduleID = getTotalNumSubmodules(); 3162 F.LocalNumSubmodules = Record[0]; 3163 unsigned LocalBaseSubmoduleID = Record[1]; 3164 if (F.LocalNumSubmodules > 0) { 3165 // Introduce the global -> local mapping for submodules within this 3166 // module. 3167 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3168 3169 // Introduce the local -> global mapping for submodules within this 3170 // module. 3171 F.SubmoduleRemap.insert( 3172 std::make_pair(LocalBaseSubmoduleID, 3173 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3174 3175 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3176 } 3177 break; 3178 } 3179 3180 case SUBMODULE_IMPORTS: { 3181 if (First) { 3182 Error("missing submodule metadata record at beginning of block"); 3183 return Failure; 3184 } 3185 3186 if (!CurrentModule) 3187 break; 3188 3189 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3190 UnresolvedModuleImportExport Unresolved; 3191 Unresolved.File = &F; 3192 Unresolved.Mod = CurrentModule; 3193 Unresolved.ID = Record[Idx]; 3194 Unresolved.IsImport = true; 3195 Unresolved.IsWildcard = false; 3196 UnresolvedModuleImportExports.push_back(Unresolved); 3197 } 3198 break; 3199 } 3200 3201 case SUBMODULE_EXPORTS: { 3202 if (First) { 3203 Error("missing submodule metadata record at beginning of block"); 3204 return Failure; 3205 } 3206 3207 if (!CurrentModule) 3208 break; 3209 3210 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3211 UnresolvedModuleImportExport Unresolved; 3212 Unresolved.File = &F; 3213 Unresolved.Mod = CurrentModule; 3214 Unresolved.ID = Record[Idx]; 3215 Unresolved.IsImport = false; 3216 Unresolved.IsWildcard = Record[Idx + 1]; 3217 UnresolvedModuleImportExports.push_back(Unresolved); 3218 } 3219 3220 // Once we've loaded the set of exports, there's no reason to keep 3221 // the parsed, unresolved exports around. 3222 CurrentModule->UnresolvedExports.clear(); 3223 break; 3224 } 3225 } 3226 } 3227 3228 return Success; 3229} 3230 3231/// \brief Parse the record that corresponds to a LangOptions data 3232/// structure. 3233/// 3234/// This routine parses the language options from the AST file and then gives 3235/// them to the AST listener if one is set. 3236/// 3237/// \returns true if the listener deems the file unacceptable, false otherwise. 3238bool ASTReader::ParseLanguageOptions( 3239 const SmallVectorImpl<uint64_t> &Record) { 3240 if (Listener) { 3241 LangOptions LangOpts; 3242 unsigned Idx = 0; 3243#define LANGOPT(Name, Bits, Default, Description) \ 3244 LangOpts.Name = Record[Idx++]; 3245#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3246 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3247#include "clang/Basic/LangOptions.def" 3248 3249 unsigned Length = Record[Idx++]; 3250 LangOpts.CurrentModule.assign(Record.begin() + Idx, 3251 Record.begin() + Idx + Length); 3252 Idx += Length; 3253 return Listener->ReadLanguageOptions(LangOpts); 3254 } 3255 3256 return false; 3257} 3258 3259std::pair<ModuleFile *, unsigned> 3260ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 3261 GlobalPreprocessedEntityMapType::iterator 3262 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 3263 assert(I != GlobalPreprocessedEntityMap.end() && 3264 "Corrupted global preprocessed entity map"); 3265 ModuleFile *M = I->second; 3266 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 3267 return std::make_pair(M, LocalIndex); 3268} 3269 3270PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 3271 PreprocessedEntityID PPID = Index+1; 3272 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3273 ModuleFile &M = *PPInfo.first; 3274 unsigned LocalIndex = PPInfo.second; 3275 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3276 3277 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 3278 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 3279 3280 unsigned Code = M.PreprocessorDetailCursor.ReadCode(); 3281 switch (Code) { 3282 case llvm::bitc::END_BLOCK: 3283 return 0; 3284 3285 case llvm::bitc::ENTER_SUBBLOCK: 3286 Error("unexpected subblock record in preprocessor detail block"); 3287 return 0; 3288 3289 case llvm::bitc::DEFINE_ABBREV: 3290 Error("unexpected abbrevation record in preprocessor detail block"); 3291 return 0; 3292 3293 default: 3294 break; 3295 } 3296 3297 if (!PP.getPreprocessingRecord()) { 3298 Error("no preprocessing record"); 3299 return 0; 3300 } 3301 3302 // Read the record. 3303 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 3304 ReadSourceLocation(M, PPOffs.End)); 3305 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 3306 const char *BlobStart = 0; 3307 unsigned BlobLen = 0; 3308 RecordData Record; 3309 PreprocessorDetailRecordTypes RecType = 3310 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord( 3311 Code, Record, BlobStart, BlobLen); 3312 switch (RecType) { 3313 case PPD_MACRO_EXPANSION: { 3314 bool isBuiltin = Record[0]; 3315 IdentifierInfo *Name = 0; 3316 MacroDefinition *Def = 0; 3317 if (isBuiltin) 3318 Name = getLocalIdentifier(M, Record[1]); 3319 else { 3320 PreprocessedEntityID 3321 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 3322 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 3323 } 3324 3325 MacroExpansion *ME; 3326 if (isBuiltin) 3327 ME = new (PPRec) MacroExpansion(Name, Range); 3328 else 3329 ME = new (PPRec) MacroExpansion(Def, Range); 3330 3331 return ME; 3332 } 3333 3334 case PPD_MACRO_DEFINITION: { 3335 // Decode the identifier info and then check again; if the macro is 3336 // still defined and associated with the identifier, 3337 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 3338 MacroDefinition *MD 3339 = new (PPRec) MacroDefinition(II, Range); 3340 3341 if (DeserializationListener) 3342 DeserializationListener->MacroDefinitionRead(PPID, MD); 3343 3344 return MD; 3345 } 3346 3347 case PPD_INCLUSION_DIRECTIVE: { 3348 const char *FullFileNameStart = BlobStart + Record[0]; 3349 const FileEntry *File 3350 = PP.getFileManager().getFile(StringRef(FullFileNameStart, 3351 BlobLen - Record[0])); 3352 3353 // FIXME: Stable encoding 3354 InclusionDirective::InclusionKind Kind 3355 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 3356 InclusionDirective *ID 3357 = new (PPRec) InclusionDirective(PPRec, Kind, 3358 StringRef(BlobStart, Record[0]), 3359 Record[1], 3360 File, 3361 Range); 3362 return ID; 3363 } 3364 } 3365 3366 Error("invalid offset in preprocessor detail block"); 3367 return 0; 3368} 3369 3370/// \brief \arg SLocMapI points at a chunk of a module that contains no 3371/// preprocessed entities or the entities it contains are not the ones we are 3372/// looking for. Find the next module that contains entities and return the ID 3373/// of the first entry. 3374PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 3375 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 3376 ++SLocMapI; 3377 for (GlobalSLocOffsetMapType::const_iterator 3378 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 3379 ModuleFile &M = *SLocMapI->second; 3380 if (M.NumPreprocessedEntities) 3381 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID); 3382 } 3383 3384 return getTotalNumPreprocessedEntities(); 3385} 3386 3387namespace { 3388 3389template <unsigned PPEntityOffset::*PPLoc> 3390struct PPEntityComp { 3391 const ASTReader &Reader; 3392 ModuleFile &M; 3393 3394 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 3395 3396 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 3397 SourceLocation LHS = getLoc(L); 3398 SourceLocation RHS = getLoc(R); 3399 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3400 } 3401 3402 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 3403 SourceLocation LHS = getLoc(L); 3404 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3405 } 3406 3407 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 3408 SourceLocation RHS = getLoc(R); 3409 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3410 } 3411 3412 SourceLocation getLoc(const PPEntityOffset &PPE) const { 3413 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 3414 } 3415}; 3416 3417} 3418 3419/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 3420PreprocessedEntityID 3421ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 3422 if (SourceMgr.isLocalSourceLocation(BLoc)) 3423 return getTotalNumPreprocessedEntities(); 3424 3425 GlobalSLocOffsetMapType::const_iterator 3426 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3427 BLoc.getOffset()); 3428 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3429 "Corrupted global sloc offset map"); 3430 3431 if (SLocMapI->second->NumPreprocessedEntities == 0) 3432 return findNextPreprocessedEntity(SLocMapI); 3433 3434 ModuleFile &M = *SLocMapI->second; 3435 typedef const PPEntityOffset *pp_iterator; 3436 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3437 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3438 3439 size_t Count = M.NumPreprocessedEntities; 3440 size_t Half; 3441 pp_iterator First = pp_begin; 3442 pp_iterator PPI; 3443 3444 // Do a binary search manually instead of using std::lower_bound because 3445 // The end locations of entities may be unordered (when a macro expansion 3446 // is inside another macro argument), but for this case it is not important 3447 // whether we get the first macro expansion or its containing macro. 3448 while (Count > 0) { 3449 Half = Count/2; 3450 PPI = First; 3451 std::advance(PPI, Half); 3452 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 3453 BLoc)){ 3454 First = PPI; 3455 ++First; 3456 Count = Count - Half - 1; 3457 } else 3458 Count = Half; 3459 } 3460 3461 if (PPI == pp_end) 3462 return findNextPreprocessedEntity(SLocMapI); 3463 3464 return getGlobalPreprocessedEntityID(M, 3465 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3466} 3467 3468/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 3469PreprocessedEntityID 3470ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 3471 if (SourceMgr.isLocalSourceLocation(ELoc)) 3472 return getTotalNumPreprocessedEntities(); 3473 3474 GlobalSLocOffsetMapType::const_iterator 3475 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3476 ELoc.getOffset()); 3477 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3478 "Corrupted global sloc offset map"); 3479 3480 if (SLocMapI->second->NumPreprocessedEntities == 0) 3481 return findNextPreprocessedEntity(SLocMapI); 3482 3483 ModuleFile &M = *SLocMapI->second; 3484 typedef const PPEntityOffset *pp_iterator; 3485 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3486 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3487 pp_iterator PPI = 3488 std::upper_bound(pp_begin, pp_end, ELoc, 3489 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 3490 3491 if (PPI == pp_end) 3492 return findNextPreprocessedEntity(SLocMapI); 3493 3494 return getGlobalPreprocessedEntityID(M, 3495 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3496} 3497 3498/// \brief Returns a pair of [Begin, End) indices of preallocated 3499/// preprocessed entities that \arg Range encompasses. 3500std::pair<unsigned, unsigned> 3501 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 3502 if (Range.isInvalid()) 3503 return std::make_pair(0,0); 3504 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 3505 3506 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 3507 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 3508 return std::make_pair(BeginID, EndID); 3509} 3510 3511/// \brief Optionally returns true or false if the preallocated preprocessed 3512/// entity with index \arg Index came from file \arg FID. 3513llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 3514 FileID FID) { 3515 if (FID.isInvalid()) 3516 return false; 3517 3518 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3519 ModuleFile &M = *PPInfo.first; 3520 unsigned LocalIndex = PPInfo.second; 3521 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3522 3523 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 3524 if (Loc.isInvalid()) 3525 return false; 3526 3527 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 3528 return true; 3529 else 3530 return false; 3531} 3532 3533namespace { 3534 /// \brief Visitor used to search for information about a header file. 3535 class HeaderFileInfoVisitor { 3536 ASTReader &Reader; 3537 const FileEntry *FE; 3538 3539 llvm::Optional<HeaderFileInfo> HFI; 3540 3541 public: 3542 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) 3543 : Reader(Reader), FE(FE) { } 3544 3545 static bool visit(ModuleFile &M, void *UserData) { 3546 HeaderFileInfoVisitor *This 3547 = static_cast<HeaderFileInfoVisitor *>(UserData); 3548 3549 HeaderFileInfoTrait Trait(This->Reader, M, 3550 &This->Reader.getPreprocessor().getHeaderSearchInfo(), 3551 M.HeaderFileFrameworkStrings, 3552 This->FE->getName()); 3553 3554 HeaderFileInfoLookupTable *Table 3555 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 3556 if (!Table) 3557 return false; 3558 3559 // Look in the on-disk hash table for an entry for this file name. 3560 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(), 3561 &Trait); 3562 if (Pos == Table->end()) 3563 return false; 3564 3565 This->HFI = *Pos; 3566 return true; 3567 } 3568 3569 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 3570 }; 3571} 3572 3573HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3574 HeaderFileInfoVisitor Visitor(*this, FE); 3575 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 3576 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 3577 if (Listener) 3578 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 3579 return *HFI; 3580 } 3581 3582 return HeaderFileInfo(); 3583} 3584 3585void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 3586 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3587 ModuleFile &F = *(*I); 3588 unsigned Idx = 0; 3589 while (Idx < F.PragmaDiagMappings.size()) { 3590 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3591 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 3592 Diag.DiagStatePoints.push_back( 3593 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(), 3594 FullSourceLoc(Loc, SourceMgr))); 3595 while (1) { 3596 assert(Idx < F.PragmaDiagMappings.size() && 3597 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3598 if (Idx >= F.PragmaDiagMappings.size()) { 3599 break; // Something is messed up but at least avoid infinite loop in 3600 // release build. 3601 } 3602 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3603 if (DiagID == (unsigned)-1) { 3604 break; // no more diag/map pairs for this location. 3605 } 3606 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3607 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 3608 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 3609 } 3610 } 3611 } 3612} 3613 3614/// \brief Get the correct cursor and offset for loading a type. 3615ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3616 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3617 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3618 ModuleFile *M = I->second; 3619 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3620} 3621 3622/// \brief Read and return the type with the given index.. 3623/// 3624/// The index is the type ID, shifted and minus the number of predefs. This 3625/// routine actually reads the record corresponding to the type at the given 3626/// location. It is a helper routine for GetType, which deals with reading type 3627/// IDs. 3628QualType ASTReader::readTypeRecord(unsigned Index) { 3629 RecordLocation Loc = TypeCursorForIndex(Index); 3630 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3631 3632 // Keep track of where we are in the stream, then jump back there 3633 // after reading this type. 3634 SavedStreamPosition SavedPosition(DeclsCursor); 3635 3636 ReadingKindTracker ReadingKind(Read_Type, *this); 3637 3638 // Note that we are loading a type record. 3639 Deserializing AType(this); 3640 3641 unsigned Idx = 0; 3642 DeclsCursor.JumpToBit(Loc.Offset); 3643 RecordData Record; 3644 unsigned Code = DeclsCursor.ReadCode(); 3645 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3646 case TYPE_EXT_QUAL: { 3647 if (Record.size() != 2) { 3648 Error("Incorrect encoding of extended qualifier type"); 3649 return QualType(); 3650 } 3651 QualType Base = readType(*Loc.F, Record, Idx); 3652 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3653 return Context.getQualifiedType(Base, Quals); 3654 } 3655 3656 case TYPE_COMPLEX: { 3657 if (Record.size() != 1) { 3658 Error("Incorrect encoding of complex type"); 3659 return QualType(); 3660 } 3661 QualType ElemType = readType(*Loc.F, Record, Idx); 3662 return Context.getComplexType(ElemType); 3663 } 3664 3665 case TYPE_POINTER: { 3666 if (Record.size() != 1) { 3667 Error("Incorrect encoding of pointer type"); 3668 return QualType(); 3669 } 3670 QualType PointeeType = readType(*Loc.F, Record, Idx); 3671 return Context.getPointerType(PointeeType); 3672 } 3673 3674 case TYPE_BLOCK_POINTER: { 3675 if (Record.size() != 1) { 3676 Error("Incorrect encoding of block pointer type"); 3677 return QualType(); 3678 } 3679 QualType PointeeType = readType(*Loc.F, Record, Idx); 3680 return Context.getBlockPointerType(PointeeType); 3681 } 3682 3683 case TYPE_LVALUE_REFERENCE: { 3684 if (Record.size() != 2) { 3685 Error("Incorrect encoding of lvalue reference type"); 3686 return QualType(); 3687 } 3688 QualType PointeeType = readType(*Loc.F, Record, Idx); 3689 return Context.getLValueReferenceType(PointeeType, Record[1]); 3690 } 3691 3692 case TYPE_RVALUE_REFERENCE: { 3693 if (Record.size() != 1) { 3694 Error("Incorrect encoding of rvalue reference type"); 3695 return QualType(); 3696 } 3697 QualType PointeeType = readType(*Loc.F, Record, Idx); 3698 return Context.getRValueReferenceType(PointeeType); 3699 } 3700 3701 case TYPE_MEMBER_POINTER: { 3702 if (Record.size() != 2) { 3703 Error("Incorrect encoding of member pointer type"); 3704 return QualType(); 3705 } 3706 QualType PointeeType = readType(*Loc.F, Record, Idx); 3707 QualType ClassType = readType(*Loc.F, Record, Idx); 3708 if (PointeeType.isNull() || ClassType.isNull()) 3709 return QualType(); 3710 3711 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3712 } 3713 3714 case TYPE_CONSTANT_ARRAY: { 3715 QualType ElementType = readType(*Loc.F, Record, Idx); 3716 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3717 unsigned IndexTypeQuals = Record[2]; 3718 unsigned Idx = 3; 3719 llvm::APInt Size = ReadAPInt(Record, Idx); 3720 return Context.getConstantArrayType(ElementType, Size, 3721 ASM, IndexTypeQuals); 3722 } 3723 3724 case TYPE_INCOMPLETE_ARRAY: { 3725 QualType ElementType = readType(*Loc.F, Record, Idx); 3726 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3727 unsigned IndexTypeQuals = Record[2]; 3728 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3729 } 3730 3731 case TYPE_VARIABLE_ARRAY: { 3732 QualType ElementType = readType(*Loc.F, Record, Idx); 3733 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3734 unsigned IndexTypeQuals = Record[2]; 3735 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3736 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3737 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3738 ASM, IndexTypeQuals, 3739 SourceRange(LBLoc, RBLoc)); 3740 } 3741 3742 case TYPE_VECTOR: { 3743 if (Record.size() != 3) { 3744 Error("incorrect encoding of vector type in AST file"); 3745 return QualType(); 3746 } 3747 3748 QualType ElementType = readType(*Loc.F, Record, Idx); 3749 unsigned NumElements = Record[1]; 3750 unsigned VecKind = Record[2]; 3751 return Context.getVectorType(ElementType, NumElements, 3752 (VectorType::VectorKind)VecKind); 3753 } 3754 3755 case TYPE_EXT_VECTOR: { 3756 if (Record.size() != 3) { 3757 Error("incorrect encoding of extended vector type in AST file"); 3758 return QualType(); 3759 } 3760 3761 QualType ElementType = readType(*Loc.F, Record, Idx); 3762 unsigned NumElements = Record[1]; 3763 return Context.getExtVectorType(ElementType, NumElements); 3764 } 3765 3766 case TYPE_FUNCTION_NO_PROTO: { 3767 if (Record.size() != 6) { 3768 Error("incorrect encoding of no-proto function type"); 3769 return QualType(); 3770 } 3771 QualType ResultType = readType(*Loc.F, Record, Idx); 3772 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3773 (CallingConv)Record[4], Record[5]); 3774 return Context.getFunctionNoProtoType(ResultType, Info); 3775 } 3776 3777 case TYPE_FUNCTION_PROTO: { 3778 QualType ResultType = readType(*Loc.F, Record, Idx); 3779 3780 FunctionProtoType::ExtProtoInfo EPI; 3781 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3782 /*hasregparm*/ Record[2], 3783 /*regparm*/ Record[3], 3784 static_cast<CallingConv>(Record[4]), 3785 /*produces*/ Record[5]); 3786 3787 unsigned Idx = 6; 3788 unsigned NumParams = Record[Idx++]; 3789 SmallVector<QualType, 16> ParamTypes; 3790 for (unsigned I = 0; I != NumParams; ++I) 3791 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3792 3793 EPI.Variadic = Record[Idx++]; 3794 EPI.TypeQuals = Record[Idx++]; 3795 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3796 ExceptionSpecificationType EST = 3797 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3798 EPI.ExceptionSpecType = EST; 3799 if (EST == EST_Dynamic) { 3800 EPI.NumExceptions = Record[Idx++]; 3801 SmallVector<QualType, 2> Exceptions; 3802 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3803 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3804 EPI.Exceptions = Exceptions.data(); 3805 } else if (EST == EST_ComputedNoexcept) { 3806 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3807 } 3808 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams, 3809 EPI); 3810 } 3811 3812 case TYPE_UNRESOLVED_USING: { 3813 unsigned Idx = 0; 3814 return Context.getTypeDeclType( 3815 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3816 } 3817 3818 case TYPE_TYPEDEF: { 3819 if (Record.size() != 2) { 3820 Error("incorrect encoding of typedef type"); 3821 return QualType(); 3822 } 3823 unsigned Idx = 0; 3824 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3825 QualType Canonical = readType(*Loc.F, Record, Idx); 3826 if (!Canonical.isNull()) 3827 Canonical = Context.getCanonicalType(Canonical); 3828 return Context.getTypedefType(Decl, Canonical); 3829 } 3830 3831 case TYPE_TYPEOF_EXPR: 3832 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 3833 3834 case TYPE_TYPEOF: { 3835 if (Record.size() != 1) { 3836 Error("incorrect encoding of typeof(type) in AST file"); 3837 return QualType(); 3838 } 3839 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3840 return Context.getTypeOfType(UnderlyingType); 3841 } 3842 3843 case TYPE_DECLTYPE: 3844 return Context.getDecltypeType(ReadExpr(*Loc.F)); 3845 3846 case TYPE_UNARY_TRANSFORM: { 3847 QualType BaseType = readType(*Loc.F, Record, Idx); 3848 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3849 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3850 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 3851 } 3852 3853 case TYPE_AUTO: 3854 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 3855 3856 case TYPE_RECORD: { 3857 if (Record.size() != 2) { 3858 Error("incorrect encoding of record type"); 3859 return QualType(); 3860 } 3861 unsigned Idx = 0; 3862 bool IsDependent = Record[Idx++]; 3863 QualType T 3864 = Context.getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3865 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3866 return T; 3867 } 3868 3869 case TYPE_ENUM: { 3870 if (Record.size() != 2) { 3871 Error("incorrect encoding of enum type"); 3872 return QualType(); 3873 } 3874 unsigned Idx = 0; 3875 bool IsDependent = Record[Idx++]; 3876 QualType T 3877 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3878 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3879 return T; 3880 } 3881 3882 case TYPE_ATTRIBUTED: { 3883 if (Record.size() != 3) { 3884 Error("incorrect encoding of attributed type"); 3885 return QualType(); 3886 } 3887 QualType modifiedType = readType(*Loc.F, Record, Idx); 3888 QualType equivalentType = readType(*Loc.F, Record, Idx); 3889 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3890 return Context.getAttributedType(kind, modifiedType, equivalentType); 3891 } 3892 3893 case TYPE_PAREN: { 3894 if (Record.size() != 1) { 3895 Error("incorrect encoding of paren type"); 3896 return QualType(); 3897 } 3898 QualType InnerType = readType(*Loc.F, Record, Idx); 3899 return Context.getParenType(InnerType); 3900 } 3901 3902 case TYPE_PACK_EXPANSION: { 3903 if (Record.size() != 2) { 3904 Error("incorrect encoding of pack expansion type"); 3905 return QualType(); 3906 } 3907 QualType Pattern = readType(*Loc.F, Record, Idx); 3908 if (Pattern.isNull()) 3909 return QualType(); 3910 llvm::Optional<unsigned> NumExpansions; 3911 if (Record[1]) 3912 NumExpansions = Record[1] - 1; 3913 return Context.getPackExpansionType(Pattern, NumExpansions); 3914 } 3915 3916 case TYPE_ELABORATED: { 3917 unsigned Idx = 0; 3918 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3919 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3920 QualType NamedType = readType(*Loc.F, Record, Idx); 3921 return Context.getElaboratedType(Keyword, NNS, NamedType); 3922 } 3923 3924 case TYPE_OBJC_INTERFACE: { 3925 unsigned Idx = 0; 3926 ObjCInterfaceDecl *ItfD 3927 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3928 return Context.getObjCInterfaceType(ItfD); 3929 } 3930 3931 case TYPE_OBJC_OBJECT: { 3932 unsigned Idx = 0; 3933 QualType Base = readType(*Loc.F, Record, Idx); 3934 unsigned NumProtos = Record[Idx++]; 3935 SmallVector<ObjCProtocolDecl*, 4> Protos; 3936 for (unsigned I = 0; I != NumProtos; ++I) 3937 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3938 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 3939 } 3940 3941 case TYPE_OBJC_OBJECT_POINTER: { 3942 unsigned Idx = 0; 3943 QualType Pointee = readType(*Loc.F, Record, Idx); 3944 return Context.getObjCObjectPointerType(Pointee); 3945 } 3946 3947 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3948 unsigned Idx = 0; 3949 QualType Parm = readType(*Loc.F, Record, Idx); 3950 QualType Replacement = readType(*Loc.F, Record, Idx); 3951 return 3952 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3953 Replacement); 3954 } 3955 3956 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3957 unsigned Idx = 0; 3958 QualType Parm = readType(*Loc.F, Record, Idx); 3959 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3960 return Context.getSubstTemplateTypeParmPackType( 3961 cast<TemplateTypeParmType>(Parm), 3962 ArgPack); 3963 } 3964 3965 case TYPE_INJECTED_CLASS_NAME: { 3966 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3967 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3968 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3969 // for AST reading, too much interdependencies. 3970 return 3971 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3972 } 3973 3974 case TYPE_TEMPLATE_TYPE_PARM: { 3975 unsigned Idx = 0; 3976 unsigned Depth = Record[Idx++]; 3977 unsigned Index = Record[Idx++]; 3978 bool Pack = Record[Idx++]; 3979 TemplateTypeParmDecl *D 3980 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3981 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 3982 } 3983 3984 case TYPE_DEPENDENT_NAME: { 3985 unsigned Idx = 0; 3986 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3987 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3988 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3989 QualType Canon = readType(*Loc.F, Record, Idx); 3990 if (!Canon.isNull()) 3991 Canon = Context.getCanonicalType(Canon); 3992 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 3993 } 3994 3995 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3996 unsigned Idx = 0; 3997 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3998 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3999 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4000 unsigned NumArgs = Record[Idx++]; 4001 SmallVector<TemplateArgument, 8> Args; 4002 Args.reserve(NumArgs); 4003 while (NumArgs--) 4004 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 4005 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 4006 Args.size(), Args.data()); 4007 } 4008 4009 case TYPE_DEPENDENT_SIZED_ARRAY: { 4010 unsigned Idx = 0; 4011 4012 // ArrayType 4013 QualType ElementType = readType(*Loc.F, Record, Idx); 4014 ArrayType::ArraySizeModifier ASM 4015 = (ArrayType::ArraySizeModifier)Record[Idx++]; 4016 unsigned IndexTypeQuals = Record[Idx++]; 4017 4018 // DependentSizedArrayType 4019 Expr *NumElts = ReadExpr(*Loc.F); 4020 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 4021 4022 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 4023 IndexTypeQuals, Brackets); 4024 } 4025 4026 case TYPE_TEMPLATE_SPECIALIZATION: { 4027 unsigned Idx = 0; 4028 bool IsDependent = Record[Idx++]; 4029 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 4030 SmallVector<TemplateArgument, 8> Args; 4031 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 4032 QualType Underlying = readType(*Loc.F, Record, Idx); 4033 QualType T; 4034 if (Underlying.isNull()) 4035 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 4036 Args.size()); 4037 else 4038 T = Context.getTemplateSpecializationType(Name, Args.data(), 4039 Args.size(), Underlying); 4040 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4041 return T; 4042 } 4043 4044 case TYPE_ATOMIC: { 4045 if (Record.size() != 1) { 4046 Error("Incorrect encoding of atomic type"); 4047 return QualType(); 4048 } 4049 QualType ValueType = readType(*Loc.F, Record, Idx); 4050 return Context.getAtomicType(ValueType); 4051 } 4052 } 4053 // Suppress a GCC warning 4054 return QualType(); 4055} 4056 4057class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 4058 ASTReader &Reader; 4059 ModuleFile &F; 4060 llvm::BitstreamCursor &DeclsCursor; 4061 const ASTReader::RecordData &Record; 4062 unsigned &Idx; 4063 4064 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4065 unsigned &I) { 4066 return Reader.ReadSourceLocation(F, R, I); 4067 } 4068 4069 template<typename T> 4070 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4071 return Reader.ReadDeclAs<T>(F, Record, Idx); 4072 } 4073 4074public: 4075 TypeLocReader(ASTReader &Reader, ModuleFile &F, 4076 const ASTReader::RecordData &Record, unsigned &Idx) 4077 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 4078 { } 4079 4080 // We want compile-time assurance that we've enumerated all of 4081 // these, so unfortunately we have to declare them first, then 4082 // define them out-of-line. 4083#define ABSTRACT_TYPELOC(CLASS, PARENT) 4084#define TYPELOC(CLASS, PARENT) \ 4085 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4086#include "clang/AST/TypeLocNodes.def" 4087 4088 void VisitFunctionTypeLoc(FunctionTypeLoc); 4089 void VisitArrayTypeLoc(ArrayTypeLoc); 4090}; 4091 4092void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4093 // nothing to do 4094} 4095void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4096 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4097 if (TL.needsExtraLocalData()) { 4098 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4099 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4100 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4101 TL.setModeAttr(Record[Idx++]); 4102 } 4103} 4104void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4105 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4106} 4107void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4108 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4109} 4110void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4111 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4112} 4113void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4114 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4115} 4116void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4117 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4118} 4119void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4120 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4121 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4122} 4123void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4124 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4125 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4126 if (Record[Idx++]) 4127 TL.setSizeExpr(Reader.ReadExpr(F)); 4128 else 4129 TL.setSizeExpr(0); 4130} 4131void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4132 VisitArrayTypeLoc(TL); 4133} 4134void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4135 VisitArrayTypeLoc(TL); 4136} 4137void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4138 VisitArrayTypeLoc(TL); 4139} 4140void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4141 DependentSizedArrayTypeLoc TL) { 4142 VisitArrayTypeLoc(TL); 4143} 4144void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4145 DependentSizedExtVectorTypeLoc TL) { 4146 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4147} 4148void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4149 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4150} 4151void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4152 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4153} 4154void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4155 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4156 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4157 TL.setTrailingReturn(Record[Idx++]); 4158 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4159 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4160 } 4161} 4162void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4163 VisitFunctionTypeLoc(TL); 4164} 4165void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4166 VisitFunctionTypeLoc(TL); 4167} 4168void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4169 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4170} 4171void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4172 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4173} 4174void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4175 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4176 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4177 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4178} 4179void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4180 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4181 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4182 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4183 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4184} 4185void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4186 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4187} 4188void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4189 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4190 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4191 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4192 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4193} 4194void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4195 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4196} 4197void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4198 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4199} 4200void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4201 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4202} 4203void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4204 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4205 if (TL.hasAttrOperand()) { 4206 SourceRange range; 4207 range.setBegin(ReadSourceLocation(Record, Idx)); 4208 range.setEnd(ReadSourceLocation(Record, Idx)); 4209 TL.setAttrOperandParensRange(range); 4210 } 4211 if (TL.hasAttrExprOperand()) { 4212 if (Record[Idx++]) 4213 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4214 else 4215 TL.setAttrExprOperand(0); 4216 } else if (TL.hasAttrEnumOperand()) 4217 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4218} 4219void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4220 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4221} 4222void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4223 SubstTemplateTypeParmTypeLoc TL) { 4224 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4225} 4226void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4227 SubstTemplateTypeParmPackTypeLoc TL) { 4228 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4229} 4230void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4231 TemplateSpecializationTypeLoc TL) { 4232 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4233 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4234 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4235 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4236 TL.setArgLocInfo(i, 4237 Reader.GetTemplateArgumentLocInfo(F, 4238 TL.getTypePtr()->getArg(i).getKind(), 4239 Record, Idx)); 4240} 4241void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4242 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4243 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4244} 4245void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4246 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4247 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4248} 4249void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4250 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4251} 4252void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4253 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4254 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4255 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4256} 4257void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4258 DependentTemplateSpecializationTypeLoc TL) { 4259 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4260 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4261 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4262 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4263 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4264 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4265 TL.setArgLocInfo(I, 4266 Reader.GetTemplateArgumentLocInfo(F, 4267 TL.getTypePtr()->getArg(I).getKind(), 4268 Record, Idx)); 4269} 4270void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4271 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4272} 4273void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4274 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4275} 4276void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4277 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4278 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4279 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4280 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4281 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4282} 4283void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4284 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4285} 4286void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4287 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4288 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4289 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4290} 4291 4292TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 4293 const RecordData &Record, 4294 unsigned &Idx) { 4295 QualType InfoTy = readType(F, Record, Idx); 4296 if (InfoTy.isNull()) 4297 return 0; 4298 4299 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 4300 TypeLocReader TLR(*this, F, Record, Idx); 4301 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4302 TLR.Visit(TL); 4303 return TInfo; 4304} 4305 4306QualType ASTReader::GetType(TypeID ID) { 4307 unsigned FastQuals = ID & Qualifiers::FastMask; 4308 unsigned Index = ID >> Qualifiers::FastWidth; 4309 4310 if (Index < NUM_PREDEF_TYPE_IDS) { 4311 QualType T; 4312 switch ((PredefinedTypeIDs)Index) { 4313 case PREDEF_TYPE_NULL_ID: return QualType(); 4314 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 4315 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 4316 4317 case PREDEF_TYPE_CHAR_U_ID: 4318 case PREDEF_TYPE_CHAR_S_ID: 4319 // FIXME: Check that the signedness of CharTy is correct! 4320 T = Context.CharTy; 4321 break; 4322 4323 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 4324 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 4325 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 4326 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 4327 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 4328 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 4329 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 4330 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 4331 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 4332 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 4333 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 4334 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 4335 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 4336 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 4337 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 4338 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 4339 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 4340 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 4341 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 4342 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 4343 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 4344 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 4345 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 4346 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 4347 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 4348 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 4349 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 4350 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 4351 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 4352 4353 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 4354 T = Context.getAutoRRefDeductType(); 4355 break; 4356 4357 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 4358 T = Context.ARCUnbridgedCastTy; 4359 break; 4360 4361 } 4362 4363 assert(!T.isNull() && "Unknown predefined type"); 4364 return T.withFastQualifiers(FastQuals); 4365 } 4366 4367 Index -= NUM_PREDEF_TYPE_IDS; 4368 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4369 if (TypesLoaded[Index].isNull()) { 4370 TypesLoaded[Index] = readTypeRecord(Index); 4371 if (TypesLoaded[Index].isNull()) 4372 return QualType(); 4373 4374 TypesLoaded[Index]->setFromAST(); 4375 if (DeserializationListener) 4376 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4377 TypesLoaded[Index]); 4378 } 4379 4380 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4381} 4382 4383QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 4384 return GetType(getGlobalTypeID(F, LocalID)); 4385} 4386 4387serialization::TypeID 4388ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 4389 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4390 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4391 4392 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4393 return LocalID; 4394 4395 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4396 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4397 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4398 4399 unsigned GlobalIndex = LocalIndex + I->second; 4400 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4401} 4402 4403TemplateArgumentLocInfo 4404ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 4405 TemplateArgument::ArgKind Kind, 4406 const RecordData &Record, 4407 unsigned &Index) { 4408 switch (Kind) { 4409 case TemplateArgument::Expression: 4410 return ReadExpr(F); 4411 case TemplateArgument::Type: 4412 return GetTypeSourceInfo(F, Record, Index); 4413 case TemplateArgument::Template: { 4414 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4415 Index); 4416 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4417 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4418 SourceLocation()); 4419 } 4420 case TemplateArgument::TemplateExpansion: { 4421 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4422 Index); 4423 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4424 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4425 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4426 EllipsisLoc); 4427 } 4428 case TemplateArgument::Null: 4429 case TemplateArgument::Integral: 4430 case TemplateArgument::Declaration: 4431 case TemplateArgument::Pack: 4432 return TemplateArgumentLocInfo(); 4433 } 4434 llvm_unreachable("unexpected template argument loc"); 4435 return TemplateArgumentLocInfo(); 4436} 4437 4438TemplateArgumentLoc 4439ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 4440 const RecordData &Record, unsigned &Index) { 4441 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4442 4443 if (Arg.getKind() == TemplateArgument::Expression) { 4444 if (Record[Index++]) // bool InfoHasSameExpr. 4445 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4446 } 4447 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4448 Record, Index)); 4449} 4450 4451Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4452 return GetDecl(ID); 4453} 4454 4455uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 4456 unsigned &Idx){ 4457 if (Idx >= Record.size()) 4458 return 0; 4459 4460 unsigned LocalID = Record[Idx++]; 4461 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4462} 4463 4464CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4465 RecordLocation Loc = getLocalBitOffset(Offset); 4466 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4467 SavedStreamPosition SavedPosition(Cursor); 4468 Cursor.JumpToBit(Loc.Offset); 4469 ReadingKindTracker ReadingKind(Read_Decl, *this); 4470 RecordData Record; 4471 unsigned Code = Cursor.ReadCode(); 4472 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4473 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4474 Error("Malformed AST file: missing C++ base specifiers"); 4475 return 0; 4476 } 4477 4478 unsigned Idx = 0; 4479 unsigned NumBases = Record[Idx++]; 4480 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4481 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4482 for (unsigned I = 0; I != NumBases; ++I) 4483 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4484 return Bases; 4485} 4486 4487serialization::DeclID 4488ASTReader::getGlobalDeclID(ModuleFile &F, unsigned LocalID) const { 4489 if (LocalID < NUM_PREDEF_DECL_IDS) 4490 return LocalID; 4491 4492 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4493 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4494 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4495 4496 return LocalID + I->second; 4497} 4498 4499bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 4500 ModuleFile &M) const { 4501 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 4502 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4503 return &M == I->second; 4504} 4505 4506SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 4507 if (ID < NUM_PREDEF_DECL_IDS) 4508 return SourceLocation(); 4509 4510 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4511 4512 if (Index > DeclsLoaded.size()) { 4513 Error("declaration ID out-of-range for AST file"); 4514 return SourceLocation(); 4515 } 4516 4517 if (Decl *D = DeclsLoaded[Index]) 4518 return D->getLocation(); 4519 4520 unsigned RawLocation = 0; 4521 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 4522 return ReadSourceLocation(*Rec.F, RawLocation); 4523} 4524 4525Decl *ASTReader::GetDecl(DeclID ID) { 4526 if (ID < NUM_PREDEF_DECL_IDS) { 4527 switch ((PredefinedDeclIDs)ID) { 4528 case PREDEF_DECL_NULL_ID: 4529 return 0; 4530 4531 case PREDEF_DECL_TRANSLATION_UNIT_ID: 4532 return Context.getTranslationUnitDecl(); 4533 4534 case PREDEF_DECL_OBJC_ID_ID: 4535 return Context.getObjCIdDecl(); 4536 4537 case PREDEF_DECL_OBJC_SEL_ID: 4538 return Context.getObjCSelDecl(); 4539 4540 case PREDEF_DECL_OBJC_CLASS_ID: 4541 return Context.getObjCClassDecl(); 4542 4543 case PREDEF_DECL_INT_128_ID: 4544 return Context.getInt128Decl(); 4545 4546 case PREDEF_DECL_UNSIGNED_INT_128_ID: 4547 return Context.getUInt128Decl(); 4548 4549 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 4550 return Context.getObjCInstanceTypeDecl(); 4551 } 4552 4553 return 0; 4554 } 4555 4556 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4557 4558 if (Index > DeclsLoaded.size()) { 4559 Error("declaration ID out-of-range for AST file"); 4560 return 0; 4561 } 4562 4563if (!DeclsLoaded[Index]) { 4564 ReadDeclRecord(ID); 4565 if (DeserializationListener) 4566 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4567 } 4568 4569 return DeclsLoaded[Index]; 4570} 4571 4572serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 4573 const RecordData &Record, 4574 unsigned &Idx) { 4575 if (Idx >= Record.size()) { 4576 Error("Corrupted AST file"); 4577 return 0; 4578 } 4579 4580 return getGlobalDeclID(F, Record[Idx++]); 4581} 4582 4583/// \brief Resolve the offset of a statement into a statement. 4584/// 4585/// This operation will read a new statement from the external 4586/// source each time it is called, and is meant to be used via a 4587/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4588Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4589 // Switch case IDs are per Decl. 4590 ClearSwitchCaseIDs(); 4591 4592 // Offset here is a global offset across the entire chain. 4593 RecordLocation Loc = getLocalBitOffset(Offset); 4594 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4595 return ReadStmtFromStream(*Loc.F); 4596} 4597 4598namespace { 4599 class FindExternalLexicalDeclsVisitor { 4600 ASTReader &Reader; 4601 const DeclContext *DC; 4602 bool (*isKindWeWant)(Decl::Kind); 4603 4604 SmallVectorImpl<Decl*> &Decls; 4605 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 4606 4607 public: 4608 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 4609 bool (*isKindWeWant)(Decl::Kind), 4610 SmallVectorImpl<Decl*> &Decls) 4611 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 4612 { 4613 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 4614 PredefsVisited[I] = false; 4615 } 4616 4617 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 4618 if (Preorder) 4619 return false; 4620 4621 FindExternalLexicalDeclsVisitor *This 4622 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 4623 4624 ModuleFile::DeclContextInfosMap::iterator Info 4625 = M.DeclContextInfos.find(This->DC); 4626 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 4627 return false; 4628 4629 // Load all of the declaration IDs 4630 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 4631 *IDE = ID + Info->second.NumLexicalDecls; 4632 ID != IDE; ++ID) { 4633 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 4634 continue; 4635 4636 // Don't add predefined declarations to the lexical context more 4637 // than once. 4638 if (ID->second < NUM_PREDEF_DECL_IDS) { 4639 if (This->PredefsVisited[ID->second]) 4640 continue; 4641 4642 This->PredefsVisited[ID->second] = true; 4643 } 4644 4645 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 4646 if (!This->DC->isDeclInLexicalTraversal(D)) 4647 This->Decls.push_back(D); 4648 } 4649 } 4650 4651 return false; 4652 } 4653 }; 4654} 4655 4656ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4657 bool (*isKindWeWant)(Decl::Kind), 4658 SmallVectorImpl<Decl*> &Decls) { 4659 // There might be lexical decls in multiple modules, for the TU at 4660 // least. Walk all of the modules in the order they were loaded. 4661 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 4662 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 4663 ++NumLexicalDeclContextsRead; 4664 return ELR_Success; 4665} 4666 4667namespace { 4668 4669class DeclIDComp { 4670 ASTReader &Reader; 4671 ModuleFile &Mod; 4672 4673public: 4674 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 4675 4676 bool operator()(LocalDeclID L, LocalDeclID R) const { 4677 SourceLocation LHS = getLocation(L); 4678 SourceLocation RHS = getLocation(R); 4679 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4680 } 4681 4682 bool operator()(SourceLocation LHS, LocalDeclID R) const { 4683 SourceLocation RHS = getLocation(R); 4684 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4685 } 4686 4687 bool operator()(LocalDeclID L, SourceLocation RHS) const { 4688 SourceLocation LHS = getLocation(L); 4689 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4690 } 4691 4692 SourceLocation getLocation(LocalDeclID ID) const { 4693 return Reader.getSourceManager().getFileLoc( 4694 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 4695 } 4696}; 4697 4698} 4699 4700void ASTReader::FindFileRegionDecls(FileID File, 4701 unsigned Offset, unsigned Length, 4702 SmallVectorImpl<Decl *> &Decls) { 4703 SourceManager &SM = getSourceManager(); 4704 4705 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 4706 if (I == FileDeclIDs.end()) 4707 return; 4708 4709 FileDeclsInfo &DInfo = I->second; 4710 if (DInfo.Decls.empty()) 4711 return; 4712 4713 SourceLocation 4714 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 4715 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 4716 4717 DeclIDComp DIDComp(*this, *DInfo.Mod); 4718 ArrayRef<serialization::LocalDeclID>::iterator 4719 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4720 BeginLoc, DIDComp); 4721 if (BeginIt != DInfo.Decls.begin()) 4722 --BeginIt; 4723 4724 // If we are pointing at a top-level decl inside an objc container, we need 4725 // to backtrack until we find it otherwise we will fail to report that the 4726 // region overlaps with an objc container. 4727 while (BeginIt != DInfo.Decls.begin() && 4728 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 4729 ->isTopLevelDeclInObjCContainer()) 4730 --BeginIt; 4731 4732 ArrayRef<serialization::LocalDeclID>::iterator 4733 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4734 EndLoc, DIDComp); 4735 if (EndIt != DInfo.Decls.end()) 4736 ++EndIt; 4737 4738 for (ArrayRef<serialization::LocalDeclID>::iterator 4739 DIt = BeginIt; DIt != EndIt; ++DIt) 4740 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 4741} 4742 4743namespace { 4744 /// \brief ModuleFile visitor used to perform name lookup into a 4745 /// declaration context. 4746 class DeclContextNameLookupVisitor { 4747 ASTReader &Reader; 4748 const DeclContext *DC; 4749 DeclarationName Name; 4750 SmallVectorImpl<NamedDecl *> &Decls; 4751 4752 public: 4753 DeclContextNameLookupVisitor(ASTReader &Reader, 4754 const DeclContext *DC, DeclarationName Name, 4755 SmallVectorImpl<NamedDecl *> &Decls) 4756 : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { } 4757 4758 static bool visit(ModuleFile &M, void *UserData) { 4759 DeclContextNameLookupVisitor *This 4760 = static_cast<DeclContextNameLookupVisitor *>(UserData); 4761 4762 // Check whether we have any visible declaration information for 4763 // this context in this module. 4764 ModuleFile::DeclContextInfosMap::iterator Info 4765 = M.DeclContextInfos.find(This->DC); 4766 if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData) 4767 return false; 4768 4769 // Look for this name within this module. 4770 ASTDeclContextNameLookupTable *LookupTable = 4771 (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData; 4772 ASTDeclContextNameLookupTable::iterator Pos 4773 = LookupTable->find(This->Name); 4774 if (Pos == LookupTable->end()) 4775 return false; 4776 4777 bool FoundAnything = false; 4778 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4779 for (; Data.first != Data.second; ++Data.first) { 4780 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 4781 if (!ND) 4782 continue; 4783 4784 if (ND->getDeclName() != This->Name) { 4785 assert(!This->Name.getCXXNameType().isNull() && 4786 "Name mismatch without a type"); 4787 continue; 4788 } 4789 4790 // Record this declaration. 4791 FoundAnything = true; 4792 This->Decls.push_back(ND); 4793 } 4794 4795 return FoundAnything; 4796 } 4797 }; 4798} 4799 4800DeclContext::lookup_result 4801ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4802 DeclarationName Name) { 4803 assert(DC->hasExternalVisibleStorage() && 4804 "DeclContext has no visible decls in storage"); 4805 if (!Name) 4806 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4807 DeclContext::lookup_iterator(0)); 4808 4809 SmallVector<NamedDecl *, 64> Decls; 4810 DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls); 4811 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 4812 ++NumVisibleDeclContextsRead; 4813 SetExternalVisibleDeclsForName(DC, Name, Decls); 4814 return const_cast<DeclContext*>(DC)->lookup(Name); 4815} 4816 4817/// \brief Under non-PCH compilation the consumer receives the objc methods 4818/// before receiving the implementation, and codegen depends on this. 4819/// We simulate this by deserializing and passing to consumer the methods of the 4820/// implementation before passing the deserialized implementation decl. 4821static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 4822 ASTConsumer *Consumer) { 4823 assert(ImplD && Consumer); 4824 4825 for (ObjCImplDecl::method_iterator 4826 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 4827 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 4828 4829 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 4830} 4831 4832void ASTReader::PassInterestingDeclsToConsumer() { 4833 assert(Consumer); 4834 while (!InterestingDecls.empty()) { 4835 Decl *D = InterestingDecls.front(); 4836 InterestingDecls.pop_front(); 4837 4838 PassInterestingDeclToConsumer(D); 4839 } 4840} 4841 4842void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 4843 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4844 PassObjCImplDeclToConsumer(ImplD, Consumer); 4845 else 4846 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 4847} 4848 4849void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4850 this->Consumer = Consumer; 4851 4852 if (!Consumer) 4853 return; 4854 4855 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4856 // Force deserialization of this decl, which will cause it to be queued for 4857 // passing to the consumer. 4858 GetDecl(ExternalDefinitions[I]); 4859 } 4860 ExternalDefinitions.clear(); 4861 4862 PassInterestingDeclsToConsumer(); 4863} 4864 4865void ASTReader::PrintStats() { 4866 std::fprintf(stderr, "*** AST File Statistics:\n"); 4867 4868 unsigned NumTypesLoaded 4869 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4870 QualType()); 4871 unsigned NumDeclsLoaded 4872 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4873 (Decl *)0); 4874 unsigned NumIdentifiersLoaded 4875 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4876 IdentifiersLoaded.end(), 4877 (IdentifierInfo *)0); 4878 unsigned NumSelectorsLoaded 4879 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4880 SelectorsLoaded.end(), 4881 Selector()); 4882 4883 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4884 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4885 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4886 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4887 NumSLocEntriesRead, TotalNumSLocEntries, 4888 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4889 if (!TypesLoaded.empty()) 4890 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4891 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4892 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4893 if (!DeclsLoaded.empty()) 4894 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4895 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4896 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4897 if (!IdentifiersLoaded.empty()) 4898 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4899 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4900 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4901 if (!SelectorsLoaded.empty()) 4902 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4903 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4904 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4905 if (TotalNumStatements) 4906 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4907 NumStatementsRead, TotalNumStatements, 4908 ((float)NumStatementsRead/TotalNumStatements * 100)); 4909 if (TotalNumMacros) 4910 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4911 NumMacrosRead, TotalNumMacros, 4912 ((float)NumMacrosRead/TotalNumMacros * 100)); 4913 if (TotalLexicalDeclContexts) 4914 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4915 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4916 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4917 * 100)); 4918 if (TotalVisibleDeclContexts) 4919 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4920 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4921 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4922 * 100)); 4923 if (TotalNumMethodPoolEntries) { 4924 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4925 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4926 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4927 * 100)); 4928 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4929 } 4930 std::fprintf(stderr, "\n"); 4931 dump(); 4932 std::fprintf(stderr, "\n"); 4933} 4934 4935template<typename Key, typename ModuleFile, unsigned InitialCapacity> 4936static void 4937dumpModuleIDMap(StringRef Name, 4938 const ContinuousRangeMap<Key, ModuleFile *, 4939 InitialCapacity> &Map) { 4940 if (Map.begin() == Map.end()) 4941 return; 4942 4943 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 4944 llvm::errs() << Name << ":\n"; 4945 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4946 I != IEnd; ++I) { 4947 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4948 << "\n"; 4949 } 4950} 4951 4952void ASTReader::dump() { 4953 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 4954 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4955 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4956 dumpModuleIDMap("Global type map", GlobalTypeMap); 4957 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4958 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4959 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 4960 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4961 dumpModuleIDMap("Global preprocessed entity map", 4962 GlobalPreprocessedEntityMap); 4963 4964 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4965 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4966 MEnd = ModuleMgr.end(); 4967 M != MEnd; ++M) 4968 (*M)->dump(); 4969} 4970 4971/// Return the amount of memory used by memory buffers, breaking down 4972/// by heap-backed versus mmap'ed memory. 4973void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4974 for (ModuleConstIterator I = ModuleMgr.begin(), 4975 E = ModuleMgr.end(); I != E; ++I) { 4976 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4977 size_t bytes = buf->getBufferSize(); 4978 switch (buf->getBufferKind()) { 4979 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4980 sizes.malloc_bytes += bytes; 4981 break; 4982 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4983 sizes.mmap_bytes += bytes; 4984 break; 4985 } 4986 } 4987 } 4988} 4989 4990void ASTReader::InitializeSema(Sema &S) { 4991 SemaObj = &S; 4992 S.ExternalSource = this; 4993 4994 // Makes sure any declarations that were deserialized "too early" 4995 // still get added to the identifier's declaration chains. 4996 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4997 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I], 4998 PreloadedDecls[I]->getDeclName()); 4999 } 5000 PreloadedDecls.clear(); 5001 5002 // Load the offsets of the declarations that Sema references. 5003 // They will be lazily deserialized when needed. 5004 if (!SemaDeclRefs.empty()) { 5005 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 5006 if (!SemaObj->StdNamespace) 5007 SemaObj->StdNamespace = SemaDeclRefs[0]; 5008 if (!SemaObj->StdBadAlloc) 5009 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 5010 } 5011 5012 if (!FPPragmaOptions.empty()) { 5013 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 5014 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 5015 } 5016 5017 if (!OpenCLExtensions.empty()) { 5018 unsigned I = 0; 5019#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 5020#include "clang/Basic/OpenCLExtensions.def" 5021 5022 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 5023 } 5024} 5025 5026IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 5027 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart)); 5028 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 5029 IdentifierInfo *II = Visitor.getIdentifierInfo(); 5030 if (II) 5031 II->setOutOfDate(false); 5032 return II; 5033} 5034 5035namespace clang { 5036 /// \brief An identifier-lookup iterator that enumerates all of the 5037 /// identifiers stored within a set of AST files. 5038 class ASTIdentifierIterator : public IdentifierIterator { 5039 /// \brief The AST reader whose identifiers are being enumerated. 5040 const ASTReader &Reader; 5041 5042 /// \brief The current index into the chain of AST files stored in 5043 /// the AST reader. 5044 unsigned Index; 5045 5046 /// \brief The current position within the identifier lookup table 5047 /// of the current AST file. 5048 ASTIdentifierLookupTable::key_iterator Current; 5049 5050 /// \brief The end position within the identifier lookup table of 5051 /// the current AST file. 5052 ASTIdentifierLookupTable::key_iterator End; 5053 5054 public: 5055 explicit ASTIdentifierIterator(const ASTReader &Reader); 5056 5057 virtual StringRef Next(); 5058 }; 5059} 5060 5061ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 5062 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 5063 ASTIdentifierLookupTable *IdTable 5064 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 5065 Current = IdTable->key_begin(); 5066 End = IdTable->key_end(); 5067} 5068 5069StringRef ASTIdentifierIterator::Next() { 5070 while (Current == End) { 5071 // If we have exhausted all of our AST files, we're done. 5072 if (Index == 0) 5073 return StringRef(); 5074 5075 --Index; 5076 ASTIdentifierLookupTable *IdTable 5077 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 5078 IdentifierLookupTable; 5079 Current = IdTable->key_begin(); 5080 End = IdTable->key_end(); 5081 } 5082 5083 // We have any identifiers remaining in the current AST file; return 5084 // the next one. 5085 std::pair<const char*, unsigned> Key = *Current; 5086 ++Current; 5087 return StringRef(Key.first, Key.second); 5088} 5089 5090IdentifierIterator *ASTReader::getIdentifiers() const { 5091 return new ASTIdentifierIterator(*this); 5092} 5093 5094namespace clang { namespace serialization { 5095 class ReadMethodPoolVisitor { 5096 ASTReader &Reader; 5097 Selector Sel; 5098 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 5099 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 5100 5101 /// \brief Build an ObjCMethodList from a vector of Objective-C method 5102 /// declarations. 5103 ObjCMethodList 5104 buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const 5105 { 5106 ObjCMethodList List; 5107 ObjCMethodList *Prev = 0; 5108 for (unsigned I = 0, N = Vec.size(); I != N; ++I) { 5109 if (!List.Method) { 5110 // This is the first method, which is the easy case. 5111 List.Method = Vec[I]; 5112 Prev = &List; 5113 continue; 5114 } 5115 5116 ObjCMethodList *Mem = 5117 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 5118 Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0); 5119 Prev = Prev->Next; 5120 } 5121 5122 return List; 5123 } 5124 5125 public: 5126 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel) 5127 : Reader(Reader), Sel(Sel) { } 5128 5129 static bool visit(ModuleFile &M, void *UserData) { 5130 ReadMethodPoolVisitor *This 5131 = static_cast<ReadMethodPoolVisitor *>(UserData); 5132 5133 if (!M.SelectorLookupTable) 5134 return false; 5135 5136 ASTSelectorLookupTable *PoolTable 5137 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 5138 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 5139 if (Pos == PoolTable->end()) 5140 return false; 5141 5142 ++This->Reader.NumSelectorsRead; 5143 // FIXME: Not quite happy with the statistics here. We probably should 5144 // disable this tracking when called via LoadSelector. 5145 // Also, should entries without methods count as misses? 5146 ++This->Reader.NumMethodPoolEntriesRead; 5147 ASTSelectorLookupTrait::data_type Data = *Pos; 5148 if (This->Reader.DeserializationListener) 5149 This->Reader.DeserializationListener->SelectorRead(Data.ID, 5150 This->Sel); 5151 5152 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 5153 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 5154 return true; 5155 } 5156 5157 /// \brief Retrieve the instance methods found by this visitor. 5158 ObjCMethodList getInstanceMethods() const { 5159 return buildObjCMethodList(InstanceMethods); 5160 } 5161 5162 /// \brief Retrieve the instance methods found by this visitor. 5163 ObjCMethodList getFactoryMethods() const { 5164 return buildObjCMethodList(FactoryMethods); 5165 } 5166 }; 5167} } // end namespace clang::serialization 5168 5169std::pair<ObjCMethodList, ObjCMethodList> 5170ASTReader::ReadMethodPool(Selector Sel) { 5171 ReadMethodPoolVisitor Visitor(*this, Sel); 5172 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 5173 std::pair<ObjCMethodList, ObjCMethodList> Result; 5174 Result.first = Visitor.getInstanceMethods(); 5175 Result.second = Visitor.getFactoryMethods(); 5176 5177 if (!Result.first.Method && !Result.second.Method) 5178 ++NumMethodPoolMisses; 5179 return Result; 5180} 5181 5182void ASTReader::ReadKnownNamespaces( 5183 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 5184 Namespaces.clear(); 5185 5186 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 5187 if (NamespaceDecl *Namespace 5188 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 5189 Namespaces.push_back(Namespace); 5190 } 5191} 5192 5193void ASTReader::ReadTentativeDefinitions( 5194 SmallVectorImpl<VarDecl *> &TentativeDefs) { 5195 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 5196 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 5197 if (Var) 5198 TentativeDefs.push_back(Var); 5199 } 5200 TentativeDefinitions.clear(); 5201} 5202 5203void ASTReader::ReadUnusedFileScopedDecls( 5204 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 5205 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 5206 DeclaratorDecl *D 5207 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 5208 if (D) 5209 Decls.push_back(D); 5210 } 5211 UnusedFileScopedDecls.clear(); 5212} 5213 5214void ASTReader::ReadDelegatingConstructors( 5215 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 5216 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 5217 CXXConstructorDecl *D 5218 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 5219 if (D) 5220 Decls.push_back(D); 5221 } 5222 DelegatingCtorDecls.clear(); 5223} 5224 5225void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 5226 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 5227 TypedefNameDecl *D 5228 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 5229 if (D) 5230 Decls.push_back(D); 5231 } 5232 ExtVectorDecls.clear(); 5233} 5234 5235void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 5236 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 5237 CXXRecordDecl *D 5238 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 5239 if (D) 5240 Decls.push_back(D); 5241 } 5242 DynamicClasses.clear(); 5243} 5244 5245void 5246ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 5247 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 5248 NamedDecl *D 5249 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 5250 if (D) 5251 Decls.push_back(D); 5252 } 5253 LocallyScopedExternalDecls.clear(); 5254} 5255 5256void ASTReader::ReadReferencedSelectors( 5257 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 5258 if (ReferencedSelectorsData.empty()) 5259 return; 5260 5261 // If there are @selector references added them to its pool. This is for 5262 // implementation of -Wselector. 5263 unsigned int DataSize = ReferencedSelectorsData.size()-1; 5264 unsigned I = 0; 5265 while (I < DataSize) { 5266 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 5267 SourceLocation SelLoc 5268 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 5269 Sels.push_back(std::make_pair(Sel, SelLoc)); 5270 } 5271 ReferencedSelectorsData.clear(); 5272} 5273 5274void ASTReader::ReadWeakUndeclaredIdentifiers( 5275 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 5276 if (WeakUndeclaredIdentifiers.empty()) 5277 return; 5278 5279 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 5280 IdentifierInfo *WeakId 5281 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5282 IdentifierInfo *AliasId 5283 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5284 SourceLocation Loc 5285 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 5286 bool Used = WeakUndeclaredIdentifiers[I++]; 5287 WeakInfo WI(AliasId, Loc); 5288 WI.setUsed(Used); 5289 WeakIDs.push_back(std::make_pair(WeakId, WI)); 5290 } 5291 WeakUndeclaredIdentifiers.clear(); 5292} 5293 5294void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 5295 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 5296 ExternalVTableUse VT; 5297 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 5298 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 5299 VT.DefinitionRequired = VTableUses[Idx++]; 5300 VTables.push_back(VT); 5301 } 5302 5303 VTableUses.clear(); 5304} 5305 5306void ASTReader::ReadPendingInstantiations( 5307 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 5308 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 5309 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 5310 SourceLocation Loc 5311 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 5312 Pending.push_back(std::make_pair(D, Loc)); 5313 } 5314 PendingInstantiations.clear(); 5315} 5316 5317void ASTReader::LoadSelector(Selector Sel) { 5318 // It would be complicated to avoid reading the methods anyway. So don't. 5319 ReadMethodPool(Sel); 5320} 5321 5322void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 5323 assert(ID && "Non-zero identifier ID required"); 5324 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 5325 IdentifiersLoaded[ID - 1] = II; 5326 if (DeserializationListener) 5327 DeserializationListener->IdentifierRead(ID, II); 5328} 5329 5330/// \brief Set the globally-visible declarations associated with the given 5331/// identifier. 5332/// 5333/// If the AST reader is currently in a state where the given declaration IDs 5334/// cannot safely be resolved, they are queued until it is safe to resolve 5335/// them. 5336/// 5337/// \param II an IdentifierInfo that refers to one or more globally-visible 5338/// declarations. 5339/// 5340/// \param DeclIDs the set of declaration IDs with the name @p II that are 5341/// visible at global scope. 5342/// 5343/// \param Nonrecursive should be true to indicate that the caller knows that 5344/// this call is non-recursive, and therefore the globally-visible declarations 5345/// will not be placed onto the pending queue. 5346void 5347ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 5348 const SmallVectorImpl<uint32_t> &DeclIDs, 5349 bool Nonrecursive) { 5350 if (NumCurrentElementsDeserializing && !Nonrecursive) { 5351 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 5352 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 5353 PII.II = II; 5354 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 5355 return; 5356 } 5357 5358 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 5359 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 5360 if (SemaObj) { 5361 // Introduce this declaration into the translation-unit scope 5362 // and add it to the declaration chain for this identifier, so 5363 // that (unqualified) name lookup will find it. 5364 SemaObj->pushExternalDeclIntoScope(D, II); 5365 } else { 5366 // Queue this declaration so that it will be added to the 5367 // translation unit scope and identifier's declaration chain 5368 // once a Sema object is known. 5369 PreloadedDecls.push_back(D); 5370 } 5371 } 5372} 5373 5374IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 5375 if (ID == 0) 5376 return 0; 5377 5378 if (IdentifiersLoaded.empty()) { 5379 Error("no identifier table in AST file"); 5380 return 0; 5381 } 5382 5383 ID -= 1; 5384 if (!IdentifiersLoaded[ID]) { 5385 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 5386 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 5387 ModuleFile *M = I->second; 5388 unsigned Index = ID - M->BaseIdentifierID; 5389 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 5390 5391 // All of the strings in the AST file are preceded by a 16-bit length. 5392 // Extract that 16-bit length to avoid having to execute strlen(). 5393 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 5394 // unsigned integers. This is important to avoid integer overflow when 5395 // we cast them to 'unsigned'. 5396 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 5397 unsigned StrLen = (((unsigned) StrLenPtr[0]) 5398 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 5399 IdentifiersLoaded[ID] 5400 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 5401 if (DeserializationListener) 5402 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 5403 } 5404 5405 return IdentifiersLoaded[ID]; 5406} 5407 5408IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 5409 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 5410} 5411 5412IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 5413 if (LocalID < NUM_PREDEF_IDENT_IDS) 5414 return LocalID; 5415 5416 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5417 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 5418 assert(I != M.IdentifierRemap.end() 5419 && "Invalid index into identifier index remap"); 5420 5421 return LocalID + I->second; 5422} 5423 5424bool ASTReader::ReadSLocEntry(int ID) { 5425 return ReadSLocEntryRecord(ID) != Success; 5426} 5427 5428serialization::SubmoduleID 5429ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 5430 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 5431 return LocalID; 5432 5433 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5434 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 5435 assert(I != M.SubmoduleRemap.end() 5436 && "Invalid index into identifier index remap"); 5437 5438 return LocalID + I->second; 5439} 5440 5441Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 5442 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 5443 assert(GlobalID == 0 && "Unhandled global submodule ID"); 5444 return 0; 5445 } 5446 5447 if (GlobalID > SubmodulesLoaded.size()) { 5448 Error("submodule ID out of range in AST file"); 5449 return 0; 5450 } 5451 5452 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 5453} 5454 5455Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 5456 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 5457} 5458 5459Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 5460 if (ID == 0) 5461 return Selector(); 5462 5463 if (ID > SelectorsLoaded.size()) { 5464 Error("selector ID out of range in AST file"); 5465 return Selector(); 5466 } 5467 5468 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 5469 // Load this selector from the selector table. 5470 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 5471 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 5472 ModuleFile &M = *I->second; 5473 ASTSelectorLookupTrait Trait(*this, M); 5474 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 5475 SelectorsLoaded[ID - 1] = 5476 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 5477 if (DeserializationListener) 5478 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 5479 } 5480 5481 return SelectorsLoaded[ID - 1]; 5482} 5483 5484Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 5485 return DecodeSelector(ID); 5486} 5487 5488uint32_t ASTReader::GetNumExternalSelectors() { 5489 // ID 0 (the null selector) is considered an external selector. 5490 return getTotalNumSelectors() + 1; 5491} 5492 5493serialization::SelectorID 5494ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 5495 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 5496 return LocalID; 5497 5498 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5499 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 5500 assert(I != M.SelectorRemap.end() 5501 && "Invalid index into identifier index remap"); 5502 5503 return LocalID + I->second; 5504} 5505 5506DeclarationName 5507ASTReader::ReadDeclarationName(ModuleFile &F, 5508 const RecordData &Record, unsigned &Idx) { 5509 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 5510 switch (Kind) { 5511 case DeclarationName::Identifier: 5512 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 5513 5514 case DeclarationName::ObjCZeroArgSelector: 5515 case DeclarationName::ObjCOneArgSelector: 5516 case DeclarationName::ObjCMultiArgSelector: 5517 return DeclarationName(ReadSelector(F, Record, Idx)); 5518 5519 case DeclarationName::CXXConstructorName: 5520 return Context.DeclarationNames.getCXXConstructorName( 5521 Context.getCanonicalType(readType(F, Record, Idx))); 5522 5523 case DeclarationName::CXXDestructorName: 5524 return Context.DeclarationNames.getCXXDestructorName( 5525 Context.getCanonicalType(readType(F, Record, Idx))); 5526 5527 case DeclarationName::CXXConversionFunctionName: 5528 return Context.DeclarationNames.getCXXConversionFunctionName( 5529 Context.getCanonicalType(readType(F, Record, Idx))); 5530 5531 case DeclarationName::CXXOperatorName: 5532 return Context.DeclarationNames.getCXXOperatorName( 5533 (OverloadedOperatorKind)Record[Idx++]); 5534 5535 case DeclarationName::CXXLiteralOperatorName: 5536 return Context.DeclarationNames.getCXXLiteralOperatorName( 5537 GetIdentifierInfo(F, Record, Idx)); 5538 5539 case DeclarationName::CXXUsingDirective: 5540 return DeclarationName::getUsingDirectiveName(); 5541 } 5542 5543 // Required to silence GCC warning 5544 return DeclarationName(); 5545} 5546 5547void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 5548 DeclarationNameLoc &DNLoc, 5549 DeclarationName Name, 5550 const RecordData &Record, unsigned &Idx) { 5551 switch (Name.getNameKind()) { 5552 case DeclarationName::CXXConstructorName: 5553 case DeclarationName::CXXDestructorName: 5554 case DeclarationName::CXXConversionFunctionName: 5555 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 5556 break; 5557 5558 case DeclarationName::CXXOperatorName: 5559 DNLoc.CXXOperatorName.BeginOpNameLoc 5560 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5561 DNLoc.CXXOperatorName.EndOpNameLoc 5562 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5563 break; 5564 5565 case DeclarationName::CXXLiteralOperatorName: 5566 DNLoc.CXXLiteralOperatorName.OpNameLoc 5567 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5568 break; 5569 5570 case DeclarationName::Identifier: 5571 case DeclarationName::ObjCZeroArgSelector: 5572 case DeclarationName::ObjCOneArgSelector: 5573 case DeclarationName::ObjCMultiArgSelector: 5574 case DeclarationName::CXXUsingDirective: 5575 break; 5576 } 5577} 5578 5579void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 5580 DeclarationNameInfo &NameInfo, 5581 const RecordData &Record, unsigned &Idx) { 5582 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 5583 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 5584 DeclarationNameLoc DNLoc; 5585 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5586 NameInfo.setInfo(DNLoc); 5587} 5588 5589void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 5590 const RecordData &Record, unsigned &Idx) { 5591 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5592 unsigned NumTPLists = Record[Idx++]; 5593 Info.NumTemplParamLists = NumTPLists; 5594 if (NumTPLists) { 5595 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 5596 for (unsigned i=0; i != NumTPLists; ++i) 5597 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5598 } 5599} 5600 5601TemplateName 5602ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 5603 unsigned &Idx) { 5604 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5605 switch (Kind) { 5606 case TemplateName::Template: 5607 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5608 5609 case TemplateName::OverloadedTemplate: { 5610 unsigned size = Record[Idx++]; 5611 UnresolvedSet<8> Decls; 5612 while (size--) 5613 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5614 5615 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 5616 } 5617 5618 case TemplateName::QualifiedTemplate: { 5619 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5620 bool hasTemplKeyword = Record[Idx++]; 5621 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5622 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5623 } 5624 5625 case TemplateName::DependentTemplate: { 5626 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5627 if (Record[Idx++]) // isIdentifier 5628 return Context.getDependentTemplateName(NNS, 5629 GetIdentifierInfo(F, Record, 5630 Idx)); 5631 return Context.getDependentTemplateName(NNS, 5632 (OverloadedOperatorKind)Record[Idx++]); 5633 } 5634 5635 case TemplateName::SubstTemplateTemplateParm: { 5636 TemplateTemplateParmDecl *param 5637 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5638 if (!param) return TemplateName(); 5639 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5640 return Context.getSubstTemplateTemplateParm(param, replacement); 5641 } 5642 5643 case TemplateName::SubstTemplateTemplateParmPack: { 5644 TemplateTemplateParmDecl *Param 5645 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5646 if (!Param) 5647 return TemplateName(); 5648 5649 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5650 if (ArgPack.getKind() != TemplateArgument::Pack) 5651 return TemplateName(); 5652 5653 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 5654 } 5655 } 5656 5657 llvm_unreachable("Unhandled template name kind!"); 5658} 5659 5660TemplateArgument 5661ASTReader::ReadTemplateArgument(ModuleFile &F, 5662 const RecordData &Record, unsigned &Idx) { 5663 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5664 switch (Kind) { 5665 case TemplateArgument::Null: 5666 return TemplateArgument(); 5667 case TemplateArgument::Type: 5668 return TemplateArgument(readType(F, Record, Idx)); 5669 case TemplateArgument::Declaration: 5670 return TemplateArgument(ReadDecl(F, Record, Idx)); 5671 case TemplateArgument::Integral: { 5672 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5673 QualType T = readType(F, Record, Idx); 5674 return TemplateArgument(Value, T); 5675 } 5676 case TemplateArgument::Template: 5677 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5678 case TemplateArgument::TemplateExpansion: { 5679 TemplateName Name = ReadTemplateName(F, Record, Idx); 5680 llvm::Optional<unsigned> NumTemplateExpansions; 5681 if (unsigned NumExpansions = Record[Idx++]) 5682 NumTemplateExpansions = NumExpansions - 1; 5683 return TemplateArgument(Name, NumTemplateExpansions); 5684 } 5685 case TemplateArgument::Expression: 5686 return TemplateArgument(ReadExpr(F)); 5687 case TemplateArgument::Pack: { 5688 unsigned NumArgs = Record[Idx++]; 5689 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 5690 for (unsigned I = 0; I != NumArgs; ++I) 5691 Args[I] = ReadTemplateArgument(F, Record, Idx); 5692 return TemplateArgument(Args, NumArgs); 5693 } 5694 } 5695 5696 llvm_unreachable("Unhandled template argument kind!"); 5697} 5698 5699TemplateParameterList * 5700ASTReader::ReadTemplateParameterList(ModuleFile &F, 5701 const RecordData &Record, unsigned &Idx) { 5702 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5703 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5704 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5705 5706 unsigned NumParams = Record[Idx++]; 5707 SmallVector<NamedDecl *, 16> Params; 5708 Params.reserve(NumParams); 5709 while (NumParams--) 5710 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5711 5712 TemplateParameterList* TemplateParams = 5713 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 5714 Params.data(), Params.size(), RAngleLoc); 5715 return TemplateParams; 5716} 5717 5718void 5719ASTReader:: 5720ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5721 ModuleFile &F, const RecordData &Record, 5722 unsigned &Idx) { 5723 unsigned NumTemplateArgs = Record[Idx++]; 5724 TemplArgs.reserve(NumTemplateArgs); 5725 while (NumTemplateArgs--) 5726 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5727} 5728 5729/// \brief Read a UnresolvedSet structure. 5730void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set, 5731 const RecordData &Record, unsigned &Idx) { 5732 unsigned NumDecls = Record[Idx++]; 5733 while (NumDecls--) { 5734 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5735 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5736 Set.addDecl(D, AS); 5737 } 5738} 5739 5740CXXBaseSpecifier 5741ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 5742 const RecordData &Record, unsigned &Idx) { 5743 bool isVirtual = static_cast<bool>(Record[Idx++]); 5744 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5745 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5746 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5747 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5748 SourceRange Range = ReadSourceRange(F, Record, Idx); 5749 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5750 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5751 EllipsisLoc); 5752 Result.setInheritConstructors(inheritConstructors); 5753 return Result; 5754} 5755 5756std::pair<CXXCtorInitializer **, unsigned> 5757ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 5758 unsigned &Idx) { 5759 CXXCtorInitializer **CtorInitializers = 0; 5760 unsigned NumInitializers = Record[Idx++]; 5761 if (NumInitializers) { 5762 CtorInitializers 5763 = new (Context) CXXCtorInitializer*[NumInitializers]; 5764 for (unsigned i=0; i != NumInitializers; ++i) { 5765 TypeSourceInfo *TInfo = 0; 5766 bool IsBaseVirtual = false; 5767 FieldDecl *Member = 0; 5768 IndirectFieldDecl *IndirectMember = 0; 5769 5770 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5771 switch (Type) { 5772 case CTOR_INITIALIZER_BASE: 5773 TInfo = GetTypeSourceInfo(F, Record, Idx); 5774 IsBaseVirtual = Record[Idx++]; 5775 break; 5776 5777 case CTOR_INITIALIZER_DELEGATING: 5778 TInfo = GetTypeSourceInfo(F, Record, Idx); 5779 break; 5780 5781 case CTOR_INITIALIZER_MEMBER: 5782 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5783 break; 5784 5785 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5786 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5787 break; 5788 } 5789 5790 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5791 Expr *Init = ReadExpr(F); 5792 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5793 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5794 bool IsWritten = Record[Idx++]; 5795 unsigned SourceOrderOrNumArrayIndices; 5796 SmallVector<VarDecl *, 8> Indices; 5797 if (IsWritten) { 5798 SourceOrderOrNumArrayIndices = Record[Idx++]; 5799 } else { 5800 SourceOrderOrNumArrayIndices = Record[Idx++]; 5801 Indices.reserve(SourceOrderOrNumArrayIndices); 5802 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5803 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5804 } 5805 5806 CXXCtorInitializer *BOMInit; 5807 if (Type == CTOR_INITIALIZER_BASE) { 5808 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 5809 LParenLoc, Init, RParenLoc, 5810 MemberOrEllipsisLoc); 5811 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5812 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 5813 Init, RParenLoc); 5814 } else if (IsWritten) { 5815 if (Member) 5816 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 5817 LParenLoc, Init, RParenLoc); 5818 else 5819 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 5820 MemberOrEllipsisLoc, LParenLoc, 5821 Init, RParenLoc); 5822 } else { 5823 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 5824 LParenLoc, Init, RParenLoc, 5825 Indices.data(), Indices.size()); 5826 } 5827 5828 if (IsWritten) 5829 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5830 CtorInitializers[i] = BOMInit; 5831 } 5832 } 5833 5834 return std::make_pair(CtorInitializers, NumInitializers); 5835} 5836 5837NestedNameSpecifier * 5838ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 5839 const RecordData &Record, unsigned &Idx) { 5840 unsigned N = Record[Idx++]; 5841 NestedNameSpecifier *NNS = 0, *Prev = 0; 5842 for (unsigned I = 0; I != N; ++I) { 5843 NestedNameSpecifier::SpecifierKind Kind 5844 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5845 switch (Kind) { 5846 case NestedNameSpecifier::Identifier: { 5847 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5848 NNS = NestedNameSpecifier::Create(Context, Prev, II); 5849 break; 5850 } 5851 5852 case NestedNameSpecifier::Namespace: { 5853 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5854 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 5855 break; 5856 } 5857 5858 case NestedNameSpecifier::NamespaceAlias: { 5859 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5860 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 5861 break; 5862 } 5863 5864 case NestedNameSpecifier::TypeSpec: 5865 case NestedNameSpecifier::TypeSpecWithTemplate: { 5866 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5867 if (!T) 5868 return 0; 5869 5870 bool Template = Record[Idx++]; 5871 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 5872 break; 5873 } 5874 5875 case NestedNameSpecifier::Global: { 5876 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 5877 // No associated value, and there can't be a prefix. 5878 break; 5879 } 5880 } 5881 Prev = NNS; 5882 } 5883 return NNS; 5884} 5885 5886NestedNameSpecifierLoc 5887ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 5888 unsigned &Idx) { 5889 unsigned N = Record[Idx++]; 5890 NestedNameSpecifierLocBuilder Builder; 5891 for (unsigned I = 0; I != N; ++I) { 5892 NestedNameSpecifier::SpecifierKind Kind 5893 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5894 switch (Kind) { 5895 case NestedNameSpecifier::Identifier: { 5896 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5897 SourceRange Range = ReadSourceRange(F, Record, Idx); 5898 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 5899 break; 5900 } 5901 5902 case NestedNameSpecifier::Namespace: { 5903 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5904 SourceRange Range = ReadSourceRange(F, Record, Idx); 5905 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 5906 break; 5907 } 5908 5909 case NestedNameSpecifier::NamespaceAlias: { 5910 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5911 SourceRange Range = ReadSourceRange(F, Record, Idx); 5912 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 5913 break; 5914 } 5915 5916 case NestedNameSpecifier::TypeSpec: 5917 case NestedNameSpecifier::TypeSpecWithTemplate: { 5918 bool Template = Record[Idx++]; 5919 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5920 if (!T) 5921 return NestedNameSpecifierLoc(); 5922 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5923 5924 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5925 Builder.Extend(Context, 5926 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5927 T->getTypeLoc(), ColonColonLoc); 5928 break; 5929 } 5930 5931 case NestedNameSpecifier::Global: { 5932 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5933 Builder.MakeGlobal(Context, ColonColonLoc); 5934 break; 5935 } 5936 } 5937 } 5938 5939 return Builder.getWithLocInContext(Context); 5940} 5941 5942SourceRange 5943ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 5944 unsigned &Idx) { 5945 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5946 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5947 return SourceRange(beg, end); 5948} 5949 5950/// \brief Read an integral value 5951llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5952 unsigned BitWidth = Record[Idx++]; 5953 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5954 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5955 Idx += NumWords; 5956 return Result; 5957} 5958 5959/// \brief Read a signed integral value 5960llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5961 bool isUnsigned = Record[Idx++]; 5962 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5963} 5964 5965/// \brief Read a floating-point value 5966llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5967 return llvm::APFloat(ReadAPInt(Record, Idx)); 5968} 5969 5970// \brief Read a string 5971std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5972 unsigned Len = Record[Idx++]; 5973 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5974 Idx += Len; 5975 return Result; 5976} 5977 5978VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5979 unsigned &Idx) { 5980 unsigned Major = Record[Idx++]; 5981 unsigned Minor = Record[Idx++]; 5982 unsigned Subminor = Record[Idx++]; 5983 if (Minor == 0) 5984 return VersionTuple(Major); 5985 if (Subminor == 0) 5986 return VersionTuple(Major, Minor - 1); 5987 return VersionTuple(Major, Minor - 1, Subminor - 1); 5988} 5989 5990CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 5991 const RecordData &Record, 5992 unsigned &Idx) { 5993 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5994 return CXXTemporary::Create(Context, Decl); 5995} 5996 5997DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5998 return Diag(SourceLocation(), DiagID); 5999} 6000 6001DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 6002 return Diags.Report(Loc, DiagID); 6003} 6004 6005/// \brief Retrieve the identifier table associated with the 6006/// preprocessor. 6007IdentifierTable &ASTReader::getIdentifierTable() { 6008 return PP.getIdentifierTable(); 6009} 6010 6011/// \brief Record that the given ID maps to the given switch-case 6012/// statement. 6013void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 6014 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 6015 SwitchCaseStmts[ID] = SC; 6016} 6017 6018/// \brief Retrieve the switch-case statement with the given ID. 6019SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 6020 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 6021 return SwitchCaseStmts[ID]; 6022} 6023 6024void ASTReader::ClearSwitchCaseIDs() { 6025 SwitchCaseStmts.clear(); 6026} 6027 6028void ASTReader::FinishedDeserializing() { 6029 assert(NumCurrentElementsDeserializing && 6030 "FinishedDeserializing not paired with StartedDeserializing"); 6031 if (NumCurrentElementsDeserializing == 1) { 6032 do { 6033 // If any identifiers with corresponding top-level declarations have 6034 // been loaded, load those declarations now. 6035 while (!PendingIdentifierInfos.empty()) { 6036 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 6037 PendingIdentifierInfos.front().DeclIDs, true); 6038 PendingIdentifierInfos.pop_front(); 6039 } 6040 6041 // Ready to load previous declarations of Decls that were delayed. 6042 while (!PendingPreviousDecls.empty()) { 6043 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 6044 PendingPreviousDecls.front().second); 6045 PendingPreviousDecls.pop_front(); 6046 } 6047 6048 for (std::vector<std::pair<ObjCInterfaceDecl *, 6049 serialization::DeclID> >::iterator 6050 I = PendingChainedObjCCategories.begin(), 6051 E = PendingChainedObjCCategories.end(); I != E; ++I) { 6052 loadObjCChainedCategories(I->second, I->first); 6053 } 6054 PendingChainedObjCCategories.clear(); 6055 6056 // We are not in recursive loading, so it's safe to pass the "interesting" 6057 // decls to the consumer. 6058 if (Consumer && !InterestingDecls.empty()) { 6059 Decl *D = InterestingDecls.front(); 6060 InterestingDecls.pop_front(); 6061 6062 PassInterestingDeclToConsumer(D); 6063 } 6064 6065 } while ((Consumer && !InterestingDecls.empty()) || 6066 !PendingIdentifierInfos.empty() || 6067 !PendingPreviousDecls.empty() || 6068 !PendingChainedObjCCategories.empty()); 6069 6070 assert(PendingForwardRefs.size() == 0 && 6071 "Some forward refs did not get linked to the definition!"); 6072 } 6073 --NumCurrentElementsDeserializing; 6074} 6075 6076ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 6077 StringRef isysroot, bool DisableValidation, 6078 bool DisableStatCache) 6079 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 6080 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 6081 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 6082 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 6083 RelocatablePCH(false), isysroot(isysroot), 6084 DisableValidation(DisableValidation), 6085 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 6086 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 6087 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 6088 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 6089 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 6090 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 6091 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 6092 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 6093 NumCXXBaseSpecifiersLoaded(0) 6094{ 6095 SourceMgr.setExternalSLocEntrySource(this); 6096} 6097 6098ASTReader::~ASTReader() { 6099 for (DeclContextVisibleUpdatesPending::iterator 6100 I = PendingVisibleUpdates.begin(), 6101 E = PendingVisibleUpdates.end(); 6102 I != E; ++I) { 6103 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 6104 F = I->second.end(); 6105 J != F; ++J) 6106 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 6107 } 6108} 6109