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