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