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