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