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