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