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