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