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