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