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