ASTReader.cpp revision 1b2c3c0884e917ae5d59edde7d93b2af33c6a1b6
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 DIAGNOSTIC_OPTIONS: { 2011 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2012 if (Listener && &F == *ModuleMgr.begin() && 2013 ParseDiagnosticOptions(Record, Complain, *Listener) && 2014 !DisableValidation) 2015 return ConfigurationMismatch; 2016 break; 2017 } 2018 2019 case FILE_SYSTEM_OPTIONS: { 2020 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2021 if (Listener && &F == *ModuleMgr.begin() && 2022 ParseFileSystemOptions(Record, Complain, *Listener) && 2023 !DisableValidation) 2024 return ConfigurationMismatch; 2025 break; 2026 } 2027 2028 case ORIGINAL_FILE: 2029 F.OriginalSourceFileID = FileID::get(Record[0]); 2030 F.ActualOriginalSourceFileName.assign(BlobStart, BlobLen); 2031 F.OriginalSourceFileName = F.ActualOriginalSourceFileName; 2032 MaybeAddSystemRootToFilename(F, F.OriginalSourceFileName); 2033 break; 2034 2035 case ORIGINAL_PCH_DIR: 2036 F.OriginalDir.assign(BlobStart, BlobLen); 2037 break; 2038 2039 case INPUT_FILE_OFFSETS: 2040 F.InputFileOffsets = (const uint32_t *)BlobStart; 2041 F.InputFilesLoaded.resize(Record[0]); 2042 break; 2043 } 2044 } 2045 2046 Error("premature end of bitstream in AST file"); 2047 return Failure; 2048} 2049 2050bool ASTReader::ReadASTBlock(ModuleFile &F) { 2051 llvm::BitstreamCursor &Stream = F.Stream; 2052 2053 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2054 Error("malformed block record in AST file"); 2055 return true; 2056 } 2057 2058 // Read all of the records and blocks for the AST file. 2059 RecordData Record; 2060 while (!Stream.AtEndOfStream()) { 2061 unsigned Code = Stream.ReadCode(); 2062 if (Code == llvm::bitc::END_BLOCK) { 2063 if (Stream.ReadBlockEnd()) { 2064 Error("error at end of module block in AST file"); 2065 return true; 2066 } 2067 2068 DeclContext *DC = Context.getTranslationUnitDecl(); 2069 if (!DC->hasExternalVisibleStorage() && DC->hasExternalLexicalStorage()) 2070 DC->setMustBuildLookupTable(); 2071 2072 return false; 2073 } 2074 2075 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2076 switch (Stream.ReadSubBlockID()) { 2077 case DECLTYPES_BLOCK_ID: 2078 // We lazily load the decls block, but we want to set up the 2079 // DeclsCursor cursor to point into it. Clone our current bitcode 2080 // cursor to it, enter the block and read the abbrevs in that block. 2081 // With the main cursor, we just skip over it. 2082 F.DeclsCursor = Stream; 2083 if (Stream.SkipBlock() || // Skip with the main cursor. 2084 // Read the abbrevs. 2085 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 2086 Error("malformed block record in AST file"); 2087 return true; 2088 } 2089 break; 2090 2091 case DECL_UPDATES_BLOCK_ID: 2092 if (Stream.SkipBlock()) { 2093 Error("malformed block record in AST file"); 2094 return true; 2095 } 2096 break; 2097 2098 case PREPROCESSOR_BLOCK_ID: 2099 F.MacroCursor = Stream; 2100 if (!PP.getExternalSource()) 2101 PP.setExternalSource(this); 2102 2103 if (Stream.SkipBlock() || 2104 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 2105 Error("malformed block record in AST file"); 2106 return true; 2107 } 2108 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 2109 break; 2110 2111 case PREPROCESSOR_DETAIL_BLOCK_ID: 2112 F.PreprocessorDetailCursor = Stream; 2113 if (Stream.SkipBlock() || 2114 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 2115 PREPROCESSOR_DETAIL_BLOCK_ID)) { 2116 Error("malformed preprocessor detail record in AST file"); 2117 return true; 2118 } 2119 F.PreprocessorDetailStartOffset 2120 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 2121 2122 if (!PP.getPreprocessingRecord()) 2123 PP.createPreprocessingRecord(/*RecordConditionalDirectives=*/false); 2124 if (!PP.getPreprocessingRecord()->getExternalSource()) 2125 PP.getPreprocessingRecord()->SetExternalSource(*this); 2126 break; 2127 2128 case SOURCE_MANAGER_BLOCK_ID: 2129 if (ReadSourceManagerBlock(F)) 2130 return true; 2131 break; 2132 2133 case SUBMODULE_BLOCK_ID: 2134 if (ReadSubmoduleBlock(F)) 2135 return true; 2136 break; 2137 2138 case COMMENTS_BLOCK_ID: { 2139 llvm::BitstreamCursor C = Stream; 2140 if (Stream.SkipBlock() || 2141 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) { 2142 Error("malformed comments block in AST file"); 2143 return true; 2144 } 2145 CommentsCursors.push_back(std::make_pair(C, &F)); 2146 break; 2147 } 2148 2149 default: 2150 if (!Stream.SkipBlock()) 2151 break; 2152 Error("malformed block record in AST file"); 2153 return true; 2154 } 2155 continue; 2156 } 2157 2158 if (Code == llvm::bitc::DEFINE_ABBREV) { 2159 Stream.ReadAbbrevRecord(); 2160 continue; 2161 } 2162 2163 // Read and process a record. 2164 Record.clear(); 2165 const char *BlobStart = 0; 2166 unsigned BlobLen = 0; 2167 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 2168 &BlobStart, &BlobLen)) { 2169 default: // Default behavior: ignore. 2170 break; 2171 2172 case TYPE_OFFSET: { 2173 if (F.LocalNumTypes != 0) { 2174 Error("duplicate TYPE_OFFSET record in AST file"); 2175 return true; 2176 } 2177 F.TypeOffsets = (const uint32_t *)BlobStart; 2178 F.LocalNumTypes = Record[0]; 2179 unsigned LocalBaseTypeIndex = Record[1]; 2180 F.BaseTypeIndex = getTotalNumTypes(); 2181 2182 if (F.LocalNumTypes > 0) { 2183 // Introduce the global -> local mapping for types within this module. 2184 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 2185 2186 // Introduce the local -> global mapping for types within this module. 2187 F.TypeRemap.insertOrReplace( 2188 std::make_pair(LocalBaseTypeIndex, 2189 F.BaseTypeIndex - LocalBaseTypeIndex)); 2190 2191 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 2192 } 2193 break; 2194 } 2195 2196 case DECL_OFFSET: { 2197 if (F.LocalNumDecls != 0) { 2198 Error("duplicate DECL_OFFSET record in AST file"); 2199 return true; 2200 } 2201 F.DeclOffsets = (const DeclOffset *)BlobStart; 2202 F.LocalNumDecls = Record[0]; 2203 unsigned LocalBaseDeclID = Record[1]; 2204 F.BaseDeclID = getTotalNumDecls(); 2205 2206 if (F.LocalNumDecls > 0) { 2207 // Introduce the global -> local mapping for declarations within this 2208 // module. 2209 GlobalDeclMap.insert( 2210 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 2211 2212 // Introduce the local -> global mapping for declarations within this 2213 // module. 2214 F.DeclRemap.insertOrReplace( 2215 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID)); 2216 2217 // Introduce the global -> local mapping for declarations within this 2218 // module. 2219 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID; 2220 2221 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 2222 } 2223 break; 2224 } 2225 2226 case TU_UPDATE_LEXICAL: { 2227 DeclContext *TU = Context.getTranslationUnitDecl(); 2228 DeclContextInfo &Info = F.DeclContextInfos[TU]; 2229 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(BlobStart); 2230 Info.NumLexicalDecls 2231 = static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair)); 2232 TU->setHasExternalLexicalStorage(true); 2233 break; 2234 } 2235 2236 case UPDATE_VISIBLE: { 2237 unsigned Idx = 0; 2238 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 2239 ASTDeclContextNameLookupTable *Table = 2240 ASTDeclContextNameLookupTable::Create( 2241 (const unsigned char *)BlobStart + Record[Idx++], 2242 (const unsigned char *)BlobStart, 2243 ASTDeclContextNameLookupTrait(*this, F)); 2244 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU? 2245 DeclContext *TU = Context.getTranslationUnitDecl(); 2246 F.DeclContextInfos[TU].NameLookupTableData = Table; 2247 TU->setHasExternalVisibleStorage(true); 2248 } else 2249 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 2250 break; 2251 } 2252 2253 case IDENTIFIER_TABLE: 2254 F.IdentifierTableData = BlobStart; 2255 if (Record[0]) { 2256 F.IdentifierLookupTable 2257 = ASTIdentifierLookupTable::Create( 2258 (const unsigned char *)F.IdentifierTableData + Record[0], 2259 (const unsigned char *)F.IdentifierTableData, 2260 ASTIdentifierLookupTrait(*this, F)); 2261 2262 PP.getIdentifierTable().setExternalIdentifierLookup(this); 2263 } 2264 break; 2265 2266 case IDENTIFIER_OFFSET: { 2267 if (F.LocalNumIdentifiers != 0) { 2268 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2269 return true; 2270 } 2271 F.IdentifierOffsets = (const uint32_t *)BlobStart; 2272 F.LocalNumIdentifiers = Record[0]; 2273 unsigned LocalBaseIdentifierID = Record[1]; 2274 F.BaseIdentifierID = getTotalNumIdentifiers(); 2275 2276 if (F.LocalNumIdentifiers > 0) { 2277 // Introduce the global -> local mapping for identifiers within this 2278 // module. 2279 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 2280 &F)); 2281 2282 // Introduce the local -> global mapping for identifiers within this 2283 // module. 2284 F.IdentifierRemap.insertOrReplace( 2285 std::make_pair(LocalBaseIdentifierID, 2286 F.BaseIdentifierID - LocalBaseIdentifierID)); 2287 2288 IdentifiersLoaded.resize(IdentifiersLoaded.size() 2289 + F.LocalNumIdentifiers); 2290 } 2291 break; 2292 } 2293 2294 case EXTERNAL_DEFINITIONS: 2295 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2296 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2297 break; 2298 2299 case SPECIAL_TYPES: 2300 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2301 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 2302 break; 2303 2304 case STATISTICS: 2305 TotalNumStatements += Record[0]; 2306 TotalNumMacros += Record[1]; 2307 TotalLexicalDeclContexts += Record[2]; 2308 TotalVisibleDeclContexts += Record[3]; 2309 break; 2310 2311 case UNUSED_FILESCOPED_DECLS: 2312 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2313 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 2314 break; 2315 2316 case DELEGATING_CTORS: 2317 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2318 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 2319 break; 2320 2321 case WEAK_UNDECLARED_IDENTIFIERS: 2322 if (Record.size() % 4 != 0) { 2323 Error("invalid weak identifiers record"); 2324 return true; 2325 } 2326 2327 // FIXME: Ignore weak undeclared identifiers from non-original PCH 2328 // files. This isn't the way to do it :) 2329 WeakUndeclaredIdentifiers.clear(); 2330 2331 // Translate the weak, undeclared identifiers into global IDs. 2332 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 2333 WeakUndeclaredIdentifiers.push_back( 2334 getGlobalIdentifierID(F, Record[I++])); 2335 WeakUndeclaredIdentifiers.push_back( 2336 getGlobalIdentifierID(F, Record[I++])); 2337 WeakUndeclaredIdentifiers.push_back( 2338 ReadSourceLocation(F, Record, I).getRawEncoding()); 2339 WeakUndeclaredIdentifiers.push_back(Record[I++]); 2340 } 2341 break; 2342 2343 case LOCALLY_SCOPED_EXTERNAL_DECLS: 2344 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2345 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I])); 2346 break; 2347 2348 case SELECTOR_OFFSETS: { 2349 F.SelectorOffsets = (const uint32_t *)BlobStart; 2350 F.LocalNumSelectors = Record[0]; 2351 unsigned LocalBaseSelectorID = Record[1]; 2352 F.BaseSelectorID = getTotalNumSelectors(); 2353 2354 if (F.LocalNumSelectors > 0) { 2355 // Introduce the global -> local mapping for selectors within this 2356 // module. 2357 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2358 2359 // Introduce the local -> global mapping for selectors within this 2360 // module. 2361 F.SelectorRemap.insertOrReplace( 2362 std::make_pair(LocalBaseSelectorID, 2363 F.BaseSelectorID - LocalBaseSelectorID)); 2364 2365 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2366 } 2367 break; 2368 } 2369 2370 case METHOD_POOL: 2371 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 2372 if (Record[0]) 2373 F.SelectorLookupTable 2374 = ASTSelectorLookupTable::Create( 2375 F.SelectorLookupTableData + Record[0], 2376 F.SelectorLookupTableData, 2377 ASTSelectorLookupTrait(*this, F)); 2378 TotalNumMethodPoolEntries += Record[1]; 2379 break; 2380 2381 case REFERENCED_SELECTOR_POOL: 2382 if (!Record.empty()) { 2383 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2384 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2385 Record[Idx++])); 2386 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2387 getRawEncoding()); 2388 } 2389 } 2390 break; 2391 2392 case PP_COUNTER_VALUE: 2393 if (!Record.empty() && Listener) 2394 Listener->ReadCounter(F, Record[0]); 2395 break; 2396 2397 case FILE_SORTED_DECLS: 2398 F.FileSortedDecls = (const DeclID *)BlobStart; 2399 F.NumFileSortedDecls = Record[0]; 2400 break; 2401 2402 case SOURCE_LOCATION_OFFSETS: { 2403 F.SLocEntryOffsets = (const uint32_t *)BlobStart; 2404 F.LocalNumSLocEntries = Record[0]; 2405 unsigned SLocSpaceSize = Record[1]; 2406 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2407 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, 2408 SLocSpaceSize); 2409 // Make our entry in the range map. BaseID is negative and growing, so 2410 // we invert it. Because we invert it, though, we need the other end of 2411 // the range. 2412 unsigned RangeStart = 2413 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2414 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2415 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2416 2417 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing. 2418 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0); 2419 GlobalSLocOffsetMap.insert( 2420 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset 2421 - SLocSpaceSize,&F)); 2422 2423 // Initialize the remapping table. 2424 // Invalid stays invalid. 2425 F.SLocRemap.insert(std::make_pair(0U, 0)); 2426 // This module. Base was 2 when being compiled. 2427 F.SLocRemap.insert(std::make_pair(2U, 2428 static_cast<int>(F.SLocEntryBaseOffset - 2))); 2429 2430 TotalNumSLocEntries += F.LocalNumSLocEntries; 2431 break; 2432 } 2433 2434 case MODULE_OFFSET_MAP: { 2435 // Additional remapping information. 2436 const unsigned char *Data = (const unsigned char*)BlobStart; 2437 const unsigned char *DataEnd = Data + BlobLen; 2438 2439 // Continuous range maps we may be updating in our module. 2440 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 2441 ContinuousRangeMap<uint32_t, int, 2>::Builder 2442 IdentifierRemap(F.IdentifierRemap); 2443 ContinuousRangeMap<uint32_t, int, 2>::Builder 2444 MacroRemap(F.MacroRemap); 2445 ContinuousRangeMap<uint32_t, int, 2>::Builder 2446 PreprocessedEntityRemap(F.PreprocessedEntityRemap); 2447 ContinuousRangeMap<uint32_t, int, 2>::Builder 2448 SubmoduleRemap(F.SubmoduleRemap); 2449 ContinuousRangeMap<uint32_t, int, 2>::Builder 2450 SelectorRemap(F.SelectorRemap); 2451 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 2452 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 2453 2454 while(Data < DataEnd) { 2455 uint16_t Len = io::ReadUnalignedLE16(Data); 2456 StringRef Name = StringRef((const char*)Data, Len); 2457 Data += Len; 2458 ModuleFile *OM = ModuleMgr.lookup(Name); 2459 if (!OM) { 2460 Error("SourceLocation remap refers to unknown module"); 2461 return true; 2462 } 2463 2464 uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 2465 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 2466 uint32_t MacroIDOffset = io::ReadUnalignedLE32(Data); 2467 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 2468 uint32_t SubmoduleIDOffset = io::ReadUnalignedLE32(Data); 2469 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 2470 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 2471 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2472 2473 // Source location offset is mapped to OM->SLocEntryBaseOffset. 2474 SLocRemap.insert(std::make_pair(SLocOffset, 2475 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2476 IdentifierRemap.insert( 2477 std::make_pair(IdentifierIDOffset, 2478 OM->BaseIdentifierID - IdentifierIDOffset)); 2479 MacroRemap.insert(std::make_pair(MacroIDOffset, 2480 OM->BaseMacroID - MacroIDOffset)); 2481 PreprocessedEntityRemap.insert( 2482 std::make_pair(PreprocessedEntityIDOffset, 2483 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); 2484 SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset, 2485 OM->BaseSubmoduleID - SubmoduleIDOffset)); 2486 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2487 OM->BaseSelectorID - SelectorIDOffset)); 2488 DeclRemap.insert(std::make_pair(DeclIDOffset, 2489 OM->BaseDeclID - DeclIDOffset)); 2490 2491 TypeRemap.insert(std::make_pair(TypeIndexOffset, 2492 OM->BaseTypeIndex - TypeIndexOffset)); 2493 2494 // Global -> local mappings. 2495 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset; 2496 } 2497 break; 2498 } 2499 2500 case SOURCE_MANAGER_LINE_TABLE: 2501 if (ParseLineTable(F, Record)) 2502 return true; 2503 break; 2504 2505 case SOURCE_LOCATION_PRELOADS: { 2506 // Need to transform from the local view (1-based IDs) to the global view, 2507 // which is based off F.SLocEntryBaseID. 2508 if (!F.PreloadSLocEntries.empty()) { 2509 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file"); 2510 return true; 2511 } 2512 2513 F.PreloadSLocEntries.swap(Record); 2514 break; 2515 } 2516 2517 case STAT_CACHE: { 2518 if (!DisableStatCache) { 2519 ASTStatCache *MyStatCache = 2520 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2521 (const unsigned char *)BlobStart, 2522 NumStatHits, NumStatMisses); 2523 FileMgr.addStatCache(MyStatCache); 2524 F.StatCache = MyStatCache; 2525 } 2526 break; 2527 } 2528 2529 case EXT_VECTOR_DECLS: 2530 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2531 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2532 break; 2533 2534 case VTABLE_USES: 2535 if (Record.size() % 3 != 0) { 2536 Error("Invalid VTABLE_USES record"); 2537 return true; 2538 } 2539 2540 // Later tables overwrite earlier ones. 2541 // FIXME: Modules will have some trouble with this. This is clearly not 2542 // the right way to do this. 2543 VTableUses.clear(); 2544 2545 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2546 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2547 VTableUses.push_back( 2548 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2549 VTableUses.push_back(Record[Idx++]); 2550 } 2551 break; 2552 2553 case DYNAMIC_CLASSES: 2554 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2555 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2556 break; 2557 2558 case PENDING_IMPLICIT_INSTANTIATIONS: 2559 if (PendingInstantiations.size() % 2 != 0) { 2560 Error("Invalid existing PendingInstantiations"); 2561 return true; 2562 } 2563 2564 if (Record.size() % 2 != 0) { 2565 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2566 return true; 2567 } 2568 2569 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2570 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2571 PendingInstantiations.push_back( 2572 ReadSourceLocation(F, Record, I).getRawEncoding()); 2573 } 2574 break; 2575 2576 case SEMA_DECL_REFS: 2577 // Later tables overwrite earlier ones. 2578 // FIXME: Modules will have some trouble with this. 2579 SemaDeclRefs.clear(); 2580 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2581 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2582 break; 2583 2584 case PPD_ENTITIES_OFFSETS: { 2585 F.PreprocessedEntityOffsets = (const PPEntityOffset *)BlobStart; 2586 assert(BlobLen % sizeof(PPEntityOffset) == 0); 2587 F.NumPreprocessedEntities = BlobLen / sizeof(PPEntityOffset); 2588 2589 unsigned LocalBasePreprocessedEntityID = Record[0]; 2590 2591 unsigned StartingID; 2592 if (!PP.getPreprocessingRecord()) 2593 PP.createPreprocessingRecord(/*RecordConditionalDirectives=*/false); 2594 if (!PP.getPreprocessingRecord()->getExternalSource()) 2595 PP.getPreprocessingRecord()->SetExternalSource(*this); 2596 StartingID 2597 = PP.getPreprocessingRecord() 2598 ->allocateLoadedEntities(F.NumPreprocessedEntities); 2599 F.BasePreprocessedEntityID = StartingID; 2600 2601 if (F.NumPreprocessedEntities > 0) { 2602 // Introduce the global -> local mapping for preprocessed entities in 2603 // this module. 2604 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2605 2606 // Introduce the local -> global mapping for preprocessed entities in 2607 // this module. 2608 F.PreprocessedEntityRemap.insertOrReplace( 2609 std::make_pair(LocalBasePreprocessedEntityID, 2610 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 2611 } 2612 2613 break; 2614 } 2615 2616 case DECL_UPDATE_OFFSETS: { 2617 if (Record.size() % 2 != 0) { 2618 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2619 return true; 2620 } 2621 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2622 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2623 .push_back(std::make_pair(&F, Record[I+1])); 2624 break; 2625 } 2626 2627 case DECL_REPLACEMENTS: { 2628 if (Record.size() % 3 != 0) { 2629 Error("invalid DECL_REPLACEMENTS block in AST file"); 2630 return true; 2631 } 2632 for (unsigned I = 0, N = Record.size(); I != N; I += 3) 2633 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2634 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]); 2635 break; 2636 } 2637 2638 case OBJC_CATEGORIES_MAP: { 2639 if (F.LocalNumObjCCategoriesInMap != 0) { 2640 Error("duplicate OBJC_CATEGORIES_MAP record in AST file"); 2641 return true; 2642 } 2643 2644 F.LocalNumObjCCategoriesInMap = Record[0]; 2645 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)BlobStart; 2646 break; 2647 } 2648 2649 case OBJC_CATEGORIES: 2650 F.ObjCCategories.swap(Record); 2651 break; 2652 2653 case CXX_BASE_SPECIFIER_OFFSETS: { 2654 if (F.LocalNumCXXBaseSpecifiers != 0) { 2655 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2656 return true; 2657 } 2658 2659 F.LocalNumCXXBaseSpecifiers = Record[0]; 2660 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2661 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2662 break; 2663 } 2664 2665 case DIAG_PRAGMA_MAPPINGS: 2666 if (Record.size() % 2 != 0) { 2667 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2668 return true; 2669 } 2670 2671 if (F.PragmaDiagMappings.empty()) 2672 F.PragmaDiagMappings.swap(Record); 2673 else 2674 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2675 Record.begin(), Record.end()); 2676 break; 2677 2678 case CUDA_SPECIAL_DECL_REFS: 2679 // Later tables overwrite earlier ones. 2680 // FIXME: Modules will have trouble with this. 2681 CUDASpecialDeclRefs.clear(); 2682 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2683 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2684 break; 2685 2686 case HEADER_SEARCH_TABLE: { 2687 F.HeaderFileInfoTableData = BlobStart; 2688 F.LocalNumHeaderFileInfos = Record[1]; 2689 F.HeaderFileFrameworkStrings = BlobStart + Record[2]; 2690 if (Record[0]) { 2691 F.HeaderFileInfoTable 2692 = HeaderFileInfoLookupTable::Create( 2693 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2694 (const unsigned char *)F.HeaderFileInfoTableData, 2695 HeaderFileInfoTrait(*this, F, 2696 &PP.getHeaderSearchInfo(), 2697 BlobStart + Record[2])); 2698 2699 PP.getHeaderSearchInfo().SetExternalSource(this); 2700 if (!PP.getHeaderSearchInfo().getExternalLookup()) 2701 PP.getHeaderSearchInfo().SetExternalLookup(this); 2702 } 2703 break; 2704 } 2705 2706 case FP_PRAGMA_OPTIONS: 2707 // Later tables overwrite earlier ones. 2708 FPPragmaOptions.swap(Record); 2709 break; 2710 2711 case OPENCL_EXTENSIONS: 2712 // Later tables overwrite earlier ones. 2713 OpenCLExtensions.swap(Record); 2714 break; 2715 2716 case TENTATIVE_DEFINITIONS: 2717 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2718 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2719 break; 2720 2721 case KNOWN_NAMESPACES: 2722 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2723 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2724 break; 2725 2726 case IMPORTED_MODULES: { 2727 if (F.Kind != MK_Module) { 2728 // If we aren't loading a module (which has its own exports), make 2729 // all of the imported modules visible. 2730 // FIXME: Deal with macros-only imports. 2731 for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2732 if (unsigned GlobalID = getGlobalSubmoduleID(F, Record[I])) 2733 ImportedModules.push_back(GlobalID); 2734 } 2735 } 2736 break; 2737 } 2738 2739 case LOCAL_REDECLARATIONS: { 2740 F.RedeclarationChains.swap(Record); 2741 break; 2742 } 2743 2744 case LOCAL_REDECLARATIONS_MAP: { 2745 if (F.LocalNumRedeclarationsInMap != 0) { 2746 Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file"); 2747 return true; 2748 } 2749 2750 F.LocalNumRedeclarationsInMap = Record[0]; 2751 F.RedeclarationsMap = (const LocalRedeclarationsInfo *)BlobStart; 2752 break; 2753 } 2754 2755 case MERGED_DECLARATIONS: { 2756 for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) { 2757 GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]); 2758 SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID]; 2759 for (unsigned N = Record[Idx++]; N > 0; --N) 2760 Decls.push_back(getGlobalDeclID(F, Record[Idx++])); 2761 } 2762 break; 2763 } 2764 2765 case MACRO_OFFSET: { 2766 if (F.LocalNumMacros != 0) { 2767 Error("duplicate MACRO_OFFSET record in AST file"); 2768 return true; 2769 } 2770 F.MacroOffsets = (const uint32_t *)BlobStart; 2771 F.LocalNumMacros = Record[0]; 2772 unsigned LocalBaseMacroID = Record[1]; 2773 F.BaseMacroID = getTotalNumMacros(); 2774 2775 if (F.LocalNumMacros > 0) { 2776 // Introduce the global -> local mapping for macros within this module. 2777 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F)); 2778 2779 // Introduce the local -> global mapping for macros within this module. 2780 F.MacroRemap.insertOrReplace( 2781 std::make_pair(LocalBaseMacroID, 2782 F.BaseMacroID - LocalBaseMacroID)); 2783 2784 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros); 2785 } 2786 break; 2787 } 2788 2789 case MACRO_UPDATES: { 2790 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2791 MacroID ID = getGlobalMacroID(F, Record[I++]); 2792 if (I == N) 2793 break; 2794 2795 SourceLocation UndefLoc = ReadSourceLocation(F, Record, I); 2796 SubmoduleID SubmoduleID = getGlobalSubmoduleID(F, Record[I++]);; 2797 MacroUpdate Update; 2798 Update.UndefLoc = UndefLoc; 2799 MacroUpdates[ID].push_back(std::make_pair(SubmoduleID, Update)); 2800 } 2801 break; 2802 } 2803 } 2804 } 2805 Error("premature end of bitstream in AST file"); 2806 return true; 2807} 2808 2809void ASTReader::makeNamesVisible(const HiddenNames &Names) { 2810 for (unsigned I = 0, N = Names.size(); I != N; ++I) { 2811 switch (Names[I].getKind()) { 2812 case HiddenName::Declaration: 2813 Names[I].getDecl()->Hidden = false; 2814 break; 2815 2816 case HiddenName::MacroVisibility: { 2817 std::pair<IdentifierInfo *, MacroInfo *> Macro = Names[I].getMacro(); 2818 Macro.second->setHidden(!Macro.second->isPublic()); 2819 if (Macro.second->isDefined()) { 2820 PP.makeLoadedMacroInfoVisible(Macro.first, Macro.second); 2821 } 2822 break; 2823 } 2824 2825 case HiddenName::MacroUndef: { 2826 std::pair<IdentifierInfo *, MacroInfo *> Macro = Names[I].getMacro(); 2827 if (Macro.second->isDefined()) { 2828 Macro.second->setUndefLoc(Names[I].getMacroUndefLoc()); 2829 if (PPMutationListener *Listener = PP.getPPMutationListener()) 2830 Listener->UndefinedMacro(Macro.second); 2831 PP.makeLoadedMacroInfoVisible(Macro.first, Macro.second); 2832 } 2833 break; 2834 } 2835 } 2836 } 2837} 2838 2839void ASTReader::makeModuleVisible(Module *Mod, 2840 Module::NameVisibilityKind NameVisibility) { 2841 llvm::SmallPtrSet<Module *, 4> Visited; 2842 llvm::SmallVector<Module *, 4> Stack; 2843 Stack.push_back(Mod); 2844 while (!Stack.empty()) { 2845 Mod = Stack.back(); 2846 Stack.pop_back(); 2847 2848 if (NameVisibility <= Mod->NameVisibility) { 2849 // This module already has this level of visibility (or greater), so 2850 // there is nothing more to do. 2851 continue; 2852 } 2853 2854 if (!Mod->isAvailable()) { 2855 // Modules that aren't available cannot be made visible. 2856 continue; 2857 } 2858 2859 // Update the module's name visibility. 2860 Mod->NameVisibility = NameVisibility; 2861 2862 // If we've already deserialized any names from this module, 2863 // mark them as visible. 2864 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 2865 if (Hidden != HiddenNamesMap.end()) { 2866 makeNamesVisible(Hidden->second); 2867 HiddenNamesMap.erase(Hidden); 2868 } 2869 2870 // Push any non-explicit submodules onto the stack to be marked as 2871 // visible. 2872 for (Module::submodule_iterator Sub = Mod->submodule_begin(), 2873 SubEnd = Mod->submodule_end(); 2874 Sub != SubEnd; ++Sub) { 2875 if (!(*Sub)->IsExplicit && Visited.insert(*Sub)) 2876 Stack.push_back(*Sub); 2877 } 2878 2879 // Push any exported modules onto the stack to be marked as visible. 2880 bool AnyWildcard = false; 2881 bool UnrestrictedWildcard = false; 2882 llvm::SmallVector<Module *, 4> WildcardRestrictions; 2883 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { 2884 Module *Exported = Mod->Exports[I].getPointer(); 2885 if (!Mod->Exports[I].getInt()) { 2886 // Export a named module directly; no wildcards involved. 2887 if (Visited.insert(Exported)) 2888 Stack.push_back(Exported); 2889 2890 continue; 2891 } 2892 2893 // Wildcard export: export all of the imported modules that match 2894 // the given pattern. 2895 AnyWildcard = true; 2896 if (UnrestrictedWildcard) 2897 continue; 2898 2899 if (Module *Restriction = Mod->Exports[I].getPointer()) 2900 WildcardRestrictions.push_back(Restriction); 2901 else { 2902 WildcardRestrictions.clear(); 2903 UnrestrictedWildcard = true; 2904 } 2905 } 2906 2907 // If there were any wildcards, push any imported modules that were 2908 // re-exported by the wildcard restriction. 2909 if (!AnyWildcard) 2910 continue; 2911 2912 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { 2913 Module *Imported = Mod->Imports[I]; 2914 if (!Visited.insert(Imported)) 2915 continue; 2916 2917 bool Acceptable = UnrestrictedWildcard; 2918 if (!Acceptable) { 2919 // Check whether this module meets one of the restrictions. 2920 for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) { 2921 Module *Restriction = WildcardRestrictions[R]; 2922 if (Imported == Restriction || Imported->isSubModuleOf(Restriction)) { 2923 Acceptable = true; 2924 break; 2925 } 2926 } 2927 } 2928 2929 if (!Acceptable) 2930 continue; 2931 2932 Stack.push_back(Imported); 2933 } 2934 } 2935} 2936 2937ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2938 ModuleKind Type, 2939 unsigned ClientLoadCapabilities) { 2940 // Bump the generation number. 2941 unsigned PreviousGeneration = CurrentGeneration++; 2942 2943 // Load the core of the AST files. 2944 llvm::SmallVector<ModuleFile *, 4> Loaded; 2945 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0, Loaded, 2946 ClientLoadCapabilities)) { 2947 case Failure: return Failure; 2948 case OutOfDate: return OutOfDate; 2949 case VersionMismatch: return VersionMismatch; 2950 case ConfigurationMismatch: return ConfigurationMismatch; 2951 case HadErrors: return HadErrors; 2952 case Success: break; 2953 } 2954 2955 // Here comes stuff that we only do once the entire chain is loaded. 2956 2957 // Load the AST blocks of all of the modules that we loaded. 2958 for (llvm::SmallVectorImpl<ModuleFile *>::iterator M = Loaded.begin(), 2959 MEnd = Loaded.end(); 2960 M != MEnd; ++M) { 2961 ModuleFile &F = **M; 2962 2963 // Read the AST block. 2964 if (ReadASTBlock(F)) 2965 return Failure; 2966 2967 // Once read, set the ModuleFile bit base offset and update the size in 2968 // bits of all files we've seen. 2969 F.GlobalBitOffset = TotalModulesSizeInBits; 2970 TotalModulesSizeInBits += F.SizeInBits; 2971 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2972 2973 // Preload SLocEntries. 2974 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) { 2975 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2976 // Load it through the SourceManager and don't call ReadSLocEntry() 2977 // directly because the entry may have already been loaded in which case 2978 // calling ReadSLocEntry() directly would trigger an assertion in 2979 // SourceManager. 2980 SourceMgr.getLoadedSLocEntryByID(Index); 2981 } 2982 } 2983 2984 // Check the predefines buffers. 2985 bool ConfigComplain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2986 if (!DisableValidation && Type == MK_PCH && 2987 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines; 2988 // if DisableValidation is true, defines that were set on command-line 2989 // but not in the PCH file will not be added to SuggestedPredefines. 2990 CheckPredefinesBuffers(ConfigComplain)) 2991 return ConfigurationMismatch; 2992 2993 // Mark all of the identifiers in the identifier table as being out of date, 2994 // so that various accessors know to check the loaded modules when the 2995 // identifier is used. 2996 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2997 IdEnd = PP.getIdentifierTable().end(); 2998 Id != IdEnd; ++Id) 2999 Id->second->setOutOfDate(true); 3000 3001 // Resolve any unresolved module exports. 3002 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) { 3003 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I]; 3004 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 3005 Module *ResolvedMod = getSubmodule(GlobalID); 3006 3007 if (Unresolved.IsImport) { 3008 if (ResolvedMod) 3009 Unresolved.Mod->Imports.push_back(ResolvedMod); 3010 continue; 3011 } 3012 3013 if (ResolvedMod || Unresolved.IsWildcard) 3014 Unresolved.Mod->Exports.push_back( 3015 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 3016 } 3017 UnresolvedModuleImportExports.clear(); 3018 3019 InitializeContext(); 3020 3021 if (DeserializationListener) 3022 DeserializationListener->ReaderInitialized(this); 3023 3024 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule(); 3025 if (!PrimaryModule.OriginalSourceFileID.isInvalid()) { 3026 PrimaryModule.OriginalSourceFileID 3027 = FileID::get(PrimaryModule.SLocEntryBaseID 3028 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1); 3029 3030 // If this AST file is a precompiled preamble, then set the 3031 // preamble file ID of the source manager to the file source file 3032 // from which the preamble was built. 3033 if (Type == MK_Preamble) { 3034 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID); 3035 } else if (Type == MK_MainFile) { 3036 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID); 3037 } 3038 } 3039 3040 // For any Objective-C class definitions we have already loaded, make sure 3041 // that we load any additional categories. 3042 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) { 3043 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(), 3044 ObjCClassesLoaded[I], 3045 PreviousGeneration); 3046 } 3047 3048 return Success; 3049} 3050 3051ASTReader::ASTReadResult 3052ASTReader::ReadASTCore(StringRef FileName, 3053 ModuleKind Type, 3054 ModuleFile *ImportedBy, 3055 llvm::SmallVectorImpl<ModuleFile *> &Loaded, 3056 unsigned ClientLoadCapabilities) { 3057 ModuleFile *M; 3058 bool NewModule; 3059 std::string ErrorStr; 3060 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy, 3061 CurrentGeneration, ErrorStr); 3062 3063 if (!M) { 3064 // We couldn't load the module. 3065 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 3066 + ErrorStr; 3067 Error(Msg); 3068 return Failure; 3069 } 3070 3071 if (!NewModule) { 3072 // We've already loaded this module. 3073 return Success; 3074 } 3075 3076 // FIXME: This seems rather a hack. Should CurrentDir be part of the 3077 // module? 3078 if (FileName != "-") { 3079 CurrentDir = llvm::sys::path::parent_path(FileName); 3080 if (CurrentDir.empty()) CurrentDir = "."; 3081 } 3082 3083 ModuleFile &F = *M; 3084 llvm::BitstreamCursor &Stream = F.Stream; 3085 Stream.init(F.StreamFile); 3086 F.SizeInBits = F.Buffer->getBufferSize() * 8; 3087 3088 // Sniff for the signature. 3089 if (Stream.Read(8) != 'C' || 3090 Stream.Read(8) != 'P' || 3091 Stream.Read(8) != 'C' || 3092 Stream.Read(8) != 'H') { 3093 Diag(diag::err_not_a_pch_file) << FileName; 3094 return Failure; 3095 } 3096 3097 while (!Stream.AtEndOfStream()) { 3098 unsigned Code = Stream.ReadCode(); 3099 3100 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 3101 Error("invalid record at top-level of AST file"); 3102 return Failure; 3103 } 3104 3105 unsigned BlockID = Stream.ReadSubBlockID(); 3106 3107 // We only know the control subblock ID. 3108 switch (BlockID) { 3109 case llvm::bitc::BLOCKINFO_BLOCK_ID: 3110 if (Stream.ReadBlockInfoBlock()) { 3111 Error("malformed BlockInfoBlock in AST file"); 3112 return Failure; 3113 } 3114 break; 3115 case CONTROL_BLOCK_ID: 3116 switch (ReadControlBlock(F, Loaded, ClientLoadCapabilities)) { 3117 case Success: 3118 break; 3119 3120 case Failure: return Failure; 3121 case OutOfDate: return OutOfDate; 3122 case VersionMismatch: return VersionMismatch; 3123 case ConfigurationMismatch: return ConfigurationMismatch; 3124 case HadErrors: return HadErrors; 3125 } 3126 break; 3127 case AST_BLOCK_ID: 3128 // Record that we've loaded this module. 3129 Loaded.push_back(M); 3130 return Success; 3131 3132 default: 3133 if (Stream.SkipBlock()) { 3134 Error("malformed block record in AST file"); 3135 return Failure; 3136 } 3137 break; 3138 } 3139 } 3140 3141 return Success; 3142} 3143 3144void ASTReader::InitializeContext() { 3145 // If there's a listener, notify them that we "read" the translation unit. 3146 if (DeserializationListener) 3147 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 3148 Context.getTranslationUnitDecl()); 3149 3150 // Make sure we load the declaration update records for the translation unit, 3151 // if there are any. 3152 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 3153 Context.getTranslationUnitDecl()); 3154 3155 // FIXME: Find a better way to deal with collisions between these 3156 // built-in types. Right now, we just ignore the problem. 3157 3158 // Load the special types. 3159 if (SpecialTypes.size() >= NumSpecialTypeIDs) { 3160 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 3161 if (!Context.CFConstantStringTypeDecl) 3162 Context.setCFConstantStringType(GetType(String)); 3163 } 3164 3165 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 3166 QualType FileType = GetType(File); 3167 if (FileType.isNull()) { 3168 Error("FILE type is NULL"); 3169 return; 3170 } 3171 3172 if (!Context.FILEDecl) { 3173 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 3174 Context.setFILEDecl(Typedef->getDecl()); 3175 else { 3176 const TagType *Tag = FileType->getAs<TagType>(); 3177 if (!Tag) { 3178 Error("Invalid FILE type in AST file"); 3179 return; 3180 } 3181 Context.setFILEDecl(Tag->getDecl()); 3182 } 3183 } 3184 } 3185 3186 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 3187 QualType Jmp_bufType = GetType(Jmp_buf); 3188 if (Jmp_bufType.isNull()) { 3189 Error("jmp_buf type is NULL"); 3190 return; 3191 } 3192 3193 if (!Context.jmp_bufDecl) { 3194 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 3195 Context.setjmp_bufDecl(Typedef->getDecl()); 3196 else { 3197 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 3198 if (!Tag) { 3199 Error("Invalid jmp_buf type in AST file"); 3200 return; 3201 } 3202 Context.setjmp_bufDecl(Tag->getDecl()); 3203 } 3204 } 3205 } 3206 3207 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 3208 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 3209 if (Sigjmp_bufType.isNull()) { 3210 Error("sigjmp_buf type is NULL"); 3211 return; 3212 } 3213 3214 if (!Context.sigjmp_bufDecl) { 3215 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 3216 Context.setsigjmp_bufDecl(Typedef->getDecl()); 3217 else { 3218 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 3219 assert(Tag && "Invalid sigjmp_buf type in AST file"); 3220 Context.setsigjmp_bufDecl(Tag->getDecl()); 3221 } 3222 } 3223 } 3224 3225 if (unsigned ObjCIdRedef 3226 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 3227 if (Context.ObjCIdRedefinitionType.isNull()) 3228 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 3229 } 3230 3231 if (unsigned ObjCClassRedef 3232 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 3233 if (Context.ObjCClassRedefinitionType.isNull()) 3234 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 3235 } 3236 3237 if (unsigned ObjCSelRedef 3238 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 3239 if (Context.ObjCSelRedefinitionType.isNull()) 3240 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3241 } 3242 3243 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 3244 QualType Ucontext_tType = GetType(Ucontext_t); 3245 if (Ucontext_tType.isNull()) { 3246 Error("ucontext_t type is NULL"); 3247 return; 3248 } 3249 3250 if (!Context.ucontext_tDecl) { 3251 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 3252 Context.setucontext_tDecl(Typedef->getDecl()); 3253 else { 3254 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 3255 assert(Tag && "Invalid ucontext_t type in AST file"); 3256 Context.setucontext_tDecl(Tag->getDecl()); 3257 } 3258 } 3259 } 3260 } 3261 3262 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 3263 3264 // If there were any CUDA special declarations, deserialize them. 3265 if (!CUDASpecialDeclRefs.empty()) { 3266 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3267 Context.setcudaConfigureCallDecl( 3268 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3269 } 3270 3271 // Re-export any modules that were imported by a non-module AST file. 3272 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 3273 if (Module *Imported = getSubmodule(ImportedModules[I])) 3274 makeModuleVisible(Imported, Module::AllVisible); 3275 } 3276 ImportedModules.clear(); 3277} 3278 3279void ASTReader::finalizeForWriting() { 3280 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 3281 HiddenEnd = HiddenNamesMap.end(); 3282 Hidden != HiddenEnd; ++Hidden) { 3283 makeNamesVisible(Hidden->second); 3284 } 3285 HiddenNamesMap.clear(); 3286} 3287 3288/// \brief Retrieve the name of the original source file name 3289/// directly from the AST file, without actually loading the AST 3290/// file. 3291std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3292 FileManager &FileMgr, 3293 DiagnosticsEngine &Diags) { 3294 // Open the AST file. 3295 std::string ErrStr; 3296 OwningPtr<llvm::MemoryBuffer> Buffer; 3297 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3298 if (!Buffer) { 3299 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ASTFileName << ErrStr; 3300 return std::string(); 3301 } 3302 3303 // Initialize the stream 3304 llvm::BitstreamReader StreamFile; 3305 llvm::BitstreamCursor Stream; 3306 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3307 (const unsigned char *)Buffer->getBufferEnd()); 3308 Stream.init(StreamFile); 3309 3310 // Sniff for the signature. 3311 if (Stream.Read(8) != 'C' || 3312 Stream.Read(8) != 'P' || 3313 Stream.Read(8) != 'C' || 3314 Stream.Read(8) != 'H') { 3315 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3316 return std::string(); 3317 } 3318 3319 RecordData Record; 3320 while (!Stream.AtEndOfStream()) { 3321 unsigned Code = Stream.ReadCode(); 3322 3323 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3324 unsigned BlockID = Stream.ReadSubBlockID(); 3325 3326 // We only know the AST subblock ID. 3327 switch (BlockID) { 3328 case CONTROL_BLOCK_ID: 3329 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) { 3330 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3331 return std::string(); 3332 } 3333 break; 3334 3335 default: 3336 if (Stream.SkipBlock()) { 3337 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3338 return std::string(); 3339 } 3340 break; 3341 } 3342 continue; 3343 } 3344 3345 if (Code == llvm::bitc::END_BLOCK) { 3346 if (Stream.ReadBlockEnd()) { 3347 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 3348 return std::string(); 3349 } 3350 continue; 3351 } 3352 3353 if (Code == llvm::bitc::DEFINE_ABBREV) { 3354 Stream.ReadAbbrevRecord(); 3355 continue; 3356 } 3357 3358 Record.clear(); 3359 const char *BlobStart = 0; 3360 unsigned BlobLen = 0; 3361 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) == ORIGINAL_FILE) 3362 return std::string(BlobStart, BlobLen); 3363 } 3364 3365 return std::string(); 3366} 3367 3368namespace { 3369 class SimplePCHValidator : public ASTReaderListener { 3370 const LangOptions &ExistingLangOpts; 3371 const TargetOptions &ExistingTargetOpts; 3372 3373 public: 3374 SimplePCHValidator(const LangOptions &ExistingLangOpts, 3375 const TargetOptions &ExistingTargetOpts) 3376 : ExistingLangOpts(ExistingLangOpts), 3377 ExistingTargetOpts(ExistingTargetOpts) 3378 { 3379 } 3380 3381 virtual bool ReadLanguageOptions(const LangOptions &LangOpts, 3382 bool Complain) { 3383 return checkLanguageOptions(ExistingLangOpts, LangOpts, 0); 3384 } 3385 virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, 3386 bool Complain) { 3387 return checkTargetOptions(ExistingTargetOpts, TargetOpts, 0); 3388 } 3389 }; 3390} 3391 3392bool ASTReader::isAcceptableASTFile(StringRef Filename, 3393 FileManager &FileMgr, 3394 const LangOptions &LangOpts, 3395 const TargetOptions &TargetOpts) { 3396 // Open the AST file. 3397 std::string ErrStr; 3398 OwningPtr<llvm::MemoryBuffer> Buffer; 3399 Buffer.reset(FileMgr.getBufferForFile(Filename, &ErrStr)); 3400 if (!Buffer) { 3401 return false; 3402 } 3403 3404 // Initialize the stream 3405 llvm::BitstreamReader StreamFile; 3406 llvm::BitstreamCursor Stream; 3407 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3408 (const unsigned char *)Buffer->getBufferEnd()); 3409 Stream.init(StreamFile); 3410 3411 // Sniff for the signature. 3412 if (Stream.Read(8) != 'C' || 3413 Stream.Read(8) != 'P' || 3414 Stream.Read(8) != 'C' || 3415 Stream.Read(8) != 'H') { 3416 return false; 3417 } 3418 3419 SimplePCHValidator Validator(LangOpts, TargetOpts); 3420 RecordData Record; 3421 bool InControlBlock = false; 3422 while (!Stream.AtEndOfStream()) { 3423 unsigned Code = Stream.ReadCode(); 3424 3425 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3426 unsigned BlockID = Stream.ReadSubBlockID(); 3427 3428 // We only know the control subblock ID. 3429 switch (BlockID) { 3430 case CONTROL_BLOCK_ID: 3431 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) { 3432 return false; 3433 } else { 3434 InControlBlock = true; 3435 } 3436 break; 3437 3438 default: 3439 if (Stream.SkipBlock()) 3440 return false; 3441 break; 3442 } 3443 continue; 3444 } 3445 3446 if (Code == llvm::bitc::END_BLOCK) { 3447 if (Stream.ReadBlockEnd()) { 3448 return false; 3449 } 3450 InControlBlock = false; 3451 continue; 3452 } 3453 3454 if (Code == llvm::bitc::DEFINE_ABBREV) { 3455 Stream.ReadAbbrevRecord(); 3456 continue; 3457 } 3458 3459 Record.clear(); 3460 const char *BlobStart = 0; 3461 unsigned BlobLen = 0; 3462 unsigned RecCode = Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen); 3463 if (InControlBlock) { 3464 switch ((ControlRecordTypes)RecCode) { 3465 case METADATA: { 3466 if (Record[0] != VERSION_MAJOR) { 3467 return false; 3468 } 3469 3470 const std::string &CurBranch = getClangFullRepositoryVersion(); 3471 StringRef ASTBranch(BlobStart, BlobLen); 3472 if (StringRef(CurBranch) != ASTBranch) 3473 return false; 3474 3475 break; 3476 } 3477 case LANGUAGE_OPTIONS: 3478 if (ParseLanguageOptions(Record, false, Validator)) 3479 return false; 3480 break; 3481 3482 case TARGET_OPTIONS: 3483 if (ParseTargetOptions(Record, false, Validator)) 3484 return false; 3485 break; 3486 3487 case DIAGNOSTIC_OPTIONS: 3488 if (ParseDiagnosticOptions(Record, false, Validator)) 3489 return false; 3490 break; 3491 3492 default: 3493 // No other validation to perform. 3494 break; 3495 } 3496 } 3497 } 3498 3499 return true; 3500} 3501 3502bool ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 3503 // Enter the submodule block. 3504 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 3505 Error("malformed submodule block record in AST file"); 3506 return true; 3507 } 3508 3509 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 3510 bool First = true; 3511 Module *CurrentModule = 0; 3512 RecordData Record; 3513 while (true) { 3514 unsigned Code = F.Stream.ReadCode(); 3515 if (Code == llvm::bitc::END_BLOCK) { 3516 if (F.Stream.ReadBlockEnd()) { 3517 Error("error at end of submodule block in AST file"); 3518 return true; 3519 } 3520 return false; 3521 } 3522 3523 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3524 // No known subblocks, always skip them. 3525 F.Stream.ReadSubBlockID(); 3526 if (F.Stream.SkipBlock()) { 3527 Error("malformed block record in AST file"); 3528 return true; 3529 } 3530 continue; 3531 } 3532 3533 if (Code == llvm::bitc::DEFINE_ABBREV) { 3534 F.Stream.ReadAbbrevRecord(); 3535 continue; 3536 } 3537 3538 // Read a record. 3539 const char *BlobStart; 3540 unsigned BlobLen; 3541 Record.clear(); 3542 switch (F.Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 3543 default: // Default behavior: ignore. 3544 break; 3545 3546 case SUBMODULE_DEFINITION: { 3547 if (First) { 3548 Error("missing submodule metadata record at beginning of block"); 3549 return true; 3550 } 3551 3552 if (Record.size() < 7) { 3553 Error("malformed module definition"); 3554 return true; 3555 } 3556 3557 StringRef Name(BlobStart, BlobLen); 3558 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]); 3559 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]); 3560 bool IsFramework = Record[2]; 3561 bool IsExplicit = Record[3]; 3562 bool IsSystem = Record[4]; 3563 bool InferSubmodules = Record[5]; 3564 bool InferExplicitSubmodules = Record[6]; 3565 bool InferExportWildcard = Record[7]; 3566 3567 Module *ParentModule = 0; 3568 if (Parent) 3569 ParentModule = getSubmodule(Parent); 3570 3571 // Retrieve this (sub)module from the module map, creating it if 3572 // necessary. 3573 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3574 IsFramework, 3575 IsExplicit).first; 3576 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 3577 if (GlobalIndex >= SubmodulesLoaded.size() || 3578 SubmodulesLoaded[GlobalIndex]) { 3579 Error("too many submodules"); 3580 return true; 3581 } 3582 3583 CurrentModule->setASTFile(F.File); 3584 CurrentModule->IsFromModuleFile = true; 3585 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem; 3586 CurrentModule->InferSubmodules = InferSubmodules; 3587 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 3588 CurrentModule->InferExportWildcard = InferExportWildcard; 3589 if (DeserializationListener) 3590 DeserializationListener->ModuleRead(GlobalID, CurrentModule); 3591 3592 SubmodulesLoaded[GlobalIndex] = CurrentModule; 3593 break; 3594 } 3595 3596 case SUBMODULE_UMBRELLA_HEADER: { 3597 if (First) { 3598 Error("missing submodule metadata record at beginning of block"); 3599 return true; 3600 } 3601 3602 if (!CurrentModule) 3603 break; 3604 3605 StringRef FileName(BlobStart, BlobLen); 3606 if (const FileEntry *Umbrella = PP.getFileManager().getFile(FileName)) { 3607 if (!CurrentModule->getUmbrellaHeader()) 3608 ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 3609 else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 3610 Error("mismatched umbrella headers in submodule"); 3611 return true; 3612 } 3613 } 3614 break; 3615 } 3616 3617 case SUBMODULE_HEADER: { 3618 if (First) { 3619 Error("missing submodule metadata record at beginning of block"); 3620 return true; 3621 } 3622 3623 if (!CurrentModule) 3624 break; 3625 3626 // FIXME: Be more lazy about this! 3627 StringRef FileName(BlobStart, BlobLen); 3628 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) { 3629 if (std::find(CurrentModule->Headers.begin(), 3630 CurrentModule->Headers.end(), 3631 File) == CurrentModule->Headers.end()) 3632 ModMap.addHeader(CurrentModule, File, false); 3633 } 3634 break; 3635 } 3636 3637 case SUBMODULE_EXCLUDED_HEADER: { 3638 if (First) { 3639 Error("missing submodule metadata record at beginning of block"); 3640 return true; 3641 } 3642 3643 if (!CurrentModule) 3644 break; 3645 3646 // FIXME: Be more lazy about this! 3647 StringRef FileName(BlobStart, BlobLen); 3648 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) { 3649 if (std::find(CurrentModule->Headers.begin(), 3650 CurrentModule->Headers.end(), 3651 File) == CurrentModule->Headers.end()) 3652 ModMap.addHeader(CurrentModule, File, true); 3653 } 3654 break; 3655 } 3656 3657 case SUBMODULE_TOPHEADER: { 3658 if (First) { 3659 Error("missing submodule metadata record at beginning of block"); 3660 return true; 3661 } 3662 3663 if (!CurrentModule) 3664 break; 3665 3666 // FIXME: Be more lazy about this! 3667 StringRef FileName(BlobStart, BlobLen); 3668 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) 3669 CurrentModule->TopHeaders.insert(File); 3670 break; 3671 } 3672 3673 case SUBMODULE_UMBRELLA_DIR: { 3674 if (First) { 3675 Error("missing submodule metadata record at beginning of block"); 3676 return true; 3677 } 3678 3679 if (!CurrentModule) 3680 break; 3681 3682 StringRef DirName(BlobStart, BlobLen); 3683 if (const DirectoryEntry *Umbrella 3684 = PP.getFileManager().getDirectory(DirName)) { 3685 if (!CurrentModule->getUmbrellaDir()) 3686 ModMap.setUmbrellaDir(CurrentModule, Umbrella); 3687 else if (CurrentModule->getUmbrellaDir() != Umbrella) { 3688 Error("mismatched umbrella directories in submodule"); 3689 return true; 3690 } 3691 } 3692 break; 3693 } 3694 3695 case SUBMODULE_METADATA: { 3696 if (!First) { 3697 Error("submodule metadata record not at beginning of block"); 3698 return true; 3699 } 3700 First = false; 3701 3702 F.BaseSubmoduleID = getTotalNumSubmodules(); 3703 F.LocalNumSubmodules = Record[0]; 3704 unsigned LocalBaseSubmoduleID = Record[1]; 3705 if (F.LocalNumSubmodules > 0) { 3706 // Introduce the global -> local mapping for submodules within this 3707 // module. 3708 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3709 3710 // Introduce the local -> global mapping for submodules within this 3711 // module. 3712 F.SubmoduleRemap.insertOrReplace( 3713 std::make_pair(LocalBaseSubmoduleID, 3714 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3715 3716 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3717 } 3718 break; 3719 } 3720 3721 case SUBMODULE_IMPORTS: { 3722 if (First) { 3723 Error("missing submodule metadata record at beginning of block"); 3724 return true; 3725 } 3726 3727 if (!CurrentModule) 3728 break; 3729 3730 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3731 UnresolvedModuleImportExport Unresolved; 3732 Unresolved.File = &F; 3733 Unresolved.Mod = CurrentModule; 3734 Unresolved.ID = Record[Idx]; 3735 Unresolved.IsImport = true; 3736 Unresolved.IsWildcard = false; 3737 UnresolvedModuleImportExports.push_back(Unresolved); 3738 } 3739 break; 3740 } 3741 3742 case SUBMODULE_EXPORTS: { 3743 if (First) { 3744 Error("missing submodule metadata record at beginning of block"); 3745 return true; 3746 } 3747 3748 if (!CurrentModule) 3749 break; 3750 3751 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3752 UnresolvedModuleImportExport Unresolved; 3753 Unresolved.File = &F; 3754 Unresolved.Mod = CurrentModule; 3755 Unresolved.ID = Record[Idx]; 3756 Unresolved.IsImport = false; 3757 Unresolved.IsWildcard = Record[Idx + 1]; 3758 UnresolvedModuleImportExports.push_back(Unresolved); 3759 } 3760 3761 // Once we've loaded the set of exports, there's no reason to keep 3762 // the parsed, unresolved exports around. 3763 CurrentModule->UnresolvedExports.clear(); 3764 break; 3765 } 3766 case SUBMODULE_REQUIRES: { 3767 if (First) { 3768 Error("missing submodule metadata record at beginning of block"); 3769 return true; 3770 } 3771 3772 if (!CurrentModule) 3773 break; 3774 3775 CurrentModule->addRequirement(StringRef(BlobStart, BlobLen), 3776 Context.getLangOpts(), 3777 Context.getTargetInfo()); 3778 break; 3779 } 3780 } 3781 } 3782} 3783 3784/// \brief Parse the record that corresponds to a LangOptions data 3785/// structure. 3786/// 3787/// This routine parses the language options from the AST file and then gives 3788/// them to the AST listener if one is set. 3789/// 3790/// \returns true if the listener deems the file unacceptable, false otherwise. 3791bool ASTReader::ParseLanguageOptions(const RecordData &Record, 3792 bool Complain, 3793 ASTReaderListener &Listener) { 3794 LangOptions LangOpts; 3795 unsigned Idx = 0; 3796#define LANGOPT(Name, Bits, Default, Description) \ 3797 LangOpts.Name = Record[Idx++]; 3798#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3799 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3800#include "clang/Basic/LangOptions.def" 3801 3802 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++]; 3803 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx); 3804 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion); 3805 3806 unsigned Length = Record[Idx++]; 3807 LangOpts.CurrentModule.assign(Record.begin() + Idx, 3808 Record.begin() + Idx + Length); 3809 return Listener.ReadLanguageOptions(LangOpts, Complain); 3810} 3811 3812bool ASTReader::ParseTargetOptions(const RecordData &Record, 3813 bool Complain, 3814 ASTReaderListener &Listener) { 3815 unsigned Idx = 0; 3816 TargetOptions TargetOpts; 3817 TargetOpts.Triple = ReadString(Record, Idx); 3818 TargetOpts.CPU = ReadString(Record, Idx); 3819 TargetOpts.ABI = ReadString(Record, Idx); 3820 TargetOpts.CXXABI = ReadString(Record, Idx); 3821 TargetOpts.LinkerVersion = ReadString(Record, Idx); 3822 for (unsigned N = Record[Idx++]; N; --N) { 3823 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx)); 3824 } 3825 for (unsigned N = Record[Idx++]; N; --N) { 3826 TargetOpts.Features.push_back(ReadString(Record, Idx)); 3827 } 3828 3829 return Listener.ReadTargetOptions(TargetOpts, Complain); 3830} 3831 3832bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain, 3833 ASTReaderListener &Listener) { 3834 DiagnosticOptions DiagOpts; 3835 unsigned Idx = 0; 3836#define DIAGOPT(Name, Bits, Default) DiagOpts.Name = Record[Idx++]; 3837#define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 3838 DiagOpts.set##Name(static_cast<Type>(Record[Idx++])); 3839#include "clang/Basic/DiagnosticOptions.def" 3840 3841 for (unsigned N = Record[Idx++]; N; --N) { 3842 DiagOpts.Warnings.push_back(ReadString(Record, Idx)); 3843 } 3844 3845 return Listener.ReadDiagnosticOptions(DiagOpts, Complain); 3846} 3847 3848bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain, 3849 ASTReaderListener &Listener) { 3850 FileSystemOptions FSOpts; 3851 unsigned Idx = 0; 3852 FSOpts.WorkingDir = ReadString(Record, Idx); 3853 return Listener.ReadFileSystemOptions(FSOpts, Complain); 3854} 3855 3856std::pair<ModuleFile *, unsigned> 3857ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 3858 GlobalPreprocessedEntityMapType::iterator 3859 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 3860 assert(I != GlobalPreprocessedEntityMap.end() && 3861 "Corrupted global preprocessed entity map"); 3862 ModuleFile *M = I->second; 3863 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 3864 return std::make_pair(M, LocalIndex); 3865} 3866 3867std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 3868ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const { 3869 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord()) 3870 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID, 3871 Mod.NumPreprocessedEntities); 3872 3873 return std::make_pair(PreprocessingRecord::iterator(), 3874 PreprocessingRecord::iterator()); 3875} 3876 3877std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator> 3878ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) { 3879 return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls), 3880 ModuleDeclIterator(this, &Mod, 3881 Mod.FileSortedDecls + Mod.NumFileSortedDecls)); 3882} 3883 3884PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 3885 PreprocessedEntityID PPID = Index+1; 3886 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3887 ModuleFile &M = *PPInfo.first; 3888 unsigned LocalIndex = PPInfo.second; 3889 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3890 3891 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 3892 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 3893 3894 unsigned Code = M.PreprocessorDetailCursor.ReadCode(); 3895 switch (Code) { 3896 case llvm::bitc::END_BLOCK: 3897 return 0; 3898 3899 case llvm::bitc::ENTER_SUBBLOCK: 3900 Error("unexpected subblock record in preprocessor detail block"); 3901 return 0; 3902 3903 case llvm::bitc::DEFINE_ABBREV: 3904 Error("unexpected abbrevation record in preprocessor detail block"); 3905 return 0; 3906 3907 default: 3908 break; 3909 } 3910 3911 if (!PP.getPreprocessingRecord()) { 3912 Error("no preprocessing record"); 3913 return 0; 3914 } 3915 3916 // Read the record. 3917 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 3918 ReadSourceLocation(M, PPOffs.End)); 3919 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 3920 const char *BlobStart = 0; 3921 unsigned BlobLen = 0; 3922 RecordData Record; 3923 PreprocessorDetailRecordTypes RecType = 3924 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord( 3925 Code, Record, BlobStart, BlobLen); 3926 switch (RecType) { 3927 case PPD_MACRO_EXPANSION: { 3928 bool isBuiltin = Record[0]; 3929 IdentifierInfo *Name = 0; 3930 MacroDefinition *Def = 0; 3931 if (isBuiltin) 3932 Name = getLocalIdentifier(M, Record[1]); 3933 else { 3934 PreprocessedEntityID 3935 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 3936 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 3937 } 3938 3939 MacroExpansion *ME; 3940 if (isBuiltin) 3941 ME = new (PPRec) MacroExpansion(Name, Range); 3942 else 3943 ME = new (PPRec) MacroExpansion(Def, Range); 3944 3945 return ME; 3946 } 3947 3948 case PPD_MACRO_DEFINITION: { 3949 // Decode the identifier info and then check again; if the macro is 3950 // still defined and associated with the identifier, 3951 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 3952 MacroDefinition *MD 3953 = new (PPRec) MacroDefinition(II, Range); 3954 3955 if (DeserializationListener) 3956 DeserializationListener->MacroDefinitionRead(PPID, MD); 3957 3958 return MD; 3959 } 3960 3961 case PPD_INCLUSION_DIRECTIVE: { 3962 const char *FullFileNameStart = BlobStart + Record[0]; 3963 StringRef FullFileName(FullFileNameStart, BlobLen - Record[0]); 3964 const FileEntry *File = 0; 3965 if (!FullFileName.empty()) 3966 File = PP.getFileManager().getFile(FullFileName); 3967 3968 // FIXME: Stable encoding 3969 InclusionDirective::InclusionKind Kind 3970 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 3971 InclusionDirective *ID 3972 = new (PPRec) InclusionDirective(PPRec, Kind, 3973 StringRef(BlobStart, Record[0]), 3974 Record[1], Record[3], 3975 File, 3976 Range); 3977 return ID; 3978 } 3979 } 3980 3981 llvm_unreachable("Invalid PreprocessorDetailRecordTypes"); 3982} 3983 3984/// \brief \arg SLocMapI points at a chunk of a module that contains no 3985/// preprocessed entities or the entities it contains are not the ones we are 3986/// looking for. Find the next module that contains entities and return the ID 3987/// of the first entry. 3988PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 3989 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 3990 ++SLocMapI; 3991 for (GlobalSLocOffsetMapType::const_iterator 3992 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 3993 ModuleFile &M = *SLocMapI->second; 3994 if (M.NumPreprocessedEntities) 3995 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID); 3996 } 3997 3998 return getTotalNumPreprocessedEntities(); 3999} 4000 4001namespace { 4002 4003template <unsigned PPEntityOffset::*PPLoc> 4004struct PPEntityComp { 4005 const ASTReader &Reader; 4006 ModuleFile &M; 4007 4008 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 4009 4010 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 4011 SourceLocation LHS = getLoc(L); 4012 SourceLocation RHS = getLoc(R); 4013 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4014 } 4015 4016 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 4017 SourceLocation LHS = getLoc(L); 4018 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4019 } 4020 4021 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 4022 SourceLocation RHS = getLoc(R); 4023 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4024 } 4025 4026 SourceLocation getLoc(const PPEntityOffset &PPE) const { 4027 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 4028 } 4029}; 4030 4031} 4032 4033/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 4034PreprocessedEntityID 4035ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 4036 if (SourceMgr.isLocalSourceLocation(BLoc)) 4037 return getTotalNumPreprocessedEntities(); 4038 4039 GlobalSLocOffsetMapType::const_iterator 4040 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4041 BLoc.getOffset()); 4042 assert(SLocMapI != GlobalSLocOffsetMap.end() && 4043 "Corrupted global sloc offset map"); 4044 4045 if (SLocMapI->second->NumPreprocessedEntities == 0) 4046 return findNextPreprocessedEntity(SLocMapI); 4047 4048 ModuleFile &M = *SLocMapI->second; 4049 typedef const PPEntityOffset *pp_iterator; 4050 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4051 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4052 4053 size_t Count = M.NumPreprocessedEntities; 4054 size_t Half; 4055 pp_iterator First = pp_begin; 4056 pp_iterator PPI; 4057 4058 // Do a binary search manually instead of using std::lower_bound because 4059 // The end locations of entities may be unordered (when a macro expansion 4060 // is inside another macro argument), but for this case it is not important 4061 // whether we get the first macro expansion or its containing macro. 4062 while (Count > 0) { 4063 Half = Count/2; 4064 PPI = First; 4065 std::advance(PPI, Half); 4066 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 4067 BLoc)){ 4068 First = PPI; 4069 ++First; 4070 Count = Count - Half - 1; 4071 } else 4072 Count = Half; 4073 } 4074 4075 if (PPI == pp_end) 4076 return findNextPreprocessedEntity(SLocMapI); 4077 4078 return getGlobalPreprocessedEntityID(M, 4079 M.BasePreprocessedEntityID + (PPI - pp_begin)); 4080} 4081 4082/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 4083PreprocessedEntityID 4084ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 4085 if (SourceMgr.isLocalSourceLocation(ELoc)) 4086 return getTotalNumPreprocessedEntities(); 4087 4088 GlobalSLocOffsetMapType::const_iterator 4089 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4090 ELoc.getOffset()); 4091 assert(SLocMapI != GlobalSLocOffsetMap.end() && 4092 "Corrupted global sloc offset map"); 4093 4094 if (SLocMapI->second->NumPreprocessedEntities == 0) 4095 return findNextPreprocessedEntity(SLocMapI); 4096 4097 ModuleFile &M = *SLocMapI->second; 4098 typedef const PPEntityOffset *pp_iterator; 4099 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4100 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4101 pp_iterator PPI = 4102 std::upper_bound(pp_begin, pp_end, ELoc, 4103 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 4104 4105 if (PPI == pp_end) 4106 return findNextPreprocessedEntity(SLocMapI); 4107 4108 return getGlobalPreprocessedEntityID(M, 4109 M.BasePreprocessedEntityID + (PPI - pp_begin)); 4110} 4111 4112/// \brief Returns a pair of [Begin, End) indices of preallocated 4113/// preprocessed entities that \arg Range encompasses. 4114std::pair<unsigned, unsigned> 4115 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 4116 if (Range.isInvalid()) 4117 return std::make_pair(0,0); 4118 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 4119 4120 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 4121 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 4122 return std::make_pair(BeginID, EndID); 4123} 4124 4125/// \brief Optionally returns true or false if the preallocated preprocessed 4126/// entity with index \arg Index came from file \arg FID. 4127llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 4128 FileID FID) { 4129 if (FID.isInvalid()) 4130 return false; 4131 4132 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 4133 ModuleFile &M = *PPInfo.first; 4134 unsigned LocalIndex = PPInfo.second; 4135 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 4136 4137 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 4138 if (Loc.isInvalid()) 4139 return false; 4140 4141 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 4142 return true; 4143 else 4144 return false; 4145} 4146 4147namespace { 4148 /// \brief Visitor used to search for information about a header file. 4149 class HeaderFileInfoVisitor { 4150 ASTReader &Reader; 4151 const FileEntry *FE; 4152 4153 llvm::Optional<HeaderFileInfo> HFI; 4154 4155 public: 4156 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) 4157 : Reader(Reader), FE(FE) { } 4158 4159 static bool visit(ModuleFile &M, void *UserData) { 4160 HeaderFileInfoVisitor *This 4161 = static_cast<HeaderFileInfoVisitor *>(UserData); 4162 4163 HeaderFileInfoTrait Trait(This->Reader, M, 4164 &This->Reader.getPreprocessor().getHeaderSearchInfo(), 4165 M.HeaderFileFrameworkStrings, 4166 This->FE->getName()); 4167 4168 HeaderFileInfoLookupTable *Table 4169 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 4170 if (!Table) 4171 return false; 4172 4173 // Look in the on-disk hash table for an entry for this file name. 4174 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(), 4175 &Trait); 4176 if (Pos == Table->end()) 4177 return false; 4178 4179 This->HFI = *Pos; 4180 return true; 4181 } 4182 4183 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 4184 }; 4185} 4186 4187HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 4188 HeaderFileInfoVisitor Visitor(*this, FE); 4189 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 4190 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 4191 if (Listener) 4192 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 4193 return *HFI; 4194 } 4195 4196 return HeaderFileInfo(); 4197} 4198 4199void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 4200 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4201 ModuleFile &F = *(*I); 4202 unsigned Idx = 0; 4203 while (Idx < F.PragmaDiagMappings.size()) { 4204 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 4205 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 4206 Diag.DiagStatePoints.push_back( 4207 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(), 4208 FullSourceLoc(Loc, SourceMgr))); 4209 while (1) { 4210 assert(Idx < F.PragmaDiagMappings.size() && 4211 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 4212 if (Idx >= F.PragmaDiagMappings.size()) { 4213 break; // Something is messed up but at least avoid infinite loop in 4214 // release build. 4215 } 4216 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 4217 if (DiagID == (unsigned)-1) { 4218 break; // no more diag/map pairs for this location. 4219 } 4220 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 4221 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 4222 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 4223 } 4224 } 4225 } 4226} 4227 4228/// \brief Get the correct cursor and offset for loading a type. 4229ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 4230 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 4231 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 4232 ModuleFile *M = I->second; 4233 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 4234} 4235 4236/// \brief Read and return the type with the given index.. 4237/// 4238/// The index is the type ID, shifted and minus the number of predefs. This 4239/// routine actually reads the record corresponding to the type at the given 4240/// location. It is a helper routine for GetType, which deals with reading type 4241/// IDs. 4242QualType ASTReader::readTypeRecord(unsigned Index) { 4243 RecordLocation Loc = TypeCursorForIndex(Index); 4244 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 4245 4246 // Keep track of where we are in the stream, then jump back there 4247 // after reading this type. 4248 SavedStreamPosition SavedPosition(DeclsCursor); 4249 4250 ReadingKindTracker ReadingKind(Read_Type, *this); 4251 4252 // Note that we are loading a type record. 4253 Deserializing AType(this); 4254 4255 unsigned Idx = 0; 4256 DeclsCursor.JumpToBit(Loc.Offset); 4257 RecordData Record; 4258 unsigned Code = DeclsCursor.ReadCode(); 4259 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 4260 case TYPE_EXT_QUAL: { 4261 if (Record.size() != 2) { 4262 Error("Incorrect encoding of extended qualifier type"); 4263 return QualType(); 4264 } 4265 QualType Base = readType(*Loc.F, Record, Idx); 4266 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 4267 return Context.getQualifiedType(Base, Quals); 4268 } 4269 4270 case TYPE_COMPLEX: { 4271 if (Record.size() != 1) { 4272 Error("Incorrect encoding of complex type"); 4273 return QualType(); 4274 } 4275 QualType ElemType = readType(*Loc.F, Record, Idx); 4276 return Context.getComplexType(ElemType); 4277 } 4278 4279 case TYPE_POINTER: { 4280 if (Record.size() != 1) { 4281 Error("Incorrect encoding of pointer type"); 4282 return QualType(); 4283 } 4284 QualType PointeeType = readType(*Loc.F, Record, Idx); 4285 return Context.getPointerType(PointeeType); 4286 } 4287 4288 case TYPE_BLOCK_POINTER: { 4289 if (Record.size() != 1) { 4290 Error("Incorrect encoding of block pointer type"); 4291 return QualType(); 4292 } 4293 QualType PointeeType = readType(*Loc.F, Record, Idx); 4294 return Context.getBlockPointerType(PointeeType); 4295 } 4296 4297 case TYPE_LVALUE_REFERENCE: { 4298 if (Record.size() != 2) { 4299 Error("Incorrect encoding of lvalue reference type"); 4300 return QualType(); 4301 } 4302 QualType PointeeType = readType(*Loc.F, Record, Idx); 4303 return Context.getLValueReferenceType(PointeeType, Record[1]); 4304 } 4305 4306 case TYPE_RVALUE_REFERENCE: { 4307 if (Record.size() != 1) { 4308 Error("Incorrect encoding of rvalue reference type"); 4309 return QualType(); 4310 } 4311 QualType PointeeType = readType(*Loc.F, Record, Idx); 4312 return Context.getRValueReferenceType(PointeeType); 4313 } 4314 4315 case TYPE_MEMBER_POINTER: { 4316 if (Record.size() != 2) { 4317 Error("Incorrect encoding of member pointer type"); 4318 return QualType(); 4319 } 4320 QualType PointeeType = readType(*Loc.F, Record, Idx); 4321 QualType ClassType = readType(*Loc.F, Record, Idx); 4322 if (PointeeType.isNull() || ClassType.isNull()) 4323 return QualType(); 4324 4325 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 4326 } 4327 4328 case TYPE_CONSTANT_ARRAY: { 4329 QualType ElementType = readType(*Loc.F, Record, Idx); 4330 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4331 unsigned IndexTypeQuals = Record[2]; 4332 unsigned Idx = 3; 4333 llvm::APInt Size = ReadAPInt(Record, Idx); 4334 return Context.getConstantArrayType(ElementType, Size, 4335 ASM, IndexTypeQuals); 4336 } 4337 4338 case TYPE_INCOMPLETE_ARRAY: { 4339 QualType ElementType = readType(*Loc.F, Record, Idx); 4340 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4341 unsigned IndexTypeQuals = Record[2]; 4342 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 4343 } 4344 4345 case TYPE_VARIABLE_ARRAY: { 4346 QualType ElementType = readType(*Loc.F, Record, Idx); 4347 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4348 unsigned IndexTypeQuals = Record[2]; 4349 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 4350 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 4351 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 4352 ASM, IndexTypeQuals, 4353 SourceRange(LBLoc, RBLoc)); 4354 } 4355 4356 case TYPE_VECTOR: { 4357 if (Record.size() != 3) { 4358 Error("incorrect encoding of vector type in AST file"); 4359 return QualType(); 4360 } 4361 4362 QualType ElementType = readType(*Loc.F, Record, Idx); 4363 unsigned NumElements = Record[1]; 4364 unsigned VecKind = Record[2]; 4365 return Context.getVectorType(ElementType, NumElements, 4366 (VectorType::VectorKind)VecKind); 4367 } 4368 4369 case TYPE_EXT_VECTOR: { 4370 if (Record.size() != 3) { 4371 Error("incorrect encoding of extended vector type in AST file"); 4372 return QualType(); 4373 } 4374 4375 QualType ElementType = readType(*Loc.F, Record, Idx); 4376 unsigned NumElements = Record[1]; 4377 return Context.getExtVectorType(ElementType, NumElements); 4378 } 4379 4380 case TYPE_FUNCTION_NO_PROTO: { 4381 if (Record.size() != 6) { 4382 Error("incorrect encoding of no-proto function type"); 4383 return QualType(); 4384 } 4385 QualType ResultType = readType(*Loc.F, Record, Idx); 4386 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 4387 (CallingConv)Record[4], Record[5]); 4388 return Context.getFunctionNoProtoType(ResultType, Info); 4389 } 4390 4391 case TYPE_FUNCTION_PROTO: { 4392 QualType ResultType = readType(*Loc.F, Record, Idx); 4393 4394 FunctionProtoType::ExtProtoInfo EPI; 4395 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 4396 /*hasregparm*/ Record[2], 4397 /*regparm*/ Record[3], 4398 static_cast<CallingConv>(Record[4]), 4399 /*produces*/ Record[5]); 4400 4401 unsigned Idx = 6; 4402 unsigned NumParams = Record[Idx++]; 4403 SmallVector<QualType, 16> ParamTypes; 4404 for (unsigned I = 0; I != NumParams; ++I) 4405 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 4406 4407 EPI.Variadic = Record[Idx++]; 4408 EPI.HasTrailingReturn = Record[Idx++]; 4409 EPI.TypeQuals = Record[Idx++]; 4410 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 4411 ExceptionSpecificationType EST = 4412 static_cast<ExceptionSpecificationType>(Record[Idx++]); 4413 EPI.ExceptionSpecType = EST; 4414 SmallVector<QualType, 2> Exceptions; 4415 if (EST == EST_Dynamic) { 4416 EPI.NumExceptions = Record[Idx++]; 4417 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 4418 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 4419 EPI.Exceptions = Exceptions.data(); 4420 } else if (EST == EST_ComputedNoexcept) { 4421 EPI.NoexceptExpr = ReadExpr(*Loc.F); 4422 } else if (EST == EST_Uninstantiated) { 4423 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4424 EPI.ExceptionSpecTemplate = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4425 } else if (EST == EST_Unevaluated) { 4426 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4427 } 4428 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams, 4429 EPI); 4430 } 4431 4432 case TYPE_UNRESOLVED_USING: { 4433 unsigned Idx = 0; 4434 return Context.getTypeDeclType( 4435 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 4436 } 4437 4438 case TYPE_TYPEDEF: { 4439 if (Record.size() != 2) { 4440 Error("incorrect encoding of typedef type"); 4441 return QualType(); 4442 } 4443 unsigned Idx = 0; 4444 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 4445 QualType Canonical = readType(*Loc.F, Record, Idx); 4446 if (!Canonical.isNull()) 4447 Canonical = Context.getCanonicalType(Canonical); 4448 return Context.getTypedefType(Decl, Canonical); 4449 } 4450 4451 case TYPE_TYPEOF_EXPR: 4452 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 4453 4454 case TYPE_TYPEOF: { 4455 if (Record.size() != 1) { 4456 Error("incorrect encoding of typeof(type) in AST file"); 4457 return QualType(); 4458 } 4459 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4460 return Context.getTypeOfType(UnderlyingType); 4461 } 4462 4463 case TYPE_DECLTYPE: { 4464 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4465 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType); 4466 } 4467 4468 case TYPE_UNARY_TRANSFORM: { 4469 QualType BaseType = readType(*Loc.F, Record, Idx); 4470 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4471 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 4472 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 4473 } 4474 4475 case TYPE_AUTO: 4476 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 4477 4478 case TYPE_RECORD: { 4479 if (Record.size() != 2) { 4480 Error("incorrect encoding of record type"); 4481 return QualType(); 4482 } 4483 unsigned Idx = 0; 4484 bool IsDependent = Record[Idx++]; 4485 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx); 4486 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl()); 4487 QualType T = Context.getRecordType(RD); 4488 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4489 return T; 4490 } 4491 4492 case TYPE_ENUM: { 4493 if (Record.size() != 2) { 4494 Error("incorrect encoding of enum type"); 4495 return QualType(); 4496 } 4497 unsigned Idx = 0; 4498 bool IsDependent = Record[Idx++]; 4499 QualType T 4500 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 4501 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4502 return T; 4503 } 4504 4505 case TYPE_ATTRIBUTED: { 4506 if (Record.size() != 3) { 4507 Error("incorrect encoding of attributed type"); 4508 return QualType(); 4509 } 4510 QualType modifiedType = readType(*Loc.F, Record, Idx); 4511 QualType equivalentType = readType(*Loc.F, Record, Idx); 4512 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 4513 return Context.getAttributedType(kind, modifiedType, equivalentType); 4514 } 4515 4516 case TYPE_PAREN: { 4517 if (Record.size() != 1) { 4518 Error("incorrect encoding of paren type"); 4519 return QualType(); 4520 } 4521 QualType InnerType = readType(*Loc.F, Record, Idx); 4522 return Context.getParenType(InnerType); 4523 } 4524 4525 case TYPE_PACK_EXPANSION: { 4526 if (Record.size() != 2) { 4527 Error("incorrect encoding of pack expansion type"); 4528 return QualType(); 4529 } 4530 QualType Pattern = readType(*Loc.F, Record, Idx); 4531 if (Pattern.isNull()) 4532 return QualType(); 4533 llvm::Optional<unsigned> NumExpansions; 4534 if (Record[1]) 4535 NumExpansions = Record[1] - 1; 4536 return Context.getPackExpansionType(Pattern, NumExpansions); 4537 } 4538 4539 case TYPE_ELABORATED: { 4540 unsigned Idx = 0; 4541 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4542 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4543 QualType NamedType = readType(*Loc.F, Record, Idx); 4544 return Context.getElaboratedType(Keyword, NNS, NamedType); 4545 } 4546 4547 case TYPE_OBJC_INTERFACE: { 4548 unsigned Idx = 0; 4549 ObjCInterfaceDecl *ItfD 4550 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 4551 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl()); 4552 } 4553 4554 case TYPE_OBJC_OBJECT: { 4555 unsigned Idx = 0; 4556 QualType Base = readType(*Loc.F, Record, Idx); 4557 unsigned NumProtos = Record[Idx++]; 4558 SmallVector<ObjCProtocolDecl*, 4> Protos; 4559 for (unsigned I = 0; I != NumProtos; ++I) 4560 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 4561 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 4562 } 4563 4564 case TYPE_OBJC_OBJECT_POINTER: { 4565 unsigned Idx = 0; 4566 QualType Pointee = readType(*Loc.F, Record, Idx); 4567 return Context.getObjCObjectPointerType(Pointee); 4568 } 4569 4570 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 4571 unsigned Idx = 0; 4572 QualType Parm = readType(*Loc.F, Record, Idx); 4573 QualType Replacement = readType(*Loc.F, Record, Idx); 4574 return 4575 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 4576 Replacement); 4577 } 4578 4579 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 4580 unsigned Idx = 0; 4581 QualType Parm = readType(*Loc.F, Record, Idx); 4582 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 4583 return Context.getSubstTemplateTypeParmPackType( 4584 cast<TemplateTypeParmType>(Parm), 4585 ArgPack); 4586 } 4587 4588 case TYPE_INJECTED_CLASS_NAME: { 4589 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 4590 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 4591 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 4592 // for AST reading, too much interdependencies. 4593 return 4594 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 4595 } 4596 4597 case TYPE_TEMPLATE_TYPE_PARM: { 4598 unsigned Idx = 0; 4599 unsigned Depth = Record[Idx++]; 4600 unsigned Index = Record[Idx++]; 4601 bool Pack = Record[Idx++]; 4602 TemplateTypeParmDecl *D 4603 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 4604 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 4605 } 4606 4607 case TYPE_DEPENDENT_NAME: { 4608 unsigned Idx = 0; 4609 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4610 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4611 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4612 QualType Canon = readType(*Loc.F, Record, Idx); 4613 if (!Canon.isNull()) 4614 Canon = Context.getCanonicalType(Canon); 4615 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 4616 } 4617 4618 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 4619 unsigned Idx = 0; 4620 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4621 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4622 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4623 unsigned NumArgs = Record[Idx++]; 4624 SmallVector<TemplateArgument, 8> Args; 4625 Args.reserve(NumArgs); 4626 while (NumArgs--) 4627 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 4628 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 4629 Args.size(), Args.data()); 4630 } 4631 4632 case TYPE_DEPENDENT_SIZED_ARRAY: { 4633 unsigned Idx = 0; 4634 4635 // ArrayType 4636 QualType ElementType = readType(*Loc.F, Record, Idx); 4637 ArrayType::ArraySizeModifier ASM 4638 = (ArrayType::ArraySizeModifier)Record[Idx++]; 4639 unsigned IndexTypeQuals = Record[Idx++]; 4640 4641 // DependentSizedArrayType 4642 Expr *NumElts = ReadExpr(*Loc.F); 4643 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 4644 4645 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 4646 IndexTypeQuals, Brackets); 4647 } 4648 4649 case TYPE_TEMPLATE_SPECIALIZATION: { 4650 unsigned Idx = 0; 4651 bool IsDependent = Record[Idx++]; 4652 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 4653 SmallVector<TemplateArgument, 8> Args; 4654 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 4655 QualType Underlying = readType(*Loc.F, Record, Idx); 4656 QualType T; 4657 if (Underlying.isNull()) 4658 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 4659 Args.size()); 4660 else 4661 T = Context.getTemplateSpecializationType(Name, Args.data(), 4662 Args.size(), Underlying); 4663 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4664 return T; 4665 } 4666 4667 case TYPE_ATOMIC: { 4668 if (Record.size() != 1) { 4669 Error("Incorrect encoding of atomic type"); 4670 return QualType(); 4671 } 4672 QualType ValueType = readType(*Loc.F, Record, Idx); 4673 return Context.getAtomicType(ValueType); 4674 } 4675 } 4676 llvm_unreachable("Invalid TypeCode!"); 4677} 4678 4679class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 4680 ASTReader &Reader; 4681 ModuleFile &F; 4682 const ASTReader::RecordData &Record; 4683 unsigned &Idx; 4684 4685 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4686 unsigned &I) { 4687 return Reader.ReadSourceLocation(F, R, I); 4688 } 4689 4690 template<typename T> 4691 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4692 return Reader.ReadDeclAs<T>(F, Record, Idx); 4693 } 4694 4695public: 4696 TypeLocReader(ASTReader &Reader, ModuleFile &F, 4697 const ASTReader::RecordData &Record, unsigned &Idx) 4698 : Reader(Reader), F(F), Record(Record), Idx(Idx) 4699 { } 4700 4701 // We want compile-time assurance that we've enumerated all of 4702 // these, so unfortunately we have to declare them first, then 4703 // define them out-of-line. 4704#define ABSTRACT_TYPELOC(CLASS, PARENT) 4705#define TYPELOC(CLASS, PARENT) \ 4706 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4707#include "clang/AST/TypeLocNodes.def" 4708 4709 void VisitFunctionTypeLoc(FunctionTypeLoc); 4710 void VisitArrayTypeLoc(ArrayTypeLoc); 4711}; 4712 4713void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4714 // nothing to do 4715} 4716void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4717 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4718 if (TL.needsExtraLocalData()) { 4719 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4720 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4721 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4722 TL.setModeAttr(Record[Idx++]); 4723 } 4724} 4725void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4726 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4727} 4728void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4729 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4730} 4731void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4732 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4733} 4734void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4735 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4736} 4737void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4738 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4739} 4740void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4741 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4742 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4743} 4744void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4745 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4746 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4747 if (Record[Idx++]) 4748 TL.setSizeExpr(Reader.ReadExpr(F)); 4749 else 4750 TL.setSizeExpr(0); 4751} 4752void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4753 VisitArrayTypeLoc(TL); 4754} 4755void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4756 VisitArrayTypeLoc(TL); 4757} 4758void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4759 VisitArrayTypeLoc(TL); 4760} 4761void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4762 DependentSizedArrayTypeLoc TL) { 4763 VisitArrayTypeLoc(TL); 4764} 4765void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4766 DependentSizedExtVectorTypeLoc TL) { 4767 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4768} 4769void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4770 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4771} 4772void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4773 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4774} 4775void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4776 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4777 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4778 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4779 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4780 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4781 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4782 } 4783} 4784void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4785 VisitFunctionTypeLoc(TL); 4786} 4787void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4788 VisitFunctionTypeLoc(TL); 4789} 4790void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4791 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4792} 4793void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4794 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4795} 4796void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4797 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4798 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4799 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4800} 4801void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4802 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4803 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4804 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4805 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4806} 4807void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4808 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4809} 4810void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4811 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4812 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4813 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4814 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4815} 4816void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4817 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4818} 4819void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4820 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4821} 4822void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4823 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4824} 4825void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4826 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4827 if (TL.hasAttrOperand()) { 4828 SourceRange range; 4829 range.setBegin(ReadSourceLocation(Record, Idx)); 4830 range.setEnd(ReadSourceLocation(Record, Idx)); 4831 TL.setAttrOperandParensRange(range); 4832 } 4833 if (TL.hasAttrExprOperand()) { 4834 if (Record[Idx++]) 4835 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4836 else 4837 TL.setAttrExprOperand(0); 4838 } else if (TL.hasAttrEnumOperand()) 4839 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4840} 4841void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4842 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4843} 4844void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4845 SubstTemplateTypeParmTypeLoc TL) { 4846 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4847} 4848void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4849 SubstTemplateTypeParmPackTypeLoc TL) { 4850 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4851} 4852void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4853 TemplateSpecializationTypeLoc TL) { 4854 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4855 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4856 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4857 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4858 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4859 TL.setArgLocInfo(i, 4860 Reader.GetTemplateArgumentLocInfo(F, 4861 TL.getTypePtr()->getArg(i).getKind(), 4862 Record, Idx)); 4863} 4864void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4865 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4866 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4867} 4868void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4869 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4870 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4871} 4872void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4873 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4874} 4875void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4876 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4877 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4878 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4879} 4880void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4881 DependentTemplateSpecializationTypeLoc TL) { 4882 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 4883 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4884 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 4885 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4886 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4887 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4888 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4889 TL.setArgLocInfo(I, 4890 Reader.GetTemplateArgumentLocInfo(F, 4891 TL.getTypePtr()->getArg(I).getKind(), 4892 Record, Idx)); 4893} 4894void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4895 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4896} 4897void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4898 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4899} 4900void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4901 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4902 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4903 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4904 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4905 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4906} 4907void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4908 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4909} 4910void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4911 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4912 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4913 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4914} 4915 4916TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 4917 const RecordData &Record, 4918 unsigned &Idx) { 4919 QualType InfoTy = readType(F, Record, Idx); 4920 if (InfoTy.isNull()) 4921 return 0; 4922 4923 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 4924 TypeLocReader TLR(*this, F, Record, Idx); 4925 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4926 TLR.Visit(TL); 4927 return TInfo; 4928} 4929 4930QualType ASTReader::GetType(TypeID ID) { 4931 unsigned FastQuals = ID & Qualifiers::FastMask; 4932 unsigned Index = ID >> Qualifiers::FastWidth; 4933 4934 if (Index < NUM_PREDEF_TYPE_IDS) { 4935 QualType T; 4936 switch ((PredefinedTypeIDs)Index) { 4937 case PREDEF_TYPE_NULL_ID: return QualType(); 4938 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 4939 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 4940 4941 case PREDEF_TYPE_CHAR_U_ID: 4942 case PREDEF_TYPE_CHAR_S_ID: 4943 // FIXME: Check that the signedness of CharTy is correct! 4944 T = Context.CharTy; 4945 break; 4946 4947 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 4948 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 4949 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 4950 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 4951 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 4952 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 4953 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 4954 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 4955 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 4956 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 4957 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 4958 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 4959 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 4960 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 4961 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 4962 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 4963 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 4964 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 4965 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 4966 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 4967 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 4968 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 4969 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 4970 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 4971 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 4972 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 4973 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 4974 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 4975 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 4976 4977 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 4978 T = Context.getAutoRRefDeductType(); 4979 break; 4980 4981 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 4982 T = Context.ARCUnbridgedCastTy; 4983 break; 4984 4985 case PREDEF_TYPE_VA_LIST_TAG: 4986 T = Context.getVaListTagType(); 4987 break; 4988 4989 case PREDEF_TYPE_BUILTIN_FN: 4990 T = Context.BuiltinFnTy; 4991 break; 4992 } 4993 4994 assert(!T.isNull() && "Unknown predefined type"); 4995 return T.withFastQualifiers(FastQuals); 4996 } 4997 4998 Index -= NUM_PREDEF_TYPE_IDS; 4999 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 5000 if (TypesLoaded[Index].isNull()) { 5001 TypesLoaded[Index] = readTypeRecord(Index); 5002 if (TypesLoaded[Index].isNull()) 5003 return QualType(); 5004 5005 TypesLoaded[Index]->setFromAST(); 5006 if (DeserializationListener) 5007 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 5008 TypesLoaded[Index]); 5009 } 5010 5011 return TypesLoaded[Index].withFastQualifiers(FastQuals); 5012} 5013 5014QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 5015 return GetType(getGlobalTypeID(F, LocalID)); 5016} 5017 5018serialization::TypeID 5019ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 5020 unsigned FastQuals = LocalID & Qualifiers::FastMask; 5021 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 5022 5023 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 5024 return LocalID; 5025 5026 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5027 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 5028 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 5029 5030 unsigned GlobalIndex = LocalIndex + I->second; 5031 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 5032} 5033 5034TemplateArgumentLocInfo 5035ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 5036 TemplateArgument::ArgKind Kind, 5037 const RecordData &Record, 5038 unsigned &Index) { 5039 switch (Kind) { 5040 case TemplateArgument::Expression: 5041 return ReadExpr(F); 5042 case TemplateArgument::Type: 5043 return GetTypeSourceInfo(F, Record, Index); 5044 case TemplateArgument::Template: { 5045 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5046 Index); 5047 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5048 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5049 SourceLocation()); 5050 } 5051 case TemplateArgument::TemplateExpansion: { 5052 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5053 Index); 5054 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5055 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 5056 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5057 EllipsisLoc); 5058 } 5059 case TemplateArgument::Null: 5060 case TemplateArgument::Integral: 5061 case TemplateArgument::Declaration: 5062 case TemplateArgument::NullPtr: 5063 case TemplateArgument::Pack: 5064 // FIXME: Is this right? 5065 return TemplateArgumentLocInfo(); 5066 } 5067 llvm_unreachable("unexpected template argument loc"); 5068} 5069 5070TemplateArgumentLoc 5071ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 5072 const RecordData &Record, unsigned &Index) { 5073 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 5074 5075 if (Arg.getKind() == TemplateArgument::Expression) { 5076 if (Record[Index++]) // bool InfoHasSameExpr. 5077 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 5078 } 5079 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 5080 Record, Index)); 5081} 5082 5083Decl *ASTReader::GetExternalDecl(uint32_t ID) { 5084 return GetDecl(ID); 5085} 5086 5087uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 5088 unsigned &Idx){ 5089 if (Idx >= Record.size()) 5090 return 0; 5091 5092 unsigned LocalID = Record[Idx++]; 5093 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 5094} 5095 5096CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 5097 RecordLocation Loc = getLocalBitOffset(Offset); 5098 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 5099 SavedStreamPosition SavedPosition(Cursor); 5100 Cursor.JumpToBit(Loc.Offset); 5101 ReadingKindTracker ReadingKind(Read_Decl, *this); 5102 RecordData Record; 5103 unsigned Code = Cursor.ReadCode(); 5104 unsigned RecCode = Cursor.ReadRecord(Code, Record); 5105 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 5106 Error("Malformed AST file: missing C++ base specifiers"); 5107 return 0; 5108 } 5109 5110 unsigned Idx = 0; 5111 unsigned NumBases = Record[Idx++]; 5112 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 5113 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 5114 for (unsigned I = 0; I != NumBases; ++I) 5115 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 5116 return Bases; 5117} 5118 5119serialization::DeclID 5120ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const { 5121 if (LocalID < NUM_PREDEF_DECL_IDS) 5122 return LocalID; 5123 5124 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5125 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 5126 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 5127 5128 return LocalID + I->second; 5129} 5130 5131bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 5132 ModuleFile &M) const { 5133 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 5134 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5135 return &M == I->second; 5136} 5137 5138ModuleFile *ASTReader::getOwningModuleFile(Decl *D) { 5139 if (!D->isFromASTFile()) 5140 return 0; 5141 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID()); 5142 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5143 return I->second; 5144} 5145 5146SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 5147 if (ID < NUM_PREDEF_DECL_IDS) 5148 return SourceLocation(); 5149 5150 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5151 5152 if (Index > DeclsLoaded.size()) { 5153 Error("declaration ID out-of-range for AST file"); 5154 return SourceLocation(); 5155 } 5156 5157 if (Decl *D = DeclsLoaded[Index]) 5158 return D->getLocation(); 5159 5160 unsigned RawLocation = 0; 5161 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 5162 return ReadSourceLocation(*Rec.F, RawLocation); 5163} 5164 5165Decl *ASTReader::GetDecl(DeclID ID) { 5166 if (ID < NUM_PREDEF_DECL_IDS) { 5167 switch ((PredefinedDeclIDs)ID) { 5168 case PREDEF_DECL_NULL_ID: 5169 return 0; 5170 5171 case PREDEF_DECL_TRANSLATION_UNIT_ID: 5172 return Context.getTranslationUnitDecl(); 5173 5174 case PREDEF_DECL_OBJC_ID_ID: 5175 return Context.getObjCIdDecl(); 5176 5177 case PREDEF_DECL_OBJC_SEL_ID: 5178 return Context.getObjCSelDecl(); 5179 5180 case PREDEF_DECL_OBJC_CLASS_ID: 5181 return Context.getObjCClassDecl(); 5182 5183 case PREDEF_DECL_OBJC_PROTOCOL_ID: 5184 return Context.getObjCProtocolDecl(); 5185 5186 case PREDEF_DECL_INT_128_ID: 5187 return Context.getInt128Decl(); 5188 5189 case PREDEF_DECL_UNSIGNED_INT_128_ID: 5190 return Context.getUInt128Decl(); 5191 5192 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 5193 return Context.getObjCInstanceTypeDecl(); 5194 5195 case PREDEF_DECL_BUILTIN_VA_LIST_ID: 5196 return Context.getBuiltinVaListDecl(); 5197 } 5198 } 5199 5200 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5201 5202 if (Index >= DeclsLoaded.size()) { 5203 assert(0 && "declaration ID out-of-range for AST file"); 5204 Error("declaration ID out-of-range for AST file"); 5205 return 0; 5206 } 5207 5208 if (!DeclsLoaded[Index]) { 5209 ReadDeclRecord(ID); 5210 if (DeserializationListener) 5211 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 5212 } 5213 5214 return DeclsLoaded[Index]; 5215} 5216 5217DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 5218 DeclID GlobalID) { 5219 if (GlobalID < NUM_PREDEF_DECL_IDS) 5220 return GlobalID; 5221 5222 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 5223 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5224 ModuleFile *Owner = I->second; 5225 5226 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 5227 = M.GlobalToLocalDeclIDs.find(Owner); 5228 if (Pos == M.GlobalToLocalDeclIDs.end()) 5229 return 0; 5230 5231 return GlobalID - Owner->BaseDeclID + Pos->second; 5232} 5233 5234serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 5235 const RecordData &Record, 5236 unsigned &Idx) { 5237 if (Idx >= Record.size()) { 5238 Error("Corrupted AST file"); 5239 return 0; 5240 } 5241 5242 return getGlobalDeclID(F, Record[Idx++]); 5243} 5244 5245/// \brief Resolve the offset of a statement into a statement. 5246/// 5247/// This operation will read a new statement from the external 5248/// source each time it is called, and is meant to be used via a 5249/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 5250Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 5251 // Switch case IDs are per Decl. 5252 ClearSwitchCaseIDs(); 5253 5254 // Offset here is a global offset across the entire chain. 5255 RecordLocation Loc = getLocalBitOffset(Offset); 5256 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 5257 return ReadStmtFromStream(*Loc.F); 5258} 5259 5260namespace { 5261 class FindExternalLexicalDeclsVisitor { 5262 ASTReader &Reader; 5263 const DeclContext *DC; 5264 bool (*isKindWeWant)(Decl::Kind); 5265 5266 SmallVectorImpl<Decl*> &Decls; 5267 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 5268 5269 public: 5270 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 5271 bool (*isKindWeWant)(Decl::Kind), 5272 SmallVectorImpl<Decl*> &Decls) 5273 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 5274 { 5275 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 5276 PredefsVisited[I] = false; 5277 } 5278 5279 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 5280 if (Preorder) 5281 return false; 5282 5283 FindExternalLexicalDeclsVisitor *This 5284 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 5285 5286 ModuleFile::DeclContextInfosMap::iterator Info 5287 = M.DeclContextInfos.find(This->DC); 5288 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 5289 return false; 5290 5291 // Load all of the declaration IDs 5292 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 5293 *IDE = ID + Info->second.NumLexicalDecls; 5294 ID != IDE; ++ID) { 5295 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 5296 continue; 5297 5298 // Don't add predefined declarations to the lexical context more 5299 // than once. 5300 if (ID->second < NUM_PREDEF_DECL_IDS) { 5301 if (This->PredefsVisited[ID->second]) 5302 continue; 5303 5304 This->PredefsVisited[ID->second] = true; 5305 } 5306 5307 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 5308 if (!This->DC->isDeclInLexicalTraversal(D)) 5309 This->Decls.push_back(D); 5310 } 5311 } 5312 5313 return false; 5314 } 5315 }; 5316} 5317 5318ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 5319 bool (*isKindWeWant)(Decl::Kind), 5320 SmallVectorImpl<Decl*> &Decls) { 5321 // There might be lexical decls in multiple modules, for the TU at 5322 // least. Walk all of the modules in the order they were loaded. 5323 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 5324 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 5325 ++NumLexicalDeclContextsRead; 5326 return ELR_Success; 5327} 5328 5329namespace { 5330 5331class DeclIDComp { 5332 ASTReader &Reader; 5333 ModuleFile &Mod; 5334 5335public: 5336 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 5337 5338 bool operator()(LocalDeclID L, LocalDeclID R) const { 5339 SourceLocation LHS = getLocation(L); 5340 SourceLocation RHS = getLocation(R); 5341 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5342 } 5343 5344 bool operator()(SourceLocation LHS, LocalDeclID R) const { 5345 SourceLocation RHS = getLocation(R); 5346 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5347 } 5348 5349 bool operator()(LocalDeclID L, SourceLocation RHS) const { 5350 SourceLocation LHS = getLocation(L); 5351 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5352 } 5353 5354 SourceLocation getLocation(LocalDeclID ID) const { 5355 return Reader.getSourceManager().getFileLoc( 5356 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 5357 } 5358}; 5359 5360} 5361 5362void ASTReader::FindFileRegionDecls(FileID File, 5363 unsigned Offset, unsigned Length, 5364 SmallVectorImpl<Decl *> &Decls) { 5365 SourceManager &SM = getSourceManager(); 5366 5367 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 5368 if (I == FileDeclIDs.end()) 5369 return; 5370 5371 FileDeclsInfo &DInfo = I->second; 5372 if (DInfo.Decls.empty()) 5373 return; 5374 5375 SourceLocation 5376 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 5377 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 5378 5379 DeclIDComp DIDComp(*this, *DInfo.Mod); 5380 ArrayRef<serialization::LocalDeclID>::iterator 5381 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5382 BeginLoc, DIDComp); 5383 if (BeginIt != DInfo.Decls.begin()) 5384 --BeginIt; 5385 5386 // If we are pointing at a top-level decl inside an objc container, we need 5387 // to backtrack until we find it otherwise we will fail to report that the 5388 // region overlaps with an objc container. 5389 while (BeginIt != DInfo.Decls.begin() && 5390 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 5391 ->isTopLevelDeclInObjCContainer()) 5392 --BeginIt; 5393 5394 ArrayRef<serialization::LocalDeclID>::iterator 5395 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5396 EndLoc, DIDComp); 5397 if (EndIt != DInfo.Decls.end()) 5398 ++EndIt; 5399 5400 for (ArrayRef<serialization::LocalDeclID>::iterator 5401 DIt = BeginIt; DIt != EndIt; ++DIt) 5402 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 5403} 5404 5405namespace { 5406 /// \brief ModuleFile visitor used to perform name lookup into a 5407 /// declaration context. 5408 class DeclContextNameLookupVisitor { 5409 ASTReader &Reader; 5410 llvm::SmallVectorImpl<const DeclContext *> &Contexts; 5411 DeclarationName Name; 5412 SmallVectorImpl<NamedDecl *> &Decls; 5413 5414 public: 5415 DeclContextNameLookupVisitor(ASTReader &Reader, 5416 SmallVectorImpl<const DeclContext *> &Contexts, 5417 DeclarationName Name, 5418 SmallVectorImpl<NamedDecl *> &Decls) 5419 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { } 5420 5421 static bool visit(ModuleFile &M, void *UserData) { 5422 DeclContextNameLookupVisitor *This 5423 = static_cast<DeclContextNameLookupVisitor *>(UserData); 5424 5425 // Check whether we have any visible declaration information for 5426 // this context in this module. 5427 ModuleFile::DeclContextInfosMap::iterator Info; 5428 bool FoundInfo = false; 5429 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5430 Info = M.DeclContextInfos.find(This->Contexts[I]); 5431 if (Info != M.DeclContextInfos.end() && 5432 Info->second.NameLookupTableData) { 5433 FoundInfo = true; 5434 break; 5435 } 5436 } 5437 5438 if (!FoundInfo) 5439 return false; 5440 5441 // Look for this name within this module. 5442 ASTDeclContextNameLookupTable *LookupTable = 5443 Info->second.NameLookupTableData; 5444 ASTDeclContextNameLookupTable::iterator Pos 5445 = LookupTable->find(This->Name); 5446 if (Pos == LookupTable->end()) 5447 return false; 5448 5449 bool FoundAnything = false; 5450 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 5451 for (; Data.first != Data.second; ++Data.first) { 5452 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 5453 if (!ND) 5454 continue; 5455 5456 if (ND->getDeclName() != This->Name) { 5457 // A name might be null because the decl's redeclarable part is 5458 // currently read before reading its name. The lookup is triggered by 5459 // building that decl (likely indirectly), and so it is later in the 5460 // sense of "already existing" and can be ignored here. 5461 continue; 5462 } 5463 5464 // Record this declaration. 5465 FoundAnything = true; 5466 This->Decls.push_back(ND); 5467 } 5468 5469 return FoundAnything; 5470 } 5471 }; 5472} 5473 5474DeclContext::lookup_result 5475ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 5476 DeclarationName Name) { 5477 assert(DC->hasExternalVisibleStorage() && 5478 "DeclContext has no visible decls in storage"); 5479 if (!Name) 5480 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 5481 DeclContext::lookup_iterator(0)); 5482 5483 SmallVector<NamedDecl *, 64> Decls; 5484 5485 // Compute the declaration contexts we need to look into. Multiple such 5486 // declaration contexts occur when two declaration contexts from disjoint 5487 // modules get merged, e.g., when two namespaces with the same name are 5488 // independently defined in separate modules. 5489 SmallVector<const DeclContext *, 2> Contexts; 5490 Contexts.push_back(DC); 5491 5492 if (DC->isNamespace()) { 5493 MergedDeclsMap::iterator Merged 5494 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5495 if (Merged != MergedDecls.end()) { 5496 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5497 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5498 } 5499 } 5500 5501 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls); 5502 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 5503 ++NumVisibleDeclContextsRead; 5504 SetExternalVisibleDeclsForName(DC, Name, Decls); 5505 return const_cast<DeclContext*>(DC)->lookup(Name); 5506} 5507 5508namespace { 5509 /// \brief ModuleFile visitor used to retrieve all visible names in a 5510 /// declaration context. 5511 class DeclContextAllNamesVisitor { 5512 ASTReader &Reader; 5513 llvm::SmallVectorImpl<const DeclContext *> &Contexts; 5514 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls; 5515 5516 public: 5517 DeclContextAllNamesVisitor(ASTReader &Reader, 5518 SmallVectorImpl<const DeclContext *> &Contexts, 5519 llvm::DenseMap<DeclarationName, 5520 SmallVector<NamedDecl *, 8> > &Decls) 5521 : Reader(Reader), Contexts(Contexts), Decls(Decls) { } 5522 5523 static bool visit(ModuleFile &M, void *UserData) { 5524 DeclContextAllNamesVisitor *This 5525 = static_cast<DeclContextAllNamesVisitor *>(UserData); 5526 5527 // Check whether we have any visible declaration information for 5528 // this context in this module. 5529 ModuleFile::DeclContextInfosMap::iterator Info; 5530 bool FoundInfo = false; 5531 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5532 Info = M.DeclContextInfos.find(This->Contexts[I]); 5533 if (Info != M.DeclContextInfos.end() && 5534 Info->second.NameLookupTableData) { 5535 FoundInfo = true; 5536 break; 5537 } 5538 } 5539 5540 if (!FoundInfo) 5541 return false; 5542 5543 ASTDeclContextNameLookupTable *LookupTable = 5544 Info->second.NameLookupTableData; 5545 bool FoundAnything = false; 5546 for (ASTDeclContextNameLookupTable::data_iterator 5547 I = LookupTable->data_begin(), E = LookupTable->data_end(); 5548 I != E; ++I) { 5549 ASTDeclContextNameLookupTrait::data_type Data = *I; 5550 for (; Data.first != Data.second; ++Data.first) { 5551 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, 5552 *Data.first); 5553 if (!ND) 5554 continue; 5555 5556 // Record this declaration. 5557 FoundAnything = true; 5558 This->Decls[ND->getDeclName()].push_back(ND); 5559 } 5560 } 5561 5562 return FoundAnything; 5563 } 5564 }; 5565} 5566 5567void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) { 5568 if (!DC->hasExternalVisibleStorage()) 5569 return; 5570 llvm::DenseMap<DeclarationName, llvm::SmallVector<NamedDecl*, 8> > Decls; 5571 5572 // Compute the declaration contexts we need to look into. Multiple such 5573 // declaration contexts occur when two declaration contexts from disjoint 5574 // modules get merged, e.g., when two namespaces with the same name are 5575 // independently defined in separate modules. 5576 SmallVector<const DeclContext *, 2> Contexts; 5577 Contexts.push_back(DC); 5578 5579 if (DC->isNamespace()) { 5580 MergedDeclsMap::iterator Merged 5581 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5582 if (Merged != MergedDecls.end()) { 5583 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5584 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5585 } 5586 } 5587 5588 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls); 5589 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor); 5590 ++NumVisibleDeclContextsRead; 5591 5592 for (llvm::DenseMap<DeclarationName, 5593 llvm::SmallVector<NamedDecl*, 8> >::iterator 5594 I = Decls.begin(), E = Decls.end(); I != E; ++I) { 5595 SetExternalVisibleDeclsForName(DC, I->first, I->second); 5596 } 5597 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false); 5598} 5599 5600/// \brief Under non-PCH compilation the consumer receives the objc methods 5601/// before receiving the implementation, and codegen depends on this. 5602/// We simulate this by deserializing and passing to consumer the methods of the 5603/// implementation before passing the deserialized implementation decl. 5604static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 5605 ASTConsumer *Consumer) { 5606 assert(ImplD && Consumer); 5607 5608 for (ObjCImplDecl::method_iterator 5609 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 5610 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 5611 5612 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 5613} 5614 5615void ASTReader::PassInterestingDeclsToConsumer() { 5616 assert(Consumer); 5617 while (!InterestingDecls.empty()) { 5618 Decl *D = InterestingDecls.front(); 5619 InterestingDecls.pop_front(); 5620 5621 PassInterestingDeclToConsumer(D); 5622 } 5623} 5624 5625void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 5626 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 5627 PassObjCImplDeclToConsumer(ImplD, Consumer); 5628 else 5629 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 5630} 5631 5632void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 5633 this->Consumer = Consumer; 5634 5635 if (!Consumer) 5636 return; 5637 5638 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 5639 // Force deserialization of this decl, which will cause it to be queued for 5640 // passing to the consumer. 5641 GetDecl(ExternalDefinitions[I]); 5642 } 5643 ExternalDefinitions.clear(); 5644 5645 PassInterestingDeclsToConsumer(); 5646} 5647 5648void ASTReader::PrintStats() { 5649 std::fprintf(stderr, "*** AST File Statistics:\n"); 5650 5651 unsigned NumTypesLoaded 5652 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 5653 QualType()); 5654 unsigned NumDeclsLoaded 5655 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 5656 (Decl *)0); 5657 unsigned NumIdentifiersLoaded 5658 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 5659 IdentifiersLoaded.end(), 5660 (IdentifierInfo *)0); 5661 unsigned NumMacrosLoaded 5662 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(), 5663 MacrosLoaded.end(), 5664 (MacroInfo *)0); 5665 unsigned NumSelectorsLoaded 5666 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 5667 SelectorsLoaded.end(), 5668 Selector()); 5669 5670 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 5671 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 5672 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 5673 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 5674 NumSLocEntriesRead, TotalNumSLocEntries, 5675 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 5676 if (!TypesLoaded.empty()) 5677 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 5678 NumTypesLoaded, (unsigned)TypesLoaded.size(), 5679 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 5680 if (!DeclsLoaded.empty()) 5681 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 5682 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 5683 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 5684 if (!IdentifiersLoaded.empty()) 5685 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 5686 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 5687 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 5688 if (!MacrosLoaded.empty()) 5689 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5690 NumMacrosLoaded, (unsigned)MacrosLoaded.size(), 5691 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100)); 5692 if (!SelectorsLoaded.empty()) 5693 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 5694 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 5695 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 5696 if (TotalNumStatements) 5697 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 5698 NumStatementsRead, TotalNumStatements, 5699 ((float)NumStatementsRead/TotalNumStatements * 100)); 5700 if (TotalNumMacros) 5701 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 5702 NumMacrosRead, TotalNumMacros, 5703 ((float)NumMacrosRead/TotalNumMacros * 100)); 5704 if (TotalLexicalDeclContexts) 5705 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 5706 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 5707 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 5708 * 100)); 5709 if (TotalVisibleDeclContexts) 5710 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 5711 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 5712 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 5713 * 100)); 5714 if (TotalNumMethodPoolEntries) { 5715 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 5716 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 5717 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 5718 * 100)); 5719 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 5720 } 5721 std::fprintf(stderr, "\n"); 5722 dump(); 5723 std::fprintf(stderr, "\n"); 5724} 5725 5726template<typename Key, typename ModuleFile, unsigned InitialCapacity> 5727static void 5728dumpModuleIDMap(StringRef Name, 5729 const ContinuousRangeMap<Key, ModuleFile *, 5730 InitialCapacity> &Map) { 5731 if (Map.begin() == Map.end()) 5732 return; 5733 5734 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 5735 llvm::errs() << Name << ":\n"; 5736 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5737 I != IEnd; ++I) { 5738 llvm::errs() << " " << I->first << " -> " << I->second->FileName 5739 << "\n"; 5740 } 5741} 5742 5743void ASTReader::dump() { 5744 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 5745 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 5746 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 5747 dumpModuleIDMap("Global type map", GlobalTypeMap); 5748 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 5749 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 5750 dumpModuleIDMap("Global macro map", GlobalMacroMap); 5751 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 5752 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 5753 dumpModuleIDMap("Global preprocessed entity map", 5754 GlobalPreprocessedEntityMap); 5755 5756 llvm::errs() << "\n*** PCH/Modules Loaded:"; 5757 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 5758 MEnd = ModuleMgr.end(); 5759 M != MEnd; ++M) 5760 (*M)->dump(); 5761} 5762 5763/// Return the amount of memory used by memory buffers, breaking down 5764/// by heap-backed versus mmap'ed memory. 5765void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 5766 for (ModuleConstIterator I = ModuleMgr.begin(), 5767 E = ModuleMgr.end(); I != E; ++I) { 5768 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 5769 size_t bytes = buf->getBufferSize(); 5770 switch (buf->getBufferKind()) { 5771 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 5772 sizes.malloc_bytes += bytes; 5773 break; 5774 case llvm::MemoryBuffer::MemoryBuffer_MMap: 5775 sizes.mmap_bytes += bytes; 5776 break; 5777 } 5778 } 5779 } 5780} 5781 5782void ASTReader::InitializeSema(Sema &S) { 5783 SemaObj = &S; 5784 S.addExternalSource(this); 5785 5786 // Makes sure any declarations that were deserialized "too early" 5787 // still get added to the identifier's declaration chains. 5788 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 5789 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I], 5790 PreloadedDecls[I]->getDeclName()); 5791 } 5792 PreloadedDecls.clear(); 5793 5794 // Load the offsets of the declarations that Sema references. 5795 // They will be lazily deserialized when needed. 5796 if (!SemaDeclRefs.empty()) { 5797 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 5798 if (!SemaObj->StdNamespace) 5799 SemaObj->StdNamespace = SemaDeclRefs[0]; 5800 if (!SemaObj->StdBadAlloc) 5801 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 5802 } 5803 5804 if (!FPPragmaOptions.empty()) { 5805 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 5806 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 5807 } 5808 5809 if (!OpenCLExtensions.empty()) { 5810 unsigned I = 0; 5811#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 5812#include "clang/Basic/OpenCLExtensions.def" 5813 5814 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 5815 } 5816} 5817 5818IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 5819 // Note that we are loading an identifier. 5820 Deserializing AnIdentifier(this); 5821 5822 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart), 5823 /*PriorGeneration=*/0); 5824 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 5825 IdentifierInfo *II = Visitor.getIdentifierInfo(); 5826 markIdentifierUpToDate(II); 5827 return II; 5828} 5829 5830namespace clang { 5831 /// \brief An identifier-lookup iterator that enumerates all of the 5832 /// identifiers stored within a set of AST files. 5833 class ASTIdentifierIterator : public IdentifierIterator { 5834 /// \brief The AST reader whose identifiers are being enumerated. 5835 const ASTReader &Reader; 5836 5837 /// \brief The current index into the chain of AST files stored in 5838 /// the AST reader. 5839 unsigned Index; 5840 5841 /// \brief The current position within the identifier lookup table 5842 /// of the current AST file. 5843 ASTIdentifierLookupTable::key_iterator Current; 5844 5845 /// \brief The end position within the identifier lookup table of 5846 /// the current AST file. 5847 ASTIdentifierLookupTable::key_iterator End; 5848 5849 public: 5850 explicit ASTIdentifierIterator(const ASTReader &Reader); 5851 5852 virtual StringRef Next(); 5853 }; 5854} 5855 5856ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 5857 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 5858 ASTIdentifierLookupTable *IdTable 5859 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 5860 Current = IdTable->key_begin(); 5861 End = IdTable->key_end(); 5862} 5863 5864StringRef ASTIdentifierIterator::Next() { 5865 while (Current == End) { 5866 // If we have exhausted all of our AST files, we're done. 5867 if (Index == 0) 5868 return StringRef(); 5869 5870 --Index; 5871 ASTIdentifierLookupTable *IdTable 5872 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 5873 IdentifierLookupTable; 5874 Current = IdTable->key_begin(); 5875 End = IdTable->key_end(); 5876 } 5877 5878 // We have any identifiers remaining in the current AST file; return 5879 // the next one. 5880 std::pair<const char*, unsigned> Key = *Current; 5881 ++Current; 5882 return StringRef(Key.first, Key.second); 5883} 5884 5885IdentifierIterator *ASTReader::getIdentifiers() const { 5886 return new ASTIdentifierIterator(*this); 5887} 5888 5889namespace clang { namespace serialization { 5890 class ReadMethodPoolVisitor { 5891 ASTReader &Reader; 5892 Selector Sel; 5893 unsigned PriorGeneration; 5894 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 5895 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 5896 5897 public: 5898 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, 5899 unsigned PriorGeneration) 5900 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { } 5901 5902 static bool visit(ModuleFile &M, void *UserData) { 5903 ReadMethodPoolVisitor *This 5904 = static_cast<ReadMethodPoolVisitor *>(UserData); 5905 5906 if (!M.SelectorLookupTable) 5907 return false; 5908 5909 // If we've already searched this module file, skip it now. 5910 if (M.Generation <= This->PriorGeneration) 5911 return true; 5912 5913 ASTSelectorLookupTable *PoolTable 5914 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 5915 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 5916 if (Pos == PoolTable->end()) 5917 return false; 5918 5919 ++This->Reader.NumSelectorsRead; 5920 // FIXME: Not quite happy with the statistics here. We probably should 5921 // disable this tracking when called via LoadSelector. 5922 // Also, should entries without methods count as misses? 5923 ++This->Reader.NumMethodPoolEntriesRead; 5924 ASTSelectorLookupTrait::data_type Data = *Pos; 5925 if (This->Reader.DeserializationListener) 5926 This->Reader.DeserializationListener->SelectorRead(Data.ID, 5927 This->Sel); 5928 5929 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 5930 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 5931 return true; 5932 } 5933 5934 /// \brief Retrieve the instance methods found by this visitor. 5935 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const { 5936 return InstanceMethods; 5937 } 5938 5939 /// \brief Retrieve the instance methods found by this visitor. 5940 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const { 5941 return FactoryMethods; 5942 } 5943 }; 5944} } // end namespace clang::serialization 5945 5946/// \brief Add the given set of methods to the method list. 5947static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods, 5948 ObjCMethodList &List) { 5949 for (unsigned I = 0, N = Methods.size(); I != N; ++I) { 5950 S.addMethodToGlobalList(&List, Methods[I]); 5951 } 5952} 5953 5954void ASTReader::ReadMethodPool(Selector Sel) { 5955 // Get the selector generation and update it to the current generation. 5956 unsigned &Generation = SelectorGeneration[Sel]; 5957 unsigned PriorGeneration = Generation; 5958 Generation = CurrentGeneration; 5959 5960 // Search for methods defined with this selector. 5961 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration); 5962 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 5963 5964 if (Visitor.getInstanceMethods().empty() && 5965 Visitor.getFactoryMethods().empty()) { 5966 ++NumMethodPoolMisses; 5967 return; 5968 } 5969 5970 if (!getSema()) 5971 return; 5972 5973 Sema &S = *getSema(); 5974 Sema::GlobalMethodPool::iterator Pos 5975 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first; 5976 5977 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first); 5978 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second); 5979} 5980 5981void ASTReader::ReadKnownNamespaces( 5982 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 5983 Namespaces.clear(); 5984 5985 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 5986 if (NamespaceDecl *Namespace 5987 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 5988 Namespaces.push_back(Namespace); 5989 } 5990} 5991 5992void ASTReader::ReadTentativeDefinitions( 5993 SmallVectorImpl<VarDecl *> &TentativeDefs) { 5994 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 5995 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 5996 if (Var) 5997 TentativeDefs.push_back(Var); 5998 } 5999 TentativeDefinitions.clear(); 6000} 6001 6002void ASTReader::ReadUnusedFileScopedDecls( 6003 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 6004 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 6005 DeclaratorDecl *D 6006 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 6007 if (D) 6008 Decls.push_back(D); 6009 } 6010 UnusedFileScopedDecls.clear(); 6011} 6012 6013void ASTReader::ReadDelegatingConstructors( 6014 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 6015 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 6016 CXXConstructorDecl *D 6017 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 6018 if (D) 6019 Decls.push_back(D); 6020 } 6021 DelegatingCtorDecls.clear(); 6022} 6023 6024void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 6025 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 6026 TypedefNameDecl *D 6027 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 6028 if (D) 6029 Decls.push_back(D); 6030 } 6031 ExtVectorDecls.clear(); 6032} 6033 6034void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 6035 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 6036 CXXRecordDecl *D 6037 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 6038 if (D) 6039 Decls.push_back(D); 6040 } 6041 DynamicClasses.clear(); 6042} 6043 6044void 6045ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 6046 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 6047 NamedDecl *D 6048 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 6049 if (D) 6050 Decls.push_back(D); 6051 } 6052 LocallyScopedExternalDecls.clear(); 6053} 6054 6055void ASTReader::ReadReferencedSelectors( 6056 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 6057 if (ReferencedSelectorsData.empty()) 6058 return; 6059 6060 // If there are @selector references added them to its pool. This is for 6061 // implementation of -Wselector. 6062 unsigned int DataSize = ReferencedSelectorsData.size()-1; 6063 unsigned I = 0; 6064 while (I < DataSize) { 6065 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 6066 SourceLocation SelLoc 6067 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 6068 Sels.push_back(std::make_pair(Sel, SelLoc)); 6069 } 6070 ReferencedSelectorsData.clear(); 6071} 6072 6073void ASTReader::ReadWeakUndeclaredIdentifiers( 6074 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 6075 if (WeakUndeclaredIdentifiers.empty()) 6076 return; 6077 6078 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 6079 IdentifierInfo *WeakId 6080 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6081 IdentifierInfo *AliasId 6082 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6083 SourceLocation Loc 6084 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 6085 bool Used = WeakUndeclaredIdentifiers[I++]; 6086 WeakInfo WI(AliasId, Loc); 6087 WI.setUsed(Used); 6088 WeakIDs.push_back(std::make_pair(WeakId, WI)); 6089 } 6090 WeakUndeclaredIdentifiers.clear(); 6091} 6092 6093void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 6094 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 6095 ExternalVTableUse VT; 6096 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 6097 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 6098 VT.DefinitionRequired = VTableUses[Idx++]; 6099 VTables.push_back(VT); 6100 } 6101 6102 VTableUses.clear(); 6103} 6104 6105void ASTReader::ReadPendingInstantiations( 6106 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 6107 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 6108 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 6109 SourceLocation Loc 6110 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 6111 6112 Pending.push_back(std::make_pair(D, Loc)); 6113 } 6114 PendingInstantiations.clear(); 6115} 6116 6117void ASTReader::LoadSelector(Selector Sel) { 6118 // It would be complicated to avoid reading the methods anyway. So don't. 6119 ReadMethodPool(Sel); 6120} 6121 6122void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 6123 assert(ID && "Non-zero identifier ID required"); 6124 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 6125 IdentifiersLoaded[ID - 1] = II; 6126 if (DeserializationListener) 6127 DeserializationListener->IdentifierRead(ID, II); 6128} 6129 6130/// \brief Set the globally-visible declarations associated with the given 6131/// identifier. 6132/// 6133/// If the AST reader is currently in a state where the given declaration IDs 6134/// cannot safely be resolved, they are queued until it is safe to resolve 6135/// them. 6136/// 6137/// \param II an IdentifierInfo that refers to one or more globally-visible 6138/// declarations. 6139/// 6140/// \param DeclIDs the set of declaration IDs with the name @p II that are 6141/// visible at global scope. 6142/// 6143/// \param Nonrecursive should be true to indicate that the caller knows that 6144/// this call is non-recursive, and therefore the globally-visible declarations 6145/// will not be placed onto the pending queue. 6146void 6147ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 6148 const SmallVectorImpl<uint32_t> &DeclIDs, 6149 bool Nonrecursive) { 6150 if (NumCurrentElementsDeserializing && !Nonrecursive) { 6151 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 6152 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 6153 PII.II = II; 6154 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 6155 return; 6156 } 6157 6158 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 6159 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 6160 if (SemaObj) { 6161 // Introduce this declaration into the translation-unit scope 6162 // and add it to the declaration chain for this identifier, so 6163 // that (unqualified) name lookup will find it. 6164 SemaObj->pushExternalDeclIntoScope(D, II); 6165 } else { 6166 // Queue this declaration so that it will be added to the 6167 // translation unit scope and identifier's declaration chain 6168 // once a Sema object is known. 6169 PreloadedDecls.push_back(D); 6170 } 6171 } 6172} 6173 6174IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 6175 if (ID == 0) 6176 return 0; 6177 6178 if (IdentifiersLoaded.empty()) { 6179 Error("no identifier table in AST file"); 6180 return 0; 6181 } 6182 6183 ID -= 1; 6184 if (!IdentifiersLoaded[ID]) { 6185 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 6186 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 6187 ModuleFile *M = I->second; 6188 unsigned Index = ID - M->BaseIdentifierID; 6189 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 6190 6191 // All of the strings in the AST file are preceded by a 16-bit length. 6192 // Extract that 16-bit length to avoid having to execute strlen(). 6193 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 6194 // unsigned integers. This is important to avoid integer overflow when 6195 // we cast them to 'unsigned'. 6196 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 6197 unsigned StrLen = (((unsigned) StrLenPtr[0]) 6198 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 6199 IdentifiersLoaded[ID] 6200 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 6201 if (DeserializationListener) 6202 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 6203 } 6204 6205 return IdentifiersLoaded[ID]; 6206} 6207 6208IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 6209 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 6210} 6211 6212IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 6213 if (LocalID < NUM_PREDEF_IDENT_IDS) 6214 return LocalID; 6215 6216 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6217 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 6218 assert(I != M.IdentifierRemap.end() 6219 && "Invalid index into identifier index remap"); 6220 6221 return LocalID + I->second; 6222} 6223 6224MacroInfo *ASTReader::getMacro(MacroID ID, MacroInfo *Hint) { 6225 if (ID == 0) 6226 return 0; 6227 6228 if (MacrosLoaded.empty()) { 6229 Error("no macro table in AST file"); 6230 return 0; 6231 } 6232 6233 ID -= NUM_PREDEF_MACRO_IDS; 6234 if (!MacrosLoaded[ID]) { 6235 GlobalMacroMapType::iterator I 6236 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS); 6237 assert(I != GlobalMacroMap.end() && "Corrupted global macro map"); 6238 ModuleFile *M = I->second; 6239 unsigned Index = ID - M->BaseMacroID; 6240 ReadMacroRecord(*M, M->MacroOffsets[Index], Hint); 6241 } 6242 6243 return MacrosLoaded[ID]; 6244} 6245 6246MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) { 6247 if (LocalID < NUM_PREDEF_MACRO_IDS) 6248 return LocalID; 6249 6250 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6251 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS); 6252 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap"); 6253 6254 return LocalID + I->second; 6255} 6256 6257serialization::SubmoduleID 6258ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 6259 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 6260 return LocalID; 6261 6262 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6263 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 6264 assert(I != M.SubmoduleRemap.end() 6265 && "Invalid index into submodule index remap"); 6266 6267 return LocalID + I->second; 6268} 6269 6270Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 6271 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 6272 assert(GlobalID == 0 && "Unhandled global submodule ID"); 6273 return 0; 6274 } 6275 6276 if (GlobalID > SubmodulesLoaded.size()) { 6277 Error("submodule ID out of range in AST file"); 6278 return 0; 6279 } 6280 6281 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 6282} 6283 6284Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 6285 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 6286} 6287 6288Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 6289 if (ID == 0) 6290 return Selector(); 6291 6292 if (ID > SelectorsLoaded.size()) { 6293 Error("selector ID out of range in AST file"); 6294 return Selector(); 6295 } 6296 6297 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 6298 // Load this selector from the selector table. 6299 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 6300 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 6301 ModuleFile &M = *I->second; 6302 ASTSelectorLookupTrait Trait(*this, M); 6303 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 6304 SelectorsLoaded[ID - 1] = 6305 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 6306 if (DeserializationListener) 6307 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 6308 } 6309 6310 return SelectorsLoaded[ID - 1]; 6311} 6312 6313Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 6314 return DecodeSelector(ID); 6315} 6316 6317uint32_t ASTReader::GetNumExternalSelectors() { 6318 // ID 0 (the null selector) is considered an external selector. 6319 return getTotalNumSelectors() + 1; 6320} 6321 6322serialization::SelectorID 6323ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 6324 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 6325 return LocalID; 6326 6327 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6328 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 6329 assert(I != M.SelectorRemap.end() 6330 && "Invalid index into selector index remap"); 6331 6332 return LocalID + I->second; 6333} 6334 6335DeclarationName 6336ASTReader::ReadDeclarationName(ModuleFile &F, 6337 const RecordData &Record, unsigned &Idx) { 6338 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 6339 switch (Kind) { 6340 case DeclarationName::Identifier: 6341 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 6342 6343 case DeclarationName::ObjCZeroArgSelector: 6344 case DeclarationName::ObjCOneArgSelector: 6345 case DeclarationName::ObjCMultiArgSelector: 6346 return DeclarationName(ReadSelector(F, Record, Idx)); 6347 6348 case DeclarationName::CXXConstructorName: 6349 return Context.DeclarationNames.getCXXConstructorName( 6350 Context.getCanonicalType(readType(F, Record, Idx))); 6351 6352 case DeclarationName::CXXDestructorName: 6353 return Context.DeclarationNames.getCXXDestructorName( 6354 Context.getCanonicalType(readType(F, Record, Idx))); 6355 6356 case DeclarationName::CXXConversionFunctionName: 6357 return Context.DeclarationNames.getCXXConversionFunctionName( 6358 Context.getCanonicalType(readType(F, Record, Idx))); 6359 6360 case DeclarationName::CXXOperatorName: 6361 return Context.DeclarationNames.getCXXOperatorName( 6362 (OverloadedOperatorKind)Record[Idx++]); 6363 6364 case DeclarationName::CXXLiteralOperatorName: 6365 return Context.DeclarationNames.getCXXLiteralOperatorName( 6366 GetIdentifierInfo(F, Record, Idx)); 6367 6368 case DeclarationName::CXXUsingDirective: 6369 return DeclarationName::getUsingDirectiveName(); 6370 } 6371 6372 llvm_unreachable("Invalid NameKind!"); 6373} 6374 6375void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 6376 DeclarationNameLoc &DNLoc, 6377 DeclarationName Name, 6378 const RecordData &Record, unsigned &Idx) { 6379 switch (Name.getNameKind()) { 6380 case DeclarationName::CXXConstructorName: 6381 case DeclarationName::CXXDestructorName: 6382 case DeclarationName::CXXConversionFunctionName: 6383 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 6384 break; 6385 6386 case DeclarationName::CXXOperatorName: 6387 DNLoc.CXXOperatorName.BeginOpNameLoc 6388 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6389 DNLoc.CXXOperatorName.EndOpNameLoc 6390 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6391 break; 6392 6393 case DeclarationName::CXXLiteralOperatorName: 6394 DNLoc.CXXLiteralOperatorName.OpNameLoc 6395 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6396 break; 6397 6398 case DeclarationName::Identifier: 6399 case DeclarationName::ObjCZeroArgSelector: 6400 case DeclarationName::ObjCOneArgSelector: 6401 case DeclarationName::ObjCMultiArgSelector: 6402 case DeclarationName::CXXUsingDirective: 6403 break; 6404 } 6405} 6406 6407void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 6408 DeclarationNameInfo &NameInfo, 6409 const RecordData &Record, unsigned &Idx) { 6410 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 6411 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 6412 DeclarationNameLoc DNLoc; 6413 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 6414 NameInfo.setInfo(DNLoc); 6415} 6416 6417void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 6418 const RecordData &Record, unsigned &Idx) { 6419 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 6420 unsigned NumTPLists = Record[Idx++]; 6421 Info.NumTemplParamLists = NumTPLists; 6422 if (NumTPLists) { 6423 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 6424 for (unsigned i=0; i != NumTPLists; ++i) 6425 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 6426 } 6427} 6428 6429TemplateName 6430ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 6431 unsigned &Idx) { 6432 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 6433 switch (Kind) { 6434 case TemplateName::Template: 6435 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 6436 6437 case TemplateName::OverloadedTemplate: { 6438 unsigned size = Record[Idx++]; 6439 UnresolvedSet<8> Decls; 6440 while (size--) 6441 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6442 6443 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 6444 } 6445 6446 case TemplateName::QualifiedTemplate: { 6447 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6448 bool hasTemplKeyword = Record[Idx++]; 6449 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 6450 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 6451 } 6452 6453 case TemplateName::DependentTemplate: { 6454 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6455 if (Record[Idx++]) // isIdentifier 6456 return Context.getDependentTemplateName(NNS, 6457 GetIdentifierInfo(F, Record, 6458 Idx)); 6459 return Context.getDependentTemplateName(NNS, 6460 (OverloadedOperatorKind)Record[Idx++]); 6461 } 6462 6463 case TemplateName::SubstTemplateTemplateParm: { 6464 TemplateTemplateParmDecl *param 6465 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6466 if (!param) return TemplateName(); 6467 TemplateName replacement = ReadTemplateName(F, Record, Idx); 6468 return Context.getSubstTemplateTemplateParm(param, replacement); 6469 } 6470 6471 case TemplateName::SubstTemplateTemplateParmPack: { 6472 TemplateTemplateParmDecl *Param 6473 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6474 if (!Param) 6475 return TemplateName(); 6476 6477 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 6478 if (ArgPack.getKind() != TemplateArgument::Pack) 6479 return TemplateName(); 6480 6481 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 6482 } 6483 } 6484 6485 llvm_unreachable("Unhandled template name kind!"); 6486} 6487 6488TemplateArgument 6489ASTReader::ReadTemplateArgument(ModuleFile &F, 6490 const RecordData &Record, unsigned &Idx) { 6491 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 6492 switch (Kind) { 6493 case TemplateArgument::Null: 6494 return TemplateArgument(); 6495 case TemplateArgument::Type: 6496 return TemplateArgument(readType(F, Record, Idx)); 6497 case TemplateArgument::Declaration: { 6498 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx); 6499 bool ForReferenceParam = Record[Idx++]; 6500 return TemplateArgument(D, ForReferenceParam); 6501 } 6502 case TemplateArgument::NullPtr: 6503 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true); 6504 case TemplateArgument::Integral: { 6505 llvm::APSInt Value = ReadAPSInt(Record, Idx); 6506 QualType T = readType(F, Record, Idx); 6507 return TemplateArgument(Context, Value, T); 6508 } 6509 case TemplateArgument::Template: 6510 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 6511 case TemplateArgument::TemplateExpansion: { 6512 TemplateName Name = ReadTemplateName(F, Record, Idx); 6513 llvm::Optional<unsigned> NumTemplateExpansions; 6514 if (unsigned NumExpansions = Record[Idx++]) 6515 NumTemplateExpansions = NumExpansions - 1; 6516 return TemplateArgument(Name, NumTemplateExpansions); 6517 } 6518 case TemplateArgument::Expression: 6519 return TemplateArgument(ReadExpr(F)); 6520 case TemplateArgument::Pack: { 6521 unsigned NumArgs = Record[Idx++]; 6522 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 6523 for (unsigned I = 0; I != NumArgs; ++I) 6524 Args[I] = ReadTemplateArgument(F, Record, Idx); 6525 return TemplateArgument(Args, NumArgs); 6526 } 6527 } 6528 6529 llvm_unreachable("Unhandled template argument kind!"); 6530} 6531 6532TemplateParameterList * 6533ASTReader::ReadTemplateParameterList(ModuleFile &F, 6534 const RecordData &Record, unsigned &Idx) { 6535 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 6536 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 6537 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 6538 6539 unsigned NumParams = Record[Idx++]; 6540 SmallVector<NamedDecl *, 16> Params; 6541 Params.reserve(NumParams); 6542 while (NumParams--) 6543 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6544 6545 TemplateParameterList* TemplateParams = 6546 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 6547 Params.data(), Params.size(), RAngleLoc); 6548 return TemplateParams; 6549} 6550 6551void 6552ASTReader:: 6553ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 6554 ModuleFile &F, const RecordData &Record, 6555 unsigned &Idx) { 6556 unsigned NumTemplateArgs = Record[Idx++]; 6557 TemplArgs.reserve(NumTemplateArgs); 6558 while (NumTemplateArgs--) 6559 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 6560} 6561 6562/// \brief Read a UnresolvedSet structure. 6563void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set, 6564 const RecordData &Record, unsigned &Idx) { 6565 unsigned NumDecls = Record[Idx++]; 6566 while (NumDecls--) { 6567 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 6568 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 6569 Set.addDecl(D, AS); 6570 } 6571} 6572 6573CXXBaseSpecifier 6574ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 6575 const RecordData &Record, unsigned &Idx) { 6576 bool isVirtual = static_cast<bool>(Record[Idx++]); 6577 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 6578 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 6579 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 6580 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 6581 SourceRange Range = ReadSourceRange(F, Record, Idx); 6582 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 6583 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 6584 EllipsisLoc); 6585 Result.setInheritConstructors(inheritConstructors); 6586 return Result; 6587} 6588 6589std::pair<CXXCtorInitializer **, unsigned> 6590ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 6591 unsigned &Idx) { 6592 CXXCtorInitializer **CtorInitializers = 0; 6593 unsigned NumInitializers = Record[Idx++]; 6594 if (NumInitializers) { 6595 CtorInitializers 6596 = new (Context) CXXCtorInitializer*[NumInitializers]; 6597 for (unsigned i=0; i != NumInitializers; ++i) { 6598 TypeSourceInfo *TInfo = 0; 6599 bool IsBaseVirtual = false; 6600 FieldDecl *Member = 0; 6601 IndirectFieldDecl *IndirectMember = 0; 6602 6603 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 6604 switch (Type) { 6605 case CTOR_INITIALIZER_BASE: 6606 TInfo = GetTypeSourceInfo(F, Record, Idx); 6607 IsBaseVirtual = Record[Idx++]; 6608 break; 6609 6610 case CTOR_INITIALIZER_DELEGATING: 6611 TInfo = GetTypeSourceInfo(F, Record, Idx); 6612 break; 6613 6614 case CTOR_INITIALIZER_MEMBER: 6615 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 6616 break; 6617 6618 case CTOR_INITIALIZER_INDIRECT_MEMBER: 6619 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 6620 break; 6621 } 6622 6623 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 6624 Expr *Init = ReadExpr(F); 6625 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 6626 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 6627 bool IsWritten = Record[Idx++]; 6628 unsigned SourceOrderOrNumArrayIndices; 6629 SmallVector<VarDecl *, 8> Indices; 6630 if (IsWritten) { 6631 SourceOrderOrNumArrayIndices = Record[Idx++]; 6632 } else { 6633 SourceOrderOrNumArrayIndices = Record[Idx++]; 6634 Indices.reserve(SourceOrderOrNumArrayIndices); 6635 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 6636 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 6637 } 6638 6639 CXXCtorInitializer *BOMInit; 6640 if (Type == CTOR_INITIALIZER_BASE) { 6641 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 6642 LParenLoc, Init, RParenLoc, 6643 MemberOrEllipsisLoc); 6644 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 6645 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 6646 Init, RParenLoc); 6647 } else if (IsWritten) { 6648 if (Member) 6649 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 6650 LParenLoc, Init, RParenLoc); 6651 else 6652 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 6653 MemberOrEllipsisLoc, LParenLoc, 6654 Init, RParenLoc); 6655 } else { 6656 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 6657 LParenLoc, Init, RParenLoc, 6658 Indices.data(), Indices.size()); 6659 } 6660 6661 if (IsWritten) 6662 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 6663 CtorInitializers[i] = BOMInit; 6664 } 6665 } 6666 6667 return std::make_pair(CtorInitializers, NumInitializers); 6668} 6669 6670NestedNameSpecifier * 6671ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 6672 const RecordData &Record, unsigned &Idx) { 6673 unsigned N = Record[Idx++]; 6674 NestedNameSpecifier *NNS = 0, *Prev = 0; 6675 for (unsigned I = 0; I != N; ++I) { 6676 NestedNameSpecifier::SpecifierKind Kind 6677 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6678 switch (Kind) { 6679 case NestedNameSpecifier::Identifier: { 6680 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6681 NNS = NestedNameSpecifier::Create(Context, Prev, II); 6682 break; 6683 } 6684 6685 case NestedNameSpecifier::Namespace: { 6686 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6687 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 6688 break; 6689 } 6690 6691 case NestedNameSpecifier::NamespaceAlias: { 6692 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6693 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 6694 break; 6695 } 6696 6697 case NestedNameSpecifier::TypeSpec: 6698 case NestedNameSpecifier::TypeSpecWithTemplate: { 6699 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 6700 if (!T) 6701 return 0; 6702 6703 bool Template = Record[Idx++]; 6704 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 6705 break; 6706 } 6707 6708 case NestedNameSpecifier::Global: { 6709 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 6710 // No associated value, and there can't be a prefix. 6711 break; 6712 } 6713 } 6714 Prev = NNS; 6715 } 6716 return NNS; 6717} 6718 6719NestedNameSpecifierLoc 6720ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 6721 unsigned &Idx) { 6722 unsigned N = Record[Idx++]; 6723 NestedNameSpecifierLocBuilder Builder; 6724 for (unsigned I = 0; I != N; ++I) { 6725 NestedNameSpecifier::SpecifierKind Kind 6726 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 6727 switch (Kind) { 6728 case NestedNameSpecifier::Identifier: { 6729 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 6730 SourceRange Range = ReadSourceRange(F, Record, Idx); 6731 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 6732 break; 6733 } 6734 6735 case NestedNameSpecifier::Namespace: { 6736 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 6737 SourceRange Range = ReadSourceRange(F, Record, Idx); 6738 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 6739 break; 6740 } 6741 6742 case NestedNameSpecifier::NamespaceAlias: { 6743 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 6744 SourceRange Range = ReadSourceRange(F, Record, Idx); 6745 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 6746 break; 6747 } 6748 6749 case NestedNameSpecifier::TypeSpec: 6750 case NestedNameSpecifier::TypeSpecWithTemplate: { 6751 bool Template = Record[Idx++]; 6752 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 6753 if (!T) 6754 return NestedNameSpecifierLoc(); 6755 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6756 6757 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 6758 Builder.Extend(Context, 6759 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 6760 T->getTypeLoc(), ColonColonLoc); 6761 break; 6762 } 6763 6764 case NestedNameSpecifier::Global: { 6765 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 6766 Builder.MakeGlobal(Context, ColonColonLoc); 6767 break; 6768 } 6769 } 6770 } 6771 6772 return Builder.getWithLocInContext(Context); 6773} 6774 6775SourceRange 6776ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 6777 unsigned &Idx) { 6778 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 6779 SourceLocation end = ReadSourceLocation(F, Record, Idx); 6780 return SourceRange(beg, end); 6781} 6782 6783/// \brief Read an integral value 6784llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 6785 unsigned BitWidth = Record[Idx++]; 6786 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 6787 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 6788 Idx += NumWords; 6789 return Result; 6790} 6791 6792/// \brief Read a signed integral value 6793llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 6794 bool isUnsigned = Record[Idx++]; 6795 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 6796} 6797 6798/// \brief Read a floating-point value 6799llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 6800 return llvm::APFloat(ReadAPInt(Record, Idx)); 6801} 6802 6803// \brief Read a string 6804std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 6805 unsigned Len = Record[Idx++]; 6806 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 6807 Idx += Len; 6808 return Result; 6809} 6810 6811VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 6812 unsigned &Idx) { 6813 unsigned Major = Record[Idx++]; 6814 unsigned Minor = Record[Idx++]; 6815 unsigned Subminor = Record[Idx++]; 6816 if (Minor == 0) 6817 return VersionTuple(Major); 6818 if (Subminor == 0) 6819 return VersionTuple(Major, Minor - 1); 6820 return VersionTuple(Major, Minor - 1, Subminor - 1); 6821} 6822 6823CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 6824 const RecordData &Record, 6825 unsigned &Idx) { 6826 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 6827 return CXXTemporary::Create(Context, Decl); 6828} 6829 6830DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 6831 return Diag(SourceLocation(), DiagID); 6832} 6833 6834DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 6835 return Diags.Report(Loc, DiagID); 6836} 6837 6838/// \brief Retrieve the identifier table associated with the 6839/// preprocessor. 6840IdentifierTable &ASTReader::getIdentifierTable() { 6841 return PP.getIdentifierTable(); 6842} 6843 6844/// \brief Record that the given ID maps to the given switch-case 6845/// statement. 6846void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 6847 assert((*CurrSwitchCaseStmts)[ID] == 0 && 6848 "Already have a SwitchCase with this ID"); 6849 (*CurrSwitchCaseStmts)[ID] = SC; 6850} 6851 6852/// \brief Retrieve the switch-case statement with the given ID. 6853SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 6854 assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID"); 6855 return (*CurrSwitchCaseStmts)[ID]; 6856} 6857 6858void ASTReader::ClearSwitchCaseIDs() { 6859 CurrSwitchCaseStmts->clear(); 6860} 6861 6862void ASTReader::ReadComments() { 6863 std::vector<RawComment *> Comments; 6864 for (SmallVectorImpl<std::pair<llvm::BitstreamCursor, 6865 serialization::ModuleFile *> >::iterator 6866 I = CommentsCursors.begin(), 6867 E = CommentsCursors.end(); 6868 I != E; ++I) { 6869 llvm::BitstreamCursor &Cursor = I->first; 6870 serialization::ModuleFile &F = *I->second; 6871 SavedStreamPosition SavedPosition(Cursor); 6872 6873 RecordData Record; 6874 while (true) { 6875 unsigned Code = Cursor.ReadCode(); 6876 if (Code == llvm::bitc::END_BLOCK) 6877 break; 6878 6879 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 6880 // No known subblocks, always skip them. 6881 Cursor.ReadSubBlockID(); 6882 if (Cursor.SkipBlock()) { 6883 Error("malformed block record in AST file"); 6884 return; 6885 } 6886 continue; 6887 } 6888 6889 if (Code == llvm::bitc::DEFINE_ABBREV) { 6890 Cursor.ReadAbbrevRecord(); 6891 continue; 6892 } 6893 6894 // Read a record. 6895 Record.clear(); 6896 switch ((CommentRecordTypes) Cursor.ReadRecord(Code, Record)) { 6897 case COMMENTS_RAW_COMMENT: { 6898 unsigned Idx = 0; 6899 SourceRange SR = ReadSourceRange(F, Record, Idx); 6900 RawComment::CommentKind Kind = 6901 (RawComment::CommentKind) Record[Idx++]; 6902 bool IsTrailingComment = Record[Idx++]; 6903 bool IsAlmostTrailingComment = Record[Idx++]; 6904 Comments.push_back(new (Context) RawComment(SR, Kind, 6905 IsTrailingComment, 6906 IsAlmostTrailingComment)); 6907 break; 6908 } 6909 } 6910 } 6911 } 6912 Context.Comments.addCommentsToFront(Comments); 6913} 6914 6915void ASTReader::finishPendingActions() { 6916 while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty() || 6917 !PendingMacroIDs.empty()) { 6918 // If any identifiers with corresponding top-level declarations have 6919 // been loaded, load those declarations now. 6920 while (!PendingIdentifierInfos.empty()) { 6921 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 6922 PendingIdentifierInfos.front().DeclIDs, true); 6923 PendingIdentifierInfos.pop_front(); 6924 } 6925 6926 // Load pending declaration chains. 6927 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 6928 loadPendingDeclChain(PendingDeclChains[I]); 6929 PendingDeclChainsKnown.erase(PendingDeclChains[I]); 6930 } 6931 PendingDeclChains.clear(); 6932 6933 // Load any pending macro definitions. 6934 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) { 6935 // FIXME: std::move here 6936 SmallVector<MacroID, 2> GlobalIDs = PendingMacroIDs.begin()[I].second; 6937 MacroInfo *Hint = 0; 6938 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 6939 ++IDIdx) { 6940 Hint = getMacro(GlobalIDs[IDIdx], Hint); 6941 } 6942 } 6943 PendingMacroIDs.clear(); 6944 } 6945 6946 // If we deserialized any C++ or Objective-C class definitions, any 6947 // Objective-C protocol definitions, or any redeclarable templates, make sure 6948 // that all redeclarations point to the definitions. Note that this can only 6949 // happen now, after the redeclaration chains have been fully wired. 6950 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(), 6951 DEnd = PendingDefinitions.end(); 6952 D != DEnd; ++D) { 6953 if (TagDecl *TD = dyn_cast<TagDecl>(*D)) { 6954 if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) { 6955 // Make sure that the TagType points at the definition. 6956 const_cast<TagType*>(TagT)->decl = TD; 6957 } 6958 6959 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) { 6960 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(), 6961 REnd = RD->redecls_end(); 6962 R != REnd; ++R) 6963 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData; 6964 6965 } 6966 6967 continue; 6968 } 6969 6970 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) { 6971 // Make sure that the ObjCInterfaceType points at the definition. 6972 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl)) 6973 ->Decl = ID; 6974 6975 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(), 6976 REnd = ID->redecls_end(); 6977 R != REnd; ++R) 6978 R->Data = ID->Data; 6979 6980 continue; 6981 } 6982 6983 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) { 6984 for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(), 6985 REnd = PD->redecls_end(); 6986 R != REnd; ++R) 6987 R->Data = PD->Data; 6988 6989 continue; 6990 } 6991 6992 RedeclarableTemplateDecl *RTD 6993 = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl(); 6994 for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(), 6995 REnd = RTD->redecls_end(); 6996 R != REnd; ++R) 6997 R->Common = RTD->Common; 6998 } 6999 PendingDefinitions.clear(); 7000 7001 // Load the bodies of any functions or methods we've encountered. We do 7002 // this now (delayed) so that we can be sure that the declaration chains 7003 // have been fully wired up. 7004 for (PendingBodiesMap::iterator PB = PendingBodies.begin(), 7005 PBEnd = PendingBodies.end(); 7006 PB != PBEnd; ++PB) { 7007 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) { 7008 // FIXME: Check for =delete/=default? 7009 // FIXME: Complain about ODR violations here? 7010 if (!getContext().getLangOpts().Modules || !FD->hasBody()) 7011 FD->setLazyBody(PB->second); 7012 continue; 7013 } 7014 7015 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first); 7016 if (!getContext().getLangOpts().Modules || !MD->hasBody()) 7017 MD->setLazyBody(PB->second); 7018 } 7019 PendingBodies.clear(); 7020} 7021 7022void ASTReader::FinishedDeserializing() { 7023 assert(NumCurrentElementsDeserializing && 7024 "FinishedDeserializing not paired with StartedDeserializing"); 7025 if (NumCurrentElementsDeserializing == 1) { 7026 // We decrease NumCurrentElementsDeserializing only after pending actions 7027 // are finished, to avoid recursively re-calling finishPendingActions(). 7028 finishPendingActions(); 7029 } 7030 --NumCurrentElementsDeserializing; 7031 7032 if (NumCurrentElementsDeserializing == 0 && 7033 Consumer && !PassingDeclsToConsumer) { 7034 // Guard variable to avoid recursively redoing the process of passing 7035 // decls to consumer. 7036 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer, 7037 true); 7038 7039 while (!InterestingDecls.empty()) { 7040 // We are not in recursive loading, so it's safe to pass the "interesting" 7041 // decls to the consumer. 7042 Decl *D = InterestingDecls.front(); 7043 InterestingDecls.pop_front(); 7044 PassInterestingDeclToConsumer(D); 7045 } 7046 } 7047} 7048 7049ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 7050 StringRef isysroot, bool DisableValidation, 7051 bool DisableStatCache, bool AllowASTWithCompilerErrors) 7052 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 7053 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 7054 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 7055 Consumer(0), ModuleMgr(PP.getFileManager()), 7056 isysroot(isysroot), DisableValidation(DisableValidation), 7057 DisableStatCache(DisableStatCache), 7058 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), 7059 CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts), 7060 NumStatHits(0), NumStatMisses(0), 7061 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 7062 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 7063 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 7064 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 7065 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 7066 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 7067 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 7068 PassingDeclsToConsumer(false), 7069 NumCXXBaseSpecifiersLoaded(0) 7070{ 7071 SourceMgr.setExternalSLocEntrySource(this); 7072} 7073 7074ASTReader::~ASTReader() { 7075 for (DeclContextVisibleUpdatesPending::iterator 7076 I = PendingVisibleUpdates.begin(), 7077 E = PendingVisibleUpdates.end(); 7078 I != E; ++I) { 7079 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 7080 F = I->second.end(); 7081 J != F; ++J) 7082 delete J->first; 7083 } 7084} 7085