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