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