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