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