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