ASTReader.cpp revision 1da901467f72d1733704b068e22089813a1962fd
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 2431 GlobalCXXBaseSpecifiersMap.insert(std::make_pair( 2432 getTotalNumCXXBaseSpecifiers() + 1, 2433 std::make_pair(&F, 2434 -getTotalNumCXXBaseSpecifiers()))); 2435 2436 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2437 2438 F.GlobalBitOffset = TotalModulesSizeInBits; 2439 TotalModulesSizeInBits += F.SizeInBits; 2440 2441 break; 2442 } 2443 2444 case DIAG_PRAGMA_MAPPINGS: 2445 if (Record.size() % 2 != 0) { 2446 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2447 return Failure; 2448 } 2449 2450 if (F.PragmaDiagMappings.empty()) 2451 F.PragmaDiagMappings.swap(Record); 2452 else 2453 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2454 Record.begin(), Record.end()); 2455 break; 2456 2457 case CUDA_SPECIAL_DECL_REFS: 2458 // Later tables overwrite earlier ones. 2459 CUDASpecialDeclRefs.swap(Record); 2460 break; 2461 2462 case HEADER_SEARCH_TABLE: 2463 F.HeaderFileInfoTableData = BlobStart; 2464 F.LocalNumHeaderFileInfos = Record[1]; 2465 if (Record[0]) { 2466 F.HeaderFileInfoTable 2467 = HeaderFileInfoLookupTable::Create( 2468 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2469 (const unsigned char *)F.HeaderFileInfoTableData); 2470 if (PP) 2471 PP->getHeaderSearchInfo().SetExternalSource(this); 2472 } 2473 break; 2474 2475 case FP_PRAGMA_OPTIONS: 2476 // Later tables overwrite earlier ones. 2477 FPPragmaOptions.swap(Record); 2478 break; 2479 2480 case OPENCL_EXTENSIONS: 2481 // Later tables overwrite earlier ones. 2482 OpenCLExtensions.swap(Record); 2483 break; 2484 2485 case TENTATIVE_DEFINITIONS: 2486 // Optimization for the first block. 2487 if (TentativeDefinitions.empty()) 2488 TentativeDefinitions.swap(Record); 2489 else 2490 TentativeDefinitions.insert(TentativeDefinitions.end(), 2491 Record.begin(), Record.end()); 2492 break; 2493 2494 case KNOWN_NAMESPACES: 2495 // Optimization for the first block. 2496 if (KnownNamespaces.empty()) 2497 KnownNamespaces.swap(Record); 2498 else 2499 KnownNamespaces.insert(KnownNamespaces.end(), 2500 Record.begin(), Record.end()); 2501 break; 2502 } 2503 First = false; 2504 } 2505 Error("premature end of bitstream in AST file"); 2506 return Failure; 2507} 2508 2509ASTReader::ASTReadResult ASTReader::validateFileEntries() { 2510 for (unsigned CI = 0, CN = Chain.size(); CI != CN; ++CI) { 2511 PerFileData *F = Chain[CI]; 2512 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 2513 2514 for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) { 2515 SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]); 2516 unsigned Code = SLocEntryCursor.ReadCode(); 2517 if (Code == llvm::bitc::END_BLOCK || 2518 Code == llvm::bitc::ENTER_SUBBLOCK || 2519 Code == llvm::bitc::DEFINE_ABBREV) { 2520 Error("incorrectly-formatted source location entry in AST file"); 2521 return Failure; 2522 } 2523 2524 RecordData Record; 2525 const char *BlobStart; 2526 unsigned BlobLen; 2527 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2528 default: 2529 Error("incorrectly-formatted source location entry in AST file"); 2530 return Failure; 2531 2532 case SM_SLOC_FILE_ENTRY: { 2533 llvm::StringRef Filename(BlobStart, BlobLen); 2534 const FileEntry *File = getFileEntry(Filename); 2535 2536 if (File == 0) { 2537 std::string ErrorStr = "could not find file '"; 2538 ErrorStr += Filename; 2539 ErrorStr += "' referenced by AST file"; 2540 Error(ErrorStr.c_str()); 2541 return IgnorePCH; 2542 } 2543 2544 if (Record.size() < 6) { 2545 Error("source location entry is incorrect"); 2546 return Failure; 2547 } 2548 2549 // The stat info from the FileEntry came from the cached stat 2550 // info of the PCH, so we cannot trust it. 2551 struct stat StatBuf; 2552 if (::stat(File->getName(), &StatBuf) != 0) { 2553 StatBuf.st_size = File->getSize(); 2554 StatBuf.st_mtime = File->getModificationTime(); 2555 } 2556 2557 if (((off_t)Record[4] != StatBuf.st_size 2558#if !defined(LLVM_ON_WIN32) 2559 // In our regression testing, the Windows file system seems to 2560 // have inconsistent modification times that sometimes 2561 // erroneously trigger this error-handling path. 2562 || (time_t)Record[5] != StatBuf.st_mtime 2563#endif 2564 )) { 2565 Error(diag::err_fe_pch_file_modified, Filename); 2566 return IgnorePCH; 2567 } 2568 2569 break; 2570 } 2571 } 2572 } 2573 } 2574 2575 return Success; 2576} 2577 2578ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2579 ASTFileType Type) { 2580 switch(ReadASTCore(FileName, Type)) { 2581 case Failure: return Failure; 2582 case IgnorePCH: return IgnorePCH; 2583 case Success: break; 2584 } 2585 2586 // Here comes stuff that we only do once the entire chain is loaded. 2587 2588 if (!DisableValidation) { 2589 switch(validateFileEntries()) { 2590 case Failure: return Failure; 2591 case IgnorePCH: return IgnorePCH; 2592 case Success: break; 2593 } 2594 } 2595 2596 // Preload SLocEntries. 2597 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) { 2598 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]); 2599 if (Result != Success) 2600 return Failure; 2601 } 2602 PreloadSLocEntries.clear(); 2603 2604 // Check the predefines buffers. 2605 if (!DisableValidation && CheckPredefinesBuffers()) 2606 return IgnorePCH; 2607 2608 if (PP) { 2609 // Initialization of keywords and pragmas occurs before the 2610 // AST file is read, so there may be some identifiers that were 2611 // loaded into the IdentifierTable before we intercepted the 2612 // creation of identifiers. Iterate through the list of known 2613 // identifiers and determine whether we have to establish 2614 // preprocessor definitions or top-level identifier declaration 2615 // chains for those identifiers. 2616 // 2617 // We copy the IdentifierInfo pointers to a small vector first, 2618 // since de-serializing declarations or macro definitions can add 2619 // new entries into the identifier table, invalidating the 2620 // iterators. 2621 llvm::SmallVector<IdentifierInfo *, 128> Identifiers; 2622 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 2623 IdEnd = PP->getIdentifierTable().end(); 2624 Id != IdEnd; ++Id) 2625 Identifiers.push_back(Id->second); 2626 // We need to search the tables in all files. 2627 for (unsigned J = 0, M = Chain.size(); J != M; ++J) { 2628 ASTIdentifierLookupTable *IdTable 2629 = (ASTIdentifierLookupTable *)Chain[J]->IdentifierLookupTable; 2630 // Not all AST files necessarily have identifier tables, only the useful 2631 // ones. 2632 if (!IdTable) 2633 continue; 2634 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2635 IdentifierInfo *II = Identifiers[I]; 2636 // Look in the on-disk hash tables for an entry for this identifier 2637 ASTIdentifierLookupTrait Info(*this, *Chain[J], II); 2638 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 2639 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 2640 if (Pos == IdTable->end()) 2641 continue; 2642 2643 // Dereferencing the iterator has the effect of populating the 2644 // IdentifierInfo node with the various declarations it needs. 2645 (void)*Pos; 2646 } 2647 } 2648 } 2649 2650 if (Context) 2651 InitializeContext(*Context); 2652 2653 if (DeserializationListener) 2654 DeserializationListener->ReaderInitialized(this); 2655 2656 // If this AST file is a precompiled preamble, then set the main file ID of 2657 // the source manager to the file source file from which the preamble was 2658 // built. This is the only valid way to use a precompiled preamble. 2659 if (Type == Preamble) { 2660 if (OriginalFileID.isInvalid()) { 2661 SourceLocation Loc 2662 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1); 2663 if (Loc.isValid()) 2664 OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first; 2665 } 2666 else { 2667 OriginalFileID = FileID::get(Chain[0]->SLocEntryBaseID 2668 + OriginalFileID.getOpaqueValue() - 1); 2669 } 2670 2671 if (!OriginalFileID.isInvalid()) 2672 SourceMgr.SetPreambleFileID(OriginalFileID); 2673 } 2674 2675 return Success; 2676} 2677 2678ASTReader::ASTReadResult ASTReader::ReadASTCore(llvm::StringRef FileName, 2679 ASTFileType Type) { 2680 PerFileData *Prev = Chain.empty() ? 0 : Chain.back(); 2681 Chain.push_back(new PerFileData(Type)); 2682 PerFileData &F = *Chain.back(); 2683 if (Prev) 2684 Prev->NextInSource = &F; 2685 else 2686 FirstInSource = &F; 2687 F.Loaders.push_back(Prev); 2688 // A non-module AST file's module name is $filename. 2689 Modules["$" + FileName.str()] = &F; 2690 2691 // Set the AST file name. 2692 F.FileName = FileName; 2693 2694 if (FileName != "-") { 2695 CurrentDir = llvm::sys::path::parent_path(FileName); 2696 if (CurrentDir.empty()) CurrentDir = "."; 2697 } 2698 2699 if (!ASTBuffers.empty()) { 2700 F.Buffer.reset(ASTBuffers.back()); 2701 ASTBuffers.pop_back(); 2702 assert(F.Buffer && "Passed null buffer"); 2703 } else { 2704 // Open the AST file. 2705 // 2706 // FIXME: This shouldn't be here, we should just take a raw_ostream. 2707 std::string ErrStr; 2708 llvm::error_code ec; 2709 if (FileName == "-") { 2710 ec = llvm::MemoryBuffer::getSTDIN(F.Buffer); 2711 if (ec) 2712 ErrStr = ec.message(); 2713 } else 2714 F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr)); 2715 if (!F.Buffer) { 2716 Error(ErrStr.c_str()); 2717 return IgnorePCH; 2718 } 2719 } 2720 2721 // Initialize the stream 2722 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2723 (const unsigned char *)F.Buffer->getBufferEnd()); 2724 llvm::BitstreamCursor &Stream = F.Stream; 2725 Stream.init(F.StreamFile); 2726 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2727 2728 // Sniff for the signature. 2729 if (Stream.Read(8) != 'C' || 2730 Stream.Read(8) != 'P' || 2731 Stream.Read(8) != 'C' || 2732 Stream.Read(8) != 'H') { 2733 Diag(diag::err_not_a_pch_file) << FileName; 2734 return Failure; 2735 } 2736 2737 while (!Stream.AtEndOfStream()) { 2738 unsigned Code = Stream.ReadCode(); 2739 2740 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2741 Error("invalid record at top-level of AST file"); 2742 return Failure; 2743 } 2744 2745 unsigned BlockID = Stream.ReadSubBlockID(); 2746 2747 // We only know the AST subblock ID. 2748 switch (BlockID) { 2749 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2750 if (Stream.ReadBlockInfoBlock()) { 2751 Error("malformed BlockInfoBlock in AST file"); 2752 return Failure; 2753 } 2754 break; 2755 case AST_BLOCK_ID: 2756 switch (ReadASTBlock(F)) { 2757 case Success: 2758 break; 2759 2760 case Failure: 2761 return Failure; 2762 2763 case IgnorePCH: 2764 // FIXME: We could consider reading through to the end of this 2765 // AST block, skipping subblocks, to see if there are other 2766 // AST blocks elsewhere. 2767 2768 // FIXME: We can't clear loaded slocentries anymore. 2769 //SourceMgr.ClearPreallocatedSLocEntries(); 2770 2771 // Remove the stat cache. 2772 if (F.StatCache) 2773 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2774 2775 return IgnorePCH; 2776 } 2777 break; 2778 default: 2779 if (Stream.SkipBlock()) { 2780 Error("malformed block record in AST file"); 2781 return Failure; 2782 } 2783 break; 2784 } 2785 } 2786 2787 return Success; 2788} 2789 2790void ASTReader::setPreprocessor(Preprocessor &pp) { 2791 PP = &pp; 2792 2793 if (unsigned N = getTotalNumPreprocessedEntities()) { 2794 if (!PP->getPreprocessingRecord()) 2795 PP->createPreprocessingRecord(true); 2796 PP->getPreprocessingRecord()->SetExternalSource(*this); 2797 PP->getPreprocessingRecord()->allocateLoadedEntities(N); 2798 } 2799 2800 PP->getHeaderSearchInfo().SetExternalLookup(this); 2801 PP->getHeaderSearchInfo().SetExternalSource(this); 2802} 2803 2804void ASTReader::InitializeContext(ASTContext &Ctx) { 2805 Context = &Ctx; 2806 assert(Context && "Passed null context!"); 2807 2808 assert(PP && "Forgot to set Preprocessor ?"); 2809 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2810 PP->setExternalSource(this); 2811 2812 // If we have an update block for the TU waiting, we have to add it before 2813 // deserializing the decl. 2814 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2815 if (DCU != DeclContextOffsets.end()) { 2816 // Insertion could invalidate map, so grab vector. 2817 DeclContextInfos T; 2818 T.swap(DCU->second); 2819 DeclContextOffsets.erase(DCU); 2820 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T); 2821 } 2822 2823 // Load the translation unit declaration 2824 GetTranslationUnitDecl(); 2825 2826 // Load the special types. 2827 Context->setBuiltinVaListType( 2828 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2829 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 2830 Context->setObjCIdType(GetType(Id)); 2831 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 2832 Context->setObjCSelType(GetType(Sel)); 2833 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 2834 Context->setObjCProtoType(GetType(Proto)); 2835 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 2836 Context->setObjCClassType(GetType(Class)); 2837 2838 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 2839 Context->setCFConstantStringType(GetType(String)); 2840 if (unsigned FastEnum 2841 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 2842 Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 2843 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2844 QualType FileType = GetType(File); 2845 if (FileType.isNull()) { 2846 Error("FILE type is NULL"); 2847 return; 2848 } 2849 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2850 Context->setFILEDecl(Typedef->getDecl()); 2851 else { 2852 const TagType *Tag = FileType->getAs<TagType>(); 2853 if (!Tag) { 2854 Error("Invalid FILE type in AST file"); 2855 return; 2856 } 2857 Context->setFILEDecl(Tag->getDecl()); 2858 } 2859 } 2860 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2861 QualType Jmp_bufType = GetType(Jmp_buf); 2862 if (Jmp_bufType.isNull()) { 2863 Error("jmp_bug type is NULL"); 2864 return; 2865 } 2866 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2867 Context->setjmp_bufDecl(Typedef->getDecl()); 2868 else { 2869 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2870 if (!Tag) { 2871 Error("Invalid jmp_buf type in AST file"); 2872 return; 2873 } 2874 Context->setjmp_bufDecl(Tag->getDecl()); 2875 } 2876 } 2877 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2878 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2879 if (Sigjmp_bufType.isNull()) { 2880 Error("sigjmp_buf type is NULL"); 2881 return; 2882 } 2883 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2884 Context->setsigjmp_bufDecl(Typedef->getDecl()); 2885 else { 2886 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2887 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2888 Context->setsigjmp_bufDecl(Tag->getDecl()); 2889 } 2890 } 2891 if (unsigned ObjCIdRedef 2892 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 2893 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2894 if (unsigned ObjCClassRedef 2895 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 2896 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2897 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 2898 Context->setBlockDescriptorType(GetType(String)); 2899 if (unsigned String 2900 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 2901 Context->setBlockDescriptorExtendedType(GetType(String)); 2902 if (unsigned ObjCSelRedef 2903 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 2904 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2905 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 2906 Context->setNSConstantStringType(GetType(String)); 2907 2908 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 2909 Context->setInt128Installed(); 2910 2911 if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT]) 2912 Context->AutoDeductTy = GetType(AutoDeduct); 2913 if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT]) 2914 Context->AutoRRefDeductTy = GetType(AutoRRefDeduct); 2915 2916 ReadPragmaDiagnosticMappings(Context->getDiagnostics()); 2917 2918 // If there were any CUDA special declarations, deserialize them. 2919 if (!CUDASpecialDeclRefs.empty()) { 2920 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 2921 Context->setcudaConfigureCallDecl( 2922 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 2923 } 2924} 2925 2926/// \brief Retrieve the name of the original source file name 2927/// directly from the AST file, without actually loading the AST 2928/// file. 2929std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2930 FileManager &FileMgr, 2931 Diagnostic &Diags) { 2932 // Open the AST file. 2933 std::string ErrStr; 2934 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2935 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 2936 if (!Buffer) { 2937 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2938 return std::string(); 2939 } 2940 2941 // Initialize the stream 2942 llvm::BitstreamReader StreamFile; 2943 llvm::BitstreamCursor Stream; 2944 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2945 (const unsigned char *)Buffer->getBufferEnd()); 2946 Stream.init(StreamFile); 2947 2948 // Sniff for the signature. 2949 if (Stream.Read(8) != 'C' || 2950 Stream.Read(8) != 'P' || 2951 Stream.Read(8) != 'C' || 2952 Stream.Read(8) != 'H') { 2953 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2954 return std::string(); 2955 } 2956 2957 RecordData Record; 2958 while (!Stream.AtEndOfStream()) { 2959 unsigned Code = Stream.ReadCode(); 2960 2961 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2962 unsigned BlockID = Stream.ReadSubBlockID(); 2963 2964 // We only know the AST subblock ID. 2965 switch (BlockID) { 2966 case AST_BLOCK_ID: 2967 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2968 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2969 return std::string(); 2970 } 2971 break; 2972 2973 default: 2974 if (Stream.SkipBlock()) { 2975 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2976 return std::string(); 2977 } 2978 break; 2979 } 2980 continue; 2981 } 2982 2983 if (Code == llvm::bitc::END_BLOCK) { 2984 if (Stream.ReadBlockEnd()) { 2985 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2986 return std::string(); 2987 } 2988 continue; 2989 } 2990 2991 if (Code == llvm::bitc::DEFINE_ABBREV) { 2992 Stream.ReadAbbrevRecord(); 2993 continue; 2994 } 2995 2996 Record.clear(); 2997 const char *BlobStart = 0; 2998 unsigned BlobLen = 0; 2999 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 3000 == ORIGINAL_FILE_NAME) 3001 return std::string(BlobStart, BlobLen); 3002 } 3003 3004 return std::string(); 3005} 3006 3007/// \brief Parse the record that corresponds to a LangOptions data 3008/// structure. 3009/// 3010/// This routine parses the language options from the AST file and then gives 3011/// them to the AST listener if one is set. 3012/// 3013/// \returns true if the listener deems the file unacceptable, false otherwise. 3014bool ASTReader::ParseLanguageOptions( 3015 const llvm::SmallVectorImpl<uint64_t> &Record) { 3016 if (Listener) { 3017 LangOptions LangOpts; 3018 3019 #define PARSE_LANGOPT(Option) \ 3020 LangOpts.Option = Record[Idx]; \ 3021 ++Idx 3022 3023 unsigned Idx = 0; 3024 PARSE_LANGOPT(Trigraphs); 3025 PARSE_LANGOPT(BCPLComment); 3026 PARSE_LANGOPT(DollarIdents); 3027 PARSE_LANGOPT(AsmPreprocessor); 3028 PARSE_LANGOPT(GNUMode); 3029 PARSE_LANGOPT(GNUKeywords); 3030 PARSE_LANGOPT(ImplicitInt); 3031 PARSE_LANGOPT(Digraphs); 3032 PARSE_LANGOPT(HexFloats); 3033 PARSE_LANGOPT(C99); 3034 PARSE_LANGOPT(C1X); 3035 PARSE_LANGOPT(Microsoft); 3036 PARSE_LANGOPT(CPlusPlus); 3037 PARSE_LANGOPT(CPlusPlus0x); 3038 PARSE_LANGOPT(CXXOperatorNames); 3039 PARSE_LANGOPT(ObjC1); 3040 PARSE_LANGOPT(ObjC2); 3041 PARSE_LANGOPT(ObjCNonFragileABI); 3042 PARSE_LANGOPT(ObjCNonFragileABI2); 3043 PARSE_LANGOPT(AppleKext); 3044 PARSE_LANGOPT(ObjCDefaultSynthProperties); 3045 PARSE_LANGOPT(ObjCInferRelatedResultType); 3046 PARSE_LANGOPT(NoConstantCFStrings); 3047 PARSE_LANGOPT(PascalStrings); 3048 PARSE_LANGOPT(WritableStrings); 3049 PARSE_LANGOPT(LaxVectorConversions); 3050 PARSE_LANGOPT(AltiVec); 3051 PARSE_LANGOPT(Exceptions); 3052 PARSE_LANGOPT(ObjCExceptions); 3053 PARSE_LANGOPT(CXXExceptions); 3054 PARSE_LANGOPT(SjLjExceptions); 3055 PARSE_LANGOPT(MSBitfields); 3056 PARSE_LANGOPT(NeXTRuntime); 3057 PARSE_LANGOPT(Freestanding); 3058 PARSE_LANGOPT(NoBuiltin); 3059 PARSE_LANGOPT(ThreadsafeStatics); 3060 PARSE_LANGOPT(POSIXThreads); 3061 PARSE_LANGOPT(Blocks); 3062 PARSE_LANGOPT(EmitAllDecls); 3063 PARSE_LANGOPT(MathErrno); 3064 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 3065 Record[Idx++]); 3066 PARSE_LANGOPT(HeinousExtensions); 3067 PARSE_LANGOPT(Optimize); 3068 PARSE_LANGOPT(OptimizeSize); 3069 PARSE_LANGOPT(Static); 3070 PARSE_LANGOPT(PICLevel); 3071 PARSE_LANGOPT(GNUInline); 3072 PARSE_LANGOPT(NoInline); 3073 PARSE_LANGOPT(Deprecated); 3074 PARSE_LANGOPT(AccessControl); 3075 PARSE_LANGOPT(CharIsSigned); 3076 PARSE_LANGOPT(ShortWChar); 3077 PARSE_LANGOPT(ShortEnums); 3078 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 3079 LangOpts.setVisibilityMode((Visibility)Record[Idx++]); 3080 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 3081 Record[Idx++]); 3082 PARSE_LANGOPT(InstantiationDepth); 3083 PARSE_LANGOPT(OpenCL); 3084 PARSE_LANGOPT(CUDA); 3085 PARSE_LANGOPT(CatchUndefined); 3086 PARSE_LANGOPT(DefaultFPContract); 3087 PARSE_LANGOPT(ElideConstructors); 3088 PARSE_LANGOPT(SpellChecking); 3089 PARSE_LANGOPT(MRTD); 3090 PARSE_LANGOPT(ObjCAutoRefCount); 3091 #undef PARSE_LANGOPT 3092 3093 return Listener->ReadLanguageOptions(LangOpts); 3094 } 3095 3096 return false; 3097} 3098 3099void ASTReader::ReadPreprocessedEntities() { 3100 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3101 PerFileData &F = *Chain[I]; 3102 if (!F.PreprocessorDetailCursor.getBitStreamReader()) 3103 continue; 3104 3105 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor); 3106 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset); 3107 while (LoadPreprocessedEntity(F)) { } 3108 } 3109} 3110 3111PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) { 3112 PerFileData *F = 0; 3113 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3114 if (Offset < Chain[I]->SizeInBits) { 3115 F = Chain[I]; 3116 break; 3117 } 3118 3119 Offset -= Chain[I]->SizeInBits; 3120 } 3121 3122 if (!F) { 3123 Error("Malformed preprocessed entity offset"); 3124 return 0; 3125 } 3126 3127 // Keep track of where we are in the stream, then jump back there 3128 // after reading this entity. 3129 SavedStreamPosition SavedPosition(F->PreprocessorDetailCursor); 3130 F->PreprocessorDetailCursor.JumpToBit(Offset); 3131 return LoadPreprocessedEntity(*F); 3132} 3133 3134HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3135 HeaderFileInfoTrait Trait(FE->getName()); 3136 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3137 PerFileData &F = *Chain[I]; 3138 HeaderFileInfoLookupTable *Table 3139 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable); 3140 if (!Table) 3141 continue; 3142 3143 // Look in the on-disk hash table for an entry for this file name. 3144 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(), 3145 &Trait); 3146 if (Pos == Table->end()) 3147 continue; 3148 3149 HeaderFileInfo HFI = *Pos; 3150 if (Listener) 3151 Listener->ReadHeaderFileInfo(HFI, FE->getUID()); 3152 3153 return HFI; 3154 } 3155 3156 return HeaderFileInfo(); 3157} 3158 3159void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) { 3160 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3161 PerFileData &F = *Chain[I]; 3162 unsigned Idx = 0; 3163 while (Idx < F.PragmaDiagMappings.size()) { 3164 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3165 while (1) { 3166 assert(Idx < F.PragmaDiagMappings.size() && 3167 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3168 if (Idx >= F.PragmaDiagMappings.size()) { 3169 break; // Something is messed up but at least avoid infinite loop in 3170 // release build. 3171 } 3172 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3173 if (DiagID == (unsigned)-1) { 3174 break; // no more diag/map pairs for this location. 3175 } 3176 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3177 Diag.setDiagnosticMapping(DiagID, Map, Loc); 3178 } 3179 } 3180 } 3181} 3182 3183/// \brief Get the correct cursor and offset for loading a type. 3184ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3185 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index+1); 3186 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3187 return RecordLocation(I->second.first, 3188 I->second.first->TypeOffsets[Index + I->second.second]); 3189} 3190 3191/// \brief Read and return the type with the given index.. 3192/// 3193/// The index is the type ID, shifted and minus the number of predefs. This 3194/// routine actually reads the record corresponding to the type at the given 3195/// location. It is a helper routine for GetType, which deals with reading type 3196/// IDs. 3197QualType ASTReader::ReadTypeRecord(unsigned Index) { 3198 RecordLocation Loc = TypeCursorForIndex(Index); 3199 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3200 3201 // Keep track of where we are in the stream, then jump back there 3202 // after reading this type. 3203 SavedStreamPosition SavedPosition(DeclsCursor); 3204 3205 ReadingKindTracker ReadingKind(Read_Type, *this); 3206 3207 // Note that we are loading a type record. 3208 Deserializing AType(this); 3209 3210 DeclsCursor.JumpToBit(Loc.Offset); 3211 RecordData Record; 3212 unsigned Code = DeclsCursor.ReadCode(); 3213 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3214 case TYPE_EXT_QUAL: { 3215 if (Record.size() != 2) { 3216 Error("Incorrect encoding of extended qualifier type"); 3217 return QualType(); 3218 } 3219 QualType Base = GetType(Record[0]); 3220 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]); 3221 return Context->getQualifiedType(Base, Quals); 3222 } 3223 3224 case TYPE_COMPLEX: { 3225 if (Record.size() != 1) { 3226 Error("Incorrect encoding of complex type"); 3227 return QualType(); 3228 } 3229 QualType ElemType = GetType(Record[0]); 3230 return Context->getComplexType(ElemType); 3231 } 3232 3233 case TYPE_POINTER: { 3234 if (Record.size() != 1) { 3235 Error("Incorrect encoding of pointer type"); 3236 return QualType(); 3237 } 3238 QualType PointeeType = GetType(Record[0]); 3239 return Context->getPointerType(PointeeType); 3240 } 3241 3242 case TYPE_BLOCK_POINTER: { 3243 if (Record.size() != 1) { 3244 Error("Incorrect encoding of block pointer type"); 3245 return QualType(); 3246 } 3247 QualType PointeeType = GetType(Record[0]); 3248 return Context->getBlockPointerType(PointeeType); 3249 } 3250 3251 case TYPE_LVALUE_REFERENCE: { 3252 if (Record.size() != 2) { 3253 Error("Incorrect encoding of lvalue reference type"); 3254 return QualType(); 3255 } 3256 QualType PointeeType = GetType(Record[0]); 3257 return Context->getLValueReferenceType(PointeeType, Record[1]); 3258 } 3259 3260 case TYPE_RVALUE_REFERENCE: { 3261 if (Record.size() != 1) { 3262 Error("Incorrect encoding of rvalue reference type"); 3263 return QualType(); 3264 } 3265 QualType PointeeType = GetType(Record[0]); 3266 return Context->getRValueReferenceType(PointeeType); 3267 } 3268 3269 case TYPE_MEMBER_POINTER: { 3270 if (Record.size() != 2) { 3271 Error("Incorrect encoding of member pointer type"); 3272 return QualType(); 3273 } 3274 QualType PointeeType = GetType(Record[0]); 3275 QualType ClassType = GetType(Record[1]); 3276 if (PointeeType.isNull() || ClassType.isNull()) 3277 return QualType(); 3278 3279 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3280 } 3281 3282 case TYPE_CONSTANT_ARRAY: { 3283 QualType ElementType = GetType(Record[0]); 3284 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3285 unsigned IndexTypeQuals = Record[2]; 3286 unsigned Idx = 3; 3287 llvm::APInt Size = ReadAPInt(Record, Idx); 3288 return Context->getConstantArrayType(ElementType, Size, 3289 ASM, IndexTypeQuals); 3290 } 3291 3292 case TYPE_INCOMPLETE_ARRAY: { 3293 QualType ElementType = GetType(Record[0]); 3294 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3295 unsigned IndexTypeQuals = Record[2]; 3296 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3297 } 3298 3299 case TYPE_VARIABLE_ARRAY: { 3300 QualType ElementType = GetType(Record[0]); 3301 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3302 unsigned IndexTypeQuals = Record[2]; 3303 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3304 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3305 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3306 ASM, IndexTypeQuals, 3307 SourceRange(LBLoc, RBLoc)); 3308 } 3309 3310 case TYPE_VECTOR: { 3311 if (Record.size() != 3) { 3312 Error("incorrect encoding of vector type in AST file"); 3313 return QualType(); 3314 } 3315 3316 QualType ElementType = GetType(Record[0]); 3317 unsigned NumElements = Record[1]; 3318 unsigned VecKind = Record[2]; 3319 return Context->getVectorType(ElementType, NumElements, 3320 (VectorType::VectorKind)VecKind); 3321 } 3322 3323 case TYPE_EXT_VECTOR: { 3324 if (Record.size() != 3) { 3325 Error("incorrect encoding of extended vector type in AST file"); 3326 return QualType(); 3327 } 3328 3329 QualType ElementType = GetType(Record[0]); 3330 unsigned NumElements = Record[1]; 3331 return Context->getExtVectorType(ElementType, NumElements); 3332 } 3333 3334 case TYPE_FUNCTION_NO_PROTO: { 3335 if (Record.size() != 6) { 3336 Error("incorrect encoding of no-proto function type"); 3337 return QualType(); 3338 } 3339 QualType ResultType = GetType(Record[0]); 3340 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3341 (CallingConv)Record[4], Record[5]); 3342 return Context->getFunctionNoProtoType(ResultType, Info); 3343 } 3344 3345 case TYPE_FUNCTION_PROTO: { 3346 QualType ResultType = GetType(Record[0]); 3347 3348 FunctionProtoType::ExtProtoInfo EPI; 3349 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3350 /*hasregparm*/ Record[2], 3351 /*regparm*/ Record[3], 3352 static_cast<CallingConv>(Record[4]), 3353 /*produces*/ Record[5]); 3354 3355 unsigned Idx = 6; 3356 unsigned NumParams = Record[Idx++]; 3357 llvm::SmallVector<QualType, 16> ParamTypes; 3358 for (unsigned I = 0; I != NumParams; ++I) 3359 ParamTypes.push_back(GetType(Record[Idx++])); 3360 3361 EPI.Variadic = Record[Idx++]; 3362 EPI.TypeQuals = Record[Idx++]; 3363 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3364 ExceptionSpecificationType EST = 3365 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3366 EPI.ExceptionSpecType = EST; 3367 if (EST == EST_Dynamic) { 3368 EPI.NumExceptions = Record[Idx++]; 3369 llvm::SmallVector<QualType, 2> Exceptions; 3370 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3371 Exceptions.push_back(GetType(Record[Idx++])); 3372 EPI.Exceptions = Exceptions.data(); 3373 } else if (EST == EST_ComputedNoexcept) { 3374 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3375 } 3376 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 3377 EPI); 3378 } 3379 3380 case TYPE_UNRESOLVED_USING: 3381 return Context->getTypeDeclType( 3382 cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0]))); 3383 3384 case TYPE_TYPEDEF: { 3385 if (Record.size() != 2) { 3386 Error("incorrect encoding of typedef type"); 3387 return QualType(); 3388 } 3389 TypedefNameDecl *Decl = cast<TypedefNameDecl>(GetDecl(Record[0])); 3390 QualType Canonical = GetType(Record[1]); 3391 if (!Canonical.isNull()) 3392 Canonical = Context->getCanonicalType(Canonical); 3393 return Context->getTypedefType(Decl, Canonical); 3394 } 3395 3396 case TYPE_TYPEOF_EXPR: 3397 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 3398 3399 case TYPE_TYPEOF: { 3400 if (Record.size() != 1) { 3401 Error("incorrect encoding of typeof(type) in AST file"); 3402 return QualType(); 3403 } 3404 QualType UnderlyingType = GetType(Record[0]); 3405 return Context->getTypeOfType(UnderlyingType); 3406 } 3407 3408 case TYPE_DECLTYPE: 3409 return Context->getDecltypeType(ReadExpr(*Loc.F)); 3410 3411 case TYPE_UNARY_TRANSFORM: { 3412 QualType BaseType = GetType(Record[0]); 3413 QualType UnderlyingType = GetType(Record[1]); 3414 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3415 return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind); 3416 } 3417 3418 case TYPE_AUTO: 3419 return Context->getAutoType(GetType(Record[0])); 3420 3421 case TYPE_RECORD: { 3422 if (Record.size() != 2) { 3423 Error("incorrect encoding of record type"); 3424 return QualType(); 3425 } 3426 bool IsDependent = Record[0]; 3427 QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1]))); 3428 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3429 return T; 3430 } 3431 3432 case TYPE_ENUM: { 3433 if (Record.size() != 2) { 3434 Error("incorrect encoding of enum type"); 3435 return QualType(); 3436 } 3437 bool IsDependent = Record[0]; 3438 QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1]))); 3439 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3440 return T; 3441 } 3442 3443 case TYPE_ATTRIBUTED: { 3444 if (Record.size() != 3) { 3445 Error("incorrect encoding of attributed type"); 3446 return QualType(); 3447 } 3448 QualType modifiedType = GetType(Record[0]); 3449 QualType equivalentType = GetType(Record[1]); 3450 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3451 return Context->getAttributedType(kind, modifiedType, equivalentType); 3452 } 3453 3454 case TYPE_PAREN: { 3455 if (Record.size() != 1) { 3456 Error("incorrect encoding of paren type"); 3457 return QualType(); 3458 } 3459 QualType InnerType = GetType(Record[0]); 3460 return Context->getParenType(InnerType); 3461 } 3462 3463 case TYPE_PACK_EXPANSION: { 3464 if (Record.size() != 2) { 3465 Error("incorrect encoding of pack expansion type"); 3466 return QualType(); 3467 } 3468 QualType Pattern = GetType(Record[0]); 3469 if (Pattern.isNull()) 3470 return QualType(); 3471 llvm::Optional<unsigned> NumExpansions; 3472 if (Record[1]) 3473 NumExpansions = Record[1] - 1; 3474 return Context->getPackExpansionType(Pattern, NumExpansions); 3475 } 3476 3477 case TYPE_ELABORATED: { 3478 unsigned Idx = 0; 3479 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3480 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3481 QualType NamedType = GetType(Record[Idx++]); 3482 return Context->getElaboratedType(Keyword, NNS, NamedType); 3483 } 3484 3485 case TYPE_OBJC_INTERFACE: { 3486 unsigned Idx = 0; 3487 ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++])); 3488 return Context->getObjCInterfaceType(ItfD); 3489 } 3490 3491 case TYPE_OBJC_OBJECT: { 3492 unsigned Idx = 0; 3493 QualType Base = GetType(Record[Idx++]); 3494 unsigned NumProtos = Record[Idx++]; 3495 llvm::SmallVector<ObjCProtocolDecl*, 4> Protos; 3496 for (unsigned I = 0; I != NumProtos; ++I) 3497 Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++]))); 3498 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 3499 } 3500 3501 case TYPE_OBJC_OBJECT_POINTER: { 3502 unsigned Idx = 0; 3503 QualType Pointee = GetType(Record[Idx++]); 3504 return Context->getObjCObjectPointerType(Pointee); 3505 } 3506 3507 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3508 unsigned Idx = 0; 3509 QualType Parm = GetType(Record[Idx++]); 3510 QualType Replacement = GetType(Record[Idx++]); 3511 return 3512 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3513 Replacement); 3514 } 3515 3516 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3517 unsigned Idx = 0; 3518 QualType Parm = GetType(Record[Idx++]); 3519 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3520 return Context->getSubstTemplateTypeParmPackType( 3521 cast<TemplateTypeParmType>(Parm), 3522 ArgPack); 3523 } 3524 3525 case TYPE_INJECTED_CLASS_NAME: { 3526 CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0])); 3527 QualType TST = GetType(Record[1]); // probably derivable 3528 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3529 // for AST reading, too much interdependencies. 3530 return 3531 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3532 } 3533 3534 case TYPE_TEMPLATE_TYPE_PARM: { 3535 unsigned Idx = 0; 3536 unsigned Depth = Record[Idx++]; 3537 unsigned Index = Record[Idx++]; 3538 bool Pack = Record[Idx++]; 3539 TemplateTypeParmDecl *D = 3540 cast_or_null<TemplateTypeParmDecl>(GetDecl(Record[Idx++])); 3541 return Context->getTemplateTypeParmType(Depth, Index, Pack, D); 3542 } 3543 3544 case TYPE_DEPENDENT_NAME: { 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 QualType Canon = GetType(Record[Idx++]); 3550 if (!Canon.isNull()) 3551 Canon = Context->getCanonicalType(Canon); 3552 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 3553 } 3554 3555 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3556 unsigned Idx = 0; 3557 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3558 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3559 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 3560 unsigned NumArgs = Record[Idx++]; 3561 llvm::SmallVector<TemplateArgument, 8> Args; 3562 Args.reserve(NumArgs); 3563 while (NumArgs--) 3564 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3565 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 3566 Args.size(), Args.data()); 3567 } 3568 3569 case TYPE_DEPENDENT_SIZED_ARRAY: { 3570 unsigned Idx = 0; 3571 3572 // ArrayType 3573 QualType ElementType = GetType(Record[Idx++]); 3574 ArrayType::ArraySizeModifier ASM 3575 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3576 unsigned IndexTypeQuals = Record[Idx++]; 3577 3578 // DependentSizedArrayType 3579 Expr *NumElts = ReadExpr(*Loc.F); 3580 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3581 3582 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 3583 IndexTypeQuals, Brackets); 3584 } 3585 3586 case TYPE_TEMPLATE_SPECIALIZATION: { 3587 unsigned Idx = 0; 3588 bool IsDependent = Record[Idx++]; 3589 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3590 llvm::SmallVector<TemplateArgument, 8> Args; 3591 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3592 QualType Underlying = GetType(Record[Idx++]); 3593 QualType T; 3594 if (Underlying.isNull()) 3595 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 3596 Args.size()); 3597 else 3598 T = Context->getTemplateSpecializationType(Name, Args.data(), 3599 Args.size(), Underlying); 3600 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3601 return T; 3602 } 3603 } 3604 // Suppress a GCC warning 3605 return QualType(); 3606} 3607 3608class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3609 ASTReader &Reader; 3610 ASTReader::PerFileData &F; 3611 llvm::BitstreamCursor &DeclsCursor; 3612 const ASTReader::RecordData &Record; 3613 unsigned &Idx; 3614 3615 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3616 unsigned &I) { 3617 return Reader.ReadSourceLocation(F, R, I); 3618 } 3619 3620public: 3621 TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F, 3622 const ASTReader::RecordData &Record, unsigned &Idx) 3623 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3624 { } 3625 3626 // We want compile-time assurance that we've enumerated all of 3627 // these, so unfortunately we have to declare them first, then 3628 // define them out-of-line. 3629#define ABSTRACT_TYPELOC(CLASS, PARENT) 3630#define TYPELOC(CLASS, PARENT) \ 3631 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3632#include "clang/AST/TypeLocNodes.def" 3633 3634 void VisitFunctionTypeLoc(FunctionTypeLoc); 3635 void VisitArrayTypeLoc(ArrayTypeLoc); 3636}; 3637 3638void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3639 // nothing to do 3640} 3641void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3642 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3643 if (TL.needsExtraLocalData()) { 3644 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3645 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3646 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3647 TL.setModeAttr(Record[Idx++]); 3648 } 3649} 3650void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3651 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3652} 3653void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3654 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3655} 3656void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3657 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3658} 3659void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3660 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3661} 3662void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3663 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3664} 3665void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3666 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3667 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3668} 3669void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3670 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3671 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3672 if (Record[Idx++]) 3673 TL.setSizeExpr(Reader.ReadExpr(F)); 3674 else 3675 TL.setSizeExpr(0); 3676} 3677void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3678 VisitArrayTypeLoc(TL); 3679} 3680void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3681 VisitArrayTypeLoc(TL); 3682} 3683void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3684 VisitArrayTypeLoc(TL); 3685} 3686void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3687 DependentSizedArrayTypeLoc TL) { 3688 VisitArrayTypeLoc(TL); 3689} 3690void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3691 DependentSizedExtVectorTypeLoc TL) { 3692 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3693} 3694void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3695 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3696} 3697void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3698 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3699} 3700void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3701 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3702 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3703 TL.setTrailingReturn(Record[Idx++]); 3704 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3705 TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 3706 } 3707} 3708void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3709 VisitFunctionTypeLoc(TL); 3710} 3711void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3712 VisitFunctionTypeLoc(TL); 3713} 3714void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3715 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3716} 3717void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3718 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3719} 3720void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3721 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3722 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3723 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3724} 3725void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3726 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3727 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3728 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3729 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3730} 3731void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3732 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3733} 3734void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 3735 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3736 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3737 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3738 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3739} 3740void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3741 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3742} 3743void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3744 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3745} 3746void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3747 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3748} 3749void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3750 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3751 if (TL.hasAttrOperand()) { 3752 SourceRange range; 3753 range.setBegin(ReadSourceLocation(Record, Idx)); 3754 range.setEnd(ReadSourceLocation(Record, Idx)); 3755 TL.setAttrOperandParensRange(range); 3756 } 3757 if (TL.hasAttrExprOperand()) { 3758 if (Record[Idx++]) 3759 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3760 else 3761 TL.setAttrExprOperand(0); 3762 } else if (TL.hasAttrEnumOperand()) 3763 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3764} 3765void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3766 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3767} 3768void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3769 SubstTemplateTypeParmTypeLoc TL) { 3770 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3771} 3772void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3773 SubstTemplateTypeParmPackTypeLoc TL) { 3774 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3775} 3776void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3777 TemplateSpecializationTypeLoc TL) { 3778 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3779 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3780 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3781 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3782 TL.setArgLocInfo(i, 3783 Reader.GetTemplateArgumentLocInfo(F, 3784 TL.getTypePtr()->getArg(i).getKind(), 3785 Record, Idx)); 3786} 3787void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3788 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3789 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3790} 3791void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3792 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3793 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3794} 3795void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3796 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3797} 3798void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3799 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3800 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3801 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3802} 3803void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3804 DependentTemplateSpecializationTypeLoc TL) { 3805 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3806 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3807 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3808 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3809 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3810 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3811 TL.setArgLocInfo(I, 3812 Reader.GetTemplateArgumentLocInfo(F, 3813 TL.getTypePtr()->getArg(I).getKind(), 3814 Record, Idx)); 3815} 3816void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3817 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3818} 3819void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3820 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3821} 3822void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3823 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3824 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3825 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3826 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3827 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3828} 3829void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3830 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3831} 3832 3833TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F, 3834 const RecordData &Record, 3835 unsigned &Idx) { 3836 QualType InfoTy = GetType(Record[Idx++]); 3837 if (InfoTy.isNull()) 3838 return 0; 3839 3840 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3841 TypeLocReader TLR(*this, F, Record, Idx); 3842 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3843 TLR.Visit(TL); 3844 return TInfo; 3845} 3846 3847QualType ASTReader::GetType(TypeID ID) { 3848 unsigned FastQuals = ID & Qualifiers::FastMask; 3849 unsigned Index = ID >> Qualifiers::FastWidth; 3850 3851 if (Index < NUM_PREDEF_TYPE_IDS) { 3852 QualType T; 3853 switch ((PredefinedTypeIDs)Index) { 3854 case PREDEF_TYPE_NULL_ID: return QualType(); 3855 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3856 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3857 3858 case PREDEF_TYPE_CHAR_U_ID: 3859 case PREDEF_TYPE_CHAR_S_ID: 3860 // FIXME: Check that the signedness of CharTy is correct! 3861 T = Context->CharTy; 3862 break; 3863 3864 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3865 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3866 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3867 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3868 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3869 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3870 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3871 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3872 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3873 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3874 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3875 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3876 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3877 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3878 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3879 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3880 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3881 case PREDEF_TYPE_BOUND_MEMBER: T = Context->BoundMemberTy; break; 3882 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3883 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break; 3884 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3885 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3886 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3887 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3888 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3889 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 3890 } 3891 3892 assert(!T.isNull() && "Unknown predefined type"); 3893 return T.withFastQualifiers(FastQuals); 3894 } 3895 3896 Index -= NUM_PREDEF_TYPE_IDS; 3897 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3898 if (TypesLoaded[Index].isNull()) { 3899 TypesLoaded[Index] = ReadTypeRecord(Index); 3900 if (TypesLoaded[Index].isNull()) 3901 return QualType(); 3902 3903 TypesLoaded[Index]->setFromAST(); 3904 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID); 3905 if (DeserializationListener) 3906 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3907 TypesLoaded[Index]); 3908 } 3909 3910 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3911} 3912 3913TypeID ASTReader::GetTypeID(QualType T) const { 3914 return MakeTypeID(T, 3915 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this)); 3916} 3917 3918TypeIdx ASTReader::GetTypeIdx(QualType T) const { 3919 if (T.isNull()) 3920 return TypeIdx(); 3921 assert(!T.getLocalFastQualifiers()); 3922 3923 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3924 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and 3925 // comparing keys of ASTDeclContextNameLookupTable. 3926 // If the type didn't come from the AST file use a specially marked index 3927 // so that any hash/key comparison fail since no such index is stored 3928 // in a AST file. 3929 if (I == TypeIdxs.end()) 3930 return TypeIdx(-1); 3931 return I->second; 3932} 3933 3934TemplateArgumentLocInfo 3935ASTReader::GetTemplateArgumentLocInfo(PerFileData &F, 3936 TemplateArgument::ArgKind Kind, 3937 const RecordData &Record, 3938 unsigned &Index) { 3939 switch (Kind) { 3940 case TemplateArgument::Expression: 3941 return ReadExpr(F); 3942 case TemplateArgument::Type: 3943 return GetTypeSourceInfo(F, Record, Index); 3944 case TemplateArgument::Template: { 3945 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3946 Index); 3947 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3948 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3949 SourceLocation()); 3950 } 3951 case TemplateArgument::TemplateExpansion: { 3952 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3953 Index); 3954 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3955 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 3956 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3957 EllipsisLoc); 3958 } 3959 case TemplateArgument::Null: 3960 case TemplateArgument::Integral: 3961 case TemplateArgument::Declaration: 3962 case TemplateArgument::Pack: 3963 return TemplateArgumentLocInfo(); 3964 } 3965 llvm_unreachable("unexpected template argument loc"); 3966 return TemplateArgumentLocInfo(); 3967} 3968 3969TemplateArgumentLoc 3970ASTReader::ReadTemplateArgumentLoc(PerFileData &F, 3971 const RecordData &Record, unsigned &Index) { 3972 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 3973 3974 if (Arg.getKind() == TemplateArgument::Expression) { 3975 if (Record[Index++]) // bool InfoHasSameExpr. 3976 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3977 } 3978 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 3979 Record, Index)); 3980} 3981 3982Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3983 return GetDecl(ID); 3984} 3985 3986uint64_t 3987ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) { 3988 if (ID == 0) 3989 return 0; 3990 3991 GlobalCXXBaseSpecifiersMapType::iterator I = 3992 GlobalCXXBaseSpecifiersMap.find(ID); 3993 3994 assert (I != GlobalCXXBaseSpecifiersMap.end() && 3995 "Corrupted global CXX base specifiers map"); 3996 3997 return I->second.first->CXXBaseSpecifiersOffsets[ID - 1 + 3998 I->second.second] + 3999 I->second.first->GlobalBitOffset; 4000 4001} 4002 4003CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4004 // Figure out which AST file contains this offset. 4005 PerFileData *F = 0; 4006 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4007 if (Offset < Chain[N - I - 1]->SizeInBits) { 4008 F = Chain[N - I - 1]; 4009 break; 4010 } 4011 4012 Offset -= Chain[N - I - 1]->SizeInBits; 4013 } 4014 4015 if (!F) { 4016 Error("Malformed AST file: C++ base specifiers at impossible offset"); 4017 return 0; 4018 } 4019 4020 llvm::BitstreamCursor &Cursor = F->DeclsCursor; 4021 SavedStreamPosition SavedPosition(Cursor); 4022 Cursor.JumpToBit(Offset); 4023 ReadingKindTracker ReadingKind(Read_Decl, *this); 4024 RecordData Record; 4025 unsigned Code = Cursor.ReadCode(); 4026 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4027 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4028 Error("Malformed AST file: missing C++ base specifiers"); 4029 return 0; 4030 } 4031 4032 unsigned Idx = 0; 4033 unsigned NumBases = Record[Idx++]; 4034 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4035 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4036 for (unsigned I = 0; I != NumBases; ++I) 4037 Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx); 4038 return Bases; 4039} 4040 4041TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 4042 if (!DeclsLoaded[0]) { 4043 ReadDeclRecord(0, 1); 4044 if (DeserializationListener) 4045 DeserializationListener->DeclRead(1, DeclsLoaded[0]); 4046 } 4047 4048 return cast<TranslationUnitDecl>(DeclsLoaded[0]); 4049} 4050 4051Decl *ASTReader::GetDecl(DeclID ID) { 4052 if (ID == 0) 4053 return 0; 4054 4055 if (ID > DeclsLoaded.size()) { 4056 Error("declaration ID out-of-range for AST file"); 4057 return 0; 4058 } 4059 4060 unsigned Index = ID - 1; 4061 if (!DeclsLoaded[Index]) { 4062 ReadDeclRecord(Index, ID); 4063 if (DeserializationListener) 4064 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4065 } 4066 4067 return DeclsLoaded[Index]; 4068} 4069 4070/// \brief Resolve the offset of a statement into a statement. 4071/// 4072/// This operation will read a new statement from the external 4073/// source each time it is called, and is meant to be used via a 4074/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4075Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4076 // Switch case IDs are per Decl. 4077 ClearSwitchCaseIDs(); 4078 4079 // Offset here is a global offset across the entire chain. 4080 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4081 PerFileData &F = *Chain[N - I - 1]; 4082 if (Offset < F.SizeInBits) { 4083 // Since we know that this statement is part of a decl, make sure to use 4084 // the decl cursor to read it. 4085 F.DeclsCursor.JumpToBit(Offset); 4086 return ReadStmtFromStream(F); 4087 } 4088 Offset -= F.SizeInBits; 4089 } 4090 llvm_unreachable("Broken chain"); 4091} 4092 4093ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4094 bool (*isKindWeWant)(Decl::Kind), 4095 llvm::SmallVectorImpl<Decl*> &Decls) { 4096 // There might be lexical decls in multiple parts of the chain, for the TU 4097 // at least. 4098 // DeclContextOffsets might reallocate as we load additional decls below, 4099 // so make a copy of the vector. 4100 DeclContextInfos Infos = DeclContextOffsets[DC]; 4101 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4102 I != E; ++I) { 4103 // IDs can be 0 if this context doesn't contain declarations. 4104 if (!I->LexicalDecls) 4105 continue; 4106 4107 // Load all of the declaration IDs 4108 for (const KindDeclIDPair *ID = I->LexicalDecls, 4109 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 4110 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 4111 continue; 4112 4113 Decl *D = GetDecl(ID->second); 4114 assert(D && "Null decl in lexical decls"); 4115 Decls.push_back(D); 4116 } 4117 } 4118 4119 ++NumLexicalDeclContextsRead; 4120 return ELR_Success; 4121} 4122 4123DeclContext::lookup_result 4124ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4125 DeclarationName Name) { 4126 assert(DC->hasExternalVisibleStorage() && 4127 "DeclContext has no visible decls in storage"); 4128 if (!Name) 4129 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4130 DeclContext::lookup_iterator(0)); 4131 4132 llvm::SmallVector<NamedDecl *, 64> Decls; 4133 // There might be visible decls in multiple parts of the chain, for the TU 4134 // and namespaces. For any given name, the last available results replace 4135 // all earlier ones. For this reason, we walk in reverse. 4136 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4137 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 4138 I != E; ++I) { 4139 if (!I->NameLookupTableData) 4140 continue; 4141 4142 ASTDeclContextNameLookupTable *LookupTable = 4143 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4144 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 4145 if (Pos == LookupTable->end()) 4146 continue; 4147 4148 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4149 for (; Data.first != Data.second; ++Data.first) 4150 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 4151 break; 4152 } 4153 4154 ++NumVisibleDeclContextsRead; 4155 4156 SetExternalVisibleDeclsForName(DC, Name, Decls); 4157 return const_cast<DeclContext*>(DC)->lookup(Name); 4158} 4159 4160void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 4161 assert(DC->hasExternalVisibleStorage() && 4162 "DeclContext has no visible decls in storage"); 4163 4164 llvm::SmallVector<NamedDecl *, 64> Decls; 4165 // There might be visible decls in multiple parts of the chain, for the TU 4166 // and namespaces. 4167 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4168 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4169 I != E; ++I) { 4170 if (!I->NameLookupTableData) 4171 continue; 4172 4173 ASTDeclContextNameLookupTable *LookupTable = 4174 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4175 for (ASTDeclContextNameLookupTable::item_iterator 4176 ItemI = LookupTable->item_begin(), 4177 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 4178 ASTDeclContextNameLookupTable::item_iterator::value_type Val 4179 = *ItemI; 4180 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 4181 Decls.clear(); 4182 for (; Data.first != Data.second; ++Data.first) 4183 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 4184 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 4185 } 4186 } 4187} 4188 4189void ASTReader::PassInterestingDeclsToConsumer() { 4190 assert(Consumer); 4191 while (!InterestingDecls.empty()) { 4192 DeclGroupRef DG(InterestingDecls.front()); 4193 InterestingDecls.pop_front(); 4194 Consumer->HandleInterestingDecl(DG); 4195 } 4196} 4197 4198void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4199 this->Consumer = Consumer; 4200 4201 if (!Consumer) 4202 return; 4203 4204 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4205 // Force deserialization of this decl, which will cause it to be queued for 4206 // passing to the consumer. 4207 GetDecl(ExternalDefinitions[I]); 4208 } 4209 4210 PassInterestingDeclsToConsumer(); 4211} 4212 4213void ASTReader::PrintStats() { 4214 std::fprintf(stderr, "*** AST File Statistics:\n"); 4215 4216 unsigned NumTypesLoaded 4217 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4218 QualType()); 4219 unsigned NumDeclsLoaded 4220 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4221 (Decl *)0); 4222 unsigned NumIdentifiersLoaded 4223 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4224 IdentifiersLoaded.end(), 4225 (IdentifierInfo *)0); 4226 unsigned NumSelectorsLoaded 4227 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4228 SelectorsLoaded.end(), 4229 Selector()); 4230 4231 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4232 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4233 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4234 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4235 NumSLocEntriesRead, TotalNumSLocEntries, 4236 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4237 if (!TypesLoaded.empty()) 4238 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4239 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4240 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4241 if (!DeclsLoaded.empty()) 4242 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4243 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4244 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4245 if (!IdentifiersLoaded.empty()) 4246 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4247 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4248 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4249 if (!SelectorsLoaded.empty()) 4250 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4251 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4252 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4253 if (TotalNumStatements) 4254 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4255 NumStatementsRead, TotalNumStatements, 4256 ((float)NumStatementsRead/TotalNumStatements * 100)); 4257 if (TotalNumMacros) 4258 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4259 NumMacrosRead, TotalNumMacros, 4260 ((float)NumMacrosRead/TotalNumMacros * 100)); 4261 if (TotalLexicalDeclContexts) 4262 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4263 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4264 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4265 * 100)); 4266 if (TotalVisibleDeclContexts) 4267 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4268 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4269 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4270 * 100)); 4271 if (TotalNumMethodPoolEntries) { 4272 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4273 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4274 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4275 * 100)); 4276 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4277 } 4278 std::fprintf(stderr, "\n"); 4279 dump(); 4280 std::fprintf(stderr, "\n"); 4281} 4282 4283template<typename Key, typename PerFileData, unsigned InitialCapacity> 4284static void 4285dumpModuleIDMap(llvm::StringRef Name, 4286 const ContinuousRangeMap<Key, PerFileData *, 4287 InitialCapacity> &Map) { 4288 if (Map.begin() == Map.end()) 4289 return; 4290 4291 typedef ContinuousRangeMap<Key, PerFileData *, InitialCapacity> MapType; 4292 llvm::errs() << Name << ":\n"; 4293 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4294 I != IEnd; ++I) { 4295 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4296 << "\n"; 4297 } 4298} 4299 4300template<typename Key, typename PerFileData, typename Adjustment, 4301 unsigned InitialCapacity> 4302static void 4303dumpModuleIDOffsetMap(llvm::StringRef Name, 4304 const ContinuousRangeMap<Key, 4305 std::pair<PerFileData *, 4306 Adjustment>, 4307 InitialCapacity> &Map) { 4308 if (Map.begin() == Map.end()) 4309 return; 4310 4311 typedef ContinuousRangeMap<Key, std::pair<PerFileData *, Adjustment>, 4312 InitialCapacity> MapType; 4313 llvm::errs() << Name << ":\n"; 4314 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4315 I != IEnd; ++I) { 4316 llvm::errs() << " " << I->first << " -> (" << I->second.first->FileName 4317 << ", " << I->second.second << ")\n"; 4318 } 4319} 4320 4321void ASTReader::dump() { 4322 llvm::errs() << "*** AST File Remapping:\n"; 4323 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4324 dumpModuleIDOffsetMap("Global type map", GlobalTypeMap); 4325 dumpModuleIDOffsetMap("Global declaration map", GlobalDeclMap); 4326 dumpModuleIDOffsetMap("Global identifier map", GlobalIdentifierMap); 4327 dumpModuleIDOffsetMap("Global selector map", GlobalSelectorMap); 4328 dumpModuleIDOffsetMap("Global macro definition map", 4329 GlobalMacroDefinitionMap); 4330 dumpModuleIDOffsetMap("Global preprocessed entity map", 4331 GlobalPreprocessedEntityMap); 4332 4333} 4334 4335/// Return the amount of memory used by memory buffers, breaking down 4336/// by heap-backed versus mmap'ed memory. 4337void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4338 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 4339 if (llvm::MemoryBuffer *buf = Chain[i]->Buffer.get()) { 4340 size_t bytes = buf->getBufferSize(); 4341 switch (buf->getBufferKind()) { 4342 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4343 sizes.malloc_bytes += bytes; 4344 break; 4345 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4346 sizes.mmap_bytes += bytes; 4347 break; 4348 } 4349 } 4350} 4351 4352void ASTReader::InitializeSema(Sema &S) { 4353 SemaObj = &S; 4354 S.ExternalSource = this; 4355 4356 // Makes sure any declarations that were deserialized "too early" 4357 // still get added to the identifier's declaration chains. 4358 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4359 if (SemaObj->TUScope) 4360 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4361 4362 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4363 } 4364 PreloadedDecls.clear(); 4365 4366 // If there were any tentative definitions, deserialize them and add 4367 // them to Sema's list of tentative definitions. 4368 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4369 VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I])); 4370 SemaObj->TentativeDefinitions.push_back(Var); 4371 } 4372 4373 // If there were any unused file scoped decls, deserialize them and add to 4374 // Sema's list of unused file scoped decls. 4375 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4376 DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4377 SemaObj->UnusedFileScopedDecls.push_back(D); 4378 } 4379 4380 // If there were any delegating constructors, add them to Sema's list 4381 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 4382 CXXConstructorDecl *D 4383 = cast<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 4384 SemaObj->DelegatingCtorDecls.push_back(D); 4385 } 4386 4387 // If there were any locally-scoped external declarations, 4388 // deserialize them and add them to Sema's table of locally-scoped 4389 // external declarations. 4390 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4391 NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4392 SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D; 4393 } 4394 4395 // If there were any ext_vector type declarations, deserialize them 4396 // and add them to Sema's vector of such declarations. 4397 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) 4398 SemaObj->ExtVectorDecls.push_back( 4399 cast<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]))); 4400 4401 // FIXME: Do VTable uses and dynamic classes deserialize too much ? 4402 // Can we cut them down before writing them ? 4403 4404 // If there were any dynamic classes declarations, deserialize them 4405 // and add them to Sema's vector of such declarations. 4406 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) 4407 SemaObj->DynamicClasses.push_back( 4408 cast<CXXRecordDecl>(GetDecl(DynamicClasses[I]))); 4409 4410 // Load the offsets of the declarations that Sema references. 4411 // They will be lazily deserialized when needed. 4412 if (!SemaDeclRefs.empty()) { 4413 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4414 SemaObj->StdNamespace = SemaDeclRefs[0]; 4415 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4416 } 4417 4418 for (PerFileData *F = FirstInSource; F; F = F->NextInSource) { 4419 4420 // If there are @selector references added them to its pool. This is for 4421 // implementation of -Wselector. 4422 if (!F->ReferencedSelectorsData.empty()) { 4423 unsigned int DataSize = F->ReferencedSelectorsData.size()-1; 4424 unsigned I = 0; 4425 while (I < DataSize) { 4426 Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]); 4427 SourceLocation SelLoc = ReadSourceLocation( 4428 *F, F->ReferencedSelectorsData, I); 4429 SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc)); 4430 } 4431 } 4432 } 4433 4434 // The special data sets below always come from the most recent PCH, 4435 // which is at the front of the chain. 4436 PerFileData &F = *Chain.front(); 4437 4438 // If there were any pending implicit instantiations, deserialize them 4439 // and add them to Sema's queue of such instantiations. 4440 assert(F.PendingInstantiations.size() % 2 == 0 && 4441 "Expected pairs of entries"); 4442 for (unsigned Idx = 0, N = F.PendingInstantiations.size(); Idx < N;) { 4443 ValueDecl *D=cast<ValueDecl>(GetDecl(F.PendingInstantiations[Idx++])); 4444 SourceLocation Loc = ReadSourceLocation(F, F.PendingInstantiations,Idx); 4445 SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc)); 4446 } 4447 4448 // If there were any weak undeclared identifiers, deserialize them and add to 4449 // Sema's list of weak undeclared identifiers. 4450 if (!WeakUndeclaredIdentifiers.empty()) { 4451 unsigned Idx = 0; 4452 for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) { 4453 IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 4454 IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 4455 SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx); 4456 bool Used = WeakUndeclaredIdentifiers[Idx++]; 4457 Sema::WeakInfo WI(AliasId, Loc); 4458 WI.setUsed(Used); 4459 SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI)); 4460 } 4461 } 4462 4463 // If there were any VTable uses, deserialize the information and add it 4464 // to Sema's vector and map of VTable uses. 4465 if (!VTableUses.empty()) { 4466 unsigned Idx = 0; 4467 for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) { 4468 CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4469 SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx); 4470 bool DefinitionRequired = VTableUses[Idx++]; 4471 SemaObj->VTableUses.push_back(std::make_pair(Class, Loc)); 4472 SemaObj->VTablesUsed[Class] = DefinitionRequired; 4473 } 4474 } 4475 4476 if (!FPPragmaOptions.empty()) { 4477 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4478 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4479 } 4480 4481 if (!OpenCLExtensions.empty()) { 4482 unsigned I = 0; 4483#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4484#include "clang/Basic/OpenCLExtensions.def" 4485 4486 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4487 } 4488} 4489 4490IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4491 // Try to find this name within our on-disk hash tables. We start with the 4492 // most recent one, since that one contains the most up-to-date info. 4493 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4494 ASTIdentifierLookupTable *IdTable 4495 = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable; 4496 if (!IdTable) 4497 continue; 4498 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 4499 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 4500 if (Pos == IdTable->end()) 4501 continue; 4502 4503 // Dereferencing the iterator has the effect of building the 4504 // IdentifierInfo node and populating it with the various 4505 // declarations it needs. 4506 return *Pos; 4507 } 4508 return 0; 4509} 4510 4511namespace clang { 4512 /// \brief An identifier-lookup iterator that enumerates all of the 4513 /// identifiers stored within a set of AST files. 4514 class ASTIdentifierIterator : public IdentifierIterator { 4515 /// \brief The AST reader whose identifiers are being enumerated. 4516 const ASTReader &Reader; 4517 4518 /// \brief The current index into the chain of AST files stored in 4519 /// the AST reader. 4520 unsigned Index; 4521 4522 /// \brief The current position within the identifier lookup table 4523 /// of the current AST file. 4524 ASTIdentifierLookupTable::key_iterator Current; 4525 4526 /// \brief The end position within the identifier lookup table of 4527 /// the current AST file. 4528 ASTIdentifierLookupTable::key_iterator End; 4529 4530 public: 4531 explicit ASTIdentifierIterator(const ASTReader &Reader); 4532 4533 virtual llvm::StringRef Next(); 4534 }; 4535} 4536 4537ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4538 : Reader(Reader), Index(Reader.Chain.size() - 1) { 4539 ASTIdentifierLookupTable *IdTable 4540 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 4541 Current = IdTable->key_begin(); 4542 End = IdTable->key_end(); 4543} 4544 4545llvm::StringRef ASTIdentifierIterator::Next() { 4546 while (Current == End) { 4547 // If we have exhausted all of our AST files, we're done. 4548 if (Index == 0) 4549 return llvm::StringRef(); 4550 4551 --Index; 4552 ASTIdentifierLookupTable *IdTable 4553 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable; 4554 Current = IdTable->key_begin(); 4555 End = IdTable->key_end(); 4556 } 4557 4558 // We have any identifiers remaining in the current AST file; return 4559 // the next one. 4560 std::pair<const char*, unsigned> Key = *Current; 4561 ++Current; 4562 return llvm::StringRef(Key.first, Key.second); 4563} 4564 4565IdentifierIterator *ASTReader::getIdentifiers() const { 4566 return new ASTIdentifierIterator(*this); 4567} 4568 4569std::pair<ObjCMethodList, ObjCMethodList> 4570ASTReader::ReadMethodPool(Selector Sel) { 4571 // Find this selector in a hash table. We want to find the most recent entry. 4572 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 4573 PerFileData &F = *Chain[I]; 4574 if (!F.SelectorLookupTable) 4575 continue; 4576 4577 ASTSelectorLookupTable *PoolTable 4578 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 4579 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 4580 if (Pos != PoolTable->end()) { 4581 ++NumSelectorsRead; 4582 // FIXME: Not quite happy with the statistics here. We probably should 4583 // disable this tracking when called via LoadSelector. 4584 // Also, should entries without methods count as misses? 4585 ++NumMethodPoolEntriesRead; 4586 ASTSelectorLookupTrait::data_type Data = *Pos; 4587 if (DeserializationListener) 4588 DeserializationListener->SelectorRead(Data.ID, Sel); 4589 return std::make_pair(Data.Instance, Data.Factory); 4590 } 4591 } 4592 4593 ++NumMethodPoolMisses; 4594 return std::pair<ObjCMethodList, ObjCMethodList>(); 4595} 4596 4597void ASTReader::ReadKnownNamespaces( 4598 llvm::SmallVectorImpl<NamespaceDecl *> &Namespaces) { 4599 Namespaces.clear(); 4600 4601 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 4602 if (NamespaceDecl *Namespace 4603 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 4604 Namespaces.push_back(Namespace); 4605 } 4606} 4607 4608void ASTReader::LoadSelector(Selector Sel) { 4609 // It would be complicated to avoid reading the methods anyway. So don't. 4610 ReadMethodPool(Sel); 4611} 4612 4613void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { 4614 assert(ID && "Non-zero identifier ID required"); 4615 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4616 IdentifiersLoaded[ID - 1] = II; 4617 if (DeserializationListener) 4618 DeserializationListener->IdentifierRead(ID, II); 4619} 4620 4621/// \brief Set the globally-visible declarations associated with the given 4622/// identifier. 4623/// 4624/// If the AST reader is currently in a state where the given declaration IDs 4625/// cannot safely be resolved, they are queued until it is safe to resolve 4626/// them. 4627/// 4628/// \param II an IdentifierInfo that refers to one or more globally-visible 4629/// declarations. 4630/// 4631/// \param DeclIDs the set of declaration IDs with the name @p II that are 4632/// visible at global scope. 4633/// 4634/// \param Nonrecursive should be true to indicate that the caller knows that 4635/// this call is non-recursive, and therefore the globally-visible declarations 4636/// will not be placed onto the pending queue. 4637void 4638ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4639 const llvm::SmallVectorImpl<uint32_t> &DeclIDs, 4640 bool Nonrecursive) { 4641 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4642 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4643 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4644 PII.II = II; 4645 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4646 return; 4647 } 4648 4649 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4650 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4651 if (SemaObj) { 4652 if (SemaObj->TUScope) { 4653 // Introduce this declaration into the translation-unit scope 4654 // and add it to the declaration chain for this identifier, so 4655 // that (unqualified) name lookup will find it. 4656 SemaObj->TUScope->AddDecl(D); 4657 } 4658 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4659 } else { 4660 // Queue this declaration so that it will be added to the 4661 // translation unit scope and identifier's declaration chain 4662 // once a Sema object is known. 4663 PreloadedDecls.push_back(D); 4664 } 4665 } 4666} 4667 4668IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) { 4669 if (ID == 0) 4670 return 0; 4671 4672 if (IdentifiersLoaded.empty()) { 4673 Error("no identifier table in AST file"); 4674 return 0; 4675 } 4676 4677 assert(PP && "Forgot to set Preprocessor ?"); 4678 ID -= 1; 4679 if (!IdentifiersLoaded[ID]) { 4680 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 4681 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 4682 unsigned Index = ID + I->second.second; 4683 const char *Str = I->second.first->IdentifierTableData 4684 + I->second.first->IdentifierOffsets[Index]; 4685 4686 // All of the strings in the AST file are preceded by a 16-bit length. 4687 // Extract that 16-bit length to avoid having to execute strlen(). 4688 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4689 // unsigned integers. This is important to avoid integer overflow when 4690 // we cast them to 'unsigned'. 4691 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4692 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4693 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4694 IdentifiersLoaded[ID] 4695 = &PP->getIdentifierTable().get(llvm::StringRef(Str, StrLen)); 4696 if (DeserializationListener) 4697 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4698 } 4699 4700 return IdentifiersLoaded[ID]; 4701} 4702 4703bool ASTReader::ReadSLocEntry(int ID) { 4704 return ReadSLocEntryRecord(ID) != Success; 4705} 4706 4707Selector ASTReader::DecodeSelector(unsigned ID) { 4708 if (ID == 0) 4709 return Selector(); 4710 4711 if (ID > SelectorsLoaded.size()) { 4712 Error("selector ID out of range in AST file"); 4713 return Selector(); 4714 } 4715 4716 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4717 // Load this selector from the selector table. 4718 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 4719 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 4720 ASTSelectorLookupTrait Trait(*this); 4721 PerFileData &F = *I->second.first; 4722 unsigned Idx = ID - 1 + I->second.second; 4723 SelectorsLoaded[ID - 1] = 4724 Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0); 4725 if (DeserializationListener) 4726 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4727 } 4728 4729 return SelectorsLoaded[ID - 1]; 4730} 4731 4732Selector ASTReader::GetExternalSelector(uint32_t ID) { 4733 return DecodeSelector(ID); 4734} 4735 4736uint32_t ASTReader::GetNumExternalSelectors() { 4737 // ID 0 (the null selector) is considered an external selector. 4738 return getTotalNumSelectors() + 1; 4739} 4740 4741DeclarationName 4742ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { 4743 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 4744 switch (Kind) { 4745 case DeclarationName::Identifier: 4746 return DeclarationName(GetIdentifierInfo(Record, Idx)); 4747 4748 case DeclarationName::ObjCZeroArgSelector: 4749 case DeclarationName::ObjCOneArgSelector: 4750 case DeclarationName::ObjCMultiArgSelector: 4751 return DeclarationName(GetSelector(Record, Idx)); 4752 4753 case DeclarationName::CXXConstructorName: 4754 return Context->DeclarationNames.getCXXConstructorName( 4755 Context->getCanonicalType(GetType(Record[Idx++]))); 4756 4757 case DeclarationName::CXXDestructorName: 4758 return Context->DeclarationNames.getCXXDestructorName( 4759 Context->getCanonicalType(GetType(Record[Idx++]))); 4760 4761 case DeclarationName::CXXConversionFunctionName: 4762 return Context->DeclarationNames.getCXXConversionFunctionName( 4763 Context->getCanonicalType(GetType(Record[Idx++]))); 4764 4765 case DeclarationName::CXXOperatorName: 4766 return Context->DeclarationNames.getCXXOperatorName( 4767 (OverloadedOperatorKind)Record[Idx++]); 4768 4769 case DeclarationName::CXXLiteralOperatorName: 4770 return Context->DeclarationNames.getCXXLiteralOperatorName( 4771 GetIdentifierInfo(Record, Idx)); 4772 4773 case DeclarationName::CXXUsingDirective: 4774 return DeclarationName::getUsingDirectiveName(); 4775 } 4776 4777 // Required to silence GCC warning 4778 return DeclarationName(); 4779} 4780 4781void ASTReader::ReadDeclarationNameLoc(PerFileData &F, 4782 DeclarationNameLoc &DNLoc, 4783 DeclarationName Name, 4784 const RecordData &Record, unsigned &Idx) { 4785 switch (Name.getNameKind()) { 4786 case DeclarationName::CXXConstructorName: 4787 case DeclarationName::CXXDestructorName: 4788 case DeclarationName::CXXConversionFunctionName: 4789 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 4790 break; 4791 4792 case DeclarationName::CXXOperatorName: 4793 DNLoc.CXXOperatorName.BeginOpNameLoc 4794 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4795 DNLoc.CXXOperatorName.EndOpNameLoc 4796 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4797 break; 4798 4799 case DeclarationName::CXXLiteralOperatorName: 4800 DNLoc.CXXLiteralOperatorName.OpNameLoc 4801 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4802 break; 4803 4804 case DeclarationName::Identifier: 4805 case DeclarationName::ObjCZeroArgSelector: 4806 case DeclarationName::ObjCOneArgSelector: 4807 case DeclarationName::ObjCMultiArgSelector: 4808 case DeclarationName::CXXUsingDirective: 4809 break; 4810 } 4811} 4812 4813void ASTReader::ReadDeclarationNameInfo(PerFileData &F, 4814 DeclarationNameInfo &NameInfo, 4815 const RecordData &Record, unsigned &Idx) { 4816 NameInfo.setName(ReadDeclarationName(Record, Idx)); 4817 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4818 DeclarationNameLoc DNLoc; 4819 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 4820 NameInfo.setInfo(DNLoc); 4821} 4822 4823void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info, 4824 const RecordData &Record, unsigned &Idx) { 4825 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 4826 unsigned NumTPLists = Record[Idx++]; 4827 Info.NumTemplParamLists = NumTPLists; 4828 if (NumTPLists) { 4829 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 4830 for (unsigned i=0; i != NumTPLists; ++i) 4831 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 4832 } 4833} 4834 4835TemplateName 4836ASTReader::ReadTemplateName(PerFileData &F, const RecordData &Record, 4837 unsigned &Idx) { 4838 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 4839 switch (Kind) { 4840 case TemplateName::Template: 4841 return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++]))); 4842 4843 case TemplateName::OverloadedTemplate: { 4844 unsigned size = Record[Idx++]; 4845 UnresolvedSet<8> Decls; 4846 while (size--) 4847 Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4848 4849 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 4850 } 4851 4852 case TemplateName::QualifiedTemplate: { 4853 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4854 bool hasTemplKeyword = Record[Idx++]; 4855 TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++])); 4856 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 4857 } 4858 4859 case TemplateName::DependentTemplate: { 4860 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 4861 if (Record[Idx++]) // isIdentifier 4862 return Context->getDependentTemplateName(NNS, 4863 GetIdentifierInfo(Record, Idx)); 4864 return Context->getDependentTemplateName(NNS, 4865 (OverloadedOperatorKind)Record[Idx++]); 4866 } 4867 4868 case TemplateName::SubstTemplateTemplateParm: { 4869 TemplateTemplateParmDecl *param 4870 = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++])); 4871 if (!param) return TemplateName(); 4872 TemplateName replacement = ReadTemplateName(F, Record, Idx); 4873 return Context->getSubstTemplateTemplateParm(param, replacement); 4874 } 4875 4876 case TemplateName::SubstTemplateTemplateParmPack: { 4877 TemplateTemplateParmDecl *Param 4878 = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++])); 4879 if (!Param) 4880 return TemplateName(); 4881 4882 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 4883 if (ArgPack.getKind() != TemplateArgument::Pack) 4884 return TemplateName(); 4885 4886 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack); 4887 } 4888 } 4889 4890 assert(0 && "Unhandled template name kind!"); 4891 return TemplateName(); 4892} 4893 4894TemplateArgument 4895ASTReader::ReadTemplateArgument(PerFileData &F, 4896 const RecordData &Record, unsigned &Idx) { 4897 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 4898 switch (Kind) { 4899 case TemplateArgument::Null: 4900 return TemplateArgument(); 4901 case TemplateArgument::Type: 4902 return TemplateArgument(GetType(Record[Idx++])); 4903 case TemplateArgument::Declaration: 4904 return TemplateArgument(GetDecl(Record[Idx++])); 4905 case TemplateArgument::Integral: { 4906 llvm::APSInt Value = ReadAPSInt(Record, Idx); 4907 QualType T = GetType(Record[Idx++]); 4908 return TemplateArgument(Value, T); 4909 } 4910 case TemplateArgument::Template: 4911 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 4912 case TemplateArgument::TemplateExpansion: { 4913 TemplateName Name = ReadTemplateName(F, Record, Idx); 4914 llvm::Optional<unsigned> NumTemplateExpansions; 4915 if (unsigned NumExpansions = Record[Idx++]) 4916 NumTemplateExpansions = NumExpansions - 1; 4917 return TemplateArgument(Name, NumTemplateExpansions); 4918 } 4919 case TemplateArgument::Expression: 4920 return TemplateArgument(ReadExpr(F)); 4921 case TemplateArgument::Pack: { 4922 unsigned NumArgs = Record[Idx++]; 4923 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs]; 4924 for (unsigned I = 0; I != NumArgs; ++I) 4925 Args[I] = ReadTemplateArgument(F, Record, Idx); 4926 return TemplateArgument(Args, NumArgs); 4927 } 4928 } 4929 4930 assert(0 && "Unhandled template argument kind!"); 4931 return TemplateArgument(); 4932} 4933 4934TemplateParameterList * 4935ASTReader::ReadTemplateParameterList(PerFileData &F, 4936 const RecordData &Record, unsigned &Idx) { 4937 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 4938 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 4939 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 4940 4941 unsigned NumParams = Record[Idx++]; 4942 llvm::SmallVector<NamedDecl *, 16> Params; 4943 Params.reserve(NumParams); 4944 while (NumParams--) 4945 Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++]))); 4946 4947 TemplateParameterList* TemplateParams = 4948 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 4949 Params.data(), Params.size(), RAngleLoc); 4950 return TemplateParams; 4951} 4952 4953void 4954ASTReader:: 4955ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs, 4956 PerFileData &F, const RecordData &Record, 4957 unsigned &Idx) { 4958 unsigned NumTemplateArgs = Record[Idx++]; 4959 TemplArgs.reserve(NumTemplateArgs); 4960 while (NumTemplateArgs--) 4961 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 4962} 4963 4964/// \brief Read a UnresolvedSet structure. 4965void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set, 4966 const RecordData &Record, unsigned &Idx) { 4967 unsigned NumDecls = Record[Idx++]; 4968 while (NumDecls--) { 4969 NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++])); 4970 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 4971 Set.addDecl(D, AS); 4972 } 4973} 4974 4975CXXBaseSpecifier 4976ASTReader::ReadCXXBaseSpecifier(PerFileData &F, 4977 const RecordData &Record, unsigned &Idx) { 4978 bool isVirtual = static_cast<bool>(Record[Idx++]); 4979 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 4980 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 4981 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 4982 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 4983 SourceRange Range = ReadSourceRange(F, Record, Idx); 4984 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 4985 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 4986 EllipsisLoc); 4987 Result.setInheritConstructors(inheritConstructors); 4988 return Result; 4989} 4990 4991std::pair<CXXCtorInitializer **, unsigned> 4992ASTReader::ReadCXXCtorInitializers(PerFileData &F, const RecordData &Record, 4993 unsigned &Idx) { 4994 CXXCtorInitializer **CtorInitializers = 0; 4995 unsigned NumInitializers = Record[Idx++]; 4996 if (NumInitializers) { 4997 ASTContext &C = *getContext(); 4998 4999 CtorInitializers 5000 = new (C) CXXCtorInitializer*[NumInitializers]; 5001 for (unsigned i=0; i != NumInitializers; ++i) { 5002 TypeSourceInfo *BaseClassInfo = 0; 5003 bool IsBaseVirtual = false; 5004 FieldDecl *Member = 0; 5005 IndirectFieldDecl *IndirectMember = 0; 5006 CXXConstructorDecl *Target = 0; 5007 5008 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5009 switch (Type) { 5010 case CTOR_INITIALIZER_BASE: 5011 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 5012 IsBaseVirtual = Record[Idx++]; 5013 break; 5014 5015 case CTOR_INITIALIZER_DELEGATING: 5016 Target = cast<CXXConstructorDecl>(GetDecl(Record[Idx++])); 5017 break; 5018 5019 case CTOR_INITIALIZER_MEMBER: 5020 Member = cast<FieldDecl>(GetDecl(Record[Idx++])); 5021 break; 5022 5023 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5024 IndirectMember = cast<IndirectFieldDecl>(GetDecl(Record[Idx++])); 5025 break; 5026 } 5027 5028 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5029 Expr *Init = ReadExpr(F); 5030 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5031 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5032 bool IsWritten = Record[Idx++]; 5033 unsigned SourceOrderOrNumArrayIndices; 5034 llvm::SmallVector<VarDecl *, 8> Indices; 5035 if (IsWritten) { 5036 SourceOrderOrNumArrayIndices = Record[Idx++]; 5037 } else { 5038 SourceOrderOrNumArrayIndices = Record[Idx++]; 5039 Indices.reserve(SourceOrderOrNumArrayIndices); 5040 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5041 Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++]))); 5042 } 5043 5044 CXXCtorInitializer *BOMInit; 5045 if (Type == CTOR_INITIALIZER_BASE) { 5046 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual, 5047 LParenLoc, Init, RParenLoc, 5048 MemberOrEllipsisLoc); 5049 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5050 BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc, 5051 Target, Init, RParenLoc); 5052 } else if (IsWritten) { 5053 if (Member) 5054 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc, 5055 LParenLoc, Init, RParenLoc); 5056 else 5057 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember, 5058 MemberOrEllipsisLoc, LParenLoc, 5059 Init, RParenLoc); 5060 } else { 5061 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc, 5062 LParenLoc, Init, RParenLoc, 5063 Indices.data(), Indices.size()); 5064 } 5065 5066 if (IsWritten) 5067 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5068 CtorInitializers[i] = BOMInit; 5069 } 5070 } 5071 5072 return std::make_pair(CtorInitializers, NumInitializers); 5073} 5074 5075NestedNameSpecifier * 5076ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) { 5077 unsigned N = Record[Idx++]; 5078 NestedNameSpecifier *NNS = 0, *Prev = 0; 5079 for (unsigned I = 0; I != N; ++I) { 5080 NestedNameSpecifier::SpecifierKind Kind 5081 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5082 switch (Kind) { 5083 case NestedNameSpecifier::Identifier: { 5084 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 5085 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 5086 break; 5087 } 5088 5089 case NestedNameSpecifier::Namespace: { 5090 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 5091 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 5092 break; 5093 } 5094 5095 case NestedNameSpecifier::NamespaceAlias: { 5096 NamespaceAliasDecl *Alias 5097 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++])); 5098 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias); 5099 break; 5100 } 5101 5102 case NestedNameSpecifier::TypeSpec: 5103 case NestedNameSpecifier::TypeSpecWithTemplate: { 5104 const Type *T = GetType(Record[Idx++]).getTypePtrOrNull(); 5105 if (!T) 5106 return 0; 5107 5108 bool Template = Record[Idx++]; 5109 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 5110 break; 5111 } 5112 5113 case NestedNameSpecifier::Global: { 5114 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 5115 // No associated value, and there can't be a prefix. 5116 break; 5117 } 5118 } 5119 Prev = NNS; 5120 } 5121 return NNS; 5122} 5123 5124NestedNameSpecifierLoc 5125ASTReader::ReadNestedNameSpecifierLoc(PerFileData &F, const RecordData &Record, 5126 unsigned &Idx) { 5127 unsigned N = Record[Idx++]; 5128 NestedNameSpecifierLocBuilder Builder; 5129 for (unsigned I = 0; I != N; ++I) { 5130 NestedNameSpecifier::SpecifierKind Kind 5131 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5132 switch (Kind) { 5133 case NestedNameSpecifier::Identifier: { 5134 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 5135 SourceRange Range = ReadSourceRange(F, Record, Idx); 5136 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd()); 5137 break; 5138 } 5139 5140 case NestedNameSpecifier::Namespace: { 5141 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 5142 SourceRange Range = ReadSourceRange(F, Record, Idx); 5143 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd()); 5144 break; 5145 } 5146 5147 case NestedNameSpecifier::NamespaceAlias: { 5148 NamespaceAliasDecl *Alias 5149 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++])); 5150 SourceRange Range = ReadSourceRange(F, Record, Idx); 5151 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd()); 5152 break; 5153 } 5154 5155 case NestedNameSpecifier::TypeSpec: 5156 case NestedNameSpecifier::TypeSpecWithTemplate: { 5157 bool Template = Record[Idx++]; 5158 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5159 if (!T) 5160 return NestedNameSpecifierLoc(); 5161 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5162 5163 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5164 Builder.Extend(*Context, 5165 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5166 T->getTypeLoc(), ColonColonLoc); 5167 break; 5168 } 5169 5170 case NestedNameSpecifier::Global: { 5171 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5172 Builder.MakeGlobal(*Context, ColonColonLoc); 5173 break; 5174 } 5175 } 5176 } 5177 5178 return Builder.getWithLocInContext(*Context); 5179} 5180 5181SourceRange 5182ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record, 5183 unsigned &Idx) { 5184 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5185 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5186 return SourceRange(beg, end); 5187} 5188 5189/// \brief Read an integral value 5190llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5191 unsigned BitWidth = Record[Idx++]; 5192 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5193 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5194 Idx += NumWords; 5195 return Result; 5196} 5197 5198/// \brief Read a signed integral value 5199llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5200 bool isUnsigned = Record[Idx++]; 5201 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5202} 5203 5204/// \brief Read a floating-point value 5205llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5206 return llvm::APFloat(ReadAPInt(Record, Idx)); 5207} 5208 5209// \brief Read a string 5210std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5211 unsigned Len = Record[Idx++]; 5212 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5213 Idx += Len; 5214 return Result; 5215} 5216 5217VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5218 unsigned &Idx) { 5219 unsigned Major = Record[Idx++]; 5220 unsigned Minor = Record[Idx++]; 5221 unsigned Subminor = Record[Idx++]; 5222 if (Minor == 0) 5223 return VersionTuple(Major); 5224 if (Subminor == 0) 5225 return VersionTuple(Major, Minor - 1); 5226 return VersionTuple(Major, Minor - 1, Subminor - 1); 5227} 5228 5229CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record, 5230 unsigned &Idx) { 5231 CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++])); 5232 return CXXTemporary::Create(*Context, Decl); 5233} 5234 5235DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5236 return Diag(SourceLocation(), DiagID); 5237} 5238 5239DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5240 return Diags.Report(Loc, DiagID); 5241} 5242 5243/// \brief Retrieve the identifier table associated with the 5244/// preprocessor. 5245IdentifierTable &ASTReader::getIdentifierTable() { 5246 assert(PP && "Forgot to set Preprocessor ?"); 5247 return PP->getIdentifierTable(); 5248} 5249 5250/// \brief Record that the given ID maps to the given switch-case 5251/// statement. 5252void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5253 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5254 SwitchCaseStmts[ID] = SC; 5255} 5256 5257/// \brief Retrieve the switch-case statement with the given ID. 5258SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5259 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5260 return SwitchCaseStmts[ID]; 5261} 5262 5263void ASTReader::ClearSwitchCaseIDs() { 5264 SwitchCaseStmts.clear(); 5265} 5266 5267void ASTReader::FinishedDeserializing() { 5268 assert(NumCurrentElementsDeserializing && 5269 "FinishedDeserializing not paired with StartedDeserializing"); 5270 if (NumCurrentElementsDeserializing == 1) { 5271 // If any identifiers with corresponding top-level declarations have 5272 // been loaded, load those declarations now. 5273 while (!PendingIdentifierInfos.empty()) { 5274 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5275 PendingIdentifierInfos.front().DeclIDs, true); 5276 PendingIdentifierInfos.pop_front(); 5277 } 5278 5279 // Ready to load previous declarations of Decls that were delayed. 5280 while (!PendingPreviousDecls.empty()) { 5281 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5282 PendingPreviousDecls.front().second); 5283 PendingPreviousDecls.pop_front(); 5284 } 5285 5286 // We are not in recursive loading, so it's safe to pass the "interesting" 5287 // decls to the consumer. 5288 if (Consumer) 5289 PassInterestingDeclsToConsumer(); 5290 5291 assert(PendingForwardRefs.size() == 0 && 5292 "Some forward refs did not get linked to the definition!"); 5293 } 5294 --NumCurrentElementsDeserializing; 5295} 5296 5297ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 5298 const char *isysroot, bool DisableValidation, 5299 bool DisableStatCache) 5300 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 5301 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 5302 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 5303 Consumer(0), FirstInSource(0), RelocatablePCH(false), isysroot(isysroot), 5304 DisableValidation(DisableValidation), 5305 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 5306 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 5307 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 5308 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 5309 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 5310 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 5311 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 5312 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 5313 NumCXXBaseSpecifiersLoaded(0) 5314{ 5315 SourceMgr.setExternalSLocEntrySource(this); 5316} 5317 5318ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 5319 Diagnostic &Diags, const char *isysroot, 5320 bool DisableValidation, bool DisableStatCache) 5321 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 5322 Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), FirstInSource(0), 5323 RelocatablePCH(false), isysroot(isysroot), 5324 DisableValidation(DisableValidation), DisableStatCache(DisableStatCache), 5325 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 5326 TotalNumSLocEntries(0), NumStatementsRead(0), 5327 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 5328 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 5329 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 5330 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 5331 TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0), 5332 NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0) 5333{ 5334 SourceMgr.setExternalSLocEntrySource(this); 5335} 5336 5337ASTReader::~ASTReader() { 5338 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 5339 delete Chain[e - i - 1]; 5340 // Delete all visible decl lookup tables 5341 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 5342 E = DeclContextOffsets.end(); 5343 I != E; ++I) { 5344 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 5345 J != F; ++J) { 5346 if (J->NameLookupTableData) 5347 delete static_cast<ASTDeclContextNameLookupTable*>( 5348 J->NameLookupTableData); 5349 } 5350 } 5351 for (DeclContextVisibleUpdatesPending::iterator 5352 I = PendingVisibleUpdates.begin(), 5353 E = PendingVisibleUpdates.end(); 5354 I != E; ++I) { 5355 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5356 F = I->second.end(); 5357 J != F; ++J) 5358 delete static_cast<ASTDeclContextNameLookupTable*>(*J); 5359 } 5360} 5361 5362ASTReader::PerFileData::PerFileData(ASTFileType Ty) 5363 : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0), 5364 SLocEntryBaseOffset(0), SLocEntryOffsets(0), 5365 SLocFileOffsets(0), LocalNumIdentifiers(0), 5366 IdentifierOffsets(0), IdentifierTableData(0), 5367 IdentifierLookupTable(0), LocalNumMacroDefinitions(0), 5368 MacroDefinitionOffsets(0), LocalNumHeaderFileInfos(0), 5369 HeaderFileInfoTableData(0), HeaderFileInfoTable(0), 5370 LocalNumSelectors(0), SelectorOffsets(0), 5371 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 5372 DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 5373 LocalNumTypes(0), TypeOffsets(0), StatCache(0), 5374 NumPreallocatedPreprocessingEntities(0), NextInSource(0) 5375{} 5376 5377ASTReader::PerFileData::~PerFileData() { 5378 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 5379 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable); 5380 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 5381} 5382