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