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