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