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