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