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