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