ASTReader.cpp revision 5655837683843a526da9d5af1eb0edbed8c0bc94
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.back()); 2467 ASTBuffers.pop_back(); 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() != 2) { 3013 Error("Incorrect encoding of lvalue reference type"); 3014 return QualType(); 3015 } 3016 QualType PointeeType = GetType(Record[0]); 3017 return Context->getLValueReferenceType(PointeeType, Record[1]); 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() != 5) { 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], Record[3], (CallingConv)Record[4]); 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 /*hasregparm*/ Record[2], 3110 /*regparm*/ Record[3], 3111 static_cast<CallingConv>(Record[4])); 3112 3113 unsigned Idx = 5; 3114 unsigned NumParams = Record[Idx++]; 3115 llvm::SmallVector<QualType, 16> ParamTypes; 3116 for (unsigned I = 0; I != NumParams; ++I) 3117 ParamTypes.push_back(GetType(Record[Idx++])); 3118 3119 EPI.Variadic = Record[Idx++]; 3120 EPI.TypeQuals = Record[Idx++]; 3121 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3122 ExceptionSpecificationType EST = 3123 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3124 EPI.ExceptionSpecType = EST; 3125 if (EST == EST_Dynamic) { 3126 EPI.NumExceptions = Record[Idx++]; 3127 llvm::SmallVector<QualType, 2> Exceptions; 3128 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3129 Exceptions.push_back(GetType(Record[Idx++])); 3130 EPI.Exceptions = Exceptions.data(); 3131 } else if (EST == EST_ComputedNoexcept) { 3132 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3133 } 3134 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 3135 EPI); 3136 } 3137 3138 case TYPE_UNRESOLVED_USING: 3139 return Context->getTypeDeclType( 3140 cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0]))); 3141 3142 case TYPE_TYPEDEF: { 3143 if (Record.size() != 2) { 3144 Error("incorrect encoding of typedef type"); 3145 return QualType(); 3146 } 3147 TypedefDecl *Decl = cast<TypedefDecl>(GetDecl(Record[0])); 3148 QualType Canonical = GetType(Record[1]); 3149 if (!Canonical.isNull()) 3150 Canonical = Context->getCanonicalType(Canonical); 3151 return Context->getTypedefType(Decl, Canonical); 3152 } 3153 3154 case TYPE_TYPEOF_EXPR: 3155 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 3156 3157 case TYPE_TYPEOF: { 3158 if (Record.size() != 1) { 3159 Error("incorrect encoding of typeof(type) in AST file"); 3160 return QualType(); 3161 } 3162 QualType UnderlyingType = GetType(Record[0]); 3163 return Context->getTypeOfType(UnderlyingType); 3164 } 3165 3166 case TYPE_DECLTYPE: 3167 return Context->getDecltypeType(ReadExpr(*Loc.F)); 3168 3169 case TYPE_AUTO: 3170 return Context->getAutoType(GetType(Record[0])); 3171 3172 case TYPE_RECORD: { 3173 if (Record.size() != 2) { 3174 Error("incorrect encoding of record type"); 3175 return QualType(); 3176 } 3177 bool IsDependent = Record[0]; 3178 QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1]))); 3179 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3180 return T; 3181 } 3182 3183 case TYPE_ENUM: { 3184 if (Record.size() != 2) { 3185 Error("incorrect encoding of enum type"); 3186 return QualType(); 3187 } 3188 bool IsDependent = Record[0]; 3189 QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1]))); 3190 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3191 return T; 3192 } 3193 3194 case TYPE_ATTRIBUTED: { 3195 if (Record.size() != 3) { 3196 Error("incorrect encoding of attributed type"); 3197 return QualType(); 3198 } 3199 QualType modifiedType = GetType(Record[0]); 3200 QualType equivalentType = GetType(Record[1]); 3201 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3202 return Context->getAttributedType(kind, modifiedType, equivalentType); 3203 } 3204 3205 case TYPE_PAREN: { 3206 if (Record.size() != 1) { 3207 Error("incorrect encoding of paren type"); 3208 return QualType(); 3209 } 3210 QualType InnerType = GetType(Record[0]); 3211 return Context->getParenType(InnerType); 3212 } 3213 3214 case TYPE_PACK_EXPANSION: { 3215 if (Record.size() != 2) { 3216 Error("incorrect encoding of pack expansion type"); 3217 return QualType(); 3218 } 3219 QualType Pattern = GetType(Record[0]); 3220 if (Pattern.isNull()) 3221 return QualType(); 3222 llvm::Optional<unsigned> NumExpansions; 3223 if (Record[1]) 3224 NumExpansions = Record[1] - 1; 3225 return Context->getPackExpansionType(Pattern, NumExpansions); 3226 } 3227 3228 case TYPE_ELABORATED: { 3229 unsigned Idx = 0; 3230 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3231 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3232 QualType NamedType = GetType(Record[Idx++]); 3233 return Context->getElaboratedType(Keyword, NNS, NamedType); 3234 } 3235 3236 case TYPE_OBJC_INTERFACE: { 3237 unsigned Idx = 0; 3238 ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++])); 3239 return Context->getObjCInterfaceType(ItfD); 3240 } 3241 3242 case TYPE_OBJC_OBJECT: { 3243 unsigned Idx = 0; 3244 QualType Base = GetType(Record[Idx++]); 3245 unsigned NumProtos = Record[Idx++]; 3246 llvm::SmallVector<ObjCProtocolDecl*, 4> Protos; 3247 for (unsigned I = 0; I != NumProtos; ++I) 3248 Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++]))); 3249 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 3250 } 3251 3252 case TYPE_OBJC_OBJECT_POINTER: { 3253 unsigned Idx = 0; 3254 QualType Pointee = GetType(Record[Idx++]); 3255 return Context->getObjCObjectPointerType(Pointee); 3256 } 3257 3258 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3259 unsigned Idx = 0; 3260 QualType Parm = GetType(Record[Idx++]); 3261 QualType Replacement = GetType(Record[Idx++]); 3262 return 3263 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3264 Replacement); 3265 } 3266 3267 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3268 unsigned Idx = 0; 3269 QualType Parm = GetType(Record[Idx++]); 3270 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3271 return Context->getSubstTemplateTypeParmPackType( 3272 cast<TemplateTypeParmType>(Parm), 3273 ArgPack); 3274 } 3275 3276 case TYPE_INJECTED_CLASS_NAME: { 3277 CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0])); 3278 QualType TST = GetType(Record[1]); // probably derivable 3279 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3280 // for AST reading, too much interdependencies. 3281 return 3282 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3283 } 3284 3285 case TYPE_TEMPLATE_TYPE_PARM: { 3286 unsigned Idx = 0; 3287 unsigned Depth = Record[Idx++]; 3288 unsigned Index = Record[Idx++]; 3289 bool Pack = Record[Idx++]; 3290 IdentifierInfo *Name = GetIdentifierInfo(Record, Idx); 3291 return Context->getTemplateTypeParmType(Depth, Index, Pack, Name); 3292 } 3293 3294 case TYPE_DEPENDENT_NAME: { 3295 unsigned Idx = 0; 3296 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3297 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3298 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 3299 QualType Canon = GetType(Record[Idx++]); 3300 if (!Canon.isNull()) 3301 Canon = Context->getCanonicalType(Canon); 3302 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 3303 } 3304 3305 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3306 unsigned Idx = 0; 3307 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3308 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3309 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 3310 unsigned NumArgs = Record[Idx++]; 3311 llvm::SmallVector<TemplateArgument, 8> Args; 3312 Args.reserve(NumArgs); 3313 while (NumArgs--) 3314 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3315 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 3316 Args.size(), Args.data()); 3317 } 3318 3319 case TYPE_DEPENDENT_SIZED_ARRAY: { 3320 unsigned Idx = 0; 3321 3322 // ArrayType 3323 QualType ElementType = GetType(Record[Idx++]); 3324 ArrayType::ArraySizeModifier ASM 3325 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3326 unsigned IndexTypeQuals = Record[Idx++]; 3327 3328 // DependentSizedArrayType 3329 Expr *NumElts = ReadExpr(*Loc.F); 3330 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3331 3332 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 3333 IndexTypeQuals, Brackets); 3334 } 3335 3336 case TYPE_TEMPLATE_SPECIALIZATION: { 3337 unsigned Idx = 0; 3338 bool IsDependent = Record[Idx++]; 3339 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3340 llvm::SmallVector<TemplateArgument, 8> Args; 3341 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3342 QualType Canon = GetType(Record[Idx++]); 3343 QualType T; 3344 if (Canon.isNull()) 3345 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 3346 Args.size()); 3347 else 3348 T = Context->getTemplateSpecializationType(Name, Args.data(), 3349 Args.size(), Canon); 3350 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3351 return T; 3352 } 3353 } 3354 // Suppress a GCC warning 3355 return QualType(); 3356} 3357 3358class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3359 ASTReader &Reader; 3360 ASTReader::PerFileData &F; 3361 llvm::BitstreamCursor &DeclsCursor; 3362 const ASTReader::RecordData &Record; 3363 unsigned &Idx; 3364 3365 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3366 unsigned &I) { 3367 return Reader.ReadSourceLocation(F, R, I); 3368 } 3369 3370public: 3371 TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F, 3372 const ASTReader::RecordData &Record, unsigned &Idx) 3373 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3374 { } 3375 3376 // We want compile-time assurance that we've enumerated all of 3377 // these, so unfortunately we have to declare them first, then 3378 // define them out-of-line. 3379#define ABSTRACT_TYPELOC(CLASS, PARENT) 3380#define TYPELOC(CLASS, PARENT) \ 3381 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3382#include "clang/AST/TypeLocNodes.def" 3383 3384 void VisitFunctionTypeLoc(FunctionTypeLoc); 3385 void VisitArrayTypeLoc(ArrayTypeLoc); 3386}; 3387 3388void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3389 // nothing to do 3390} 3391void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3392 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3393 if (TL.needsExtraLocalData()) { 3394 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3395 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3396 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3397 TL.setModeAttr(Record[Idx++]); 3398 } 3399} 3400void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3401 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3402} 3403void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3404 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3405} 3406void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3407 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3408} 3409void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3410 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3411} 3412void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3413 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3414} 3415void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3416 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3417 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3418} 3419void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3420 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3421 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3422 if (Record[Idx++]) 3423 TL.setSizeExpr(Reader.ReadExpr(F)); 3424 else 3425 TL.setSizeExpr(0); 3426} 3427void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3428 VisitArrayTypeLoc(TL); 3429} 3430void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3431 VisitArrayTypeLoc(TL); 3432} 3433void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3434 VisitArrayTypeLoc(TL); 3435} 3436void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3437 DependentSizedArrayTypeLoc TL) { 3438 VisitArrayTypeLoc(TL); 3439} 3440void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3441 DependentSizedExtVectorTypeLoc TL) { 3442 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3443} 3444void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3445 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3446} 3447void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3448 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3449} 3450void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3451 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3452 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3453 TL.setTrailingReturn(Record[Idx++]); 3454 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3455 TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 3456 } 3457} 3458void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3459 VisitFunctionTypeLoc(TL); 3460} 3461void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3462 VisitFunctionTypeLoc(TL); 3463} 3464void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3465 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3466} 3467void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3468 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3469} 3470void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3471 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3472 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3473 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3474} 3475void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3476 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3477 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3478 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3479 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3480} 3481void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3482 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3483} 3484void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3485 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3486} 3487void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3488 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3489} 3490void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3491 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3492} 3493void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3494 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3495 if (TL.hasAttrOperand()) { 3496 SourceRange range; 3497 range.setBegin(ReadSourceLocation(Record, Idx)); 3498 range.setEnd(ReadSourceLocation(Record, Idx)); 3499 TL.setAttrOperandParensRange(range); 3500 } 3501 if (TL.hasAttrExprOperand()) { 3502 if (Record[Idx++]) 3503 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3504 else 3505 TL.setAttrExprOperand(0); 3506 } else if (TL.hasAttrEnumOperand()) 3507 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3508} 3509void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3510 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3511} 3512void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3513 SubstTemplateTypeParmTypeLoc TL) { 3514 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3515} 3516void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3517 SubstTemplateTypeParmPackTypeLoc TL) { 3518 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3519} 3520void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3521 TemplateSpecializationTypeLoc TL) { 3522 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3523 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3524 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3525 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3526 TL.setArgLocInfo(i, 3527 Reader.GetTemplateArgumentLocInfo(F, 3528 TL.getTypePtr()->getArg(i).getKind(), 3529 Record, Idx)); 3530} 3531void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3532 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3533 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3534} 3535void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3536 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3537 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3538} 3539void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3540 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3541} 3542void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3543 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3544 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3545 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3546} 3547void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3548 DependentTemplateSpecializationTypeLoc TL) { 3549 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3550 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3551 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3552 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3553 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3554 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3555 TL.setArgLocInfo(I, 3556 Reader.GetTemplateArgumentLocInfo(F, 3557 TL.getTypePtr()->getArg(I).getKind(), 3558 Record, Idx)); 3559} 3560void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3561 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3562} 3563void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3564 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3565} 3566void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3567 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3568 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3569 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3570 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3571 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3572} 3573void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3574 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3575} 3576 3577TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F, 3578 const RecordData &Record, 3579 unsigned &Idx) { 3580 QualType InfoTy = GetType(Record[Idx++]); 3581 if (InfoTy.isNull()) 3582 return 0; 3583 3584 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3585 TypeLocReader TLR(*this, F, Record, Idx); 3586 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3587 TLR.Visit(TL); 3588 return TInfo; 3589} 3590 3591QualType ASTReader::GetType(TypeID ID) { 3592 unsigned FastQuals = ID & Qualifiers::FastMask; 3593 unsigned Index = ID >> Qualifiers::FastWidth; 3594 3595 if (Index < NUM_PREDEF_TYPE_IDS) { 3596 QualType T; 3597 switch ((PredefinedTypeIDs)Index) { 3598 case PREDEF_TYPE_NULL_ID: return QualType(); 3599 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3600 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3601 3602 case PREDEF_TYPE_CHAR_U_ID: 3603 case PREDEF_TYPE_CHAR_S_ID: 3604 // FIXME: Check that the signedness of CharTy is correct! 3605 T = Context->CharTy; 3606 break; 3607 3608 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3609 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3610 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3611 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3612 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3613 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3614 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3615 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3616 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3617 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3618 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3619 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3620 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3621 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3622 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3623 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3624 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3625 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3626 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break; 3627 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3628 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3629 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3630 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3631 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3632 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 3633 } 3634 3635 assert(!T.isNull() && "Unknown predefined type"); 3636 return T.withFastQualifiers(FastQuals); 3637 } 3638 3639 Index -= NUM_PREDEF_TYPE_IDS; 3640 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3641 if (TypesLoaded[Index].isNull()) { 3642 TypesLoaded[Index] = ReadTypeRecord(Index); 3643 if (TypesLoaded[Index].isNull()) 3644 return QualType(); 3645 3646 TypesLoaded[Index]->setFromAST(); 3647 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID); 3648 if (DeserializationListener) 3649 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3650 TypesLoaded[Index]); 3651 } 3652 3653 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3654} 3655 3656TypeID ASTReader::GetTypeID(QualType T) const { 3657 return MakeTypeID(T, 3658 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this)); 3659} 3660 3661TypeIdx ASTReader::GetTypeIdx(QualType T) const { 3662 if (T.isNull()) 3663 return TypeIdx(); 3664 assert(!T.getLocalFastQualifiers()); 3665 3666 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3667 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and 3668 // comparing keys of ASTDeclContextNameLookupTable. 3669 // If the type didn't come from the AST file use a specially marked index 3670 // so that any hash/key comparison fail since no such index is stored 3671 // in a AST file. 3672 if (I == TypeIdxs.end()) 3673 return TypeIdx(-1); 3674 return I->second; 3675} 3676 3677unsigned ASTReader::getTotalNumCXXBaseSpecifiers() const { 3678 unsigned Result = 0; 3679 for (unsigned I = 0, N = Chain.size(); I != N; ++I) 3680 Result += Chain[I]->LocalNumCXXBaseSpecifiers; 3681 3682 return Result; 3683} 3684 3685TemplateArgumentLocInfo 3686ASTReader::GetTemplateArgumentLocInfo(PerFileData &F, 3687 TemplateArgument::ArgKind Kind, 3688 const RecordData &Record, 3689 unsigned &Index) { 3690 switch (Kind) { 3691 case TemplateArgument::Expression: 3692 return ReadExpr(F); 3693 case TemplateArgument::Type: 3694 return GetTypeSourceInfo(F, Record, Index); 3695 case TemplateArgument::Template: { 3696 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3697 Index); 3698 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3699 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3700 SourceLocation()); 3701 } 3702 case TemplateArgument::TemplateExpansion: { 3703 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3704 Index); 3705 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3706 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 3707 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3708 EllipsisLoc); 3709 } 3710 case TemplateArgument::Null: 3711 case TemplateArgument::Integral: 3712 case TemplateArgument::Declaration: 3713 case TemplateArgument::Pack: 3714 return TemplateArgumentLocInfo(); 3715 } 3716 llvm_unreachable("unexpected template argument loc"); 3717 return TemplateArgumentLocInfo(); 3718} 3719 3720TemplateArgumentLoc 3721ASTReader::ReadTemplateArgumentLoc(PerFileData &F, 3722 const RecordData &Record, unsigned &Index) { 3723 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 3724 3725 if (Arg.getKind() == TemplateArgument::Expression) { 3726 if (Record[Index++]) // bool InfoHasSameExpr. 3727 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3728 } 3729 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 3730 Record, Index)); 3731} 3732 3733Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3734 return GetDecl(ID); 3735} 3736 3737uint64_t 3738ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) { 3739 if (ID == 0) 3740 return 0; 3741 3742 --ID; 3743 uint64_t Offset = 0; 3744 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3745 PerFileData &F = *Chain[N - I - 1]; 3746 3747 if (ID < F.LocalNumCXXBaseSpecifiers) 3748 return Offset + F.CXXBaseSpecifiersOffsets[ID]; 3749 3750 ID -= F.LocalNumCXXBaseSpecifiers; 3751 Offset += F.SizeInBits; 3752 } 3753 3754 assert(false && "CXXBaseSpecifiers not found"); 3755 return 0; 3756} 3757 3758CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 3759 // Figure out which AST file contains this offset. 3760 PerFileData *F = 0; 3761 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3762 if (Offset < Chain[N - I - 1]->SizeInBits) { 3763 F = Chain[N - I - 1]; 3764 break; 3765 } 3766 3767 Offset -= Chain[N - I - 1]->SizeInBits; 3768 } 3769 3770 if (!F) { 3771 Error("Malformed AST file: C++ base specifiers at impossible offset"); 3772 return 0; 3773 } 3774 3775 llvm::BitstreamCursor &Cursor = F->DeclsCursor; 3776 SavedStreamPosition SavedPosition(Cursor); 3777 Cursor.JumpToBit(Offset); 3778 ReadingKindTracker ReadingKind(Read_Decl, *this); 3779 RecordData Record; 3780 unsigned Code = Cursor.ReadCode(); 3781 unsigned RecCode = Cursor.ReadRecord(Code, Record); 3782 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 3783 Error("Malformed AST file: missing C++ base specifiers"); 3784 return 0; 3785 } 3786 3787 unsigned Idx = 0; 3788 unsigned NumBases = Record[Idx++]; 3789 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 3790 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 3791 for (unsigned I = 0; I != NumBases; ++I) 3792 Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx); 3793 return Bases; 3794} 3795 3796TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 3797 if (!DeclsLoaded[0]) { 3798 ReadDeclRecord(0, 1); 3799 if (DeserializationListener) 3800 DeserializationListener->DeclRead(1, DeclsLoaded[0]); 3801 } 3802 3803 return cast<TranslationUnitDecl>(DeclsLoaded[0]); 3804} 3805 3806Decl *ASTReader::GetDecl(DeclID ID) { 3807 if (ID == 0) 3808 return 0; 3809 3810 if (ID > DeclsLoaded.size()) { 3811 Error("declaration ID out-of-range for AST file"); 3812 return 0; 3813 } 3814 3815 unsigned Index = ID - 1; 3816 if (!DeclsLoaded[Index]) { 3817 ReadDeclRecord(Index, ID); 3818 if (DeserializationListener) 3819 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 3820 } 3821 3822 return DeclsLoaded[Index]; 3823} 3824 3825/// \brief Resolve the offset of a statement into a statement. 3826/// 3827/// This operation will read a new statement from the external 3828/// source each time it is called, and is meant to be used via a 3829/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 3830Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 3831 // Switch case IDs are per Decl. 3832 ClearSwitchCaseIDs(); 3833 3834 // Offset here is a global offset across the entire chain. 3835 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3836 PerFileData &F = *Chain[N - I - 1]; 3837 if (Offset < F.SizeInBits) { 3838 // Since we know that this statement is part of a decl, make sure to use 3839 // the decl cursor to read it. 3840 F.DeclsCursor.JumpToBit(Offset); 3841 return ReadStmtFromStream(F); 3842 } 3843 Offset -= F.SizeInBits; 3844 } 3845 llvm_unreachable("Broken chain"); 3846} 3847 3848bool ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 3849 bool (*isKindWeWant)(Decl::Kind), 3850 llvm::SmallVectorImpl<Decl*> &Decls) { 3851 assert(DC->hasExternalLexicalStorage() && 3852 "DeclContext has no lexical decls in storage"); 3853 3854 // There might be lexical decls in multiple parts of the chain, for the TU 3855 // at least. 3856 // DeclContextOffsets might reallocate as we load additional decls below, 3857 // so make a copy of the vector. 3858 DeclContextInfos Infos = DeclContextOffsets[DC]; 3859 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3860 I != E; ++I) { 3861 // IDs can be 0 if this context doesn't contain declarations. 3862 if (!I->LexicalDecls) 3863 continue; 3864 3865 // Load all of the declaration IDs 3866 for (const KindDeclIDPair *ID = I->LexicalDecls, 3867 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 3868 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 3869 continue; 3870 3871 Decl *D = GetDecl(ID->second); 3872 assert(D && "Null decl in lexical decls"); 3873 Decls.push_back(D); 3874 } 3875 } 3876 3877 ++NumLexicalDeclContextsRead; 3878 return false; 3879} 3880 3881DeclContext::lookup_result 3882ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 3883 DeclarationName Name) { 3884 assert(DC->hasExternalVisibleStorage() && 3885 "DeclContext has no visible decls in storage"); 3886 if (!Name) 3887 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 3888 DeclContext::lookup_iterator(0)); 3889 3890 llvm::SmallVector<NamedDecl *, 64> Decls; 3891 // There might be visible decls in multiple parts of the chain, for the TU 3892 // and namespaces. For any given name, the last available results replace 3893 // all earlier ones. For this reason, we walk in reverse. 3894 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3895 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 3896 I != E; ++I) { 3897 if (!I->NameLookupTableData) 3898 continue; 3899 3900 ASTDeclContextNameLookupTable *LookupTable = 3901 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3902 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 3903 if (Pos == LookupTable->end()) 3904 continue; 3905 3906 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 3907 for (; Data.first != Data.second; ++Data.first) 3908 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3909 break; 3910 } 3911 3912 ++NumVisibleDeclContextsRead; 3913 3914 SetExternalVisibleDeclsForName(DC, Name, Decls); 3915 return const_cast<DeclContext*>(DC)->lookup(Name); 3916} 3917 3918void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 3919 assert(DC->hasExternalVisibleStorage() && 3920 "DeclContext has no visible decls in storage"); 3921 3922 llvm::SmallVector<NamedDecl *, 64> Decls; 3923 // There might be visible decls in multiple parts of the chain, for the TU 3924 // and namespaces. 3925 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3926 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3927 I != E; ++I) { 3928 if (!I->NameLookupTableData) 3929 continue; 3930 3931 ASTDeclContextNameLookupTable *LookupTable = 3932 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3933 for (ASTDeclContextNameLookupTable::item_iterator 3934 ItemI = LookupTable->item_begin(), 3935 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 3936 ASTDeclContextNameLookupTable::item_iterator::value_type Val 3937 = *ItemI; 3938 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 3939 Decls.clear(); 3940 for (; Data.first != Data.second; ++Data.first) 3941 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3942 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 3943 } 3944 } 3945} 3946 3947void ASTReader::PassInterestingDeclsToConsumer() { 3948 assert(Consumer); 3949 while (!InterestingDecls.empty()) { 3950 DeclGroupRef DG(InterestingDecls.front()); 3951 InterestingDecls.pop_front(); 3952 Consumer->HandleInterestingDecl(DG); 3953 } 3954} 3955 3956void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 3957 this->Consumer = Consumer; 3958 3959 if (!Consumer) 3960 return; 3961 3962 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 3963 // Force deserialization of this decl, which will cause it to be queued for 3964 // passing to the consumer. 3965 GetDecl(ExternalDefinitions[I]); 3966 } 3967 3968 PassInterestingDeclsToConsumer(); 3969} 3970 3971void ASTReader::PrintStats() { 3972 std::fprintf(stderr, "*** AST File Statistics:\n"); 3973 3974 unsigned NumTypesLoaded 3975 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 3976 QualType()); 3977 unsigned NumDeclsLoaded 3978 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 3979 (Decl *)0); 3980 unsigned NumIdentifiersLoaded 3981 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 3982 IdentifiersLoaded.end(), 3983 (IdentifierInfo *)0); 3984 unsigned NumSelectorsLoaded 3985 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 3986 SelectorsLoaded.end(), 3987 Selector()); 3988 3989 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 3990 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 3991 if (TotalNumSLocEntries) 3992 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 3993 NumSLocEntriesRead, TotalNumSLocEntries, 3994 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 3995 if (!TypesLoaded.empty()) 3996 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 3997 NumTypesLoaded, (unsigned)TypesLoaded.size(), 3998 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 3999 if (!DeclsLoaded.empty()) 4000 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4001 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4002 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4003 if (!IdentifiersLoaded.empty()) 4004 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4005 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4006 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4007 if (!SelectorsLoaded.empty()) 4008 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4009 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4010 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4011 if (TotalNumStatements) 4012 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4013 NumStatementsRead, TotalNumStatements, 4014 ((float)NumStatementsRead/TotalNumStatements * 100)); 4015 if (TotalNumMacros) 4016 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4017 NumMacrosRead, TotalNumMacros, 4018 ((float)NumMacrosRead/TotalNumMacros * 100)); 4019 if (TotalLexicalDeclContexts) 4020 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4021 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4022 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4023 * 100)); 4024 if (TotalVisibleDeclContexts) 4025 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4026 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4027 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4028 * 100)); 4029 if (TotalNumMethodPoolEntries) { 4030 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4031 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4032 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4033 * 100)); 4034 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4035 } 4036 std::fprintf(stderr, "\n"); 4037} 4038 4039void ASTReader::InitializeSema(Sema &S) { 4040 SemaObj = &S; 4041 S.ExternalSource = this; 4042 4043 // Makes sure any declarations that were deserialized "too early" 4044 // still get added to the identifier's declaration chains. 4045 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4046 if (SemaObj->TUScope) 4047 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4048 4049 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4050 } 4051 PreloadedDecls.clear(); 4052 4053 // If there were any tentative definitions, deserialize them and add 4054 // them to Sema's list of tentative definitions. 4055 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4056 VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I])); 4057 SemaObj->TentativeDefinitions.push_back(Var); 4058 } 4059 4060 // If there were any unused file scoped decls, deserialize them and add to 4061 // Sema's list of unused file scoped decls. 4062 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4063 DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4064 SemaObj->UnusedFileScopedDecls.push_back(D); 4065 } 4066 4067 // If there were any locally-scoped external declarations, 4068 // deserialize them and add them to Sema's table of locally-scoped 4069 // external declarations. 4070 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4071 NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4072 SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D; 4073 } 4074 4075 // If there were any ext_vector type declarations, deserialize them 4076 // and add them to Sema's vector of such declarations. 4077 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) 4078 SemaObj->ExtVectorDecls.push_back( 4079 cast<TypedefDecl>(GetDecl(ExtVectorDecls[I]))); 4080 4081 // FIXME: Do VTable uses and dynamic classes deserialize too much ? 4082 // Can we cut them down before writing them ? 4083 4084 // If there were any dynamic classes declarations, deserialize them 4085 // and add them to Sema's vector of such declarations. 4086 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) 4087 SemaObj->DynamicClasses.push_back( 4088 cast<CXXRecordDecl>(GetDecl(DynamicClasses[I]))); 4089 4090 // Load the offsets of the declarations that Sema references. 4091 // They will be lazily deserialized when needed. 4092 if (!SemaDeclRefs.empty()) { 4093 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4094 SemaObj->StdNamespace = SemaDeclRefs[0]; 4095 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4096 } 4097 4098 for (PerFileData *F = FirstInSource; F; F = F->NextInSource) { 4099 4100 // If there are @selector references added them to its pool. This is for 4101 // implementation of -Wselector. 4102 if (!F->ReferencedSelectorsData.empty()) { 4103 unsigned int DataSize = F->ReferencedSelectorsData.size()-1; 4104 unsigned I = 0; 4105 while (I < DataSize) { 4106 Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]); 4107 SourceLocation SelLoc = ReadSourceLocation( 4108 *F, F->ReferencedSelectorsData, I); 4109 SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc)); 4110 } 4111 } 4112 4113 // If there were any pending implicit instantiations, deserialize them 4114 // and add them to Sema's queue of such instantiations. 4115 assert(F->PendingInstantiations.size() % 2 == 0 && 4116 "Expected pairs of entries"); 4117 for (unsigned Idx = 0, N = F->PendingInstantiations.size(); Idx < N;) { 4118 ValueDecl *D=cast<ValueDecl>(GetDecl(F->PendingInstantiations[Idx++])); 4119 SourceLocation Loc = ReadSourceLocation(*F, F->PendingInstantiations,Idx); 4120 SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc)); 4121 } 4122 } 4123 4124 // The two special data sets below always come from the most recent PCH, 4125 // which is at the front of the chain. 4126 PerFileData &F = *Chain.front(); 4127 4128 // If there were any weak undeclared identifiers, deserialize them and add to 4129 // Sema's list of weak undeclared identifiers. 4130 if (!WeakUndeclaredIdentifiers.empty()) { 4131 unsigned Idx = 0; 4132 for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) { 4133 IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 4134 IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 4135 SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx); 4136 bool Used = WeakUndeclaredIdentifiers[Idx++]; 4137 Sema::WeakInfo WI(AliasId, Loc); 4138 WI.setUsed(Used); 4139 SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI)); 4140 } 4141 } 4142 4143 // If there were any VTable uses, deserialize the information and add it 4144 // to Sema's vector and map of VTable uses. 4145 if (!VTableUses.empty()) { 4146 unsigned Idx = 0; 4147 for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) { 4148 CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4149 SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx); 4150 bool DefinitionRequired = VTableUses[Idx++]; 4151 SemaObj->VTableUses.push_back(std::make_pair(Class, Loc)); 4152 SemaObj->VTablesUsed[Class] = DefinitionRequired; 4153 } 4154 } 4155 4156 if (!FPPragmaOptions.empty()) { 4157 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4158 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4159 } 4160 4161 if (!OpenCLExtensions.empty()) { 4162 unsigned I = 0; 4163#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4164#include "clang/Basic/OpenCLExtensions.def" 4165 4166 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4167 } 4168} 4169 4170IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4171 // Try to find this name within our on-disk hash tables. We start with the 4172 // most recent one, since that one contains the most up-to-date info. 4173 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4174 ASTIdentifierLookupTable *IdTable 4175 = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable; 4176 if (!IdTable) 4177 continue; 4178 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 4179 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 4180 if (Pos == IdTable->end()) 4181 continue; 4182 4183 // Dereferencing the iterator has the effect of building the 4184 // IdentifierInfo node and populating it with the various 4185 // declarations it needs. 4186 return *Pos; 4187 } 4188 return 0; 4189} 4190 4191namespace clang { 4192 /// \brief An identifier-lookup iterator that enumerates all of the 4193 /// identifiers stored within a set of AST files. 4194 class ASTIdentifierIterator : public IdentifierIterator { 4195 /// \brief The AST reader whose identifiers are being enumerated. 4196 const ASTReader &Reader; 4197 4198 /// \brief The current index into the chain of AST files stored in 4199 /// the AST reader. 4200 unsigned Index; 4201 4202 /// \brief The current position within the identifier lookup table 4203 /// of the current AST file. 4204 ASTIdentifierLookupTable::key_iterator Current; 4205 4206 /// \brief The end position within the identifier lookup table of 4207 /// the current AST file. 4208 ASTIdentifierLookupTable::key_iterator End; 4209 4210 public: 4211 explicit ASTIdentifierIterator(const ASTReader &Reader); 4212 4213 virtual llvm::StringRef Next(); 4214 }; 4215} 4216 4217ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4218 : Reader(Reader), Index(Reader.Chain.size() - 1) { 4219 ASTIdentifierLookupTable *IdTable 4220 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 4221 Current = IdTable->key_begin(); 4222 End = IdTable->key_end(); 4223} 4224 4225llvm::StringRef ASTIdentifierIterator::Next() { 4226 while (Current == End) { 4227 // If we have exhausted all of our AST files, we're done. 4228 if (Index == 0) 4229 return llvm::StringRef(); 4230 4231 --Index; 4232 ASTIdentifierLookupTable *IdTable 4233 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 4234 Current = IdTable->key_begin(); 4235 End = IdTable->key_end(); 4236 } 4237 4238 // We have any identifiers remaining in the current AST file; return 4239 // the next one. 4240 std::pair<const char*, unsigned> Key = *Current; 4241 ++Current; 4242 return llvm::StringRef(Key.first, Key.second); 4243} 4244 4245IdentifierIterator *ASTReader::getIdentifiers() const { 4246 return new ASTIdentifierIterator(*this); 4247} 4248 4249std::pair<ObjCMethodList, ObjCMethodList> 4250ASTReader::ReadMethodPool(Selector Sel) { 4251 // Find this selector in a hash table. We want to find the most recent entry. 4252 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4253 PerFileData &F = *Chain[I]; 4254 if (!F.SelectorLookupTable) 4255 continue; 4256 4257 ASTSelectorLookupTable *PoolTable 4258 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 4259 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 4260 if (Pos != PoolTable->end()) { 4261 ++NumSelectorsRead; 4262 // FIXME: Not quite happy with the statistics here. We probably should 4263 // disable this tracking when called via LoadSelector. 4264 // Also, should entries without methods count as misses? 4265 ++NumMethodPoolEntriesRead; 4266 ASTSelectorLookupTrait::data_type Data = *Pos; 4267 if (DeserializationListener) 4268 DeserializationListener->SelectorRead(Data.ID, Sel); 4269 return std::make_pair(Data.Instance, Data.Factory); 4270 } 4271 } 4272 4273 ++NumMethodPoolMisses; 4274 return std::pair<ObjCMethodList, ObjCMethodList>(); 4275} 4276 4277void ASTReader::LoadSelector(Selector Sel) { 4278 // It would be complicated to avoid reading the methods anyway. So don't. 4279 ReadMethodPool(Sel); 4280} 4281 4282void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { 4283 assert(ID && "Non-zero identifier ID required"); 4284 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4285 IdentifiersLoaded[ID - 1] = II; 4286 if (DeserializationListener) 4287 DeserializationListener->IdentifierRead(ID, II); 4288} 4289 4290/// \brief Set the globally-visible declarations associated with the given 4291/// identifier. 4292/// 4293/// If the AST reader is currently in a state where the given declaration IDs 4294/// cannot safely be resolved, they are queued until it is safe to resolve 4295/// them. 4296/// 4297/// \param II an IdentifierInfo that refers to one or more globally-visible 4298/// declarations. 4299/// 4300/// \param DeclIDs the set of declaration IDs with the name @p II that are 4301/// visible at global scope. 4302/// 4303/// \param Nonrecursive should be true to indicate that the caller knows that 4304/// this call is non-recursive, and therefore the globally-visible declarations 4305/// will not be placed onto the pending queue. 4306void 4307ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4308 const llvm::SmallVectorImpl<uint32_t> &DeclIDs, 4309 bool Nonrecursive) { 4310 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4311 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4312 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4313 PII.II = II; 4314 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4315 return; 4316 } 4317 4318 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4319 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4320 if (SemaObj) { 4321 if (SemaObj->TUScope) { 4322 // Introduce this declaration into the translation-unit scope 4323 // and add it to the declaration chain for this identifier, so 4324 // that (unqualified) name lookup will find it. 4325 SemaObj->TUScope->AddDecl(D); 4326 } 4327 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4328 } else { 4329 // Queue this declaration so that it will be added to the 4330 // translation unit scope and identifier's declaration chain 4331 // once a Sema object is known. 4332 PreloadedDecls.push_back(D); 4333 } 4334 } 4335} 4336 4337IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) { 4338 if (ID == 0) 4339 return 0; 4340 4341 if (IdentifiersLoaded.empty()) { 4342 Error("no identifier table in AST file"); 4343 return 0; 4344 } 4345 4346 assert(PP && "Forgot to set Preprocessor ?"); 4347 ID -= 1; 4348 if (!IdentifiersLoaded[ID]) { 4349 unsigned Index = ID; 4350 const char *Str = 0; 4351 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4352 PerFileData *F = Chain[N - I - 1]; 4353 if (Index < F->LocalNumIdentifiers) { 4354 uint32_t Offset = F->IdentifierOffsets[Index]; 4355 Str = F->IdentifierTableData + Offset; 4356 break; 4357 } 4358 Index -= F->LocalNumIdentifiers; 4359 } 4360 assert(Str && "Broken Chain"); 4361 4362 // All of the strings in the AST file are preceded by a 16-bit length. 4363 // Extract that 16-bit length to avoid having to execute strlen(). 4364 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4365 // unsigned integers. This is important to avoid integer overflow when 4366 // we cast them to 'unsigned'. 4367 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4368 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4369 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4370 IdentifiersLoaded[ID] 4371 = &PP->getIdentifierTable().get(Str, StrLen); 4372 if (DeserializationListener) 4373 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4374 } 4375 4376 return IdentifiersLoaded[ID]; 4377} 4378 4379void ASTReader::ReadSLocEntry(unsigned ID) { 4380 ReadSLocEntryRecord(ID); 4381} 4382 4383Selector ASTReader::DecodeSelector(unsigned ID) { 4384 if (ID == 0) 4385 return Selector(); 4386 4387 if (ID > SelectorsLoaded.size()) { 4388 Error("selector ID out of range in AST file"); 4389 return Selector(); 4390 } 4391 4392 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4393 // Load this selector from the selector table. 4394 unsigned Idx = ID - 1; 4395 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4396 PerFileData &F = *Chain[N - I - 1]; 4397 if (Idx < F.LocalNumSelectors) { 4398 ASTSelectorLookupTrait Trait(*this); 4399 SelectorsLoaded[ID - 1] = 4400 Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0); 4401 if (DeserializationListener) 4402 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4403 break; 4404 } 4405 Idx -= F.LocalNumSelectors; 4406 } 4407 } 4408 4409 return SelectorsLoaded[ID - 1]; 4410} 4411 4412Selector ASTReader::GetExternalSelector(uint32_t ID) { 4413 return DecodeSelector(ID); 4414} 4415 4416uint32_t ASTReader::GetNumExternalSelectors() { 4417 // ID 0 (the null selector) is considered an external selector. 4418 return getTotalNumSelectors() + 1; 4419} 4420 4421DeclarationName 4422ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { 4423 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 4424 switch (Kind) { 4425 case DeclarationName::Identifier: 4426 return DeclarationName(GetIdentifierInfo(Record, Idx)); 4427 4428 case DeclarationName::ObjCZeroArgSelector: 4429 case DeclarationName::ObjCOneArgSelector: 4430 case DeclarationName::ObjCMultiArgSelector: 4431 return DeclarationName(GetSelector(Record, Idx)); 4432 4433 case DeclarationName::CXXConstructorName: 4434 return Context->DeclarationNames.getCXXConstructorName( 4435 Context->getCanonicalType(GetType(Record[Idx++]))); 4436 4437 case DeclarationName::CXXDestructorName: 4438 return Context->DeclarationNames.getCXXDestructorName( 4439 Context->getCanonicalType(GetType(Record[Idx++]))); 4440 4441 case DeclarationName::CXXConversionFunctionName: 4442 return Context->DeclarationNames.getCXXConversionFunctionName( 4443 Context->getCanonicalType(GetType(Record[Idx++]))); 4444 4445 case DeclarationName::CXXOperatorName: 4446 return Context->DeclarationNames.getCXXOperatorName( 4447 (OverloadedOperatorKind)Record[Idx++]); 4448 4449 case DeclarationName::CXXLiteralOperatorName: 4450 return Context->DeclarationNames.getCXXLiteralOperatorName( 4451 GetIdentifierInfo(Record, Idx)); 4452 4453 case DeclarationName::CXXUsingDirective: 4454 return DeclarationName::getUsingDirectiveName(); 4455 } 4456 4457 // Required to silence GCC warning 4458 return DeclarationName(); 4459} 4460 4461void ASTReader::ReadDeclarationNameLoc(PerFileData &F, 4462 DeclarationNameLoc &DNLoc, 4463 DeclarationName Name, 4464 const RecordData &Record, unsigned &Idx) { 4465 switch (Name.getNameKind()) { 4466 case DeclarationName::CXXConstructorName: 4467 case DeclarationName::CXXDestructorName: 4468 case DeclarationName::CXXConversionFunctionName: 4469 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 4470 break; 4471 4472 case DeclarationName::CXXOperatorName: 4473 DNLoc.CXXOperatorName.BeginOpNameLoc 4474 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4475 DNLoc.CXXOperatorName.EndOpNameLoc 4476 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4477 break; 4478 4479 case DeclarationName::CXXLiteralOperatorName: 4480 DNLoc.CXXLiteralOperatorName.OpNameLoc 4481 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4482 break; 4483 4484 case DeclarationName::Identifier: 4485 case DeclarationName::ObjCZeroArgSelector: 4486 case DeclarationName::ObjCOneArgSelector: 4487 case DeclarationName::ObjCMultiArgSelector: 4488 case DeclarationName::CXXUsingDirective: 4489 break; 4490 } 4491} 4492 4493void ASTReader::ReadDeclarationNameInfo(PerFileData &F, 4494 DeclarationNameInfo &NameInfo, 4495 const RecordData &Record, unsigned &Idx) { 4496 NameInfo.setName(ReadDeclarationName(Record, Idx)); 4497 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4498 DeclarationNameLoc DNLoc; 4499 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 4500 NameInfo.setInfo(DNLoc); 4501} 4502 4503void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info, 4504 const RecordData &Record, unsigned &Idx) { 4505 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 4506 unsigned NumTPLists = Record[Idx++]; 4507 Info.NumTemplParamLists = NumTPLists; 4508 if (NumTPLists) { 4509 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 4510 for (unsigned i=0; i != NumTPLists; ++i) 4511 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 4512 } 4513} 4514 4515TemplateName 4516ASTReader::ReadTemplateName(PerFileData &F, const RecordData &Record, 4517 unsigned &Idx) { 4518 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 4519 switch (Kind) { 4520 case TemplateName::Template: 4521 return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++]))); 4522 4523 case TemplateName::OverloadedTemplate: { 4524 unsigned size = Record[Idx++]; 4525 UnresolvedSet<8> Decls; 4526 while (size--) 4527 Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4528 4529 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 4530 } 4531 4532 case TemplateName::QualifiedTemplate: { 4533 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4534 bool hasTemplKeyword = Record[Idx++]; 4535 TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++])); 4536 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 4537 } 4538 4539 case TemplateName::DependentTemplate: { 4540 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4541 if (Record[Idx++]) // isIdentifier 4542 return Context->getDependentTemplateName(NNS, 4543 GetIdentifierInfo(Record, Idx)); 4544 return Context->getDependentTemplateName(NNS, 4545 (OverloadedOperatorKind)Record[Idx++]); 4546 } 4547 4548 case TemplateName::SubstTemplateTemplateParmPack: { 4549 TemplateTemplateParmDecl *Param 4550 = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++])); 4551 if (!Param) 4552 return TemplateName(); 4553 4554 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 4555 if (ArgPack.getKind() != TemplateArgument::Pack) 4556 return TemplateName(); 4557 4558 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack); 4559 } 4560 } 4561 4562 assert(0 && "Unhandled template name kind!"); 4563 return TemplateName(); 4564} 4565 4566TemplateArgument 4567ASTReader::ReadTemplateArgument(PerFileData &F, 4568 const RecordData &Record, unsigned &Idx) { 4569 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 4570 switch (Kind) { 4571 case TemplateArgument::Null: 4572 return TemplateArgument(); 4573 case TemplateArgument::Type: 4574 return TemplateArgument(GetType(Record[Idx++])); 4575 case TemplateArgument::Declaration: 4576 return TemplateArgument(GetDecl(Record[Idx++])); 4577 case TemplateArgument::Integral: { 4578 llvm::APSInt Value = ReadAPSInt(Record, Idx); 4579 QualType T = GetType(Record[Idx++]); 4580 return TemplateArgument(Value, T); 4581 } 4582 case TemplateArgument::Template: 4583 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 4584 case TemplateArgument::TemplateExpansion: { 4585 TemplateName Name = ReadTemplateName(F, Record, Idx); 4586 llvm::Optional<unsigned> NumTemplateExpansions; 4587 if (unsigned NumExpansions = Record[Idx++]) 4588 NumTemplateExpansions = NumExpansions - 1; 4589 return TemplateArgument(Name, NumTemplateExpansions); 4590 } 4591 case TemplateArgument::Expression: 4592 return TemplateArgument(ReadExpr(F)); 4593 case TemplateArgument::Pack: { 4594 unsigned NumArgs = Record[Idx++]; 4595 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs]; 4596 for (unsigned I = 0; I != NumArgs; ++I) 4597 Args[I] = ReadTemplateArgument(F, Record, Idx); 4598 return TemplateArgument(Args, NumArgs); 4599 } 4600 } 4601 4602 assert(0 && "Unhandled template argument kind!"); 4603 return TemplateArgument(); 4604} 4605 4606TemplateParameterList * 4607ASTReader::ReadTemplateParameterList(PerFileData &F, 4608 const RecordData &Record, unsigned &Idx) { 4609 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 4610 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 4611 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 4612 4613 unsigned NumParams = Record[Idx++]; 4614 llvm::SmallVector<NamedDecl *, 16> Params; 4615 Params.reserve(NumParams); 4616 while (NumParams--) 4617 Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4618 4619 TemplateParameterList* TemplateParams = 4620 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 4621 Params.data(), Params.size(), RAngleLoc); 4622 return TemplateParams; 4623} 4624 4625void 4626ASTReader:: 4627ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs, 4628 PerFileData &F, const RecordData &Record, 4629 unsigned &Idx) { 4630 unsigned NumTemplateArgs = Record[Idx++]; 4631 TemplArgs.reserve(NumTemplateArgs); 4632 while (NumTemplateArgs--) 4633 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 4634} 4635 4636/// \brief Read a UnresolvedSet structure. 4637void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set, 4638 const RecordData &Record, unsigned &Idx) { 4639 unsigned NumDecls = Record[Idx++]; 4640 while (NumDecls--) { 4641 NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++])); 4642 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 4643 Set.addDecl(D, AS); 4644 } 4645} 4646 4647CXXBaseSpecifier 4648ASTReader::ReadCXXBaseSpecifier(PerFileData &F, 4649 const RecordData &Record, unsigned &Idx) { 4650 bool isVirtual = static_cast<bool>(Record[Idx++]); 4651 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 4652 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 4653 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 4654 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 4655 SourceRange Range = ReadSourceRange(F, Record, Idx); 4656 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 4657 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 4658 EllipsisLoc); 4659 Result.setInheritConstructors(inheritConstructors); 4660 return Result; 4661} 4662 4663std::pair<CXXCtorInitializer **, unsigned> 4664ASTReader::ReadCXXCtorInitializers(PerFileData &F, const RecordData &Record, 4665 unsigned &Idx) { 4666 CXXCtorInitializer **CtorInitializers = 0; 4667 unsigned NumInitializers = Record[Idx++]; 4668 if (NumInitializers) { 4669 ASTContext &C = *getContext(); 4670 4671 CtorInitializers 4672 = new (C) CXXCtorInitializer*[NumInitializers]; 4673 for (unsigned i=0; i != NumInitializers; ++i) { 4674 TypeSourceInfo *BaseClassInfo = 0; 4675 bool IsBaseVirtual = false; 4676 FieldDecl *Member = 0; 4677 IndirectFieldDecl *IndirectMember = 0; 4678 4679 bool IsBaseInitializer = Record[Idx++]; 4680 if (IsBaseInitializer) { 4681 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 4682 IsBaseVirtual = Record[Idx++]; 4683 } else { 4684 bool IsIndirectMemberInitializer = Record[Idx++]; 4685 if (IsIndirectMemberInitializer) 4686 IndirectMember = cast<IndirectFieldDecl>(GetDecl(Record[Idx++])); 4687 else 4688 Member = cast<FieldDecl>(GetDecl(Record[Idx++])); 4689 } 4690 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 4691 Expr *Init = ReadExpr(F); 4692 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 4693 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 4694 bool IsWritten = Record[Idx++]; 4695 unsigned SourceOrderOrNumArrayIndices; 4696 llvm::SmallVector<VarDecl *, 8> Indices; 4697 if (IsWritten) { 4698 SourceOrderOrNumArrayIndices = Record[Idx++]; 4699 } else { 4700 SourceOrderOrNumArrayIndices = Record[Idx++]; 4701 Indices.reserve(SourceOrderOrNumArrayIndices); 4702 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 4703 Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++]))); 4704 } 4705 4706 CXXCtorInitializer *BOMInit; 4707 if (IsBaseInitializer) { 4708 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual, 4709 LParenLoc, Init, RParenLoc, 4710 MemberOrEllipsisLoc); 4711 } else if (IsWritten) { 4712 if (Member) 4713 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc, 4714 LParenLoc, Init, RParenLoc); 4715 else 4716 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember, 4717 MemberOrEllipsisLoc, LParenLoc, 4718 Init, RParenLoc); 4719 } else { 4720 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc, 4721 LParenLoc, Init, RParenLoc, 4722 Indices.data(), Indices.size()); 4723 } 4724 4725 if (IsWritten) 4726 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 4727 CtorInitializers[i] = BOMInit; 4728 } 4729 } 4730 4731 return std::make_pair(CtorInitializers, NumInitializers); 4732} 4733 4734NestedNameSpecifier * 4735ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) { 4736 unsigned N = Record[Idx++]; 4737 NestedNameSpecifier *NNS = 0, *Prev = 0; 4738 for (unsigned I = 0; I != N; ++I) { 4739 NestedNameSpecifier::SpecifierKind Kind 4740 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 4741 switch (Kind) { 4742 case NestedNameSpecifier::Identifier: { 4743 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 4744 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 4745 break; 4746 } 4747 4748 case NestedNameSpecifier::Namespace: { 4749 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 4750 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 4751 break; 4752 } 4753 4754 case NestedNameSpecifier::NamespaceAlias: { 4755 NamespaceAliasDecl *Alias 4756 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++])); 4757 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias); 4758 break; 4759 } 4760 4761 case NestedNameSpecifier::TypeSpec: 4762 case NestedNameSpecifier::TypeSpecWithTemplate: { 4763 const Type *T = GetType(Record[Idx++]).getTypePtrOrNull(); 4764 if (!T) 4765 return 0; 4766 4767 bool Template = Record[Idx++]; 4768 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 4769 break; 4770 } 4771 4772 case NestedNameSpecifier::Global: { 4773 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 4774 // No associated value, and there can't be a prefix. 4775 break; 4776 } 4777 } 4778 Prev = NNS; 4779 } 4780 return NNS; 4781} 4782 4783NestedNameSpecifierLoc 4784ASTReader::ReadNestedNameSpecifierLoc(PerFileData &F, const RecordData &Record, 4785 unsigned &Idx) { 4786 unsigned N = Record[Idx++]; 4787 NestedNameSpecifierLocBuilder Builder; 4788 for (unsigned I = 0; I != N; ++I) { 4789 NestedNameSpecifier::SpecifierKind Kind 4790 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 4791 switch (Kind) { 4792 case NestedNameSpecifier::Identifier: { 4793 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 4794 SourceRange Range = ReadSourceRange(F, Record, Idx); 4795 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd()); 4796 break; 4797 } 4798 4799 case NestedNameSpecifier::Namespace: { 4800 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 4801 SourceRange Range = ReadSourceRange(F, Record, Idx); 4802 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd()); 4803 break; 4804 } 4805 4806 case NestedNameSpecifier::NamespaceAlias: { 4807 NamespaceAliasDecl *Alias 4808 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++])); 4809 SourceRange Range = ReadSourceRange(F, Record, Idx); 4810 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd()); 4811 break; 4812 } 4813 4814 case NestedNameSpecifier::TypeSpec: 4815 case NestedNameSpecifier::TypeSpecWithTemplate: { 4816 bool Template = Record[Idx++]; 4817 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 4818 if (!T) 4819 return NestedNameSpecifierLoc(); 4820 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 4821 4822 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 4823 Builder.Extend(*Context, 4824 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 4825 T->getTypeLoc(), ColonColonLoc); 4826 break; 4827 } 4828 4829 case NestedNameSpecifier::Global: { 4830 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 4831 Builder.MakeGlobal(*Context, ColonColonLoc); 4832 break; 4833 } 4834 } 4835 } 4836 4837 return Builder.getWithLocInContext(*Context); 4838} 4839 4840SourceRange 4841ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record, 4842 unsigned &Idx) { 4843 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 4844 SourceLocation end = ReadSourceLocation(F, Record, Idx); 4845 return SourceRange(beg, end); 4846} 4847 4848/// \brief Read an integral value 4849llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 4850 unsigned BitWidth = Record[Idx++]; 4851 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 4852 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 4853 Idx += NumWords; 4854 return Result; 4855} 4856 4857/// \brief Read a signed integral value 4858llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 4859 bool isUnsigned = Record[Idx++]; 4860 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 4861} 4862 4863/// \brief Read a floating-point value 4864llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 4865 return llvm::APFloat(ReadAPInt(Record, Idx)); 4866} 4867 4868// \brief Read a string 4869std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 4870 unsigned Len = Record[Idx++]; 4871 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 4872 Idx += Len; 4873 return Result; 4874} 4875 4876VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 4877 unsigned &Idx) { 4878 unsigned Major = Record[Idx++]; 4879 unsigned Minor = Record[Idx++]; 4880 unsigned Subminor = Record[Idx++]; 4881 if (Minor == 0) 4882 return VersionTuple(Major); 4883 if (Subminor == 0) 4884 return VersionTuple(Major, Minor - 1); 4885 return VersionTuple(Major, Minor - 1, Subminor - 1); 4886} 4887 4888CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record, 4889 unsigned &Idx) { 4890 CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++])); 4891 return CXXTemporary::Create(*Context, Decl); 4892} 4893 4894DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 4895 return Diag(SourceLocation(), DiagID); 4896} 4897 4898DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 4899 return Diags.Report(Loc, DiagID); 4900} 4901 4902/// \brief Retrieve the identifier table associated with the 4903/// preprocessor. 4904IdentifierTable &ASTReader::getIdentifierTable() { 4905 assert(PP && "Forgot to set Preprocessor ?"); 4906 return PP->getIdentifierTable(); 4907} 4908 4909/// \brief Record that the given ID maps to the given switch-case 4910/// statement. 4911void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 4912 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 4913 SwitchCaseStmts[ID] = SC; 4914} 4915 4916/// \brief Retrieve the switch-case statement with the given ID. 4917SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 4918 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 4919 return SwitchCaseStmts[ID]; 4920} 4921 4922void ASTReader::ClearSwitchCaseIDs() { 4923 SwitchCaseStmts.clear(); 4924} 4925 4926void ASTReader::FinishedDeserializing() { 4927 assert(NumCurrentElementsDeserializing && 4928 "FinishedDeserializing not paired with StartedDeserializing"); 4929 if (NumCurrentElementsDeserializing == 1) { 4930 // If any identifiers with corresponding top-level declarations have 4931 // been loaded, load those declarations now. 4932 while (!PendingIdentifierInfos.empty()) { 4933 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 4934 PendingIdentifierInfos.front().DeclIDs, true); 4935 PendingIdentifierInfos.pop_front(); 4936 } 4937 4938 // Ready to load previous declarations of Decls that were delayed. 4939 while (!PendingPreviousDecls.empty()) { 4940 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 4941 PendingPreviousDecls.front().second); 4942 PendingPreviousDecls.pop_front(); 4943 } 4944 4945 // We are not in recursive loading, so it's safe to pass the "interesting" 4946 // decls to the consumer. 4947 if (Consumer) 4948 PassInterestingDeclsToConsumer(); 4949 4950 assert(PendingForwardRefs.size() == 0 && 4951 "Some forward refs did not get linked to the definition!"); 4952 } 4953 --NumCurrentElementsDeserializing; 4954} 4955 4956ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 4957 const char *isysroot, bool DisableValidation, 4958 bool DisableStatCache) 4959 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 4960 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 4961 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 4962 Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation), 4963 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 4964 NumSLocEntriesRead(0), TotalNumSLocEntries(0), NextSLocOffset(0), 4965 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 4966 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 4967 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 4968 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 4969 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 4970 NumCurrentElementsDeserializing(0) 4971{ 4972 RelocatablePCH = false; 4973} 4974 4975ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 4976 Diagnostic &Diags, const char *isysroot, 4977 bool DisableValidation, bool DisableStatCache) 4978 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 4979 Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), 4980 isysroot(isysroot), DisableValidation(DisableValidation), 4981 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 4982 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 4983 NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0), 4984 NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0), 4985 NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 4986 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4987 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 4988 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 4989 RelocatablePCH = false; 4990} 4991 4992ASTReader::~ASTReader() { 4993 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 4994 delete Chain[e - i - 1]; 4995 // Delete all visible decl lookup tables 4996 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 4997 E = DeclContextOffsets.end(); 4998 I != E; ++I) { 4999 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 5000 J != F; ++J) { 5001 if (J->NameLookupTableData) 5002 delete static_cast<ASTDeclContextNameLookupTable*>( 5003 J->NameLookupTableData); 5004 } 5005 } 5006 for (DeclContextVisibleUpdatesPending::iterator 5007 I = PendingVisibleUpdates.begin(), 5008 E = PendingVisibleUpdates.end(); 5009 I != E; ++I) { 5010 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5011 F = I->second.end(); 5012 J != F; ++J) 5013 delete static_cast<ASTDeclContextNameLookupTable*>(*J); 5014 } 5015} 5016 5017ASTReader::PerFileData::PerFileData(ASTFileType Ty) 5018 : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0), LocalSLocSize(0), 5019 LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0), 5020 IdentifierLookupTable(0), LocalNumMacroDefinitions(0), 5021 MacroDefinitionOffsets(0), 5022 LocalNumHeaderFileInfos(0), HeaderFileInfoTableData(0), 5023 HeaderFileInfoTable(0), 5024 LocalNumSelectors(0), SelectorOffsets(0), 5025 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 5026 DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 5027 LocalNumTypes(0), TypeOffsets(0), StatCache(0), 5028 NumPreallocatedPreprocessingEntities(0), NextInSource(0) 5029{} 5030 5031ASTReader::PerFileData::~PerFileData() { 5032 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 5033 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable); 5034 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 5035} 5036