ASTReader.cpp revision 0d2d1bcef51993ca3fd957e45fb7ec85e45016e5
1//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the ASTReader class, which reads AST files. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Serialization/ASTReader.h" 15#include "clang/Serialization/ASTDeserializationListener.h" 16#include "ASTCommon.h" 17#include "clang/Frontend/FrontendDiagnostic.h" 18#include "clang/Frontend/Utils.h" 19#include "clang/Sema/Sema.h" 20#include "clang/Sema/Scope.h" 21#include "clang/AST/ASTConsumer.h" 22#include "clang/AST/ASTContext.h" 23#include "clang/AST/DeclTemplate.h" 24#include "clang/AST/Expr.h" 25#include "clang/AST/ExprCXX.h" 26#include "clang/AST/NestedNameSpecifier.h" 27#include "clang/AST/Type.h" 28#include "clang/AST/TypeLocVisitor.h" 29#include "clang/Lex/MacroInfo.h" 30#include "clang/Lex/PreprocessingRecord.h" 31#include "clang/Lex/Preprocessor.h" 32#include "clang/Lex/HeaderSearch.h" 33#include "clang/Basic/OnDiskHashTable.h" 34#include "clang/Basic/SourceManager.h" 35#include "clang/Basic/SourceManagerInternals.h" 36#include "clang/Basic/FileManager.h" 37#include "clang/Basic/FileSystemStatCache.h" 38#include "clang/Basic/TargetInfo.h" 39#include "clang/Basic/Version.h" 40#include "clang/Basic/VersionTuple.h" 41#include "llvm/ADT/StringExtras.h" 42#include "llvm/Bitcode/BitstreamReader.h" 43#include "llvm/Support/MemoryBuffer.h" 44#include "llvm/Support/ErrorHandling.h" 45#include "llvm/Support/FileSystem.h" 46#include "llvm/Support/Path.h" 47#include "llvm/Support/system_error.h" 48#include <algorithm> 49#include <iterator> 50#include <cstdio> 51#include <sys/stat.h> 52 53using namespace clang; 54using namespace clang::serialization; 55 56//===----------------------------------------------------------------------===// 57// PCH validator implementation 58//===----------------------------------------------------------------------===// 59 60ASTReaderListener::~ASTReaderListener() {} 61 62bool 63PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 64 const LangOptions &PPLangOpts = PP.getLangOptions(); 65#define PARSE_LANGOPT_BENIGN(Option) 66#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \ 67 if (PPLangOpts.Option != LangOpts.Option) { \ 68 Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \ 69 return true; \ 70 } 71 72 PARSE_LANGOPT_BENIGN(Trigraphs); 73 PARSE_LANGOPT_BENIGN(BCPLComment); 74 PARSE_LANGOPT_BENIGN(DollarIdents); 75 PARSE_LANGOPT_BENIGN(AsmPreprocessor); 76 PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions); 77 PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords); 78 PARSE_LANGOPT_BENIGN(ImplicitInt); 79 PARSE_LANGOPT_BENIGN(Digraphs); 80 PARSE_LANGOPT_BENIGN(HexFloats); 81 PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99); 82 PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x); 83 PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions); 84 PARSE_LANGOPT_BENIGN(MSCVersion); 85 PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus); 86 PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x); 87 PARSE_LANGOPT_BENIGN(CXXOperatorName); 88 PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c); 89 PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2); 90 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi); 91 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2); 92 PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext); 93 PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties, 94 diag::warn_pch_objc_auto_properties); 95 PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings, 96 diag::warn_pch_no_constant_cfstrings); 97 PARSE_LANGOPT_BENIGN(PascalStrings); 98 PARSE_LANGOPT_BENIGN(WritableStrings); 99 PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, 100 diag::warn_pch_lax_vector_conversions); 101 PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec); 102 PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions); 103 PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions); 104 PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions); 105 PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions); 106 PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields); 107 PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime); 108 PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding); 109 PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins); 110 PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, 111 diag::warn_pch_thread_safe_statics); 112 PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads); 113 PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks); 114 PARSE_LANGOPT_BENIGN(EmitAllDecls); 115 PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno); 116 PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior()); 117 PARSE_LANGOPT_IMPORTANT(HeinousExtensions, 118 diag::warn_pch_heinous_extensions); 119 // FIXME: Most of the options below are benign if the macro wasn't 120 // used. Unfortunately, this means that a PCH compiled without 121 // optimization can't be used with optimization turned on, even 122 // though the only thing that changes is whether __OPTIMIZE__ was 123 // defined... but if __OPTIMIZE__ never showed up in the header, it 124 // doesn't matter. We could consider making this some special kind 125 // of check. 126 PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize); 127 PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size); 128 PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static); 129 PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level); 130 PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline); 131 PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline); 132 PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated); 133 PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control); 134 PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed); 135 PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar); 136 PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums); 137 if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) { 138 Reader.Diag(diag::warn_pch_gc_mode) 139 << LangOpts.getGCMode() << PPLangOpts.getGCMode(); 140 return true; 141 } 142 PARSE_LANGOPT_BENIGN(getVisibilityMode()); 143 PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(), 144 diag::warn_pch_stack_protector); 145 PARSE_LANGOPT_BENIGN(InstantiationDepth); 146 PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl); 147 PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda); 148 PARSE_LANGOPT_BENIGN(CatchUndefined); 149 PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors); 150 PARSE_LANGOPT_BENIGN(SpellChecking); 151 PARSE_LANGOPT_BENIGN(DefaultFPContract); 152#undef PARSE_LANGOPT_IMPORTANT 153#undef PARSE_LANGOPT_BENIGN 154 155 return false; 156} 157 158bool PCHValidator::ReadTargetTriple(llvm::StringRef Triple) { 159 if (Triple == PP.getTargetInfo().getTriple().str()) 160 return false; 161 162 Reader.Diag(diag::warn_pch_target_triple) 163 << Triple << PP.getTargetInfo().getTriple().str(); 164 return true; 165} 166 167namespace { 168 struct EmptyStringRef { 169 bool operator ()(llvm::StringRef r) const { return r.empty(); } 170 }; 171 struct EmptyBlock { 172 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();} 173 }; 174} 175 176static bool EqualConcatenations(llvm::SmallVector<llvm::StringRef, 2> L, 177 PCHPredefinesBlocks R) { 178 // First, sum up the lengths. 179 unsigned LL = 0, RL = 0; 180 for (unsigned I = 0, N = L.size(); I != N; ++I) { 181 LL += L[I].size(); 182 } 183 for (unsigned I = 0, N = R.size(); I != N; ++I) { 184 RL += R[I].Data.size(); 185 } 186 if (LL != RL) 187 return false; 188 if (LL == 0 && RL == 0) 189 return true; 190 191 // Kick out empty parts, they confuse the algorithm below. 192 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 193 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 194 195 // Do it the hard way. At this point, both vectors must be non-empty. 196 llvm::StringRef LR = L[0], RR = R[0].Data; 197 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 198 (void) RN; 199 for (;;) { 200 // Compare the current pieces. 201 if (LR.size() == RR.size()) { 202 // If they're the same length, it's pretty easy. 203 if (LR != RR) 204 return false; 205 // Both pieces are done, advance. 206 ++LI; 207 ++RI; 208 // If either string is done, they're both done, since they're the same 209 // length. 210 if (LI == LN) { 211 assert(RI == RN && "Strings not the same length after all?"); 212 return true; 213 } 214 LR = L[LI]; 215 RR = R[RI].Data; 216 } else if (LR.size() < RR.size()) { 217 // Right piece is longer. 218 if (!RR.startswith(LR)) 219 return false; 220 ++LI; 221 assert(LI != LN && "Strings not the same length after all?"); 222 RR = RR.substr(LR.size()); 223 LR = L[LI]; 224 } else { 225 // Left piece is longer. 226 if (!LR.startswith(RR)) 227 return false; 228 ++RI; 229 assert(RI != RN && "Strings not the same length after all?"); 230 LR = LR.substr(RR.size()); 231 RR = R[RI].Data; 232 } 233 } 234} 235 236static std::pair<FileID, llvm::StringRef::size_type> 237FindMacro(const PCHPredefinesBlocks &Buffers, llvm::StringRef MacroDef) { 238 std::pair<FileID, llvm::StringRef::size_type> Res; 239 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 240 Res.second = Buffers[I].Data.find(MacroDef); 241 if (Res.second != llvm::StringRef::npos) { 242 Res.first = Buffers[I].BufferID; 243 break; 244 } 245 } 246 return Res; 247} 248 249bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 250 llvm::StringRef OriginalFileName, 251 std::string &SuggestedPredefines, 252 FileManager &FileMgr) { 253 // We are in the context of an implicit include, so the predefines buffer will 254 // have a #include entry for the PCH file itself (as normalized by the 255 // preprocessor initialization). Find it and skip over it in the checking 256 // below. 257 llvm::SmallString<256> PCHInclude; 258 PCHInclude += "#include \""; 259 PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr); 260 PCHInclude += "\"\n"; 261 std::pair<llvm::StringRef,llvm::StringRef> Split = 262 llvm::StringRef(PP.getPredefines()).split(PCHInclude.str()); 263 llvm::StringRef Left = Split.first, Right = Split.second; 264 if (Left == PP.getPredefines()) { 265 Error("Missing PCH include entry!"); 266 return true; 267 } 268 269 // If the concatenation of all the PCH buffers is equal to the adjusted 270 // command line, we're done. 271 llvm::SmallVector<llvm::StringRef, 2> CommandLine; 272 CommandLine.push_back(Left); 273 CommandLine.push_back(Right); 274 if (EqualConcatenations(CommandLine, Buffers)) 275 return false; 276 277 SourceManager &SourceMgr = PP.getSourceManager(); 278 279 // The predefines buffers are different. Determine what the differences are, 280 // and whether they require us to reject the PCH file. 281 llvm::SmallVector<llvm::StringRef, 8> PCHLines; 282 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) 283 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 284 285 llvm::SmallVector<llvm::StringRef, 8> CmdLineLines; 286 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 287 288 // Pick out implicit #includes after the PCH and don't consider them for 289 // validation; we will insert them into SuggestedPredefines so that the 290 // preprocessor includes them. 291 std::string IncludesAfterPCH; 292 llvm::SmallVector<llvm::StringRef, 8> AfterPCHLines; 293 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 294 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) { 295 if (AfterPCHLines[i].startswith("#include ")) { 296 IncludesAfterPCH += AfterPCHLines[i]; 297 IncludesAfterPCH += '\n'; 298 } else { 299 CmdLineLines.push_back(AfterPCHLines[i]); 300 } 301 } 302 303 // Make sure we add the includes last into SuggestedPredefines before we 304 // exit this function. 305 struct AddIncludesRAII { 306 std::string &SuggestedPredefines; 307 std::string &IncludesAfterPCH; 308 309 AddIncludesRAII(std::string &SuggestedPredefines, 310 std::string &IncludesAfterPCH) 311 : SuggestedPredefines(SuggestedPredefines), 312 IncludesAfterPCH(IncludesAfterPCH) { } 313 ~AddIncludesRAII() { 314 SuggestedPredefines += IncludesAfterPCH; 315 } 316 } AddIncludes(SuggestedPredefines, IncludesAfterPCH); 317 318 // Sort both sets of predefined buffer lines, since we allow some extra 319 // definitions and they may appear at any point in the output. 320 std::sort(CmdLineLines.begin(), CmdLineLines.end()); 321 std::sort(PCHLines.begin(), PCHLines.end()); 322 323 // Determine which predefines that were used to build the PCH file are missing 324 // from the command line. 325 std::vector<llvm::StringRef> MissingPredefines; 326 std::set_difference(PCHLines.begin(), PCHLines.end(), 327 CmdLineLines.begin(), CmdLineLines.end(), 328 std::back_inserter(MissingPredefines)); 329 330 bool MissingDefines = false; 331 bool ConflictingDefines = false; 332 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) { 333 llvm::StringRef Missing = MissingPredefines[I]; 334 if (Missing.startswith("#include ")) { 335 // An -include was specified when generating the PCH; it is included in 336 // the PCH, just ignore it. 337 continue; 338 } 339 if (!Missing.startswith("#define ")) { 340 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 341 return true; 342 } 343 344 // This is a macro definition. Determine the name of the macro we're 345 // defining. 346 std::string::size_type StartOfMacroName = strlen("#define "); 347 std::string::size_type EndOfMacroName 348 = Missing.find_first_of("( \n\r", StartOfMacroName); 349 assert(EndOfMacroName != std::string::npos && 350 "Couldn't find the end of the macro name"); 351 llvm::StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName); 352 353 // Determine whether this macro was given a different definition on the 354 // command line. 355 std::string MacroDefStart = "#define " + MacroName.str(); 356 std::string::size_type MacroDefLen = MacroDefStart.size(); 357 llvm::SmallVector<llvm::StringRef, 8>::iterator ConflictPos 358 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(), 359 MacroDefStart); 360 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) { 361 if (!ConflictPos->startswith(MacroDefStart)) { 362 // Different macro; we're done. 363 ConflictPos = CmdLineLines.end(); 364 break; 365 } 366 367 assert(ConflictPos->size() > MacroDefLen && 368 "Invalid #define in predefines buffer?"); 369 if ((*ConflictPos)[MacroDefLen] != ' ' && 370 (*ConflictPos)[MacroDefLen] != '(') 371 continue; // Longer macro name; keep trying. 372 373 // We found a conflicting macro definition. 374 break; 375 } 376 377 if (ConflictPos != CmdLineLines.end()) { 378 Reader.Diag(diag::warn_cmdline_conflicting_macro_def) 379 << MacroName; 380 381 // Show the definition of this macro within the PCH file. 382 std::pair<FileID, llvm::StringRef::size_type> MacroLoc = 383 FindMacro(Buffers, Missing); 384 assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!"); 385 SourceLocation PCHMissingLoc = 386 SourceMgr.getLocForStartOfFile(MacroLoc.first) 387 .getFileLocWithOffset(MacroLoc.second); 388 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName; 389 390 ConflictingDefines = true; 391 continue; 392 } 393 394 // If the macro doesn't conflict, then we'll just pick up the macro 395 // definition from the PCH file. Warn the user that they made a mistake. 396 if (ConflictingDefines) 397 continue; // Don't complain if there are already conflicting defs 398 399 if (!MissingDefines) { 400 Reader.Diag(diag::warn_cmdline_missing_macro_defs); 401 MissingDefines = true; 402 } 403 404 // Show the definition of this macro within the PCH file. 405 std::pair<FileID, llvm::StringRef::size_type> MacroLoc = 406 FindMacro(Buffers, Missing); 407 assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!"); 408 SourceLocation PCHMissingLoc = 409 SourceMgr.getLocForStartOfFile(MacroLoc.first) 410 .getFileLocWithOffset(MacroLoc.second); 411 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); 412 } 413 414 if (ConflictingDefines) 415 return true; 416 417 // Determine what predefines were introduced based on command-line 418 // parameters that were not present when building the PCH 419 // file. Extra #defines are okay, so long as the identifiers being 420 // defined were not used within the precompiled header. 421 std::vector<llvm::StringRef> ExtraPredefines; 422 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), 423 PCHLines.begin(), PCHLines.end(), 424 std::back_inserter(ExtraPredefines)); 425 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { 426 llvm::StringRef &Extra = ExtraPredefines[I]; 427 if (!Extra.startswith("#define ")) { 428 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 429 return true; 430 } 431 432 // This is an extra macro definition. Determine the name of the 433 // macro we're defining. 434 std::string::size_type StartOfMacroName = strlen("#define "); 435 std::string::size_type EndOfMacroName 436 = Extra.find_first_of("( \n\r", StartOfMacroName); 437 assert(EndOfMacroName != std::string::npos && 438 "Couldn't find the end of the macro name"); 439 llvm::StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName); 440 441 // Check whether this name was used somewhere in the PCH file. If 442 // so, defining it as a macro could change behavior, so we reject 443 // the PCH file. 444 if (IdentifierInfo *II = Reader.get(MacroName)) { 445 Reader.Diag(diag::warn_macro_name_used_in_pch) << II; 446 return true; 447 } 448 449 // Add this definition to the suggested predefines buffer. 450 SuggestedPredefines += Extra; 451 SuggestedPredefines += '\n'; 452 } 453 454 // If we get here, it's because the predefines buffer had compatible 455 // contents. Accept the PCH file. 456 return false; 457} 458 459void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 460 unsigned ID) { 461 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 462 ++NumHeaderInfos; 463} 464 465void PCHValidator::ReadCounter(unsigned Value) { 466 PP.setCounterValue(Value); 467} 468 469//===----------------------------------------------------------------------===// 470// AST reader implementation 471//===----------------------------------------------------------------------===// 472 473void 474ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 475 DeserializationListener = Listener; 476} 477 478 479namespace { 480class ASTSelectorLookupTrait { 481 ASTReader &Reader; 482 483public: 484 struct data_type { 485 SelectorID ID; 486 ObjCMethodList Instance, Factory; 487 }; 488 489 typedef Selector external_key_type; 490 typedef external_key_type internal_key_type; 491 492 explicit ASTSelectorLookupTrait(ASTReader &Reader) : Reader(Reader) { } 493 494 static bool EqualKey(const internal_key_type& a, 495 const internal_key_type& b) { 496 return a == b; 497 } 498 499 static unsigned ComputeHash(Selector Sel) { 500 return serialization::ComputeHash(Sel); 501 } 502 503 // This hopefully will just get inlined and removed by the optimizer. 504 static const internal_key_type& 505 GetInternalKey(const external_key_type& x) { return x; } 506 507 static std::pair<unsigned, unsigned> 508 ReadKeyDataLength(const unsigned char*& d) { 509 using namespace clang::io; 510 unsigned KeyLen = ReadUnalignedLE16(d); 511 unsigned DataLen = ReadUnalignedLE16(d); 512 return std::make_pair(KeyLen, DataLen); 513 } 514 515 internal_key_type ReadKey(const unsigned char* d, unsigned) { 516 using namespace clang::io; 517 SelectorTable &SelTable = Reader.getContext()->Selectors; 518 unsigned N = ReadUnalignedLE16(d); 519 IdentifierInfo *FirstII 520 = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 521 if (N == 0) 522 return SelTable.getNullarySelector(FirstII); 523 else if (N == 1) 524 return SelTable.getUnarySelector(FirstII); 525 526 llvm::SmallVector<IdentifierInfo *, 16> Args; 527 Args.push_back(FirstII); 528 for (unsigned I = 1; I != N; ++I) 529 Args.push_back(Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d))); 530 531 return SelTable.getSelector(N, Args.data()); 532 } 533 534 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) { 535 using namespace clang::io; 536 537 data_type Result; 538 539 Result.ID = ReadUnalignedLE32(d); 540 unsigned NumInstanceMethods = ReadUnalignedLE16(d); 541 unsigned NumFactoryMethods = ReadUnalignedLE16(d); 542 543 // Load instance methods 544 ObjCMethodList *Prev = 0; 545 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 546 ObjCMethodDecl *Method 547 = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); 548 if (!Result.Instance.Method) { 549 // This is the first method, which is the easy case. 550 Result.Instance.Method = Method; 551 Prev = &Result.Instance; 552 continue; 553 } 554 555 ObjCMethodList *Mem = 556 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 557 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 558 Prev = Prev->Next; 559 } 560 561 // Load factory methods 562 Prev = 0; 563 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 564 ObjCMethodDecl *Method 565 = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); 566 if (!Result.Factory.Method) { 567 // This is the first method, which is the easy case. 568 Result.Factory.Method = Method; 569 Prev = &Result.Factory; 570 continue; 571 } 572 573 ObjCMethodList *Mem = 574 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 575 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 576 Prev = Prev->Next; 577 } 578 579 return Result; 580 } 581}; 582 583} // end anonymous namespace 584 585/// \brief The on-disk hash table used for the global method pool. 586typedef OnDiskChainedHashTable<ASTSelectorLookupTrait> 587 ASTSelectorLookupTable; 588 589namespace clang { 590class ASTIdentifierLookupTrait { 591 ASTReader &Reader; 592 ASTReader::PerFileData &F; 593 594 // If we know the IdentifierInfo in advance, it is here and we will 595 // not build a new one. Used when deserializing information about an 596 // identifier that was constructed before the AST file was read. 597 IdentifierInfo *KnownII; 598 599public: 600 typedef IdentifierInfo * data_type; 601 602 typedef const std::pair<const char*, unsigned> external_key_type; 603 604 typedef external_key_type internal_key_type; 605 606 ASTIdentifierLookupTrait(ASTReader &Reader, ASTReader::PerFileData &F, 607 IdentifierInfo *II = 0) 608 : Reader(Reader), F(F), KnownII(II) { } 609 610 static bool EqualKey(const internal_key_type& a, 611 const internal_key_type& b) { 612 return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0 613 : false; 614 } 615 616 static unsigned ComputeHash(const internal_key_type& a) { 617 return llvm::HashString(llvm::StringRef(a.first, a.second)); 618 } 619 620 // This hopefully will just get inlined and removed by the optimizer. 621 static const internal_key_type& 622 GetInternalKey(const external_key_type& x) { return x; } 623 624 // This hopefully will just get inlined and removed by the optimizer. 625 static const external_key_type& 626 GetExternalKey(const internal_key_type& x) { return x; } 627 628 static std::pair<unsigned, unsigned> 629 ReadKeyDataLength(const unsigned char*& d) { 630 using namespace clang::io; 631 unsigned DataLen = ReadUnalignedLE16(d); 632 unsigned KeyLen = ReadUnalignedLE16(d); 633 return std::make_pair(KeyLen, DataLen); 634 } 635 636 static std::pair<const char*, unsigned> 637 ReadKey(const unsigned char* d, unsigned n) { 638 assert(n >= 2 && d[n-1] == '\0'); 639 return std::make_pair((const char*) d, n-1); 640 } 641 642 IdentifierInfo *ReadData(const internal_key_type& k, 643 const unsigned char* d, 644 unsigned DataLen) { 645 using namespace clang::io; 646 IdentID ID = ReadUnalignedLE32(d); 647 bool IsInteresting = ID & 0x01; 648 649 // Wipe out the "is interesting" bit. 650 ID = ID >> 1; 651 652 if (!IsInteresting) { 653 // For uninteresting identifiers, just build the IdentifierInfo 654 // and associate it with the persistent ID. 655 IdentifierInfo *II = KnownII; 656 if (!II) 657 II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second); 658 Reader.SetIdentifierInfo(ID, II); 659 II->setIsFromAST(); 660 return II; 661 } 662 663 unsigned Bits = ReadUnalignedLE16(d); 664 bool CPlusPlusOperatorKeyword = Bits & 0x01; 665 Bits >>= 1; 666 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 667 Bits >>= 1; 668 bool Poisoned = Bits & 0x01; 669 Bits >>= 1; 670 bool ExtensionToken = Bits & 0x01; 671 Bits >>= 1; 672 bool hasMacroDefinition = Bits & 0x01; 673 Bits >>= 1; 674 unsigned ObjCOrBuiltinID = Bits & 0x3FF; 675 Bits >>= 10; 676 677 assert(Bits == 0 && "Extra bits in the identifier?"); 678 DataLen -= 6; 679 680 // Build the IdentifierInfo itself and link the identifier ID with 681 // the new IdentifierInfo. 682 IdentifierInfo *II = KnownII; 683 if (!II) 684 II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second); 685 Reader.SetIdentifierInfo(ID, II); 686 687 // Set or check the various bits in the IdentifierInfo structure. 688 // Token IDs are read-only. 689 if (HasRevertedTokenIDToIdentifier) 690 II->RevertTokenIDToIdentifier(); 691 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 692 assert(II->isExtensionToken() == ExtensionToken && 693 "Incorrect extension token flag"); 694 (void)ExtensionToken; 695 II->setIsPoisoned(Poisoned); 696 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 697 "Incorrect C++ operator keyword flag"); 698 (void)CPlusPlusOperatorKeyword; 699 700 // If this identifier is a macro, deserialize the macro 701 // definition. 702 if (hasMacroDefinition) { 703 uint32_t Offset = ReadUnalignedLE32(d); 704 Reader.SetIdentifierIsMacro(II, F, Offset); 705 DataLen -= 4; 706 } 707 708 // Read all of the declarations visible at global scope with this 709 // name. 710 if (Reader.getContext() == 0) return II; 711 if (DataLen > 0) { 712 llvm::SmallVector<uint32_t, 4> DeclIDs; 713 for (; DataLen > 0; DataLen -= 4) 714 DeclIDs.push_back(ReadUnalignedLE32(d)); 715 Reader.SetGloballyVisibleDecls(II, DeclIDs); 716 } 717 718 II->setIsFromAST(); 719 return II; 720 } 721}; 722 723} // end anonymous namespace 724 725/// \brief The on-disk hash table used to contain information about 726/// all of the identifiers in the program. 727typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait> 728 ASTIdentifierLookupTable; 729 730namespace { 731class ASTDeclContextNameLookupTrait { 732 ASTReader &Reader; 733 734public: 735 /// \brief Pair of begin/end iterators for DeclIDs. 736 typedef std::pair<DeclID *, DeclID *> data_type; 737 738 /// \brief Special internal key for declaration names. 739 /// The hash table creates keys for comparison; we do not create 740 /// a DeclarationName for the internal key to avoid deserializing types. 741 struct DeclNameKey { 742 DeclarationName::NameKind Kind; 743 uint64_t Data; 744 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { } 745 }; 746 747 typedef DeclarationName external_key_type; 748 typedef DeclNameKey internal_key_type; 749 750 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader) : Reader(Reader) { } 751 752 static bool EqualKey(const internal_key_type& a, 753 const internal_key_type& b) { 754 return a.Kind == b.Kind && a.Data == b.Data; 755 } 756 757 unsigned ComputeHash(const DeclNameKey &Key) const { 758 llvm::FoldingSetNodeID ID; 759 ID.AddInteger(Key.Kind); 760 761 switch (Key.Kind) { 762 case DeclarationName::Identifier: 763 case DeclarationName::CXXLiteralOperatorName: 764 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 765 break; 766 case DeclarationName::ObjCZeroArgSelector: 767 case DeclarationName::ObjCOneArgSelector: 768 case DeclarationName::ObjCMultiArgSelector: 769 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 770 break; 771 case DeclarationName::CXXConstructorName: 772 case DeclarationName::CXXDestructorName: 773 case DeclarationName::CXXConversionFunctionName: 774 ID.AddInteger((TypeID)Key.Data); 775 break; 776 case DeclarationName::CXXOperatorName: 777 ID.AddInteger((OverloadedOperatorKind)Key.Data); 778 break; 779 case DeclarationName::CXXUsingDirective: 780 break; 781 } 782 783 return ID.ComputeHash(); 784 } 785 786 internal_key_type GetInternalKey(const external_key_type& Name) const { 787 DeclNameKey Key; 788 Key.Kind = Name.getNameKind(); 789 switch (Name.getNameKind()) { 790 case DeclarationName::Identifier: 791 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 792 break; 793 case DeclarationName::ObjCZeroArgSelector: 794 case DeclarationName::ObjCOneArgSelector: 795 case DeclarationName::ObjCMultiArgSelector: 796 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 797 break; 798 case DeclarationName::CXXConstructorName: 799 case DeclarationName::CXXDestructorName: 800 case DeclarationName::CXXConversionFunctionName: 801 Key.Data = Reader.GetTypeID(Name.getCXXNameType()); 802 break; 803 case DeclarationName::CXXOperatorName: 804 Key.Data = Name.getCXXOverloadedOperator(); 805 break; 806 case DeclarationName::CXXLiteralOperatorName: 807 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 808 break; 809 case DeclarationName::CXXUsingDirective: 810 break; 811 } 812 813 return Key; 814 } 815 816 external_key_type GetExternalKey(const internal_key_type& Key) const { 817 ASTContext *Context = Reader.getContext(); 818 switch (Key.Kind) { 819 case DeclarationName::Identifier: 820 return DeclarationName((IdentifierInfo*)Key.Data); 821 822 case DeclarationName::ObjCZeroArgSelector: 823 case DeclarationName::ObjCOneArgSelector: 824 case DeclarationName::ObjCMultiArgSelector: 825 return DeclarationName(Selector(Key.Data)); 826 827 case DeclarationName::CXXConstructorName: 828 return Context->DeclarationNames.getCXXConstructorName( 829 Context->getCanonicalType(Reader.GetType(Key.Data))); 830 831 case DeclarationName::CXXDestructorName: 832 return Context->DeclarationNames.getCXXDestructorName( 833 Context->getCanonicalType(Reader.GetType(Key.Data))); 834 835 case DeclarationName::CXXConversionFunctionName: 836 return Context->DeclarationNames.getCXXConversionFunctionName( 837 Context->getCanonicalType(Reader.GetType(Key.Data))); 838 839 case DeclarationName::CXXOperatorName: 840 return Context->DeclarationNames.getCXXOperatorName( 841 (OverloadedOperatorKind)Key.Data); 842 843 case DeclarationName::CXXLiteralOperatorName: 844 return Context->DeclarationNames.getCXXLiteralOperatorName( 845 (IdentifierInfo*)Key.Data); 846 847 case DeclarationName::CXXUsingDirective: 848 return DeclarationName::getUsingDirectiveName(); 849 } 850 851 llvm_unreachable("Invalid Name Kind ?"); 852 } 853 854 static std::pair<unsigned, unsigned> 855 ReadKeyDataLength(const unsigned char*& d) { 856 using namespace clang::io; 857 unsigned KeyLen = ReadUnalignedLE16(d); 858 unsigned DataLen = ReadUnalignedLE16(d); 859 return std::make_pair(KeyLen, DataLen); 860 } 861 862 internal_key_type ReadKey(const unsigned char* d, unsigned) { 863 using namespace clang::io; 864 865 DeclNameKey Key; 866 Key.Kind = (DeclarationName::NameKind)*d++; 867 switch (Key.Kind) { 868 case DeclarationName::Identifier: 869 Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 870 break; 871 case DeclarationName::ObjCZeroArgSelector: 872 case DeclarationName::ObjCOneArgSelector: 873 case DeclarationName::ObjCMultiArgSelector: 874 Key.Data = 875 (uint64_t)Reader.DecodeSelector(ReadUnalignedLE32(d)).getAsOpaquePtr(); 876 break; 877 case DeclarationName::CXXConstructorName: 878 case DeclarationName::CXXDestructorName: 879 case DeclarationName::CXXConversionFunctionName: 880 Key.Data = ReadUnalignedLE32(d); // TypeID 881 break; 882 case DeclarationName::CXXOperatorName: 883 Key.Data = *d++; // OverloadedOperatorKind 884 break; 885 case DeclarationName::CXXLiteralOperatorName: 886 Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); 887 break; 888 case DeclarationName::CXXUsingDirective: 889 break; 890 } 891 892 return Key; 893 } 894 895 data_type ReadData(internal_key_type, const unsigned char* d, 896 unsigned DataLen) { 897 using namespace clang::io; 898 unsigned NumDecls = ReadUnalignedLE16(d); 899 DeclID *Start = (DeclID *)d; 900 return std::make_pair(Start, Start + NumDecls); 901 } 902}; 903 904} // end anonymous namespace 905 906/// \brief The on-disk hash table used for the DeclContext's Name lookup table. 907typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait> 908 ASTDeclContextNameLookupTable; 909 910bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor, 911 const std::pair<uint64_t, uint64_t> &Offsets, 912 DeclContextInfo &Info) { 913 SavedStreamPosition SavedPosition(Cursor); 914 // First the lexical decls. 915 if (Offsets.first != 0) { 916 Cursor.JumpToBit(Offsets.first); 917 918 RecordData Record; 919 const char *Blob; 920 unsigned BlobLen; 921 unsigned Code = Cursor.ReadCode(); 922 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 923 if (RecCode != DECL_CONTEXT_LEXICAL) { 924 Error("Expected lexical block"); 925 return true; 926 } 927 928 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob); 929 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair); 930 } else { 931 Info.LexicalDecls = 0; 932 Info.NumLexicalDecls = 0; 933 } 934 935 // Now the lookup table. 936 if (Offsets.second != 0) { 937 Cursor.JumpToBit(Offsets.second); 938 939 RecordData Record; 940 const char *Blob; 941 unsigned BlobLen; 942 unsigned Code = Cursor.ReadCode(); 943 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 944 if (RecCode != DECL_CONTEXT_VISIBLE) { 945 Error("Expected visible lookup table block"); 946 return true; 947 } 948 Info.NameLookupTableData 949 = ASTDeclContextNameLookupTable::Create( 950 (const unsigned char *)Blob + Record[0], 951 (const unsigned char *)Blob, 952 ASTDeclContextNameLookupTrait(*this)); 953 } else { 954 Info.NameLookupTableData = 0; 955 } 956 957 return false; 958} 959 960void ASTReader::Error(const char *Msg) { 961 Diag(diag::err_fe_pch_malformed) << Msg; 962} 963 964/// \brief Tell the AST listener about the predefines buffers in the chain. 965bool ASTReader::CheckPredefinesBuffers() { 966 if (Listener) 967 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers, 968 ActualOriginalFileName, 969 SuggestedPredefines, 970 FileMgr); 971 return false; 972} 973 974//===----------------------------------------------------------------------===// 975// Source Manager Deserialization 976//===----------------------------------------------------------------------===// 977 978/// \brief Read the line table in the source manager block. 979/// \returns true if there was an error. 980bool ASTReader::ParseLineTable(PerFileData &F, 981 llvm::SmallVectorImpl<uint64_t> &Record) { 982 unsigned Idx = 0; 983 LineTableInfo &LineTable = SourceMgr.getLineTable(); 984 985 // Parse the file names 986 std::map<int, int> FileIDs; 987 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 988 // Extract the file name 989 unsigned FilenameLen = Record[Idx++]; 990 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 991 Idx += FilenameLen; 992 MaybeAddSystemRootToFilename(Filename); 993 FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(), 994 Filename.size()); 995 } 996 997 // Parse the line entries 998 std::vector<LineEntry> Entries; 999 while (Idx < Record.size()) { 1000 int FID = Record[Idx++]; 1001 1002 // Extract the line entries 1003 unsigned NumEntries = Record[Idx++]; 1004 assert(NumEntries && "Numentries is 00000"); 1005 Entries.clear(); 1006 Entries.reserve(NumEntries); 1007 for (unsigned I = 0; I != NumEntries; ++I) { 1008 unsigned FileOffset = Record[Idx++]; 1009 unsigned LineNo = Record[Idx++]; 1010 int FilenameID = FileIDs[Record[Idx++]]; 1011 SrcMgr::CharacteristicKind FileKind 1012 = (SrcMgr::CharacteristicKind)Record[Idx++]; 1013 unsigned IncludeOffset = Record[Idx++]; 1014 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 1015 FileKind, IncludeOffset)); 1016 } 1017 LineTable.AddEntry(FID, Entries); 1018 } 1019 1020 return false; 1021} 1022 1023namespace { 1024 1025class ASTStatData { 1026public: 1027 const ino_t ino; 1028 const dev_t dev; 1029 const mode_t mode; 1030 const time_t mtime; 1031 const off_t size; 1032 1033 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) 1034 : ino(i), dev(d), mode(mo), mtime(m), size(s) {} 1035}; 1036 1037class ASTStatLookupTrait { 1038 public: 1039 typedef const char *external_key_type; 1040 typedef const char *internal_key_type; 1041 1042 typedef ASTStatData data_type; 1043 1044 static unsigned ComputeHash(const char *path) { 1045 return llvm::HashString(path); 1046 } 1047 1048 static internal_key_type GetInternalKey(const char *path) { return path; } 1049 1050 static bool EqualKey(internal_key_type a, internal_key_type b) { 1051 return strcmp(a, b) == 0; 1052 } 1053 1054 static std::pair<unsigned, unsigned> 1055 ReadKeyDataLength(const unsigned char*& d) { 1056 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1057 unsigned DataLen = (unsigned) *d++; 1058 return std::make_pair(KeyLen + 1, DataLen); 1059 } 1060 1061 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1062 return (const char *)d; 1063 } 1064 1065 static data_type ReadData(const internal_key_type, const unsigned char *d, 1066 unsigned /*DataLen*/) { 1067 using namespace clang::io; 1068 1069 ino_t ino = (ino_t) ReadUnalignedLE32(d); 1070 dev_t dev = (dev_t) ReadUnalignedLE32(d); 1071 mode_t mode = (mode_t) ReadUnalignedLE16(d); 1072 time_t mtime = (time_t) ReadUnalignedLE64(d); 1073 off_t size = (off_t) ReadUnalignedLE64(d); 1074 return data_type(ino, dev, mode, mtime, size); 1075 } 1076}; 1077 1078/// \brief stat() cache for precompiled headers. 1079/// 1080/// This cache is very similar to the stat cache used by pretokenized 1081/// headers. 1082class ASTStatCache : public FileSystemStatCache { 1083 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy; 1084 CacheTy *Cache; 1085 1086 unsigned &NumStatHits, &NumStatMisses; 1087public: 1088 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base, 1089 unsigned &NumStatHits, unsigned &NumStatMisses) 1090 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { 1091 Cache = CacheTy::Create(Buckets, Base); 1092 } 1093 1094 ~ASTStatCache() { delete Cache; } 1095 1096 LookupResult getStat(const char *Path, struct stat &StatBuf, 1097 int *FileDescriptor) { 1098 // Do the lookup for the file's data in the AST file. 1099 CacheTy::iterator I = Cache->find(Path); 1100 1101 // If we don't get a hit in the AST file just forward to 'stat'. 1102 if (I == Cache->end()) { 1103 ++NumStatMisses; 1104 return statChained(Path, StatBuf, FileDescriptor); 1105 } 1106 1107 ++NumStatHits; 1108 ASTStatData Data = *I; 1109 1110 StatBuf.st_ino = Data.ino; 1111 StatBuf.st_dev = Data.dev; 1112 StatBuf.st_mtime = Data.mtime; 1113 StatBuf.st_mode = Data.mode; 1114 StatBuf.st_size = Data.size; 1115 return CacheExists; 1116 } 1117}; 1118} // end anonymous namespace 1119 1120 1121/// \brief Read a source manager block 1122ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(PerFileData &F) { 1123 using namespace SrcMgr; 1124 1125 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 1126 1127 // Set the source-location entry cursor to the current position in 1128 // the stream. This cursor will be used to read the contents of the 1129 // source manager block initially, and then lazily read 1130 // source-location entries as needed. 1131 SLocEntryCursor = F.Stream; 1132 1133 // The stream itself is going to skip over the source manager block. 1134 if (F.Stream.SkipBlock()) { 1135 Error("malformed block record in AST file"); 1136 return Failure; 1137 } 1138 1139 // Enter the source manager block. 1140 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 1141 Error("malformed source manager block record in AST file"); 1142 return Failure; 1143 } 1144 1145 RecordData Record; 1146 while (true) { 1147 unsigned Code = SLocEntryCursor.ReadCode(); 1148 if (Code == llvm::bitc::END_BLOCK) { 1149 if (SLocEntryCursor.ReadBlockEnd()) { 1150 Error("error at end of Source Manager block in AST file"); 1151 return Failure; 1152 } 1153 return Success; 1154 } 1155 1156 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1157 // No known subblocks, always skip them. 1158 SLocEntryCursor.ReadSubBlockID(); 1159 if (SLocEntryCursor.SkipBlock()) { 1160 Error("malformed block record in AST file"); 1161 return Failure; 1162 } 1163 continue; 1164 } 1165 1166 if (Code == llvm::bitc::DEFINE_ABBREV) { 1167 SLocEntryCursor.ReadAbbrevRecord(); 1168 continue; 1169 } 1170 1171 // Read a record. 1172 const char *BlobStart; 1173 unsigned BlobLen; 1174 Record.clear(); 1175 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1176 default: // Default behavior: ignore. 1177 break; 1178 1179 case SM_LINE_TABLE: 1180 if (ParseLineTable(F, Record)) 1181 return Failure; 1182 break; 1183 1184 case SM_SLOC_FILE_ENTRY: 1185 case SM_SLOC_BUFFER_ENTRY: 1186 case SM_SLOC_INSTANTIATION_ENTRY: 1187 // Once we hit one of the source location entries, we're done. 1188 return Success; 1189 } 1190 } 1191} 1192 1193/// \brief If a header file is not found at the path that we expect it to be 1194/// and the PCH file was moved from its original location, try to resolve the 1195/// file by assuming that header+PCH were moved together and the header is in 1196/// the same place relative to the PCH. 1197static std::string 1198resolveFileRelativeToOriginalDir(const std::string &Filename, 1199 const std::string &OriginalDir, 1200 const std::string &CurrDir) { 1201 assert(OriginalDir != CurrDir && 1202 "No point trying to resolve the file if the PCH dir didn't change"); 1203 using namespace llvm::sys; 1204 llvm::SmallString<128> filePath(Filename); 1205 fs::make_absolute(filePath); 1206 assert(path::is_absolute(OriginalDir)); 1207 llvm::SmallString<128> currPCHPath(CurrDir); 1208 1209 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 1210 fileDirE = path::end(path::parent_path(filePath)); 1211 path::const_iterator origDirI = path::begin(OriginalDir), 1212 origDirE = path::end(OriginalDir); 1213 // Skip the common path components from filePath and OriginalDir. 1214 while (fileDirI != fileDirE && origDirI != origDirE && 1215 *fileDirI == *origDirI) { 1216 ++fileDirI; 1217 ++origDirI; 1218 } 1219 for (; origDirI != origDirE; ++origDirI) 1220 path::append(currPCHPath, ".."); 1221 path::append(currPCHPath, fileDirI, fileDirE); 1222 path::append(currPCHPath, path::filename(Filename)); 1223 return currPCHPath.str(); 1224} 1225 1226/// \brief Get a cursor that's correctly positioned for reading the source 1227/// location entry with the given ID. 1228ASTReader::PerFileData *ASTReader::SLocCursorForID(unsigned ID) { 1229 assert(ID != 0 && ID <= TotalNumSLocEntries && 1230 "SLocCursorForID should only be called for real IDs."); 1231 1232 ID -= 1; 1233 PerFileData *F = 0; 1234 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1235 F = Chain[N - I - 1]; 1236 if (ID < F->LocalNumSLocEntries) 1237 break; 1238 ID -= F->LocalNumSLocEntries; 1239 } 1240 assert(F && F->LocalNumSLocEntries > ID && "Chain corrupted"); 1241 1242 F->SLocEntryCursor.JumpToBit(F->SLocOffsets[ID]); 1243 return F; 1244} 1245 1246/// \brief Read in the source location entry with the given ID. 1247ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(unsigned ID) { 1248 if (ID == 0) 1249 return Success; 1250 1251 if (ID > TotalNumSLocEntries) { 1252 Error("source location entry ID out-of-range for AST file"); 1253 return Failure; 1254 } 1255 1256 PerFileData *F = SLocCursorForID(ID); 1257 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 1258 1259 ++NumSLocEntriesRead; 1260 unsigned Code = SLocEntryCursor.ReadCode(); 1261 if (Code == llvm::bitc::END_BLOCK || 1262 Code == llvm::bitc::ENTER_SUBBLOCK || 1263 Code == llvm::bitc::DEFINE_ABBREV) { 1264 Error("incorrectly-formatted source location entry in AST file"); 1265 return Failure; 1266 } 1267 1268 RecordData Record; 1269 const char *BlobStart; 1270 unsigned BlobLen; 1271 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1272 default: 1273 Error("incorrectly-formatted source location entry in AST file"); 1274 return Failure; 1275 1276 case SM_SLOC_FILE_ENTRY: { 1277 std::string Filename(BlobStart, BlobStart + BlobLen); 1278 MaybeAddSystemRootToFilename(Filename); 1279 const FileEntry *File = FileMgr.getFile(Filename); 1280 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1281 OriginalDir != CurrentDir) { 1282 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1283 OriginalDir, 1284 CurrentDir); 1285 if (!resolved.empty()) 1286 File = FileMgr.getFile(resolved); 1287 } 1288 if (File == 0) 1289 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4], 1290 (time_t)Record[5]); 1291 if (File == 0) { 1292 std::string ErrorStr = "could not find file '"; 1293 ErrorStr += Filename; 1294 ErrorStr += "' referenced by AST file"; 1295 Error(ErrorStr.c_str()); 1296 return Failure; 1297 } 1298 1299 if (Record.size() < 6) { 1300 Error("source location entry is incorrect"); 1301 return Failure; 1302 } 1303 1304 if (!DisableValidation && 1305 ((off_t)Record[4] != File->getSize() 1306#if !defined(LLVM_ON_WIN32) 1307 // In our regression testing, the Windows file system seems to 1308 // have inconsistent modification times that sometimes 1309 // erroneously trigger this error-handling path. 1310 || (time_t)Record[5] != File->getModificationTime() 1311#endif 1312 )) { 1313 Diag(diag::err_fe_pch_file_modified) 1314 << Filename; 1315 return Failure; 1316 } 1317 1318 FileID FID = SourceMgr.createFileID(File, ReadSourceLocation(*F, Record[1]), 1319 (SrcMgr::CharacteristicKind)Record[2], 1320 ID, Record[0]); 1321 if (Record[3]) 1322 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()) 1323 .setHasLineDirectives(); 1324 1325 break; 1326 } 1327 1328 case SM_SLOC_BUFFER_ENTRY: { 1329 const char *Name = BlobStart; 1330 unsigned Offset = Record[0]; 1331 unsigned Code = SLocEntryCursor.ReadCode(); 1332 Record.clear(); 1333 unsigned RecCode 1334 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); 1335 1336 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1337 Error("AST record has invalid code"); 1338 return Failure; 1339 } 1340 1341 llvm::MemoryBuffer *Buffer 1342 = llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(BlobStart, BlobLen - 1), 1343 Name); 1344 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, Offset); 1345 1346 if (strcmp(Name, "<built-in>") == 0) { 1347 PCHPredefinesBlock Block = { 1348 BufferID, 1349 llvm::StringRef(BlobStart, BlobLen - 1) 1350 }; 1351 PCHPredefinesBuffers.push_back(Block); 1352 } 1353 1354 break; 1355 } 1356 1357 case SM_SLOC_INSTANTIATION_ENTRY: { 1358 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1359 SourceMgr.createInstantiationLoc(SpellingLoc, 1360 ReadSourceLocation(*F, Record[2]), 1361 ReadSourceLocation(*F, Record[3]), 1362 Record[4], 1363 ID, 1364 Record[0]); 1365 break; 1366 } 1367 } 1368 1369 return Success; 1370} 1371 1372/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1373/// specified cursor. Read the abbreviations that are at the top of the block 1374/// and then leave the cursor pointing into the block. 1375bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, 1376 unsigned BlockID) { 1377 if (Cursor.EnterSubBlock(BlockID)) { 1378 Error("malformed block record in AST file"); 1379 return Failure; 1380 } 1381 1382 while (true) { 1383 uint64_t Offset = Cursor.GetCurrentBitNo(); 1384 unsigned Code = Cursor.ReadCode(); 1385 1386 // We expect all abbrevs to be at the start of the block. 1387 if (Code != llvm::bitc::DEFINE_ABBREV) { 1388 Cursor.JumpToBit(Offset); 1389 return false; 1390 } 1391 Cursor.ReadAbbrevRecord(); 1392 } 1393} 1394 1395PreprocessedEntity *ASTReader::ReadMacroRecord(PerFileData &F, uint64_t Offset) { 1396 assert(PP && "Forgot to set Preprocessor ?"); 1397 llvm::BitstreamCursor &Stream = F.MacroCursor; 1398 1399 // Keep track of where we are in the stream, then jump back there 1400 // after reading this macro. 1401 SavedStreamPosition SavedPosition(Stream); 1402 1403 Stream.JumpToBit(Offset); 1404 RecordData Record; 1405 llvm::SmallVector<IdentifierInfo*, 16> MacroArgs; 1406 MacroInfo *Macro = 0; 1407 1408 while (true) { 1409 unsigned Code = Stream.ReadCode(); 1410 switch (Code) { 1411 case llvm::bitc::END_BLOCK: 1412 return 0; 1413 1414 case llvm::bitc::ENTER_SUBBLOCK: 1415 // No known subblocks, always skip them. 1416 Stream.ReadSubBlockID(); 1417 if (Stream.SkipBlock()) { 1418 Error("malformed block record in AST file"); 1419 return 0; 1420 } 1421 continue; 1422 1423 case llvm::bitc::DEFINE_ABBREV: 1424 Stream.ReadAbbrevRecord(); 1425 continue; 1426 default: break; 1427 } 1428 1429 // Read a record. 1430 const char *BlobStart = 0; 1431 unsigned BlobLen = 0; 1432 Record.clear(); 1433 PreprocessorRecordTypes RecType = 1434 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart, 1435 BlobLen); 1436 switch (RecType) { 1437 case PP_MACRO_OBJECT_LIKE: 1438 case PP_MACRO_FUNCTION_LIKE: { 1439 // If we already have a macro, that means that we've hit the end 1440 // of the definition of the macro we were looking for. We're 1441 // done. 1442 if (Macro) 1443 return 0; 1444 1445 IdentifierInfo *II = DecodeIdentifierInfo(Record[0]); 1446 if (II == 0) { 1447 Error("macro must have a name in AST file"); 1448 return 0; 1449 } 1450 SourceLocation Loc = ReadSourceLocation(F, Record[1]); 1451 bool isUsed = Record[2]; 1452 1453 MacroInfo *MI = PP->AllocateMacroInfo(Loc); 1454 MI->setIsUsed(isUsed); 1455 MI->setIsFromAST(); 1456 1457 unsigned NextIndex = 3; 1458 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1459 // Decode function-like macro info. 1460 bool isC99VarArgs = Record[3]; 1461 bool isGNUVarArgs = Record[4]; 1462 MacroArgs.clear(); 1463 unsigned NumArgs = Record[5]; 1464 NextIndex = 6 + NumArgs; 1465 for (unsigned i = 0; i != NumArgs; ++i) 1466 MacroArgs.push_back(DecodeIdentifierInfo(Record[6+i])); 1467 1468 // Install function-like macro info. 1469 MI->setIsFunctionLike(); 1470 if (isC99VarArgs) MI->setIsC99Varargs(); 1471 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1472 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1473 PP->getPreprocessorAllocator()); 1474 } 1475 1476 // Finally, install the macro. 1477 PP->setMacroInfo(II, MI); 1478 1479 // Remember that we saw this macro last so that we add the tokens that 1480 // form its body to it. 1481 Macro = MI; 1482 1483 if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) { 1484 // We have a macro definition. Load it now. 1485 PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro, 1486 getMacroDefinition(Record[NextIndex])); 1487 } 1488 1489 ++NumMacrosRead; 1490 break; 1491 } 1492 1493 case PP_TOKEN: { 1494 // If we see a TOKEN before a PP_MACRO_*, then the file is 1495 // erroneous, just pretend we didn't see this. 1496 if (Macro == 0) break; 1497 1498 Token Tok; 1499 Tok.startToken(); 1500 Tok.setLocation(ReadSourceLocation(F, Record[0])); 1501 Tok.setLength(Record[1]); 1502 if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2])) 1503 Tok.setIdentifierInfo(II); 1504 Tok.setKind((tok::TokenKind)Record[3]); 1505 Tok.setFlag((Token::TokenFlags)Record[4]); 1506 Macro->AddTokenToBody(Tok); 1507 break; 1508 } 1509 } 1510 } 1511 1512 return 0; 1513} 1514 1515PreprocessedEntity *ASTReader::LoadPreprocessedEntity(PerFileData &F) { 1516 assert(PP && "Forgot to set Preprocessor ?"); 1517 unsigned Code = F.PreprocessorDetailCursor.ReadCode(); 1518 switch (Code) { 1519 case llvm::bitc::END_BLOCK: 1520 return 0; 1521 1522 case llvm::bitc::ENTER_SUBBLOCK: 1523 Error("unexpected subblock record in preprocessor detail block"); 1524 return 0; 1525 1526 case llvm::bitc::DEFINE_ABBREV: 1527 Error("unexpected abbrevation record in preprocessor detail block"); 1528 return 0; 1529 1530 default: 1531 break; 1532 } 1533 1534 if (!PP->getPreprocessingRecord()) { 1535 Error("no preprocessing record"); 1536 return 0; 1537 } 1538 1539 // Read the record. 1540 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1541 const char *BlobStart = 0; 1542 unsigned BlobLen = 0; 1543 RecordData Record; 1544 PreprocessorDetailRecordTypes RecType = 1545 (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord( 1546 Code, Record, BlobStart, BlobLen); 1547 switch (RecType) { 1548 case PPD_MACRO_INSTANTIATION: { 1549 if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0])) 1550 return PE; 1551 1552 MacroInstantiation *MI 1553 = new (PPRec) MacroInstantiation(DecodeIdentifierInfo(Record[3]), 1554 SourceRange(ReadSourceLocation(F, Record[1]), 1555 ReadSourceLocation(F, Record[2])), 1556 getMacroDefinition(Record[4])); 1557 PPRec.SetPreallocatedEntity(Record[0], MI); 1558 return MI; 1559 } 1560 1561 case PPD_MACRO_DEFINITION: { 1562 if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0])) 1563 return PE; 1564 1565 if (Record[1] > MacroDefinitionsLoaded.size()) { 1566 Error("out-of-bounds macro definition record"); 1567 return 0; 1568 } 1569 1570 // Decode the identifier info and then check again; if the macro is 1571 // still defined and associated with the identifier, 1572 IdentifierInfo *II = DecodeIdentifierInfo(Record[4]); 1573 if (!MacroDefinitionsLoaded[Record[1] - 1]) { 1574 MacroDefinition *MD 1575 = new (PPRec) MacroDefinition(II, 1576 ReadSourceLocation(F, Record[5]), 1577 SourceRange( 1578 ReadSourceLocation(F, Record[2]), 1579 ReadSourceLocation(F, Record[3]))); 1580 1581 PPRec.SetPreallocatedEntity(Record[0], MD); 1582 MacroDefinitionsLoaded[Record[1] - 1] = MD; 1583 1584 if (DeserializationListener) 1585 DeserializationListener->MacroDefinitionRead(Record[1], MD); 1586 } 1587 1588 return MacroDefinitionsLoaded[Record[1] - 1]; 1589 } 1590 1591 case PPD_INCLUSION_DIRECTIVE: { 1592 if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0])) 1593 return PE; 1594 1595 const char *FullFileNameStart = BlobStart + Record[3]; 1596 const FileEntry *File 1597 = PP->getFileManager().getFile(llvm::StringRef(FullFileNameStart, 1598 BlobLen - Record[3])); 1599 1600 // FIXME: Stable encoding 1601 InclusionDirective::InclusionKind Kind 1602 = static_cast<InclusionDirective::InclusionKind>(Record[5]); 1603 InclusionDirective *ID 1604 = new (PPRec) InclusionDirective(PPRec, Kind, 1605 llvm::StringRef(BlobStart, Record[3]), 1606 Record[4], 1607 File, 1608 SourceRange(ReadSourceLocation(F, Record[1]), 1609 ReadSourceLocation(F, Record[2]))); 1610 PPRec.SetPreallocatedEntity(Record[0], ID); 1611 return ID; 1612 } 1613 } 1614 1615 Error("invalid offset in preprocessor detail block"); 1616 return 0; 1617} 1618 1619namespace { 1620 /// \brief Trait class used to search the on-disk hash table containing all of 1621 /// the header search information. 1622 /// 1623 /// The on-disk hash table contains a mapping from each header path to 1624 /// information about that header (how many times it has been included, its 1625 /// controlling macro, etc.). Note that we actually hash based on the 1626 /// filename, and support "deep" comparisons of file names based on current 1627 /// inode numbers, so that the search can cope with non-normalized path names 1628 /// and symlinks. 1629 class HeaderFileInfoTrait { 1630 const char *SearchPath; 1631 struct stat SearchPathStatBuf; 1632 llvm::Optional<int> SearchPathStatResult; 1633 1634 int StatSimpleCache(const char *Path, struct stat *StatBuf) { 1635 if (Path == SearchPath) { 1636 if (!SearchPathStatResult) 1637 SearchPathStatResult = stat(Path, &SearchPathStatBuf); 1638 1639 *StatBuf = SearchPathStatBuf; 1640 return *SearchPathStatResult; 1641 } 1642 1643 return stat(Path, StatBuf); 1644 } 1645 1646 public: 1647 typedef const char *external_key_type; 1648 typedef const char *internal_key_type; 1649 1650 typedef HeaderFileInfo data_type; 1651 1652 HeaderFileInfoTrait(const char *SearchPath = 0) : SearchPath(SearchPath) { } 1653 1654 static unsigned ComputeHash(const char *path) { 1655 return llvm::HashString(llvm::sys::path::filename(path)); 1656 } 1657 1658 static internal_key_type GetInternalKey(const char *path) { return path; } 1659 1660 bool EqualKey(internal_key_type a, internal_key_type b) { 1661 if (strcmp(a, b) == 0) 1662 return true; 1663 1664 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b)) 1665 return false; 1666 1667 // The file names match, but the path names don't. stat() the files to 1668 // see if they are the same. 1669 struct stat StatBufA, StatBufB; 1670 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB)) 1671 return false; 1672 1673 return StatBufA.st_ino == StatBufB.st_ino; 1674 } 1675 1676 static std::pair<unsigned, unsigned> 1677 ReadKeyDataLength(const unsigned char*& d) { 1678 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1679 unsigned DataLen = (unsigned) *d++; 1680 return std::make_pair(KeyLen + 1, DataLen); 1681 } 1682 1683 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1684 return (const char *)d; 1685 } 1686 1687 static data_type ReadData(const internal_key_type, const unsigned char *d, 1688 unsigned DataLen) { 1689 const unsigned char *End = d + DataLen; 1690 using namespace clang::io; 1691 HeaderFileInfo HFI; 1692 unsigned Flags = *d++; 1693 HFI.isImport = (Flags >> 3) & 0x01; 1694 HFI.DirInfo = (Flags >> 1) & 0x03; 1695 HFI.Resolved = Flags & 0x01; 1696 HFI.NumIncludes = ReadUnalignedLE16(d); 1697 HFI.ControllingMacroID = ReadUnalignedLE32(d); 1698 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1699 (void)End; 1700 1701 // This HeaderFileInfo was externally loaded. 1702 HFI.External = true; 1703 return HFI; 1704 } 1705 }; 1706} 1707 1708/// \brief The on-disk hash table used for the global method pool. 1709typedef OnDiskChainedHashTable<HeaderFileInfoTrait> 1710 HeaderFileInfoLookupTable; 1711 1712void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, PerFileData &F, 1713 uint64_t Offset) { 1714 // Note that this identifier has a macro definition. 1715 II->setHasMacroDefinition(true); 1716 1717 // Adjust the offset based on our position in the chain. 1718 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1719 if (Chain[I] == &F) 1720 break; 1721 1722 Offset += Chain[I]->SizeInBits; 1723 } 1724 1725 UnreadMacroRecordOffsets[II] = Offset; 1726} 1727 1728void ASTReader::ReadDefinedMacros() { 1729 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1730 PerFileData &F = *Chain[N - I - 1]; 1731 llvm::BitstreamCursor &MacroCursor = F.MacroCursor; 1732 1733 // If there was no preprocessor block, skip this file. 1734 if (!MacroCursor.getBitStreamReader()) 1735 continue; 1736 1737 llvm::BitstreamCursor Cursor = MacroCursor; 1738 Cursor.JumpToBit(F.MacroStartOffset); 1739 1740 RecordData Record; 1741 while (true) { 1742 unsigned Code = Cursor.ReadCode(); 1743 if (Code == llvm::bitc::END_BLOCK) 1744 break; 1745 1746 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1747 // No known subblocks, always skip them. 1748 Cursor.ReadSubBlockID(); 1749 if (Cursor.SkipBlock()) { 1750 Error("malformed block record in AST file"); 1751 return; 1752 } 1753 continue; 1754 } 1755 1756 if (Code == llvm::bitc::DEFINE_ABBREV) { 1757 Cursor.ReadAbbrevRecord(); 1758 continue; 1759 } 1760 1761 // Read a record. 1762 const char *BlobStart; 1763 unsigned BlobLen; 1764 Record.clear(); 1765 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1766 default: // Default behavior: ignore. 1767 break; 1768 1769 case PP_MACRO_OBJECT_LIKE: 1770 case PP_MACRO_FUNCTION_LIKE: 1771 DecodeIdentifierInfo(Record[0]); 1772 break; 1773 1774 case PP_TOKEN: 1775 // Ignore tokens. 1776 break; 1777 } 1778 } 1779 } 1780 1781 // Drain the unread macro-record offsets map. 1782 while (!UnreadMacroRecordOffsets.empty()) 1783 LoadMacroDefinition(UnreadMacroRecordOffsets.begin()); 1784} 1785 1786void ASTReader::LoadMacroDefinition( 1787 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) { 1788 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition"); 1789 PerFileData *F = 0; 1790 uint64_t Offset = Pos->second; 1791 UnreadMacroRecordOffsets.erase(Pos); 1792 1793 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1794 if (Offset < Chain[I]->SizeInBits) { 1795 F = Chain[I]; 1796 break; 1797 } 1798 1799 Offset -= Chain[I]->SizeInBits; 1800 } 1801 if (!F) { 1802 Error("Malformed macro record offset"); 1803 return; 1804 } 1805 1806 ReadMacroRecord(*F, Offset); 1807} 1808 1809void ASTReader::LoadMacroDefinition(IdentifierInfo *II) { 1810 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos 1811 = UnreadMacroRecordOffsets.find(II); 1812 LoadMacroDefinition(Pos); 1813} 1814 1815MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) { 1816 if (ID == 0 || ID > MacroDefinitionsLoaded.size()) 1817 return 0; 1818 1819 if (!MacroDefinitionsLoaded[ID - 1]) { 1820 unsigned Index = ID - 1; 1821 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 1822 PerFileData &F = *Chain[N - I - 1]; 1823 if (Index < F.LocalNumMacroDefinitions) { 1824 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor); 1825 F.PreprocessorDetailCursor.JumpToBit(F.MacroDefinitionOffsets[Index]); 1826 LoadPreprocessedEntity(F); 1827 break; 1828 } 1829 Index -= F.LocalNumMacroDefinitions; 1830 } 1831 assert(MacroDefinitionsLoaded[ID - 1] && "Broken chain"); 1832 } 1833 1834 return MacroDefinitionsLoaded[ID - 1]; 1835} 1836 1837/// \brief If we are loading a relocatable PCH file, and the filename is 1838/// not an absolute path, add the system root to the beginning of the file 1839/// name. 1840void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 1841 // If this is not a relocatable PCH file, there's nothing to do. 1842 if (!RelocatablePCH) 1843 return; 1844 1845 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1846 return; 1847 1848 if (isysroot == 0) { 1849 // If no system root was given, default to '/' 1850 Filename.insert(Filename.begin(), '/'); 1851 return; 1852 } 1853 1854 unsigned Length = strlen(isysroot); 1855 if (isysroot[Length - 1] != '/') 1856 Filename.insert(Filename.begin(), '/'); 1857 1858 Filename.insert(Filename.begin(), isysroot, isysroot + Length); 1859} 1860 1861ASTReader::ASTReadResult 1862ASTReader::ReadASTBlock(PerFileData &F) { 1863 llvm::BitstreamCursor &Stream = F.Stream; 1864 1865 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1866 Error("malformed block record in AST file"); 1867 return Failure; 1868 } 1869 1870 // Read all of the records and blocks for the ASt file. 1871 RecordData Record; 1872 bool First = true; 1873 while (!Stream.AtEndOfStream()) { 1874 unsigned Code = Stream.ReadCode(); 1875 if (Code == llvm::bitc::END_BLOCK) { 1876 if (Stream.ReadBlockEnd()) { 1877 Error("error at end of module block in AST file"); 1878 return Failure; 1879 } 1880 1881 return Success; 1882 } 1883 1884 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1885 switch (Stream.ReadSubBlockID()) { 1886 case DECLTYPES_BLOCK_ID: 1887 // We lazily load the decls block, but we want to set up the 1888 // DeclsCursor cursor to point into it. Clone our current bitcode 1889 // cursor to it, enter the block and read the abbrevs in that block. 1890 // With the main cursor, we just skip over it. 1891 F.DeclsCursor = Stream; 1892 if (Stream.SkipBlock() || // Skip with the main cursor. 1893 // Read the abbrevs. 1894 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1895 Error("malformed block record in AST file"); 1896 return Failure; 1897 } 1898 break; 1899 1900 case DECL_UPDATES_BLOCK_ID: 1901 if (Stream.SkipBlock()) { 1902 Error("malformed block record in AST file"); 1903 return Failure; 1904 } 1905 break; 1906 1907 case PREPROCESSOR_BLOCK_ID: 1908 F.MacroCursor = Stream; 1909 if (PP) 1910 PP->setExternalSource(this); 1911 1912 if (Stream.SkipBlock() || 1913 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1914 Error("malformed block record in AST file"); 1915 return Failure; 1916 } 1917 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1918 break; 1919 1920 case PREPROCESSOR_DETAIL_BLOCK_ID: 1921 F.PreprocessorDetailCursor = Stream; 1922 if (Stream.SkipBlock() || 1923 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 1924 PREPROCESSOR_DETAIL_BLOCK_ID)) { 1925 Error("malformed preprocessor detail record in AST file"); 1926 return Failure; 1927 } 1928 F.PreprocessorDetailStartOffset 1929 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 1930 break; 1931 1932 case SOURCE_MANAGER_BLOCK_ID: 1933 switch (ReadSourceManagerBlock(F)) { 1934 case Success: 1935 break; 1936 1937 case Failure: 1938 Error("malformed source manager block in AST file"); 1939 return Failure; 1940 1941 case IgnorePCH: 1942 return IgnorePCH; 1943 } 1944 break; 1945 } 1946 First = false; 1947 continue; 1948 } 1949 1950 if (Code == llvm::bitc::DEFINE_ABBREV) { 1951 Stream.ReadAbbrevRecord(); 1952 continue; 1953 } 1954 1955 // Read and process a record. 1956 Record.clear(); 1957 const char *BlobStart = 0; 1958 unsigned BlobLen = 0; 1959 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 1960 &BlobStart, &BlobLen)) { 1961 default: // Default behavior: ignore. 1962 break; 1963 1964 case METADATA: { 1965 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1966 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1967 : diag::warn_pch_version_too_new); 1968 return IgnorePCH; 1969 } 1970 1971 RelocatablePCH = Record[4]; 1972 if (Listener) { 1973 std::string TargetTriple(BlobStart, BlobLen); 1974 if (Listener->ReadTargetTriple(TargetTriple)) 1975 return IgnorePCH; 1976 } 1977 break; 1978 } 1979 1980 case CHAINED_METADATA: { 1981 if (!First) { 1982 Error("CHAINED_METADATA is not first record in block"); 1983 return Failure; 1984 } 1985 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1986 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1987 : diag::warn_pch_version_too_new); 1988 return IgnorePCH; 1989 } 1990 1991 // Load the chained file, which is always a PCH file. 1992 switch(ReadASTCore(llvm::StringRef(BlobStart, BlobLen), PCH)) { 1993 case Failure: return Failure; 1994 // If we have to ignore the dependency, we'll have to ignore this too. 1995 case IgnorePCH: return IgnorePCH; 1996 case Success: break; 1997 } 1998 break; 1999 } 2000 2001 case TYPE_OFFSET: 2002 if (F.LocalNumTypes != 0) { 2003 Error("duplicate TYPE_OFFSET record in AST file"); 2004 return Failure; 2005 } 2006 F.TypeOffsets = (const uint32_t *)BlobStart; 2007 F.LocalNumTypes = Record[0]; 2008 break; 2009 2010 case DECL_OFFSET: 2011 if (F.LocalNumDecls != 0) { 2012 Error("duplicate DECL_OFFSET record in AST file"); 2013 return Failure; 2014 } 2015 F.DeclOffsets = (const uint32_t *)BlobStart; 2016 F.LocalNumDecls = Record[0]; 2017 break; 2018 2019 case TU_UPDATE_LEXICAL: { 2020 DeclContextInfo Info = { 2021 /* No visible information */ 0, 2022 reinterpret_cast<const KindDeclIDPair *>(BlobStart), 2023 BlobLen / sizeof(KindDeclIDPair) 2024 }; 2025 DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0] 2026 .push_back(Info); 2027 break; 2028 } 2029 2030 case UPDATE_VISIBLE: { 2031 serialization::DeclID ID = Record[0]; 2032 void *Table = ASTDeclContextNameLookupTable::Create( 2033 (const unsigned char *)BlobStart + Record[1], 2034 (const unsigned char *)BlobStart, 2035 ASTDeclContextNameLookupTrait(*this)); 2036 if (ID == 1 && Context) { // Is it the TU? 2037 DeclContextInfo Info = { 2038 Table, /* No lexical inforamtion */ 0, 0 2039 }; 2040 DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info); 2041 } else 2042 PendingVisibleUpdates[ID].push_back(Table); 2043 break; 2044 } 2045 2046 case REDECLS_UPDATE_LATEST: { 2047 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 2048 for (unsigned i = 0, e = Record.size(); i < e; i += 2) { 2049 DeclID First = Record[i], Latest = Record[i+1]; 2050 assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() || 2051 Latest > FirstLatestDeclIDs[First]) && 2052 "The new latest is supposed to come after the previous latest"); 2053 FirstLatestDeclIDs[First] = Latest; 2054 } 2055 break; 2056 } 2057 2058 case LANGUAGE_OPTIONS: 2059 if (ParseLanguageOptions(Record) && !DisableValidation) 2060 return IgnorePCH; 2061 break; 2062 2063 case IDENTIFIER_TABLE: 2064 F.IdentifierTableData = BlobStart; 2065 if (Record[0]) { 2066 F.IdentifierLookupTable 2067 = ASTIdentifierLookupTable::Create( 2068 (const unsigned char *)F.IdentifierTableData + Record[0], 2069 (const unsigned char *)F.IdentifierTableData, 2070 ASTIdentifierLookupTrait(*this, F)); 2071 if (PP) 2072 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2073 } 2074 break; 2075 2076 case IDENTIFIER_OFFSET: 2077 if (F.LocalNumIdentifiers != 0) { 2078 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2079 return Failure; 2080 } 2081 F.IdentifierOffsets = (const uint32_t *)BlobStart; 2082 F.LocalNumIdentifiers = Record[0]; 2083 break; 2084 2085 case EXTERNAL_DEFINITIONS: 2086 // Optimization for the first block. 2087 if (ExternalDefinitions.empty()) 2088 ExternalDefinitions.swap(Record); 2089 else 2090 ExternalDefinitions.insert(ExternalDefinitions.end(), 2091 Record.begin(), Record.end()); 2092 break; 2093 2094 case SPECIAL_TYPES: 2095 // Optimization for the first block 2096 if (SpecialTypes.empty()) 2097 SpecialTypes.swap(Record); 2098 else 2099 SpecialTypes.insert(SpecialTypes.end(), Record.begin(), Record.end()); 2100 break; 2101 2102 case STATISTICS: 2103 TotalNumStatements += Record[0]; 2104 TotalNumMacros += Record[1]; 2105 TotalLexicalDeclContexts += Record[2]; 2106 TotalVisibleDeclContexts += Record[3]; 2107 break; 2108 2109 case TENTATIVE_DEFINITIONS: 2110 // Optimization for the first block. 2111 if (TentativeDefinitions.empty()) 2112 TentativeDefinitions.swap(Record); 2113 else 2114 TentativeDefinitions.insert(TentativeDefinitions.end(), 2115 Record.begin(), Record.end()); 2116 break; 2117 2118 case UNUSED_FILESCOPED_DECLS: 2119 // Optimization for the first block. 2120 if (UnusedFileScopedDecls.empty()) 2121 UnusedFileScopedDecls.swap(Record); 2122 else 2123 UnusedFileScopedDecls.insert(UnusedFileScopedDecls.end(), 2124 Record.begin(), Record.end()); 2125 break; 2126 2127 case WEAK_UNDECLARED_IDENTIFIERS: 2128 // Later blocks overwrite earlier ones. 2129 WeakUndeclaredIdentifiers.swap(Record); 2130 break; 2131 2132 case LOCALLY_SCOPED_EXTERNAL_DECLS: 2133 // Optimization for the first block. 2134 if (LocallyScopedExternalDecls.empty()) 2135 LocallyScopedExternalDecls.swap(Record); 2136 else 2137 LocallyScopedExternalDecls.insert(LocallyScopedExternalDecls.end(), 2138 Record.begin(), Record.end()); 2139 break; 2140 2141 case SELECTOR_OFFSETS: 2142 F.SelectorOffsets = (const uint32_t *)BlobStart; 2143 F.LocalNumSelectors = Record[0]; 2144 break; 2145 2146 case METHOD_POOL: 2147 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 2148 if (Record[0]) 2149 F.SelectorLookupTable 2150 = ASTSelectorLookupTable::Create( 2151 F.SelectorLookupTableData + Record[0], 2152 F.SelectorLookupTableData, 2153 ASTSelectorLookupTrait(*this)); 2154 TotalNumMethodPoolEntries += Record[1]; 2155 break; 2156 2157 case REFERENCED_SELECTOR_POOL: 2158 F.ReferencedSelectorsData.swap(Record); 2159 break; 2160 2161 case PP_COUNTER_VALUE: 2162 if (!Record.empty() && Listener) 2163 Listener->ReadCounter(Record[0]); 2164 break; 2165 2166 case SOURCE_LOCATION_OFFSETS: 2167 F.SLocOffsets = (const uint32_t *)BlobStart; 2168 F.LocalNumSLocEntries = Record[0]; 2169 F.LocalSLocSize = Record[1]; 2170 break; 2171 2172 case SOURCE_LOCATION_PRELOADS: 2173 if (PreloadSLocEntries.empty()) 2174 PreloadSLocEntries.swap(Record); 2175 else 2176 PreloadSLocEntries.insert(PreloadSLocEntries.end(), 2177 Record.begin(), Record.end()); 2178 break; 2179 2180 case STAT_CACHE: { 2181 if (!DisableStatCache) { 2182 ASTStatCache *MyStatCache = 2183 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2184 (const unsigned char *)BlobStart, 2185 NumStatHits, NumStatMisses); 2186 FileMgr.addStatCache(MyStatCache); 2187 F.StatCache = MyStatCache; 2188 } 2189 break; 2190 } 2191 2192 case EXT_VECTOR_DECLS: 2193 // Optimization for the first block. 2194 if (ExtVectorDecls.empty()) 2195 ExtVectorDecls.swap(Record); 2196 else 2197 ExtVectorDecls.insert(ExtVectorDecls.end(), 2198 Record.begin(), Record.end()); 2199 break; 2200 2201 case VTABLE_USES: 2202 // Later tables overwrite earlier ones. 2203 VTableUses.swap(Record); 2204 break; 2205 2206 case DYNAMIC_CLASSES: 2207 // Optimization for the first block. 2208 if (DynamicClasses.empty()) 2209 DynamicClasses.swap(Record); 2210 else 2211 DynamicClasses.insert(DynamicClasses.end(), 2212 Record.begin(), Record.end()); 2213 break; 2214 2215 case PENDING_IMPLICIT_INSTANTIATIONS: 2216 F.PendingInstantiations.swap(Record); 2217 break; 2218 2219 case SEMA_DECL_REFS: 2220 // Later tables overwrite earlier ones. 2221 SemaDeclRefs.swap(Record); 2222 break; 2223 2224 case ORIGINAL_FILE_NAME: 2225 // The primary AST will be the last to get here, so it will be the one 2226 // that's used. 2227 ActualOriginalFileName.assign(BlobStart, BlobLen); 2228 OriginalFileName = ActualOriginalFileName; 2229 MaybeAddSystemRootToFilename(OriginalFileName); 2230 break; 2231 2232 case ORIGINAL_PCH_DIR: 2233 // The primary AST will be the last to get here, so it will be the one 2234 // that's used. 2235 OriginalDir.assign(BlobStart, BlobLen); 2236 break; 2237 2238 case VERSION_CONTROL_BRANCH_REVISION: { 2239 const std::string &CurBranch = getClangFullRepositoryVersion(); 2240 llvm::StringRef ASTBranch(BlobStart, BlobLen); 2241 if (llvm::StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2242 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2243 return IgnorePCH; 2244 } 2245 break; 2246 } 2247 2248 case MACRO_DEFINITION_OFFSETS: 2249 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart; 2250 F.NumPreallocatedPreprocessingEntities = Record[0]; 2251 F.LocalNumMacroDefinitions = Record[1]; 2252 break; 2253 2254 case DECL_UPDATE_OFFSETS: { 2255 if (Record.size() % 2 != 0) { 2256 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2257 return Failure; 2258 } 2259 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2260 DeclUpdateOffsets[static_cast<DeclID>(Record[I])] 2261 .push_back(std::make_pair(&F, Record[I+1])); 2262 break; 2263 } 2264 2265 case DECL_REPLACEMENTS: { 2266 if (Record.size() % 2 != 0) { 2267 Error("invalid DECL_REPLACEMENTS block in AST file"); 2268 return Failure; 2269 } 2270 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2271 ReplacedDecls[static_cast<DeclID>(Record[I])] = 2272 std::make_pair(&F, Record[I+1]); 2273 break; 2274 } 2275 2276 case CXX_BASE_SPECIFIER_OFFSETS: { 2277 if (F.LocalNumCXXBaseSpecifiers != 0) { 2278 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2279 return Failure; 2280 } 2281 2282 F.LocalNumCXXBaseSpecifiers = Record[0]; 2283 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2284 break; 2285 } 2286 2287 case DIAG_PRAGMA_MAPPINGS: 2288 if (Record.size() % 2 != 0) { 2289 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2290 return Failure; 2291 } 2292 if (PragmaDiagMappings.empty()) 2293 PragmaDiagMappings.swap(Record); 2294 else 2295 PragmaDiagMappings.insert(PragmaDiagMappings.end(), 2296 Record.begin(), Record.end()); 2297 break; 2298 2299 case CUDA_SPECIAL_DECL_REFS: 2300 // Later tables overwrite earlier ones. 2301 CUDASpecialDeclRefs.swap(Record); 2302 break; 2303 2304 case HEADER_SEARCH_TABLE: 2305 F.HeaderFileInfoTableData = BlobStart; 2306 F.LocalNumHeaderFileInfos = Record[1]; 2307 if (Record[0]) { 2308 F.HeaderFileInfoTable 2309 = HeaderFileInfoLookupTable::Create( 2310 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2311 (const unsigned char *)F.HeaderFileInfoTableData); 2312 if (PP) 2313 PP->getHeaderSearchInfo().SetExternalSource(this); 2314 } 2315 break; 2316 2317 case FP_PRAGMA_OPTIONS: 2318 // Later tables overwrite earlier ones. 2319 FPPragmaOptions.swap(Record); 2320 break; 2321 2322 case OPENCL_EXTENSIONS: 2323 // Later tables overwrite earlier ones. 2324 OpenCLExtensions.swap(Record); 2325 break; 2326 } 2327 First = false; 2328 } 2329 Error("premature end of bitstream in AST file"); 2330 return Failure; 2331} 2332 2333ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2334 ASTFileType Type) { 2335 switch(ReadASTCore(FileName, Type)) { 2336 case Failure: return Failure; 2337 case IgnorePCH: return IgnorePCH; 2338 case Success: break; 2339 } 2340 2341 // Here comes stuff that we only do once the entire chain is loaded. 2342 2343 // Allocate space for loaded slocentries, identifiers, decls and types. 2344 unsigned TotalNumIdentifiers = 0, TotalNumTypes = 0, TotalNumDecls = 0, 2345 TotalNumPreallocatedPreprocessingEntities = 0, TotalNumMacroDefs = 0, 2346 TotalNumSelectors = 0; 2347 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2348 TotalNumSLocEntries += Chain[I]->LocalNumSLocEntries; 2349 NextSLocOffset += Chain[I]->LocalSLocSize; 2350 TotalNumIdentifiers += Chain[I]->LocalNumIdentifiers; 2351 TotalNumTypes += Chain[I]->LocalNumTypes; 2352 TotalNumDecls += Chain[I]->LocalNumDecls; 2353 TotalNumPreallocatedPreprocessingEntities += 2354 Chain[I]->NumPreallocatedPreprocessingEntities; 2355 TotalNumMacroDefs += Chain[I]->LocalNumMacroDefinitions; 2356 TotalNumSelectors += Chain[I]->LocalNumSelectors; 2357 } 2358 SourceMgr.PreallocateSLocEntries(this, TotalNumSLocEntries, NextSLocOffset); 2359 IdentifiersLoaded.resize(TotalNumIdentifiers); 2360 TypesLoaded.resize(TotalNumTypes); 2361 DeclsLoaded.resize(TotalNumDecls); 2362 MacroDefinitionsLoaded.resize(TotalNumMacroDefs); 2363 if (PP) { 2364 if (TotalNumIdentifiers > 0) 2365 PP->getHeaderSearchInfo().SetExternalLookup(this); 2366 if (TotalNumPreallocatedPreprocessingEntities > 0) { 2367 if (!PP->getPreprocessingRecord()) 2368 PP->createPreprocessingRecord(); 2369 PP->getPreprocessingRecord()->SetExternalSource(*this, 2370 TotalNumPreallocatedPreprocessingEntities); 2371 } 2372 } 2373 SelectorsLoaded.resize(TotalNumSelectors); 2374 // Preload SLocEntries. 2375 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) { 2376 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]); 2377 if (Result != Success) 2378 return Result; 2379 } 2380 2381 // Check the predefines buffers. 2382 if (!DisableValidation && CheckPredefinesBuffers()) 2383 return IgnorePCH; 2384 2385 if (PP) { 2386 // Initialization of keywords and pragmas occurs before the 2387 // AST file is read, so there may be some identifiers that were 2388 // loaded into the IdentifierTable before we intercepted the 2389 // creation of identifiers. Iterate through the list of known 2390 // identifiers and determine whether we have to establish 2391 // preprocessor definitions or top-level identifier declaration 2392 // chains for those identifiers. 2393 // 2394 // We copy the IdentifierInfo pointers to a small vector first, 2395 // since de-serializing declarations or macro definitions can add 2396 // new entries into the identifier table, invalidating the 2397 // iterators. 2398 llvm::SmallVector<IdentifierInfo *, 128> Identifiers; 2399 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 2400 IdEnd = PP->getIdentifierTable().end(); 2401 Id != IdEnd; ++Id) 2402 Identifiers.push_back(Id->second); 2403 // We need to search the tables in all files. 2404 for (unsigned J = 0, M = Chain.size(); J != M; ++J) { 2405 ASTIdentifierLookupTable *IdTable 2406 = (ASTIdentifierLookupTable *)Chain[J]->IdentifierLookupTable; 2407 // Not all AST files necessarily have identifier tables, only the useful 2408 // ones. 2409 if (!IdTable) 2410 continue; 2411 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2412 IdentifierInfo *II = Identifiers[I]; 2413 // Look in the on-disk hash tables for an entry for this identifier 2414 ASTIdentifierLookupTrait Info(*this, *Chain[J], II); 2415 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 2416 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 2417 if (Pos == IdTable->end()) 2418 continue; 2419 2420 // Dereferencing the iterator has the effect of populating the 2421 // IdentifierInfo node with the various declarations it needs. 2422 (void)*Pos; 2423 } 2424 } 2425 } 2426 2427 if (Context) 2428 InitializeContext(*Context); 2429 2430 if (DeserializationListener) 2431 DeserializationListener->ReaderInitialized(this); 2432 2433 // If this AST file is a precompiled preamble, then set the main file ID of 2434 // the source manager to the file source file from which the preamble was 2435 // built. This is the only valid way to use a precompiled preamble. 2436 if (Type == Preamble) { 2437 SourceLocation Loc 2438 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1); 2439 if (Loc.isValid()) { 2440 std::pair<FileID, unsigned> Decomposed = SourceMgr.getDecomposedLoc(Loc); 2441 SourceMgr.SetPreambleFileID(Decomposed.first); 2442 } 2443 } 2444 2445 return Success; 2446} 2447 2448ASTReader::ASTReadResult ASTReader::ReadASTCore(llvm::StringRef FileName, 2449 ASTFileType Type) { 2450 PerFileData *Prev = Chain.empty() ? 0 : Chain.back(); 2451 Chain.push_back(new PerFileData(Type)); 2452 PerFileData &F = *Chain.back(); 2453 if (Prev) 2454 Prev->NextInSource = &F; 2455 else 2456 FirstInSource = &F; 2457 F.Loaders.push_back(Prev); 2458 2459 // Set the AST file name. 2460 F.FileName = FileName; 2461 2462 if (FileName != "-") { 2463 CurrentDir = llvm::sys::path::parent_path(FileName); 2464 if (CurrentDir.empty()) CurrentDir = "."; 2465 } 2466 2467 if (!ASTBuffers.empty()) { 2468 F.Buffer.reset(ASTBuffers.back()); 2469 ASTBuffers.pop_back(); 2470 assert(F.Buffer && "Passed null buffer"); 2471 } else { 2472 // Open the AST file. 2473 // 2474 // FIXME: This shouldn't be here, we should just take a raw_ostream. 2475 std::string ErrStr; 2476 llvm::error_code ec; 2477 if (FileName == "-") { 2478 ec = llvm::MemoryBuffer::getSTDIN(F.Buffer); 2479 if (ec) 2480 ErrStr = ec.message(); 2481 } else 2482 F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr)); 2483 if (!F.Buffer) { 2484 Error(ErrStr.c_str()); 2485 return IgnorePCH; 2486 } 2487 } 2488 2489 // Initialize the stream 2490 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2491 (const unsigned char *)F.Buffer->getBufferEnd()); 2492 llvm::BitstreamCursor &Stream = F.Stream; 2493 Stream.init(F.StreamFile); 2494 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2495 2496 // Sniff for the signature. 2497 if (Stream.Read(8) != 'C' || 2498 Stream.Read(8) != 'P' || 2499 Stream.Read(8) != 'C' || 2500 Stream.Read(8) != 'H') { 2501 Diag(diag::err_not_a_pch_file) << FileName; 2502 return Failure; 2503 } 2504 2505 while (!Stream.AtEndOfStream()) { 2506 unsigned Code = Stream.ReadCode(); 2507 2508 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2509 Error("invalid record at top-level of AST file"); 2510 return Failure; 2511 } 2512 2513 unsigned BlockID = Stream.ReadSubBlockID(); 2514 2515 // We only know the AST subblock ID. 2516 switch (BlockID) { 2517 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2518 if (Stream.ReadBlockInfoBlock()) { 2519 Error("malformed BlockInfoBlock in AST file"); 2520 return Failure; 2521 } 2522 break; 2523 case AST_BLOCK_ID: 2524 switch (ReadASTBlock(F)) { 2525 case Success: 2526 break; 2527 2528 case Failure: 2529 return Failure; 2530 2531 case IgnorePCH: 2532 // FIXME: We could consider reading through to the end of this 2533 // AST block, skipping subblocks, to see if there are other 2534 // AST blocks elsewhere. 2535 2536 // Clear out any preallocated source location entries, so that 2537 // the source manager does not try to resolve them later. 2538 SourceMgr.ClearPreallocatedSLocEntries(); 2539 2540 // Remove the stat cache. 2541 if (F.StatCache) 2542 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2543 2544 return IgnorePCH; 2545 } 2546 break; 2547 default: 2548 if (Stream.SkipBlock()) { 2549 Error("malformed block record in AST file"); 2550 return Failure; 2551 } 2552 break; 2553 } 2554 } 2555 2556 return Success; 2557} 2558 2559void ASTReader::setPreprocessor(Preprocessor &pp) { 2560 PP = &pp; 2561 2562 unsigned TotalNum = 0; 2563 for (unsigned I = 0, N = Chain.size(); I != N; ++I) 2564 TotalNum += Chain[I]->NumPreallocatedPreprocessingEntities; 2565 if (TotalNum) { 2566 if (!PP->getPreprocessingRecord()) 2567 PP->createPreprocessingRecord(); 2568 PP->getPreprocessingRecord()->SetExternalSource(*this, TotalNum); 2569 } 2570} 2571 2572void ASTReader::InitializeContext(ASTContext &Ctx) { 2573 Context = &Ctx; 2574 assert(Context && "Passed null context!"); 2575 2576 assert(PP && "Forgot to set Preprocessor ?"); 2577 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2578 PP->getHeaderSearchInfo().SetExternalLookup(this); 2579 PP->setExternalSource(this); 2580 PP->getHeaderSearchInfo().SetExternalSource(this); 2581 2582 // If we have an update block for the TU waiting, we have to add it before 2583 // deserializing the decl. 2584 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2585 if (DCU != DeclContextOffsets.end()) { 2586 // Insertion could invalidate map, so grab vector. 2587 DeclContextInfos T; 2588 T.swap(DCU->second); 2589 DeclContextOffsets.erase(DCU); 2590 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T); 2591 } 2592 2593 // Load the translation unit declaration 2594 GetTranslationUnitDecl(); 2595 2596 // Load the special types. 2597 Context->setBuiltinVaListType( 2598 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2599 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 2600 Context->setObjCIdType(GetType(Id)); 2601 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 2602 Context->setObjCSelType(GetType(Sel)); 2603 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 2604 Context->setObjCProtoType(GetType(Proto)); 2605 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 2606 Context->setObjCClassType(GetType(Class)); 2607 2608 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 2609 Context->setCFConstantStringType(GetType(String)); 2610 if (unsigned FastEnum 2611 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 2612 Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 2613 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2614 QualType FileType = GetType(File); 2615 if (FileType.isNull()) { 2616 Error("FILE type is NULL"); 2617 return; 2618 } 2619 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2620 Context->setFILEDecl(Typedef->getDecl()); 2621 else { 2622 const TagType *Tag = FileType->getAs<TagType>(); 2623 if (!Tag) { 2624 Error("Invalid FILE type in AST file"); 2625 return; 2626 } 2627 Context->setFILEDecl(Tag->getDecl()); 2628 } 2629 } 2630 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2631 QualType Jmp_bufType = GetType(Jmp_buf); 2632 if (Jmp_bufType.isNull()) { 2633 Error("jmp_bug type is NULL"); 2634 return; 2635 } 2636 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2637 Context->setjmp_bufDecl(Typedef->getDecl()); 2638 else { 2639 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2640 if (!Tag) { 2641 Error("Invalid jmp_buf type in AST file"); 2642 return; 2643 } 2644 Context->setjmp_bufDecl(Tag->getDecl()); 2645 } 2646 } 2647 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2648 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2649 if (Sigjmp_bufType.isNull()) { 2650 Error("sigjmp_buf type is NULL"); 2651 return; 2652 } 2653 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2654 Context->setsigjmp_bufDecl(Typedef->getDecl()); 2655 else { 2656 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2657 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2658 Context->setsigjmp_bufDecl(Tag->getDecl()); 2659 } 2660 } 2661 if (unsigned ObjCIdRedef 2662 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 2663 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2664 if (unsigned ObjCClassRedef 2665 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 2666 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2667 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 2668 Context->setBlockDescriptorType(GetType(String)); 2669 if (unsigned String 2670 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 2671 Context->setBlockDescriptorExtendedType(GetType(String)); 2672 if (unsigned ObjCSelRedef 2673 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 2674 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2675 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 2676 Context->setNSConstantStringType(GetType(String)); 2677 2678 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 2679 Context->setInt128Installed(); 2680 2681 if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT]) 2682 Context->AutoDeductTy = GetType(AutoDeduct); 2683 if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT]) 2684 Context->AutoRRefDeductTy = GetType(AutoRRefDeduct); 2685 2686 ReadPragmaDiagnosticMappings(Context->getDiagnostics()); 2687 2688 // If there were any CUDA special declarations, deserialize them. 2689 if (!CUDASpecialDeclRefs.empty()) { 2690 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 2691 Context->setcudaConfigureCallDecl( 2692 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 2693 } 2694} 2695 2696/// \brief Retrieve the name of the original source file name 2697/// directly from the AST file, without actually loading the AST 2698/// file. 2699std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2700 FileManager &FileMgr, 2701 Diagnostic &Diags) { 2702 // Open the AST file. 2703 std::string ErrStr; 2704 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2705 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 2706 if (!Buffer) { 2707 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2708 return std::string(); 2709 } 2710 2711 // Initialize the stream 2712 llvm::BitstreamReader StreamFile; 2713 llvm::BitstreamCursor Stream; 2714 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2715 (const unsigned char *)Buffer->getBufferEnd()); 2716 Stream.init(StreamFile); 2717 2718 // Sniff for the signature. 2719 if (Stream.Read(8) != 'C' || 2720 Stream.Read(8) != 'P' || 2721 Stream.Read(8) != 'C' || 2722 Stream.Read(8) != 'H') { 2723 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2724 return std::string(); 2725 } 2726 2727 RecordData Record; 2728 while (!Stream.AtEndOfStream()) { 2729 unsigned Code = Stream.ReadCode(); 2730 2731 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2732 unsigned BlockID = Stream.ReadSubBlockID(); 2733 2734 // We only know the AST subblock ID. 2735 switch (BlockID) { 2736 case AST_BLOCK_ID: 2737 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2738 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2739 return std::string(); 2740 } 2741 break; 2742 2743 default: 2744 if (Stream.SkipBlock()) { 2745 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2746 return std::string(); 2747 } 2748 break; 2749 } 2750 continue; 2751 } 2752 2753 if (Code == llvm::bitc::END_BLOCK) { 2754 if (Stream.ReadBlockEnd()) { 2755 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2756 return std::string(); 2757 } 2758 continue; 2759 } 2760 2761 if (Code == llvm::bitc::DEFINE_ABBREV) { 2762 Stream.ReadAbbrevRecord(); 2763 continue; 2764 } 2765 2766 Record.clear(); 2767 const char *BlobStart = 0; 2768 unsigned BlobLen = 0; 2769 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 2770 == ORIGINAL_FILE_NAME) 2771 return std::string(BlobStart, BlobLen); 2772 } 2773 2774 return std::string(); 2775} 2776 2777/// \brief Parse the record that corresponds to a LangOptions data 2778/// structure. 2779/// 2780/// This routine parses the language options from the AST file and then gives 2781/// them to the AST listener if one is set. 2782/// 2783/// \returns true if the listener deems the file unacceptable, false otherwise. 2784bool ASTReader::ParseLanguageOptions( 2785 const llvm::SmallVectorImpl<uint64_t> &Record) { 2786 if (Listener) { 2787 LangOptions LangOpts; 2788 2789 #define PARSE_LANGOPT(Option) \ 2790 LangOpts.Option = Record[Idx]; \ 2791 ++Idx 2792 2793 unsigned Idx = 0; 2794 PARSE_LANGOPT(Trigraphs); 2795 PARSE_LANGOPT(BCPLComment); 2796 PARSE_LANGOPT(DollarIdents); 2797 PARSE_LANGOPT(AsmPreprocessor); 2798 PARSE_LANGOPT(GNUMode); 2799 PARSE_LANGOPT(GNUKeywords); 2800 PARSE_LANGOPT(ImplicitInt); 2801 PARSE_LANGOPT(Digraphs); 2802 PARSE_LANGOPT(HexFloats); 2803 PARSE_LANGOPT(C99); 2804 PARSE_LANGOPT(C1X); 2805 PARSE_LANGOPT(Microsoft); 2806 PARSE_LANGOPT(CPlusPlus); 2807 PARSE_LANGOPT(CPlusPlus0x); 2808 PARSE_LANGOPT(CXXOperatorNames); 2809 PARSE_LANGOPT(ObjC1); 2810 PARSE_LANGOPT(ObjC2); 2811 PARSE_LANGOPT(ObjCNonFragileABI); 2812 PARSE_LANGOPT(ObjCNonFragileABI2); 2813 PARSE_LANGOPT(AppleKext); 2814 PARSE_LANGOPT(ObjCDefaultSynthProperties); 2815 PARSE_LANGOPT(NoConstantCFStrings); 2816 PARSE_LANGOPT(PascalStrings); 2817 PARSE_LANGOPT(WritableStrings); 2818 PARSE_LANGOPT(LaxVectorConversions); 2819 PARSE_LANGOPT(AltiVec); 2820 PARSE_LANGOPT(Exceptions); 2821 PARSE_LANGOPT(ObjCExceptions); 2822 PARSE_LANGOPT(CXXExceptions); 2823 PARSE_LANGOPT(SjLjExceptions); 2824 PARSE_LANGOPT(MSBitfields); 2825 PARSE_LANGOPT(NeXTRuntime); 2826 PARSE_LANGOPT(Freestanding); 2827 PARSE_LANGOPT(NoBuiltin); 2828 PARSE_LANGOPT(ThreadsafeStatics); 2829 PARSE_LANGOPT(POSIXThreads); 2830 PARSE_LANGOPT(Blocks); 2831 PARSE_LANGOPT(EmitAllDecls); 2832 PARSE_LANGOPT(MathErrno); 2833 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 2834 Record[Idx++]); 2835 PARSE_LANGOPT(HeinousExtensions); 2836 PARSE_LANGOPT(Optimize); 2837 PARSE_LANGOPT(OptimizeSize); 2838 PARSE_LANGOPT(Static); 2839 PARSE_LANGOPT(PICLevel); 2840 PARSE_LANGOPT(GNUInline); 2841 PARSE_LANGOPT(NoInline); 2842 PARSE_LANGOPT(Deprecated); 2843 PARSE_LANGOPT(AccessControl); 2844 PARSE_LANGOPT(CharIsSigned); 2845 PARSE_LANGOPT(ShortWChar); 2846 PARSE_LANGOPT(ShortEnums); 2847 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 2848 LangOpts.setVisibilityMode((Visibility)Record[Idx++]); 2849 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 2850 Record[Idx++]); 2851 PARSE_LANGOPT(InstantiationDepth); 2852 PARSE_LANGOPT(OpenCL); 2853 PARSE_LANGOPT(CUDA); 2854 PARSE_LANGOPT(CatchUndefined); 2855 PARSE_LANGOPT(DefaultFPContract); 2856 PARSE_LANGOPT(ElideConstructors); 2857 PARSE_LANGOPT(SpellChecking); 2858 PARSE_LANGOPT(MRTD); 2859 #undef PARSE_LANGOPT 2860 2861 return Listener->ReadLanguageOptions(LangOpts); 2862 } 2863 2864 return false; 2865} 2866 2867void ASTReader::ReadPreprocessedEntities() { 2868 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2869 PerFileData &F = *Chain[I]; 2870 if (!F.PreprocessorDetailCursor.getBitStreamReader()) 2871 continue; 2872 2873 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor); 2874 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset); 2875 while (LoadPreprocessedEntity(F)) { } 2876 } 2877} 2878 2879PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) { 2880 PerFileData *F = 0; 2881 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2882 if (Offset < Chain[I]->SizeInBits) { 2883 F = Chain[I]; 2884 break; 2885 } 2886 2887 Offset -= Chain[I]->SizeInBits; 2888 } 2889 2890 if (!F) { 2891 Error("Malformed preprocessed entity offset"); 2892 return 0; 2893 } 2894 2895 // Keep track of where we are in the stream, then jump back there 2896 // after reading this entity. 2897 SavedStreamPosition SavedPosition(F->PreprocessorDetailCursor); 2898 F->PreprocessorDetailCursor.JumpToBit(Offset); 2899 return LoadPreprocessedEntity(*F); 2900} 2901 2902HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 2903 HeaderFileInfoTrait Trait(FE->getName()); 2904 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2905 PerFileData &F = *Chain[I]; 2906 HeaderFileInfoLookupTable *Table 2907 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable); 2908 if (!Table) 2909 continue; 2910 2911 // Look in the on-disk hash table for an entry for this file name. 2912 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(), 2913 &Trait); 2914 if (Pos == Table->end()) 2915 continue; 2916 2917 HeaderFileInfo HFI = *Pos; 2918 if (Listener) 2919 Listener->ReadHeaderFileInfo(HFI, FE->getUID()); 2920 2921 return HFI; 2922 } 2923 2924 return HeaderFileInfo(); 2925} 2926 2927void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) { 2928 unsigned Idx = 0; 2929 while (Idx < PragmaDiagMappings.size()) { 2930 SourceLocation 2931 Loc = SourceLocation::getFromRawEncoding(PragmaDiagMappings[Idx++]); 2932 while (1) { 2933 assert(Idx < PragmaDiagMappings.size() && 2934 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 2935 if (Idx >= PragmaDiagMappings.size()) 2936 break; // Something is messed up but at least avoid infinite loop in 2937 // release build. 2938 unsigned DiagID = PragmaDiagMappings[Idx++]; 2939 if (DiagID == (unsigned)-1) 2940 break; // no more diag/map pairs for this location. 2941 diag::Mapping Map = (diag::Mapping)PragmaDiagMappings[Idx++]; 2942 Diag.setDiagnosticMapping(DiagID, Map, Loc); 2943 } 2944 } 2945} 2946 2947/// \brief Get the correct cursor and offset for loading a type. 2948ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 2949 PerFileData *F = 0; 2950 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2951 F = Chain[N - I - 1]; 2952 if (Index < F->LocalNumTypes) 2953 break; 2954 Index -= F->LocalNumTypes; 2955 } 2956 assert(F && F->LocalNumTypes > Index && "Broken chain"); 2957 return RecordLocation(F, F->TypeOffsets[Index]); 2958} 2959 2960/// \brief Read and return the type with the given index.. 2961/// 2962/// The index is the type ID, shifted and minus the number of predefs. This 2963/// routine actually reads the record corresponding to the type at the given 2964/// location. It is a helper routine for GetType, which deals with reading type 2965/// IDs. 2966QualType ASTReader::ReadTypeRecord(unsigned Index) { 2967 RecordLocation Loc = TypeCursorForIndex(Index); 2968 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 2969 2970 // Keep track of where we are in the stream, then jump back there 2971 // after reading this type. 2972 SavedStreamPosition SavedPosition(DeclsCursor); 2973 2974 ReadingKindTracker ReadingKind(Read_Type, *this); 2975 2976 // Note that we are loading a type record. 2977 Deserializing AType(this); 2978 2979 DeclsCursor.JumpToBit(Loc.Offset); 2980 RecordData Record; 2981 unsigned Code = DeclsCursor.ReadCode(); 2982 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 2983 case TYPE_EXT_QUAL: { 2984 if (Record.size() != 2) { 2985 Error("Incorrect encoding of extended qualifier type"); 2986 return QualType(); 2987 } 2988 QualType Base = GetType(Record[0]); 2989 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]); 2990 return Context->getQualifiedType(Base, Quals); 2991 } 2992 2993 case TYPE_COMPLEX: { 2994 if (Record.size() != 1) { 2995 Error("Incorrect encoding of complex type"); 2996 return QualType(); 2997 } 2998 QualType ElemType = GetType(Record[0]); 2999 return Context->getComplexType(ElemType); 3000 } 3001 3002 case TYPE_POINTER: { 3003 if (Record.size() != 1) { 3004 Error("Incorrect encoding of pointer type"); 3005 return QualType(); 3006 } 3007 QualType PointeeType = GetType(Record[0]); 3008 return Context->getPointerType(PointeeType); 3009 } 3010 3011 case TYPE_BLOCK_POINTER: { 3012 if (Record.size() != 1) { 3013 Error("Incorrect encoding of block pointer type"); 3014 return QualType(); 3015 } 3016 QualType PointeeType = GetType(Record[0]); 3017 return Context->getBlockPointerType(PointeeType); 3018 } 3019 3020 case TYPE_LVALUE_REFERENCE: { 3021 if (Record.size() != 2) { 3022 Error("Incorrect encoding of lvalue reference type"); 3023 return QualType(); 3024 } 3025 QualType PointeeType = GetType(Record[0]); 3026 return Context->getLValueReferenceType(PointeeType, Record[1]); 3027 } 3028 3029 case TYPE_RVALUE_REFERENCE: { 3030 if (Record.size() != 1) { 3031 Error("Incorrect encoding of rvalue reference type"); 3032 return QualType(); 3033 } 3034 QualType PointeeType = GetType(Record[0]); 3035 return Context->getRValueReferenceType(PointeeType); 3036 } 3037 3038 case TYPE_MEMBER_POINTER: { 3039 if (Record.size() != 2) { 3040 Error("Incorrect encoding of member pointer type"); 3041 return QualType(); 3042 } 3043 QualType PointeeType = GetType(Record[0]); 3044 QualType ClassType = GetType(Record[1]); 3045 if (PointeeType.isNull() || ClassType.isNull()) 3046 return QualType(); 3047 3048 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3049 } 3050 3051 case TYPE_CONSTANT_ARRAY: { 3052 QualType ElementType = GetType(Record[0]); 3053 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3054 unsigned IndexTypeQuals = Record[2]; 3055 unsigned Idx = 3; 3056 llvm::APInt Size = ReadAPInt(Record, Idx); 3057 return Context->getConstantArrayType(ElementType, Size, 3058 ASM, IndexTypeQuals); 3059 } 3060 3061 case TYPE_INCOMPLETE_ARRAY: { 3062 QualType ElementType = GetType(Record[0]); 3063 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3064 unsigned IndexTypeQuals = Record[2]; 3065 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3066 } 3067 3068 case TYPE_VARIABLE_ARRAY: { 3069 QualType ElementType = GetType(Record[0]); 3070 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3071 unsigned IndexTypeQuals = Record[2]; 3072 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3073 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3074 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3075 ASM, IndexTypeQuals, 3076 SourceRange(LBLoc, RBLoc)); 3077 } 3078 3079 case TYPE_VECTOR: { 3080 if (Record.size() != 3) { 3081 Error("incorrect encoding of vector type in AST file"); 3082 return QualType(); 3083 } 3084 3085 QualType ElementType = GetType(Record[0]); 3086 unsigned NumElements = Record[1]; 3087 unsigned VecKind = Record[2]; 3088 return Context->getVectorType(ElementType, NumElements, 3089 (VectorType::VectorKind)VecKind); 3090 } 3091 3092 case TYPE_EXT_VECTOR: { 3093 if (Record.size() != 3) { 3094 Error("incorrect encoding of extended vector type in AST file"); 3095 return QualType(); 3096 } 3097 3098 QualType ElementType = GetType(Record[0]); 3099 unsigned NumElements = Record[1]; 3100 return Context->getExtVectorType(ElementType, NumElements); 3101 } 3102 3103 case TYPE_FUNCTION_NO_PROTO: { 3104 if (Record.size() != 5) { 3105 Error("incorrect encoding of no-proto function type"); 3106 return QualType(); 3107 } 3108 QualType ResultType = GetType(Record[0]); 3109 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], (CallingConv)Record[4]); 3110 return Context->getFunctionNoProtoType(ResultType, Info); 3111 } 3112 3113 case TYPE_FUNCTION_PROTO: { 3114 QualType ResultType = GetType(Record[0]); 3115 3116 FunctionProtoType::ExtProtoInfo EPI; 3117 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3118 /*hasregparm*/ Record[2], 3119 /*regparm*/ Record[3], 3120 static_cast<CallingConv>(Record[4])); 3121 3122 unsigned Idx = 5; 3123 unsigned NumParams = Record[Idx++]; 3124 llvm::SmallVector<QualType, 16> ParamTypes; 3125 for (unsigned I = 0; I != NumParams; ++I) 3126 ParamTypes.push_back(GetType(Record[Idx++])); 3127 3128 EPI.Variadic = Record[Idx++]; 3129 EPI.TypeQuals = Record[Idx++]; 3130 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3131 ExceptionSpecificationType EST = 3132 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3133 EPI.ExceptionSpecType = EST; 3134 if (EST == EST_Dynamic) { 3135 EPI.NumExceptions = Record[Idx++]; 3136 llvm::SmallVector<QualType, 2> Exceptions; 3137 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3138 Exceptions.push_back(GetType(Record[Idx++])); 3139 EPI.Exceptions = Exceptions.data(); 3140 } else if (EST == EST_ComputedNoexcept) { 3141 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3142 } 3143 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 3144 EPI); 3145 } 3146 3147 case TYPE_UNRESOLVED_USING: 3148 return Context->getTypeDeclType( 3149 cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0]))); 3150 3151 case TYPE_TYPEDEF: { 3152 if (Record.size() != 2) { 3153 Error("incorrect encoding of typedef type"); 3154 return QualType(); 3155 } 3156 TypedefNameDecl *Decl = cast<TypedefNameDecl>(GetDecl(Record[0])); 3157 QualType Canonical = GetType(Record[1]); 3158 if (!Canonical.isNull()) 3159 Canonical = Context->getCanonicalType(Canonical); 3160 return Context->getTypedefType(Decl, Canonical); 3161 } 3162 3163 case TYPE_TYPEOF_EXPR: 3164 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 3165 3166 case TYPE_TYPEOF: { 3167 if (Record.size() != 1) { 3168 Error("incorrect encoding of typeof(type) in AST file"); 3169 return QualType(); 3170 } 3171 QualType UnderlyingType = GetType(Record[0]); 3172 return Context->getTypeOfType(UnderlyingType); 3173 } 3174 3175 case TYPE_DECLTYPE: 3176 return Context->getDecltypeType(ReadExpr(*Loc.F)); 3177 3178 case TYPE_AUTO: 3179 return Context->getAutoType(GetType(Record[0])); 3180 3181 case TYPE_RECORD: { 3182 if (Record.size() != 2) { 3183 Error("incorrect encoding of record type"); 3184 return QualType(); 3185 } 3186 bool IsDependent = Record[0]; 3187 QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1]))); 3188 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3189 return T; 3190 } 3191 3192 case TYPE_ENUM: { 3193 if (Record.size() != 2) { 3194 Error("incorrect encoding of enum type"); 3195 return QualType(); 3196 } 3197 bool IsDependent = Record[0]; 3198 QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1]))); 3199 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3200 return T; 3201 } 3202 3203 case TYPE_ATTRIBUTED: { 3204 if (Record.size() != 3) { 3205 Error("incorrect encoding of attributed type"); 3206 return QualType(); 3207 } 3208 QualType modifiedType = GetType(Record[0]); 3209 QualType equivalentType = GetType(Record[1]); 3210 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3211 return Context->getAttributedType(kind, modifiedType, equivalentType); 3212 } 3213 3214 case TYPE_PAREN: { 3215 if (Record.size() != 1) { 3216 Error("incorrect encoding of paren type"); 3217 return QualType(); 3218 } 3219 QualType InnerType = GetType(Record[0]); 3220 return Context->getParenType(InnerType); 3221 } 3222 3223 case TYPE_PACK_EXPANSION: { 3224 if (Record.size() != 2) { 3225 Error("incorrect encoding of pack expansion type"); 3226 return QualType(); 3227 } 3228 QualType Pattern = GetType(Record[0]); 3229 if (Pattern.isNull()) 3230 return QualType(); 3231 llvm::Optional<unsigned> NumExpansions; 3232 if (Record[1]) 3233 NumExpansions = Record[1] - 1; 3234 return Context->getPackExpansionType(Pattern, NumExpansions); 3235 } 3236 3237 case TYPE_ELABORATED: { 3238 unsigned Idx = 0; 3239 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3240 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3241 QualType NamedType = GetType(Record[Idx++]); 3242 return Context->getElaboratedType(Keyword, NNS, NamedType); 3243 } 3244 3245 case TYPE_OBJC_INTERFACE: { 3246 unsigned Idx = 0; 3247 ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++])); 3248 return Context->getObjCInterfaceType(ItfD); 3249 } 3250 3251 case TYPE_OBJC_OBJECT: { 3252 unsigned Idx = 0; 3253 QualType Base = GetType(Record[Idx++]); 3254 unsigned NumProtos = Record[Idx++]; 3255 llvm::SmallVector<ObjCProtocolDecl*, 4> Protos; 3256 for (unsigned I = 0; I != NumProtos; ++I) 3257 Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++]))); 3258 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 3259 } 3260 3261 case TYPE_OBJC_OBJECT_POINTER: { 3262 unsigned Idx = 0; 3263 QualType Pointee = GetType(Record[Idx++]); 3264 return Context->getObjCObjectPointerType(Pointee); 3265 } 3266 3267 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3268 unsigned Idx = 0; 3269 QualType Parm = GetType(Record[Idx++]); 3270 QualType Replacement = GetType(Record[Idx++]); 3271 return 3272 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3273 Replacement); 3274 } 3275 3276 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3277 unsigned Idx = 0; 3278 QualType Parm = GetType(Record[Idx++]); 3279 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3280 return Context->getSubstTemplateTypeParmPackType( 3281 cast<TemplateTypeParmType>(Parm), 3282 ArgPack); 3283 } 3284 3285 case TYPE_INJECTED_CLASS_NAME: { 3286 CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0])); 3287 QualType TST = GetType(Record[1]); // probably derivable 3288 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3289 // for AST reading, too much interdependencies. 3290 return 3291 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3292 } 3293 3294 case TYPE_TEMPLATE_TYPE_PARM: { 3295 unsigned Idx = 0; 3296 unsigned Depth = Record[Idx++]; 3297 unsigned Index = Record[Idx++]; 3298 bool Pack = Record[Idx++]; 3299 IdentifierInfo *Name = GetIdentifierInfo(Record, Idx); 3300 return Context->getTemplateTypeParmType(Depth, Index, Pack, Name); 3301 } 3302 3303 case TYPE_DEPENDENT_NAME: { 3304 unsigned Idx = 0; 3305 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3306 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3307 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 3308 QualType Canon = GetType(Record[Idx++]); 3309 if (!Canon.isNull()) 3310 Canon = Context->getCanonicalType(Canon); 3311 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 3312 } 3313 3314 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3315 unsigned Idx = 0; 3316 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3317 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3318 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 3319 unsigned NumArgs = Record[Idx++]; 3320 llvm::SmallVector<TemplateArgument, 8> Args; 3321 Args.reserve(NumArgs); 3322 while (NumArgs--) 3323 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3324 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 3325 Args.size(), Args.data()); 3326 } 3327 3328 case TYPE_DEPENDENT_SIZED_ARRAY: { 3329 unsigned Idx = 0; 3330 3331 // ArrayType 3332 QualType ElementType = GetType(Record[Idx++]); 3333 ArrayType::ArraySizeModifier ASM 3334 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3335 unsigned IndexTypeQuals = Record[Idx++]; 3336 3337 // DependentSizedArrayType 3338 Expr *NumElts = ReadExpr(*Loc.F); 3339 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3340 3341 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 3342 IndexTypeQuals, Brackets); 3343 } 3344 3345 case TYPE_TEMPLATE_SPECIALIZATION: { 3346 unsigned Idx = 0; 3347 bool IsDependent = Record[Idx++]; 3348 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3349 llvm::SmallVector<TemplateArgument, 8> Args; 3350 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3351 QualType Canon = GetType(Record[Idx++]); 3352 QualType T; 3353 if (Canon.isNull()) 3354 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 3355 Args.size()); 3356 else 3357 T = Context->getTemplateSpecializationType(Name, Args.data(), 3358 Args.size(), Canon); 3359 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3360 return T; 3361 } 3362 } 3363 // Suppress a GCC warning 3364 return QualType(); 3365} 3366 3367class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3368 ASTReader &Reader; 3369 ASTReader::PerFileData &F; 3370 llvm::BitstreamCursor &DeclsCursor; 3371 const ASTReader::RecordData &Record; 3372 unsigned &Idx; 3373 3374 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3375 unsigned &I) { 3376 return Reader.ReadSourceLocation(F, R, I); 3377 } 3378 3379public: 3380 TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F, 3381 const ASTReader::RecordData &Record, unsigned &Idx) 3382 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3383 { } 3384 3385 // We want compile-time assurance that we've enumerated all of 3386 // these, so unfortunately we have to declare them first, then 3387 // define them out-of-line. 3388#define ABSTRACT_TYPELOC(CLASS, PARENT) 3389#define TYPELOC(CLASS, PARENT) \ 3390 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3391#include "clang/AST/TypeLocNodes.def" 3392 3393 void VisitFunctionTypeLoc(FunctionTypeLoc); 3394 void VisitArrayTypeLoc(ArrayTypeLoc); 3395}; 3396 3397void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3398 // nothing to do 3399} 3400void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3401 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3402 if (TL.needsExtraLocalData()) { 3403 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3404 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3405 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3406 TL.setModeAttr(Record[Idx++]); 3407 } 3408} 3409void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3410 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3411} 3412void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3413 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3414} 3415void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3416 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3417} 3418void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3419 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3420} 3421void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3422 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3423} 3424void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3425 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3426 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3427} 3428void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3429 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3430 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3431 if (Record[Idx++]) 3432 TL.setSizeExpr(Reader.ReadExpr(F)); 3433 else 3434 TL.setSizeExpr(0); 3435} 3436void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3437 VisitArrayTypeLoc(TL); 3438} 3439void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3440 VisitArrayTypeLoc(TL); 3441} 3442void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3443 VisitArrayTypeLoc(TL); 3444} 3445void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3446 DependentSizedArrayTypeLoc TL) { 3447 VisitArrayTypeLoc(TL); 3448} 3449void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3450 DependentSizedExtVectorTypeLoc TL) { 3451 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3452} 3453void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3454 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3455} 3456void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3457 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3458} 3459void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3460 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3461 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3462 TL.setTrailingReturn(Record[Idx++]); 3463 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3464 TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 3465 } 3466} 3467void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3468 VisitFunctionTypeLoc(TL); 3469} 3470void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3471 VisitFunctionTypeLoc(TL); 3472} 3473void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3474 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3475} 3476void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3477 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3478} 3479void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3480 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3481 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3482 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3483} 3484void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3485 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3486 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3487 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3488 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3489} 3490void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3491 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3492} 3493void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3494 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3495} 3496void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3497 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3498} 3499void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3500 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3501} 3502void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3503 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3504 if (TL.hasAttrOperand()) { 3505 SourceRange range; 3506 range.setBegin(ReadSourceLocation(Record, Idx)); 3507 range.setEnd(ReadSourceLocation(Record, Idx)); 3508 TL.setAttrOperandParensRange(range); 3509 } 3510 if (TL.hasAttrExprOperand()) { 3511 if (Record[Idx++]) 3512 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3513 else 3514 TL.setAttrExprOperand(0); 3515 } else if (TL.hasAttrEnumOperand()) 3516 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3517} 3518void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3519 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3520} 3521void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3522 SubstTemplateTypeParmTypeLoc TL) { 3523 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3524} 3525void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3526 SubstTemplateTypeParmPackTypeLoc TL) { 3527 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3528} 3529void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3530 TemplateSpecializationTypeLoc TL) { 3531 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3532 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3533 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3534 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3535 TL.setArgLocInfo(i, 3536 Reader.GetTemplateArgumentLocInfo(F, 3537 TL.getTypePtr()->getArg(i).getKind(), 3538 Record, Idx)); 3539} 3540void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3541 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3542 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3543} 3544void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3545 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3546 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3547} 3548void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3549 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3550} 3551void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3552 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3553 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3554 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3555} 3556void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3557 DependentTemplateSpecializationTypeLoc TL) { 3558 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3559 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3560 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3561 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3562 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3563 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3564 TL.setArgLocInfo(I, 3565 Reader.GetTemplateArgumentLocInfo(F, 3566 TL.getTypePtr()->getArg(I).getKind(), 3567 Record, Idx)); 3568} 3569void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3570 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3571} 3572void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3573 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3574} 3575void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3576 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3577 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3578 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3579 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3580 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3581} 3582void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3583 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3584} 3585 3586TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F, 3587 const RecordData &Record, 3588 unsigned &Idx) { 3589 QualType InfoTy = GetType(Record[Idx++]); 3590 if (InfoTy.isNull()) 3591 return 0; 3592 3593 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3594 TypeLocReader TLR(*this, F, Record, Idx); 3595 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3596 TLR.Visit(TL); 3597 return TInfo; 3598} 3599 3600QualType ASTReader::GetType(TypeID ID) { 3601 unsigned FastQuals = ID & Qualifiers::FastMask; 3602 unsigned Index = ID >> Qualifiers::FastWidth; 3603 3604 if (Index < NUM_PREDEF_TYPE_IDS) { 3605 QualType T; 3606 switch ((PredefinedTypeIDs)Index) { 3607 case PREDEF_TYPE_NULL_ID: return QualType(); 3608 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3609 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3610 3611 case PREDEF_TYPE_CHAR_U_ID: 3612 case PREDEF_TYPE_CHAR_S_ID: 3613 // FIXME: Check that the signedness of CharTy is correct! 3614 T = Context->CharTy; 3615 break; 3616 3617 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3618 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3619 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3620 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3621 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3622 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3623 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3624 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3625 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3626 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3627 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3628 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3629 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3630 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3631 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3632 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3633 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3634 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3635 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break; 3636 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3637 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3638 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3639 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3640 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3641 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 3642 } 3643 3644 assert(!T.isNull() && "Unknown predefined type"); 3645 return T.withFastQualifiers(FastQuals); 3646 } 3647 3648 Index -= NUM_PREDEF_TYPE_IDS; 3649 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3650 if (TypesLoaded[Index].isNull()) { 3651 TypesLoaded[Index] = ReadTypeRecord(Index); 3652 if (TypesLoaded[Index].isNull()) 3653 return QualType(); 3654 3655 TypesLoaded[Index]->setFromAST(); 3656 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID); 3657 if (DeserializationListener) 3658 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3659 TypesLoaded[Index]); 3660 } 3661 3662 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3663} 3664 3665TypeID ASTReader::GetTypeID(QualType T) const { 3666 return MakeTypeID(T, 3667 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this)); 3668} 3669 3670TypeIdx ASTReader::GetTypeIdx(QualType T) const { 3671 if (T.isNull()) 3672 return TypeIdx(); 3673 assert(!T.getLocalFastQualifiers()); 3674 3675 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3676 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and 3677 // comparing keys of ASTDeclContextNameLookupTable. 3678 // If the type didn't come from the AST file use a specially marked index 3679 // so that any hash/key comparison fail since no such index is stored 3680 // in a AST file. 3681 if (I == TypeIdxs.end()) 3682 return TypeIdx(-1); 3683 return I->second; 3684} 3685 3686unsigned ASTReader::getTotalNumCXXBaseSpecifiers() const { 3687 unsigned Result = 0; 3688 for (unsigned I = 0, N = Chain.size(); I != N; ++I) 3689 Result += Chain[I]->LocalNumCXXBaseSpecifiers; 3690 3691 return Result; 3692} 3693 3694TemplateArgumentLocInfo 3695ASTReader::GetTemplateArgumentLocInfo(PerFileData &F, 3696 TemplateArgument::ArgKind Kind, 3697 const RecordData &Record, 3698 unsigned &Index) { 3699 switch (Kind) { 3700 case TemplateArgument::Expression: 3701 return ReadExpr(F); 3702 case TemplateArgument::Type: 3703 return GetTypeSourceInfo(F, Record, Index); 3704 case TemplateArgument::Template: { 3705 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3706 Index); 3707 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3708 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3709 SourceLocation()); 3710 } 3711 case TemplateArgument::TemplateExpansion: { 3712 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3713 Index); 3714 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3715 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 3716 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3717 EllipsisLoc); 3718 } 3719 case TemplateArgument::Null: 3720 case TemplateArgument::Integral: 3721 case TemplateArgument::Declaration: 3722 case TemplateArgument::Pack: 3723 return TemplateArgumentLocInfo(); 3724 } 3725 llvm_unreachable("unexpected template argument loc"); 3726 return TemplateArgumentLocInfo(); 3727} 3728 3729TemplateArgumentLoc 3730ASTReader::ReadTemplateArgumentLoc(PerFileData &F, 3731 const RecordData &Record, unsigned &Index) { 3732 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 3733 3734 if (Arg.getKind() == TemplateArgument::Expression) { 3735 if (Record[Index++]) // bool InfoHasSameExpr. 3736 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3737 } 3738 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 3739 Record, Index)); 3740} 3741 3742Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3743 return GetDecl(ID); 3744} 3745 3746uint64_t 3747ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) { 3748 if (ID == 0) 3749 return 0; 3750 3751 --ID; 3752 uint64_t Offset = 0; 3753 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3754 PerFileData &F = *Chain[N - I - 1]; 3755 3756 if (ID < F.LocalNumCXXBaseSpecifiers) 3757 return Offset + F.CXXBaseSpecifiersOffsets[ID]; 3758 3759 ID -= F.LocalNumCXXBaseSpecifiers; 3760 Offset += F.SizeInBits; 3761 } 3762 3763 assert(false && "CXXBaseSpecifiers not found"); 3764 return 0; 3765} 3766 3767CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 3768 // Figure out which AST file contains this offset. 3769 PerFileData *F = 0; 3770 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3771 if (Offset < Chain[N - I - 1]->SizeInBits) { 3772 F = Chain[N - I - 1]; 3773 break; 3774 } 3775 3776 Offset -= Chain[N - I - 1]->SizeInBits; 3777 } 3778 3779 if (!F) { 3780 Error("Malformed AST file: C++ base specifiers at impossible offset"); 3781 return 0; 3782 } 3783 3784 llvm::BitstreamCursor &Cursor = F->DeclsCursor; 3785 SavedStreamPosition SavedPosition(Cursor); 3786 Cursor.JumpToBit(Offset); 3787 ReadingKindTracker ReadingKind(Read_Decl, *this); 3788 RecordData Record; 3789 unsigned Code = Cursor.ReadCode(); 3790 unsigned RecCode = Cursor.ReadRecord(Code, Record); 3791 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 3792 Error("Malformed AST file: missing C++ base specifiers"); 3793 return 0; 3794 } 3795 3796 unsigned Idx = 0; 3797 unsigned NumBases = Record[Idx++]; 3798 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 3799 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 3800 for (unsigned I = 0; I != NumBases; ++I) 3801 Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx); 3802 return Bases; 3803} 3804 3805TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 3806 if (!DeclsLoaded[0]) { 3807 ReadDeclRecord(0, 1); 3808 if (DeserializationListener) 3809 DeserializationListener->DeclRead(1, DeclsLoaded[0]); 3810 } 3811 3812 return cast<TranslationUnitDecl>(DeclsLoaded[0]); 3813} 3814 3815Decl *ASTReader::GetDecl(DeclID ID) { 3816 if (ID == 0) 3817 return 0; 3818 3819 if (ID > DeclsLoaded.size()) { 3820 Error("declaration ID out-of-range for AST file"); 3821 return 0; 3822 } 3823 3824 unsigned Index = ID - 1; 3825 if (!DeclsLoaded[Index]) { 3826 ReadDeclRecord(Index, ID); 3827 if (DeserializationListener) 3828 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 3829 } 3830 3831 return DeclsLoaded[Index]; 3832} 3833 3834/// \brief Resolve the offset of a statement into a statement. 3835/// 3836/// This operation will read a new statement from the external 3837/// source each time it is called, and is meant to be used via a 3838/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 3839Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 3840 // Switch case IDs are per Decl. 3841 ClearSwitchCaseIDs(); 3842 3843 // Offset here is a global offset across the entire chain. 3844 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3845 PerFileData &F = *Chain[N - I - 1]; 3846 if (Offset < F.SizeInBits) { 3847 // Since we know that this statement is part of a decl, make sure to use 3848 // the decl cursor to read it. 3849 F.DeclsCursor.JumpToBit(Offset); 3850 return ReadStmtFromStream(F); 3851 } 3852 Offset -= F.SizeInBits; 3853 } 3854 llvm_unreachable("Broken chain"); 3855} 3856 3857bool ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 3858 bool (*isKindWeWant)(Decl::Kind), 3859 llvm::SmallVectorImpl<Decl*> &Decls) { 3860 assert(DC->hasExternalLexicalStorage() && 3861 "DeclContext has no lexical decls in storage"); 3862 3863 // There might be lexical decls in multiple parts of the chain, for the TU 3864 // at least. 3865 // DeclContextOffsets might reallocate as we load additional decls below, 3866 // so make a copy of the vector. 3867 DeclContextInfos Infos = DeclContextOffsets[DC]; 3868 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3869 I != E; ++I) { 3870 // IDs can be 0 if this context doesn't contain declarations. 3871 if (!I->LexicalDecls) 3872 continue; 3873 3874 // Load all of the declaration IDs 3875 for (const KindDeclIDPair *ID = I->LexicalDecls, 3876 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 3877 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 3878 continue; 3879 3880 Decl *D = GetDecl(ID->second); 3881 assert(D && "Null decl in lexical decls"); 3882 Decls.push_back(D); 3883 } 3884 } 3885 3886 ++NumLexicalDeclContextsRead; 3887 return false; 3888} 3889 3890DeclContext::lookup_result 3891ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 3892 DeclarationName Name) { 3893 assert(DC->hasExternalVisibleStorage() && 3894 "DeclContext has no visible decls in storage"); 3895 if (!Name) 3896 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 3897 DeclContext::lookup_iterator(0)); 3898 3899 llvm::SmallVector<NamedDecl *, 64> Decls; 3900 // There might be visible decls in multiple parts of the chain, for the TU 3901 // and namespaces. For any given name, the last available results replace 3902 // all earlier ones. For this reason, we walk in reverse. 3903 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3904 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 3905 I != E; ++I) { 3906 if (!I->NameLookupTableData) 3907 continue; 3908 3909 ASTDeclContextNameLookupTable *LookupTable = 3910 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3911 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 3912 if (Pos == LookupTable->end()) 3913 continue; 3914 3915 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 3916 for (; Data.first != Data.second; ++Data.first) 3917 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3918 break; 3919 } 3920 3921 ++NumVisibleDeclContextsRead; 3922 3923 SetExternalVisibleDeclsForName(DC, Name, Decls); 3924 return const_cast<DeclContext*>(DC)->lookup(Name); 3925} 3926 3927void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 3928 assert(DC->hasExternalVisibleStorage() && 3929 "DeclContext has no visible decls in storage"); 3930 3931 llvm::SmallVector<NamedDecl *, 64> Decls; 3932 // There might be visible decls in multiple parts of the chain, for the TU 3933 // and namespaces. 3934 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3935 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3936 I != E; ++I) { 3937 if (!I->NameLookupTableData) 3938 continue; 3939 3940 ASTDeclContextNameLookupTable *LookupTable = 3941 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3942 for (ASTDeclContextNameLookupTable::item_iterator 3943 ItemI = LookupTable->item_begin(), 3944 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 3945 ASTDeclContextNameLookupTable::item_iterator::value_type Val 3946 = *ItemI; 3947 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 3948 Decls.clear(); 3949 for (; Data.first != Data.second; ++Data.first) 3950 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3951 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 3952 } 3953 } 3954} 3955 3956void ASTReader::PassInterestingDeclsToConsumer() { 3957 assert(Consumer); 3958 while (!InterestingDecls.empty()) { 3959 DeclGroupRef DG(InterestingDecls.front()); 3960 InterestingDecls.pop_front(); 3961 Consumer->HandleInterestingDecl(DG); 3962 } 3963} 3964 3965void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 3966 this->Consumer = Consumer; 3967 3968 if (!Consumer) 3969 return; 3970 3971 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 3972 // Force deserialization of this decl, which will cause it to be queued for 3973 // passing to the consumer. 3974 GetDecl(ExternalDefinitions[I]); 3975 } 3976 3977 PassInterestingDeclsToConsumer(); 3978} 3979 3980void ASTReader::PrintStats() { 3981 std::fprintf(stderr, "*** AST File Statistics:\n"); 3982 3983 unsigned NumTypesLoaded 3984 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 3985 QualType()); 3986 unsigned NumDeclsLoaded 3987 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 3988 (Decl *)0); 3989 unsigned NumIdentifiersLoaded 3990 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 3991 IdentifiersLoaded.end(), 3992 (IdentifierInfo *)0); 3993 unsigned NumSelectorsLoaded 3994 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 3995 SelectorsLoaded.end(), 3996 Selector()); 3997 3998 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 3999 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4000 if (TotalNumSLocEntries) 4001 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4002 NumSLocEntriesRead, TotalNumSLocEntries, 4003 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4004 if (!TypesLoaded.empty()) 4005 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4006 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4007 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4008 if (!DeclsLoaded.empty()) 4009 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4010 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4011 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4012 if (!IdentifiersLoaded.empty()) 4013 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4014 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4015 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4016 if (!SelectorsLoaded.empty()) 4017 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4018 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4019 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4020 if (TotalNumStatements) 4021 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4022 NumStatementsRead, TotalNumStatements, 4023 ((float)NumStatementsRead/TotalNumStatements * 100)); 4024 if (TotalNumMacros) 4025 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4026 NumMacrosRead, TotalNumMacros, 4027 ((float)NumMacrosRead/TotalNumMacros * 100)); 4028 if (TotalLexicalDeclContexts) 4029 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4030 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4031 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4032 * 100)); 4033 if (TotalVisibleDeclContexts) 4034 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4035 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4036 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4037 * 100)); 4038 if (TotalNumMethodPoolEntries) { 4039 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4040 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4041 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4042 * 100)); 4043 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4044 } 4045 std::fprintf(stderr, "\n"); 4046} 4047 4048void ASTReader::InitializeSema(Sema &S) { 4049 SemaObj = &S; 4050 S.ExternalSource = this; 4051 4052 // Makes sure any declarations that were deserialized "too early" 4053 // still get added to the identifier's declaration chains. 4054 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4055 if (SemaObj->TUScope) 4056 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4057 4058 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4059 } 4060 PreloadedDecls.clear(); 4061 4062 // If there were any tentative definitions, deserialize them and add 4063 // them to Sema's list of tentative definitions. 4064 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4065 VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I])); 4066 SemaObj->TentativeDefinitions.push_back(Var); 4067 } 4068 4069 // If there were any unused file scoped decls, deserialize them and add to 4070 // Sema's list of unused file scoped decls. 4071 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4072 DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4073 SemaObj->UnusedFileScopedDecls.push_back(D); 4074 } 4075 4076 // If there were any locally-scoped external declarations, 4077 // deserialize them and add them to Sema's table of locally-scoped 4078 // external declarations. 4079 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4080 NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4081 SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D; 4082 } 4083 4084 // If there were any ext_vector type declarations, deserialize them 4085 // and add them to Sema's vector of such declarations. 4086 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) 4087 SemaObj->ExtVectorDecls.push_back( 4088 cast<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]))); 4089 4090 // FIXME: Do VTable uses and dynamic classes deserialize too much ? 4091 // Can we cut them down before writing them ? 4092 4093 // If there were any dynamic classes declarations, deserialize them 4094 // and add them to Sema's vector of such declarations. 4095 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) 4096 SemaObj->DynamicClasses.push_back( 4097 cast<CXXRecordDecl>(GetDecl(DynamicClasses[I]))); 4098 4099 // Load the offsets of the declarations that Sema references. 4100 // They will be lazily deserialized when needed. 4101 if (!SemaDeclRefs.empty()) { 4102 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4103 SemaObj->StdNamespace = SemaDeclRefs[0]; 4104 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4105 } 4106 4107 for (PerFileData *F = FirstInSource; F; F = F->NextInSource) { 4108 4109 // If there are @selector references added them to its pool. This is for 4110 // implementation of -Wselector. 4111 if (!F->ReferencedSelectorsData.empty()) { 4112 unsigned int DataSize = F->ReferencedSelectorsData.size()-1; 4113 unsigned I = 0; 4114 while (I < DataSize) { 4115 Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]); 4116 SourceLocation SelLoc = ReadSourceLocation( 4117 *F, F->ReferencedSelectorsData, I); 4118 SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc)); 4119 } 4120 } 4121 4122 // If there were any pending implicit instantiations, deserialize them 4123 // and add them to Sema's queue of such instantiations. 4124 assert(F->PendingInstantiations.size() % 2 == 0 && 4125 "Expected pairs of entries"); 4126 for (unsigned Idx = 0, N = F->PendingInstantiations.size(); Idx < N;) { 4127 ValueDecl *D=cast<ValueDecl>(GetDecl(F->PendingInstantiations[Idx++])); 4128 SourceLocation Loc = ReadSourceLocation(*F, F->PendingInstantiations,Idx); 4129 SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc)); 4130 } 4131 } 4132 4133 // The two special data sets below always come from the most recent PCH, 4134 // which is at the front of the chain. 4135 PerFileData &F = *Chain.front(); 4136 4137 // If there were any weak undeclared identifiers, deserialize them and add to 4138 // Sema's list of weak undeclared identifiers. 4139 if (!WeakUndeclaredIdentifiers.empty()) { 4140 unsigned Idx = 0; 4141 for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) { 4142 IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 4143 IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 4144 SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx); 4145 bool Used = WeakUndeclaredIdentifiers[Idx++]; 4146 Sema::WeakInfo WI(AliasId, Loc); 4147 WI.setUsed(Used); 4148 SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI)); 4149 } 4150 } 4151 4152 // If there were any VTable uses, deserialize the information and add it 4153 // to Sema's vector and map of VTable uses. 4154 if (!VTableUses.empty()) { 4155 unsigned Idx = 0; 4156 for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) { 4157 CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4158 SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx); 4159 bool DefinitionRequired = VTableUses[Idx++]; 4160 SemaObj->VTableUses.push_back(std::make_pair(Class, Loc)); 4161 SemaObj->VTablesUsed[Class] = DefinitionRequired; 4162 } 4163 } 4164 4165 if (!FPPragmaOptions.empty()) { 4166 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4167 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4168 } 4169 4170 if (!OpenCLExtensions.empty()) { 4171 unsigned I = 0; 4172#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4173#include "clang/Basic/OpenCLExtensions.def" 4174 4175 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4176 } 4177} 4178 4179IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4180 // Try to find this name within our on-disk hash tables. We start with the 4181 // most recent one, since that one contains the most up-to-date info. 4182 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4183 ASTIdentifierLookupTable *IdTable 4184 = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable; 4185 if (!IdTable) 4186 continue; 4187 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 4188 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 4189 if (Pos == IdTable->end()) 4190 continue; 4191 4192 // Dereferencing the iterator has the effect of building the 4193 // IdentifierInfo node and populating it with the various 4194 // declarations it needs. 4195 return *Pos; 4196 } 4197 return 0; 4198} 4199 4200namespace clang { 4201 /// \brief An identifier-lookup iterator that enumerates all of the 4202 /// identifiers stored within a set of AST files. 4203 class ASTIdentifierIterator : public IdentifierIterator { 4204 /// \brief The AST reader whose identifiers are being enumerated. 4205 const ASTReader &Reader; 4206 4207 /// \brief The current index into the chain of AST files stored in 4208 /// the AST reader. 4209 unsigned Index; 4210 4211 /// \brief The current position within the identifier lookup table 4212 /// of the current AST file. 4213 ASTIdentifierLookupTable::key_iterator Current; 4214 4215 /// \brief The end position within the identifier lookup table of 4216 /// the current AST file. 4217 ASTIdentifierLookupTable::key_iterator End; 4218 4219 public: 4220 explicit ASTIdentifierIterator(const ASTReader &Reader); 4221 4222 virtual llvm::StringRef Next(); 4223 }; 4224} 4225 4226ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4227 : Reader(Reader), Index(Reader.Chain.size() - 1) { 4228 ASTIdentifierLookupTable *IdTable 4229 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 4230 Current = IdTable->key_begin(); 4231 End = IdTable->key_end(); 4232} 4233 4234llvm::StringRef ASTIdentifierIterator::Next() { 4235 while (Current == End) { 4236 // If we have exhausted all of our AST files, we're done. 4237 if (Index == 0) 4238 return llvm::StringRef(); 4239 4240 --Index; 4241 ASTIdentifierLookupTable *IdTable 4242 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 4243 Current = IdTable->key_begin(); 4244 End = IdTable->key_end(); 4245 } 4246 4247 // We have any identifiers remaining in the current AST file; return 4248 // the next one. 4249 std::pair<const char*, unsigned> Key = *Current; 4250 ++Current; 4251 return llvm::StringRef(Key.first, Key.second); 4252} 4253 4254IdentifierIterator *ASTReader::getIdentifiers() const { 4255 return new ASTIdentifierIterator(*this); 4256} 4257 4258std::pair<ObjCMethodList, ObjCMethodList> 4259ASTReader::ReadMethodPool(Selector Sel) { 4260 // Find this selector in a hash table. We want to find the most recent entry. 4261 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4262 PerFileData &F = *Chain[I]; 4263 if (!F.SelectorLookupTable) 4264 continue; 4265 4266 ASTSelectorLookupTable *PoolTable 4267 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 4268 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 4269 if (Pos != PoolTable->end()) { 4270 ++NumSelectorsRead; 4271 // FIXME: Not quite happy with the statistics here. We probably should 4272 // disable this tracking when called via LoadSelector. 4273 // Also, should entries without methods count as misses? 4274 ++NumMethodPoolEntriesRead; 4275 ASTSelectorLookupTrait::data_type Data = *Pos; 4276 if (DeserializationListener) 4277 DeserializationListener->SelectorRead(Data.ID, Sel); 4278 return std::make_pair(Data.Instance, Data.Factory); 4279 } 4280 } 4281 4282 ++NumMethodPoolMisses; 4283 return std::pair<ObjCMethodList, ObjCMethodList>(); 4284} 4285 4286void ASTReader::LoadSelector(Selector Sel) { 4287 // It would be complicated to avoid reading the methods anyway. So don't. 4288 ReadMethodPool(Sel); 4289} 4290 4291void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { 4292 assert(ID && "Non-zero identifier ID required"); 4293 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4294 IdentifiersLoaded[ID - 1] = II; 4295 if (DeserializationListener) 4296 DeserializationListener->IdentifierRead(ID, II); 4297} 4298 4299/// \brief Set the globally-visible declarations associated with the given 4300/// identifier. 4301/// 4302/// If the AST reader is currently in a state where the given declaration IDs 4303/// cannot safely be resolved, they are queued until it is safe to resolve 4304/// them. 4305/// 4306/// \param II an IdentifierInfo that refers to one or more globally-visible 4307/// declarations. 4308/// 4309/// \param DeclIDs the set of declaration IDs with the name @p II that are 4310/// visible at global scope. 4311/// 4312/// \param Nonrecursive should be true to indicate that the caller knows that 4313/// this call is non-recursive, and therefore the globally-visible declarations 4314/// will not be placed onto the pending queue. 4315void 4316ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4317 const llvm::SmallVectorImpl<uint32_t> &DeclIDs, 4318 bool Nonrecursive) { 4319 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4320 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4321 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4322 PII.II = II; 4323 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4324 return; 4325 } 4326 4327 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4328 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4329 if (SemaObj) { 4330 if (SemaObj->TUScope) { 4331 // Introduce this declaration into the translation-unit scope 4332 // and add it to the declaration chain for this identifier, so 4333 // that (unqualified) name lookup will find it. 4334 SemaObj->TUScope->AddDecl(D); 4335 } 4336 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4337 } else { 4338 // Queue this declaration so that it will be added to the 4339 // translation unit scope and identifier's declaration chain 4340 // once a Sema object is known. 4341 PreloadedDecls.push_back(D); 4342 } 4343 } 4344} 4345 4346IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) { 4347 if (ID == 0) 4348 return 0; 4349 4350 if (IdentifiersLoaded.empty()) { 4351 Error("no identifier table in AST file"); 4352 return 0; 4353 } 4354 4355 assert(PP && "Forgot to set Preprocessor ?"); 4356 ID -= 1; 4357 if (!IdentifiersLoaded[ID]) { 4358 unsigned Index = ID; 4359 const char *Str = 0; 4360 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4361 PerFileData *F = Chain[N - I - 1]; 4362 if (Index < F->LocalNumIdentifiers) { 4363 uint32_t Offset = F->IdentifierOffsets[Index]; 4364 Str = F->IdentifierTableData + Offset; 4365 break; 4366 } 4367 Index -= F->LocalNumIdentifiers; 4368 } 4369 assert(Str && "Broken Chain"); 4370 4371 // All of the strings in the AST file are preceded by a 16-bit length. 4372 // Extract that 16-bit length to avoid having to execute strlen(). 4373 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4374 // unsigned integers. This is important to avoid integer overflow when 4375 // we cast them to 'unsigned'. 4376 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4377 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4378 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4379 IdentifiersLoaded[ID] 4380 = &PP->getIdentifierTable().get(Str, StrLen); 4381 if (DeserializationListener) 4382 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4383 } 4384 4385 return IdentifiersLoaded[ID]; 4386} 4387 4388bool ASTReader::ReadSLocEntry(unsigned ID) { 4389 return ReadSLocEntryRecord(ID) != Success; 4390} 4391 4392Selector ASTReader::DecodeSelector(unsigned ID) { 4393 if (ID == 0) 4394 return Selector(); 4395 4396 if (ID > SelectorsLoaded.size()) { 4397 Error("selector ID out of range in AST file"); 4398 return Selector(); 4399 } 4400 4401 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4402 // Load this selector from the selector table. 4403 unsigned Idx = ID - 1; 4404 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4405 PerFileData &F = *Chain[N - I - 1]; 4406 if (Idx < F.LocalNumSelectors) { 4407 ASTSelectorLookupTrait Trait(*this); 4408 SelectorsLoaded[ID - 1] = 4409 Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0); 4410 if (DeserializationListener) 4411 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4412 break; 4413 } 4414 Idx -= F.LocalNumSelectors; 4415 } 4416 } 4417 4418 return SelectorsLoaded[ID - 1]; 4419} 4420 4421Selector ASTReader::GetExternalSelector(uint32_t ID) { 4422 return DecodeSelector(ID); 4423} 4424 4425uint32_t ASTReader::GetNumExternalSelectors() { 4426 // ID 0 (the null selector) is considered an external selector. 4427 return getTotalNumSelectors() + 1; 4428} 4429 4430DeclarationName 4431ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { 4432 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 4433 switch (Kind) { 4434 case DeclarationName::Identifier: 4435 return DeclarationName(GetIdentifierInfo(Record, Idx)); 4436 4437 case DeclarationName::ObjCZeroArgSelector: 4438 case DeclarationName::ObjCOneArgSelector: 4439 case DeclarationName::ObjCMultiArgSelector: 4440 return DeclarationName(GetSelector(Record, Idx)); 4441 4442 case DeclarationName::CXXConstructorName: 4443 return Context->DeclarationNames.getCXXConstructorName( 4444 Context->getCanonicalType(GetType(Record[Idx++]))); 4445 4446 case DeclarationName::CXXDestructorName: 4447 return Context->DeclarationNames.getCXXDestructorName( 4448 Context->getCanonicalType(GetType(Record[Idx++]))); 4449 4450 case DeclarationName::CXXConversionFunctionName: 4451 return Context->DeclarationNames.getCXXConversionFunctionName( 4452 Context->getCanonicalType(GetType(Record[Idx++]))); 4453 4454 case DeclarationName::CXXOperatorName: 4455 return Context->DeclarationNames.getCXXOperatorName( 4456 (OverloadedOperatorKind)Record[Idx++]); 4457 4458 case DeclarationName::CXXLiteralOperatorName: 4459 return Context->DeclarationNames.getCXXLiteralOperatorName( 4460 GetIdentifierInfo(Record, Idx)); 4461 4462 case DeclarationName::CXXUsingDirective: 4463 return DeclarationName::getUsingDirectiveName(); 4464 } 4465 4466 // Required to silence GCC warning 4467 return DeclarationName(); 4468} 4469 4470void ASTReader::ReadDeclarationNameLoc(PerFileData &F, 4471 DeclarationNameLoc &DNLoc, 4472 DeclarationName Name, 4473 const RecordData &Record, unsigned &Idx) { 4474 switch (Name.getNameKind()) { 4475 case DeclarationName::CXXConstructorName: 4476 case DeclarationName::CXXDestructorName: 4477 case DeclarationName::CXXConversionFunctionName: 4478 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 4479 break; 4480 4481 case DeclarationName::CXXOperatorName: 4482 DNLoc.CXXOperatorName.BeginOpNameLoc 4483 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4484 DNLoc.CXXOperatorName.EndOpNameLoc 4485 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4486 break; 4487 4488 case DeclarationName::CXXLiteralOperatorName: 4489 DNLoc.CXXLiteralOperatorName.OpNameLoc 4490 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4491 break; 4492 4493 case DeclarationName::Identifier: 4494 case DeclarationName::ObjCZeroArgSelector: 4495 case DeclarationName::ObjCOneArgSelector: 4496 case DeclarationName::ObjCMultiArgSelector: 4497 case DeclarationName::CXXUsingDirective: 4498 break; 4499 } 4500} 4501 4502void ASTReader::ReadDeclarationNameInfo(PerFileData &F, 4503 DeclarationNameInfo &NameInfo, 4504 const RecordData &Record, unsigned &Idx) { 4505 NameInfo.setName(ReadDeclarationName(Record, Idx)); 4506 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4507 DeclarationNameLoc DNLoc; 4508 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 4509 NameInfo.setInfo(DNLoc); 4510} 4511 4512void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info, 4513 const RecordData &Record, unsigned &Idx) { 4514 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 4515 unsigned NumTPLists = Record[Idx++]; 4516 Info.NumTemplParamLists = NumTPLists; 4517 if (NumTPLists) { 4518 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 4519 for (unsigned i=0; i != NumTPLists; ++i) 4520 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 4521 } 4522} 4523 4524TemplateName 4525ASTReader::ReadTemplateName(PerFileData &F, const RecordData &Record, 4526 unsigned &Idx) { 4527 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 4528 switch (Kind) { 4529 case TemplateName::Template: 4530 return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++]))); 4531 4532 case TemplateName::OverloadedTemplate: { 4533 unsigned size = Record[Idx++]; 4534 UnresolvedSet<8> Decls; 4535 while (size--) 4536 Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4537 4538 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 4539 } 4540 4541 case TemplateName::QualifiedTemplate: { 4542 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4543 bool hasTemplKeyword = Record[Idx++]; 4544 TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++])); 4545 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 4546 } 4547 4548 case TemplateName::DependentTemplate: { 4549 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4550 if (Record[Idx++]) // isIdentifier 4551 return Context->getDependentTemplateName(NNS, 4552 GetIdentifierInfo(Record, Idx)); 4553 return Context->getDependentTemplateName(NNS, 4554 (OverloadedOperatorKind)Record[Idx++]); 4555 } 4556 4557 case TemplateName::SubstTemplateTemplateParmPack: { 4558 TemplateTemplateParmDecl *Param 4559 = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++])); 4560 if (!Param) 4561 return TemplateName(); 4562 4563 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 4564 if (ArgPack.getKind() != TemplateArgument::Pack) 4565 return TemplateName(); 4566 4567 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack); 4568 } 4569 } 4570 4571 assert(0 && "Unhandled template name kind!"); 4572 return TemplateName(); 4573} 4574 4575TemplateArgument 4576ASTReader::ReadTemplateArgument(PerFileData &F, 4577 const RecordData &Record, unsigned &Idx) { 4578 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 4579 switch (Kind) { 4580 case TemplateArgument::Null: 4581 return TemplateArgument(); 4582 case TemplateArgument::Type: 4583 return TemplateArgument(GetType(Record[Idx++])); 4584 case TemplateArgument::Declaration: 4585 return TemplateArgument(GetDecl(Record[Idx++])); 4586 case TemplateArgument::Integral: { 4587 llvm::APSInt Value = ReadAPSInt(Record, Idx); 4588 QualType T = GetType(Record[Idx++]); 4589 return TemplateArgument(Value, T); 4590 } 4591 case TemplateArgument::Template: 4592 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 4593 case TemplateArgument::TemplateExpansion: { 4594 TemplateName Name = ReadTemplateName(F, Record, Idx); 4595 llvm::Optional<unsigned> NumTemplateExpansions; 4596 if (unsigned NumExpansions = Record[Idx++]) 4597 NumTemplateExpansions = NumExpansions - 1; 4598 return TemplateArgument(Name, NumTemplateExpansions); 4599 } 4600 case TemplateArgument::Expression: 4601 return TemplateArgument(ReadExpr(F)); 4602 case TemplateArgument::Pack: { 4603 unsigned NumArgs = Record[Idx++]; 4604 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs]; 4605 for (unsigned I = 0; I != NumArgs; ++I) 4606 Args[I] = ReadTemplateArgument(F, Record, Idx); 4607 return TemplateArgument(Args, NumArgs); 4608 } 4609 } 4610 4611 assert(0 && "Unhandled template argument kind!"); 4612 return TemplateArgument(); 4613} 4614 4615TemplateParameterList * 4616ASTReader::ReadTemplateParameterList(PerFileData &F, 4617 const RecordData &Record, unsigned &Idx) { 4618 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 4619 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 4620 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 4621 4622 unsigned NumParams = Record[Idx++]; 4623 llvm::SmallVector<NamedDecl *, 16> Params; 4624 Params.reserve(NumParams); 4625 while (NumParams--) 4626 Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4627 4628 TemplateParameterList* TemplateParams = 4629 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 4630 Params.data(), Params.size(), RAngleLoc); 4631 return TemplateParams; 4632} 4633 4634void 4635ASTReader:: 4636ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs, 4637 PerFileData &F, const RecordData &Record, 4638 unsigned &Idx) { 4639 unsigned NumTemplateArgs = Record[Idx++]; 4640 TemplArgs.reserve(NumTemplateArgs); 4641 while (NumTemplateArgs--) 4642 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 4643} 4644 4645/// \brief Read a UnresolvedSet structure. 4646void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set, 4647 const RecordData &Record, unsigned &Idx) { 4648 unsigned NumDecls = Record[Idx++]; 4649 while (NumDecls--) { 4650 NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++])); 4651 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 4652 Set.addDecl(D, AS); 4653 } 4654} 4655 4656CXXBaseSpecifier 4657ASTReader::ReadCXXBaseSpecifier(PerFileData &F, 4658 const RecordData &Record, unsigned &Idx) { 4659 bool isVirtual = static_cast<bool>(Record[Idx++]); 4660 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 4661 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 4662 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 4663 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 4664 SourceRange Range = ReadSourceRange(F, Record, Idx); 4665 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 4666 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 4667 EllipsisLoc); 4668 Result.setInheritConstructors(inheritConstructors); 4669 return Result; 4670} 4671 4672std::pair<CXXCtorInitializer **, unsigned> 4673ASTReader::ReadCXXCtorInitializers(PerFileData &F, const RecordData &Record, 4674 unsigned &Idx) { 4675 CXXCtorInitializer **CtorInitializers = 0; 4676 unsigned NumInitializers = Record[Idx++]; 4677 if (NumInitializers) { 4678 ASTContext &C = *getContext(); 4679 4680 CtorInitializers 4681 = new (C) CXXCtorInitializer*[NumInitializers]; 4682 for (unsigned i=0; i != NumInitializers; ++i) { 4683 TypeSourceInfo *BaseClassInfo = 0; 4684 bool IsBaseVirtual = false; 4685 FieldDecl *Member = 0; 4686 IndirectFieldDecl *IndirectMember = 0; 4687 4688 bool IsBaseInitializer = Record[Idx++]; 4689 if (IsBaseInitializer) { 4690 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 4691 IsBaseVirtual = Record[Idx++]; 4692 } else { 4693 bool IsIndirectMemberInitializer = Record[Idx++]; 4694 if (IsIndirectMemberInitializer) 4695 IndirectMember = cast<IndirectFieldDecl>(GetDecl(Record[Idx++])); 4696 else 4697 Member = cast<FieldDecl>(GetDecl(Record[Idx++])); 4698 } 4699 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 4700 Expr *Init = ReadExpr(F); 4701 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 4702 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 4703 bool IsWritten = Record[Idx++]; 4704 unsigned SourceOrderOrNumArrayIndices; 4705 llvm::SmallVector<VarDecl *, 8> Indices; 4706 if (IsWritten) { 4707 SourceOrderOrNumArrayIndices = Record[Idx++]; 4708 } else { 4709 SourceOrderOrNumArrayIndices = Record[Idx++]; 4710 Indices.reserve(SourceOrderOrNumArrayIndices); 4711 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 4712 Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++]))); 4713 } 4714 4715 CXXCtorInitializer *BOMInit; 4716 if (IsBaseInitializer) { 4717 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual, 4718 LParenLoc, Init, RParenLoc, 4719 MemberOrEllipsisLoc); 4720 } else if (IsWritten) { 4721 if (Member) 4722 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc, 4723 LParenLoc, Init, RParenLoc); 4724 else 4725 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember, 4726 MemberOrEllipsisLoc, LParenLoc, 4727 Init, RParenLoc); 4728 } else { 4729 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc, 4730 LParenLoc, Init, RParenLoc, 4731 Indices.data(), Indices.size()); 4732 } 4733 4734 if (IsWritten) 4735 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 4736 CtorInitializers[i] = BOMInit; 4737 } 4738 } 4739 4740 return std::make_pair(CtorInitializers, NumInitializers); 4741} 4742 4743NestedNameSpecifier * 4744ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) { 4745 unsigned N = Record[Idx++]; 4746 NestedNameSpecifier *NNS = 0, *Prev = 0; 4747 for (unsigned I = 0; I != N; ++I) { 4748 NestedNameSpecifier::SpecifierKind Kind 4749 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 4750 switch (Kind) { 4751 case NestedNameSpecifier::Identifier: { 4752 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 4753 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 4754 break; 4755 } 4756 4757 case NestedNameSpecifier::Namespace: { 4758 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 4759 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 4760 break; 4761 } 4762 4763 case NestedNameSpecifier::NamespaceAlias: { 4764 NamespaceAliasDecl *Alias 4765 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++])); 4766 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias); 4767 break; 4768 } 4769 4770 case NestedNameSpecifier::TypeSpec: 4771 case NestedNameSpecifier::TypeSpecWithTemplate: { 4772 const Type *T = GetType(Record[Idx++]).getTypePtrOrNull(); 4773 if (!T) 4774 return 0; 4775 4776 bool Template = Record[Idx++]; 4777 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 4778 break; 4779 } 4780 4781 case NestedNameSpecifier::Global: { 4782 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 4783 // No associated value, and there can't be a prefix. 4784 break; 4785 } 4786 } 4787 Prev = NNS; 4788 } 4789 return NNS; 4790} 4791 4792NestedNameSpecifierLoc 4793ASTReader::ReadNestedNameSpecifierLoc(PerFileData &F, const RecordData &Record, 4794 unsigned &Idx) { 4795 unsigned N = Record[Idx++]; 4796 NestedNameSpecifierLocBuilder Builder; 4797 for (unsigned I = 0; I != N; ++I) { 4798 NestedNameSpecifier::SpecifierKind Kind 4799 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 4800 switch (Kind) { 4801 case NestedNameSpecifier::Identifier: { 4802 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 4803 SourceRange Range = ReadSourceRange(F, Record, Idx); 4804 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd()); 4805 break; 4806 } 4807 4808 case NestedNameSpecifier::Namespace: { 4809 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 4810 SourceRange Range = ReadSourceRange(F, Record, Idx); 4811 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd()); 4812 break; 4813 } 4814 4815 case NestedNameSpecifier::NamespaceAlias: { 4816 NamespaceAliasDecl *Alias 4817 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++])); 4818 SourceRange Range = ReadSourceRange(F, Record, Idx); 4819 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd()); 4820 break; 4821 } 4822 4823 case NestedNameSpecifier::TypeSpec: 4824 case NestedNameSpecifier::TypeSpecWithTemplate: { 4825 bool Template = Record[Idx++]; 4826 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 4827 if (!T) 4828 return NestedNameSpecifierLoc(); 4829 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 4830 4831 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 4832 Builder.Extend(*Context, 4833 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 4834 T->getTypeLoc(), ColonColonLoc); 4835 break; 4836 } 4837 4838 case NestedNameSpecifier::Global: { 4839 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 4840 Builder.MakeGlobal(*Context, ColonColonLoc); 4841 break; 4842 } 4843 } 4844 } 4845 4846 return Builder.getWithLocInContext(*Context); 4847} 4848 4849SourceRange 4850ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record, 4851 unsigned &Idx) { 4852 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 4853 SourceLocation end = ReadSourceLocation(F, Record, Idx); 4854 return SourceRange(beg, end); 4855} 4856 4857/// \brief Read an integral value 4858llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 4859 unsigned BitWidth = Record[Idx++]; 4860 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 4861 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 4862 Idx += NumWords; 4863 return Result; 4864} 4865 4866/// \brief Read a signed integral value 4867llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 4868 bool isUnsigned = Record[Idx++]; 4869 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 4870} 4871 4872/// \brief Read a floating-point value 4873llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 4874 return llvm::APFloat(ReadAPInt(Record, Idx)); 4875} 4876 4877// \brief Read a string 4878std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 4879 unsigned Len = Record[Idx++]; 4880 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 4881 Idx += Len; 4882 return Result; 4883} 4884 4885VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 4886 unsigned &Idx) { 4887 unsigned Major = Record[Idx++]; 4888 unsigned Minor = Record[Idx++]; 4889 unsigned Subminor = Record[Idx++]; 4890 if (Minor == 0) 4891 return VersionTuple(Major); 4892 if (Subminor == 0) 4893 return VersionTuple(Major, Minor - 1); 4894 return VersionTuple(Major, Minor - 1, Subminor - 1); 4895} 4896 4897CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record, 4898 unsigned &Idx) { 4899 CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++])); 4900 return CXXTemporary::Create(*Context, Decl); 4901} 4902 4903DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 4904 return Diag(SourceLocation(), DiagID); 4905} 4906 4907DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 4908 return Diags.Report(Loc, DiagID); 4909} 4910 4911/// \brief Retrieve the identifier table associated with the 4912/// preprocessor. 4913IdentifierTable &ASTReader::getIdentifierTable() { 4914 assert(PP && "Forgot to set Preprocessor ?"); 4915 return PP->getIdentifierTable(); 4916} 4917 4918/// \brief Record that the given ID maps to the given switch-case 4919/// statement. 4920void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 4921 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 4922 SwitchCaseStmts[ID] = SC; 4923} 4924 4925/// \brief Retrieve the switch-case statement with the given ID. 4926SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 4927 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 4928 return SwitchCaseStmts[ID]; 4929} 4930 4931void ASTReader::ClearSwitchCaseIDs() { 4932 SwitchCaseStmts.clear(); 4933} 4934 4935void ASTReader::FinishedDeserializing() { 4936 assert(NumCurrentElementsDeserializing && 4937 "FinishedDeserializing not paired with StartedDeserializing"); 4938 if (NumCurrentElementsDeserializing == 1) { 4939 // If any identifiers with corresponding top-level declarations have 4940 // been loaded, load those declarations now. 4941 while (!PendingIdentifierInfos.empty()) { 4942 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 4943 PendingIdentifierInfos.front().DeclIDs, true); 4944 PendingIdentifierInfos.pop_front(); 4945 } 4946 4947 // Ready to load previous declarations of Decls that were delayed. 4948 while (!PendingPreviousDecls.empty()) { 4949 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 4950 PendingPreviousDecls.front().second); 4951 PendingPreviousDecls.pop_front(); 4952 } 4953 4954 // We are not in recursive loading, so it's safe to pass the "interesting" 4955 // decls to the consumer. 4956 if (Consumer) 4957 PassInterestingDeclsToConsumer(); 4958 4959 assert(PendingForwardRefs.size() == 0 && 4960 "Some forward refs did not get linked to the definition!"); 4961 } 4962 --NumCurrentElementsDeserializing; 4963} 4964 4965ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 4966 const char *isysroot, bool DisableValidation, 4967 bool DisableStatCache) 4968 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 4969 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 4970 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 4971 Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation), 4972 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 4973 NumSLocEntriesRead(0), TotalNumSLocEntries(0), NextSLocOffset(0), 4974 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 4975 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 4976 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 4977 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 4978 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 4979 NumCurrentElementsDeserializing(0) 4980{ 4981 RelocatablePCH = false; 4982} 4983 4984ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 4985 Diagnostic &Diags, const char *isysroot, 4986 bool DisableValidation, bool DisableStatCache) 4987 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 4988 Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), 4989 isysroot(isysroot), DisableValidation(DisableValidation), 4990 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 4991 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 4992 NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0), 4993 NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0), 4994 NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 4995 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4996 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 4997 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 4998 RelocatablePCH = false; 4999} 5000 5001ASTReader::~ASTReader() { 5002 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 5003 delete Chain[e - i - 1]; 5004 // Delete all visible decl lookup tables 5005 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 5006 E = DeclContextOffsets.end(); 5007 I != E; ++I) { 5008 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 5009 J != F; ++J) { 5010 if (J->NameLookupTableData) 5011 delete static_cast<ASTDeclContextNameLookupTable*>( 5012 J->NameLookupTableData); 5013 } 5014 } 5015 for (DeclContextVisibleUpdatesPending::iterator 5016 I = PendingVisibleUpdates.begin(), 5017 E = PendingVisibleUpdates.end(); 5018 I != E; ++I) { 5019 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5020 F = I->second.end(); 5021 J != F; ++J) 5022 delete static_cast<ASTDeclContextNameLookupTable*>(*J); 5023 } 5024} 5025 5026ASTReader::PerFileData::PerFileData(ASTFileType Ty) 5027 : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0), LocalSLocSize(0), 5028 LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0), 5029 IdentifierLookupTable(0), LocalNumMacroDefinitions(0), 5030 MacroDefinitionOffsets(0), 5031 LocalNumHeaderFileInfos(0), HeaderFileInfoTableData(0), 5032 HeaderFileInfoTable(0), 5033 LocalNumSelectors(0), SelectorOffsets(0), 5034 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 5035 DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 5036 LocalNumTypes(0), TypeOffsets(0), StatCache(0), 5037 NumPreallocatedPreprocessingEntities(0), NextInSource(0) 5038{} 5039 5040ASTReader::PerFileData::~PerFileData() { 5041 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 5042 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable); 5043 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 5044} 5045