ASTReader.cpp revision b1a7d9a21bcfc295d1d899a42c0d14d617058c29
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 PerFileData *Prev = Chain.empty() ? 0 : Chain.back(); 2126 Chain.push_back(new PerFileData()); 2127 PerFileData &F = *Chain.back(); 2128 if (Prev) 2129 Prev->NextInSource = &F; 2130 else 2131 FirstInSource = &F; 2132 F.Loaders.push_back(Prev); 2133 2134 // Set the AST file name. 2135 F.FileName = FileName; 2136 2137 // Open the AST file. 2138 // 2139 // FIXME: This shouldn't be here, we should just take a raw_ostream. 2140 std::string ErrStr; 2141 F.Buffer.reset(llvm::MemoryBuffer::getFileOrSTDIN(FileName, &ErrStr)); 2142 if (!F.Buffer) { 2143 Error(ErrStr.c_str()); 2144 return IgnorePCH; 2145 } 2146 2147 // Initialize the stream 2148 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2149 (const unsigned char *)F.Buffer->getBufferEnd()); 2150 llvm::BitstreamCursor &Stream = F.Stream; 2151 Stream.init(F.StreamFile); 2152 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2153 2154 // Sniff for the signature. 2155 if (Stream.Read(8) != 'C' || 2156 Stream.Read(8) != 'P' || 2157 Stream.Read(8) != 'C' || 2158 Stream.Read(8) != 'H') { 2159 Diag(diag::err_not_a_pch_file) << FileName; 2160 return Failure; 2161 } 2162 2163 while (!Stream.AtEndOfStream()) { 2164 unsigned Code = Stream.ReadCode(); 2165 2166 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2167 Error("invalid record at top-level of AST file"); 2168 return Failure; 2169 } 2170 2171 unsigned BlockID = Stream.ReadSubBlockID(); 2172 2173 // We only know the AST subblock ID. 2174 switch (BlockID) { 2175 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2176 if (Stream.ReadBlockInfoBlock()) { 2177 Error("malformed BlockInfoBlock in AST file"); 2178 return Failure; 2179 } 2180 break; 2181 case AST_BLOCK_ID: 2182 switch (ReadASTBlock(F)) { 2183 case Success: 2184 break; 2185 2186 case Failure: 2187 return Failure; 2188 2189 case IgnorePCH: 2190 // FIXME: We could consider reading through to the end of this 2191 // AST block, skipping subblocks, to see if there are other 2192 // AST blocks elsewhere. 2193 2194 // Clear out any preallocated source location entries, so that 2195 // the source manager does not try to resolve them later. 2196 SourceMgr.ClearPreallocatedSLocEntries(); 2197 2198 // Remove the stat cache. 2199 if (F.StatCache) 2200 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2201 2202 return IgnorePCH; 2203 } 2204 break; 2205 default: 2206 if (Stream.SkipBlock()) { 2207 Error("malformed block record in AST file"); 2208 return Failure; 2209 } 2210 break; 2211 } 2212 } 2213 2214 return Success; 2215} 2216 2217void ASTReader::setPreprocessor(Preprocessor &pp) { 2218 PP = &pp; 2219 2220 unsigned TotalNum = 0; 2221 for (unsigned I = 0, N = Chain.size(); I != N; ++I) 2222 TotalNum += Chain[I]->NumPreallocatedPreprocessingEntities; 2223 if (TotalNum) { 2224 if (!PP->getPreprocessingRecord()) 2225 PP->createPreprocessingRecord(); 2226 PP->getPreprocessingRecord()->SetExternalSource(*this, TotalNum); 2227 } 2228} 2229 2230void ASTReader::InitializeContext(ASTContext &Ctx) { 2231 Context = &Ctx; 2232 assert(Context && "Passed null context!"); 2233 2234 assert(PP && "Forgot to set Preprocessor ?"); 2235 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2236 PP->getHeaderSearchInfo().SetExternalLookup(this); 2237 PP->setExternalSource(this); 2238 2239 // If we have an update block for the TU waiting, we have to add it before 2240 // deserializing the decl. 2241 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2242 if (DCU != DeclContextOffsets.end()) { 2243 // Insertion could invalidate map, so grab vector. 2244 DeclContextInfos T; 2245 T.swap(DCU->second); 2246 DeclContextOffsets.erase(DCU); 2247 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T); 2248 } 2249 2250 // Load the translation unit declaration 2251 GetTranslationUnitDecl(); 2252 2253 // Load the special types. 2254 Context->setBuiltinVaListType( 2255 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2256 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 2257 Context->setObjCIdType(GetType(Id)); 2258 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 2259 Context->setObjCSelType(GetType(Sel)); 2260 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 2261 Context->setObjCProtoType(GetType(Proto)); 2262 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 2263 Context->setObjCClassType(GetType(Class)); 2264 2265 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 2266 Context->setCFConstantStringType(GetType(String)); 2267 if (unsigned FastEnum 2268 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 2269 Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 2270 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2271 QualType FileType = GetType(File); 2272 if (FileType.isNull()) { 2273 Error("FILE type is NULL"); 2274 return; 2275 } 2276 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2277 Context->setFILEDecl(Typedef->getDecl()); 2278 else { 2279 const TagType *Tag = FileType->getAs<TagType>(); 2280 if (!Tag) { 2281 Error("Invalid FILE type in AST file"); 2282 return; 2283 } 2284 Context->setFILEDecl(Tag->getDecl()); 2285 } 2286 } 2287 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2288 QualType Jmp_bufType = GetType(Jmp_buf); 2289 if (Jmp_bufType.isNull()) { 2290 Error("jmp_bug type is NULL"); 2291 return; 2292 } 2293 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2294 Context->setjmp_bufDecl(Typedef->getDecl()); 2295 else { 2296 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2297 if (!Tag) { 2298 Error("Invalid jmp_buf type in AST file"); 2299 return; 2300 } 2301 Context->setjmp_bufDecl(Tag->getDecl()); 2302 } 2303 } 2304 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2305 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2306 if (Sigjmp_bufType.isNull()) { 2307 Error("sigjmp_buf type is NULL"); 2308 return; 2309 } 2310 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2311 Context->setsigjmp_bufDecl(Typedef->getDecl()); 2312 else { 2313 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2314 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2315 Context->setsigjmp_bufDecl(Tag->getDecl()); 2316 } 2317 } 2318 if (unsigned ObjCIdRedef 2319 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 2320 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2321 if (unsigned ObjCClassRedef 2322 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 2323 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2324 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 2325 Context->setBlockDescriptorType(GetType(String)); 2326 if (unsigned String 2327 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 2328 Context->setBlockDescriptorExtendedType(GetType(String)); 2329 if (unsigned ObjCSelRedef 2330 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 2331 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2332 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 2333 Context->setNSConstantStringType(GetType(String)); 2334 2335 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 2336 Context->setInt128Installed(); 2337} 2338 2339/// \brief Retrieve the name of the original source file name 2340/// directly from the AST file, without actually loading the AST 2341/// file. 2342std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2343 Diagnostic &Diags) { 2344 // Open the AST file. 2345 std::string ErrStr; 2346 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2347 Buffer.reset(llvm::MemoryBuffer::getFile(ASTFileName.c_str(), &ErrStr)); 2348 if (!Buffer) { 2349 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2350 return std::string(); 2351 } 2352 2353 // Initialize the stream 2354 llvm::BitstreamReader StreamFile; 2355 llvm::BitstreamCursor Stream; 2356 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2357 (const unsigned char *)Buffer->getBufferEnd()); 2358 Stream.init(StreamFile); 2359 2360 // Sniff for the signature. 2361 if (Stream.Read(8) != 'C' || 2362 Stream.Read(8) != 'P' || 2363 Stream.Read(8) != 'C' || 2364 Stream.Read(8) != 'H') { 2365 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2366 return std::string(); 2367 } 2368 2369 RecordData Record; 2370 while (!Stream.AtEndOfStream()) { 2371 unsigned Code = Stream.ReadCode(); 2372 2373 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2374 unsigned BlockID = Stream.ReadSubBlockID(); 2375 2376 // We only know the AST subblock ID. 2377 switch (BlockID) { 2378 case AST_BLOCK_ID: 2379 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2380 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2381 return std::string(); 2382 } 2383 break; 2384 2385 default: 2386 if (Stream.SkipBlock()) { 2387 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2388 return std::string(); 2389 } 2390 break; 2391 } 2392 continue; 2393 } 2394 2395 if (Code == llvm::bitc::END_BLOCK) { 2396 if (Stream.ReadBlockEnd()) { 2397 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2398 return std::string(); 2399 } 2400 continue; 2401 } 2402 2403 if (Code == llvm::bitc::DEFINE_ABBREV) { 2404 Stream.ReadAbbrevRecord(); 2405 continue; 2406 } 2407 2408 Record.clear(); 2409 const char *BlobStart = 0; 2410 unsigned BlobLen = 0; 2411 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 2412 == ORIGINAL_FILE_NAME) 2413 return std::string(BlobStart, BlobLen); 2414 } 2415 2416 return std::string(); 2417} 2418 2419/// \brief Parse the record that corresponds to a LangOptions data 2420/// structure. 2421/// 2422/// This routine parses the language options from the AST file and then gives 2423/// them to the AST listener if one is set. 2424/// 2425/// \returns true if the listener deems the file unacceptable, false otherwise. 2426bool ASTReader::ParseLanguageOptions( 2427 const llvm::SmallVectorImpl<uint64_t> &Record) { 2428 if (Listener) { 2429 LangOptions LangOpts; 2430 2431 #define PARSE_LANGOPT(Option) \ 2432 LangOpts.Option = Record[Idx]; \ 2433 ++Idx 2434 2435 unsigned Idx = 0; 2436 PARSE_LANGOPT(Trigraphs); 2437 PARSE_LANGOPT(BCPLComment); 2438 PARSE_LANGOPT(DollarIdents); 2439 PARSE_LANGOPT(AsmPreprocessor); 2440 PARSE_LANGOPT(GNUMode); 2441 PARSE_LANGOPT(GNUKeywords); 2442 PARSE_LANGOPT(ImplicitInt); 2443 PARSE_LANGOPT(Digraphs); 2444 PARSE_LANGOPT(HexFloats); 2445 PARSE_LANGOPT(C99); 2446 PARSE_LANGOPT(Microsoft); 2447 PARSE_LANGOPT(CPlusPlus); 2448 PARSE_LANGOPT(CPlusPlus0x); 2449 PARSE_LANGOPT(CXXOperatorNames); 2450 PARSE_LANGOPT(ObjC1); 2451 PARSE_LANGOPT(ObjC2); 2452 PARSE_LANGOPT(ObjCNonFragileABI); 2453 PARSE_LANGOPT(ObjCNonFragileABI2); 2454 PARSE_LANGOPT(NoConstantCFStrings); 2455 PARSE_LANGOPT(PascalStrings); 2456 PARSE_LANGOPT(WritableStrings); 2457 PARSE_LANGOPT(LaxVectorConversions); 2458 PARSE_LANGOPT(AltiVec); 2459 PARSE_LANGOPT(Exceptions); 2460 PARSE_LANGOPT(SjLjExceptions); 2461 PARSE_LANGOPT(NeXTRuntime); 2462 PARSE_LANGOPT(Freestanding); 2463 PARSE_LANGOPT(NoBuiltin); 2464 PARSE_LANGOPT(ThreadsafeStatics); 2465 PARSE_LANGOPT(POSIXThreads); 2466 PARSE_LANGOPT(Blocks); 2467 PARSE_LANGOPT(EmitAllDecls); 2468 PARSE_LANGOPT(MathErrno); 2469 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 2470 Record[Idx++]); 2471 PARSE_LANGOPT(HeinousExtensions); 2472 PARSE_LANGOPT(Optimize); 2473 PARSE_LANGOPT(OptimizeSize); 2474 PARSE_LANGOPT(Static); 2475 PARSE_LANGOPT(PICLevel); 2476 PARSE_LANGOPT(GNUInline); 2477 PARSE_LANGOPT(NoInline); 2478 PARSE_LANGOPT(AccessControl); 2479 PARSE_LANGOPT(CharIsSigned); 2480 PARSE_LANGOPT(ShortWChar); 2481 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 2482 LangOpts.setVisibilityMode((LangOptions::VisibilityMode)Record[Idx++]); 2483 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 2484 Record[Idx++]); 2485 PARSE_LANGOPT(InstantiationDepth); 2486 PARSE_LANGOPT(OpenCL); 2487 PARSE_LANGOPT(CatchUndefined); 2488 // FIXME: Missing ElideConstructors?! 2489 #undef PARSE_LANGOPT 2490 2491 return Listener->ReadLanguageOptions(LangOpts); 2492 } 2493 2494 return false; 2495} 2496 2497void ASTReader::ReadPreprocessedEntities() { 2498 ReadDefinedMacros(); 2499} 2500 2501/// \brief Get the correct cursor and offset for loading a type. 2502ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 2503 PerFileData *F = 0; 2504 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 2505 F = Chain[N - I - 1]; 2506 if (Index < F->LocalNumTypes) 2507 break; 2508 Index -= F->LocalNumTypes; 2509 } 2510 assert(F && F->LocalNumTypes > Index && "Broken chain"); 2511 return RecordLocation(&F->DeclsCursor, F->TypeOffsets[Index]); 2512} 2513 2514/// \brief Read and return the type with the given index.. 2515/// 2516/// The index is the type ID, shifted and minus the number of predefs. This 2517/// routine actually reads the record corresponding to the type at the given 2518/// location. It is a helper routine for GetType, which deals with reading type 2519/// IDs. 2520QualType ASTReader::ReadTypeRecord(unsigned Index) { 2521 RecordLocation Loc = TypeCursorForIndex(Index); 2522 llvm::BitstreamCursor &DeclsCursor = *Loc.first; 2523 2524 // Keep track of where we are in the stream, then jump back there 2525 // after reading this type. 2526 SavedStreamPosition SavedPosition(DeclsCursor); 2527 2528 ReadingKindTracker ReadingKind(Read_Type, *this); 2529 2530 // Note that we are loading a type record. 2531 Deserializing AType(this); 2532 2533 DeclsCursor.JumpToBit(Loc.second); 2534 RecordData Record; 2535 unsigned Code = DeclsCursor.ReadCode(); 2536 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 2537 case TYPE_EXT_QUAL: { 2538 if (Record.size() != 2) { 2539 Error("Incorrect encoding of extended qualifier type"); 2540 return QualType(); 2541 } 2542 QualType Base = GetType(Record[0]); 2543 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]); 2544 return Context->getQualifiedType(Base, Quals); 2545 } 2546 2547 case TYPE_COMPLEX: { 2548 if (Record.size() != 1) { 2549 Error("Incorrect encoding of complex type"); 2550 return QualType(); 2551 } 2552 QualType ElemType = GetType(Record[0]); 2553 return Context->getComplexType(ElemType); 2554 } 2555 2556 case TYPE_POINTER: { 2557 if (Record.size() != 1) { 2558 Error("Incorrect encoding of pointer type"); 2559 return QualType(); 2560 } 2561 QualType PointeeType = GetType(Record[0]); 2562 return Context->getPointerType(PointeeType); 2563 } 2564 2565 case TYPE_BLOCK_POINTER: { 2566 if (Record.size() != 1) { 2567 Error("Incorrect encoding of block pointer type"); 2568 return QualType(); 2569 } 2570 QualType PointeeType = GetType(Record[0]); 2571 return Context->getBlockPointerType(PointeeType); 2572 } 2573 2574 case TYPE_LVALUE_REFERENCE: { 2575 if (Record.size() != 1) { 2576 Error("Incorrect encoding of lvalue reference type"); 2577 return QualType(); 2578 } 2579 QualType PointeeType = GetType(Record[0]); 2580 return Context->getLValueReferenceType(PointeeType); 2581 } 2582 2583 case TYPE_RVALUE_REFERENCE: { 2584 if (Record.size() != 1) { 2585 Error("Incorrect encoding of rvalue reference type"); 2586 return QualType(); 2587 } 2588 QualType PointeeType = GetType(Record[0]); 2589 return Context->getRValueReferenceType(PointeeType); 2590 } 2591 2592 case TYPE_MEMBER_POINTER: { 2593 if (Record.size() != 2) { 2594 Error("Incorrect encoding of member pointer type"); 2595 return QualType(); 2596 } 2597 QualType PointeeType = GetType(Record[0]); 2598 QualType ClassType = GetType(Record[1]); 2599 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 2600 } 2601 2602 case TYPE_CONSTANT_ARRAY: { 2603 QualType ElementType = GetType(Record[0]); 2604 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2605 unsigned IndexTypeQuals = Record[2]; 2606 unsigned Idx = 3; 2607 llvm::APInt Size = ReadAPInt(Record, Idx); 2608 return Context->getConstantArrayType(ElementType, Size, 2609 ASM, IndexTypeQuals); 2610 } 2611 2612 case TYPE_INCOMPLETE_ARRAY: { 2613 QualType ElementType = GetType(Record[0]); 2614 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2615 unsigned IndexTypeQuals = Record[2]; 2616 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 2617 } 2618 2619 case TYPE_VARIABLE_ARRAY: { 2620 QualType ElementType = GetType(Record[0]); 2621 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 2622 unsigned IndexTypeQuals = Record[2]; 2623 SourceLocation LBLoc = SourceLocation::getFromRawEncoding(Record[3]); 2624 SourceLocation RBLoc = SourceLocation::getFromRawEncoding(Record[4]); 2625 return Context->getVariableArrayType(ElementType, ReadExpr(DeclsCursor), 2626 ASM, IndexTypeQuals, 2627 SourceRange(LBLoc, RBLoc)); 2628 } 2629 2630 case TYPE_VECTOR: { 2631 if (Record.size() != 3) { 2632 Error("incorrect encoding of vector type in AST file"); 2633 return QualType(); 2634 } 2635 2636 QualType ElementType = GetType(Record[0]); 2637 unsigned NumElements = Record[1]; 2638 unsigned AltiVecSpec = Record[2]; 2639 return Context->getVectorType(ElementType, NumElements, 2640 (VectorType::AltiVecSpecific)AltiVecSpec); 2641 } 2642 2643 case TYPE_EXT_VECTOR: { 2644 if (Record.size() != 3) { 2645 Error("incorrect encoding of extended vector type in AST file"); 2646 return QualType(); 2647 } 2648 2649 QualType ElementType = GetType(Record[0]); 2650 unsigned NumElements = Record[1]; 2651 return Context->getExtVectorType(ElementType, NumElements); 2652 } 2653 2654 case TYPE_FUNCTION_NO_PROTO: { 2655 if (Record.size() != 4) { 2656 Error("incorrect encoding of no-proto function type"); 2657 return QualType(); 2658 } 2659 QualType ResultType = GetType(Record[0]); 2660 FunctionType::ExtInfo Info(Record[1], Record[2], (CallingConv)Record[3]); 2661 return Context->getFunctionNoProtoType(ResultType, Info); 2662 } 2663 2664 case TYPE_FUNCTION_PROTO: { 2665 QualType ResultType = GetType(Record[0]); 2666 bool NoReturn = Record[1]; 2667 unsigned RegParm = Record[2]; 2668 CallingConv CallConv = (CallingConv)Record[3]; 2669 unsigned Idx = 4; 2670 unsigned NumParams = Record[Idx++]; 2671 llvm::SmallVector<QualType, 16> ParamTypes; 2672 for (unsigned I = 0; I != NumParams; ++I) 2673 ParamTypes.push_back(GetType(Record[Idx++])); 2674 bool isVariadic = Record[Idx++]; 2675 unsigned Quals = Record[Idx++]; 2676 bool hasExceptionSpec = Record[Idx++]; 2677 bool hasAnyExceptionSpec = Record[Idx++]; 2678 unsigned NumExceptions = Record[Idx++]; 2679 llvm::SmallVector<QualType, 2> Exceptions; 2680 for (unsigned I = 0; I != NumExceptions; ++I) 2681 Exceptions.push_back(GetType(Record[Idx++])); 2682 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 2683 isVariadic, Quals, hasExceptionSpec, 2684 hasAnyExceptionSpec, NumExceptions, 2685 Exceptions.data(), 2686 FunctionType::ExtInfo(NoReturn, RegParm, 2687 CallConv)); 2688 } 2689 2690 case TYPE_UNRESOLVED_USING: 2691 return Context->getTypeDeclType( 2692 cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0]))); 2693 2694 case TYPE_TYPEDEF: { 2695 if (Record.size() != 2) { 2696 Error("incorrect encoding of typedef type"); 2697 return QualType(); 2698 } 2699 TypedefDecl *Decl = cast<TypedefDecl>(GetDecl(Record[0])); 2700 QualType Canonical = GetType(Record[1]); 2701 return Context->getTypedefType(Decl, Canonical); 2702 } 2703 2704 case TYPE_TYPEOF_EXPR: 2705 return Context->getTypeOfExprType(ReadExpr(DeclsCursor)); 2706 2707 case TYPE_TYPEOF: { 2708 if (Record.size() != 1) { 2709 Error("incorrect encoding of typeof(type) in AST file"); 2710 return QualType(); 2711 } 2712 QualType UnderlyingType = GetType(Record[0]); 2713 return Context->getTypeOfType(UnderlyingType); 2714 } 2715 2716 case TYPE_DECLTYPE: 2717 return Context->getDecltypeType(ReadExpr(DeclsCursor)); 2718 2719 case TYPE_RECORD: { 2720 if (Record.size() != 2) { 2721 Error("incorrect encoding of record type"); 2722 return QualType(); 2723 } 2724 bool IsDependent = Record[0]; 2725 QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1]))); 2726 T->Dependent = IsDependent; 2727 return T; 2728 } 2729 2730 case TYPE_ENUM: { 2731 if (Record.size() != 2) { 2732 Error("incorrect encoding of enum type"); 2733 return QualType(); 2734 } 2735 bool IsDependent = Record[0]; 2736 QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1]))); 2737 T->Dependent = IsDependent; 2738 return T; 2739 } 2740 2741 case TYPE_ELABORATED: { 2742 unsigned Idx = 0; 2743 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 2744 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2745 QualType NamedType = GetType(Record[Idx++]); 2746 return Context->getElaboratedType(Keyword, NNS, NamedType); 2747 } 2748 2749 case TYPE_OBJC_INTERFACE: { 2750 unsigned Idx = 0; 2751 ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++])); 2752 return Context->getObjCInterfaceType(ItfD); 2753 } 2754 2755 case TYPE_OBJC_OBJECT: { 2756 unsigned Idx = 0; 2757 QualType Base = GetType(Record[Idx++]); 2758 unsigned NumProtos = Record[Idx++]; 2759 llvm::SmallVector<ObjCProtocolDecl*, 4> Protos; 2760 for (unsigned I = 0; I != NumProtos; ++I) 2761 Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++]))); 2762 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 2763 } 2764 2765 case TYPE_OBJC_OBJECT_POINTER: { 2766 unsigned Idx = 0; 2767 QualType Pointee = GetType(Record[Idx++]); 2768 return Context->getObjCObjectPointerType(Pointee); 2769 } 2770 2771 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 2772 unsigned Idx = 0; 2773 QualType Parm = GetType(Record[Idx++]); 2774 QualType Replacement = GetType(Record[Idx++]); 2775 return 2776 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 2777 Replacement); 2778 } 2779 2780 case TYPE_INJECTED_CLASS_NAME: { 2781 CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0])); 2782 QualType TST = GetType(Record[1]); // probably derivable 2783 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 2784 // for AST reading, too much interdependencies. 2785 return 2786 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 2787 } 2788 2789 case TYPE_TEMPLATE_TYPE_PARM: { 2790 unsigned Idx = 0; 2791 unsigned Depth = Record[Idx++]; 2792 unsigned Index = Record[Idx++]; 2793 bool Pack = Record[Idx++]; 2794 IdentifierInfo *Name = GetIdentifierInfo(Record, Idx); 2795 return Context->getTemplateTypeParmType(Depth, Index, Pack, Name); 2796 } 2797 2798 case TYPE_DEPENDENT_NAME: { 2799 unsigned Idx = 0; 2800 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 2801 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2802 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 2803 QualType Canon = GetType(Record[Idx++]); 2804 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 2805 } 2806 2807 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 2808 unsigned Idx = 0; 2809 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 2810 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 2811 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx); 2812 unsigned NumArgs = Record[Idx++]; 2813 llvm::SmallVector<TemplateArgument, 8> Args; 2814 Args.reserve(NumArgs); 2815 while (NumArgs--) 2816 Args.push_back(ReadTemplateArgument(DeclsCursor, Record, Idx)); 2817 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 2818 Args.size(), Args.data()); 2819 } 2820 2821 case TYPE_DEPENDENT_SIZED_ARRAY: { 2822 unsigned Idx = 0; 2823 2824 // ArrayType 2825 QualType ElementType = GetType(Record[Idx++]); 2826 ArrayType::ArraySizeModifier ASM 2827 = (ArrayType::ArraySizeModifier)Record[Idx++]; 2828 unsigned IndexTypeQuals = Record[Idx++]; 2829 2830 // DependentSizedArrayType 2831 Expr *NumElts = ReadExpr(DeclsCursor); 2832 SourceRange Brackets = ReadSourceRange(Record, Idx); 2833 2834 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 2835 IndexTypeQuals, Brackets); 2836 } 2837 2838 case TYPE_TEMPLATE_SPECIALIZATION: { 2839 unsigned Idx = 0; 2840 bool IsDependent = Record[Idx++]; 2841 TemplateName Name = ReadTemplateName(Record, Idx); 2842 llvm::SmallVector<TemplateArgument, 8> Args; 2843 ReadTemplateArgumentList(Args, DeclsCursor, Record, Idx); 2844 QualType Canon = GetType(Record[Idx++]); 2845 QualType T; 2846 if (Canon.isNull()) 2847 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 2848 Args.size()); 2849 else 2850 T = Context->getTemplateSpecializationType(Name, Args.data(), 2851 Args.size(), Canon); 2852 T->Dependent = IsDependent; 2853 return T; 2854 } 2855 } 2856 // Suppress a GCC warning 2857 return QualType(); 2858} 2859 2860namespace { 2861 2862class TypeLocReader : public TypeLocVisitor<TypeLocReader> { 2863 ASTReader &Reader; 2864 llvm::BitstreamCursor &DeclsCursor; 2865 const ASTReader::RecordData &Record; 2866 unsigned &Idx; 2867 2868public: 2869 TypeLocReader(ASTReader &Reader, llvm::BitstreamCursor &Cursor, 2870 const ASTReader::RecordData &Record, unsigned &Idx) 2871 : Reader(Reader), DeclsCursor(Cursor), Record(Record), Idx(Idx) { } 2872 2873 // We want compile-time assurance that we've enumerated all of 2874 // these, so unfortunately we have to declare them first, then 2875 // define them out-of-line. 2876#define ABSTRACT_TYPELOC(CLASS, PARENT) 2877#define TYPELOC(CLASS, PARENT) \ 2878 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 2879#include "clang/AST/TypeLocNodes.def" 2880 2881 void VisitFunctionTypeLoc(FunctionTypeLoc); 2882 void VisitArrayTypeLoc(ArrayTypeLoc); 2883}; 2884 2885} 2886 2887void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 2888 // nothing to do 2889} 2890void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 2891 TL.setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2892 if (TL.needsExtraLocalData()) { 2893 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 2894 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 2895 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 2896 TL.setModeAttr(Record[Idx++]); 2897 } 2898} 2899void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 2900 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2901} 2902void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 2903 TL.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2904} 2905void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 2906 TL.setCaretLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2907} 2908void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 2909 TL.setAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2910} 2911void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 2912 TL.setAmpAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2913} 2914void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 2915 TL.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2916} 2917void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 2918 TL.setLBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2919 TL.setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2920 if (Record[Idx++]) 2921 TL.setSizeExpr(Reader.ReadExpr(DeclsCursor)); 2922 else 2923 TL.setSizeExpr(0); 2924} 2925void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 2926 VisitArrayTypeLoc(TL); 2927} 2928void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 2929 VisitArrayTypeLoc(TL); 2930} 2931void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 2932 VisitArrayTypeLoc(TL); 2933} 2934void TypeLocReader::VisitDependentSizedArrayTypeLoc( 2935 DependentSizedArrayTypeLoc TL) { 2936 VisitArrayTypeLoc(TL); 2937} 2938void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 2939 DependentSizedExtVectorTypeLoc TL) { 2940 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2941} 2942void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 2943 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2944} 2945void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 2946 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2947} 2948void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 2949 TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2950 TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2951 TL.setTrailingReturn(Record[Idx++]); 2952 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2953 TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); 2954 } 2955} 2956void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 2957 VisitFunctionTypeLoc(TL); 2958} 2959void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 2960 VisitFunctionTypeLoc(TL); 2961} 2962void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 2963 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2964} 2965void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 2966 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2967} 2968void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 2969 TL.setTypeofLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2970 TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2971 TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2972} 2973void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 2974 TL.setTypeofLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2975 TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2976 TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2977 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx)); 2978} 2979void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 2980 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2981} 2982void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 2983 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2984} 2985void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 2986 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2987} 2988void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 2989 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2990} 2991void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 2992 SubstTemplateTypeParmTypeLoc TL) { 2993 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2994} 2995void TypeLocReader::VisitTemplateSpecializationTypeLoc( 2996 TemplateSpecializationTypeLoc TL) { 2997 TL.setTemplateNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2998 TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 2999 TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3000 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3001 TL.setArgLocInfo(i, 3002 Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(i).getKind(), 3003 DeclsCursor, Record, Idx)); 3004} 3005void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3006 TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3007 TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx)); 3008} 3009void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3010 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3011} 3012void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3013 TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3014 TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx)); 3015 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3016} 3017void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3018 DependentTemplateSpecializationTypeLoc TL) { 3019 TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3020 TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx)); 3021 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3022 TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3023 TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3024 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3025 TL.setArgLocInfo(I, 3026 Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(), 3027 DeclsCursor, Record, Idx)); 3028} 3029void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3030 TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3031} 3032void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3033 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3034 TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3035 TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3036 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3037 TL.setProtocolLoc(i, SourceLocation::getFromRawEncoding(Record[Idx++])); 3038} 3039void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3040 TL.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); 3041} 3042 3043TypeSourceInfo *ASTReader::GetTypeSourceInfo(llvm::BitstreamCursor &DeclsCursor, 3044 const RecordData &Record, 3045 unsigned &Idx) { 3046 QualType InfoTy = GetType(Record[Idx++]); 3047 if (InfoTy.isNull()) 3048 return 0; 3049 3050 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3051 TypeLocReader TLR(*this, DeclsCursor, Record, Idx); 3052 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3053 TLR.Visit(TL); 3054 return TInfo; 3055} 3056 3057QualType ASTReader::GetType(TypeID ID) { 3058 unsigned FastQuals = ID & Qualifiers::FastMask; 3059 unsigned Index = ID >> Qualifiers::FastWidth; 3060 3061 if (Index < NUM_PREDEF_TYPE_IDS) { 3062 QualType T; 3063 switch ((PredefinedTypeIDs)Index) { 3064 case PREDEF_TYPE_NULL_ID: return QualType(); 3065 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3066 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3067 3068 case PREDEF_TYPE_CHAR_U_ID: 3069 case PREDEF_TYPE_CHAR_S_ID: 3070 // FIXME: Check that the signedness of CharTy is correct! 3071 T = Context->CharTy; 3072 break; 3073 3074 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3075 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3076 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3077 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3078 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3079 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3080 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3081 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3082 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3083 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3084 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3085 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3086 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3087 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3088 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3089 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3090 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3091 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3092 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3093 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3094 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3095 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3096 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3097 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 3098 } 3099 3100 assert(!T.isNull() && "Unknown predefined type"); 3101 return T.withFastQualifiers(FastQuals); 3102 } 3103 3104 Index -= NUM_PREDEF_TYPE_IDS; 3105 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3106 if (TypesLoaded[Index].isNull()) { 3107 TypesLoaded[Index] = ReadTypeRecord(Index); 3108 TypesLoaded[Index]->setFromAST(); 3109 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID); 3110 if (DeserializationListener) 3111 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3112 TypesLoaded[Index]); 3113 } 3114 3115 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3116} 3117 3118TypeID ASTReader::GetTypeID(QualType T) const { 3119 return MakeTypeID(T, 3120 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this)); 3121} 3122 3123TypeIdx ASTReader::GetTypeIdx(QualType T) const { 3124 if (T.isNull()) 3125 return TypeIdx(); 3126 assert(!T.getLocalFastQualifiers()); 3127 3128 TypeIdxMap::const_iterator I = TypeIdxs.find(T); 3129 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and 3130 // comparing keys of ASTDeclContextNameLookupTable. 3131 // If the type didn't come from the AST file use a specially marked index 3132 // so that any hash/key comparison fail since no such index is stored 3133 // in a AST file. 3134 if (I == TypeIdxs.end()) 3135 return TypeIdx(-1); 3136 return I->second; 3137} 3138 3139TemplateArgumentLocInfo 3140ASTReader::GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, 3141 llvm::BitstreamCursor &DeclsCursor, 3142 const RecordData &Record, 3143 unsigned &Index) { 3144 switch (Kind) { 3145 case TemplateArgument::Expression: 3146 return ReadExpr(DeclsCursor); 3147 case TemplateArgument::Type: 3148 return GetTypeSourceInfo(DeclsCursor, Record, Index); 3149 case TemplateArgument::Template: { 3150 SourceRange QualifierRange = ReadSourceRange(Record, Index); 3151 SourceLocation TemplateNameLoc = ReadSourceLocation(Record, Index); 3152 return TemplateArgumentLocInfo(QualifierRange, TemplateNameLoc); 3153 } 3154 case TemplateArgument::Null: 3155 case TemplateArgument::Integral: 3156 case TemplateArgument::Declaration: 3157 case TemplateArgument::Pack: 3158 return TemplateArgumentLocInfo(); 3159 } 3160 llvm_unreachable("unexpected template argument loc"); 3161 return TemplateArgumentLocInfo(); 3162} 3163 3164TemplateArgumentLoc 3165ASTReader::ReadTemplateArgumentLoc(llvm::BitstreamCursor &DeclsCursor, 3166 const RecordData &Record, unsigned &Index) { 3167 TemplateArgument Arg = ReadTemplateArgument(DeclsCursor, Record, Index); 3168 3169 if (Arg.getKind() == TemplateArgument::Expression) { 3170 if (Record[Index++]) // bool InfoHasSameExpr. 3171 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3172 } 3173 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(Arg.getKind(), 3174 DeclsCursor, 3175 Record, Index)); 3176} 3177 3178Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3179 return GetDecl(ID); 3180} 3181 3182TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 3183 if (!DeclsLoaded[0]) { 3184 ReadDeclRecord(0, 1); 3185 if (DeserializationListener) 3186 DeserializationListener->DeclRead(1, DeclsLoaded[0]); 3187 } 3188 3189 return cast<TranslationUnitDecl>(DeclsLoaded[0]); 3190} 3191 3192Decl *ASTReader::GetDecl(DeclID ID) { 3193 if (ID == 0) 3194 return 0; 3195 3196 if (ID > DeclsLoaded.size()) { 3197 Error("declaration ID out-of-range for AST file"); 3198 return 0; 3199 } 3200 3201 unsigned Index = ID - 1; 3202 if (!DeclsLoaded[Index]) { 3203 ReadDeclRecord(Index, ID); 3204 if (DeserializationListener) 3205 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 3206 } 3207 3208 return DeclsLoaded[Index]; 3209} 3210 3211/// \brief Resolve the offset of a statement into a statement. 3212/// 3213/// This operation will read a new statement from the external 3214/// source each time it is called, and is meant to be used via a 3215/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 3216Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 3217 // Offset here is a global offset across the entire chain. 3218 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3219 PerFileData &F = *Chain[N - I - 1]; 3220 if (Offset < F.SizeInBits) { 3221 // Since we know that this statement is part of a decl, make sure to use 3222 // the decl cursor to read it. 3223 F.DeclsCursor.JumpToBit(Offset); 3224 return ReadStmtFromStream(F.DeclsCursor); 3225 } 3226 Offset -= F.SizeInBits; 3227 } 3228 llvm_unreachable("Broken chain"); 3229} 3230 3231bool ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 3232 llvm::SmallVectorImpl<Decl*> &Decls) { 3233 assert(DC->hasExternalLexicalStorage() && 3234 "DeclContext has no lexical decls in storage"); 3235 3236 // There might be lexical decls in multiple parts of the chain, for the TU 3237 // at least. 3238 // DeclContextOffsets might reallocate as we load additional decls below, 3239 // so make a copy of the vector. 3240 DeclContextInfos Infos = DeclContextOffsets[DC]; 3241 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3242 I != E; ++I) { 3243 // IDs can be 0 if this context doesn't contain declarations. 3244 if (!I->LexicalDecls) 3245 continue; 3246 3247 // Load all of the declaration IDs 3248 for (const DeclID *ID = I->LexicalDecls, *IDE = ID + I->NumLexicalDecls; 3249 ID != IDE; ++ID) { 3250 Decl *D = GetDecl(*ID); 3251 assert(D && "Null decl in lexical decls"); 3252 Decls.push_back(D); 3253 } 3254 } 3255 3256 ++NumLexicalDeclContextsRead; 3257 return false; 3258} 3259 3260DeclContext::lookup_result 3261ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 3262 DeclarationName Name) { 3263 assert(DC->hasExternalVisibleStorage() && 3264 "DeclContext has no visible decls in storage"); 3265 if (!Name) 3266 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 3267 DeclContext::lookup_iterator(0)); 3268 3269 llvm::SmallVector<NamedDecl *, 64> Decls; 3270 // There might be visible decls in multiple parts of the chain, for the TU 3271 // and namespaces. For any given name, the last available results replace 3272 // all earlier ones. For this reason, we walk in reverse. 3273 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3274 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 3275 I != E; ++I) { 3276 if (!I->NameLookupTableData) 3277 continue; 3278 3279 ASTDeclContextNameLookupTable *LookupTable = 3280 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3281 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 3282 if (Pos == LookupTable->end()) 3283 continue; 3284 3285 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 3286 for (; Data.first != Data.second; ++Data.first) 3287 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3288 break; 3289 } 3290 3291 ++NumVisibleDeclContextsRead; 3292 3293 SetExternalVisibleDeclsForName(DC, Name, Decls); 3294 return const_cast<DeclContext*>(DC)->lookup(Name); 3295} 3296 3297void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 3298 assert(DC->hasExternalVisibleStorage() && 3299 "DeclContext has no visible decls in storage"); 3300 3301 llvm::SmallVector<NamedDecl *, 64> Decls; 3302 // There might be visible decls in multiple parts of the chain, for the TU 3303 // and namespaces. 3304 DeclContextInfos &Infos = DeclContextOffsets[DC]; 3305 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 3306 I != E; ++I) { 3307 if (!I->NameLookupTableData) 3308 continue; 3309 3310 ASTDeclContextNameLookupTable *LookupTable = 3311 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 3312 for (ASTDeclContextNameLookupTable::item_iterator 3313 ItemI = LookupTable->item_begin(), 3314 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 3315 ASTDeclContextNameLookupTable::item_iterator::value_type Val 3316 = *ItemI; 3317 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 3318 Decls.clear(); 3319 for (; Data.first != Data.second; ++Data.first) 3320 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first))); 3321 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 3322 } 3323 } 3324} 3325 3326void ASTReader::PassInterestingDeclsToConsumer() { 3327 assert(Consumer); 3328 while (!InterestingDecls.empty()) { 3329 DeclGroupRef DG(InterestingDecls.front()); 3330 InterestingDecls.pop_front(); 3331 Consumer->HandleInterestingDecl(DG); 3332 } 3333} 3334 3335void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 3336 this->Consumer = Consumer; 3337 3338 if (!Consumer) 3339 return; 3340 3341 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 3342 // Force deserialization of this decl, which will cause it to be queued for 3343 // passing to the consumer. 3344 GetDecl(ExternalDefinitions[I]); 3345 } 3346 3347 PassInterestingDeclsToConsumer(); 3348} 3349 3350void ASTReader::PrintStats() { 3351 std::fprintf(stderr, "*** AST File Statistics:\n"); 3352 3353 unsigned NumTypesLoaded 3354 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 3355 QualType()); 3356 unsigned NumDeclsLoaded 3357 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 3358 (Decl *)0); 3359 unsigned NumIdentifiersLoaded 3360 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 3361 IdentifiersLoaded.end(), 3362 (IdentifierInfo *)0); 3363 unsigned NumSelectorsLoaded 3364 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 3365 SelectorsLoaded.end(), 3366 Selector()); 3367 3368 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 3369 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 3370 if (TotalNumSLocEntries) 3371 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 3372 NumSLocEntriesRead, TotalNumSLocEntries, 3373 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 3374 if (!TypesLoaded.empty()) 3375 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 3376 NumTypesLoaded, (unsigned)TypesLoaded.size(), 3377 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 3378 if (!DeclsLoaded.empty()) 3379 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 3380 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 3381 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 3382 if (!IdentifiersLoaded.empty()) 3383 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 3384 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 3385 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 3386 if (!SelectorsLoaded.empty()) 3387 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 3388 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 3389 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 3390 if (TotalNumStatements) 3391 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 3392 NumStatementsRead, TotalNumStatements, 3393 ((float)NumStatementsRead/TotalNumStatements * 100)); 3394 if (TotalNumMacros) 3395 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 3396 NumMacrosRead, TotalNumMacros, 3397 ((float)NumMacrosRead/TotalNumMacros * 100)); 3398 if (TotalLexicalDeclContexts) 3399 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 3400 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 3401 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 3402 * 100)); 3403 if (TotalVisibleDeclContexts) 3404 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 3405 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 3406 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 3407 * 100)); 3408 if (TotalNumMethodPoolEntries) { 3409 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 3410 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 3411 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 3412 * 100)); 3413 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 3414 } 3415 std::fprintf(stderr, "\n"); 3416} 3417 3418void ASTReader::InitializeSema(Sema &S) { 3419 SemaObj = &S; 3420 S.ExternalSource = this; 3421 3422 // Makes sure any declarations that were deserialized "too early" 3423 // still get added to the identifier's declaration chains. 3424 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 3425 if (SemaObj->TUScope) 3426 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 3427 3428 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 3429 } 3430 PreloadedDecls.clear(); 3431 3432 // If there were any tentative definitions, deserialize them and add 3433 // them to Sema's list of tentative definitions. 3434 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 3435 VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I])); 3436 SemaObj->TentativeDefinitions.push_back(Var); 3437 } 3438 3439 // If there were any unused file scoped decls, deserialize them and add to 3440 // Sema's list of unused file scoped decls. 3441 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 3442 DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 3443 SemaObj->UnusedFileScopedDecls.push_back(D); 3444 } 3445 3446 // If there were any weak undeclared identifiers, deserialize them and add to 3447 // Sema's list of weak undeclared identifiers. 3448 if (!WeakUndeclaredIdentifiers.empty()) { 3449 unsigned Idx = 0; 3450 for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) { 3451 IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 3452 IdentifierInfo *AliasId=GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx); 3453 SourceLocation Loc = ReadSourceLocation(WeakUndeclaredIdentifiers, Idx); 3454 bool Used = WeakUndeclaredIdentifiers[Idx++]; 3455 Sema::WeakInfo WI(AliasId, Loc); 3456 WI.setUsed(Used); 3457 SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI)); 3458 } 3459 } 3460 3461 // If there were any locally-scoped external declarations, 3462 // deserialize them and add them to Sema's table of locally-scoped 3463 // external declarations. 3464 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 3465 NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 3466 SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D; 3467 } 3468 3469 // If there were any ext_vector type declarations, deserialize them 3470 // and add them to Sema's vector of such declarations. 3471 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) 3472 SemaObj->ExtVectorDecls.push_back( 3473 cast<TypedefDecl>(GetDecl(ExtVectorDecls[I]))); 3474 3475 // FIXME: Do VTable uses and dynamic classes deserialize too much ? 3476 // Can we cut them down before writing them ? 3477 3478 // If there were any VTable uses, deserialize the information and add it 3479 // to Sema's vector and map of VTable uses. 3480 if (!VTableUses.empty()) { 3481 unsigned Idx = 0; 3482 for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) { 3483 CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 3484 SourceLocation Loc = ReadSourceLocation(VTableUses, Idx); 3485 bool DefinitionRequired = VTableUses[Idx++]; 3486 SemaObj->VTableUses.push_back(std::make_pair(Class, Loc)); 3487 SemaObj->VTablesUsed[Class] = DefinitionRequired; 3488 } 3489 } 3490 3491 // If there were any dynamic classes declarations, deserialize them 3492 // and add them to Sema's vector of such declarations. 3493 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) 3494 SemaObj->DynamicClasses.push_back( 3495 cast<CXXRecordDecl>(GetDecl(DynamicClasses[I]))); 3496 3497 // If there were any pending implicit instantiations, deserialize them 3498 // and add them to Sema's queue of such instantiations. 3499 assert(PendingInstantiations.size() % 2 == 0 && "Expected pairs of entries"); 3500 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 3501 ValueDecl *D=cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 3502 SourceLocation Loc = ReadSourceLocation(PendingInstantiations, Idx); 3503 SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc)); 3504 } 3505 3506 // Load the offsets of the declarations that Sema references. 3507 // They will be lazily deserialized when needed. 3508 if (!SemaDeclRefs.empty()) { 3509 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 3510 SemaObj->StdNamespace = SemaDeclRefs[0]; 3511 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 3512 } 3513 3514 // If there are @selector references added them to its pool. This is for 3515 // implementation of -Wselector. 3516 if (!ReferencedSelectorsData.empty()) { 3517 unsigned int DataSize = ReferencedSelectorsData.size()-1; 3518 unsigned I = 0; 3519 while (I < DataSize) { 3520 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 3521 SourceLocation SelLoc = 3522 SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 3523 SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc)); 3524 } 3525 } 3526} 3527 3528IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 3529 // Try to find this name within our on-disk hash tables. We start with the 3530 // most recent one, since that one contains the most up-to-date info. 3531 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3532 ASTIdentifierLookupTable *IdTable 3533 = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable; 3534 if (!IdTable) 3535 continue; 3536 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 3537 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 3538 if (Pos == IdTable->end()) 3539 continue; 3540 3541 // Dereferencing the iterator has the effect of building the 3542 // IdentifierInfo node and populating it with the various 3543 // declarations it needs. 3544 return *Pos; 3545 } 3546 return 0; 3547} 3548 3549std::pair<ObjCMethodList, ObjCMethodList> 3550ASTReader::ReadMethodPool(Selector Sel) { 3551 // Find this selector in a hash table. We want to find the most recent entry. 3552 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3553 PerFileData &F = *Chain[I]; 3554 if (!F.SelectorLookupTable) 3555 continue; 3556 3557 ASTSelectorLookupTable *PoolTable 3558 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 3559 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 3560 if (Pos != PoolTable->end()) { 3561 ++NumSelectorsRead; 3562 // FIXME: Not quite happy with the statistics here. We probably should 3563 // disable this tracking when called via LoadSelector. 3564 // Also, should entries without methods count as misses? 3565 ++NumMethodPoolEntriesRead; 3566 ASTSelectorLookupTrait::data_type Data = *Pos; 3567 if (DeserializationListener) 3568 DeserializationListener->SelectorRead(Data.ID, Sel); 3569 return std::make_pair(Data.Instance, Data.Factory); 3570 } 3571 } 3572 3573 ++NumMethodPoolMisses; 3574 return std::pair<ObjCMethodList, ObjCMethodList>(); 3575} 3576 3577void ASTReader::LoadSelector(Selector Sel) { 3578 // It would be complicated to avoid reading the methods anyway. So don't. 3579 ReadMethodPool(Sel); 3580} 3581 3582void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { 3583 assert(ID && "Non-zero identifier ID required"); 3584 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 3585 IdentifiersLoaded[ID - 1] = II; 3586 if (DeserializationListener) 3587 DeserializationListener->IdentifierRead(ID, II); 3588} 3589 3590/// \brief Set the globally-visible declarations associated with the given 3591/// identifier. 3592/// 3593/// If the AST reader is currently in a state where the given declaration IDs 3594/// cannot safely be resolved, they are queued until it is safe to resolve 3595/// them. 3596/// 3597/// \param II an IdentifierInfo that refers to one or more globally-visible 3598/// declarations. 3599/// 3600/// \param DeclIDs the set of declaration IDs with the name @p II that are 3601/// visible at global scope. 3602/// 3603/// \param Nonrecursive should be true to indicate that the caller knows that 3604/// this call is non-recursive, and therefore the globally-visible declarations 3605/// will not be placed onto the pending queue. 3606void 3607ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 3608 const llvm::SmallVectorImpl<uint32_t> &DeclIDs, 3609 bool Nonrecursive) { 3610 if (NumCurrentElementsDeserializing && !Nonrecursive) { 3611 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 3612 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 3613 PII.II = II; 3614 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 3615 return; 3616 } 3617 3618 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 3619 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 3620 if (SemaObj) { 3621 if (SemaObj->TUScope) { 3622 // Introduce this declaration into the translation-unit scope 3623 // and add it to the declaration chain for this identifier, so 3624 // that (unqualified) name lookup will find it. 3625 SemaObj->TUScope->AddDecl(D); 3626 } 3627 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 3628 } else { 3629 // Queue this declaration so that it will be added to the 3630 // translation unit scope and identifier's declaration chain 3631 // once a Sema object is known. 3632 PreloadedDecls.push_back(D); 3633 } 3634 } 3635} 3636 3637IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) { 3638 if (ID == 0) 3639 return 0; 3640 3641 if (IdentifiersLoaded.empty()) { 3642 Error("no identifier table in AST file"); 3643 return 0; 3644 } 3645 3646 assert(PP && "Forgot to set Preprocessor ?"); 3647 ID -= 1; 3648 if (!IdentifiersLoaded[ID]) { 3649 unsigned Index = ID; 3650 const char *Str = 0; 3651 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3652 PerFileData *F = Chain[N - I - 1]; 3653 if (Index < F->LocalNumIdentifiers) { 3654 uint32_t Offset = F->IdentifierOffsets[Index]; 3655 Str = F->IdentifierTableData + Offset; 3656 break; 3657 } 3658 Index -= F->LocalNumIdentifiers; 3659 } 3660 assert(Str && "Broken Chain"); 3661 3662 // All of the strings in the AST file are preceded by a 16-bit length. 3663 // Extract that 16-bit length to avoid having to execute strlen(). 3664 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 3665 // unsigned integers. This is important to avoid integer overflow when 3666 // we cast them to 'unsigned'. 3667 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 3668 unsigned StrLen = (((unsigned) StrLenPtr[0]) 3669 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 3670 IdentifiersLoaded[ID] 3671 = &PP->getIdentifierTable().get(Str, StrLen); 3672 if (DeserializationListener) 3673 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 3674 } 3675 3676 return IdentifiersLoaded[ID]; 3677} 3678 3679void ASTReader::ReadSLocEntry(unsigned ID) { 3680 ReadSLocEntryRecord(ID); 3681} 3682 3683Selector ASTReader::DecodeSelector(unsigned ID) { 3684 if (ID == 0) 3685 return Selector(); 3686 3687 if (ID > SelectorsLoaded.size()) { 3688 Error("selector ID out of range in AST file"); 3689 return Selector(); 3690 } 3691 3692 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 3693 // Load this selector from the selector table. 3694 unsigned Idx = ID - 1; 3695 for (unsigned I = 0, N = Chain.size(); I != N; ++I) { 3696 PerFileData &F = *Chain[N - I - 1]; 3697 if (Idx < F.LocalNumSelectors) { 3698 ASTSelectorLookupTrait Trait(*this); 3699 SelectorsLoaded[ID - 1] = 3700 Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0); 3701 if (DeserializationListener) 3702 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 3703 break; 3704 } 3705 Idx -= F.LocalNumSelectors; 3706 } 3707 } 3708 3709 return SelectorsLoaded[ID - 1]; 3710} 3711 3712Selector ASTReader::GetExternalSelector(uint32_t ID) { 3713 return DecodeSelector(ID); 3714} 3715 3716uint32_t ASTReader::GetNumExternalSelectors() { 3717 // ID 0 (the null selector) is considered an external selector. 3718 return getTotalNumSelectors() + 1; 3719} 3720 3721DeclarationName 3722ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { 3723 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 3724 switch (Kind) { 3725 case DeclarationName::Identifier: 3726 return DeclarationName(GetIdentifierInfo(Record, Idx)); 3727 3728 case DeclarationName::ObjCZeroArgSelector: 3729 case DeclarationName::ObjCOneArgSelector: 3730 case DeclarationName::ObjCMultiArgSelector: 3731 return DeclarationName(GetSelector(Record, Idx)); 3732 3733 case DeclarationName::CXXConstructorName: 3734 return Context->DeclarationNames.getCXXConstructorName( 3735 Context->getCanonicalType(GetType(Record[Idx++]))); 3736 3737 case DeclarationName::CXXDestructorName: 3738 return Context->DeclarationNames.getCXXDestructorName( 3739 Context->getCanonicalType(GetType(Record[Idx++]))); 3740 3741 case DeclarationName::CXXConversionFunctionName: 3742 return Context->DeclarationNames.getCXXConversionFunctionName( 3743 Context->getCanonicalType(GetType(Record[Idx++]))); 3744 3745 case DeclarationName::CXXOperatorName: 3746 return Context->DeclarationNames.getCXXOperatorName( 3747 (OverloadedOperatorKind)Record[Idx++]); 3748 3749 case DeclarationName::CXXLiteralOperatorName: 3750 return Context->DeclarationNames.getCXXLiteralOperatorName( 3751 GetIdentifierInfo(Record, Idx)); 3752 3753 case DeclarationName::CXXUsingDirective: 3754 return DeclarationName::getUsingDirectiveName(); 3755 } 3756 3757 // Required to silence GCC warning 3758 return DeclarationName(); 3759} 3760 3761TemplateName 3762ASTReader::ReadTemplateName(const RecordData &Record, unsigned &Idx) { 3763 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 3764 switch (Kind) { 3765 case TemplateName::Template: 3766 return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++]))); 3767 3768 case TemplateName::OverloadedTemplate: { 3769 unsigned size = Record[Idx++]; 3770 UnresolvedSet<8> Decls; 3771 while (size--) 3772 Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++]))); 3773 3774 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 3775 } 3776 3777 case TemplateName::QualifiedTemplate: { 3778 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3779 bool hasTemplKeyword = Record[Idx++]; 3780 TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++])); 3781 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 3782 } 3783 3784 case TemplateName::DependentTemplate: { 3785 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx); 3786 if (Record[Idx++]) // isIdentifier 3787 return Context->getDependentTemplateName(NNS, 3788 GetIdentifierInfo(Record, Idx)); 3789 return Context->getDependentTemplateName(NNS, 3790 (OverloadedOperatorKind)Record[Idx++]); 3791 } 3792 } 3793 3794 assert(0 && "Unhandled template name kind!"); 3795 return TemplateName(); 3796} 3797 3798TemplateArgument 3799ASTReader::ReadTemplateArgument(llvm::BitstreamCursor &DeclsCursor, 3800 const RecordData &Record, unsigned &Idx) { 3801 switch ((TemplateArgument::ArgKind)Record[Idx++]) { 3802 case TemplateArgument::Null: 3803 return TemplateArgument(); 3804 case TemplateArgument::Type: 3805 return TemplateArgument(GetType(Record[Idx++])); 3806 case TemplateArgument::Declaration: 3807 return TemplateArgument(GetDecl(Record[Idx++])); 3808 case TemplateArgument::Integral: { 3809 llvm::APSInt Value = ReadAPSInt(Record, Idx); 3810 QualType T = GetType(Record[Idx++]); 3811 return TemplateArgument(Value, T); 3812 } 3813 case TemplateArgument::Template: 3814 return TemplateArgument(ReadTemplateName(Record, Idx)); 3815 case TemplateArgument::Expression: 3816 return TemplateArgument(ReadExpr(DeclsCursor)); 3817 case TemplateArgument::Pack: { 3818 unsigned NumArgs = Record[Idx++]; 3819 llvm::SmallVector<TemplateArgument, 8> Args; 3820 Args.reserve(NumArgs); 3821 while (NumArgs--) 3822 Args.push_back(ReadTemplateArgument(DeclsCursor, Record, Idx)); 3823 TemplateArgument TemplArg; 3824 TemplArg.setArgumentPack(Args.data(), Args.size(), /*CopyArgs=*/true); 3825 return TemplArg; 3826 } 3827 } 3828 3829 assert(0 && "Unhandled template argument kind!"); 3830 return TemplateArgument(); 3831} 3832 3833TemplateParameterList * 3834ASTReader::ReadTemplateParameterList(const RecordData &Record, unsigned &Idx) { 3835 SourceLocation TemplateLoc = ReadSourceLocation(Record, Idx); 3836 SourceLocation LAngleLoc = ReadSourceLocation(Record, Idx); 3837 SourceLocation RAngleLoc = ReadSourceLocation(Record, Idx); 3838 3839 unsigned NumParams = Record[Idx++]; 3840 llvm::SmallVector<NamedDecl *, 16> Params; 3841 Params.reserve(NumParams); 3842 while (NumParams--) 3843 Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++]))); 3844 3845 TemplateParameterList* TemplateParams = 3846 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 3847 Params.data(), Params.size(), RAngleLoc); 3848 return TemplateParams; 3849} 3850 3851void 3852ASTReader:: 3853ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs, 3854 llvm::BitstreamCursor &DeclsCursor, 3855 const RecordData &Record, unsigned &Idx) { 3856 unsigned NumTemplateArgs = Record[Idx++]; 3857 TemplArgs.reserve(NumTemplateArgs); 3858 while (NumTemplateArgs--) 3859 TemplArgs.push_back(ReadTemplateArgument(DeclsCursor, Record, Idx)); 3860} 3861 3862/// \brief Read a UnresolvedSet structure. 3863void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set, 3864 const RecordData &Record, unsigned &Idx) { 3865 unsigned NumDecls = Record[Idx++]; 3866 while (NumDecls--) { 3867 NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++])); 3868 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 3869 Set.addDecl(D, AS); 3870 } 3871} 3872 3873CXXBaseSpecifier 3874ASTReader::ReadCXXBaseSpecifier(llvm::BitstreamCursor &DeclsCursor, 3875 const RecordData &Record, unsigned &Idx) { 3876 bool isVirtual = static_cast<bool>(Record[Idx++]); 3877 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 3878 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 3879 TypeSourceInfo *TInfo = GetTypeSourceInfo(DeclsCursor, Record, Idx); 3880 SourceRange Range = ReadSourceRange(Record, Idx); 3881 return CXXBaseSpecifier(Range, isVirtual, isBaseOfClass, AS, TInfo); 3882} 3883 3884std::pair<CXXBaseOrMemberInitializer **, unsigned> 3885ASTReader::ReadCXXBaseOrMemberInitializers(llvm::BitstreamCursor &Cursor, 3886 const RecordData &Record, 3887 unsigned &Idx) { 3888 CXXBaseOrMemberInitializer **BaseOrMemberInitializers = 0; 3889 unsigned NumInitializers = Record[Idx++]; 3890 if (NumInitializers) { 3891 ASTContext &C = *getContext(); 3892 3893 BaseOrMemberInitializers 3894 = new (C) CXXBaseOrMemberInitializer*[NumInitializers]; 3895 for (unsigned i=0; i != NumInitializers; ++i) { 3896 TypeSourceInfo *BaseClassInfo = 0; 3897 bool IsBaseVirtual = false; 3898 FieldDecl *Member = 0; 3899 3900 bool IsBaseInitializer = Record[Idx++]; 3901 if (IsBaseInitializer) { 3902 BaseClassInfo = GetTypeSourceInfo(Cursor, Record, Idx); 3903 IsBaseVirtual = Record[Idx++]; 3904 } else { 3905 Member = cast<FieldDecl>(GetDecl(Record[Idx++])); 3906 } 3907 SourceLocation MemberLoc = ReadSourceLocation(Record, Idx); 3908 Expr *Init = ReadExpr(Cursor); 3909 FieldDecl *AnonUnionMember 3910 = cast_or_null<FieldDecl>(GetDecl(Record[Idx++])); 3911 SourceLocation LParenLoc = ReadSourceLocation(Record, Idx); 3912 SourceLocation RParenLoc = ReadSourceLocation(Record, Idx); 3913 bool IsWritten = Record[Idx++]; 3914 unsigned SourceOrderOrNumArrayIndices; 3915 llvm::SmallVector<VarDecl *, 8> Indices; 3916 if (IsWritten) { 3917 SourceOrderOrNumArrayIndices = Record[Idx++]; 3918 } else { 3919 SourceOrderOrNumArrayIndices = Record[Idx++]; 3920 Indices.reserve(SourceOrderOrNumArrayIndices); 3921 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 3922 Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++]))); 3923 } 3924 3925 CXXBaseOrMemberInitializer *BOMInit; 3926 if (IsBaseInitializer) { 3927 BOMInit = new (C) CXXBaseOrMemberInitializer(C, BaseClassInfo, 3928 IsBaseVirtual, LParenLoc, 3929 Init, RParenLoc); 3930 } else if (IsWritten) { 3931 BOMInit = new (C) CXXBaseOrMemberInitializer(C, Member, MemberLoc, 3932 LParenLoc, Init, RParenLoc); 3933 } else { 3934 BOMInit = CXXBaseOrMemberInitializer::Create(C, Member, MemberLoc, 3935 LParenLoc, Init, RParenLoc, 3936 Indices.data(), 3937 Indices.size()); 3938 } 3939 3940 if (IsWritten) 3941 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 3942 BOMInit->setAnonUnionMember(AnonUnionMember); 3943 BaseOrMemberInitializers[i] = BOMInit; 3944 } 3945 } 3946 3947 return std::make_pair(BaseOrMemberInitializers, NumInitializers); 3948} 3949 3950NestedNameSpecifier * 3951ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) { 3952 unsigned N = Record[Idx++]; 3953 NestedNameSpecifier *NNS = 0, *Prev = 0; 3954 for (unsigned I = 0; I != N; ++I) { 3955 NestedNameSpecifier::SpecifierKind Kind 3956 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 3957 switch (Kind) { 3958 case NestedNameSpecifier::Identifier: { 3959 IdentifierInfo *II = GetIdentifierInfo(Record, Idx); 3960 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 3961 break; 3962 } 3963 3964 case NestedNameSpecifier::Namespace: { 3965 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++])); 3966 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 3967 break; 3968 } 3969 3970 case NestedNameSpecifier::TypeSpec: 3971 case NestedNameSpecifier::TypeSpecWithTemplate: { 3972 Type *T = GetType(Record[Idx++]).getTypePtr(); 3973 bool Template = Record[Idx++]; 3974 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 3975 break; 3976 } 3977 3978 case NestedNameSpecifier::Global: { 3979 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 3980 // No associated value, and there can't be a prefix. 3981 break; 3982 } 3983 } 3984 Prev = NNS; 3985 } 3986 return NNS; 3987} 3988 3989SourceRange 3990ASTReader::ReadSourceRange(const RecordData &Record, unsigned &Idx) { 3991 SourceLocation beg = SourceLocation::getFromRawEncoding(Record[Idx++]); 3992 SourceLocation end = SourceLocation::getFromRawEncoding(Record[Idx++]); 3993 return SourceRange(beg, end); 3994} 3995 3996/// \brief Read an integral value 3997llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 3998 unsigned BitWidth = Record[Idx++]; 3999 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 4000 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 4001 Idx += NumWords; 4002 return Result; 4003} 4004 4005/// \brief Read a signed integral value 4006llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 4007 bool isUnsigned = Record[Idx++]; 4008 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 4009} 4010 4011/// \brief Read a floating-point value 4012llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 4013 return llvm::APFloat(ReadAPInt(Record, Idx)); 4014} 4015 4016// \brief Read a string 4017std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 4018 unsigned Len = Record[Idx++]; 4019 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 4020 Idx += Len; 4021 return Result; 4022} 4023 4024CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record, 4025 unsigned &Idx) { 4026 CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++])); 4027 return CXXTemporary::Create(*Context, Decl); 4028} 4029 4030DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 4031 return Diag(SourceLocation(), DiagID); 4032} 4033 4034DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 4035 return Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID); 4036} 4037 4038/// \brief Retrieve the identifier table associated with the 4039/// preprocessor. 4040IdentifierTable &ASTReader::getIdentifierTable() { 4041 assert(PP && "Forgot to set Preprocessor ?"); 4042 return PP->getIdentifierTable(); 4043} 4044 4045/// \brief Record that the given ID maps to the given switch-case 4046/// statement. 4047void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 4048 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 4049 SwitchCaseStmts[ID] = SC; 4050} 4051 4052/// \brief Retrieve the switch-case statement with the given ID. 4053SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 4054 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 4055 return SwitchCaseStmts[ID]; 4056} 4057 4058/// \brief Record that the given label statement has been 4059/// deserialized and has the given ID. 4060void ASTReader::RecordLabelStmt(LabelStmt *S, unsigned ID) { 4061 assert(LabelStmts.find(ID) == LabelStmts.end() && 4062 "Deserialized label twice"); 4063 LabelStmts[ID] = S; 4064 4065 // If we've already seen any goto statements that point to this 4066 // label, resolve them now. 4067 typedef std::multimap<unsigned, GotoStmt *>::iterator GotoIter; 4068 std::pair<GotoIter, GotoIter> Gotos = UnresolvedGotoStmts.equal_range(ID); 4069 for (GotoIter Goto = Gotos.first; Goto != Gotos.second; ++Goto) 4070 Goto->second->setLabel(S); 4071 UnresolvedGotoStmts.erase(Gotos.first, Gotos.second); 4072 4073 // If we've already seen any address-label statements that point to 4074 // this label, resolve them now. 4075 typedef std::multimap<unsigned, AddrLabelExpr *>::iterator AddrLabelIter; 4076 std::pair<AddrLabelIter, AddrLabelIter> AddrLabels 4077 = UnresolvedAddrLabelExprs.equal_range(ID); 4078 for (AddrLabelIter AddrLabel = AddrLabels.first; 4079 AddrLabel != AddrLabels.second; ++AddrLabel) 4080 AddrLabel->second->setLabel(S); 4081 UnresolvedAddrLabelExprs.erase(AddrLabels.first, AddrLabels.second); 4082} 4083 4084/// \brief Set the label of the given statement to the label 4085/// identified by ID. 4086/// 4087/// Depending on the order in which the label and other statements 4088/// referencing that label occur, this operation may complete 4089/// immediately (updating the statement) or it may queue the 4090/// statement to be back-patched later. 4091void ASTReader::SetLabelOf(GotoStmt *S, unsigned ID) { 4092 std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID); 4093 if (Label != LabelStmts.end()) { 4094 // We've already seen this label, so set the label of the goto and 4095 // we're done. 4096 S->setLabel(Label->second); 4097 } else { 4098 // We haven't seen this label yet, so add this goto to the set of 4099 // unresolved goto statements. 4100 UnresolvedGotoStmts.insert(std::make_pair(ID, S)); 4101 } 4102} 4103 4104/// \brief Set the label of the given expression to the label 4105/// identified by ID. 4106/// 4107/// Depending on the order in which the label and other statements 4108/// referencing that label occur, this operation may complete 4109/// immediately (updating the statement) or it may queue the 4110/// statement to be back-patched later. 4111void ASTReader::SetLabelOf(AddrLabelExpr *S, unsigned ID) { 4112 std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID); 4113 if (Label != LabelStmts.end()) { 4114 // We've already seen this label, so set the label of the 4115 // label-address expression and we're done. 4116 S->setLabel(Label->second); 4117 } else { 4118 // We haven't seen this label yet, so add this label-address 4119 // expression to the set of unresolved label-address expressions. 4120 UnresolvedAddrLabelExprs.insert(std::make_pair(ID, S)); 4121 } 4122} 4123 4124void ASTReader::FinishedDeserializing() { 4125 assert(NumCurrentElementsDeserializing && 4126 "FinishedDeserializing not paired with StartedDeserializing"); 4127 if (NumCurrentElementsDeserializing == 1) { 4128 // If any identifiers with corresponding top-level declarations have 4129 // been loaded, load those declarations now. 4130 while (!PendingIdentifierInfos.empty()) { 4131 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 4132 PendingIdentifierInfos.front().DeclIDs, true); 4133 PendingIdentifierInfos.pop_front(); 4134 } 4135 4136 // We are not in recursive loading, so it's safe to pass the "interesting" 4137 // decls to the consumer. 4138 if (Consumer) 4139 PassInterestingDeclsToConsumer(); 4140 } 4141 --NumCurrentElementsDeserializing; 4142} 4143 4144ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 4145 const char *isysroot, bool DisableValidation) 4146 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 4147 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 4148 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 4149 Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation), 4150 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 4151 TotalNumSLocEntries(0), NextSLocOffset(0), NumStatementsRead(0), 4152 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 4153 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 4154 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4155 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 4156 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 4157 RelocatablePCH = false; 4158} 4159 4160ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 4161 Diagnostic &Diags, const char *isysroot, 4162 bool DisableValidation) 4163 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 4164 Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), 4165 isysroot(isysroot), DisableValidation(DisableValidation), NumStatHits(0), 4166 NumStatMisses(0), NumSLocEntriesRead(0), TotalNumSLocEntries(0), 4167 NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0), 4168 NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0), 4169 NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 4170 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 4171 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 4172 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) { 4173 RelocatablePCH = false; 4174} 4175 4176ASTReader::~ASTReader() { 4177 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 4178 delete Chain[e - i - 1]; 4179 // Delete all visible decl lookup tables 4180 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 4181 E = DeclContextOffsets.end(); 4182 I != E; ++I) { 4183 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 4184 J != F; ++J) { 4185 if (J->NameLookupTableData) 4186 delete static_cast<ASTDeclContextNameLookupTable*>( 4187 J->NameLookupTableData); 4188 } 4189 } 4190 for (DeclContextVisibleUpdatesPending::iterator 4191 I = PendingVisibleUpdates.begin(), 4192 E = PendingVisibleUpdates.end(); 4193 I != E; ++I) { 4194 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 4195 F = I->second.end(); 4196 J != F; ++J) 4197 delete static_cast<ASTDeclContextNameLookupTable*>(*J); 4198 } 4199} 4200 4201ASTReader::PerFileData::PerFileData() 4202 : SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0), LocalSLocSize(0), 4203 LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0), 4204 IdentifierLookupTable(0), LocalNumMacroDefinitions(0), 4205 MacroDefinitionOffsets(0), LocalNumSelectors(0), SelectorOffsets(0), 4206 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 4207 DeclOffsets(0), LocalNumTypes(0), TypeOffsets(0), StatCache(0), 4208 NumPreallocatedPreprocessingEntities(0), NextInSource(0) 4209{} 4210 4211ASTReader::PerFileData::~PerFileData() { 4212 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 4213 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 4214} 4215 4216