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