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