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