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