ASTReader.cpp revision 55988680ece66b8e505ee136b35e74fcb1173aee
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 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { 2524 Module *Exported = Mod->Exports[I].getPointer(); 2525 if (Visited.insert(Exported)) { 2526 // FIXME: The intent of wildcards is to re-export any imported modules. 2527 // However, we don't yet have the module-dependency information to do 2528 // this, so we ignore wildcards for now. 2529 if (!Mod->Exports[I].getInt()) 2530 Stack.push_back(Exported); 2531 } 2532 } 2533 } 2534} 2535 2536ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2537 ModuleKind Type) { 2538 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) { 2539 case Failure: return Failure; 2540 case IgnorePCH: return IgnorePCH; 2541 case Success: break; 2542 } 2543 2544 // Here comes stuff that we only do once the entire chain is loaded. 2545 2546 // Check the predefines buffers. 2547 if (!DisableValidation && Type == MK_PCH && 2548 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines; 2549 // if DisableValidation is true, defines that were set on command-line 2550 // but not in the PCH file will not be added to SuggestedPredefines. 2551 CheckPredefinesBuffers()) 2552 return IgnorePCH; 2553 2554 // Mark all of the identifiers in the identifier table as being out of date, 2555 // so that various accessors know to check the loaded modules when the 2556 // identifier is used. 2557 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2558 IdEnd = PP.getIdentifierTable().end(); 2559 Id != IdEnd; ++Id) 2560 Id->second->setOutOfDate(true); 2561 2562 // Resolve any unresolved module exports. 2563 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) { 2564 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I]; 2565 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 2566 if (Module *ResolvedMod = getSubmodule(GlobalID)) { 2567 if (Unresolved.IsImport) 2568 Unresolved.Mod->Imports.push_back(ResolvedMod); 2569 else 2570 Unresolved.Mod->Exports.push_back( 2571 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 2572 } 2573 } 2574 UnresolvedModuleImportExports.clear(); 2575 2576 InitializeContext(); 2577 2578 if (DeserializationListener) 2579 DeserializationListener->ReaderInitialized(this); 2580 2581 // If this AST file is a precompiled preamble, then set the preamble file ID 2582 // of the source manager to the file source file from which the preamble was 2583 // built. 2584 if (Type == MK_Preamble) { 2585 if (!OriginalFileID.isInvalid()) { 2586 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2587 + OriginalFileID.getOpaqueValue() - 1); 2588 SourceMgr.setPreambleFileID(OriginalFileID); 2589 } 2590 } 2591 2592 return Success; 2593} 2594 2595ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2596 ModuleKind Type, 2597 ModuleFile *ImportedBy) { 2598 ModuleFile *M; 2599 bool NewModule; 2600 std::string ErrorStr; 2601 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy, 2602 ErrorStr); 2603 2604 if (!M) { 2605 // We couldn't load the module. 2606 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2607 + ErrorStr; 2608 Error(Msg); 2609 return Failure; 2610 } 2611 2612 if (!NewModule) { 2613 // We've already loaded this module. 2614 return Success; 2615 } 2616 2617 // FIXME: This seems rather a hack. Should CurrentDir be part of the 2618 // module? 2619 if (FileName != "-") { 2620 CurrentDir = llvm::sys::path::parent_path(FileName); 2621 if (CurrentDir.empty()) CurrentDir = "."; 2622 } 2623 2624 ModuleFile &F = *M; 2625 llvm::BitstreamCursor &Stream = F.Stream; 2626 Stream.init(F.StreamFile); 2627 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2628 2629 // Sniff for the signature. 2630 if (Stream.Read(8) != 'C' || 2631 Stream.Read(8) != 'P' || 2632 Stream.Read(8) != 'C' || 2633 Stream.Read(8) != 'H') { 2634 Diag(diag::err_not_a_pch_file) << FileName; 2635 return Failure; 2636 } 2637 2638 while (!Stream.AtEndOfStream()) { 2639 unsigned Code = Stream.ReadCode(); 2640 2641 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2642 Error("invalid record at top-level of AST file"); 2643 return Failure; 2644 } 2645 2646 unsigned BlockID = Stream.ReadSubBlockID(); 2647 2648 // We only know the AST subblock ID. 2649 switch (BlockID) { 2650 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2651 if (Stream.ReadBlockInfoBlock()) { 2652 Error("malformed BlockInfoBlock in AST file"); 2653 return Failure; 2654 } 2655 break; 2656 case AST_BLOCK_ID: 2657 switch (ReadASTBlock(F)) { 2658 case Success: 2659 break; 2660 2661 case Failure: 2662 return Failure; 2663 2664 case IgnorePCH: 2665 // FIXME: We could consider reading through to the end of this 2666 // AST block, skipping subblocks, to see if there are other 2667 // AST blocks elsewhere. 2668 2669 // FIXME: We can't clear loaded slocentries anymore. 2670 //SourceMgr.ClearPreallocatedSLocEntries(); 2671 2672 // Remove the stat cache. 2673 if (F.StatCache) 2674 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2675 2676 return IgnorePCH; 2677 } 2678 break; 2679 default: 2680 if (Stream.SkipBlock()) { 2681 Error("malformed block record in AST file"); 2682 return Failure; 2683 } 2684 break; 2685 } 2686 } 2687 2688 // Once read, set the ModuleFile bit base offset and update the size in 2689 // bits of all files we've seen. 2690 F.GlobalBitOffset = TotalModulesSizeInBits; 2691 TotalModulesSizeInBits += F.SizeInBits; 2692 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2693 2694 // Make sure that the files this module was built against are still available. 2695 if (!DisableValidation) { 2696 switch(validateFileEntries(*M)) { 2697 case Failure: return Failure; 2698 case IgnorePCH: return IgnorePCH; 2699 case Success: break; 2700 } 2701 } 2702 2703 // Preload SLocEntries. 2704 for (unsigned I = 0, N = M->PreloadSLocEntries.size(); I != N; ++I) { 2705 int Index = int(M->PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2706 // Load it through the SourceManager and don't call ReadSLocEntryRecord() 2707 // directly because the entry may have already been loaded in which case 2708 // calling ReadSLocEntryRecord() directly would trigger an assertion in 2709 // SourceManager. 2710 SourceMgr.getLoadedSLocEntryByID(Index); 2711 } 2712 2713 2714 return Success; 2715} 2716 2717void ASTReader::InitializeContext() { 2718 // If there's a listener, notify them that we "read" the translation unit. 2719 if (DeserializationListener) 2720 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 2721 Context.getTranslationUnitDecl()); 2722 2723 // Make sure we load the declaration update records for the translation unit, 2724 // if there are any. 2725 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 2726 Context.getTranslationUnitDecl()); 2727 2728 // FIXME: Find a better way to deal with collisions between these 2729 // built-in types. Right now, we just ignore the problem. 2730 2731 // Load the special types. 2732 if (SpecialTypes.size() > NumSpecialTypeIDs) { 2733 if (Context.getBuiltinVaListType().isNull()) { 2734 Context.setBuiltinVaListType( 2735 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2736 } 2737 2738 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) { 2739 if (Context.ObjCProtoType.isNull()) 2740 Context.ObjCProtoType = GetType(Proto); 2741 } 2742 2743 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 2744 if (!Context.CFConstantStringTypeDecl) 2745 Context.setCFConstantStringType(GetType(String)); 2746 } 2747 2748 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2749 QualType FileType = GetType(File); 2750 if (FileType.isNull()) { 2751 Error("FILE type is NULL"); 2752 return; 2753 } 2754 2755 if (!Context.FILEDecl) { 2756 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2757 Context.setFILEDecl(Typedef->getDecl()); 2758 else { 2759 const TagType *Tag = FileType->getAs<TagType>(); 2760 if (!Tag) { 2761 Error("Invalid FILE type in AST file"); 2762 return; 2763 } 2764 Context.setFILEDecl(Tag->getDecl()); 2765 } 2766 } 2767 } 2768 2769 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 2770 QualType Jmp_bufType = GetType(Jmp_buf); 2771 if (Jmp_bufType.isNull()) { 2772 Error("jmp_buf type is NULL"); 2773 return; 2774 } 2775 2776 if (!Context.jmp_bufDecl) { 2777 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2778 Context.setjmp_bufDecl(Typedef->getDecl()); 2779 else { 2780 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2781 if (!Tag) { 2782 Error("Invalid jmp_buf type in AST file"); 2783 return; 2784 } 2785 Context.setjmp_bufDecl(Tag->getDecl()); 2786 } 2787 } 2788 } 2789 2790 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 2791 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2792 if (Sigjmp_bufType.isNull()) { 2793 Error("sigjmp_buf type is NULL"); 2794 return; 2795 } 2796 2797 if (!Context.sigjmp_bufDecl) { 2798 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2799 Context.setsigjmp_bufDecl(Typedef->getDecl()); 2800 else { 2801 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2802 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2803 Context.setsigjmp_bufDecl(Tag->getDecl()); 2804 } 2805 } 2806 } 2807 2808 if (unsigned ObjCIdRedef 2809 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 2810 if (Context.ObjCIdRedefinitionType.isNull()) 2811 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2812 } 2813 2814 if (unsigned ObjCClassRedef 2815 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 2816 if (Context.ObjCClassRedefinitionType.isNull()) 2817 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2818 } 2819 2820 if (unsigned ObjCSelRedef 2821 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 2822 if (Context.ObjCSelRedefinitionType.isNull()) 2823 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2824 } 2825 2826 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 2827 QualType Ucontext_tType = GetType(Ucontext_t); 2828 if (Ucontext_tType.isNull()) { 2829 Error("ucontext_t type is NULL"); 2830 return; 2831 } 2832 2833 if (!Context.ucontext_tDecl) { 2834 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 2835 Context.setucontext_tDecl(Typedef->getDecl()); 2836 else { 2837 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 2838 assert(Tag && "Invalid ucontext_t type in AST file"); 2839 Context.setucontext_tDecl(Tag->getDecl()); 2840 } 2841 } 2842 } 2843 } 2844 2845 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 2846 2847 // If there were any CUDA special declarations, deserialize them. 2848 if (!CUDASpecialDeclRefs.empty()) { 2849 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 2850 Context.setcudaConfigureCallDecl( 2851 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 2852 } 2853 2854 // Re-export any modules that were imported by a non-module AST file. 2855 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 2856 if (Module *Imported = getSubmodule(ImportedModules[I])) 2857 makeModuleVisible(Imported, Module::AllVisible); 2858 } 2859 ImportedModules.clear(); 2860} 2861 2862void ASTReader::finalizeForWriting() { 2863 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 2864 HiddenEnd = HiddenNamesMap.end(); 2865 Hidden != HiddenEnd; ++Hidden) { 2866 makeNamesVisible(Hidden->second); 2867 } 2868 HiddenNamesMap.clear(); 2869} 2870 2871/// \brief Retrieve the name of the original source file name 2872/// directly from the AST file, without actually loading the AST 2873/// file. 2874std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2875 FileManager &FileMgr, 2876 DiagnosticsEngine &Diags) { 2877 // Open the AST file. 2878 std::string ErrStr; 2879 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2880 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 2881 if (!Buffer) { 2882 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2883 return std::string(); 2884 } 2885 2886 // Initialize the stream 2887 llvm::BitstreamReader StreamFile; 2888 llvm::BitstreamCursor Stream; 2889 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2890 (const unsigned char *)Buffer->getBufferEnd()); 2891 Stream.init(StreamFile); 2892 2893 // Sniff for the signature. 2894 if (Stream.Read(8) != 'C' || 2895 Stream.Read(8) != 'P' || 2896 Stream.Read(8) != 'C' || 2897 Stream.Read(8) != 'H') { 2898 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2899 return std::string(); 2900 } 2901 2902 RecordData Record; 2903 while (!Stream.AtEndOfStream()) { 2904 unsigned Code = Stream.ReadCode(); 2905 2906 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2907 unsigned BlockID = Stream.ReadSubBlockID(); 2908 2909 // We only know the AST subblock ID. 2910 switch (BlockID) { 2911 case AST_BLOCK_ID: 2912 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2913 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2914 return std::string(); 2915 } 2916 break; 2917 2918 default: 2919 if (Stream.SkipBlock()) { 2920 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2921 return std::string(); 2922 } 2923 break; 2924 } 2925 continue; 2926 } 2927 2928 if (Code == llvm::bitc::END_BLOCK) { 2929 if (Stream.ReadBlockEnd()) { 2930 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2931 return std::string(); 2932 } 2933 continue; 2934 } 2935 2936 if (Code == llvm::bitc::DEFINE_ABBREV) { 2937 Stream.ReadAbbrevRecord(); 2938 continue; 2939 } 2940 2941 Record.clear(); 2942 const char *BlobStart = 0; 2943 unsigned BlobLen = 0; 2944 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 2945 == ORIGINAL_FILE_NAME) 2946 return std::string(BlobStart, BlobLen); 2947 } 2948 2949 return std::string(); 2950} 2951 2952ASTReader::ASTReadResult ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 2953 // Enter the submodule block. 2954 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 2955 Error("malformed submodule block record in AST file"); 2956 return Failure; 2957 } 2958 2959 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 2960 bool First = true; 2961 Module *CurrentModule = 0; 2962 RecordData Record; 2963 SubmoduleID CurrentModuleGlobalIndex = 0; 2964 while (true) { 2965 unsigned Code = F.Stream.ReadCode(); 2966 if (Code == llvm::bitc::END_BLOCK) { 2967 if (F.Stream.ReadBlockEnd()) { 2968 Error("error at end of submodule block in AST file"); 2969 return Failure; 2970 } 2971 return Success; 2972 } 2973 2974 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2975 // No known subblocks, always skip them. 2976 F.Stream.ReadSubBlockID(); 2977 if (F.Stream.SkipBlock()) { 2978 Error("malformed block record in AST file"); 2979 return Failure; 2980 } 2981 continue; 2982 } 2983 2984 if (Code == llvm::bitc::DEFINE_ABBREV) { 2985 F.Stream.ReadAbbrevRecord(); 2986 continue; 2987 } 2988 2989 // Read a record. 2990 const char *BlobStart; 2991 unsigned BlobLen; 2992 Record.clear(); 2993 switch (F.Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2994 default: // Default behavior: ignore. 2995 break; 2996 2997 case SUBMODULE_DEFINITION: { 2998 if (First) { 2999 Error("missing submodule metadata record at beginning of block"); 3000 return Failure; 3001 } 3002 3003 StringRef Name(BlobStart, BlobLen); 3004 unsigned Parent = getGlobalSubmoduleID(F, Record[0]); 3005 bool IsFramework = Record[1]; 3006 bool IsExplicit = Record[2]; 3007 3008 Module *ParentModule = 0; 3009 if (Parent) 3010 ParentModule = getSubmodule(Parent); 3011 3012 // Retrieve this (sub)module from the module map, creating it if 3013 // necessary. 3014 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3015 IsFramework, 3016 IsExplicit).first; 3017 3018 if (CurrentModuleGlobalIndex >= SubmodulesLoaded.size() || 3019 SubmodulesLoaded[CurrentModuleGlobalIndex]) { 3020 Error("too many submodules"); 3021 return Failure; 3022 } 3023 3024 if (DeserializationListener) 3025 DeserializationListener->ModuleRead( 3026 CurrentModuleGlobalIndex + NUM_PREDEF_SUBMODULE_IDS, 3027 CurrentModule); 3028 3029 SubmodulesLoaded[CurrentModuleGlobalIndex++] = CurrentModule; 3030 break; 3031 } 3032 3033 case SUBMODULE_UMBRELLA: { 3034 if (First) { 3035 Error("missing submodule metadata record at beginning of block"); 3036 return Failure; 3037 } 3038 3039 if (!CurrentModule) 3040 break; 3041 3042 StringRef FileName(BlobStart, BlobLen); 3043 if (const FileEntry *Umbrella = PP.getFileManager().getFile(FileName)) { 3044 if (!CurrentModule->UmbrellaHeader) 3045 CurrentModule->UmbrellaHeader = Umbrella; 3046 else if (CurrentModule->UmbrellaHeader != Umbrella) { 3047 Error("mismatched umbrella headers in submodule"); 3048 return Failure; 3049 } 3050 } 3051 break; 3052 } 3053 3054 case SUBMODULE_HEADER: { 3055 if (First) { 3056 Error("missing submodule metadata record at beginning of block"); 3057 return Failure; 3058 } 3059 3060 if (!CurrentModule) 3061 break; 3062 3063 // FIXME: Be more lazy about this! 3064 StringRef FileName(BlobStart, BlobLen); 3065 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) { 3066 if (std::find(CurrentModule->Headers.begin(), 3067 CurrentModule->Headers.end(), 3068 File) == CurrentModule->Headers.end()) 3069 CurrentModule->Headers.push_back(File); 3070 } 3071 break; 3072 } 3073 3074 case SUBMODULE_METADATA: { 3075 if (!First) { 3076 Error("submodule metadata record not at beginning of block"); 3077 return Failure; 3078 } 3079 First = false; 3080 3081 F.BaseSubmoduleID = getTotalNumSubmodules(); 3082 CurrentModuleGlobalIndex = F.BaseSubmoduleID; 3083 F.LocalNumSubmodules = Record[0]; 3084 unsigned LocalBaseSubmoduleID = Record[1]; 3085 if (F.LocalNumSubmodules > 0) { 3086 // Introduce the global -> local mapping for submodules within this 3087 // module. 3088 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3089 3090 // Introduce the local -> global mapping for submodules within this 3091 // module. 3092 F.SubmoduleRemap.insert( 3093 std::make_pair(LocalBaseSubmoduleID, 3094 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3095 3096 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3097 } 3098 break; 3099 } 3100 3101 case SUBMODULE_IMPORTS: { 3102 if (First) { 3103 Error("missing submodule metadata record at beginning of block"); 3104 return Failure; 3105 } 3106 3107 if (!CurrentModule) 3108 break; 3109 3110 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3111 UnresolvedModuleImportExport Unresolved; 3112 Unresolved.File = &F; 3113 Unresolved.Mod = CurrentModule; 3114 Unresolved.ID = Record[Idx]; 3115 Unresolved.IsImport = true; 3116 Unresolved.IsWildcard = false; 3117 UnresolvedModuleImportExports.push_back(Unresolved); 3118 } 3119 break; 3120 } 3121 3122 case SUBMODULE_EXPORTS: { 3123 if (First) { 3124 Error("missing submodule metadata record at beginning of block"); 3125 return Failure; 3126 } 3127 3128 if (!CurrentModule) 3129 break; 3130 3131 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3132 UnresolvedModuleImportExport Unresolved; 3133 Unresolved.File = &F; 3134 Unresolved.Mod = CurrentModule; 3135 Unresolved.ID = Record[Idx]; 3136 Unresolved.IsImport = false; 3137 Unresolved.IsWildcard = Record[Idx + 1]; 3138 UnresolvedModuleImportExports.push_back(Unresolved); 3139 } 3140 3141 // Once we've loaded the set of exports, there's no reason to keep 3142 // the parsed, unresolved exports around. 3143 CurrentModule->UnresolvedExports.clear(); 3144 break; 3145 } 3146 } 3147 } 3148 3149 return Success; 3150} 3151 3152/// \brief Parse the record that corresponds to a LangOptions data 3153/// structure. 3154/// 3155/// This routine parses the language options from the AST file and then gives 3156/// them to the AST listener if one is set. 3157/// 3158/// \returns true if the listener deems the file unacceptable, false otherwise. 3159bool ASTReader::ParseLanguageOptions( 3160 const SmallVectorImpl<uint64_t> &Record) { 3161 if (Listener) { 3162 LangOptions LangOpts; 3163 unsigned Idx = 0; 3164#define LANGOPT(Name, Bits, Default, Description) \ 3165 LangOpts.Name = Record[Idx++]; 3166#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3167 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3168#include "clang/Basic/LangOptions.def" 3169 3170 unsigned Length = Record[Idx++]; 3171 LangOpts.CurrentModule.assign(Record.begin() + Idx, 3172 Record.begin() + Idx + Length); 3173 Idx += Length; 3174 return Listener->ReadLanguageOptions(LangOpts); 3175 } 3176 3177 return false; 3178} 3179 3180std::pair<ModuleFile *, unsigned> 3181ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 3182 GlobalPreprocessedEntityMapType::iterator 3183 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 3184 assert(I != GlobalPreprocessedEntityMap.end() && 3185 "Corrupted global preprocessed entity map"); 3186 ModuleFile *M = I->second; 3187 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 3188 return std::make_pair(M, LocalIndex); 3189} 3190 3191PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 3192 PreprocessedEntityID PPID = Index+1; 3193 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3194 ModuleFile &M = *PPInfo.first; 3195 unsigned LocalIndex = PPInfo.second; 3196 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3197 3198 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 3199 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 3200 3201 unsigned Code = M.PreprocessorDetailCursor.ReadCode(); 3202 switch (Code) { 3203 case llvm::bitc::END_BLOCK: 3204 return 0; 3205 3206 case llvm::bitc::ENTER_SUBBLOCK: 3207 Error("unexpected subblock record in preprocessor detail block"); 3208 return 0; 3209 3210 case llvm::bitc::DEFINE_ABBREV: 3211 Error("unexpected abbrevation record in preprocessor detail block"); 3212 return 0; 3213 3214 default: 3215 break; 3216 } 3217 3218 if (!PP.getPreprocessingRecord()) { 3219 Error("no preprocessing record"); 3220 return 0; 3221 } 3222 3223 // Read the record. 3224 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 3225 ReadSourceLocation(M, PPOffs.End)); 3226 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 3227 const char *BlobStart = 0; 3228 unsigned BlobLen = 0; 3229 RecordData Record; 3230 PreprocessorDetailRecordTypes RecType = 3231 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord( 3232 Code, Record, BlobStart, BlobLen); 3233 switch (RecType) { 3234 case PPD_MACRO_EXPANSION: { 3235 bool isBuiltin = Record[0]; 3236 IdentifierInfo *Name = 0; 3237 MacroDefinition *Def = 0; 3238 if (isBuiltin) 3239 Name = getLocalIdentifier(M, Record[1]); 3240 else { 3241 PreprocessedEntityID 3242 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 3243 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 3244 } 3245 3246 MacroExpansion *ME; 3247 if (isBuiltin) 3248 ME = new (PPRec) MacroExpansion(Name, Range); 3249 else 3250 ME = new (PPRec) MacroExpansion(Def, Range); 3251 3252 return ME; 3253 } 3254 3255 case PPD_MACRO_DEFINITION: { 3256 // Decode the identifier info and then check again; if the macro is 3257 // still defined and associated with the identifier, 3258 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 3259 MacroDefinition *MD 3260 = new (PPRec) MacroDefinition(II, Range); 3261 3262 if (DeserializationListener) 3263 DeserializationListener->MacroDefinitionRead(PPID, MD); 3264 3265 return MD; 3266 } 3267 3268 case PPD_INCLUSION_DIRECTIVE: { 3269 const char *FullFileNameStart = BlobStart + Record[0]; 3270 const FileEntry *File 3271 = PP.getFileManager().getFile(StringRef(FullFileNameStart, 3272 BlobLen - Record[0])); 3273 3274 // FIXME: Stable encoding 3275 InclusionDirective::InclusionKind Kind 3276 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 3277 InclusionDirective *ID 3278 = new (PPRec) InclusionDirective(PPRec, Kind, 3279 StringRef(BlobStart, Record[0]), 3280 Record[1], 3281 File, 3282 Range); 3283 return ID; 3284 } 3285 } 3286 3287 Error("invalid offset in preprocessor detail block"); 3288 return 0; 3289} 3290 3291/// \brief \arg SLocMapI points at a chunk of a module that contains no 3292/// preprocessed entities or the entities it contains are not the ones we are 3293/// looking for. Find the next module that contains entities and return the ID 3294/// of the first entry. 3295PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 3296 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 3297 ++SLocMapI; 3298 for (GlobalSLocOffsetMapType::const_iterator 3299 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 3300 ModuleFile &M = *SLocMapI->second; 3301 if (M.NumPreprocessedEntities) 3302 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID); 3303 } 3304 3305 return getTotalNumPreprocessedEntities(); 3306} 3307 3308namespace { 3309 3310template <unsigned PPEntityOffset::*PPLoc> 3311struct PPEntityComp { 3312 const ASTReader &Reader; 3313 ModuleFile &M; 3314 3315 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 3316 3317 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 3318 SourceLocation LHS = getLoc(L); 3319 SourceLocation RHS = getLoc(R); 3320 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3321 } 3322 3323 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 3324 SourceLocation LHS = getLoc(L); 3325 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3326 } 3327 3328 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 3329 SourceLocation RHS = getLoc(R); 3330 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3331 } 3332 3333 SourceLocation getLoc(const PPEntityOffset &PPE) const { 3334 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 3335 } 3336}; 3337 3338} 3339 3340/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 3341PreprocessedEntityID 3342ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 3343 if (SourceMgr.isLocalSourceLocation(BLoc)) 3344 return getTotalNumPreprocessedEntities(); 3345 3346 GlobalSLocOffsetMapType::const_iterator 3347 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3348 BLoc.getOffset()); 3349 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3350 "Corrupted global sloc offset map"); 3351 3352 if (SLocMapI->second->NumPreprocessedEntities == 0) 3353 return findNextPreprocessedEntity(SLocMapI); 3354 3355 ModuleFile &M = *SLocMapI->second; 3356 typedef const PPEntityOffset *pp_iterator; 3357 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3358 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3359 3360 size_t Count = M.NumPreprocessedEntities; 3361 size_t Half; 3362 pp_iterator First = pp_begin; 3363 pp_iterator PPI; 3364 3365 // Do a binary search manually instead of using std::lower_bound because 3366 // The end locations of entities may be unordered (when a macro expansion 3367 // is inside another macro argument), but for this case it is not important 3368 // whether we get the first macro expansion or its containing macro. 3369 while (Count > 0) { 3370 Half = Count/2; 3371 PPI = First; 3372 std::advance(PPI, Half); 3373 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 3374 BLoc)){ 3375 First = PPI; 3376 ++First; 3377 Count = Count - Half - 1; 3378 } else 3379 Count = Half; 3380 } 3381 3382 if (PPI == pp_end) 3383 return findNextPreprocessedEntity(SLocMapI); 3384 3385 return getGlobalPreprocessedEntityID(M, 3386 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3387} 3388 3389/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 3390PreprocessedEntityID 3391ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 3392 if (SourceMgr.isLocalSourceLocation(ELoc)) 3393 return getTotalNumPreprocessedEntities(); 3394 3395 GlobalSLocOffsetMapType::const_iterator 3396 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3397 ELoc.getOffset()); 3398 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3399 "Corrupted global sloc offset map"); 3400 3401 if (SLocMapI->second->NumPreprocessedEntities == 0) 3402 return findNextPreprocessedEntity(SLocMapI); 3403 3404 ModuleFile &M = *SLocMapI->second; 3405 typedef const PPEntityOffset *pp_iterator; 3406 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3407 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3408 pp_iterator PPI = 3409 std::upper_bound(pp_begin, pp_end, ELoc, 3410 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 3411 3412 if (PPI == pp_end) 3413 return findNextPreprocessedEntity(SLocMapI); 3414 3415 return getGlobalPreprocessedEntityID(M, 3416 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3417} 3418 3419/// \brief Returns a pair of [Begin, End) indices of preallocated 3420/// preprocessed entities that \arg Range encompasses. 3421std::pair<unsigned, unsigned> 3422 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 3423 if (Range.isInvalid()) 3424 return std::make_pair(0,0); 3425 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 3426 3427 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 3428 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 3429 return std::make_pair(BeginID, EndID); 3430} 3431 3432/// \brief Optionally returns true or false if the preallocated preprocessed 3433/// entity with index \arg Index came from file \arg FID. 3434llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 3435 FileID FID) { 3436 if (FID.isInvalid()) 3437 return false; 3438 3439 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3440 ModuleFile &M = *PPInfo.first; 3441 unsigned LocalIndex = PPInfo.second; 3442 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3443 3444 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 3445 if (Loc.isInvalid()) 3446 return false; 3447 3448 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 3449 return true; 3450 else 3451 return false; 3452} 3453 3454namespace { 3455 /// \brief Visitor used to search for information about a header file. 3456 class HeaderFileInfoVisitor { 3457 ASTReader &Reader; 3458 const FileEntry *FE; 3459 3460 llvm::Optional<HeaderFileInfo> HFI; 3461 3462 public: 3463 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) 3464 : Reader(Reader), FE(FE) { } 3465 3466 static bool visit(ModuleFile &M, void *UserData) { 3467 HeaderFileInfoVisitor *This 3468 = static_cast<HeaderFileInfoVisitor *>(UserData); 3469 3470 HeaderFileInfoTrait Trait(This->Reader, M, 3471 &This->Reader.getPreprocessor().getHeaderSearchInfo(), 3472 M.HeaderFileFrameworkStrings, 3473 This->FE->getName()); 3474 3475 HeaderFileInfoLookupTable *Table 3476 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 3477 if (!Table) 3478 return false; 3479 3480 // Look in the on-disk hash table for an entry for this file name. 3481 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(), 3482 &Trait); 3483 if (Pos == Table->end()) 3484 return false; 3485 3486 This->HFI = *Pos; 3487 return true; 3488 } 3489 3490 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 3491 }; 3492} 3493 3494HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3495 HeaderFileInfoVisitor Visitor(*this, FE); 3496 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 3497 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 3498 if (Listener) 3499 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 3500 return *HFI; 3501 } 3502 3503 return HeaderFileInfo(); 3504} 3505 3506void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 3507 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3508 ModuleFile &F = *(*I); 3509 unsigned Idx = 0; 3510 while (Idx < F.PragmaDiagMappings.size()) { 3511 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3512 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 3513 Diag.DiagStatePoints.push_back( 3514 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(), 3515 FullSourceLoc(Loc, SourceMgr))); 3516 while (1) { 3517 assert(Idx < F.PragmaDiagMappings.size() && 3518 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3519 if (Idx >= F.PragmaDiagMappings.size()) { 3520 break; // Something is messed up but at least avoid infinite loop in 3521 // release build. 3522 } 3523 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3524 if (DiagID == (unsigned)-1) { 3525 break; // no more diag/map pairs for this location. 3526 } 3527 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3528 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 3529 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 3530 } 3531 } 3532 } 3533} 3534 3535/// \brief Get the correct cursor and offset for loading a type. 3536ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3537 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3538 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3539 ModuleFile *M = I->second; 3540 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3541} 3542 3543/// \brief Read and return the type with the given index.. 3544/// 3545/// The index is the type ID, shifted and minus the number of predefs. This 3546/// routine actually reads the record corresponding to the type at the given 3547/// location. It is a helper routine for GetType, which deals with reading type 3548/// IDs. 3549QualType ASTReader::readTypeRecord(unsigned Index) { 3550 RecordLocation Loc = TypeCursorForIndex(Index); 3551 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3552 3553 // Keep track of where we are in the stream, then jump back there 3554 // after reading this type. 3555 SavedStreamPosition SavedPosition(DeclsCursor); 3556 3557 ReadingKindTracker ReadingKind(Read_Type, *this); 3558 3559 // Note that we are loading a type record. 3560 Deserializing AType(this); 3561 3562 unsigned Idx = 0; 3563 DeclsCursor.JumpToBit(Loc.Offset); 3564 RecordData Record; 3565 unsigned Code = DeclsCursor.ReadCode(); 3566 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3567 case TYPE_EXT_QUAL: { 3568 if (Record.size() != 2) { 3569 Error("Incorrect encoding of extended qualifier type"); 3570 return QualType(); 3571 } 3572 QualType Base = readType(*Loc.F, Record, Idx); 3573 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3574 return Context.getQualifiedType(Base, Quals); 3575 } 3576 3577 case TYPE_COMPLEX: { 3578 if (Record.size() != 1) { 3579 Error("Incorrect encoding of complex type"); 3580 return QualType(); 3581 } 3582 QualType ElemType = readType(*Loc.F, Record, Idx); 3583 return Context.getComplexType(ElemType); 3584 } 3585 3586 case TYPE_POINTER: { 3587 if (Record.size() != 1) { 3588 Error("Incorrect encoding of pointer type"); 3589 return QualType(); 3590 } 3591 QualType PointeeType = readType(*Loc.F, Record, Idx); 3592 return Context.getPointerType(PointeeType); 3593 } 3594 3595 case TYPE_BLOCK_POINTER: { 3596 if (Record.size() != 1) { 3597 Error("Incorrect encoding of block pointer type"); 3598 return QualType(); 3599 } 3600 QualType PointeeType = readType(*Loc.F, Record, Idx); 3601 return Context.getBlockPointerType(PointeeType); 3602 } 3603 3604 case TYPE_LVALUE_REFERENCE: { 3605 if (Record.size() != 2) { 3606 Error("Incorrect encoding of lvalue reference type"); 3607 return QualType(); 3608 } 3609 QualType PointeeType = readType(*Loc.F, Record, Idx); 3610 return Context.getLValueReferenceType(PointeeType, Record[1]); 3611 } 3612 3613 case TYPE_RVALUE_REFERENCE: { 3614 if (Record.size() != 1) { 3615 Error("Incorrect encoding of rvalue reference type"); 3616 return QualType(); 3617 } 3618 QualType PointeeType = readType(*Loc.F, Record, Idx); 3619 return Context.getRValueReferenceType(PointeeType); 3620 } 3621 3622 case TYPE_MEMBER_POINTER: { 3623 if (Record.size() != 2) { 3624 Error("Incorrect encoding of member pointer type"); 3625 return QualType(); 3626 } 3627 QualType PointeeType = readType(*Loc.F, Record, Idx); 3628 QualType ClassType = readType(*Loc.F, Record, Idx); 3629 if (PointeeType.isNull() || ClassType.isNull()) 3630 return QualType(); 3631 3632 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3633 } 3634 3635 case TYPE_CONSTANT_ARRAY: { 3636 QualType ElementType = readType(*Loc.F, Record, Idx); 3637 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3638 unsigned IndexTypeQuals = Record[2]; 3639 unsigned Idx = 3; 3640 llvm::APInt Size = ReadAPInt(Record, Idx); 3641 return Context.getConstantArrayType(ElementType, Size, 3642 ASM, IndexTypeQuals); 3643 } 3644 3645 case TYPE_INCOMPLETE_ARRAY: { 3646 QualType ElementType = readType(*Loc.F, Record, Idx); 3647 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3648 unsigned IndexTypeQuals = Record[2]; 3649 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3650 } 3651 3652 case TYPE_VARIABLE_ARRAY: { 3653 QualType ElementType = readType(*Loc.F, Record, Idx); 3654 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3655 unsigned IndexTypeQuals = Record[2]; 3656 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3657 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3658 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3659 ASM, IndexTypeQuals, 3660 SourceRange(LBLoc, RBLoc)); 3661 } 3662 3663 case TYPE_VECTOR: { 3664 if (Record.size() != 3) { 3665 Error("incorrect encoding of vector type in AST file"); 3666 return QualType(); 3667 } 3668 3669 QualType ElementType = readType(*Loc.F, Record, Idx); 3670 unsigned NumElements = Record[1]; 3671 unsigned VecKind = Record[2]; 3672 return Context.getVectorType(ElementType, NumElements, 3673 (VectorType::VectorKind)VecKind); 3674 } 3675 3676 case TYPE_EXT_VECTOR: { 3677 if (Record.size() != 3) { 3678 Error("incorrect encoding of extended vector type in AST file"); 3679 return QualType(); 3680 } 3681 3682 QualType ElementType = readType(*Loc.F, Record, Idx); 3683 unsigned NumElements = Record[1]; 3684 return Context.getExtVectorType(ElementType, NumElements); 3685 } 3686 3687 case TYPE_FUNCTION_NO_PROTO: { 3688 if (Record.size() != 6) { 3689 Error("incorrect encoding of no-proto function type"); 3690 return QualType(); 3691 } 3692 QualType ResultType = readType(*Loc.F, Record, Idx); 3693 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3694 (CallingConv)Record[4], Record[5]); 3695 return Context.getFunctionNoProtoType(ResultType, Info); 3696 } 3697 3698 case TYPE_FUNCTION_PROTO: { 3699 QualType ResultType = readType(*Loc.F, Record, Idx); 3700 3701 FunctionProtoType::ExtProtoInfo EPI; 3702 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3703 /*hasregparm*/ Record[2], 3704 /*regparm*/ Record[3], 3705 static_cast<CallingConv>(Record[4]), 3706 /*produces*/ Record[5]); 3707 3708 unsigned Idx = 6; 3709 unsigned NumParams = Record[Idx++]; 3710 SmallVector<QualType, 16> ParamTypes; 3711 for (unsigned I = 0; I != NumParams; ++I) 3712 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3713 3714 EPI.Variadic = Record[Idx++]; 3715 EPI.TypeQuals = Record[Idx++]; 3716 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3717 ExceptionSpecificationType EST = 3718 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3719 EPI.ExceptionSpecType = EST; 3720 if (EST == EST_Dynamic) { 3721 EPI.NumExceptions = Record[Idx++]; 3722 SmallVector<QualType, 2> Exceptions; 3723 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3724 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3725 EPI.Exceptions = Exceptions.data(); 3726 } else if (EST == EST_ComputedNoexcept) { 3727 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3728 } 3729 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams, 3730 EPI); 3731 } 3732 3733 case TYPE_UNRESOLVED_USING: { 3734 unsigned Idx = 0; 3735 return Context.getTypeDeclType( 3736 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3737 } 3738 3739 case TYPE_TYPEDEF: { 3740 if (Record.size() != 2) { 3741 Error("incorrect encoding of typedef type"); 3742 return QualType(); 3743 } 3744 unsigned Idx = 0; 3745 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3746 QualType Canonical = readType(*Loc.F, Record, Idx); 3747 if (!Canonical.isNull()) 3748 Canonical = Context.getCanonicalType(Canonical); 3749 return Context.getTypedefType(Decl, Canonical); 3750 } 3751 3752 case TYPE_TYPEOF_EXPR: 3753 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 3754 3755 case TYPE_TYPEOF: { 3756 if (Record.size() != 1) { 3757 Error("incorrect encoding of typeof(type) in AST file"); 3758 return QualType(); 3759 } 3760 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3761 return Context.getTypeOfType(UnderlyingType); 3762 } 3763 3764 case TYPE_DECLTYPE: 3765 return Context.getDecltypeType(ReadExpr(*Loc.F)); 3766 3767 case TYPE_UNARY_TRANSFORM: { 3768 QualType BaseType = readType(*Loc.F, Record, Idx); 3769 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3770 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3771 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 3772 } 3773 3774 case TYPE_AUTO: 3775 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 3776 3777 case TYPE_RECORD: { 3778 if (Record.size() != 2) { 3779 Error("incorrect encoding of record type"); 3780 return QualType(); 3781 } 3782 unsigned Idx = 0; 3783 bool IsDependent = Record[Idx++]; 3784 QualType T 3785 = Context.getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3786 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3787 return T; 3788 } 3789 3790 case TYPE_ENUM: { 3791 if (Record.size() != 2) { 3792 Error("incorrect encoding of enum type"); 3793 return QualType(); 3794 } 3795 unsigned Idx = 0; 3796 bool IsDependent = Record[Idx++]; 3797 QualType T 3798 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3799 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3800 return T; 3801 } 3802 3803 case TYPE_ATTRIBUTED: { 3804 if (Record.size() != 3) { 3805 Error("incorrect encoding of attributed type"); 3806 return QualType(); 3807 } 3808 QualType modifiedType = readType(*Loc.F, Record, Idx); 3809 QualType equivalentType = readType(*Loc.F, Record, Idx); 3810 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3811 return Context.getAttributedType(kind, modifiedType, equivalentType); 3812 } 3813 3814 case TYPE_PAREN: { 3815 if (Record.size() != 1) { 3816 Error("incorrect encoding of paren type"); 3817 return QualType(); 3818 } 3819 QualType InnerType = readType(*Loc.F, Record, Idx); 3820 return Context.getParenType(InnerType); 3821 } 3822 3823 case TYPE_PACK_EXPANSION: { 3824 if (Record.size() != 2) { 3825 Error("incorrect encoding of pack expansion type"); 3826 return QualType(); 3827 } 3828 QualType Pattern = readType(*Loc.F, Record, Idx); 3829 if (Pattern.isNull()) 3830 return QualType(); 3831 llvm::Optional<unsigned> NumExpansions; 3832 if (Record[1]) 3833 NumExpansions = Record[1] - 1; 3834 return Context.getPackExpansionType(Pattern, NumExpansions); 3835 } 3836 3837 case TYPE_ELABORATED: { 3838 unsigned Idx = 0; 3839 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3840 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3841 QualType NamedType = readType(*Loc.F, Record, Idx); 3842 return Context.getElaboratedType(Keyword, NNS, NamedType); 3843 } 3844 3845 case TYPE_OBJC_INTERFACE: { 3846 unsigned Idx = 0; 3847 ObjCInterfaceDecl *ItfD 3848 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3849 return Context.getObjCInterfaceType(ItfD); 3850 } 3851 3852 case TYPE_OBJC_OBJECT: { 3853 unsigned Idx = 0; 3854 QualType Base = readType(*Loc.F, Record, Idx); 3855 unsigned NumProtos = Record[Idx++]; 3856 SmallVector<ObjCProtocolDecl*, 4> Protos; 3857 for (unsigned I = 0; I != NumProtos; ++I) 3858 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3859 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 3860 } 3861 3862 case TYPE_OBJC_OBJECT_POINTER: { 3863 unsigned Idx = 0; 3864 QualType Pointee = readType(*Loc.F, Record, Idx); 3865 return Context.getObjCObjectPointerType(Pointee); 3866 } 3867 3868 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3869 unsigned Idx = 0; 3870 QualType Parm = readType(*Loc.F, Record, Idx); 3871 QualType Replacement = readType(*Loc.F, Record, Idx); 3872 return 3873 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3874 Replacement); 3875 } 3876 3877 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3878 unsigned Idx = 0; 3879 QualType Parm = readType(*Loc.F, Record, Idx); 3880 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3881 return Context.getSubstTemplateTypeParmPackType( 3882 cast<TemplateTypeParmType>(Parm), 3883 ArgPack); 3884 } 3885 3886 case TYPE_INJECTED_CLASS_NAME: { 3887 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3888 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3889 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3890 // for AST reading, too much interdependencies. 3891 return 3892 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3893 } 3894 3895 case TYPE_TEMPLATE_TYPE_PARM: { 3896 unsigned Idx = 0; 3897 unsigned Depth = Record[Idx++]; 3898 unsigned Index = Record[Idx++]; 3899 bool Pack = Record[Idx++]; 3900 TemplateTypeParmDecl *D 3901 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3902 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 3903 } 3904 3905 case TYPE_DEPENDENT_NAME: { 3906 unsigned Idx = 0; 3907 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3908 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3909 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3910 QualType Canon = readType(*Loc.F, Record, Idx); 3911 if (!Canon.isNull()) 3912 Canon = Context.getCanonicalType(Canon); 3913 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 3914 } 3915 3916 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3917 unsigned Idx = 0; 3918 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3919 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3920 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3921 unsigned NumArgs = Record[Idx++]; 3922 SmallVector<TemplateArgument, 8> Args; 3923 Args.reserve(NumArgs); 3924 while (NumArgs--) 3925 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3926 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 3927 Args.size(), Args.data()); 3928 } 3929 3930 case TYPE_DEPENDENT_SIZED_ARRAY: { 3931 unsigned Idx = 0; 3932 3933 // ArrayType 3934 QualType ElementType = readType(*Loc.F, Record, Idx); 3935 ArrayType::ArraySizeModifier ASM 3936 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3937 unsigned IndexTypeQuals = Record[Idx++]; 3938 3939 // DependentSizedArrayType 3940 Expr *NumElts = ReadExpr(*Loc.F); 3941 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3942 3943 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 3944 IndexTypeQuals, Brackets); 3945 } 3946 3947 case TYPE_TEMPLATE_SPECIALIZATION: { 3948 unsigned Idx = 0; 3949 bool IsDependent = Record[Idx++]; 3950 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3951 SmallVector<TemplateArgument, 8> Args; 3952 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3953 QualType Underlying = readType(*Loc.F, Record, Idx); 3954 QualType T; 3955 if (Underlying.isNull()) 3956 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 3957 Args.size()); 3958 else 3959 T = Context.getTemplateSpecializationType(Name, Args.data(), 3960 Args.size(), Underlying); 3961 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3962 return T; 3963 } 3964 3965 case TYPE_ATOMIC: { 3966 if (Record.size() != 1) { 3967 Error("Incorrect encoding of atomic type"); 3968 return QualType(); 3969 } 3970 QualType ValueType = readType(*Loc.F, Record, Idx); 3971 return Context.getAtomicType(ValueType); 3972 } 3973 } 3974 // Suppress a GCC warning 3975 return QualType(); 3976} 3977 3978class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3979 ASTReader &Reader; 3980 ModuleFile &F; 3981 llvm::BitstreamCursor &DeclsCursor; 3982 const ASTReader::RecordData &Record; 3983 unsigned &Idx; 3984 3985 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3986 unsigned &I) { 3987 return Reader.ReadSourceLocation(F, R, I); 3988 } 3989 3990 template<typename T> 3991 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 3992 return Reader.ReadDeclAs<T>(F, Record, Idx); 3993 } 3994 3995public: 3996 TypeLocReader(ASTReader &Reader, ModuleFile &F, 3997 const ASTReader::RecordData &Record, unsigned &Idx) 3998 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3999 { } 4000 4001 // We want compile-time assurance that we've enumerated all of 4002 // these, so unfortunately we have to declare them first, then 4003 // define them out-of-line. 4004#define ABSTRACT_TYPELOC(CLASS, PARENT) 4005#define TYPELOC(CLASS, PARENT) \ 4006 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4007#include "clang/AST/TypeLocNodes.def" 4008 4009 void VisitFunctionTypeLoc(FunctionTypeLoc); 4010 void VisitArrayTypeLoc(ArrayTypeLoc); 4011}; 4012 4013void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4014 // nothing to do 4015} 4016void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4017 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4018 if (TL.needsExtraLocalData()) { 4019 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4020 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4021 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4022 TL.setModeAttr(Record[Idx++]); 4023 } 4024} 4025void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4026 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4027} 4028void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4029 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4030} 4031void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4032 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4033} 4034void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4035 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4036} 4037void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4038 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4039} 4040void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4041 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4042 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4043} 4044void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4045 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4046 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4047 if (Record[Idx++]) 4048 TL.setSizeExpr(Reader.ReadExpr(F)); 4049 else 4050 TL.setSizeExpr(0); 4051} 4052void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4053 VisitArrayTypeLoc(TL); 4054} 4055void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4056 VisitArrayTypeLoc(TL); 4057} 4058void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4059 VisitArrayTypeLoc(TL); 4060} 4061void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4062 DependentSizedArrayTypeLoc TL) { 4063 VisitArrayTypeLoc(TL); 4064} 4065void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4066 DependentSizedExtVectorTypeLoc TL) { 4067 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4068} 4069void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4070 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4071} 4072void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4073 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4074} 4075void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4076 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4077 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4078 TL.setTrailingReturn(Record[Idx++]); 4079 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4080 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4081 } 4082} 4083void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4084 VisitFunctionTypeLoc(TL); 4085} 4086void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4087 VisitFunctionTypeLoc(TL); 4088} 4089void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4090 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4091} 4092void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4093 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4094} 4095void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4096 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4097 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4098 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4099} 4100void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4101 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4102 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4103 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4104 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4105} 4106void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4107 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4108} 4109void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4110 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4111 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4112 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4113 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4114} 4115void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4116 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4117} 4118void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4119 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4120} 4121void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4122 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4123} 4124void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4125 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4126 if (TL.hasAttrOperand()) { 4127 SourceRange range; 4128 range.setBegin(ReadSourceLocation(Record, Idx)); 4129 range.setEnd(ReadSourceLocation(Record, Idx)); 4130 TL.setAttrOperandParensRange(range); 4131 } 4132 if (TL.hasAttrExprOperand()) { 4133 if (Record[Idx++]) 4134 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4135 else 4136 TL.setAttrExprOperand(0); 4137 } else if (TL.hasAttrEnumOperand()) 4138 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4139} 4140void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4141 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4142} 4143void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4144 SubstTemplateTypeParmTypeLoc TL) { 4145 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4146} 4147void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4148 SubstTemplateTypeParmPackTypeLoc TL) { 4149 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4150} 4151void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4152 TemplateSpecializationTypeLoc TL) { 4153 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4154 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4155 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4156 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4157 TL.setArgLocInfo(i, 4158 Reader.GetTemplateArgumentLocInfo(F, 4159 TL.getTypePtr()->getArg(i).getKind(), 4160 Record, Idx)); 4161} 4162void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4163 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4164 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4165} 4166void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4167 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4168 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4169} 4170void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4171 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4172} 4173void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4174 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4175 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4176 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4177} 4178void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4179 DependentTemplateSpecializationTypeLoc TL) { 4180 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4181 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4182 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4183 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4184 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4185 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4186 TL.setArgLocInfo(I, 4187 Reader.GetTemplateArgumentLocInfo(F, 4188 TL.getTypePtr()->getArg(I).getKind(), 4189 Record, Idx)); 4190} 4191void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4192 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4193} 4194void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4195 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4196} 4197void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4198 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4199 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4200 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4201 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4202 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4203} 4204void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4205 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4206} 4207void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4208 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4209 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4210 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4211} 4212 4213TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 4214 const RecordData &Record, 4215 unsigned &Idx) { 4216 QualType InfoTy = readType(F, Record, Idx); 4217 if (InfoTy.isNull()) 4218 return 0; 4219 4220 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 4221 TypeLocReader TLR(*this, F, Record, Idx); 4222 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4223 TLR.Visit(TL); 4224 return TInfo; 4225} 4226 4227QualType ASTReader::GetType(TypeID ID) { 4228 unsigned FastQuals = ID & Qualifiers::FastMask; 4229 unsigned Index = ID >> Qualifiers::FastWidth; 4230 4231 if (Index < NUM_PREDEF_TYPE_IDS) { 4232 QualType T; 4233 switch ((PredefinedTypeIDs)Index) { 4234 case PREDEF_TYPE_NULL_ID: return QualType(); 4235 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 4236 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 4237 4238 case PREDEF_TYPE_CHAR_U_ID: 4239 case PREDEF_TYPE_CHAR_S_ID: 4240 // FIXME: Check that the signedness of CharTy is correct! 4241 T = Context.CharTy; 4242 break; 4243 4244 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 4245 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 4246 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 4247 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 4248 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 4249 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 4250 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 4251 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 4252 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 4253 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 4254 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 4255 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 4256 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 4257 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 4258 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 4259 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 4260 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 4261 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 4262 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 4263 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 4264 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 4265 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 4266 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 4267 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 4268 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 4269 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 4270 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 4271 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 4272 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 4273 4274 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 4275 T = Context.getAutoRRefDeductType(); 4276 break; 4277 4278 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 4279 T = Context.ARCUnbridgedCastTy; 4280 break; 4281 4282 } 4283 4284 assert(!T.isNull() && "Unknown predefined type"); 4285 return T.withFastQualifiers(FastQuals); 4286 } 4287 4288 Index -= NUM_PREDEF_TYPE_IDS; 4289 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4290 if (TypesLoaded[Index].isNull()) { 4291 TypesLoaded[Index] = readTypeRecord(Index); 4292 if (TypesLoaded[Index].isNull()) 4293 return QualType(); 4294 4295 TypesLoaded[Index]->setFromAST(); 4296 if (DeserializationListener) 4297 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4298 TypesLoaded[Index]); 4299 } 4300 4301 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4302} 4303 4304QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 4305 return GetType(getGlobalTypeID(F, LocalID)); 4306} 4307 4308serialization::TypeID 4309ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 4310 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4311 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4312 4313 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4314 return LocalID; 4315 4316 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4317 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4318 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4319 4320 unsigned GlobalIndex = LocalIndex + I->second; 4321 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4322} 4323 4324TemplateArgumentLocInfo 4325ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 4326 TemplateArgument::ArgKind Kind, 4327 const RecordData &Record, 4328 unsigned &Index) { 4329 switch (Kind) { 4330 case TemplateArgument::Expression: 4331 return ReadExpr(F); 4332 case TemplateArgument::Type: 4333 return GetTypeSourceInfo(F, Record, Index); 4334 case TemplateArgument::Template: { 4335 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4336 Index); 4337 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4338 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4339 SourceLocation()); 4340 } 4341 case TemplateArgument::TemplateExpansion: { 4342 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4343 Index); 4344 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4345 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4346 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4347 EllipsisLoc); 4348 } 4349 case TemplateArgument::Null: 4350 case TemplateArgument::Integral: 4351 case TemplateArgument::Declaration: 4352 case TemplateArgument::Pack: 4353 return TemplateArgumentLocInfo(); 4354 } 4355 llvm_unreachable("unexpected template argument loc"); 4356 return TemplateArgumentLocInfo(); 4357} 4358 4359TemplateArgumentLoc 4360ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 4361 const RecordData &Record, unsigned &Index) { 4362 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4363 4364 if (Arg.getKind() == TemplateArgument::Expression) { 4365 if (Record[Index++]) // bool InfoHasSameExpr. 4366 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4367 } 4368 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4369 Record, Index)); 4370} 4371 4372Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4373 return GetDecl(ID); 4374} 4375 4376uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 4377 unsigned &Idx){ 4378 if (Idx >= Record.size()) 4379 return 0; 4380 4381 unsigned LocalID = Record[Idx++]; 4382 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4383} 4384 4385CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4386 RecordLocation Loc = getLocalBitOffset(Offset); 4387 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4388 SavedStreamPosition SavedPosition(Cursor); 4389 Cursor.JumpToBit(Loc.Offset); 4390 ReadingKindTracker ReadingKind(Read_Decl, *this); 4391 RecordData Record; 4392 unsigned Code = Cursor.ReadCode(); 4393 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4394 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4395 Error("Malformed AST file: missing C++ base specifiers"); 4396 return 0; 4397 } 4398 4399 unsigned Idx = 0; 4400 unsigned NumBases = Record[Idx++]; 4401 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4402 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4403 for (unsigned I = 0; I != NumBases; ++I) 4404 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4405 return Bases; 4406} 4407 4408serialization::DeclID 4409ASTReader::getGlobalDeclID(ModuleFile &F, unsigned LocalID) const { 4410 if (LocalID < NUM_PREDEF_DECL_IDS) 4411 return LocalID; 4412 4413 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4414 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4415 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4416 4417 return LocalID + I->second; 4418} 4419 4420bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 4421 ModuleFile &M) const { 4422 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 4423 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4424 return &M == I->second; 4425} 4426 4427SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 4428 if (ID < NUM_PREDEF_DECL_IDS) 4429 return SourceLocation(); 4430 4431 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4432 4433 if (Index > DeclsLoaded.size()) { 4434 Error("declaration ID out-of-range for AST file"); 4435 return SourceLocation(); 4436 } 4437 4438 if (Decl *D = DeclsLoaded[Index]) 4439 return D->getLocation(); 4440 4441 unsigned RawLocation = 0; 4442 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 4443 return ReadSourceLocation(*Rec.F, RawLocation); 4444} 4445 4446Decl *ASTReader::GetDecl(DeclID ID) { 4447 if (ID < NUM_PREDEF_DECL_IDS) { 4448 switch ((PredefinedDeclIDs)ID) { 4449 case PREDEF_DECL_NULL_ID: 4450 return 0; 4451 4452 case PREDEF_DECL_TRANSLATION_UNIT_ID: 4453 return Context.getTranslationUnitDecl(); 4454 4455 case PREDEF_DECL_OBJC_ID_ID: 4456 return Context.getObjCIdDecl(); 4457 4458 case PREDEF_DECL_OBJC_SEL_ID: 4459 return Context.getObjCSelDecl(); 4460 4461 case PREDEF_DECL_OBJC_CLASS_ID: 4462 return Context.getObjCClassDecl(); 4463 4464 case PREDEF_DECL_INT_128_ID: 4465 return Context.getInt128Decl(); 4466 4467 case PREDEF_DECL_UNSIGNED_INT_128_ID: 4468 return Context.getUInt128Decl(); 4469 4470 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 4471 return Context.getObjCInstanceTypeDecl(); 4472 } 4473 4474 return 0; 4475 } 4476 4477 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4478 4479 if (Index > DeclsLoaded.size()) { 4480 Error("declaration ID out-of-range for AST file"); 4481 return 0; 4482 } 4483 4484if (!DeclsLoaded[Index]) { 4485 ReadDeclRecord(ID); 4486 if (DeserializationListener) 4487 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4488 } 4489 4490 return DeclsLoaded[Index]; 4491} 4492 4493serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 4494 const RecordData &Record, 4495 unsigned &Idx) { 4496 if (Idx >= Record.size()) { 4497 Error("Corrupted AST file"); 4498 return 0; 4499 } 4500 4501 return getGlobalDeclID(F, Record[Idx++]); 4502} 4503 4504/// \brief Resolve the offset of a statement into a statement. 4505/// 4506/// This operation will read a new statement from the external 4507/// source each time it is called, and is meant to be used via a 4508/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4509Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4510 // Switch case IDs are per Decl. 4511 ClearSwitchCaseIDs(); 4512 4513 // Offset here is a global offset across the entire chain. 4514 RecordLocation Loc = getLocalBitOffset(Offset); 4515 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4516 return ReadStmtFromStream(*Loc.F); 4517} 4518 4519namespace { 4520 class FindExternalLexicalDeclsVisitor { 4521 ASTReader &Reader; 4522 const DeclContext *DC; 4523 bool (*isKindWeWant)(Decl::Kind); 4524 4525 SmallVectorImpl<Decl*> &Decls; 4526 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 4527 4528 public: 4529 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 4530 bool (*isKindWeWant)(Decl::Kind), 4531 SmallVectorImpl<Decl*> &Decls) 4532 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 4533 { 4534 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 4535 PredefsVisited[I] = false; 4536 } 4537 4538 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 4539 if (Preorder) 4540 return false; 4541 4542 FindExternalLexicalDeclsVisitor *This 4543 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 4544 4545 ModuleFile::DeclContextInfosMap::iterator Info 4546 = M.DeclContextInfos.find(This->DC); 4547 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 4548 return false; 4549 4550 // Load all of the declaration IDs 4551 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 4552 *IDE = ID + Info->second.NumLexicalDecls; 4553 ID != IDE; ++ID) { 4554 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 4555 continue; 4556 4557 // Don't add predefined declarations to the lexical context more 4558 // than once. 4559 if (ID->second < NUM_PREDEF_DECL_IDS) { 4560 if (This->PredefsVisited[ID->second]) 4561 continue; 4562 4563 This->PredefsVisited[ID->second] = true; 4564 } 4565 4566 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 4567 if (!This->DC->isDeclInLexicalTraversal(D)) 4568 This->Decls.push_back(D); 4569 } 4570 } 4571 4572 return false; 4573 } 4574 }; 4575} 4576 4577ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4578 bool (*isKindWeWant)(Decl::Kind), 4579 SmallVectorImpl<Decl*> &Decls) { 4580 // There might be lexical decls in multiple modules, for the TU at 4581 // least. Walk all of the modules in the order they were loaded. 4582 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 4583 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 4584 ++NumLexicalDeclContextsRead; 4585 return ELR_Success; 4586} 4587 4588namespace { 4589 4590class DeclIDComp { 4591 ASTReader &Reader; 4592 ModuleFile &Mod; 4593 4594public: 4595 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 4596 4597 bool operator()(LocalDeclID L, LocalDeclID R) const { 4598 SourceLocation LHS = getLocation(L); 4599 SourceLocation RHS = getLocation(R); 4600 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4601 } 4602 4603 bool operator()(SourceLocation LHS, LocalDeclID R) const { 4604 SourceLocation RHS = getLocation(R); 4605 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4606 } 4607 4608 bool operator()(LocalDeclID L, SourceLocation RHS) const { 4609 SourceLocation LHS = getLocation(L); 4610 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4611 } 4612 4613 SourceLocation getLocation(LocalDeclID ID) const { 4614 return Reader.getSourceManager().getFileLoc( 4615 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 4616 } 4617}; 4618 4619} 4620 4621void ASTReader::FindFileRegionDecls(FileID File, 4622 unsigned Offset, unsigned Length, 4623 SmallVectorImpl<Decl *> &Decls) { 4624 SourceManager &SM = getSourceManager(); 4625 4626 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 4627 if (I == FileDeclIDs.end()) 4628 return; 4629 4630 FileDeclsInfo &DInfo = I->second; 4631 if (DInfo.Decls.empty()) 4632 return; 4633 4634 SourceLocation 4635 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 4636 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 4637 4638 DeclIDComp DIDComp(*this, *DInfo.Mod); 4639 ArrayRef<serialization::LocalDeclID>::iterator 4640 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4641 BeginLoc, DIDComp); 4642 if (BeginIt != DInfo.Decls.begin()) 4643 --BeginIt; 4644 4645 // If we are pointing at a top-level decl inside an objc container, we need 4646 // to backtrack until we find it otherwise we will fail to report that the 4647 // region overlaps with an objc container. 4648 while (BeginIt != DInfo.Decls.begin() && 4649 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 4650 ->isTopLevelDeclInObjCContainer()) 4651 --BeginIt; 4652 4653 ArrayRef<serialization::LocalDeclID>::iterator 4654 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4655 EndLoc, DIDComp); 4656 if (EndIt != DInfo.Decls.end()) 4657 ++EndIt; 4658 4659 for (ArrayRef<serialization::LocalDeclID>::iterator 4660 DIt = BeginIt; DIt != EndIt; ++DIt) 4661 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 4662} 4663 4664namespace { 4665 /// \brief ModuleFile visitor used to perform name lookup into a 4666 /// declaration context. 4667 class DeclContextNameLookupVisitor { 4668 ASTReader &Reader; 4669 const DeclContext *DC; 4670 DeclarationName Name; 4671 SmallVectorImpl<NamedDecl *> &Decls; 4672 4673 public: 4674 DeclContextNameLookupVisitor(ASTReader &Reader, 4675 const DeclContext *DC, DeclarationName Name, 4676 SmallVectorImpl<NamedDecl *> &Decls) 4677 : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { } 4678 4679 static bool visit(ModuleFile &M, void *UserData) { 4680 DeclContextNameLookupVisitor *This 4681 = static_cast<DeclContextNameLookupVisitor *>(UserData); 4682 4683 // Check whether we have any visible declaration information for 4684 // this context in this module. 4685 ModuleFile::DeclContextInfosMap::iterator Info 4686 = M.DeclContextInfos.find(This->DC); 4687 if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData) 4688 return false; 4689 4690 // Look for this name within this module. 4691 ASTDeclContextNameLookupTable *LookupTable = 4692 (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData; 4693 ASTDeclContextNameLookupTable::iterator Pos 4694 = LookupTable->find(This->Name); 4695 if (Pos == LookupTable->end()) 4696 return false; 4697 4698 bool FoundAnything = false; 4699 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4700 for (; Data.first != Data.second; ++Data.first) { 4701 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 4702 if (!ND) 4703 continue; 4704 4705 if (ND->getDeclName() != This->Name) { 4706 assert(!This->Name.getCXXNameType().isNull() && 4707 "Name mismatch without a type"); 4708 continue; 4709 } 4710 4711 // Record this declaration. 4712 FoundAnything = true; 4713 This->Decls.push_back(ND); 4714 } 4715 4716 return FoundAnything; 4717 } 4718 }; 4719} 4720 4721DeclContext::lookup_result 4722ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4723 DeclarationName Name) { 4724 assert(DC->hasExternalVisibleStorage() && 4725 "DeclContext has no visible decls in storage"); 4726 if (!Name) 4727 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4728 DeclContext::lookup_iterator(0)); 4729 4730 SmallVector<NamedDecl *, 64> Decls; 4731 DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls); 4732 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 4733 ++NumVisibleDeclContextsRead; 4734 SetExternalVisibleDeclsForName(DC, Name, Decls); 4735 return const_cast<DeclContext*>(DC)->lookup(Name); 4736} 4737 4738/// \brief Under non-PCH compilation the consumer receives the objc methods 4739/// before receiving the implementation, and codegen depends on this. 4740/// We simulate this by deserializing and passing to consumer the methods of the 4741/// implementation before passing the deserialized implementation decl. 4742static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 4743 ASTConsumer *Consumer) { 4744 assert(ImplD && Consumer); 4745 4746 for (ObjCImplDecl::method_iterator 4747 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 4748 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 4749 4750 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 4751} 4752 4753void ASTReader::PassInterestingDeclsToConsumer() { 4754 assert(Consumer); 4755 while (!InterestingDecls.empty()) { 4756 Decl *D = InterestingDecls.front(); 4757 InterestingDecls.pop_front(); 4758 4759 PassInterestingDeclToConsumer(D); 4760 } 4761} 4762 4763void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 4764 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4765 PassObjCImplDeclToConsumer(ImplD, Consumer); 4766 else 4767 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 4768} 4769 4770void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4771 this->Consumer = Consumer; 4772 4773 if (!Consumer) 4774 return; 4775 4776 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4777 // Force deserialization of this decl, which will cause it to be queued for 4778 // passing to the consumer. 4779 GetDecl(ExternalDefinitions[I]); 4780 } 4781 ExternalDefinitions.clear(); 4782 4783 PassInterestingDeclsToConsumer(); 4784} 4785 4786void ASTReader::PrintStats() { 4787 std::fprintf(stderr, "*** AST File Statistics:\n"); 4788 4789 unsigned NumTypesLoaded 4790 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4791 QualType()); 4792 unsigned NumDeclsLoaded 4793 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4794 (Decl *)0); 4795 unsigned NumIdentifiersLoaded 4796 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4797 IdentifiersLoaded.end(), 4798 (IdentifierInfo *)0); 4799 unsigned NumSelectorsLoaded 4800 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4801 SelectorsLoaded.end(), 4802 Selector()); 4803 4804 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4805 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4806 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4807 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4808 NumSLocEntriesRead, TotalNumSLocEntries, 4809 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4810 if (!TypesLoaded.empty()) 4811 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4812 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4813 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4814 if (!DeclsLoaded.empty()) 4815 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4816 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4817 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4818 if (!IdentifiersLoaded.empty()) 4819 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4820 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4821 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4822 if (!SelectorsLoaded.empty()) 4823 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4824 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4825 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4826 if (TotalNumStatements) 4827 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4828 NumStatementsRead, TotalNumStatements, 4829 ((float)NumStatementsRead/TotalNumStatements * 100)); 4830 if (TotalNumMacros) 4831 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4832 NumMacrosRead, TotalNumMacros, 4833 ((float)NumMacrosRead/TotalNumMacros * 100)); 4834 if (TotalLexicalDeclContexts) 4835 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4836 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4837 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4838 * 100)); 4839 if (TotalVisibleDeclContexts) 4840 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4841 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4842 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4843 * 100)); 4844 if (TotalNumMethodPoolEntries) { 4845 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4846 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4847 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4848 * 100)); 4849 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4850 } 4851 std::fprintf(stderr, "\n"); 4852 dump(); 4853 std::fprintf(stderr, "\n"); 4854} 4855 4856template<typename Key, typename ModuleFile, unsigned InitialCapacity> 4857static void 4858dumpModuleIDMap(StringRef Name, 4859 const ContinuousRangeMap<Key, ModuleFile *, 4860 InitialCapacity> &Map) { 4861 if (Map.begin() == Map.end()) 4862 return; 4863 4864 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 4865 llvm::errs() << Name << ":\n"; 4866 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4867 I != IEnd; ++I) { 4868 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4869 << "\n"; 4870 } 4871} 4872 4873void ASTReader::dump() { 4874 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 4875 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4876 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4877 dumpModuleIDMap("Global type map", GlobalTypeMap); 4878 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4879 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4880 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 4881 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4882 dumpModuleIDMap("Global preprocessed entity map", 4883 GlobalPreprocessedEntityMap); 4884 4885 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4886 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4887 MEnd = ModuleMgr.end(); 4888 M != MEnd; ++M) 4889 (*M)->dump(); 4890} 4891 4892/// Return the amount of memory used by memory buffers, breaking down 4893/// by heap-backed versus mmap'ed memory. 4894void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4895 for (ModuleConstIterator I = ModuleMgr.begin(), 4896 E = ModuleMgr.end(); I != E; ++I) { 4897 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4898 size_t bytes = buf->getBufferSize(); 4899 switch (buf->getBufferKind()) { 4900 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4901 sizes.malloc_bytes += bytes; 4902 break; 4903 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4904 sizes.mmap_bytes += bytes; 4905 break; 4906 } 4907 } 4908 } 4909} 4910 4911void ASTReader::InitializeSema(Sema &S) { 4912 SemaObj = &S; 4913 S.ExternalSource = this; 4914 4915 // Makes sure any declarations that were deserialized "too early" 4916 // still get added to the identifier's declaration chains. 4917 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4918 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I], 4919 PreloadedDecls[I]->getDeclName()); 4920 } 4921 PreloadedDecls.clear(); 4922 4923 // Load the offsets of the declarations that Sema references. 4924 // They will be lazily deserialized when needed. 4925 if (!SemaDeclRefs.empty()) { 4926 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4927 if (!SemaObj->StdNamespace) 4928 SemaObj->StdNamespace = SemaDeclRefs[0]; 4929 if (!SemaObj->StdBadAlloc) 4930 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4931 } 4932 4933 if (!FPPragmaOptions.empty()) { 4934 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4935 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4936 } 4937 4938 if (!OpenCLExtensions.empty()) { 4939 unsigned I = 0; 4940#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4941#include "clang/Basic/OpenCLExtensions.def" 4942 4943 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4944 } 4945} 4946 4947IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4948 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart)); 4949 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 4950 IdentifierInfo *II = Visitor.getIdentifierInfo(); 4951 if (II) 4952 II->setOutOfDate(false); 4953 return II; 4954} 4955 4956namespace clang { 4957 /// \brief An identifier-lookup iterator that enumerates all of the 4958 /// identifiers stored within a set of AST files. 4959 class ASTIdentifierIterator : public IdentifierIterator { 4960 /// \brief The AST reader whose identifiers are being enumerated. 4961 const ASTReader &Reader; 4962 4963 /// \brief The current index into the chain of AST files stored in 4964 /// the AST reader. 4965 unsigned Index; 4966 4967 /// \brief The current position within the identifier lookup table 4968 /// of the current AST file. 4969 ASTIdentifierLookupTable::key_iterator Current; 4970 4971 /// \brief The end position within the identifier lookup table of 4972 /// the current AST file. 4973 ASTIdentifierLookupTable::key_iterator End; 4974 4975 public: 4976 explicit ASTIdentifierIterator(const ASTReader &Reader); 4977 4978 virtual StringRef Next(); 4979 }; 4980} 4981 4982ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4983 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 4984 ASTIdentifierLookupTable *IdTable 4985 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 4986 Current = IdTable->key_begin(); 4987 End = IdTable->key_end(); 4988} 4989 4990StringRef ASTIdentifierIterator::Next() { 4991 while (Current == End) { 4992 // If we have exhausted all of our AST files, we're done. 4993 if (Index == 0) 4994 return StringRef(); 4995 4996 --Index; 4997 ASTIdentifierLookupTable *IdTable 4998 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 4999 IdentifierLookupTable; 5000 Current = IdTable->key_begin(); 5001 End = IdTable->key_end(); 5002 } 5003 5004 // We have any identifiers remaining in the current AST file; return 5005 // the next one. 5006 std::pair<const char*, unsigned> Key = *Current; 5007 ++Current; 5008 return StringRef(Key.first, Key.second); 5009} 5010 5011IdentifierIterator *ASTReader::getIdentifiers() const { 5012 return new ASTIdentifierIterator(*this); 5013} 5014 5015namespace clang { namespace serialization { 5016 class ReadMethodPoolVisitor { 5017 ASTReader &Reader; 5018 Selector Sel; 5019 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 5020 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 5021 5022 /// \brief Build an ObjCMethodList from a vector of Objective-C method 5023 /// declarations. 5024 ObjCMethodList 5025 buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const 5026 { 5027 ObjCMethodList List; 5028 ObjCMethodList *Prev = 0; 5029 for (unsigned I = 0, N = Vec.size(); I != N; ++I) { 5030 if (!List.Method) { 5031 // This is the first method, which is the easy case. 5032 List.Method = Vec[I]; 5033 Prev = &List; 5034 continue; 5035 } 5036 5037 ObjCMethodList *Mem = 5038 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 5039 Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0); 5040 Prev = Prev->Next; 5041 } 5042 5043 return List; 5044 } 5045 5046 public: 5047 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel) 5048 : Reader(Reader), Sel(Sel) { } 5049 5050 static bool visit(ModuleFile &M, void *UserData) { 5051 ReadMethodPoolVisitor *This 5052 = static_cast<ReadMethodPoolVisitor *>(UserData); 5053 5054 if (!M.SelectorLookupTable) 5055 return false; 5056 5057 ASTSelectorLookupTable *PoolTable 5058 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 5059 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 5060 if (Pos == PoolTable->end()) 5061 return false; 5062 5063 ++This->Reader.NumSelectorsRead; 5064 // FIXME: Not quite happy with the statistics here. We probably should 5065 // disable this tracking when called via LoadSelector. 5066 // Also, should entries without methods count as misses? 5067 ++This->Reader.NumMethodPoolEntriesRead; 5068 ASTSelectorLookupTrait::data_type Data = *Pos; 5069 if (This->Reader.DeserializationListener) 5070 This->Reader.DeserializationListener->SelectorRead(Data.ID, 5071 This->Sel); 5072 5073 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 5074 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 5075 return true; 5076 } 5077 5078 /// \brief Retrieve the instance methods found by this visitor. 5079 ObjCMethodList getInstanceMethods() const { 5080 return buildObjCMethodList(InstanceMethods); 5081 } 5082 5083 /// \brief Retrieve the instance methods found by this visitor. 5084 ObjCMethodList getFactoryMethods() const { 5085 return buildObjCMethodList(FactoryMethods); 5086 } 5087 }; 5088} } // end namespace clang::serialization 5089 5090std::pair<ObjCMethodList, ObjCMethodList> 5091ASTReader::ReadMethodPool(Selector Sel) { 5092 ReadMethodPoolVisitor Visitor(*this, Sel); 5093 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 5094 std::pair<ObjCMethodList, ObjCMethodList> Result; 5095 Result.first = Visitor.getInstanceMethods(); 5096 Result.second = Visitor.getFactoryMethods(); 5097 5098 if (!Result.first.Method && !Result.second.Method) 5099 ++NumMethodPoolMisses; 5100 return Result; 5101} 5102 5103void ASTReader::ReadKnownNamespaces( 5104 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 5105 Namespaces.clear(); 5106 5107 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 5108 if (NamespaceDecl *Namespace 5109 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 5110 Namespaces.push_back(Namespace); 5111 } 5112} 5113 5114void ASTReader::ReadTentativeDefinitions( 5115 SmallVectorImpl<VarDecl *> &TentativeDefs) { 5116 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 5117 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 5118 if (Var) 5119 TentativeDefs.push_back(Var); 5120 } 5121 TentativeDefinitions.clear(); 5122} 5123 5124void ASTReader::ReadUnusedFileScopedDecls( 5125 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 5126 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 5127 DeclaratorDecl *D 5128 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 5129 if (D) 5130 Decls.push_back(D); 5131 } 5132 UnusedFileScopedDecls.clear(); 5133} 5134 5135void ASTReader::ReadDelegatingConstructors( 5136 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 5137 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 5138 CXXConstructorDecl *D 5139 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 5140 if (D) 5141 Decls.push_back(D); 5142 } 5143 DelegatingCtorDecls.clear(); 5144} 5145 5146void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 5147 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 5148 TypedefNameDecl *D 5149 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 5150 if (D) 5151 Decls.push_back(D); 5152 } 5153 ExtVectorDecls.clear(); 5154} 5155 5156void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 5157 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 5158 CXXRecordDecl *D 5159 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 5160 if (D) 5161 Decls.push_back(D); 5162 } 5163 DynamicClasses.clear(); 5164} 5165 5166void 5167ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 5168 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 5169 NamedDecl *D 5170 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 5171 if (D) 5172 Decls.push_back(D); 5173 } 5174 LocallyScopedExternalDecls.clear(); 5175} 5176 5177void ASTReader::ReadReferencedSelectors( 5178 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 5179 if (ReferencedSelectorsData.empty()) 5180 return; 5181 5182 // If there are @selector references added them to its pool. This is for 5183 // implementation of -Wselector. 5184 unsigned int DataSize = ReferencedSelectorsData.size()-1; 5185 unsigned I = 0; 5186 while (I < DataSize) { 5187 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 5188 SourceLocation SelLoc 5189 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 5190 Sels.push_back(std::make_pair(Sel, SelLoc)); 5191 } 5192 ReferencedSelectorsData.clear(); 5193} 5194 5195void ASTReader::ReadWeakUndeclaredIdentifiers( 5196 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 5197 if (WeakUndeclaredIdentifiers.empty()) 5198 return; 5199 5200 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 5201 IdentifierInfo *WeakId 5202 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5203 IdentifierInfo *AliasId 5204 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5205 SourceLocation Loc 5206 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 5207 bool Used = WeakUndeclaredIdentifiers[I++]; 5208 WeakInfo WI(AliasId, Loc); 5209 WI.setUsed(Used); 5210 WeakIDs.push_back(std::make_pair(WeakId, WI)); 5211 } 5212 WeakUndeclaredIdentifiers.clear(); 5213} 5214 5215void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 5216 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 5217 ExternalVTableUse VT; 5218 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 5219 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 5220 VT.DefinitionRequired = VTableUses[Idx++]; 5221 VTables.push_back(VT); 5222 } 5223 5224 VTableUses.clear(); 5225} 5226 5227void ASTReader::ReadPendingInstantiations( 5228 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 5229 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 5230 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 5231 SourceLocation Loc 5232 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 5233 Pending.push_back(std::make_pair(D, Loc)); 5234 } 5235 PendingInstantiations.clear(); 5236} 5237 5238void ASTReader::LoadSelector(Selector Sel) { 5239 // It would be complicated to avoid reading the methods anyway. So don't. 5240 ReadMethodPool(Sel); 5241} 5242 5243void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 5244 assert(ID && "Non-zero identifier ID required"); 5245 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 5246 IdentifiersLoaded[ID - 1] = II; 5247 if (DeserializationListener) 5248 DeserializationListener->IdentifierRead(ID, II); 5249} 5250 5251/// \brief Set the globally-visible declarations associated with the given 5252/// identifier. 5253/// 5254/// If the AST reader is currently in a state where the given declaration IDs 5255/// cannot safely be resolved, they are queued until it is safe to resolve 5256/// them. 5257/// 5258/// \param II an IdentifierInfo that refers to one or more globally-visible 5259/// declarations. 5260/// 5261/// \param DeclIDs the set of declaration IDs with the name @p II that are 5262/// visible at global scope. 5263/// 5264/// \param Nonrecursive should be true to indicate that the caller knows that 5265/// this call is non-recursive, and therefore the globally-visible declarations 5266/// will not be placed onto the pending queue. 5267void 5268ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 5269 const SmallVectorImpl<uint32_t> &DeclIDs, 5270 bool Nonrecursive) { 5271 if (NumCurrentElementsDeserializing && !Nonrecursive) { 5272 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 5273 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 5274 PII.II = II; 5275 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 5276 return; 5277 } 5278 5279 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 5280 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 5281 if (SemaObj) { 5282 // Introduce this declaration into the translation-unit scope 5283 // and add it to the declaration chain for this identifier, so 5284 // that (unqualified) name lookup will find it. 5285 SemaObj->pushExternalDeclIntoScope(D, II); 5286 } else { 5287 // Queue this declaration so that it will be added to the 5288 // translation unit scope and identifier's declaration chain 5289 // once a Sema object is known. 5290 PreloadedDecls.push_back(D); 5291 } 5292 } 5293} 5294 5295IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 5296 if (ID == 0) 5297 return 0; 5298 5299 if (IdentifiersLoaded.empty()) { 5300 Error("no identifier table in AST file"); 5301 return 0; 5302 } 5303 5304 ID -= 1; 5305 if (!IdentifiersLoaded[ID]) { 5306 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 5307 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 5308 ModuleFile *M = I->second; 5309 unsigned Index = ID - M->BaseIdentifierID; 5310 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 5311 5312 // All of the strings in the AST file are preceded by a 16-bit length. 5313 // Extract that 16-bit length to avoid having to execute strlen(). 5314 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 5315 // unsigned integers. This is important to avoid integer overflow when 5316 // we cast them to 'unsigned'. 5317 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 5318 unsigned StrLen = (((unsigned) StrLenPtr[0]) 5319 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 5320 IdentifiersLoaded[ID] 5321 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 5322 if (DeserializationListener) 5323 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 5324 } 5325 5326 return IdentifiersLoaded[ID]; 5327} 5328 5329IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 5330 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 5331} 5332 5333IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 5334 if (LocalID < NUM_PREDEF_IDENT_IDS) 5335 return LocalID; 5336 5337 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5338 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 5339 assert(I != M.IdentifierRemap.end() 5340 && "Invalid index into identifier index remap"); 5341 5342 return LocalID + I->second; 5343} 5344 5345bool ASTReader::ReadSLocEntry(int ID) { 5346 return ReadSLocEntryRecord(ID) != Success; 5347} 5348 5349serialization::SubmoduleID 5350ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 5351 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 5352 return LocalID; 5353 5354 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5355 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 5356 assert(I != M.SubmoduleRemap.end() 5357 && "Invalid index into identifier index remap"); 5358 5359 return LocalID + I->second; 5360} 5361 5362Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 5363 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 5364 assert(GlobalID == 0 && "Unhandled global submodule ID"); 5365 return 0; 5366 } 5367 5368 if (GlobalID > SubmodulesLoaded.size()) { 5369 Error("submodule ID out of range in AST file"); 5370 return 0; 5371 } 5372 5373 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 5374} 5375 5376Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 5377 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 5378} 5379 5380Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 5381 if (ID == 0) 5382 return Selector(); 5383 5384 if (ID > SelectorsLoaded.size()) { 5385 Error("selector ID out of range in AST file"); 5386 return Selector(); 5387 } 5388 5389 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 5390 // Load this selector from the selector table. 5391 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 5392 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 5393 ModuleFile &M = *I->second; 5394 ASTSelectorLookupTrait Trait(*this, M); 5395 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 5396 SelectorsLoaded[ID - 1] = 5397 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 5398 if (DeserializationListener) 5399 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 5400 } 5401 5402 return SelectorsLoaded[ID - 1]; 5403} 5404 5405Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 5406 return DecodeSelector(ID); 5407} 5408 5409uint32_t ASTReader::GetNumExternalSelectors() { 5410 // ID 0 (the null selector) is considered an external selector. 5411 return getTotalNumSelectors() + 1; 5412} 5413 5414serialization::SelectorID 5415ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 5416 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 5417 return LocalID; 5418 5419 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5420 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 5421 assert(I != M.SelectorRemap.end() 5422 && "Invalid index into identifier index remap"); 5423 5424 return LocalID + I->second; 5425} 5426 5427DeclarationName 5428ASTReader::ReadDeclarationName(ModuleFile &F, 5429 const RecordData &Record, unsigned &Idx) { 5430 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 5431 switch (Kind) { 5432 case DeclarationName::Identifier: 5433 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 5434 5435 case DeclarationName::ObjCZeroArgSelector: 5436 case DeclarationName::ObjCOneArgSelector: 5437 case DeclarationName::ObjCMultiArgSelector: 5438 return DeclarationName(ReadSelector(F, Record, Idx)); 5439 5440 case DeclarationName::CXXConstructorName: 5441 return Context.DeclarationNames.getCXXConstructorName( 5442 Context.getCanonicalType(readType(F, Record, Idx))); 5443 5444 case DeclarationName::CXXDestructorName: 5445 return Context.DeclarationNames.getCXXDestructorName( 5446 Context.getCanonicalType(readType(F, Record, Idx))); 5447 5448 case DeclarationName::CXXConversionFunctionName: 5449 return Context.DeclarationNames.getCXXConversionFunctionName( 5450 Context.getCanonicalType(readType(F, Record, Idx))); 5451 5452 case DeclarationName::CXXOperatorName: 5453 return Context.DeclarationNames.getCXXOperatorName( 5454 (OverloadedOperatorKind)Record[Idx++]); 5455 5456 case DeclarationName::CXXLiteralOperatorName: 5457 return Context.DeclarationNames.getCXXLiteralOperatorName( 5458 GetIdentifierInfo(F, Record, Idx)); 5459 5460 case DeclarationName::CXXUsingDirective: 5461 return DeclarationName::getUsingDirectiveName(); 5462 } 5463 5464 // Required to silence GCC warning 5465 return DeclarationName(); 5466} 5467 5468void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 5469 DeclarationNameLoc &DNLoc, 5470 DeclarationName Name, 5471 const RecordData &Record, unsigned &Idx) { 5472 switch (Name.getNameKind()) { 5473 case DeclarationName::CXXConstructorName: 5474 case DeclarationName::CXXDestructorName: 5475 case DeclarationName::CXXConversionFunctionName: 5476 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 5477 break; 5478 5479 case DeclarationName::CXXOperatorName: 5480 DNLoc.CXXOperatorName.BeginOpNameLoc 5481 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5482 DNLoc.CXXOperatorName.EndOpNameLoc 5483 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5484 break; 5485 5486 case DeclarationName::CXXLiteralOperatorName: 5487 DNLoc.CXXLiteralOperatorName.OpNameLoc 5488 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5489 break; 5490 5491 case DeclarationName::Identifier: 5492 case DeclarationName::ObjCZeroArgSelector: 5493 case DeclarationName::ObjCOneArgSelector: 5494 case DeclarationName::ObjCMultiArgSelector: 5495 case DeclarationName::CXXUsingDirective: 5496 break; 5497 } 5498} 5499 5500void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 5501 DeclarationNameInfo &NameInfo, 5502 const RecordData &Record, unsigned &Idx) { 5503 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 5504 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 5505 DeclarationNameLoc DNLoc; 5506 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5507 NameInfo.setInfo(DNLoc); 5508} 5509 5510void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 5511 const RecordData &Record, unsigned &Idx) { 5512 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5513 unsigned NumTPLists = Record[Idx++]; 5514 Info.NumTemplParamLists = NumTPLists; 5515 if (NumTPLists) { 5516 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 5517 for (unsigned i=0; i != NumTPLists; ++i) 5518 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5519 } 5520} 5521 5522TemplateName 5523ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 5524 unsigned &Idx) { 5525 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5526 switch (Kind) { 5527 case TemplateName::Template: 5528 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5529 5530 case TemplateName::OverloadedTemplate: { 5531 unsigned size = Record[Idx++]; 5532 UnresolvedSet<8> Decls; 5533 while (size--) 5534 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5535 5536 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 5537 } 5538 5539 case TemplateName::QualifiedTemplate: { 5540 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5541 bool hasTemplKeyword = Record[Idx++]; 5542 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5543 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5544 } 5545 5546 case TemplateName::DependentTemplate: { 5547 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5548 if (Record[Idx++]) // isIdentifier 5549 return Context.getDependentTemplateName(NNS, 5550 GetIdentifierInfo(F, Record, 5551 Idx)); 5552 return Context.getDependentTemplateName(NNS, 5553 (OverloadedOperatorKind)Record[Idx++]); 5554 } 5555 5556 case TemplateName::SubstTemplateTemplateParm: { 5557 TemplateTemplateParmDecl *param 5558 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5559 if (!param) return TemplateName(); 5560 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5561 return Context.getSubstTemplateTemplateParm(param, replacement); 5562 } 5563 5564 case TemplateName::SubstTemplateTemplateParmPack: { 5565 TemplateTemplateParmDecl *Param 5566 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5567 if (!Param) 5568 return TemplateName(); 5569 5570 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5571 if (ArgPack.getKind() != TemplateArgument::Pack) 5572 return TemplateName(); 5573 5574 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 5575 } 5576 } 5577 5578 llvm_unreachable("Unhandled template name kind!"); 5579} 5580 5581TemplateArgument 5582ASTReader::ReadTemplateArgument(ModuleFile &F, 5583 const RecordData &Record, unsigned &Idx) { 5584 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5585 switch (Kind) { 5586 case TemplateArgument::Null: 5587 return TemplateArgument(); 5588 case TemplateArgument::Type: 5589 return TemplateArgument(readType(F, Record, Idx)); 5590 case TemplateArgument::Declaration: 5591 return TemplateArgument(ReadDecl(F, Record, Idx)); 5592 case TemplateArgument::Integral: { 5593 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5594 QualType T = readType(F, Record, Idx); 5595 return TemplateArgument(Value, T); 5596 } 5597 case TemplateArgument::Template: 5598 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5599 case TemplateArgument::TemplateExpansion: { 5600 TemplateName Name = ReadTemplateName(F, Record, Idx); 5601 llvm::Optional<unsigned> NumTemplateExpansions; 5602 if (unsigned NumExpansions = Record[Idx++]) 5603 NumTemplateExpansions = NumExpansions - 1; 5604 return TemplateArgument(Name, NumTemplateExpansions); 5605 } 5606 case TemplateArgument::Expression: 5607 return TemplateArgument(ReadExpr(F)); 5608 case TemplateArgument::Pack: { 5609 unsigned NumArgs = Record[Idx++]; 5610 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 5611 for (unsigned I = 0; I != NumArgs; ++I) 5612 Args[I] = ReadTemplateArgument(F, Record, Idx); 5613 return TemplateArgument(Args, NumArgs); 5614 } 5615 } 5616 5617 llvm_unreachable("Unhandled template argument kind!"); 5618} 5619 5620TemplateParameterList * 5621ASTReader::ReadTemplateParameterList(ModuleFile &F, 5622 const RecordData &Record, unsigned &Idx) { 5623 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5624 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5625 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5626 5627 unsigned NumParams = Record[Idx++]; 5628 SmallVector<NamedDecl *, 16> Params; 5629 Params.reserve(NumParams); 5630 while (NumParams--) 5631 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5632 5633 TemplateParameterList* TemplateParams = 5634 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 5635 Params.data(), Params.size(), RAngleLoc); 5636 return TemplateParams; 5637} 5638 5639void 5640ASTReader:: 5641ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5642 ModuleFile &F, const RecordData &Record, 5643 unsigned &Idx) { 5644 unsigned NumTemplateArgs = Record[Idx++]; 5645 TemplArgs.reserve(NumTemplateArgs); 5646 while (NumTemplateArgs--) 5647 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5648} 5649 5650/// \brief Read a UnresolvedSet structure. 5651void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set, 5652 const RecordData &Record, unsigned &Idx) { 5653 unsigned NumDecls = Record[Idx++]; 5654 while (NumDecls--) { 5655 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5656 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5657 Set.addDecl(D, AS); 5658 } 5659} 5660 5661CXXBaseSpecifier 5662ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 5663 const RecordData &Record, unsigned &Idx) { 5664 bool isVirtual = static_cast<bool>(Record[Idx++]); 5665 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5666 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5667 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5668 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5669 SourceRange Range = ReadSourceRange(F, Record, Idx); 5670 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5671 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5672 EllipsisLoc); 5673 Result.setInheritConstructors(inheritConstructors); 5674 return Result; 5675} 5676 5677std::pair<CXXCtorInitializer **, unsigned> 5678ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 5679 unsigned &Idx) { 5680 CXXCtorInitializer **CtorInitializers = 0; 5681 unsigned NumInitializers = Record[Idx++]; 5682 if (NumInitializers) { 5683 CtorInitializers 5684 = new (Context) CXXCtorInitializer*[NumInitializers]; 5685 for (unsigned i=0; i != NumInitializers; ++i) { 5686 TypeSourceInfo *TInfo = 0; 5687 bool IsBaseVirtual = false; 5688 FieldDecl *Member = 0; 5689 IndirectFieldDecl *IndirectMember = 0; 5690 5691 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5692 switch (Type) { 5693 case CTOR_INITIALIZER_BASE: 5694 TInfo = GetTypeSourceInfo(F, Record, Idx); 5695 IsBaseVirtual = Record[Idx++]; 5696 break; 5697 5698 case CTOR_INITIALIZER_DELEGATING: 5699 TInfo = GetTypeSourceInfo(F, Record, Idx); 5700 break; 5701 5702 case CTOR_INITIALIZER_MEMBER: 5703 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5704 break; 5705 5706 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5707 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5708 break; 5709 } 5710 5711 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5712 Expr *Init = ReadExpr(F); 5713 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5714 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5715 bool IsWritten = Record[Idx++]; 5716 unsigned SourceOrderOrNumArrayIndices; 5717 SmallVector<VarDecl *, 8> Indices; 5718 if (IsWritten) { 5719 SourceOrderOrNumArrayIndices = Record[Idx++]; 5720 } else { 5721 SourceOrderOrNumArrayIndices = Record[Idx++]; 5722 Indices.reserve(SourceOrderOrNumArrayIndices); 5723 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5724 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5725 } 5726 5727 CXXCtorInitializer *BOMInit; 5728 if (Type == CTOR_INITIALIZER_BASE) { 5729 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 5730 LParenLoc, Init, RParenLoc, 5731 MemberOrEllipsisLoc); 5732 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5733 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 5734 Init, RParenLoc); 5735 } else if (IsWritten) { 5736 if (Member) 5737 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 5738 LParenLoc, Init, RParenLoc); 5739 else 5740 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 5741 MemberOrEllipsisLoc, LParenLoc, 5742 Init, RParenLoc); 5743 } else { 5744 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 5745 LParenLoc, Init, RParenLoc, 5746 Indices.data(), Indices.size()); 5747 } 5748 5749 if (IsWritten) 5750 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5751 CtorInitializers[i] = BOMInit; 5752 } 5753 } 5754 5755 return std::make_pair(CtorInitializers, NumInitializers); 5756} 5757 5758NestedNameSpecifier * 5759ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 5760 const RecordData &Record, unsigned &Idx) { 5761 unsigned N = Record[Idx++]; 5762 NestedNameSpecifier *NNS = 0, *Prev = 0; 5763 for (unsigned I = 0; I != N; ++I) { 5764 NestedNameSpecifier::SpecifierKind Kind 5765 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5766 switch (Kind) { 5767 case NestedNameSpecifier::Identifier: { 5768 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5769 NNS = NestedNameSpecifier::Create(Context, Prev, II); 5770 break; 5771 } 5772 5773 case NestedNameSpecifier::Namespace: { 5774 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5775 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 5776 break; 5777 } 5778 5779 case NestedNameSpecifier::NamespaceAlias: { 5780 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5781 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 5782 break; 5783 } 5784 5785 case NestedNameSpecifier::TypeSpec: 5786 case NestedNameSpecifier::TypeSpecWithTemplate: { 5787 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5788 if (!T) 5789 return 0; 5790 5791 bool Template = Record[Idx++]; 5792 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 5793 break; 5794 } 5795 5796 case NestedNameSpecifier::Global: { 5797 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 5798 // No associated value, and there can't be a prefix. 5799 break; 5800 } 5801 } 5802 Prev = NNS; 5803 } 5804 return NNS; 5805} 5806 5807NestedNameSpecifierLoc 5808ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 5809 unsigned &Idx) { 5810 unsigned N = Record[Idx++]; 5811 NestedNameSpecifierLocBuilder Builder; 5812 for (unsigned I = 0; I != N; ++I) { 5813 NestedNameSpecifier::SpecifierKind Kind 5814 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5815 switch (Kind) { 5816 case NestedNameSpecifier::Identifier: { 5817 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5818 SourceRange Range = ReadSourceRange(F, Record, Idx); 5819 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 5820 break; 5821 } 5822 5823 case NestedNameSpecifier::Namespace: { 5824 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5825 SourceRange Range = ReadSourceRange(F, Record, Idx); 5826 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 5827 break; 5828 } 5829 5830 case NestedNameSpecifier::NamespaceAlias: { 5831 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5832 SourceRange Range = ReadSourceRange(F, Record, Idx); 5833 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 5834 break; 5835 } 5836 5837 case NestedNameSpecifier::TypeSpec: 5838 case NestedNameSpecifier::TypeSpecWithTemplate: { 5839 bool Template = Record[Idx++]; 5840 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5841 if (!T) 5842 return NestedNameSpecifierLoc(); 5843 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5844 5845 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5846 Builder.Extend(Context, 5847 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5848 T->getTypeLoc(), ColonColonLoc); 5849 break; 5850 } 5851 5852 case NestedNameSpecifier::Global: { 5853 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5854 Builder.MakeGlobal(Context, ColonColonLoc); 5855 break; 5856 } 5857 } 5858 } 5859 5860 return Builder.getWithLocInContext(Context); 5861} 5862 5863SourceRange 5864ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 5865 unsigned &Idx) { 5866 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5867 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5868 return SourceRange(beg, end); 5869} 5870 5871/// \brief Read an integral value 5872llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5873 unsigned BitWidth = Record[Idx++]; 5874 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5875 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5876 Idx += NumWords; 5877 return Result; 5878} 5879 5880/// \brief Read a signed integral value 5881llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5882 bool isUnsigned = Record[Idx++]; 5883 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5884} 5885 5886/// \brief Read a floating-point value 5887llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5888 return llvm::APFloat(ReadAPInt(Record, Idx)); 5889} 5890 5891// \brief Read a string 5892std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5893 unsigned Len = Record[Idx++]; 5894 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5895 Idx += Len; 5896 return Result; 5897} 5898 5899VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5900 unsigned &Idx) { 5901 unsigned Major = Record[Idx++]; 5902 unsigned Minor = Record[Idx++]; 5903 unsigned Subminor = Record[Idx++]; 5904 if (Minor == 0) 5905 return VersionTuple(Major); 5906 if (Subminor == 0) 5907 return VersionTuple(Major, Minor - 1); 5908 return VersionTuple(Major, Minor - 1, Subminor - 1); 5909} 5910 5911CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 5912 const RecordData &Record, 5913 unsigned &Idx) { 5914 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5915 return CXXTemporary::Create(Context, Decl); 5916} 5917 5918DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5919 return Diag(SourceLocation(), DiagID); 5920} 5921 5922DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5923 return Diags.Report(Loc, DiagID); 5924} 5925 5926/// \brief Retrieve the identifier table associated with the 5927/// preprocessor. 5928IdentifierTable &ASTReader::getIdentifierTable() { 5929 return PP.getIdentifierTable(); 5930} 5931 5932/// \brief Record that the given ID maps to the given switch-case 5933/// statement. 5934void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5935 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5936 SwitchCaseStmts[ID] = SC; 5937} 5938 5939/// \brief Retrieve the switch-case statement with the given ID. 5940SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5941 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5942 return SwitchCaseStmts[ID]; 5943} 5944 5945void ASTReader::ClearSwitchCaseIDs() { 5946 SwitchCaseStmts.clear(); 5947} 5948 5949void ASTReader::FinishedDeserializing() { 5950 assert(NumCurrentElementsDeserializing && 5951 "FinishedDeserializing not paired with StartedDeserializing"); 5952 if (NumCurrentElementsDeserializing == 1) { 5953 do { 5954 // If any identifiers with corresponding top-level declarations have 5955 // been loaded, load those declarations now. 5956 while (!PendingIdentifierInfos.empty()) { 5957 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5958 PendingIdentifierInfos.front().DeclIDs, true); 5959 PendingIdentifierInfos.pop_front(); 5960 } 5961 5962 // Ready to load previous declarations of Decls that were delayed. 5963 while (!PendingPreviousDecls.empty()) { 5964 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5965 PendingPreviousDecls.front().second); 5966 PendingPreviousDecls.pop_front(); 5967 } 5968 5969 for (std::vector<std::pair<ObjCInterfaceDecl *, 5970 serialization::DeclID> >::iterator 5971 I = PendingChainedObjCCategories.begin(), 5972 E = PendingChainedObjCCategories.end(); I != E; ++I) { 5973 loadObjCChainedCategories(I->second, I->first); 5974 } 5975 PendingChainedObjCCategories.clear(); 5976 5977 // We are not in recursive loading, so it's safe to pass the "interesting" 5978 // decls to the consumer. 5979 if (Consumer && !InterestingDecls.empty()) { 5980 Decl *D = InterestingDecls.front(); 5981 InterestingDecls.pop_front(); 5982 5983 PassInterestingDeclToConsumer(D); 5984 } 5985 5986 } while ((Consumer && !InterestingDecls.empty()) || 5987 !PendingIdentifierInfos.empty() || 5988 !PendingPreviousDecls.empty() || 5989 !PendingChainedObjCCategories.empty()); 5990 5991 assert(PendingForwardRefs.size() == 0 && 5992 "Some forward refs did not get linked to the definition!"); 5993 } 5994 --NumCurrentElementsDeserializing; 5995} 5996 5997ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 5998 StringRef isysroot, bool DisableValidation, 5999 bool DisableStatCache) 6000 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 6001 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 6002 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 6003 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 6004 RelocatablePCH(false), isysroot(isysroot), 6005 DisableValidation(DisableValidation), 6006 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 6007 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 6008 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 6009 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 6010 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 6011 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 6012 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 6013 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 6014 NumCXXBaseSpecifiersLoaded(0) 6015{ 6016 SourceMgr.setExternalSLocEntrySource(this); 6017} 6018 6019ASTReader::~ASTReader() { 6020 for (DeclContextVisibleUpdatesPending::iterator 6021 I = PendingVisibleUpdates.begin(), 6022 E = PendingVisibleUpdates.end(); 6023 I != E; ++I) { 6024 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 6025 F = I->second.end(); 6026 J != F; ++J) 6027 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 6028 } 6029} 6030