ASTReader.cpp revision 1d4c1137c314cfb9ced32006cacdb80deffb66d4
1a5728872c7702ddd09537c95bc3cbd20e1f2fb09Daniel Dunbar//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===// 2db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin// 3c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor// The LLVM Compiler Infrastructure 4c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor// 539a8de10c18365bde7062d8959b7ed525449c561Douglas Gregor// This file is distributed under the University of Illinois Open Source 6c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor// License. See LICENSE.TXT for details. 74b02dff7aebb98d2d60b2ff4d3fc86109213128cDavid Blaikie// 8c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor//===----------------------------------------------------------------------===// 9c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor// 108b642592a35167a3780074e78674e0bece87c40cDouglas Gregor// This file defines the ASTReader class, which reads AST files. 118b642592a35167a3780074e78674e0bece87c40cDouglas Gregor// 12c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor//===----------------------------------------------------------------------===// 13c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor 14db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/Serialization/ASTReader.h" 15db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/Serialization/ASTDeserializationListener.h" 16db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/Serialization/ModuleManager.h" 17db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/Serialization/SerializationDiagnostic.h" 18db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "ASTCommon.h" 19db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "ASTReaderInternals.h" 20db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/Sema/Sema.h" 21db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/Sema/Scope.h" 224b02dff7aebb98d2d60b2ff4d3fc86109213128cDavid Blaikie#include "clang/AST/ASTConsumer.h" 23db88d8ad74097e2601d81ee863ce46a8a48a7034Jeffrey Yasskin#include "clang/AST/ASTContext.h" 24c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/AST/DeclTemplate.h" 25c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/AST/Expr.h" 26c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/AST/ExprCXX.h" 2717fb855280be411389361f1c79753e0013c4187cChandler Carruth#include "clang/AST/NestedNameSpecifier.h" 28c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/AST/Type.h" 29c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/AST/TypeLocVisitor.h" 30c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/Lex/MacroInfo.h" 3117fb855280be411389361f1c79753e0013c4187cChandler Carruth#include "clang/Lex/PreprocessingRecord.h" 32c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/Lex/Preprocessor.h" 33d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Lex/HeaderSearch.h" 34d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/OnDiskHashTable.h" 35d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/SourceManager.h" 36d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/SourceManagerInternals.h" 37d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/FileManager.h" 38d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/FileSystemStatCache.h" 39d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/TargetInfo.h" 40d57a38ee02c285d69d05fed6df0d7406b2517888Douglas Gregor#include "clang/Basic/Version.h" 41c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#include "clang/Basic/VersionTuple.h" 42c15cb38a4ff717097b32532fbf761c71b1376a02Douglas Gregor#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 } 2412 Error("premature end of bitstream in AST file"); 2413 return Failure; 2414} 2415 2416ASTReader::ASTReadResult ASTReader::validateFileEntries(ModuleFile &M) { 2417 llvm::BitstreamCursor &SLocEntryCursor = M.SLocEntryCursor; 2418 2419 for (unsigned i = 0, e = M.LocalNumSLocFileEntries; i != e; ++i) { 2420 SLocEntryCursor.JumpToBit(M.SLocFileOffsets[i]); 2421 unsigned Code = SLocEntryCursor.ReadCode(); 2422 if (Code == llvm::bitc::END_BLOCK || 2423 Code == llvm::bitc::ENTER_SUBBLOCK || 2424 Code == llvm::bitc::DEFINE_ABBREV) { 2425 Error("incorrectly-formatted source location entry in AST file"); 2426 return Failure; 2427 } 2428 2429 RecordData Record; 2430 const char *BlobStart; 2431 unsigned BlobLen; 2432 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2433 default: 2434 Error("incorrectly-formatted source location entry in AST file"); 2435 return Failure; 2436 2437 case SM_SLOC_FILE_ENTRY: { 2438 // If the buffer was overridden, the file need not exist. 2439 if (Record[6]) 2440 break; 2441 2442 StringRef Filename(BlobStart, BlobLen); 2443 const FileEntry *File = getFileEntry(Filename); 2444 2445 if (File == 0) { 2446 std::string ErrorStr = "could not find file '"; 2447 ErrorStr += Filename; 2448 ErrorStr += "' referenced by AST file"; 2449 Error(ErrorStr.c_str()); 2450 return IgnorePCH; 2451 } 2452 2453 if (Record.size() < 7) { 2454 Error("source location entry is incorrect"); 2455 return Failure; 2456 } 2457 2458 // The stat info from the FileEntry came from the cached stat 2459 // info of the PCH, so we cannot trust it. 2460 struct stat StatBuf; 2461 if (::stat(File->getName(), &StatBuf) != 0) { 2462 StatBuf.st_size = File->getSize(); 2463 StatBuf.st_mtime = File->getModificationTime(); 2464 } 2465 2466 if (((off_t)Record[4] != StatBuf.st_size 2467#if !defined(LLVM_ON_WIN32) 2468 // In our regression testing, the Windows file system seems to 2469 // have inconsistent modification times that sometimes 2470 // erroneously trigger this error-handling path. 2471 || (time_t)Record[5] != StatBuf.st_mtime 2472#endif 2473 )) { 2474 Error(diag::err_fe_pch_file_modified, Filename); 2475 return IgnorePCH; 2476 } 2477 2478 break; 2479 } 2480 } 2481 } 2482 2483 return Success; 2484} 2485 2486void ASTReader::makeNamesVisible(const HiddenNames &Names) { 2487 for (unsigned I = 0, N = Names.size(); I != N; ++I) { 2488 if (Decl *D = Names[I].dyn_cast<Decl *>()) 2489 D->ModulePrivate = false; 2490 else { 2491 IdentifierInfo *II = Names[I].get<IdentifierInfo *>(); 2492 if (!II->hasMacroDefinition()) { 2493 II->setHasMacroDefinition(true); 2494 if (DeserializationListener) 2495 DeserializationListener->MacroVisible(II); 2496 } 2497 } 2498 } 2499} 2500 2501void ASTReader::makeModuleVisible(Module *Mod, 2502 Module::NameVisibilityKind NameVisibility) { 2503 llvm::SmallPtrSet<Module *, 4> Visited; 2504 llvm::SmallVector<Module *, 4> Stack; 2505 Stack.push_back(Mod); 2506 while (!Stack.empty()) { 2507 Mod = Stack.back(); 2508 Stack.pop_back(); 2509 2510 if (NameVisibility <= Mod->NameVisibility) { 2511 // This module already has this level of visibility (or greater), so 2512 // there is nothing more to do. 2513 continue; 2514 } 2515 2516 // Update the module's name visibility. 2517 Mod->NameVisibility = NameVisibility; 2518 2519 // If we've already deserialized any names from this module, 2520 // mark them as visible. 2521 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 2522 if (Hidden != HiddenNamesMap.end()) { 2523 makeNamesVisible(Hidden->second); 2524 HiddenNamesMap.erase(Hidden); 2525 } 2526 2527 // Push any non-explicit submodules onto the stack to be marked as 2528 // visible. 2529 for (llvm::StringMap<Module *>::iterator Sub = Mod->SubModules.begin(), 2530 SubEnd = Mod->SubModules.end(); 2531 Sub != SubEnd; ++Sub) { 2532 if (!Sub->getValue()->IsExplicit && Visited.insert(Sub->getValue())) 2533 Stack.push_back(Sub->getValue()); 2534 } 2535 2536 // Push any exported modules onto the stack to be marked as visible. 2537 bool AnyWildcard = false; 2538 bool UnrestrictedWildcard = false; 2539 llvm::SmallVector<Module *, 4> WildcardRestrictions; 2540 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) { 2541 Module *Exported = Mod->Exports[I].getPointer(); 2542 if (!Mod->Exports[I].getInt()) { 2543 // Export a named module directly; no wildcards involved. 2544 if (Visited.insert(Exported)) 2545 Stack.push_back(Exported); 2546 2547 continue; 2548 } 2549 2550 // Wildcard export: export all of the imported modules that match 2551 // the given pattern. 2552 AnyWildcard = true; 2553 if (UnrestrictedWildcard) 2554 continue; 2555 2556 if (Module *Restriction = Mod->Exports[I].getPointer()) 2557 WildcardRestrictions.push_back(Restriction); 2558 else { 2559 WildcardRestrictions.clear(); 2560 UnrestrictedWildcard = true; 2561 } 2562 } 2563 2564 // If there were any wildcards, push any imported modules that were 2565 // re-exported by the wildcard restriction. 2566 if (!AnyWildcard) 2567 continue; 2568 2569 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) { 2570 Module *Imported = Mod->Imports[I]; 2571 if (Visited.count(Imported)) 2572 continue; 2573 2574 bool Acceptable = UnrestrictedWildcard; 2575 if (!Acceptable) { 2576 // Check whether this module meets one of the restrictions. 2577 for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) { 2578 Module *Restriction = WildcardRestrictions[R]; 2579 if (Imported == Restriction || Imported->isSubModuleOf(Restriction)) { 2580 Acceptable = true; 2581 break; 2582 } 2583 } 2584 } 2585 2586 if (!Acceptable) 2587 continue; 2588 2589 Visited.insert(Imported); 2590 Stack.push_back(Imported); 2591 } 2592 } 2593} 2594 2595ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2596 ModuleKind Type) { 2597 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) { 2598 case Failure: return Failure; 2599 case IgnorePCH: return IgnorePCH; 2600 case Success: break; 2601 } 2602 2603 // Here comes stuff that we only do once the entire chain is loaded. 2604 2605 // Check the predefines buffers. 2606 if (!DisableValidation && Type == MK_PCH && 2607 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines; 2608 // if DisableValidation is true, defines that were set on command-line 2609 // but not in the PCH file will not be added to SuggestedPredefines. 2610 CheckPredefinesBuffers()) 2611 return IgnorePCH; 2612 2613 // Mark all of the identifiers in the identifier table as being out of date, 2614 // so that various accessors know to check the loaded modules when the 2615 // identifier is used. 2616 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2617 IdEnd = PP.getIdentifierTable().end(); 2618 Id != IdEnd; ++Id) 2619 Id->second->setOutOfDate(true); 2620 2621 // Resolve any unresolved module exports. 2622 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) { 2623 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I]; 2624 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 2625 Module *ResolvedMod = getSubmodule(GlobalID); 2626 2627 if (Unresolved.IsImport) { 2628 if (ResolvedMod) 2629 Unresolved.Mod->Imports.push_back(ResolvedMod); 2630 continue; 2631 } 2632 2633 if (ResolvedMod || Unresolved.IsWildcard) 2634 Unresolved.Mod->Exports.push_back( 2635 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 2636 } 2637 UnresolvedModuleImportExports.clear(); 2638 2639 InitializeContext(); 2640 2641 if (DeserializationListener) 2642 DeserializationListener->ReaderInitialized(this); 2643 2644 // If this AST file is a precompiled preamble, then set the preamble file ID 2645 // of the source manager to the file source file from which the preamble was 2646 // built. 2647 if (Type == MK_Preamble) { 2648 if (!OriginalFileID.isInvalid()) { 2649 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2650 + OriginalFileID.getOpaqueValue() - 1); 2651 SourceMgr.setPreambleFileID(OriginalFileID); 2652 } 2653 } 2654 2655 return Success; 2656} 2657 2658ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2659 ModuleKind Type, 2660 ModuleFile *ImportedBy) { 2661 ModuleFile *M; 2662 bool NewModule; 2663 std::string ErrorStr; 2664 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy, 2665 ErrorStr); 2666 2667 if (!M) { 2668 // We couldn't load the module. 2669 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2670 + ErrorStr; 2671 Error(Msg); 2672 return Failure; 2673 } 2674 2675 if (!NewModule) { 2676 // We've already loaded this module. 2677 return Success; 2678 } 2679 2680 // FIXME: This seems rather a hack. Should CurrentDir be part of the 2681 // module? 2682 if (FileName != "-") { 2683 CurrentDir = llvm::sys::path::parent_path(FileName); 2684 if (CurrentDir.empty()) CurrentDir = "."; 2685 } 2686 2687 ModuleFile &F = *M; 2688 llvm::BitstreamCursor &Stream = F.Stream; 2689 Stream.init(F.StreamFile); 2690 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2691 2692 // Sniff for the signature. 2693 if (Stream.Read(8) != 'C' || 2694 Stream.Read(8) != 'P' || 2695 Stream.Read(8) != 'C' || 2696 Stream.Read(8) != 'H') { 2697 Diag(diag::err_not_a_pch_file) << FileName; 2698 return Failure; 2699 } 2700 2701 while (!Stream.AtEndOfStream()) { 2702 unsigned Code = Stream.ReadCode(); 2703 2704 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2705 Error("invalid record at top-level of AST file"); 2706 return Failure; 2707 } 2708 2709 unsigned BlockID = Stream.ReadSubBlockID(); 2710 2711 // We only know the AST subblock ID. 2712 switch (BlockID) { 2713 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2714 if (Stream.ReadBlockInfoBlock()) { 2715 Error("malformed BlockInfoBlock in AST file"); 2716 return Failure; 2717 } 2718 break; 2719 case AST_BLOCK_ID: 2720 switch (ReadASTBlock(F)) { 2721 case Success: 2722 break; 2723 2724 case Failure: 2725 return Failure; 2726 2727 case IgnorePCH: 2728 // FIXME: We could consider reading through to the end of this 2729 // AST block, skipping subblocks, to see if there are other 2730 // AST blocks elsewhere. 2731 2732 // FIXME: We can't clear loaded slocentries anymore. 2733 //SourceMgr.ClearPreallocatedSLocEntries(); 2734 2735 // Remove the stat cache. 2736 if (F.StatCache) 2737 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2738 2739 return IgnorePCH; 2740 } 2741 break; 2742 default: 2743 if (Stream.SkipBlock()) { 2744 Error("malformed block record in AST file"); 2745 return Failure; 2746 } 2747 break; 2748 } 2749 } 2750 2751 // Once read, set the ModuleFile bit base offset and update the size in 2752 // bits of all files we've seen. 2753 F.GlobalBitOffset = TotalModulesSizeInBits; 2754 TotalModulesSizeInBits += F.SizeInBits; 2755 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2756 2757 // Make sure that the files this module was built against are still available. 2758 if (!DisableValidation) { 2759 switch(validateFileEntries(*M)) { 2760 case Failure: return Failure; 2761 case IgnorePCH: return IgnorePCH; 2762 case Success: break; 2763 } 2764 } 2765 2766 // Preload SLocEntries. 2767 for (unsigned I = 0, N = M->PreloadSLocEntries.size(); I != N; ++I) { 2768 int Index = int(M->PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2769 // Load it through the SourceManager and don't call ReadSLocEntryRecord() 2770 // directly because the entry may have already been loaded in which case 2771 // calling ReadSLocEntryRecord() directly would trigger an assertion in 2772 // SourceManager. 2773 SourceMgr.getLoadedSLocEntryByID(Index); 2774 } 2775 2776 2777 return Success; 2778} 2779 2780void ASTReader::InitializeContext() { 2781 // If there's a listener, notify them that we "read" the translation unit. 2782 if (DeserializationListener) 2783 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 2784 Context.getTranslationUnitDecl()); 2785 2786 // Make sure we load the declaration update records for the translation unit, 2787 // if there are any. 2788 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 2789 Context.getTranslationUnitDecl()); 2790 2791 // FIXME: Find a better way to deal with collisions between these 2792 // built-in types. Right now, we just ignore the problem. 2793 2794 // Load the special types. 2795 if (SpecialTypes.size() > NumSpecialTypeIDs) { 2796 if (Context.getBuiltinVaListType().isNull()) { 2797 Context.setBuiltinVaListType( 2798 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2799 } 2800 2801 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) { 2802 if (Context.ObjCProtoType.isNull()) 2803 Context.ObjCProtoType = GetType(Proto); 2804 } 2805 2806 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 2807 if (!Context.CFConstantStringTypeDecl) 2808 Context.setCFConstantStringType(GetType(String)); 2809 } 2810 2811 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2812 QualType FileType = GetType(File); 2813 if (FileType.isNull()) { 2814 Error("FILE type is NULL"); 2815 return; 2816 } 2817 2818 if (!Context.FILEDecl) { 2819 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2820 Context.setFILEDecl(Typedef->getDecl()); 2821 else { 2822 const TagType *Tag = FileType->getAs<TagType>(); 2823 if (!Tag) { 2824 Error("Invalid FILE type in AST file"); 2825 return; 2826 } 2827 Context.setFILEDecl(Tag->getDecl()); 2828 } 2829 } 2830 } 2831 2832 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 2833 QualType Jmp_bufType = GetType(Jmp_buf); 2834 if (Jmp_bufType.isNull()) { 2835 Error("jmp_buf type is NULL"); 2836 return; 2837 } 2838 2839 if (!Context.jmp_bufDecl) { 2840 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2841 Context.setjmp_bufDecl(Typedef->getDecl()); 2842 else { 2843 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2844 if (!Tag) { 2845 Error("Invalid jmp_buf type in AST file"); 2846 return; 2847 } 2848 Context.setjmp_bufDecl(Tag->getDecl()); 2849 } 2850 } 2851 } 2852 2853 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 2854 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2855 if (Sigjmp_bufType.isNull()) { 2856 Error("sigjmp_buf type is NULL"); 2857 return; 2858 } 2859 2860 if (!Context.sigjmp_bufDecl) { 2861 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2862 Context.setsigjmp_bufDecl(Typedef->getDecl()); 2863 else { 2864 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2865 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2866 Context.setsigjmp_bufDecl(Tag->getDecl()); 2867 } 2868 } 2869 } 2870 2871 if (unsigned ObjCIdRedef 2872 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 2873 if (Context.ObjCIdRedefinitionType.isNull()) 2874 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2875 } 2876 2877 if (unsigned ObjCClassRedef 2878 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 2879 if (Context.ObjCClassRedefinitionType.isNull()) 2880 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2881 } 2882 2883 if (unsigned ObjCSelRedef 2884 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 2885 if (Context.ObjCSelRedefinitionType.isNull()) 2886 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2887 } 2888 2889 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 2890 QualType Ucontext_tType = GetType(Ucontext_t); 2891 if (Ucontext_tType.isNull()) { 2892 Error("ucontext_t type is NULL"); 2893 return; 2894 } 2895 2896 if (!Context.ucontext_tDecl) { 2897 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 2898 Context.setucontext_tDecl(Typedef->getDecl()); 2899 else { 2900 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 2901 assert(Tag && "Invalid ucontext_t type in AST file"); 2902 Context.setucontext_tDecl(Tag->getDecl()); 2903 } 2904 } 2905 } 2906 } 2907 2908 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 2909 2910 // If there were any CUDA special declarations, deserialize them. 2911 if (!CUDASpecialDeclRefs.empty()) { 2912 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 2913 Context.setcudaConfigureCallDecl( 2914 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 2915 } 2916 2917 // Re-export any modules that were imported by a non-module AST file. 2918 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 2919 if (Module *Imported = getSubmodule(ImportedModules[I])) 2920 makeModuleVisible(Imported, Module::AllVisible); 2921 } 2922 ImportedModules.clear(); 2923} 2924 2925void ASTReader::finalizeForWriting() { 2926 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 2927 HiddenEnd = HiddenNamesMap.end(); 2928 Hidden != HiddenEnd; ++Hidden) { 2929 makeNamesVisible(Hidden->second); 2930 } 2931 HiddenNamesMap.clear(); 2932} 2933 2934/// \brief Retrieve the name of the original source file name 2935/// directly from the AST file, without actually loading the AST 2936/// file. 2937std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2938 FileManager &FileMgr, 2939 DiagnosticsEngine &Diags) { 2940 // Open the AST file. 2941 std::string ErrStr; 2942 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2943 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 2944 if (!Buffer) { 2945 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2946 return std::string(); 2947 } 2948 2949 // Initialize the stream 2950 llvm::BitstreamReader StreamFile; 2951 llvm::BitstreamCursor Stream; 2952 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2953 (const unsigned char *)Buffer->getBufferEnd()); 2954 Stream.init(StreamFile); 2955 2956 // Sniff for the signature. 2957 if (Stream.Read(8) != 'C' || 2958 Stream.Read(8) != 'P' || 2959 Stream.Read(8) != 'C' || 2960 Stream.Read(8) != 'H') { 2961 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2962 return std::string(); 2963 } 2964 2965 RecordData Record; 2966 while (!Stream.AtEndOfStream()) { 2967 unsigned Code = Stream.ReadCode(); 2968 2969 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2970 unsigned BlockID = Stream.ReadSubBlockID(); 2971 2972 // We only know the AST subblock ID. 2973 switch (BlockID) { 2974 case AST_BLOCK_ID: 2975 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2976 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2977 return std::string(); 2978 } 2979 break; 2980 2981 default: 2982 if (Stream.SkipBlock()) { 2983 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2984 return std::string(); 2985 } 2986 break; 2987 } 2988 continue; 2989 } 2990 2991 if (Code == llvm::bitc::END_BLOCK) { 2992 if (Stream.ReadBlockEnd()) { 2993 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2994 return std::string(); 2995 } 2996 continue; 2997 } 2998 2999 if (Code == llvm::bitc::DEFINE_ABBREV) { 3000 Stream.ReadAbbrevRecord(); 3001 continue; 3002 } 3003 3004 Record.clear(); 3005 const char *BlobStart = 0; 3006 unsigned BlobLen = 0; 3007 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 3008 == ORIGINAL_FILE_NAME) 3009 return std::string(BlobStart, BlobLen); 3010 } 3011 3012 return std::string(); 3013} 3014 3015ASTReader::ASTReadResult ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 3016 // Enter the submodule block. 3017 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 3018 Error("malformed submodule block record in AST file"); 3019 return Failure; 3020 } 3021 3022 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 3023 bool First = true; 3024 Module *CurrentModule = 0; 3025 RecordData Record; 3026 while (true) { 3027 unsigned Code = F.Stream.ReadCode(); 3028 if (Code == llvm::bitc::END_BLOCK) { 3029 if (F.Stream.ReadBlockEnd()) { 3030 Error("error at end of submodule block in AST file"); 3031 return Failure; 3032 } 3033 return Success; 3034 } 3035 3036 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3037 // No known subblocks, always skip them. 3038 F.Stream.ReadSubBlockID(); 3039 if (F.Stream.SkipBlock()) { 3040 Error("malformed block record in AST file"); 3041 return Failure; 3042 } 3043 continue; 3044 } 3045 3046 if (Code == llvm::bitc::DEFINE_ABBREV) { 3047 F.Stream.ReadAbbrevRecord(); 3048 continue; 3049 } 3050 3051 // Read a record. 3052 const char *BlobStart; 3053 unsigned BlobLen; 3054 Record.clear(); 3055 switch (F.Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 3056 default: // Default behavior: ignore. 3057 break; 3058 3059 case SUBMODULE_DEFINITION: { 3060 if (First) { 3061 Error("missing submodule metadata record at beginning of block"); 3062 return Failure; 3063 } 3064 3065 if (Record.size() < 7) { 3066 Error("malformed module definition"); 3067 return Failure; 3068 } 3069 3070 StringRef Name(BlobStart, BlobLen); 3071 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]); 3072 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]); 3073 bool IsFramework = Record[2]; 3074 bool IsExplicit = Record[3]; 3075 bool InferSubmodules = Record[4]; 3076 bool InferExplicitSubmodules = Record[5]; 3077 bool InferExportWildcard = Record[6]; 3078 3079 Module *ParentModule = 0; 3080 if (Parent) 3081 ParentModule = getSubmodule(Parent); 3082 3083 // Retrieve this (sub)module from the module map, creating it if 3084 // necessary. 3085 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3086 IsFramework, 3087 IsExplicit).first; 3088 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 3089 if (GlobalIndex >= SubmodulesLoaded.size() || 3090 SubmodulesLoaded[GlobalIndex]) { 3091 Error("too many submodules"); 3092 return Failure; 3093 } 3094 3095 CurrentModule->IsFromModuleFile = true; 3096 CurrentModule->InferSubmodules = InferSubmodules; 3097 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 3098 CurrentModule->InferExportWildcard = InferExportWildcard; 3099 if (DeserializationListener) 3100 DeserializationListener->ModuleRead(GlobalID, CurrentModule); 3101 3102 SubmodulesLoaded[GlobalIndex] = CurrentModule; 3103 break; 3104 } 3105 3106 case SUBMODULE_UMBRELLA_HEADER: { 3107 if (First) { 3108 Error("missing submodule metadata record at beginning of block"); 3109 return Failure; 3110 } 3111 3112 if (!CurrentModule) 3113 break; 3114 3115 StringRef FileName(BlobStart, BlobLen); 3116 if (const FileEntry *Umbrella = PP.getFileManager().getFile(FileName)) { 3117 if (!CurrentModule->getUmbrellaHeader()) 3118 ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 3119 else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 3120 Error("mismatched umbrella headers in submodule"); 3121 return Failure; 3122 } 3123 } 3124 break; 3125 } 3126 3127 case SUBMODULE_HEADER: { 3128 if (First) { 3129 Error("missing submodule metadata record at beginning of block"); 3130 return Failure; 3131 } 3132 3133 if (!CurrentModule) 3134 break; 3135 3136 // FIXME: Be more lazy about this! 3137 StringRef FileName(BlobStart, BlobLen); 3138 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) { 3139 if (std::find(CurrentModule->Headers.begin(), 3140 CurrentModule->Headers.end(), 3141 File) == CurrentModule->Headers.end()) 3142 ModMap.addHeader(CurrentModule, File); 3143 } 3144 break; 3145 } 3146 3147 case SUBMODULE_UMBRELLA_DIR: { 3148 if (First) { 3149 Error("missing submodule metadata record at beginning of block"); 3150 return Failure; 3151 } 3152 3153 if (!CurrentModule) 3154 break; 3155 3156 StringRef DirName(BlobStart, BlobLen); 3157 if (const DirectoryEntry *Umbrella 3158 = PP.getFileManager().getDirectory(DirName)) { 3159 if (!CurrentModule->getUmbrellaDir()) 3160 ModMap.setUmbrellaDir(CurrentModule, Umbrella); 3161 else if (CurrentModule->getUmbrellaDir() != Umbrella) { 3162 Error("mismatched umbrella directories in submodule"); 3163 return Failure; 3164 } 3165 } 3166 break; 3167 } 3168 3169 case SUBMODULE_METADATA: { 3170 if (!First) { 3171 Error("submodule metadata record not at beginning of block"); 3172 return Failure; 3173 } 3174 First = false; 3175 3176 F.BaseSubmoduleID = getTotalNumSubmodules(); 3177 F.LocalNumSubmodules = Record[0]; 3178 unsigned LocalBaseSubmoduleID = Record[1]; 3179 if (F.LocalNumSubmodules > 0) { 3180 // Introduce the global -> local mapping for submodules within this 3181 // module. 3182 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3183 3184 // Introduce the local -> global mapping for submodules within this 3185 // module. 3186 F.SubmoduleRemap.insertOrReplace( 3187 std::make_pair(LocalBaseSubmoduleID, 3188 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3189 3190 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3191 } 3192 break; 3193 } 3194 3195 case SUBMODULE_IMPORTS: { 3196 if (First) { 3197 Error("missing submodule metadata record at beginning of block"); 3198 return Failure; 3199 } 3200 3201 if (!CurrentModule) 3202 break; 3203 3204 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3205 UnresolvedModuleImportExport Unresolved; 3206 Unresolved.File = &F; 3207 Unresolved.Mod = CurrentModule; 3208 Unresolved.ID = Record[Idx]; 3209 Unresolved.IsImport = true; 3210 Unresolved.IsWildcard = false; 3211 UnresolvedModuleImportExports.push_back(Unresolved); 3212 } 3213 break; 3214 } 3215 3216 case SUBMODULE_EXPORTS: { 3217 if (First) { 3218 Error("missing submodule metadata record at beginning of block"); 3219 return Failure; 3220 } 3221 3222 if (!CurrentModule) 3223 break; 3224 3225 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3226 UnresolvedModuleImportExport Unresolved; 3227 Unresolved.File = &F; 3228 Unresolved.Mod = CurrentModule; 3229 Unresolved.ID = Record[Idx]; 3230 Unresolved.IsImport = false; 3231 Unresolved.IsWildcard = Record[Idx + 1]; 3232 UnresolvedModuleImportExports.push_back(Unresolved); 3233 } 3234 3235 // Once we've loaded the set of exports, there's no reason to keep 3236 // the parsed, unresolved exports around. 3237 CurrentModule->UnresolvedExports.clear(); 3238 break; 3239 } 3240 } 3241 } 3242 3243 return Success; 3244} 3245 3246/// \brief Parse the record that corresponds to a LangOptions data 3247/// structure. 3248/// 3249/// This routine parses the language options from the AST file and then gives 3250/// them to the AST listener if one is set. 3251/// 3252/// \returns true if the listener deems the file unacceptable, false otherwise. 3253bool ASTReader::ParseLanguageOptions( 3254 const SmallVectorImpl<uint64_t> &Record) { 3255 if (Listener) { 3256 LangOptions LangOpts; 3257 unsigned Idx = 0; 3258#define LANGOPT(Name, Bits, Default, Description) \ 3259 LangOpts.Name = Record[Idx++]; 3260#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3261 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3262#include "clang/Basic/LangOptions.def" 3263 3264 unsigned Length = Record[Idx++]; 3265 LangOpts.CurrentModule.assign(Record.begin() + Idx, 3266 Record.begin() + Idx + Length); 3267 Idx += Length; 3268 return Listener->ReadLanguageOptions(LangOpts); 3269 } 3270 3271 return false; 3272} 3273 3274std::pair<ModuleFile *, unsigned> 3275ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 3276 GlobalPreprocessedEntityMapType::iterator 3277 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 3278 assert(I != GlobalPreprocessedEntityMap.end() && 3279 "Corrupted global preprocessed entity map"); 3280 ModuleFile *M = I->second; 3281 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 3282 return std::make_pair(M, LocalIndex); 3283} 3284 3285PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 3286 PreprocessedEntityID PPID = Index+1; 3287 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3288 ModuleFile &M = *PPInfo.first; 3289 unsigned LocalIndex = PPInfo.second; 3290 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3291 3292 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 3293 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 3294 3295 unsigned Code = M.PreprocessorDetailCursor.ReadCode(); 3296 switch (Code) { 3297 case llvm::bitc::END_BLOCK: 3298 return 0; 3299 3300 case llvm::bitc::ENTER_SUBBLOCK: 3301 Error("unexpected subblock record in preprocessor detail block"); 3302 return 0; 3303 3304 case llvm::bitc::DEFINE_ABBREV: 3305 Error("unexpected abbrevation record in preprocessor detail block"); 3306 return 0; 3307 3308 default: 3309 break; 3310 } 3311 3312 if (!PP.getPreprocessingRecord()) { 3313 Error("no preprocessing record"); 3314 return 0; 3315 } 3316 3317 // Read the record. 3318 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 3319 ReadSourceLocation(M, PPOffs.End)); 3320 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 3321 const char *BlobStart = 0; 3322 unsigned BlobLen = 0; 3323 RecordData Record; 3324 PreprocessorDetailRecordTypes RecType = 3325 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord( 3326 Code, Record, BlobStart, BlobLen); 3327 switch (RecType) { 3328 case PPD_MACRO_EXPANSION: { 3329 bool isBuiltin = Record[0]; 3330 IdentifierInfo *Name = 0; 3331 MacroDefinition *Def = 0; 3332 if (isBuiltin) 3333 Name = getLocalIdentifier(M, Record[1]); 3334 else { 3335 PreprocessedEntityID 3336 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 3337 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 3338 } 3339 3340 MacroExpansion *ME; 3341 if (isBuiltin) 3342 ME = new (PPRec) MacroExpansion(Name, Range); 3343 else 3344 ME = new (PPRec) MacroExpansion(Def, Range); 3345 3346 return ME; 3347 } 3348 3349 case PPD_MACRO_DEFINITION: { 3350 // Decode the identifier info and then check again; if the macro is 3351 // still defined and associated with the identifier, 3352 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 3353 MacroDefinition *MD 3354 = new (PPRec) MacroDefinition(II, Range); 3355 3356 if (DeserializationListener) 3357 DeserializationListener->MacroDefinitionRead(PPID, MD); 3358 3359 return MD; 3360 } 3361 3362 case PPD_INCLUSION_DIRECTIVE: { 3363 const char *FullFileNameStart = BlobStart + Record[0]; 3364 const FileEntry *File 3365 = PP.getFileManager().getFile(StringRef(FullFileNameStart, 3366 BlobLen - Record[0])); 3367 3368 // FIXME: Stable encoding 3369 InclusionDirective::InclusionKind Kind 3370 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 3371 InclusionDirective *ID 3372 = new (PPRec) InclusionDirective(PPRec, Kind, 3373 StringRef(BlobStart, Record[0]), 3374 Record[1], 3375 File, 3376 Range); 3377 return ID; 3378 } 3379 } 3380 3381 Error("invalid offset in preprocessor detail block"); 3382 return 0; 3383} 3384 3385/// \brief \arg SLocMapI points at a chunk of a module that contains no 3386/// preprocessed entities or the entities it contains are not the ones we are 3387/// looking for. Find the next module that contains entities and return the ID 3388/// of the first entry. 3389PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 3390 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 3391 ++SLocMapI; 3392 for (GlobalSLocOffsetMapType::const_iterator 3393 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 3394 ModuleFile &M = *SLocMapI->second; 3395 if (M.NumPreprocessedEntities) 3396 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID); 3397 } 3398 3399 return getTotalNumPreprocessedEntities(); 3400} 3401 3402namespace { 3403 3404template <unsigned PPEntityOffset::*PPLoc> 3405struct PPEntityComp { 3406 const ASTReader &Reader; 3407 ModuleFile &M; 3408 3409 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 3410 3411 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 3412 SourceLocation LHS = getLoc(L); 3413 SourceLocation RHS = getLoc(R); 3414 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3415 } 3416 3417 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 3418 SourceLocation LHS = getLoc(L); 3419 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3420 } 3421 3422 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 3423 SourceLocation RHS = getLoc(R); 3424 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 3425 } 3426 3427 SourceLocation getLoc(const PPEntityOffset &PPE) const { 3428 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 3429 } 3430}; 3431 3432} 3433 3434/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 3435PreprocessedEntityID 3436ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 3437 if (SourceMgr.isLocalSourceLocation(BLoc)) 3438 return getTotalNumPreprocessedEntities(); 3439 3440 GlobalSLocOffsetMapType::const_iterator 3441 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3442 BLoc.getOffset()); 3443 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3444 "Corrupted global sloc offset map"); 3445 3446 if (SLocMapI->second->NumPreprocessedEntities == 0) 3447 return findNextPreprocessedEntity(SLocMapI); 3448 3449 ModuleFile &M = *SLocMapI->second; 3450 typedef const PPEntityOffset *pp_iterator; 3451 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3452 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3453 3454 size_t Count = M.NumPreprocessedEntities; 3455 size_t Half; 3456 pp_iterator First = pp_begin; 3457 pp_iterator PPI; 3458 3459 // Do a binary search manually instead of using std::lower_bound because 3460 // The end locations of entities may be unordered (when a macro expansion 3461 // is inside another macro argument), but for this case it is not important 3462 // whether we get the first macro expansion or its containing macro. 3463 while (Count > 0) { 3464 Half = Count/2; 3465 PPI = First; 3466 std::advance(PPI, Half); 3467 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 3468 BLoc)){ 3469 First = PPI; 3470 ++First; 3471 Count = Count - Half - 1; 3472 } else 3473 Count = Half; 3474 } 3475 3476 if (PPI == pp_end) 3477 return findNextPreprocessedEntity(SLocMapI); 3478 3479 return getGlobalPreprocessedEntityID(M, 3480 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3481} 3482 3483/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 3484PreprocessedEntityID 3485ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 3486 if (SourceMgr.isLocalSourceLocation(ELoc)) 3487 return getTotalNumPreprocessedEntities(); 3488 3489 GlobalSLocOffsetMapType::const_iterator 3490 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 3491 ELoc.getOffset()); 3492 assert(SLocMapI != GlobalSLocOffsetMap.end() && 3493 "Corrupted global sloc offset map"); 3494 3495 if (SLocMapI->second->NumPreprocessedEntities == 0) 3496 return findNextPreprocessedEntity(SLocMapI); 3497 3498 ModuleFile &M = *SLocMapI->second; 3499 typedef const PPEntityOffset *pp_iterator; 3500 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 3501 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 3502 pp_iterator PPI = 3503 std::upper_bound(pp_begin, pp_end, ELoc, 3504 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 3505 3506 if (PPI == pp_end) 3507 return findNextPreprocessedEntity(SLocMapI); 3508 3509 return getGlobalPreprocessedEntityID(M, 3510 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3511} 3512 3513/// \brief Returns a pair of [Begin, End) indices of preallocated 3514/// preprocessed entities that \arg Range encompasses. 3515std::pair<unsigned, unsigned> 3516 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 3517 if (Range.isInvalid()) 3518 return std::make_pair(0,0); 3519 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 3520 3521 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 3522 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 3523 return std::make_pair(BeginID, EndID); 3524} 3525 3526/// \brief Optionally returns true or false if the preallocated preprocessed 3527/// entity with index \arg Index came from file \arg FID. 3528llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 3529 FileID FID) { 3530 if (FID.isInvalid()) 3531 return false; 3532 3533 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 3534 ModuleFile &M = *PPInfo.first; 3535 unsigned LocalIndex = PPInfo.second; 3536 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 3537 3538 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 3539 if (Loc.isInvalid()) 3540 return false; 3541 3542 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 3543 return true; 3544 else 3545 return false; 3546} 3547 3548namespace { 3549 /// \brief Visitor used to search for information about a header file. 3550 class HeaderFileInfoVisitor { 3551 ASTReader &Reader; 3552 const FileEntry *FE; 3553 3554 llvm::Optional<HeaderFileInfo> HFI; 3555 3556 public: 3557 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) 3558 : Reader(Reader), FE(FE) { } 3559 3560 static bool visit(ModuleFile &M, void *UserData) { 3561 HeaderFileInfoVisitor *This 3562 = static_cast<HeaderFileInfoVisitor *>(UserData); 3563 3564 HeaderFileInfoTrait Trait(This->Reader, M, 3565 &This->Reader.getPreprocessor().getHeaderSearchInfo(), 3566 M.HeaderFileFrameworkStrings, 3567 This->FE->getName()); 3568 3569 HeaderFileInfoLookupTable *Table 3570 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 3571 if (!Table) 3572 return false; 3573 3574 // Look in the on-disk hash table for an entry for this file name. 3575 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(), 3576 &Trait); 3577 if (Pos == Table->end()) 3578 return false; 3579 3580 This->HFI = *Pos; 3581 return true; 3582 } 3583 3584 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 3585 }; 3586} 3587 3588HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3589 HeaderFileInfoVisitor Visitor(*this, FE); 3590 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 3591 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 3592 if (Listener) 3593 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 3594 return *HFI; 3595 } 3596 3597 return HeaderFileInfo(); 3598} 3599 3600void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 3601 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3602 ModuleFile &F = *(*I); 3603 unsigned Idx = 0; 3604 while (Idx < F.PragmaDiagMappings.size()) { 3605 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3606 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 3607 Diag.DiagStatePoints.push_back( 3608 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(), 3609 FullSourceLoc(Loc, SourceMgr))); 3610 while (1) { 3611 assert(Idx < F.PragmaDiagMappings.size() && 3612 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3613 if (Idx >= F.PragmaDiagMappings.size()) { 3614 break; // Something is messed up but at least avoid infinite loop in 3615 // release build. 3616 } 3617 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3618 if (DiagID == (unsigned)-1) { 3619 break; // no more diag/map pairs for this location. 3620 } 3621 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3622 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 3623 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 3624 } 3625 } 3626 } 3627} 3628 3629/// \brief Get the correct cursor and offset for loading a type. 3630ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3631 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3632 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3633 ModuleFile *M = I->second; 3634 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3635} 3636 3637/// \brief Read and return the type with the given index.. 3638/// 3639/// The index is the type ID, shifted and minus the number of predefs. This 3640/// routine actually reads the record corresponding to the type at the given 3641/// location. It is a helper routine for GetType, which deals with reading type 3642/// IDs. 3643QualType ASTReader::readTypeRecord(unsigned Index) { 3644 RecordLocation Loc = TypeCursorForIndex(Index); 3645 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3646 3647 // Keep track of where we are in the stream, then jump back there 3648 // after reading this type. 3649 SavedStreamPosition SavedPosition(DeclsCursor); 3650 3651 ReadingKindTracker ReadingKind(Read_Type, *this); 3652 3653 // Note that we are loading a type record. 3654 Deserializing AType(this); 3655 3656 unsigned Idx = 0; 3657 DeclsCursor.JumpToBit(Loc.Offset); 3658 RecordData Record; 3659 unsigned Code = DeclsCursor.ReadCode(); 3660 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3661 case TYPE_EXT_QUAL: { 3662 if (Record.size() != 2) { 3663 Error("Incorrect encoding of extended qualifier type"); 3664 return QualType(); 3665 } 3666 QualType Base = readType(*Loc.F, Record, Idx); 3667 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3668 return Context.getQualifiedType(Base, Quals); 3669 } 3670 3671 case TYPE_COMPLEX: { 3672 if (Record.size() != 1) { 3673 Error("Incorrect encoding of complex type"); 3674 return QualType(); 3675 } 3676 QualType ElemType = readType(*Loc.F, Record, Idx); 3677 return Context.getComplexType(ElemType); 3678 } 3679 3680 case TYPE_POINTER: { 3681 if (Record.size() != 1) { 3682 Error("Incorrect encoding of pointer type"); 3683 return QualType(); 3684 } 3685 QualType PointeeType = readType(*Loc.F, Record, Idx); 3686 return Context.getPointerType(PointeeType); 3687 } 3688 3689 case TYPE_BLOCK_POINTER: { 3690 if (Record.size() != 1) { 3691 Error("Incorrect encoding of block pointer type"); 3692 return QualType(); 3693 } 3694 QualType PointeeType = readType(*Loc.F, Record, Idx); 3695 return Context.getBlockPointerType(PointeeType); 3696 } 3697 3698 case TYPE_LVALUE_REFERENCE: { 3699 if (Record.size() != 2) { 3700 Error("Incorrect encoding of lvalue reference type"); 3701 return QualType(); 3702 } 3703 QualType PointeeType = readType(*Loc.F, Record, Idx); 3704 return Context.getLValueReferenceType(PointeeType, Record[1]); 3705 } 3706 3707 case TYPE_RVALUE_REFERENCE: { 3708 if (Record.size() != 1) { 3709 Error("Incorrect encoding of rvalue reference type"); 3710 return QualType(); 3711 } 3712 QualType PointeeType = readType(*Loc.F, Record, Idx); 3713 return Context.getRValueReferenceType(PointeeType); 3714 } 3715 3716 case TYPE_MEMBER_POINTER: { 3717 if (Record.size() != 2) { 3718 Error("Incorrect encoding of member pointer type"); 3719 return QualType(); 3720 } 3721 QualType PointeeType = readType(*Loc.F, Record, Idx); 3722 QualType ClassType = readType(*Loc.F, Record, Idx); 3723 if (PointeeType.isNull() || ClassType.isNull()) 3724 return QualType(); 3725 3726 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3727 } 3728 3729 case TYPE_CONSTANT_ARRAY: { 3730 QualType ElementType = readType(*Loc.F, Record, Idx); 3731 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3732 unsigned IndexTypeQuals = Record[2]; 3733 unsigned Idx = 3; 3734 llvm::APInt Size = ReadAPInt(Record, Idx); 3735 return Context.getConstantArrayType(ElementType, Size, 3736 ASM, IndexTypeQuals); 3737 } 3738 3739 case TYPE_INCOMPLETE_ARRAY: { 3740 QualType ElementType = readType(*Loc.F, Record, Idx); 3741 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3742 unsigned IndexTypeQuals = Record[2]; 3743 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3744 } 3745 3746 case TYPE_VARIABLE_ARRAY: { 3747 QualType ElementType = readType(*Loc.F, Record, Idx); 3748 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3749 unsigned IndexTypeQuals = Record[2]; 3750 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3751 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3752 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3753 ASM, IndexTypeQuals, 3754 SourceRange(LBLoc, RBLoc)); 3755 } 3756 3757 case TYPE_VECTOR: { 3758 if (Record.size() != 3) { 3759 Error("incorrect encoding of vector type in AST file"); 3760 return QualType(); 3761 } 3762 3763 QualType ElementType = readType(*Loc.F, Record, Idx); 3764 unsigned NumElements = Record[1]; 3765 unsigned VecKind = Record[2]; 3766 return Context.getVectorType(ElementType, NumElements, 3767 (VectorType::VectorKind)VecKind); 3768 } 3769 3770 case TYPE_EXT_VECTOR: { 3771 if (Record.size() != 3) { 3772 Error("incorrect encoding of extended vector type in AST file"); 3773 return QualType(); 3774 } 3775 3776 QualType ElementType = readType(*Loc.F, Record, Idx); 3777 unsigned NumElements = Record[1]; 3778 return Context.getExtVectorType(ElementType, NumElements); 3779 } 3780 3781 case TYPE_FUNCTION_NO_PROTO: { 3782 if (Record.size() != 6) { 3783 Error("incorrect encoding of no-proto function type"); 3784 return QualType(); 3785 } 3786 QualType ResultType = readType(*Loc.F, Record, Idx); 3787 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3788 (CallingConv)Record[4], Record[5]); 3789 return Context.getFunctionNoProtoType(ResultType, Info); 3790 } 3791 3792 case TYPE_FUNCTION_PROTO: { 3793 QualType ResultType = readType(*Loc.F, Record, Idx); 3794 3795 FunctionProtoType::ExtProtoInfo EPI; 3796 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3797 /*hasregparm*/ Record[2], 3798 /*regparm*/ Record[3], 3799 static_cast<CallingConv>(Record[4]), 3800 /*produces*/ Record[5]); 3801 3802 unsigned Idx = 6; 3803 unsigned NumParams = Record[Idx++]; 3804 SmallVector<QualType, 16> ParamTypes; 3805 for (unsigned I = 0; I != NumParams; ++I) 3806 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3807 3808 EPI.Variadic = Record[Idx++]; 3809 EPI.TypeQuals = Record[Idx++]; 3810 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3811 ExceptionSpecificationType EST = 3812 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3813 EPI.ExceptionSpecType = EST; 3814 if (EST == EST_Dynamic) { 3815 EPI.NumExceptions = Record[Idx++]; 3816 SmallVector<QualType, 2> Exceptions; 3817 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3818 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3819 EPI.Exceptions = Exceptions.data(); 3820 } else if (EST == EST_ComputedNoexcept) { 3821 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3822 } 3823 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams, 3824 EPI); 3825 } 3826 3827 case TYPE_UNRESOLVED_USING: { 3828 unsigned Idx = 0; 3829 return Context.getTypeDeclType( 3830 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3831 } 3832 3833 case TYPE_TYPEDEF: { 3834 if (Record.size() != 2) { 3835 Error("incorrect encoding of typedef type"); 3836 return QualType(); 3837 } 3838 unsigned Idx = 0; 3839 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3840 QualType Canonical = readType(*Loc.F, Record, Idx); 3841 if (!Canonical.isNull()) 3842 Canonical = Context.getCanonicalType(Canonical); 3843 return Context.getTypedefType(Decl, Canonical); 3844 } 3845 3846 case TYPE_TYPEOF_EXPR: 3847 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 3848 3849 case TYPE_TYPEOF: { 3850 if (Record.size() != 1) { 3851 Error("incorrect encoding of typeof(type) in AST file"); 3852 return QualType(); 3853 } 3854 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3855 return Context.getTypeOfType(UnderlyingType); 3856 } 3857 3858 case TYPE_DECLTYPE: 3859 return Context.getDecltypeType(ReadExpr(*Loc.F)); 3860 3861 case TYPE_UNARY_TRANSFORM: { 3862 QualType BaseType = readType(*Loc.F, Record, Idx); 3863 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3864 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3865 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 3866 } 3867 3868 case TYPE_AUTO: 3869 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 3870 3871 case TYPE_RECORD: { 3872 if (Record.size() != 2) { 3873 Error("incorrect encoding of record type"); 3874 return QualType(); 3875 } 3876 unsigned Idx = 0; 3877 bool IsDependent = Record[Idx++]; 3878 QualType T 3879 = Context.getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3880 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3881 return T; 3882 } 3883 3884 case TYPE_ENUM: { 3885 if (Record.size() != 2) { 3886 Error("incorrect encoding of enum type"); 3887 return QualType(); 3888 } 3889 unsigned Idx = 0; 3890 bool IsDependent = Record[Idx++]; 3891 QualType T 3892 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3893 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3894 return T; 3895 } 3896 3897 case TYPE_ATTRIBUTED: { 3898 if (Record.size() != 3) { 3899 Error("incorrect encoding of attributed type"); 3900 return QualType(); 3901 } 3902 QualType modifiedType = readType(*Loc.F, Record, Idx); 3903 QualType equivalentType = readType(*Loc.F, Record, Idx); 3904 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3905 return Context.getAttributedType(kind, modifiedType, equivalentType); 3906 } 3907 3908 case TYPE_PAREN: { 3909 if (Record.size() != 1) { 3910 Error("incorrect encoding of paren type"); 3911 return QualType(); 3912 } 3913 QualType InnerType = readType(*Loc.F, Record, Idx); 3914 return Context.getParenType(InnerType); 3915 } 3916 3917 case TYPE_PACK_EXPANSION: { 3918 if (Record.size() != 2) { 3919 Error("incorrect encoding of pack expansion type"); 3920 return QualType(); 3921 } 3922 QualType Pattern = readType(*Loc.F, Record, Idx); 3923 if (Pattern.isNull()) 3924 return QualType(); 3925 llvm::Optional<unsigned> NumExpansions; 3926 if (Record[1]) 3927 NumExpansions = Record[1] - 1; 3928 return Context.getPackExpansionType(Pattern, NumExpansions); 3929 } 3930 3931 case TYPE_ELABORATED: { 3932 unsigned Idx = 0; 3933 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3934 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3935 QualType NamedType = readType(*Loc.F, Record, Idx); 3936 return Context.getElaboratedType(Keyword, NNS, NamedType); 3937 } 3938 3939 case TYPE_OBJC_INTERFACE: { 3940 unsigned Idx = 0; 3941 ObjCInterfaceDecl *ItfD 3942 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3943 return Context.getObjCInterfaceType(ItfD); 3944 } 3945 3946 case TYPE_OBJC_OBJECT: { 3947 unsigned Idx = 0; 3948 QualType Base = readType(*Loc.F, Record, Idx); 3949 unsigned NumProtos = Record[Idx++]; 3950 SmallVector<ObjCProtocolDecl*, 4> Protos; 3951 for (unsigned I = 0; I != NumProtos; ++I) 3952 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3953 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 3954 } 3955 3956 case TYPE_OBJC_OBJECT_POINTER: { 3957 unsigned Idx = 0; 3958 QualType Pointee = readType(*Loc.F, Record, Idx); 3959 return Context.getObjCObjectPointerType(Pointee); 3960 } 3961 3962 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3963 unsigned Idx = 0; 3964 QualType Parm = readType(*Loc.F, Record, Idx); 3965 QualType Replacement = readType(*Loc.F, Record, Idx); 3966 return 3967 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3968 Replacement); 3969 } 3970 3971 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3972 unsigned Idx = 0; 3973 QualType Parm = readType(*Loc.F, Record, Idx); 3974 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3975 return Context.getSubstTemplateTypeParmPackType( 3976 cast<TemplateTypeParmType>(Parm), 3977 ArgPack); 3978 } 3979 3980 case TYPE_INJECTED_CLASS_NAME: { 3981 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3982 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3983 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3984 // for AST reading, too much interdependencies. 3985 return 3986 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3987 } 3988 3989 case TYPE_TEMPLATE_TYPE_PARM: { 3990 unsigned Idx = 0; 3991 unsigned Depth = Record[Idx++]; 3992 unsigned Index = Record[Idx++]; 3993 bool Pack = Record[Idx++]; 3994 TemplateTypeParmDecl *D 3995 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3996 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 3997 } 3998 3999 case TYPE_DEPENDENT_NAME: { 4000 unsigned Idx = 0; 4001 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4002 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4003 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4004 QualType Canon = readType(*Loc.F, Record, Idx); 4005 if (!Canon.isNull()) 4006 Canon = Context.getCanonicalType(Canon); 4007 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 4008 } 4009 4010 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 4011 unsigned Idx = 0; 4012 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4013 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4014 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4015 unsigned NumArgs = Record[Idx++]; 4016 SmallVector<TemplateArgument, 8> Args; 4017 Args.reserve(NumArgs); 4018 while (NumArgs--) 4019 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 4020 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 4021 Args.size(), Args.data()); 4022 } 4023 4024 case TYPE_DEPENDENT_SIZED_ARRAY: { 4025 unsigned Idx = 0; 4026 4027 // ArrayType 4028 QualType ElementType = readType(*Loc.F, Record, Idx); 4029 ArrayType::ArraySizeModifier ASM 4030 = (ArrayType::ArraySizeModifier)Record[Idx++]; 4031 unsigned IndexTypeQuals = Record[Idx++]; 4032 4033 // DependentSizedArrayType 4034 Expr *NumElts = ReadExpr(*Loc.F); 4035 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 4036 4037 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 4038 IndexTypeQuals, Brackets); 4039 } 4040 4041 case TYPE_TEMPLATE_SPECIALIZATION: { 4042 unsigned Idx = 0; 4043 bool IsDependent = Record[Idx++]; 4044 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 4045 SmallVector<TemplateArgument, 8> Args; 4046 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 4047 QualType Underlying = readType(*Loc.F, Record, Idx); 4048 QualType T; 4049 if (Underlying.isNull()) 4050 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 4051 Args.size()); 4052 else 4053 T = Context.getTemplateSpecializationType(Name, Args.data(), 4054 Args.size(), Underlying); 4055 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4056 return T; 4057 } 4058 4059 case TYPE_ATOMIC: { 4060 if (Record.size() != 1) { 4061 Error("Incorrect encoding of atomic type"); 4062 return QualType(); 4063 } 4064 QualType ValueType = readType(*Loc.F, Record, Idx); 4065 return Context.getAtomicType(ValueType); 4066 } 4067 } 4068 // Suppress a GCC warning 4069 return QualType(); 4070} 4071 4072class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 4073 ASTReader &Reader; 4074 ModuleFile &F; 4075 llvm::BitstreamCursor &DeclsCursor; 4076 const ASTReader::RecordData &Record; 4077 unsigned &Idx; 4078 4079 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4080 unsigned &I) { 4081 return Reader.ReadSourceLocation(F, R, I); 4082 } 4083 4084 template<typename T> 4085 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4086 return Reader.ReadDeclAs<T>(F, Record, Idx); 4087 } 4088 4089public: 4090 TypeLocReader(ASTReader &Reader, ModuleFile &F, 4091 const ASTReader::RecordData &Record, unsigned &Idx) 4092 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 4093 { } 4094 4095 // We want compile-time assurance that we've enumerated all of 4096 // these, so unfortunately we have to declare them first, then 4097 // define them out-of-line. 4098#define ABSTRACT_TYPELOC(CLASS, PARENT) 4099#define TYPELOC(CLASS, PARENT) \ 4100 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4101#include "clang/AST/TypeLocNodes.def" 4102 4103 void VisitFunctionTypeLoc(FunctionTypeLoc); 4104 void VisitArrayTypeLoc(ArrayTypeLoc); 4105}; 4106 4107void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4108 // nothing to do 4109} 4110void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4111 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4112 if (TL.needsExtraLocalData()) { 4113 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4114 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4115 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4116 TL.setModeAttr(Record[Idx++]); 4117 } 4118} 4119void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4120 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4121} 4122void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4123 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4124} 4125void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4126 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 4127} 4128void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4129 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 4130} 4131void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4132 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 4133} 4134void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4135 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4136 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4137} 4138void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 4139 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 4140 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 4141 if (Record[Idx++]) 4142 TL.setSizeExpr(Reader.ReadExpr(F)); 4143 else 4144 TL.setSizeExpr(0); 4145} 4146void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 4147 VisitArrayTypeLoc(TL); 4148} 4149void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 4150 VisitArrayTypeLoc(TL); 4151} 4152void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 4153 VisitArrayTypeLoc(TL); 4154} 4155void TypeLocReader::VisitDependentSizedArrayTypeLoc( 4156 DependentSizedArrayTypeLoc TL) { 4157 VisitArrayTypeLoc(TL); 4158} 4159void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 4160 DependentSizedExtVectorTypeLoc TL) { 4161 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4162} 4163void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 4164 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4165} 4166void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 4167 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4168} 4169void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4170 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 4171 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 4172 TL.setTrailingReturn(Record[Idx++]); 4173 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 4174 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 4175 } 4176} 4177void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 4178 VisitFunctionTypeLoc(TL); 4179} 4180void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 4181 VisitFunctionTypeLoc(TL); 4182} 4183void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 4184 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4185} 4186void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4187 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4188} 4189void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4190 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4191 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4192 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4193} 4194void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4195 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 4196 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4197 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4198 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4199} 4200void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 4201 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4202} 4203void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4204 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4205 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4206 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4207 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 4208} 4209void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 4210 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4211} 4212void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 4213 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4214} 4215void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 4216 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4217} 4218void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4219 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 4220 if (TL.hasAttrOperand()) { 4221 SourceRange range; 4222 range.setBegin(ReadSourceLocation(Record, Idx)); 4223 range.setEnd(ReadSourceLocation(Record, Idx)); 4224 TL.setAttrOperandParensRange(range); 4225 } 4226 if (TL.hasAttrExprOperand()) { 4227 if (Record[Idx++]) 4228 TL.setAttrExprOperand(Reader.ReadExpr(F)); 4229 else 4230 TL.setAttrExprOperand(0); 4231 } else if (TL.hasAttrEnumOperand()) 4232 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 4233} 4234void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 4235 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4236} 4237void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 4238 SubstTemplateTypeParmTypeLoc TL) { 4239 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4240} 4241void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 4242 SubstTemplateTypeParmPackTypeLoc TL) { 4243 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4244} 4245void TypeLocReader::VisitTemplateSpecializationTypeLoc( 4246 TemplateSpecializationTypeLoc TL) { 4247 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 4248 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4249 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4250 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 4251 TL.setArgLocInfo(i, 4252 Reader.GetTemplateArgumentLocInfo(F, 4253 TL.getTypePtr()->getArg(i).getKind(), 4254 Record, Idx)); 4255} 4256void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 4257 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4258 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4259} 4260void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4261 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4262 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4263} 4264void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 4265 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4266} 4267void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4268 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4269 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4270 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4271} 4272void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 4273 DependentTemplateSpecializationTypeLoc TL) { 4274 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 4275 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 4276 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4277 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4278 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4279 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4280 TL.setArgLocInfo(I, 4281 Reader.GetTemplateArgumentLocInfo(F, 4282 TL.getTypePtr()->getArg(I).getKind(), 4283 Record, Idx)); 4284} 4285void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 4286 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 4287} 4288void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4289 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4290} 4291void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4292 TL.setHasBaseTypeAsWritten(Record[Idx++]); 4293 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 4294 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 4295 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 4296 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 4297} 4298void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4299 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4300} 4301void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4302 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 4303 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 4304 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 4305} 4306 4307TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 4308 const RecordData &Record, 4309 unsigned &Idx) { 4310 QualType InfoTy = readType(F, Record, Idx); 4311 if (InfoTy.isNull()) 4312 return 0; 4313 4314 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 4315 TypeLocReader TLR(*this, F, Record, Idx); 4316 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 4317 TLR.Visit(TL); 4318 return TInfo; 4319} 4320 4321QualType ASTReader::GetType(TypeID ID) { 4322 unsigned FastQuals = ID & Qualifiers::FastMask; 4323 unsigned Index = ID >> Qualifiers::FastWidth; 4324 4325 if (Index < NUM_PREDEF_TYPE_IDS) { 4326 QualType T; 4327 switch ((PredefinedTypeIDs)Index) { 4328 case PREDEF_TYPE_NULL_ID: return QualType(); 4329 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 4330 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 4331 4332 case PREDEF_TYPE_CHAR_U_ID: 4333 case PREDEF_TYPE_CHAR_S_ID: 4334 // FIXME: Check that the signedness of CharTy is correct! 4335 T = Context.CharTy; 4336 break; 4337 4338 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 4339 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 4340 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 4341 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 4342 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 4343 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 4344 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 4345 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 4346 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 4347 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 4348 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 4349 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 4350 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 4351 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 4352 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 4353 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 4354 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 4355 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 4356 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 4357 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 4358 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 4359 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 4360 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 4361 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 4362 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 4363 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 4364 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 4365 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 4366 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 4367 4368 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 4369 T = Context.getAutoRRefDeductType(); 4370 break; 4371 4372 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 4373 T = Context.ARCUnbridgedCastTy; 4374 break; 4375 4376 } 4377 4378 assert(!T.isNull() && "Unknown predefined type"); 4379 return T.withFastQualifiers(FastQuals); 4380 } 4381 4382 Index -= NUM_PREDEF_TYPE_IDS; 4383 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4384 if (TypesLoaded[Index].isNull()) { 4385 TypesLoaded[Index] = readTypeRecord(Index); 4386 if (TypesLoaded[Index].isNull()) 4387 return QualType(); 4388 4389 TypesLoaded[Index]->setFromAST(); 4390 if (DeserializationListener) 4391 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4392 TypesLoaded[Index]); 4393 } 4394 4395 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4396} 4397 4398QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 4399 return GetType(getGlobalTypeID(F, LocalID)); 4400} 4401 4402serialization::TypeID 4403ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 4404 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4405 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4406 4407 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4408 return LocalID; 4409 4410 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4411 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4412 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4413 4414 unsigned GlobalIndex = LocalIndex + I->second; 4415 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4416} 4417 4418TemplateArgumentLocInfo 4419ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 4420 TemplateArgument::ArgKind Kind, 4421 const RecordData &Record, 4422 unsigned &Index) { 4423 switch (Kind) { 4424 case TemplateArgument::Expression: 4425 return ReadExpr(F); 4426 case TemplateArgument::Type: 4427 return GetTypeSourceInfo(F, Record, Index); 4428 case TemplateArgument::Template: { 4429 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4430 Index); 4431 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4432 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4433 SourceLocation()); 4434 } 4435 case TemplateArgument::TemplateExpansion: { 4436 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4437 Index); 4438 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4439 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4440 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4441 EllipsisLoc); 4442 } 4443 case TemplateArgument::Null: 4444 case TemplateArgument::Integral: 4445 case TemplateArgument::Declaration: 4446 case TemplateArgument::Pack: 4447 return TemplateArgumentLocInfo(); 4448 } 4449 llvm_unreachable("unexpected template argument loc"); 4450 return TemplateArgumentLocInfo(); 4451} 4452 4453TemplateArgumentLoc 4454ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 4455 const RecordData &Record, unsigned &Index) { 4456 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4457 4458 if (Arg.getKind() == TemplateArgument::Expression) { 4459 if (Record[Index++]) // bool InfoHasSameExpr. 4460 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4461 } 4462 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4463 Record, Index)); 4464} 4465 4466Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4467 return GetDecl(ID); 4468} 4469 4470uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 4471 unsigned &Idx){ 4472 if (Idx >= Record.size()) 4473 return 0; 4474 4475 unsigned LocalID = Record[Idx++]; 4476 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4477} 4478 4479CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4480 RecordLocation Loc = getLocalBitOffset(Offset); 4481 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4482 SavedStreamPosition SavedPosition(Cursor); 4483 Cursor.JumpToBit(Loc.Offset); 4484 ReadingKindTracker ReadingKind(Read_Decl, *this); 4485 RecordData Record; 4486 unsigned Code = Cursor.ReadCode(); 4487 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4488 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4489 Error("Malformed AST file: missing C++ base specifiers"); 4490 return 0; 4491 } 4492 4493 unsigned Idx = 0; 4494 unsigned NumBases = Record[Idx++]; 4495 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4496 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4497 for (unsigned I = 0; I != NumBases; ++I) 4498 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4499 return Bases; 4500} 4501 4502serialization::DeclID 4503ASTReader::getGlobalDeclID(ModuleFile &F, unsigned LocalID) const { 4504 if (LocalID < NUM_PREDEF_DECL_IDS) 4505 return LocalID; 4506 4507 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4508 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4509 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4510 4511 return LocalID + I->second; 4512} 4513 4514bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 4515 ModuleFile &M) const { 4516 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 4517 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4518 return &M == I->second; 4519} 4520 4521SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 4522 if (ID < NUM_PREDEF_DECL_IDS) 4523 return SourceLocation(); 4524 4525 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4526 4527 if (Index > DeclsLoaded.size()) { 4528 Error("declaration ID out-of-range for AST file"); 4529 return SourceLocation(); 4530 } 4531 4532 if (Decl *D = DeclsLoaded[Index]) 4533 return D->getLocation(); 4534 4535 unsigned RawLocation = 0; 4536 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 4537 return ReadSourceLocation(*Rec.F, RawLocation); 4538} 4539 4540Decl *ASTReader::GetDecl(DeclID ID) { 4541 if (ID < NUM_PREDEF_DECL_IDS) { 4542 switch ((PredefinedDeclIDs)ID) { 4543 case PREDEF_DECL_NULL_ID: 4544 return 0; 4545 4546 case PREDEF_DECL_TRANSLATION_UNIT_ID: 4547 return Context.getTranslationUnitDecl(); 4548 4549 case PREDEF_DECL_OBJC_ID_ID: 4550 return Context.getObjCIdDecl(); 4551 4552 case PREDEF_DECL_OBJC_SEL_ID: 4553 return Context.getObjCSelDecl(); 4554 4555 case PREDEF_DECL_OBJC_CLASS_ID: 4556 return Context.getObjCClassDecl(); 4557 4558 case PREDEF_DECL_INT_128_ID: 4559 return Context.getInt128Decl(); 4560 4561 case PREDEF_DECL_UNSIGNED_INT_128_ID: 4562 return Context.getUInt128Decl(); 4563 4564 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 4565 return Context.getObjCInstanceTypeDecl(); 4566 } 4567 4568 return 0; 4569 } 4570 4571 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4572 4573 if (Index >= DeclsLoaded.size()) { 4574 Error("declaration ID out-of-range for AST file"); 4575 return 0; 4576 } 4577 4578 if (!DeclsLoaded[Index]) { 4579 ReadDeclRecord(ID); 4580 if (DeserializationListener) 4581 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4582 } 4583 4584 return DeclsLoaded[Index]; 4585} 4586 4587DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 4588 DeclID GlobalID) { 4589 if (GlobalID < NUM_PREDEF_DECL_IDS) 4590 return GlobalID; 4591 4592 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 4593 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 4594 ModuleFile *Owner = I->second; 4595 4596 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 4597 = M.GlobalToLocalDeclIDs.find(Owner); 4598 if (Pos == M.GlobalToLocalDeclIDs.end()) 4599 return 0; 4600 4601 return GlobalID - Owner->BaseDeclID + Pos->second; 4602} 4603 4604serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 4605 const RecordData &Record, 4606 unsigned &Idx) { 4607 if (Idx >= Record.size()) { 4608 Error("Corrupted AST file"); 4609 return 0; 4610 } 4611 4612 return getGlobalDeclID(F, Record[Idx++]); 4613} 4614 4615/// \brief Resolve the offset of a statement into a statement. 4616/// 4617/// This operation will read a new statement from the external 4618/// source each time it is called, and is meant to be used via a 4619/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4620Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4621 // Switch case IDs are per Decl. 4622 ClearSwitchCaseIDs(); 4623 4624 // Offset here is a global offset across the entire chain. 4625 RecordLocation Loc = getLocalBitOffset(Offset); 4626 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4627 return ReadStmtFromStream(*Loc.F); 4628} 4629 4630namespace { 4631 class FindExternalLexicalDeclsVisitor { 4632 ASTReader &Reader; 4633 const DeclContext *DC; 4634 bool (*isKindWeWant)(Decl::Kind); 4635 4636 SmallVectorImpl<Decl*> &Decls; 4637 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 4638 4639 public: 4640 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 4641 bool (*isKindWeWant)(Decl::Kind), 4642 SmallVectorImpl<Decl*> &Decls) 4643 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 4644 { 4645 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 4646 PredefsVisited[I] = false; 4647 } 4648 4649 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 4650 if (Preorder) 4651 return false; 4652 4653 FindExternalLexicalDeclsVisitor *This 4654 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 4655 4656 ModuleFile::DeclContextInfosMap::iterator Info 4657 = M.DeclContextInfos.find(This->DC); 4658 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 4659 return false; 4660 4661 // Load all of the declaration IDs 4662 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 4663 *IDE = ID + Info->second.NumLexicalDecls; 4664 ID != IDE; ++ID) { 4665 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 4666 continue; 4667 4668 // Don't add predefined declarations to the lexical context more 4669 // than once. 4670 if (ID->second < NUM_PREDEF_DECL_IDS) { 4671 if (This->PredefsVisited[ID->second]) 4672 continue; 4673 4674 This->PredefsVisited[ID->second] = true; 4675 } 4676 4677 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 4678 if (!This->DC->isDeclInLexicalTraversal(D)) 4679 This->Decls.push_back(D); 4680 } 4681 } 4682 4683 return false; 4684 } 4685 }; 4686} 4687 4688ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4689 bool (*isKindWeWant)(Decl::Kind), 4690 SmallVectorImpl<Decl*> &Decls) { 4691 // There might be lexical decls in multiple modules, for the TU at 4692 // least. Walk all of the modules in the order they were loaded. 4693 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 4694 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 4695 ++NumLexicalDeclContextsRead; 4696 return ELR_Success; 4697} 4698 4699namespace { 4700 4701class DeclIDComp { 4702 ASTReader &Reader; 4703 ModuleFile &Mod; 4704 4705public: 4706 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 4707 4708 bool operator()(LocalDeclID L, LocalDeclID R) const { 4709 SourceLocation LHS = getLocation(L); 4710 SourceLocation RHS = getLocation(R); 4711 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4712 } 4713 4714 bool operator()(SourceLocation LHS, LocalDeclID R) const { 4715 SourceLocation RHS = getLocation(R); 4716 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4717 } 4718 4719 bool operator()(LocalDeclID L, SourceLocation RHS) const { 4720 SourceLocation LHS = getLocation(L); 4721 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4722 } 4723 4724 SourceLocation getLocation(LocalDeclID ID) const { 4725 return Reader.getSourceManager().getFileLoc( 4726 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 4727 } 4728}; 4729 4730} 4731 4732void ASTReader::FindFileRegionDecls(FileID File, 4733 unsigned Offset, unsigned Length, 4734 SmallVectorImpl<Decl *> &Decls) { 4735 SourceManager &SM = getSourceManager(); 4736 4737 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 4738 if (I == FileDeclIDs.end()) 4739 return; 4740 4741 FileDeclsInfo &DInfo = I->second; 4742 if (DInfo.Decls.empty()) 4743 return; 4744 4745 SourceLocation 4746 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 4747 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 4748 4749 DeclIDComp DIDComp(*this, *DInfo.Mod); 4750 ArrayRef<serialization::LocalDeclID>::iterator 4751 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4752 BeginLoc, DIDComp); 4753 if (BeginIt != DInfo.Decls.begin()) 4754 --BeginIt; 4755 4756 // If we are pointing at a top-level decl inside an objc container, we need 4757 // to backtrack until we find it otherwise we will fail to report that the 4758 // region overlaps with an objc container. 4759 while (BeginIt != DInfo.Decls.begin() && 4760 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 4761 ->isTopLevelDeclInObjCContainer()) 4762 --BeginIt; 4763 4764 ArrayRef<serialization::LocalDeclID>::iterator 4765 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 4766 EndLoc, DIDComp); 4767 if (EndIt != DInfo.Decls.end()) 4768 ++EndIt; 4769 4770 for (ArrayRef<serialization::LocalDeclID>::iterator 4771 DIt = BeginIt; DIt != EndIt; ++DIt) 4772 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 4773} 4774 4775namespace { 4776 /// \brief ModuleFile visitor used to perform name lookup into a 4777 /// declaration context. 4778 class DeclContextNameLookupVisitor { 4779 ASTReader &Reader; 4780 const DeclContext *DC; 4781 DeclarationName Name; 4782 SmallVectorImpl<NamedDecl *> &Decls; 4783 4784 public: 4785 DeclContextNameLookupVisitor(ASTReader &Reader, 4786 const DeclContext *DC, DeclarationName Name, 4787 SmallVectorImpl<NamedDecl *> &Decls) 4788 : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { } 4789 4790 static bool visit(ModuleFile &M, void *UserData) { 4791 DeclContextNameLookupVisitor *This 4792 = static_cast<DeclContextNameLookupVisitor *>(UserData); 4793 4794 // Check whether we have any visible declaration information for 4795 // this context in this module. 4796 ModuleFile::DeclContextInfosMap::iterator Info 4797 = M.DeclContextInfos.find(This->DC); 4798 if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData) 4799 return false; 4800 4801 // Look for this name within this module. 4802 ASTDeclContextNameLookupTable *LookupTable = 4803 (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData; 4804 ASTDeclContextNameLookupTable::iterator Pos 4805 = LookupTable->find(This->Name); 4806 if (Pos == LookupTable->end()) 4807 return false; 4808 4809 bool FoundAnything = false; 4810 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4811 for (; Data.first != Data.second; ++Data.first) { 4812 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 4813 if (!ND) 4814 continue; 4815 4816 if (ND->getDeclName() != This->Name) { 4817 assert(!This->Name.getCXXNameType().isNull() && 4818 "Name mismatch without a type"); 4819 continue; 4820 } 4821 4822 // Record this declaration. 4823 FoundAnything = true; 4824 This->Decls.push_back(ND); 4825 } 4826 4827 return FoundAnything; 4828 } 4829 }; 4830} 4831 4832DeclContext::lookup_result 4833ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4834 DeclarationName Name) { 4835 assert(DC->hasExternalVisibleStorage() && 4836 "DeclContext has no visible decls in storage"); 4837 if (!Name) 4838 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4839 DeclContext::lookup_iterator(0)); 4840 4841 SmallVector<NamedDecl *, 64> Decls; 4842 DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls); 4843 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 4844 ++NumVisibleDeclContextsRead; 4845 SetExternalVisibleDeclsForName(DC, Name, Decls); 4846 return const_cast<DeclContext*>(DC)->lookup(Name); 4847} 4848 4849/// \brief Under non-PCH compilation the consumer receives the objc methods 4850/// before receiving the implementation, and codegen depends on this. 4851/// We simulate this by deserializing and passing to consumer the methods of the 4852/// implementation before passing the deserialized implementation decl. 4853static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 4854 ASTConsumer *Consumer) { 4855 assert(ImplD && Consumer); 4856 4857 for (ObjCImplDecl::method_iterator 4858 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 4859 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 4860 4861 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 4862} 4863 4864void ASTReader::PassInterestingDeclsToConsumer() { 4865 assert(Consumer); 4866 while (!InterestingDecls.empty()) { 4867 Decl *D = InterestingDecls.front(); 4868 InterestingDecls.pop_front(); 4869 4870 PassInterestingDeclToConsumer(D); 4871 } 4872} 4873 4874void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 4875 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4876 PassObjCImplDeclToConsumer(ImplD, Consumer); 4877 else 4878 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 4879} 4880 4881void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4882 this->Consumer = Consumer; 4883 4884 if (!Consumer) 4885 return; 4886 4887 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4888 // Force deserialization of this decl, which will cause it to be queued for 4889 // passing to the consumer. 4890 GetDecl(ExternalDefinitions[I]); 4891 } 4892 ExternalDefinitions.clear(); 4893 4894 PassInterestingDeclsToConsumer(); 4895} 4896 4897void ASTReader::PrintStats() { 4898 std::fprintf(stderr, "*** AST File Statistics:\n"); 4899 4900 unsigned NumTypesLoaded 4901 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4902 QualType()); 4903 unsigned NumDeclsLoaded 4904 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4905 (Decl *)0); 4906 unsigned NumIdentifiersLoaded 4907 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4908 IdentifiersLoaded.end(), 4909 (IdentifierInfo *)0); 4910 unsigned NumSelectorsLoaded 4911 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4912 SelectorsLoaded.end(), 4913 Selector()); 4914 4915 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4916 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4917 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4918 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4919 NumSLocEntriesRead, TotalNumSLocEntries, 4920 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4921 if (!TypesLoaded.empty()) 4922 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4923 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4924 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4925 if (!DeclsLoaded.empty()) 4926 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4927 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4928 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4929 if (!IdentifiersLoaded.empty()) 4930 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4931 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4932 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4933 if (!SelectorsLoaded.empty()) 4934 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4935 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4936 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4937 if (TotalNumStatements) 4938 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4939 NumStatementsRead, TotalNumStatements, 4940 ((float)NumStatementsRead/TotalNumStatements * 100)); 4941 if (TotalNumMacros) 4942 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4943 NumMacrosRead, TotalNumMacros, 4944 ((float)NumMacrosRead/TotalNumMacros * 100)); 4945 if (TotalLexicalDeclContexts) 4946 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4947 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4948 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4949 * 100)); 4950 if (TotalVisibleDeclContexts) 4951 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4952 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4953 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4954 * 100)); 4955 if (TotalNumMethodPoolEntries) { 4956 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4957 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4958 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4959 * 100)); 4960 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4961 } 4962 std::fprintf(stderr, "\n"); 4963 dump(); 4964 std::fprintf(stderr, "\n"); 4965} 4966 4967template<typename Key, typename ModuleFile, unsigned InitialCapacity> 4968static void 4969dumpModuleIDMap(StringRef Name, 4970 const ContinuousRangeMap<Key, ModuleFile *, 4971 InitialCapacity> &Map) { 4972 if (Map.begin() == Map.end()) 4973 return; 4974 4975 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 4976 llvm::errs() << Name << ":\n"; 4977 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4978 I != IEnd; ++I) { 4979 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4980 << "\n"; 4981 } 4982} 4983 4984void ASTReader::dump() { 4985 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 4986 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4987 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4988 dumpModuleIDMap("Global type map", GlobalTypeMap); 4989 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4990 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4991 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 4992 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4993 dumpModuleIDMap("Global preprocessed entity map", 4994 GlobalPreprocessedEntityMap); 4995 4996 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4997 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4998 MEnd = ModuleMgr.end(); 4999 M != MEnd; ++M) 5000 (*M)->dump(); 5001} 5002 5003/// Return the amount of memory used by memory buffers, breaking down 5004/// by heap-backed versus mmap'ed memory. 5005void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 5006 for (ModuleConstIterator I = ModuleMgr.begin(), 5007 E = ModuleMgr.end(); I != E; ++I) { 5008 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 5009 size_t bytes = buf->getBufferSize(); 5010 switch (buf->getBufferKind()) { 5011 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 5012 sizes.malloc_bytes += bytes; 5013 break; 5014 case llvm::MemoryBuffer::MemoryBuffer_MMap: 5015 sizes.mmap_bytes += bytes; 5016 break; 5017 } 5018 } 5019 } 5020} 5021 5022void ASTReader::InitializeSema(Sema &S) { 5023 SemaObj = &S; 5024 S.ExternalSource = this; 5025 5026 // Makes sure any declarations that were deserialized "too early" 5027 // still get added to the identifier's declaration chains. 5028 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 5029 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I], 5030 PreloadedDecls[I]->getDeclName()); 5031 } 5032 PreloadedDecls.clear(); 5033 5034 // Load the offsets of the declarations that Sema references. 5035 // They will be lazily deserialized when needed. 5036 if (!SemaDeclRefs.empty()) { 5037 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 5038 if (!SemaObj->StdNamespace) 5039 SemaObj->StdNamespace = SemaDeclRefs[0]; 5040 if (!SemaObj->StdBadAlloc) 5041 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 5042 } 5043 5044 if (!FPPragmaOptions.empty()) { 5045 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 5046 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 5047 } 5048 5049 if (!OpenCLExtensions.empty()) { 5050 unsigned I = 0; 5051#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 5052#include "clang/Basic/OpenCLExtensions.def" 5053 5054 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 5055 } 5056} 5057 5058IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 5059 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart)); 5060 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 5061 IdentifierInfo *II = Visitor.getIdentifierInfo(); 5062 if (II) 5063 II->setOutOfDate(false); 5064 return II; 5065} 5066 5067namespace clang { 5068 /// \brief An identifier-lookup iterator that enumerates all of the 5069 /// identifiers stored within a set of AST files. 5070 class ASTIdentifierIterator : public IdentifierIterator { 5071 /// \brief The AST reader whose identifiers are being enumerated. 5072 const ASTReader &Reader; 5073 5074 /// \brief The current index into the chain of AST files stored in 5075 /// the AST reader. 5076 unsigned Index; 5077 5078 /// \brief The current position within the identifier lookup table 5079 /// of the current AST file. 5080 ASTIdentifierLookupTable::key_iterator Current; 5081 5082 /// \brief The end position within the identifier lookup table of 5083 /// the current AST file. 5084 ASTIdentifierLookupTable::key_iterator End; 5085 5086 public: 5087 explicit ASTIdentifierIterator(const ASTReader &Reader); 5088 5089 virtual StringRef Next(); 5090 }; 5091} 5092 5093ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 5094 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 5095 ASTIdentifierLookupTable *IdTable 5096 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 5097 Current = IdTable->key_begin(); 5098 End = IdTable->key_end(); 5099} 5100 5101StringRef ASTIdentifierIterator::Next() { 5102 while (Current == End) { 5103 // If we have exhausted all of our AST files, we're done. 5104 if (Index == 0) 5105 return StringRef(); 5106 5107 --Index; 5108 ASTIdentifierLookupTable *IdTable 5109 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 5110 IdentifierLookupTable; 5111 Current = IdTable->key_begin(); 5112 End = IdTable->key_end(); 5113 } 5114 5115 // We have any identifiers remaining in the current AST file; return 5116 // the next one. 5117 std::pair<const char*, unsigned> Key = *Current; 5118 ++Current; 5119 return StringRef(Key.first, Key.second); 5120} 5121 5122IdentifierIterator *ASTReader::getIdentifiers() const { 5123 return new ASTIdentifierIterator(*this); 5124} 5125 5126namespace clang { namespace serialization { 5127 class ReadMethodPoolVisitor { 5128 ASTReader &Reader; 5129 Selector Sel; 5130 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 5131 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 5132 5133 /// \brief Build an ObjCMethodList from a vector of Objective-C method 5134 /// declarations. 5135 ObjCMethodList 5136 buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const 5137 { 5138 ObjCMethodList List; 5139 ObjCMethodList *Prev = 0; 5140 for (unsigned I = 0, N = Vec.size(); I != N; ++I) { 5141 if (!List.Method) { 5142 // This is the first method, which is the easy case. 5143 List.Method = Vec[I]; 5144 Prev = &List; 5145 continue; 5146 } 5147 5148 ObjCMethodList *Mem = 5149 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 5150 Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0); 5151 Prev = Prev->Next; 5152 } 5153 5154 return List; 5155 } 5156 5157 public: 5158 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel) 5159 : Reader(Reader), Sel(Sel) { } 5160 5161 static bool visit(ModuleFile &M, void *UserData) { 5162 ReadMethodPoolVisitor *This 5163 = static_cast<ReadMethodPoolVisitor *>(UserData); 5164 5165 if (!M.SelectorLookupTable) 5166 return false; 5167 5168 ASTSelectorLookupTable *PoolTable 5169 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 5170 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 5171 if (Pos == PoolTable->end()) 5172 return false; 5173 5174 ++This->Reader.NumSelectorsRead; 5175 // FIXME: Not quite happy with the statistics here. We probably should 5176 // disable this tracking when called via LoadSelector. 5177 // Also, should entries without methods count as misses? 5178 ++This->Reader.NumMethodPoolEntriesRead; 5179 ASTSelectorLookupTrait::data_type Data = *Pos; 5180 if (This->Reader.DeserializationListener) 5181 This->Reader.DeserializationListener->SelectorRead(Data.ID, 5182 This->Sel); 5183 5184 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 5185 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 5186 return true; 5187 } 5188 5189 /// \brief Retrieve the instance methods found by this visitor. 5190 ObjCMethodList getInstanceMethods() const { 5191 return buildObjCMethodList(InstanceMethods); 5192 } 5193 5194 /// \brief Retrieve the instance methods found by this visitor. 5195 ObjCMethodList getFactoryMethods() const { 5196 return buildObjCMethodList(FactoryMethods); 5197 } 5198 }; 5199} } // end namespace clang::serialization 5200 5201std::pair<ObjCMethodList, ObjCMethodList> 5202ASTReader::ReadMethodPool(Selector Sel) { 5203 ReadMethodPoolVisitor Visitor(*this, Sel); 5204 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 5205 std::pair<ObjCMethodList, ObjCMethodList> Result; 5206 Result.first = Visitor.getInstanceMethods(); 5207 Result.second = Visitor.getFactoryMethods(); 5208 5209 if (!Result.first.Method && !Result.second.Method) 5210 ++NumMethodPoolMisses; 5211 return Result; 5212} 5213 5214void ASTReader::ReadKnownNamespaces( 5215 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 5216 Namespaces.clear(); 5217 5218 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 5219 if (NamespaceDecl *Namespace 5220 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 5221 Namespaces.push_back(Namespace); 5222 } 5223} 5224 5225void ASTReader::ReadTentativeDefinitions( 5226 SmallVectorImpl<VarDecl *> &TentativeDefs) { 5227 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 5228 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 5229 if (Var) 5230 TentativeDefs.push_back(Var); 5231 } 5232 TentativeDefinitions.clear(); 5233} 5234 5235void ASTReader::ReadUnusedFileScopedDecls( 5236 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 5237 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 5238 DeclaratorDecl *D 5239 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 5240 if (D) 5241 Decls.push_back(D); 5242 } 5243 UnusedFileScopedDecls.clear(); 5244} 5245 5246void ASTReader::ReadDelegatingConstructors( 5247 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 5248 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 5249 CXXConstructorDecl *D 5250 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 5251 if (D) 5252 Decls.push_back(D); 5253 } 5254 DelegatingCtorDecls.clear(); 5255} 5256 5257void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 5258 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 5259 TypedefNameDecl *D 5260 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 5261 if (D) 5262 Decls.push_back(D); 5263 } 5264 ExtVectorDecls.clear(); 5265} 5266 5267void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 5268 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 5269 CXXRecordDecl *D 5270 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 5271 if (D) 5272 Decls.push_back(D); 5273 } 5274 DynamicClasses.clear(); 5275} 5276 5277void 5278ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 5279 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 5280 NamedDecl *D 5281 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 5282 if (D) 5283 Decls.push_back(D); 5284 } 5285 LocallyScopedExternalDecls.clear(); 5286} 5287 5288void ASTReader::ReadReferencedSelectors( 5289 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 5290 if (ReferencedSelectorsData.empty()) 5291 return; 5292 5293 // If there are @selector references added them to its pool. This is for 5294 // implementation of -Wselector. 5295 unsigned int DataSize = ReferencedSelectorsData.size()-1; 5296 unsigned I = 0; 5297 while (I < DataSize) { 5298 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 5299 SourceLocation SelLoc 5300 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 5301 Sels.push_back(std::make_pair(Sel, SelLoc)); 5302 } 5303 ReferencedSelectorsData.clear(); 5304} 5305 5306void ASTReader::ReadWeakUndeclaredIdentifiers( 5307 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 5308 if (WeakUndeclaredIdentifiers.empty()) 5309 return; 5310 5311 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 5312 IdentifierInfo *WeakId 5313 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5314 IdentifierInfo *AliasId 5315 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 5316 SourceLocation Loc 5317 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 5318 bool Used = WeakUndeclaredIdentifiers[I++]; 5319 WeakInfo WI(AliasId, Loc); 5320 WI.setUsed(Used); 5321 WeakIDs.push_back(std::make_pair(WeakId, WI)); 5322 } 5323 WeakUndeclaredIdentifiers.clear(); 5324} 5325 5326void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 5327 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 5328 ExternalVTableUse VT; 5329 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 5330 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 5331 VT.DefinitionRequired = VTableUses[Idx++]; 5332 VTables.push_back(VT); 5333 } 5334 5335 VTableUses.clear(); 5336} 5337 5338void ASTReader::ReadPendingInstantiations( 5339 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 5340 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 5341 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 5342 SourceLocation Loc 5343 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 5344 Pending.push_back(std::make_pair(D, Loc)); 5345 } 5346 PendingInstantiations.clear(); 5347} 5348 5349void ASTReader::LoadSelector(Selector Sel) { 5350 // It would be complicated to avoid reading the methods anyway. So don't. 5351 ReadMethodPool(Sel); 5352} 5353 5354void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 5355 assert(ID && "Non-zero identifier ID required"); 5356 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 5357 IdentifiersLoaded[ID - 1] = II; 5358 if (DeserializationListener) 5359 DeserializationListener->IdentifierRead(ID, II); 5360} 5361 5362/// \brief Set the globally-visible declarations associated with the given 5363/// identifier. 5364/// 5365/// If the AST reader is currently in a state where the given declaration IDs 5366/// cannot safely be resolved, they are queued until it is safe to resolve 5367/// them. 5368/// 5369/// \param II an IdentifierInfo that refers to one or more globally-visible 5370/// declarations. 5371/// 5372/// \param DeclIDs the set of declaration IDs with the name @p II that are 5373/// visible at global scope. 5374/// 5375/// \param Nonrecursive should be true to indicate that the caller knows that 5376/// this call is non-recursive, and therefore the globally-visible declarations 5377/// will not be placed onto the pending queue. 5378void 5379ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 5380 const SmallVectorImpl<uint32_t> &DeclIDs, 5381 bool Nonrecursive) { 5382 if (NumCurrentElementsDeserializing && !Nonrecursive) { 5383 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 5384 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 5385 PII.II = II; 5386 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 5387 return; 5388 } 5389 5390 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 5391 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 5392 if (SemaObj) { 5393 // Introduce this declaration into the translation-unit scope 5394 // and add it to the declaration chain for this identifier, so 5395 // that (unqualified) name lookup will find it. 5396 SemaObj->pushExternalDeclIntoScope(D, II); 5397 } else { 5398 // Queue this declaration so that it will be added to the 5399 // translation unit scope and identifier's declaration chain 5400 // once a Sema object is known. 5401 PreloadedDecls.push_back(D); 5402 } 5403 } 5404} 5405 5406IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 5407 if (ID == 0) 5408 return 0; 5409 5410 if (IdentifiersLoaded.empty()) { 5411 Error("no identifier table in AST file"); 5412 return 0; 5413 } 5414 5415 ID -= 1; 5416 if (!IdentifiersLoaded[ID]) { 5417 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 5418 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 5419 ModuleFile *M = I->second; 5420 unsigned Index = ID - M->BaseIdentifierID; 5421 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 5422 5423 // All of the strings in the AST file are preceded by a 16-bit length. 5424 // Extract that 16-bit length to avoid having to execute strlen(). 5425 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 5426 // unsigned integers. This is important to avoid integer overflow when 5427 // we cast them to 'unsigned'. 5428 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 5429 unsigned StrLen = (((unsigned) StrLenPtr[0]) 5430 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 5431 IdentifiersLoaded[ID] 5432 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 5433 if (DeserializationListener) 5434 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 5435 } 5436 5437 return IdentifiersLoaded[ID]; 5438} 5439 5440IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 5441 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 5442} 5443 5444IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 5445 if (LocalID < NUM_PREDEF_IDENT_IDS) 5446 return LocalID; 5447 5448 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5449 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 5450 assert(I != M.IdentifierRemap.end() 5451 && "Invalid index into identifier index remap"); 5452 5453 return LocalID + I->second; 5454} 5455 5456bool ASTReader::ReadSLocEntry(int ID) { 5457 return ReadSLocEntryRecord(ID) != Success; 5458} 5459 5460serialization::SubmoduleID 5461ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 5462 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 5463 return LocalID; 5464 5465 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5466 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 5467 assert(I != M.SubmoduleRemap.end() 5468 && "Invalid index into identifier index remap"); 5469 5470 return LocalID + I->second; 5471} 5472 5473Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 5474 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 5475 assert(GlobalID == 0 && "Unhandled global submodule ID"); 5476 return 0; 5477 } 5478 5479 if (GlobalID > SubmodulesLoaded.size()) { 5480 Error("submodule ID out of range in AST file"); 5481 return 0; 5482 } 5483 5484 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 5485} 5486 5487Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 5488 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 5489} 5490 5491Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 5492 if (ID == 0) 5493 return Selector(); 5494 5495 if (ID > SelectorsLoaded.size()) { 5496 Error("selector ID out of range in AST file"); 5497 return Selector(); 5498 } 5499 5500 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 5501 // Load this selector from the selector table. 5502 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 5503 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 5504 ModuleFile &M = *I->second; 5505 ASTSelectorLookupTrait Trait(*this, M); 5506 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 5507 SelectorsLoaded[ID - 1] = 5508 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 5509 if (DeserializationListener) 5510 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 5511 } 5512 5513 return SelectorsLoaded[ID - 1]; 5514} 5515 5516Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 5517 return DecodeSelector(ID); 5518} 5519 5520uint32_t ASTReader::GetNumExternalSelectors() { 5521 // ID 0 (the null selector) is considered an external selector. 5522 return getTotalNumSelectors() + 1; 5523} 5524 5525serialization::SelectorID 5526ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 5527 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 5528 return LocalID; 5529 5530 ContinuousRangeMap<uint32_t, int, 2>::iterator I 5531 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 5532 assert(I != M.SelectorRemap.end() 5533 && "Invalid index into identifier index remap"); 5534 5535 return LocalID + I->second; 5536} 5537 5538DeclarationName 5539ASTReader::ReadDeclarationName(ModuleFile &F, 5540 const RecordData &Record, unsigned &Idx) { 5541 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 5542 switch (Kind) { 5543 case DeclarationName::Identifier: 5544 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 5545 5546 case DeclarationName::ObjCZeroArgSelector: 5547 case DeclarationName::ObjCOneArgSelector: 5548 case DeclarationName::ObjCMultiArgSelector: 5549 return DeclarationName(ReadSelector(F, Record, Idx)); 5550 5551 case DeclarationName::CXXConstructorName: 5552 return Context.DeclarationNames.getCXXConstructorName( 5553 Context.getCanonicalType(readType(F, Record, Idx))); 5554 5555 case DeclarationName::CXXDestructorName: 5556 return Context.DeclarationNames.getCXXDestructorName( 5557 Context.getCanonicalType(readType(F, Record, Idx))); 5558 5559 case DeclarationName::CXXConversionFunctionName: 5560 return Context.DeclarationNames.getCXXConversionFunctionName( 5561 Context.getCanonicalType(readType(F, Record, Idx))); 5562 5563 case DeclarationName::CXXOperatorName: 5564 return Context.DeclarationNames.getCXXOperatorName( 5565 (OverloadedOperatorKind)Record[Idx++]); 5566 5567 case DeclarationName::CXXLiteralOperatorName: 5568 return Context.DeclarationNames.getCXXLiteralOperatorName( 5569 GetIdentifierInfo(F, Record, Idx)); 5570 5571 case DeclarationName::CXXUsingDirective: 5572 return DeclarationName::getUsingDirectiveName(); 5573 } 5574 5575 // Required to silence GCC warning 5576 return DeclarationName(); 5577} 5578 5579void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 5580 DeclarationNameLoc &DNLoc, 5581 DeclarationName Name, 5582 const RecordData &Record, unsigned &Idx) { 5583 switch (Name.getNameKind()) { 5584 case DeclarationName::CXXConstructorName: 5585 case DeclarationName::CXXDestructorName: 5586 case DeclarationName::CXXConversionFunctionName: 5587 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 5588 break; 5589 5590 case DeclarationName::CXXOperatorName: 5591 DNLoc.CXXOperatorName.BeginOpNameLoc 5592 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5593 DNLoc.CXXOperatorName.EndOpNameLoc 5594 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5595 break; 5596 5597 case DeclarationName::CXXLiteralOperatorName: 5598 DNLoc.CXXLiteralOperatorName.OpNameLoc 5599 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 5600 break; 5601 5602 case DeclarationName::Identifier: 5603 case DeclarationName::ObjCZeroArgSelector: 5604 case DeclarationName::ObjCOneArgSelector: 5605 case DeclarationName::ObjCMultiArgSelector: 5606 case DeclarationName::CXXUsingDirective: 5607 break; 5608 } 5609} 5610 5611void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 5612 DeclarationNameInfo &NameInfo, 5613 const RecordData &Record, unsigned &Idx) { 5614 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 5615 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 5616 DeclarationNameLoc DNLoc; 5617 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5618 NameInfo.setInfo(DNLoc); 5619} 5620 5621void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 5622 const RecordData &Record, unsigned &Idx) { 5623 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5624 unsigned NumTPLists = Record[Idx++]; 5625 Info.NumTemplParamLists = NumTPLists; 5626 if (NumTPLists) { 5627 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 5628 for (unsigned i=0; i != NumTPLists; ++i) 5629 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5630 } 5631} 5632 5633TemplateName 5634ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 5635 unsigned &Idx) { 5636 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5637 switch (Kind) { 5638 case TemplateName::Template: 5639 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5640 5641 case TemplateName::OverloadedTemplate: { 5642 unsigned size = Record[Idx++]; 5643 UnresolvedSet<8> Decls; 5644 while (size--) 5645 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5646 5647 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 5648 } 5649 5650 case TemplateName::QualifiedTemplate: { 5651 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5652 bool hasTemplKeyword = Record[Idx++]; 5653 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5654 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5655 } 5656 5657 case TemplateName::DependentTemplate: { 5658 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5659 if (Record[Idx++]) // isIdentifier 5660 return Context.getDependentTemplateName(NNS, 5661 GetIdentifierInfo(F, Record, 5662 Idx)); 5663 return Context.getDependentTemplateName(NNS, 5664 (OverloadedOperatorKind)Record[Idx++]); 5665 } 5666 5667 case TemplateName::SubstTemplateTemplateParm: { 5668 TemplateTemplateParmDecl *param 5669 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5670 if (!param) return TemplateName(); 5671 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5672 return Context.getSubstTemplateTemplateParm(param, replacement); 5673 } 5674 5675 case TemplateName::SubstTemplateTemplateParmPack: { 5676 TemplateTemplateParmDecl *Param 5677 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5678 if (!Param) 5679 return TemplateName(); 5680 5681 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5682 if (ArgPack.getKind() != TemplateArgument::Pack) 5683 return TemplateName(); 5684 5685 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 5686 } 5687 } 5688 5689 llvm_unreachable("Unhandled template name kind!"); 5690} 5691 5692TemplateArgument 5693ASTReader::ReadTemplateArgument(ModuleFile &F, 5694 const RecordData &Record, unsigned &Idx) { 5695 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5696 switch (Kind) { 5697 case TemplateArgument::Null: 5698 return TemplateArgument(); 5699 case TemplateArgument::Type: 5700 return TemplateArgument(readType(F, Record, Idx)); 5701 case TemplateArgument::Declaration: 5702 return TemplateArgument(ReadDecl(F, Record, Idx)); 5703 case TemplateArgument::Integral: { 5704 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5705 QualType T = readType(F, Record, Idx); 5706 return TemplateArgument(Value, T); 5707 } 5708 case TemplateArgument::Template: 5709 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5710 case TemplateArgument::TemplateExpansion: { 5711 TemplateName Name = ReadTemplateName(F, Record, Idx); 5712 llvm::Optional<unsigned> NumTemplateExpansions; 5713 if (unsigned NumExpansions = Record[Idx++]) 5714 NumTemplateExpansions = NumExpansions - 1; 5715 return TemplateArgument(Name, NumTemplateExpansions); 5716 } 5717 case TemplateArgument::Expression: 5718 return TemplateArgument(ReadExpr(F)); 5719 case TemplateArgument::Pack: { 5720 unsigned NumArgs = Record[Idx++]; 5721 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 5722 for (unsigned I = 0; I != NumArgs; ++I) 5723 Args[I] = ReadTemplateArgument(F, Record, Idx); 5724 return TemplateArgument(Args, NumArgs); 5725 } 5726 } 5727 5728 llvm_unreachable("Unhandled template argument kind!"); 5729} 5730 5731TemplateParameterList * 5732ASTReader::ReadTemplateParameterList(ModuleFile &F, 5733 const RecordData &Record, unsigned &Idx) { 5734 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5735 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5736 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5737 5738 unsigned NumParams = Record[Idx++]; 5739 SmallVector<NamedDecl *, 16> Params; 5740 Params.reserve(NumParams); 5741 while (NumParams--) 5742 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5743 5744 TemplateParameterList* TemplateParams = 5745 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 5746 Params.data(), Params.size(), RAngleLoc); 5747 return TemplateParams; 5748} 5749 5750void 5751ASTReader:: 5752ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5753 ModuleFile &F, const RecordData &Record, 5754 unsigned &Idx) { 5755 unsigned NumTemplateArgs = Record[Idx++]; 5756 TemplArgs.reserve(NumTemplateArgs); 5757 while (NumTemplateArgs--) 5758 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5759} 5760 5761/// \brief Read a UnresolvedSet structure. 5762void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set, 5763 const RecordData &Record, unsigned &Idx) { 5764 unsigned NumDecls = Record[Idx++]; 5765 while (NumDecls--) { 5766 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5767 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5768 Set.addDecl(D, AS); 5769 } 5770} 5771 5772CXXBaseSpecifier 5773ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 5774 const RecordData &Record, unsigned &Idx) { 5775 bool isVirtual = static_cast<bool>(Record[Idx++]); 5776 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5777 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5778 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5779 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5780 SourceRange Range = ReadSourceRange(F, Record, Idx); 5781 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5782 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5783 EllipsisLoc); 5784 Result.setInheritConstructors(inheritConstructors); 5785 return Result; 5786} 5787 5788std::pair<CXXCtorInitializer **, unsigned> 5789ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 5790 unsigned &Idx) { 5791 CXXCtorInitializer **CtorInitializers = 0; 5792 unsigned NumInitializers = Record[Idx++]; 5793 if (NumInitializers) { 5794 CtorInitializers 5795 = new (Context) CXXCtorInitializer*[NumInitializers]; 5796 for (unsigned i=0; i != NumInitializers; ++i) { 5797 TypeSourceInfo *TInfo = 0; 5798 bool IsBaseVirtual = false; 5799 FieldDecl *Member = 0; 5800 IndirectFieldDecl *IndirectMember = 0; 5801 5802 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5803 switch (Type) { 5804 case CTOR_INITIALIZER_BASE: 5805 TInfo = GetTypeSourceInfo(F, Record, Idx); 5806 IsBaseVirtual = Record[Idx++]; 5807 break; 5808 5809 case CTOR_INITIALIZER_DELEGATING: 5810 TInfo = GetTypeSourceInfo(F, Record, Idx); 5811 break; 5812 5813 case CTOR_INITIALIZER_MEMBER: 5814 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5815 break; 5816 5817 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5818 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5819 break; 5820 } 5821 5822 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5823 Expr *Init = ReadExpr(F); 5824 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5825 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5826 bool IsWritten = Record[Idx++]; 5827 unsigned SourceOrderOrNumArrayIndices; 5828 SmallVector<VarDecl *, 8> Indices; 5829 if (IsWritten) { 5830 SourceOrderOrNumArrayIndices = Record[Idx++]; 5831 } else { 5832 SourceOrderOrNumArrayIndices = Record[Idx++]; 5833 Indices.reserve(SourceOrderOrNumArrayIndices); 5834 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5835 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5836 } 5837 5838 CXXCtorInitializer *BOMInit; 5839 if (Type == CTOR_INITIALIZER_BASE) { 5840 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 5841 LParenLoc, Init, RParenLoc, 5842 MemberOrEllipsisLoc); 5843 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5844 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 5845 Init, RParenLoc); 5846 } else if (IsWritten) { 5847 if (Member) 5848 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 5849 LParenLoc, Init, RParenLoc); 5850 else 5851 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 5852 MemberOrEllipsisLoc, LParenLoc, 5853 Init, RParenLoc); 5854 } else { 5855 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 5856 LParenLoc, Init, RParenLoc, 5857 Indices.data(), Indices.size()); 5858 } 5859 5860 if (IsWritten) 5861 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5862 CtorInitializers[i] = BOMInit; 5863 } 5864 } 5865 5866 return std::make_pair(CtorInitializers, NumInitializers); 5867} 5868 5869NestedNameSpecifier * 5870ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 5871 const RecordData &Record, unsigned &Idx) { 5872 unsigned N = Record[Idx++]; 5873 NestedNameSpecifier *NNS = 0, *Prev = 0; 5874 for (unsigned I = 0; I != N; ++I) { 5875 NestedNameSpecifier::SpecifierKind Kind 5876 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5877 switch (Kind) { 5878 case NestedNameSpecifier::Identifier: { 5879 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5880 NNS = NestedNameSpecifier::Create(Context, Prev, II); 5881 break; 5882 } 5883 5884 case NestedNameSpecifier::Namespace: { 5885 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5886 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 5887 break; 5888 } 5889 5890 case NestedNameSpecifier::NamespaceAlias: { 5891 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5892 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 5893 break; 5894 } 5895 5896 case NestedNameSpecifier::TypeSpec: 5897 case NestedNameSpecifier::TypeSpecWithTemplate: { 5898 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5899 if (!T) 5900 return 0; 5901 5902 bool Template = Record[Idx++]; 5903 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 5904 break; 5905 } 5906 5907 case NestedNameSpecifier::Global: { 5908 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 5909 // No associated value, and there can't be a prefix. 5910 break; 5911 } 5912 } 5913 Prev = NNS; 5914 } 5915 return NNS; 5916} 5917 5918NestedNameSpecifierLoc 5919ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 5920 unsigned &Idx) { 5921 unsigned N = Record[Idx++]; 5922 NestedNameSpecifierLocBuilder Builder; 5923 for (unsigned I = 0; I != N; ++I) { 5924 NestedNameSpecifier::SpecifierKind Kind 5925 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5926 switch (Kind) { 5927 case NestedNameSpecifier::Identifier: { 5928 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5929 SourceRange Range = ReadSourceRange(F, Record, Idx); 5930 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 5931 break; 5932 } 5933 5934 case NestedNameSpecifier::Namespace: { 5935 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5936 SourceRange Range = ReadSourceRange(F, Record, Idx); 5937 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 5938 break; 5939 } 5940 5941 case NestedNameSpecifier::NamespaceAlias: { 5942 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5943 SourceRange Range = ReadSourceRange(F, Record, Idx); 5944 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 5945 break; 5946 } 5947 5948 case NestedNameSpecifier::TypeSpec: 5949 case NestedNameSpecifier::TypeSpecWithTemplate: { 5950 bool Template = Record[Idx++]; 5951 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5952 if (!T) 5953 return NestedNameSpecifierLoc(); 5954 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5955 5956 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5957 Builder.Extend(Context, 5958 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5959 T->getTypeLoc(), ColonColonLoc); 5960 break; 5961 } 5962 5963 case NestedNameSpecifier::Global: { 5964 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5965 Builder.MakeGlobal(Context, ColonColonLoc); 5966 break; 5967 } 5968 } 5969 } 5970 5971 return Builder.getWithLocInContext(Context); 5972} 5973 5974SourceRange 5975ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 5976 unsigned &Idx) { 5977 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5978 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5979 return SourceRange(beg, end); 5980} 5981 5982/// \brief Read an integral value 5983llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5984 unsigned BitWidth = Record[Idx++]; 5985 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5986 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5987 Idx += NumWords; 5988 return Result; 5989} 5990 5991/// \brief Read a signed integral value 5992llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5993 bool isUnsigned = Record[Idx++]; 5994 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5995} 5996 5997/// \brief Read a floating-point value 5998llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5999 return llvm::APFloat(ReadAPInt(Record, Idx)); 6000} 6001 6002// \brief Read a string 6003std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 6004 unsigned Len = Record[Idx++]; 6005 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 6006 Idx += Len; 6007 return Result; 6008} 6009 6010VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 6011 unsigned &Idx) { 6012 unsigned Major = Record[Idx++]; 6013 unsigned Minor = Record[Idx++]; 6014 unsigned Subminor = Record[Idx++]; 6015 if (Minor == 0) 6016 return VersionTuple(Major); 6017 if (Subminor == 0) 6018 return VersionTuple(Major, Minor - 1); 6019 return VersionTuple(Major, Minor - 1, Subminor - 1); 6020} 6021 6022CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 6023 const RecordData &Record, 6024 unsigned &Idx) { 6025 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 6026 return CXXTemporary::Create(Context, Decl); 6027} 6028 6029DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 6030 return Diag(SourceLocation(), DiagID); 6031} 6032 6033DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 6034 return Diags.Report(Loc, DiagID); 6035} 6036 6037/// \brief Retrieve the identifier table associated with the 6038/// preprocessor. 6039IdentifierTable &ASTReader::getIdentifierTable() { 6040 return PP.getIdentifierTable(); 6041} 6042 6043/// \brief Record that the given ID maps to the given switch-case 6044/// statement. 6045void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 6046 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 6047 SwitchCaseStmts[ID] = SC; 6048} 6049 6050/// \brief Retrieve the switch-case statement with the given ID. 6051SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 6052 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 6053 return SwitchCaseStmts[ID]; 6054} 6055 6056void ASTReader::ClearSwitchCaseIDs() { 6057 SwitchCaseStmts.clear(); 6058} 6059 6060void ASTReader::finishPendingActions() { 6061 while (!PendingIdentifierInfos.empty() || 6062 !PendingPreviousDecls.empty() || 6063 !PendingDeclChains.empty() || 6064 !PendingChainedObjCCategories.empty()) { 6065 6066 // If any identifiers with corresponding top-level declarations have 6067 // been loaded, load those declarations now. 6068 while (!PendingIdentifierInfos.empty()) { 6069 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 6070 PendingIdentifierInfos.front().DeclIDs, true); 6071 PendingIdentifierInfos.pop_front(); 6072 } 6073 6074 // Ready to load previous declarations of Decls that were delayed. 6075 while (!PendingPreviousDecls.empty()) { 6076 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 6077 PendingPreviousDecls.front().second); 6078 PendingPreviousDecls.pop_front(); 6079 } 6080 6081 // Load pending declaration chains. 6082 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 6083 loadPendingDeclChain(PendingDeclChains[I]); 6084 } 6085 PendingDeclChains.clear(); 6086 6087 for (std::vector<std::pair<ObjCInterfaceDecl *, 6088 serialization::DeclID> >::iterator 6089 I = PendingChainedObjCCategories.begin(), 6090 E = PendingChainedObjCCategories.end(); I != E; ++I) { 6091 loadObjCChainedCategories(I->second, I->first); 6092 } 6093 PendingChainedObjCCategories.clear(); 6094 } 6095 6096 // If we deserialized any C++ or Objective-C class definitions, make sure 6097 // that all redeclarations point to the definitions. Note that this can only 6098 // happen now, after the redeclaration chains have been fully wired. 6099 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(), 6100 DEnd = PendingDefinitions.end(); 6101 D != DEnd; ++D) { 6102 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) { 6103 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(), 6104 REnd = RD->redecls_end(); 6105 R != REnd; ++R) 6106 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData; 6107 6108 continue; 6109 } 6110 6111 ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(*D); 6112 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(), 6113 REnd = ID->redecls_end(); 6114 R != REnd; ++R) 6115 R->Data = ID->Data; 6116 } 6117 PendingDefinitions.clear(); 6118} 6119 6120void ASTReader::FinishedDeserializing() { 6121 assert(NumCurrentElementsDeserializing && 6122 "FinishedDeserializing not paired with StartedDeserializing"); 6123 if (NumCurrentElementsDeserializing == 1) { 6124 6125 while (Consumer && !InterestingDecls.empty()) { 6126 finishPendingActions(); 6127 6128 // We are not in recursive loading, so it's safe to pass the "interesting" 6129 // decls to the consumer. 6130 Decl *D = InterestingDecls.front(); 6131 InterestingDecls.pop_front(); 6132 6133 // Fully load the interesting decls, including deserializing their 6134 // bodies, so that any other declarations that get referenced in the 6135 // body will be fully deserialized by the time we pass them to the 6136 // consumer. 6137 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 6138 if (FD->doesThisDeclarationHaveABody()) { 6139 FD->getBody(); 6140 finishPendingActions(); 6141 } 6142 } 6143 6144 PassInterestingDeclToConsumer(D); 6145 } 6146 6147 finishPendingActions(); 6148 PendingDeclChainsKnown.clear(); 6149 } 6150 --NumCurrentElementsDeserializing; 6151} 6152 6153ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 6154 StringRef isysroot, bool DisableValidation, 6155 bool DisableStatCache) 6156 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 6157 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 6158 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 6159 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 6160 RelocatablePCH(false), isysroot(isysroot), 6161 DisableValidation(DisableValidation), 6162 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 6163 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 6164 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 6165 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 6166 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 6167 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 6168 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 6169 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 6170 NumCXXBaseSpecifiersLoaded(0) 6171{ 6172 SourceMgr.setExternalSLocEntrySource(this); 6173} 6174 6175ASTReader::~ASTReader() { 6176 for (DeclContextVisibleUpdatesPending::iterator 6177 I = PendingVisibleUpdates.begin(), 6178 E = PendingVisibleUpdates.end(); 6179 I != E; ++I) { 6180 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 6181 F = I->second.end(); 6182 J != F; ++J) 6183 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 6184 } 6185} 6186