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