ASTReader.cpp revision d631d0e74d9ad5c13b51250881bf3cee750ecb67
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/NestedNameSpecifier.h" 27#include "clang/AST/Type.h" 28#include "clang/AST/TypeLocVisitor.h" 29#include "clang/Lex/MacroInfo.h" 30#include "clang/Lex/PreprocessingRecord.h" 31#include "clang/Lex/Preprocessor.h" 32#include "clang/Lex/HeaderSearch.h" 33#include "clang/Basic/OnDiskHashTable.h" 34#include "clang/Basic/SourceManager.h" 35#include "clang/Basic/SourceManagerInternals.h" 36#include "clang/Basic/FileManager.h" 37#include "clang/Basic/FileSystemStatCache.h" 38#include "clang/Basic/TargetInfo.h" 39#include "clang/Basic/Version.h" 40#include "clang/Basic/VersionTuple.h" 41#include "llvm/ADT/StringExtras.h" 42#include "llvm/Bitcode/BitstreamReader.h" 43#include "llvm/Support/MemoryBuffer.h" 44#include "llvm/Support/ErrorHandling.h" 45#include "llvm/Support/FileSystem.h" 46#include "llvm/Support/Path.h" 47#include "llvm/Support/system_error.h" 48#include <algorithm> 49#include <iterator> 50#include <cstdio> 51#include <sys/stat.h> 52#include <iostream> 53 54using namespace clang; 55using namespace clang::serialization; 56 57//===----------------------------------------------------------------------===// 58// PCH validator implementation 59//===----------------------------------------------------------------------===// 60 61ASTReaderListener::~ASTReaderListener() {} 62 63bool 64PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 65 const LangOptions &PPLangOpts = PP.getLangOptions(); 66#define PARSE_LANGOPT_BENIGN(Option) 67#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \ 68 if (PPLangOpts.Option != LangOpts.Option) { \ 69 Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \ 70 return true; \ 71 } 72 73 PARSE_LANGOPT_BENIGN(Trigraphs); 74 PARSE_LANGOPT_BENIGN(BCPLComment); 75 PARSE_LANGOPT_BENIGN(DollarIdents); 76 PARSE_LANGOPT_BENIGN(AsmPreprocessor); 77 PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions); 78 PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords); 79 PARSE_LANGOPT_BENIGN(ImplicitInt); 80 PARSE_LANGOPT_BENIGN(Digraphs); 81 PARSE_LANGOPT_BENIGN(HexFloats); 82 PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99); 83 PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x); 84 PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions); 85 PARSE_LANGOPT_BENIGN(MSCVersion); 86 PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus); 87 PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x); 88 PARSE_LANGOPT_BENIGN(CXXOperatorName); 89 PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c); 90 PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2); 91 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi); 92 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2); 93 PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext); 94 PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties, 95 diag::warn_pch_objc_auto_properties); 96 PARSE_LANGOPT_BENIGN(ObjCInferRelatedResultType) 97 PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings, 98 diag::warn_pch_no_constant_cfstrings); 99 PARSE_LANGOPT_BENIGN(PascalStrings); 100 PARSE_LANGOPT_BENIGN(WritableStrings); 101 PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, 102 diag::warn_pch_lax_vector_conversions); 103 PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec); 104 PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions); 105 PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions); 106 PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions); 107 PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions); 108 PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields); 109 PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime); 110 PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding); 111 PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins); 112 PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, 113 diag::warn_pch_thread_safe_statics); 114 PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads); 115 PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks); 116 PARSE_LANGOPT_BENIGN(EmitAllDecls); 117 PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno); 118 PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior()); 119 PARSE_LANGOPT_IMPORTANT(HeinousExtensions, 120 diag::warn_pch_heinous_extensions); 121 // FIXME: Most of the options below are benign if the macro wasn't 122 // used. Unfortunately, this means that a PCH compiled without 123 // optimization can't be used with optimization turned on, even 124 // though the only thing that changes is whether __OPTIMIZE__ was 125 // defined... but if __OPTIMIZE__ never showed up in the header, it 126 // doesn't matter. We could consider making this some special kind 127 // of check. 128 PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize); 129 PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size); 130 PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static); 131 PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level); 132 PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline); 133 PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline); 134 PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated); 135 PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control); 136 PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed); 137 PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar); 138 PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums); 139 if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) { 140 Reader.Diag(diag::warn_pch_gc_mode) 141 << LangOpts.getGCMode() << PPLangOpts.getGCMode(); 142 return true; 143 } 144 PARSE_LANGOPT_BENIGN(getVisibilityMode()); 145 PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(), 146 diag::warn_pch_stack_protector); 147 PARSE_LANGOPT_BENIGN(InstantiationDepth); 148 PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl); 149 PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda); 150 PARSE_LANGOPT_BENIGN(CatchUndefined); 151 PARSE_LANGOPT_BENIGN(DefaultFPContract); 152 PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors); 153 PARSE_LANGOPT_BENIGN(SpellChecking); 154 PARSE_LANGOPT_IMPORTANT(ObjCAutoRefCount, diag::warn_pch_auto_ref_count); 155 PARSE_LANGOPT_BENIGN(ObjCInferRelatedReturnType); 156#undef PARSE_LANGOPT_IMPORTANT 157#undef PARSE_LANGOPT_BENIGN 158 159 return false; 160} 161 162bool PCHValidator::ReadTargetTriple(StringRef Triple) { 163 if (Triple == PP.getTargetInfo().getTriple().str()) 164 return false; 165 166 Reader.Diag(diag::warn_pch_target_triple) 167 << Triple << PP.getTargetInfo().getTriple().str(); 168 return true; 169} 170 171namespace { 172 struct EmptyStringRef { 173 bool operator ()(StringRef r) const { return r.empty(); } 174 }; 175 struct EmptyBlock { 176 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();} 177 }; 178} 179 180static bool EqualConcatenations(SmallVector<StringRef, 2> L, 181 PCHPredefinesBlocks R) { 182 // First, sum up the lengths. 183 unsigned LL = 0, RL = 0; 184 for (unsigned I = 0, N = L.size(); I != N; ++I) { 185 LL += L[I].size(); 186 } 187 for (unsigned I = 0, N = R.size(); I != N; ++I) { 188 RL += R[I].Data.size(); 189 } 190 if (LL != RL) 191 return false; 192 if (LL == 0 && RL == 0) 193 return true; 194 195 // Kick out empty parts, they confuse the algorithm below. 196 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 197 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 198 199 // Do it the hard way. At this point, both vectors must be non-empty. 200 StringRef LR = L[0], RR = R[0].Data; 201 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 202 (void) RN; 203 for (;;) { 204 // Compare the current pieces. 205 if (LR.size() == RR.size()) { 206 // If they're the same length, it's pretty easy. 207 if (LR != RR) 208 return false; 209 // Both pieces are done, advance. 210 ++LI; 211 ++RI; 212 // If either string is done, they're both done, since they're the same 213 // length. 214 if (LI == LN) { 215 assert(RI == RN && "Strings not the same length after all?"); 216 return true; 217 } 218 LR = L[LI]; 219 RR = R[RI].Data; 220 } else if (LR.size() < RR.size()) { 221 // Right piece is longer. 222 if (!RR.startswith(LR)) 223 return false; 224 ++LI; 225 assert(LI != LN && "Strings not the same length after all?"); 226 RR = RR.substr(LR.size()); 227 LR = L[LI]; 228 } else { 229 // Left piece is longer. 230 if (!LR.startswith(RR)) 231 return false; 232 ++RI; 233 assert(RI != RN && "Strings not the same length after all?"); 234 LR = LR.substr(RR.size()); 235 RR = R[RI].Data; 236 } 237 } 238} 239 240static std::pair<FileID, StringRef::size_type> 241FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) { 242 std::pair<FileID, StringRef::size_type> Res; 243 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 244 Res.second = Buffers[I].Data.find(MacroDef); 245 if (Res.second != StringRef::npos) { 246 Res.first = Buffers[I].BufferID; 247 break; 248 } 249 } 250 return Res; 251} 252 253bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 254 StringRef OriginalFileName, 255 std::string &SuggestedPredefines, 256 FileManager &FileMgr) { 257 // We are in the context of an implicit include, so the predefines buffer will 258 // have a #include entry for the PCH file itself (as normalized by the 259 // preprocessor initialization). Find it and skip over it in the checking 260 // below. 261 llvm::SmallString<256> PCHInclude; 262 PCHInclude += "#include \""; 263 PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr); 264 PCHInclude += "\"\n"; 265 std::pair<StringRef,StringRef> Split = 266 StringRef(PP.getPredefines()).split(PCHInclude.str()); 267 StringRef Left = Split.first, Right = Split.second; 268 if (Left == PP.getPredefines()) { 269 Error("Missing PCH include entry!"); 270 return true; 271 } 272 273 // If the concatenation of all the PCH buffers is equal to the adjusted 274 // command line, we're done. 275 SmallVector<StringRef, 2> CommandLine; 276 CommandLine.push_back(Left); 277 CommandLine.push_back(Right); 278 if (EqualConcatenations(CommandLine, Buffers)) 279 return false; 280 281 SourceManager &SourceMgr = PP.getSourceManager(); 282 283 // The predefines buffers are different. Determine what the differences are, 284 // and whether they require us to reject the PCH file. 285 SmallVector<StringRef, 8> PCHLines; 286 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) 287 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 288 289 SmallVector<StringRef, 8> CmdLineLines; 290 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 291 292 // Pick out implicit #includes after the PCH and don't consider them for 293 // validation; we will insert them into SuggestedPredefines so that the 294 // preprocessor includes them. 295 std::string IncludesAfterPCH; 296 SmallVector<StringRef, 8> AfterPCHLines; 297 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 298 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) { 299 if (AfterPCHLines[i].startswith("#include ")) { 300 IncludesAfterPCH += AfterPCHLines[i]; 301 IncludesAfterPCH += '\n'; 302 } else { 303 CmdLineLines.push_back(AfterPCHLines[i]); 304 } 305 } 306 307 // Make sure we add the includes last into SuggestedPredefines before we 308 // exit this function. 309 struct AddIncludesRAII { 310 std::string &SuggestedPredefines; 311 std::string &IncludesAfterPCH; 312 313 AddIncludesRAII(std::string &SuggestedPredefines, 314 std::string &IncludesAfterPCH) 315 : SuggestedPredefines(SuggestedPredefines), 316 IncludesAfterPCH(IncludesAfterPCH) { } 317 ~AddIncludesRAII() { 318 SuggestedPredefines += IncludesAfterPCH; 319 } 320 } AddIncludes(SuggestedPredefines, IncludesAfterPCH); 321 322 // Sort both sets of predefined buffer lines, since we allow some extra 323 // definitions and they may appear at any point in the output. 324 std::sort(CmdLineLines.begin(), CmdLineLines.end()); 325 std::sort(PCHLines.begin(), PCHLines.end()); 326 327 // Determine which predefines that were used to build the PCH file are missing 328 // from the command line. 329 std::vector<StringRef> MissingPredefines; 330 std::set_difference(PCHLines.begin(), PCHLines.end(), 331 CmdLineLines.begin(), CmdLineLines.end(), 332 std::back_inserter(MissingPredefines)); 333 334 bool MissingDefines = false; 335 bool ConflictingDefines = false; 336 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) { 337 StringRef Missing = MissingPredefines[I]; 338 if (Missing.startswith("#include ")) { 339 // An -include was specified when generating the PCH; it is included in 340 // the PCH, just ignore it. 341 continue; 342 } 343 if (!Missing.startswith("#define ")) { 344 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 345 return true; 346 } 347 348 // This is a macro definition. Determine the name of the macro we're 349 // defining. 350 std::string::size_type StartOfMacroName = strlen("#define "); 351 std::string::size_type EndOfMacroName 352 = Missing.find_first_of("( \n\r", StartOfMacroName); 353 assert(EndOfMacroName != std::string::npos && 354 "Couldn't find the end of the macro name"); 355 StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName); 356 357 // Determine whether this macro was given a different definition on the 358 // command line. 359 std::string MacroDefStart = "#define " + MacroName.str(); 360 std::string::size_type MacroDefLen = MacroDefStart.size(); 361 SmallVector<StringRef, 8>::iterator ConflictPos 362 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(), 363 MacroDefStart); 364 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) { 365 if (!ConflictPos->startswith(MacroDefStart)) { 366 // Different macro; we're done. 367 ConflictPos = CmdLineLines.end(); 368 break; 369 } 370 371 assert(ConflictPos->size() > MacroDefLen && 372 "Invalid #define in predefines buffer?"); 373 if ((*ConflictPos)[MacroDefLen] != ' ' && 374 (*ConflictPos)[MacroDefLen] != '(') 375 continue; // Longer macro name; keep trying. 376 377 // We found a conflicting macro definition. 378 break; 379 } 380 381 if (ConflictPos != CmdLineLines.end()) { 382 Reader.Diag(diag::warn_cmdline_conflicting_macro_def) 383 << MacroName; 384 385 // Show the definition of this macro within the PCH file. 386 std::pair<FileID, StringRef::size_type> MacroLoc = 387 FindMacro(Buffers, Missing); 388 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!"); 389 SourceLocation PCHMissingLoc = 390 SourceMgr.getLocForStartOfFile(MacroLoc.first) 391 .getFileLocWithOffset(MacroLoc.second); 392 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName; 393 394 ConflictingDefines = true; 395 continue; 396 } 397 398 // If the macro doesn't conflict, then we'll just pick up the macro 399 // definition from the PCH file. Warn the user that they made a mistake. 400 if (ConflictingDefines) 401 continue; // Don't complain if there are already conflicting defs 402 403 if (!MissingDefines) { 404 Reader.Diag(diag::warn_cmdline_missing_macro_defs); 405 MissingDefines = true; 406 } 407 408 // Show the definition of this macro within the PCH file. 409 std::pair<FileID, StringRef::size_type> MacroLoc = 410 FindMacro(Buffers, Missing); 411 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!"); 412 SourceLocation PCHMissingLoc = 413 SourceMgr.getLocForStartOfFile(MacroLoc.first) 414 .getFileLocWithOffset(MacroLoc.second); 415 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); 416 } 417 418 if (ConflictingDefines) 419 return true; 420 421 // Determine what predefines were introduced based on command-line 422 // parameters that were not present when building the PCH 423 // file. Extra #defines are okay, so long as the identifiers being 424 // defined were not used within the precompiled header. 425 std::vector<StringRef> ExtraPredefines; 426 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), 427 PCHLines.begin(), PCHLines.end(), 428 std::back_inserter(ExtraPredefines)); 429 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { 430 StringRef &Extra = ExtraPredefines[I]; 431 if (!Extra.startswith("#define ")) { 432 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 433 return true; 434 } 435 436 // This is an extra macro definition. Determine the name of the 437 // macro we're defining. 438 std::string::size_type StartOfMacroName = strlen("#define "); 439 std::string::size_type EndOfMacroName 440 = Extra.find_first_of("( \n\r", StartOfMacroName); 441 assert(EndOfMacroName != std::string::npos && 442 "Couldn't find the end of the macro name"); 443 StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName); 444 445 // Check whether this name was used somewhere in the PCH file. If 446 // so, defining it as a macro could change behavior, so we reject 447 // the PCH file. 448 if (IdentifierInfo *II = Reader.get(MacroName)) { 449 Reader.Diag(diag::warn_macro_name_used_in_pch) << II; 450 return true; 451 } 452 453 // Add this definition to the suggested predefines buffer. 454 SuggestedPredefines += Extra; 455 SuggestedPredefines += '\n'; 456 } 457 458 // If we get here, it's because the predefines buffer had compatible 459 // contents. Accept the PCH file. 460 return false; 461} 462 463void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 464 unsigned ID) { 465 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 466 ++NumHeaderInfos; 467} 468 469void PCHValidator::ReadCounter(unsigned Value) { 470 PP.setCounterValue(Value); 471} 472 473//===----------------------------------------------------------------------===// 474// AST reader implementation 475//===----------------------------------------------------------------------===// 476 477void 478ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 479 DeserializationListener = Listener; 480} 481 482 483namespace { 484class ASTSelectorLookupTrait { 485 ASTReader &Reader; 486 Module &F; 487 488public: 489 struct data_type { 490 SelectorID ID; 491 ObjCMethodList Instance, Factory; 492 }; 493 494 typedef Selector external_key_type; 495 typedef external_key_type internal_key_type; 496 497 ASTSelectorLookupTrait(ASTReader &Reader, Module &F) 498 : Reader(Reader), F(F) { } 499 500 static bool EqualKey(const internal_key_type& a, 501 const internal_key_type& b) { 502 return a == b; 503 } 504 505 static unsigned ComputeHash(Selector Sel) { 506 return serialization::ComputeHash(Sel); 507 } 508 509 // This hopefully will just get inlined and removed by the optimizer. 510 static const internal_key_type& 511 GetInternalKey(const external_key_type& x) { return x; } 512 513 static std::pair<unsigned, unsigned> 514 ReadKeyDataLength(const unsigned char*& d) { 515 using namespace clang::io; 516 unsigned KeyLen = ReadUnalignedLE16(d); 517 unsigned DataLen = ReadUnalignedLE16(d); 518 return std::make_pair(KeyLen, DataLen); 519 } 520 521 internal_key_type ReadKey(const unsigned char* d, unsigned) { 522 using namespace clang::io; 523 SelectorTable &SelTable = Reader.getContext()->Selectors; 524 unsigned N = ReadUnalignedLE16(d); 525 IdentifierInfo *FirstII 526 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 527 if (N == 0) 528 return SelTable.getNullarySelector(FirstII); 529 else if (N == 1) 530 return SelTable.getUnarySelector(FirstII); 531 532 SmallVector<IdentifierInfo *, 16> Args; 533 Args.push_back(FirstII); 534 for (unsigned I = 1; I != N; ++I) 535 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d))); 536 537 return SelTable.getSelector(N, Args.data()); 538 } 539 540 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) { 541 using namespace clang::io; 542 543 data_type Result; 544 545 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d)); 546 unsigned NumInstanceMethods = ReadUnalignedLE16(d); 547 unsigned NumFactoryMethods = ReadUnalignedLE16(d); 548 549 // Load instance methods 550 ObjCMethodList *Prev = 0; 551 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 552 ObjCMethodDecl *Method 553 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)); 554 if (!Result.Instance.Method) { 555 // This is the first method, which is the easy case. 556 Result.Instance.Method = Method; 557 Prev = &Result.Instance; 558 continue; 559 } 560 561 ObjCMethodList *Mem = 562 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 563 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 564 Prev = Prev->Next; 565 } 566 567 // Load factory methods 568 Prev = 0; 569 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 570 ObjCMethodDecl *Method 571 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)); 572 if (!Result.Factory.Method) { 573 // This is the first method, which is the easy case. 574 Result.Factory.Method = Method; 575 Prev = &Result.Factory; 576 continue; 577 } 578 579 ObjCMethodList *Mem = 580 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 581 Prev->Next = new (Mem) ObjCMethodList(Method, 0); 582 Prev = Prev->Next; 583 } 584 585 return Result; 586 } 587}; 588 589} // end anonymous namespace 590 591/// \brief The on-disk hash table used for the global method pool. 592typedef OnDiskChainedHashTable<ASTSelectorLookupTrait> 593 ASTSelectorLookupTable; 594 595namespace clang { 596class ASTIdentifierLookupTrait { 597 ASTReader &Reader; 598 Module &F; 599 600 // If we know the IdentifierInfo in advance, it is here and we will 601 // not build a new one. Used when deserializing information about an 602 // identifier that was constructed before the AST file was read. 603 IdentifierInfo *KnownII; 604 605public: 606 typedef IdentifierInfo * data_type; 607 608 typedef const std::pair<const char*, unsigned> external_key_type; 609 610 typedef external_key_type internal_key_type; 611 612 ASTIdentifierLookupTrait(ASTReader &Reader, Module &F, 613 IdentifierInfo *II = 0) 614 : Reader(Reader), F(F), KnownII(II) { } 615 616 static bool EqualKey(const internal_key_type& a, 617 const internal_key_type& b) { 618 return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0 619 : false; 620 } 621 622 static unsigned ComputeHash(const internal_key_type& a) { 623 return llvm::HashString(StringRef(a.first, a.second)); 624 } 625 626 // This hopefully will just get inlined and removed by the optimizer. 627 static const internal_key_type& 628 GetInternalKey(const external_key_type& x) { return x; } 629 630 // This hopefully will just get inlined and removed by the optimizer. 631 static const external_key_type& 632 GetExternalKey(const internal_key_type& x) { return x; } 633 634 static std::pair<unsigned, unsigned> 635 ReadKeyDataLength(const unsigned char*& d) { 636 using namespace clang::io; 637 unsigned DataLen = ReadUnalignedLE16(d); 638 unsigned KeyLen = ReadUnalignedLE16(d); 639 return std::make_pair(KeyLen, DataLen); 640 } 641 642 static std::pair<const char*, unsigned> 643 ReadKey(const unsigned char* d, unsigned n) { 644 assert(n >= 2 && d[n-1] == '\0'); 645 return std::make_pair((const char*) d, n-1); 646 } 647 648 IdentifierInfo *ReadData(const internal_key_type& k, 649 const unsigned char* d, 650 unsigned DataLen) { 651 using namespace clang::io; 652 unsigned RawID = ReadUnalignedLE32(d); 653 bool IsInteresting = RawID & 0x01; 654 655 // Wipe out the "is interesting" bit. 656 RawID = RawID >> 1; 657 658 IdentID ID = Reader.getGlobalIdentifierID(F, RawID); 659 if (!IsInteresting) { 660 // For uninteresting identifiers, just build the IdentifierInfo 661 // and associate it with the persistent ID. 662 IdentifierInfo *II = KnownII; 663 if (!II) 664 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second)); 665 Reader.SetIdentifierInfo(ID, II); 666 II->setIsFromAST(); 667 return II; 668 } 669 670 unsigned Bits = ReadUnalignedLE16(d); 671 bool CPlusPlusOperatorKeyword = Bits & 0x01; 672 Bits >>= 1; 673 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 674 Bits >>= 1; 675 bool Poisoned = Bits & 0x01; 676 Bits >>= 1; 677 bool ExtensionToken = Bits & 0x01; 678 Bits >>= 1; 679 bool hasMacroDefinition = Bits & 0x01; 680 Bits >>= 1; 681 unsigned ObjCOrBuiltinID = Bits & 0x3FF; 682 Bits >>= 10; 683 684 assert(Bits == 0 && "Extra bits in the identifier?"); 685 DataLen -= 6; 686 687 // Build the IdentifierInfo itself and link the identifier ID with 688 // the new IdentifierInfo. 689 IdentifierInfo *II = KnownII; 690 if (!II) 691 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second)); 692 Reader.SetIdentifierInfo(ID, II); 693 694 // Set or check the various bits in the IdentifierInfo structure. 695 // Token IDs are read-only. 696 if (HasRevertedTokenIDToIdentifier) 697 II->RevertTokenIDToIdentifier(); 698 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 699 assert(II->isExtensionToken() == ExtensionToken && 700 "Incorrect extension token flag"); 701 (void)ExtensionToken; 702 II->setIsPoisoned(Poisoned); 703 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 704 "Incorrect C++ operator keyword flag"); 705 (void)CPlusPlusOperatorKeyword; 706 707 // If this identifier is a macro, deserialize the macro 708 // definition. 709 if (hasMacroDefinition) { 710 uint32_t Offset = ReadUnalignedLE32(d); 711 Reader.SetIdentifierIsMacro(II, F, Offset); 712 DataLen -= 4; 713 } 714 715 // Read all of the declarations visible at global scope with this 716 // name. 717 if (Reader.getContext() == 0) return II; 718 if (DataLen > 0) { 719 SmallVector<uint32_t, 4> DeclIDs; 720 for (; DataLen > 0; DataLen -= 4) 721 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d))); 722 Reader.SetGloballyVisibleDecls(II, DeclIDs); 723 } 724 725 II->setIsFromAST(); 726 return II; 727 } 728}; 729 730} // end anonymous namespace 731 732/// \brief The on-disk hash table used to contain information about 733/// all of the identifiers in the program. 734typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait> 735 ASTIdentifierLookupTable; 736 737namespace { 738class ASTDeclContextNameLookupTrait { 739 ASTReader &Reader; 740 Module &F; 741 742public: 743 /// \brief Pair of begin/end iterators for DeclIDs. 744 /// 745 /// Note that these declaration IDs are local to the module that contains this 746 /// particular lookup t 747 typedef std::pair<DeclID *, DeclID *> data_type; 748 749 /// \brief Special internal key for declaration names. 750 /// The hash table creates keys for comparison; we do not create 751 /// a DeclarationName for the internal key to avoid deserializing types. 752 struct DeclNameKey { 753 DeclarationName::NameKind Kind; 754 uint64_t Data; 755 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { } 756 }; 757 758 typedef DeclarationName external_key_type; 759 typedef DeclNameKey internal_key_type; 760 761 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader, 762 Module &F) 763 : Reader(Reader), F(F) { } 764 765 static bool EqualKey(const internal_key_type& a, 766 const internal_key_type& b) { 767 return a.Kind == b.Kind && a.Data == b.Data; 768 } 769 770 unsigned ComputeHash(const DeclNameKey &Key) const { 771 llvm::FoldingSetNodeID ID; 772 ID.AddInteger(Key.Kind); 773 774 switch (Key.Kind) { 775 case DeclarationName::Identifier: 776 case DeclarationName::CXXLiteralOperatorName: 777 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 778 break; 779 case DeclarationName::ObjCZeroArgSelector: 780 case DeclarationName::ObjCOneArgSelector: 781 case DeclarationName::ObjCMultiArgSelector: 782 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 783 break; 784 case DeclarationName::CXXOperatorName: 785 ID.AddInteger((OverloadedOperatorKind)Key.Data); 786 break; 787 case DeclarationName::CXXConstructorName: 788 case DeclarationName::CXXDestructorName: 789 case DeclarationName::CXXConversionFunctionName: 790 case DeclarationName::CXXUsingDirective: 791 break; 792 } 793 794 return ID.ComputeHash(); 795 } 796 797 internal_key_type GetInternalKey(const external_key_type& Name) const { 798 DeclNameKey Key; 799 Key.Kind = Name.getNameKind(); 800 switch (Name.getNameKind()) { 801 case DeclarationName::Identifier: 802 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 803 break; 804 case DeclarationName::ObjCZeroArgSelector: 805 case DeclarationName::ObjCOneArgSelector: 806 case DeclarationName::ObjCMultiArgSelector: 807 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 808 break; 809 case DeclarationName::CXXOperatorName: 810 Key.Data = Name.getCXXOverloadedOperator(); 811 break; 812 case DeclarationName::CXXLiteralOperatorName: 813 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 814 break; 815 case DeclarationName::CXXConstructorName: 816 case DeclarationName::CXXDestructorName: 817 case DeclarationName::CXXConversionFunctionName: 818 case DeclarationName::CXXUsingDirective: 819 Key.Data = 0; 820 break; 821 } 822 823 return Key; 824 } 825 826 external_key_type GetExternalKey(const internal_key_type& Key) const { 827 ASTContext *Context = Reader.getContext(); 828 switch (Key.Kind) { 829 case DeclarationName::Identifier: 830 return DeclarationName((IdentifierInfo*)Key.Data); 831 832 case DeclarationName::ObjCZeroArgSelector: 833 case DeclarationName::ObjCOneArgSelector: 834 case DeclarationName::ObjCMultiArgSelector: 835 return DeclarationName(Selector(Key.Data)); 836 837 case DeclarationName::CXXConstructorName: 838 return Context->DeclarationNames.getCXXConstructorName( 839 Context->getCanonicalType(Reader.getLocalType(F, Key.Data))); 840 841 case DeclarationName::CXXDestructorName: 842 return Context->DeclarationNames.getCXXDestructorName( 843 Context->getCanonicalType(Reader.getLocalType(F, Key.Data))); 844 845 case DeclarationName::CXXConversionFunctionName: 846 return Context->DeclarationNames.getCXXConversionFunctionName( 847 Context->getCanonicalType(Reader.getLocalType(F, Key.Data))); 848 849 case DeclarationName::CXXOperatorName: 850 return Context->DeclarationNames.getCXXOperatorName( 851 (OverloadedOperatorKind)Key.Data); 852 853 case DeclarationName::CXXLiteralOperatorName: 854 return Context->DeclarationNames.getCXXLiteralOperatorName( 855 (IdentifierInfo*)Key.Data); 856 857 case DeclarationName::CXXUsingDirective: 858 return DeclarationName::getUsingDirectiveName(); 859 } 860 861 llvm_unreachable("Invalid Name Kind ?"); 862 } 863 864 static std::pair<unsigned, unsigned> 865 ReadKeyDataLength(const unsigned char*& d) { 866 using namespace clang::io; 867 unsigned KeyLen = ReadUnalignedLE16(d); 868 unsigned DataLen = ReadUnalignedLE16(d); 869 return std::make_pair(KeyLen, DataLen); 870 } 871 872 internal_key_type ReadKey(const unsigned char* d, unsigned) { 873 using namespace clang::io; 874 875 DeclNameKey Key; 876 Key.Kind = (DeclarationName::NameKind)*d++; 877 switch (Key.Kind) { 878 case DeclarationName::Identifier: 879 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 880 break; 881 case DeclarationName::ObjCZeroArgSelector: 882 case DeclarationName::ObjCOneArgSelector: 883 case DeclarationName::ObjCMultiArgSelector: 884 Key.Data = 885 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d)) 886 .getAsOpaquePtr(); 887 break; 888 case DeclarationName::CXXOperatorName: 889 Key.Data = *d++; // OverloadedOperatorKind 890 break; 891 case DeclarationName::CXXLiteralOperatorName: 892 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 893 break; 894 case DeclarationName::CXXConstructorName: 895 case DeclarationName::CXXDestructorName: 896 case DeclarationName::CXXConversionFunctionName: 897 case DeclarationName::CXXUsingDirective: 898 Key.Data = 0; 899 break; 900 } 901 902 return Key; 903 } 904 905 data_type ReadData(internal_key_type, const unsigned char* d, 906 unsigned DataLen) { 907 using namespace clang::io; 908 unsigned NumDecls = ReadUnalignedLE16(d); 909 DeclID *Start = (DeclID *)d; 910 return std::make_pair(Start, Start + NumDecls); 911 } 912}; 913 914} // end anonymous namespace 915 916/// \brief The on-disk hash table used for the DeclContext's Name lookup table. 917typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait> 918 ASTDeclContextNameLookupTable; 919 920bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor, 921 const std::pair<uint64_t, uint64_t> &Offsets, 922 DeclContextInfo &Info) { 923 SavedStreamPosition SavedPosition(Cursor); 924 // First the lexical decls. 925 if (Offsets.first != 0) { 926 Cursor.JumpToBit(Offsets.first); 927 928 RecordData Record; 929 const char *Blob; 930 unsigned BlobLen; 931 unsigned Code = Cursor.ReadCode(); 932 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 933 if (RecCode != DECL_CONTEXT_LEXICAL) { 934 Error("Expected lexical block"); 935 return true; 936 } 937 938 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob); 939 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair); 940 } else { 941 Info.LexicalDecls = 0; 942 Info.NumLexicalDecls = 0; 943 } 944 945 // Now the lookup table. 946 if (Offsets.second != 0) { 947 Cursor.JumpToBit(Offsets.second); 948 949 RecordData Record; 950 const char *Blob; 951 unsigned BlobLen; 952 unsigned Code = Cursor.ReadCode(); 953 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 954 if (RecCode != DECL_CONTEXT_VISIBLE) { 955 Error("Expected visible lookup table block"); 956 return true; 957 } 958 Info.NameLookupTableData 959 = ASTDeclContextNameLookupTable::Create( 960 (const unsigned char *)Blob + Record[0], 961 (const unsigned char *)Blob, 962 ASTDeclContextNameLookupTrait(*this, *Info.F)); 963 } else { 964 Info.NameLookupTableData = 0; 965 } 966 967 return false; 968} 969 970void ASTReader::Error(StringRef Msg) { 971 Error(diag::err_fe_pch_malformed, Msg); 972} 973 974void ASTReader::Error(unsigned DiagID, 975 StringRef Arg1, StringRef Arg2) { 976 if (Diags.isDiagnosticInFlight()) 977 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2); 978 else 979 Diag(DiagID) << Arg1 << Arg2; 980} 981 982/// \brief Tell the AST listener about the predefines buffers in the chain. 983bool ASTReader::CheckPredefinesBuffers() { 984 if (Listener) 985 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers, 986 ActualOriginalFileName, 987 SuggestedPredefines, 988 FileMgr); 989 return false; 990} 991 992//===----------------------------------------------------------------------===// 993// Source Manager Deserialization 994//===----------------------------------------------------------------------===// 995 996/// \brief Read the line table in the source manager block. 997/// \returns true if there was an error. 998bool ASTReader::ParseLineTable(Module &F, 999 SmallVectorImpl<uint64_t> &Record) { 1000 unsigned Idx = 0; 1001 LineTableInfo &LineTable = SourceMgr.getLineTable(); 1002 1003 // Parse the file names 1004 std::map<int, int> FileIDs; 1005 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 1006 // Extract the file name 1007 unsigned FilenameLen = Record[Idx++]; 1008 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 1009 Idx += FilenameLen; 1010 MaybeAddSystemRootToFilename(Filename); 1011 FileIDs[I] = LineTable.getLineTableFilenameID(Filename); 1012 } 1013 1014 // Parse the line entries 1015 std::vector<LineEntry> Entries; 1016 while (Idx < Record.size()) { 1017 int FID = Record[Idx++]; 1018 assert(FID >= 0 && "Serialized line entries for non-local file."); 1019 // Remap FileID from 1-based old view. 1020 FID += F.SLocEntryBaseID - 1; 1021 1022 // Extract the line entries 1023 unsigned NumEntries = Record[Idx++]; 1024 assert(NumEntries && "Numentries is 00000"); 1025 Entries.clear(); 1026 Entries.reserve(NumEntries); 1027 for (unsigned I = 0; I != NumEntries; ++I) { 1028 unsigned FileOffset = Record[Idx++]; 1029 unsigned LineNo = Record[Idx++]; 1030 int FilenameID = FileIDs[Record[Idx++]]; 1031 SrcMgr::CharacteristicKind FileKind 1032 = (SrcMgr::CharacteristicKind)Record[Idx++]; 1033 unsigned IncludeOffset = Record[Idx++]; 1034 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 1035 FileKind, IncludeOffset)); 1036 } 1037 LineTable.AddEntry(FID, Entries); 1038 } 1039 1040 return false; 1041} 1042 1043namespace { 1044 1045class ASTStatData { 1046public: 1047 const ino_t ino; 1048 const dev_t dev; 1049 const mode_t mode; 1050 const time_t mtime; 1051 const off_t size; 1052 1053 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) 1054 : ino(i), dev(d), mode(mo), mtime(m), size(s) {} 1055}; 1056 1057class ASTStatLookupTrait { 1058 public: 1059 typedef const char *external_key_type; 1060 typedef const char *internal_key_type; 1061 1062 typedef ASTStatData data_type; 1063 1064 static unsigned ComputeHash(const char *path) { 1065 return llvm::HashString(path); 1066 } 1067 1068 static internal_key_type GetInternalKey(const char *path) { return path; } 1069 1070 static bool EqualKey(internal_key_type a, internal_key_type b) { 1071 return strcmp(a, b) == 0; 1072 } 1073 1074 static std::pair<unsigned, unsigned> 1075 ReadKeyDataLength(const unsigned char*& d) { 1076 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1077 unsigned DataLen = (unsigned) *d++; 1078 return std::make_pair(KeyLen + 1, DataLen); 1079 } 1080 1081 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1082 return (const char *)d; 1083 } 1084 1085 static data_type ReadData(const internal_key_type, const unsigned char *d, 1086 unsigned /*DataLen*/) { 1087 using namespace clang::io; 1088 1089 ino_t ino = (ino_t) ReadUnalignedLE32(d); 1090 dev_t dev = (dev_t) ReadUnalignedLE32(d); 1091 mode_t mode = (mode_t) ReadUnalignedLE16(d); 1092 time_t mtime = (time_t) ReadUnalignedLE64(d); 1093 off_t size = (off_t) ReadUnalignedLE64(d); 1094 return data_type(ino, dev, mode, mtime, size); 1095 } 1096}; 1097 1098/// \brief stat() cache for precompiled headers. 1099/// 1100/// This cache is very similar to the stat cache used by pretokenized 1101/// headers. 1102class ASTStatCache : public FileSystemStatCache { 1103 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy; 1104 CacheTy *Cache; 1105 1106 unsigned &NumStatHits, &NumStatMisses; 1107public: 1108 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base, 1109 unsigned &NumStatHits, unsigned &NumStatMisses) 1110 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { 1111 Cache = CacheTy::Create(Buckets, Base); 1112 } 1113 1114 ~ASTStatCache() { delete Cache; } 1115 1116 LookupResult getStat(const char *Path, struct stat &StatBuf, 1117 int *FileDescriptor) { 1118 // Do the lookup for the file's data in the AST file. 1119 CacheTy::iterator I = Cache->find(Path); 1120 1121 // If we don't get a hit in the AST file just forward to 'stat'. 1122 if (I == Cache->end()) { 1123 ++NumStatMisses; 1124 return statChained(Path, StatBuf, FileDescriptor); 1125 } 1126 1127 ++NumStatHits; 1128 ASTStatData Data = *I; 1129 1130 StatBuf.st_ino = Data.ino; 1131 StatBuf.st_dev = Data.dev; 1132 StatBuf.st_mtime = Data.mtime; 1133 StatBuf.st_mode = Data.mode; 1134 StatBuf.st_size = Data.size; 1135 return CacheExists; 1136 } 1137}; 1138} // end anonymous namespace 1139 1140 1141/// \brief Read a source manager block 1142ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(Module &F) { 1143 using namespace SrcMgr; 1144 1145 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 1146 1147 // Set the source-location entry cursor to the current position in 1148 // the stream. This cursor will be used to read the contents of the 1149 // source manager block initially, and then lazily read 1150 // source-location entries as needed. 1151 SLocEntryCursor = F.Stream; 1152 1153 // The stream itself is going to skip over the source manager block. 1154 if (F.Stream.SkipBlock()) { 1155 Error("malformed block record in AST file"); 1156 return Failure; 1157 } 1158 1159 // Enter the source manager block. 1160 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 1161 Error("malformed source manager block record in AST file"); 1162 return Failure; 1163 } 1164 1165 RecordData Record; 1166 while (true) { 1167 unsigned Code = SLocEntryCursor.ReadCode(); 1168 if (Code == llvm::bitc::END_BLOCK) { 1169 if (SLocEntryCursor.ReadBlockEnd()) { 1170 Error("error at end of Source Manager block in AST file"); 1171 return Failure; 1172 } 1173 return Success; 1174 } 1175 1176 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1177 // No known subblocks, always skip them. 1178 SLocEntryCursor.ReadSubBlockID(); 1179 if (SLocEntryCursor.SkipBlock()) { 1180 Error("malformed block record in AST file"); 1181 return Failure; 1182 } 1183 continue; 1184 } 1185 1186 if (Code == llvm::bitc::DEFINE_ABBREV) { 1187 SLocEntryCursor.ReadAbbrevRecord(); 1188 continue; 1189 } 1190 1191 // Read a record. 1192 const char *BlobStart; 1193 unsigned BlobLen; 1194 Record.clear(); 1195 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1196 default: // Default behavior: ignore. 1197 break; 1198 1199 case SM_SLOC_FILE_ENTRY: 1200 case SM_SLOC_BUFFER_ENTRY: 1201 case SM_SLOC_EXPANSION_ENTRY: 1202 // Once we hit one of the source location entries, we're done. 1203 return Success; 1204 } 1205 } 1206} 1207 1208/// \brief If a header file is not found at the path that we expect it to be 1209/// and the PCH file was moved from its original location, try to resolve the 1210/// file by assuming that header+PCH were moved together and the header is in 1211/// the same place relative to the PCH. 1212static std::string 1213resolveFileRelativeToOriginalDir(const std::string &Filename, 1214 const std::string &OriginalDir, 1215 const std::string &CurrDir) { 1216 assert(OriginalDir != CurrDir && 1217 "No point trying to resolve the file if the PCH dir didn't change"); 1218 using namespace llvm::sys; 1219 llvm::SmallString<128> filePath(Filename); 1220 fs::make_absolute(filePath); 1221 assert(path::is_absolute(OriginalDir)); 1222 llvm::SmallString<128> currPCHPath(CurrDir); 1223 1224 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 1225 fileDirE = path::end(path::parent_path(filePath)); 1226 path::const_iterator origDirI = path::begin(OriginalDir), 1227 origDirE = path::end(OriginalDir); 1228 // Skip the common path components from filePath and OriginalDir. 1229 while (fileDirI != fileDirE && origDirI != origDirE && 1230 *fileDirI == *origDirI) { 1231 ++fileDirI; 1232 ++origDirI; 1233 } 1234 for (; origDirI != origDirE; ++origDirI) 1235 path::append(currPCHPath, ".."); 1236 path::append(currPCHPath, fileDirI, fileDirE); 1237 path::append(currPCHPath, path::filename(Filename)); 1238 return currPCHPath.str(); 1239} 1240 1241/// \brief Read in the source location entry with the given ID. 1242ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) { 1243 if (ID == 0) 1244 return Success; 1245 1246 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1247 Error("source location entry ID out-of-range for AST file"); 1248 return Failure; 1249 } 1250 1251 Module *F = GlobalSLocEntryMap.find(-ID)->second; 1252 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]); 1253 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 1254 unsigned BaseOffset = F->SLocEntryBaseOffset; 1255 1256 ++NumSLocEntriesRead; 1257 unsigned Code = SLocEntryCursor.ReadCode(); 1258 if (Code == llvm::bitc::END_BLOCK || 1259 Code == llvm::bitc::ENTER_SUBBLOCK || 1260 Code == llvm::bitc::DEFINE_ABBREV) { 1261 Error("incorrectly-formatted source location entry in AST file"); 1262 return Failure; 1263 } 1264 1265 RecordData Record; 1266 const char *BlobStart; 1267 unsigned BlobLen; 1268 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1269 default: 1270 Error("incorrectly-formatted source location entry in AST file"); 1271 return Failure; 1272 1273 case SM_SLOC_FILE_ENTRY: { 1274 std::string Filename(BlobStart, BlobStart + BlobLen); 1275 MaybeAddSystemRootToFilename(Filename); 1276 const FileEntry *File = FileMgr.getFile(Filename); 1277 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1278 OriginalDir != CurrentDir) { 1279 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1280 OriginalDir, 1281 CurrentDir); 1282 if (!resolved.empty()) 1283 File = FileMgr.getFile(resolved); 1284 } 1285 if (File == 0) 1286 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4], 1287 (time_t)Record[5]); 1288 if (File == 0) { 1289 std::string ErrorStr = "could not find file '"; 1290 ErrorStr += Filename; 1291 ErrorStr += "' referenced by AST file"; 1292 Error(ErrorStr.c_str()); 1293 return Failure; 1294 } 1295 1296 if (Record.size() < 6) { 1297 Error("source location entry is incorrect"); 1298 return Failure; 1299 } 1300 1301 if (!DisableValidation && 1302 ((off_t)Record[4] != File->getSize() 1303#if !defined(LLVM_ON_WIN32) 1304 // In our regression testing, the Windows file system seems to 1305 // have inconsistent modification times that sometimes 1306 // erroneously trigger this error-handling path. 1307 || (time_t)Record[5] != File->getModificationTime() 1308#endif 1309 )) { 1310 Error(diag::err_fe_pch_file_modified, Filename); 1311 return Failure; 1312 } 1313 1314 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 1315 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) { 1316 // This is the module's main file. 1317 IncludeLoc = getImportLocation(F); 1318 } 1319 FileID FID = SourceMgr.createFileID(File, IncludeLoc, 1320 (SrcMgr::CharacteristicKind)Record[2], 1321 ID, BaseOffset + Record[0]); 1322 if (Record[3]) 1323 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()) 1324 .setHasLineDirectives(); 1325 1326 break; 1327 } 1328 1329 case SM_SLOC_BUFFER_ENTRY: { 1330 const char *Name = BlobStart; 1331 unsigned Offset = Record[0]; 1332 unsigned Code = SLocEntryCursor.ReadCode(); 1333 Record.clear(); 1334 unsigned RecCode 1335 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); 1336 1337 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1338 Error("AST record has invalid code"); 1339 return Failure; 1340 } 1341 1342 llvm::MemoryBuffer *Buffer 1343 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1), 1344 Name); 1345 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, 1346 BaseOffset + Offset); 1347 1348 if (strcmp(Name, "<built-in>") == 0) { 1349 PCHPredefinesBlock Block = { 1350 BufferID, 1351 StringRef(BlobStart, BlobLen - 1) 1352 }; 1353 PCHPredefinesBuffers.push_back(Block); 1354 } 1355 1356 break; 1357 } 1358 1359 case SM_SLOC_EXPANSION_ENTRY: { 1360 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1361 SourceMgr.createExpansionLoc(SpellingLoc, 1362 ReadSourceLocation(*F, Record[2]), 1363 ReadSourceLocation(*F, Record[3]), 1364 Record[4], 1365 ID, 1366 BaseOffset + Record[0]); 1367 break; 1368 } 1369 } 1370 1371 return Success; 1372} 1373 1374/// \brief Find the location where the module F is imported. 1375SourceLocation ASTReader::getImportLocation(Module *F) { 1376 if (F->ImportLoc.isValid()) 1377 return F->ImportLoc; 1378 1379 // Otherwise we have a PCH. It's considered to be "imported" at the first 1380 // location of its includer. 1381 if (F->ImportedBy.empty() || !F->ImportedBy[0]) { 1382 // Main file is the importer. We assume that it is the first entry in the 1383 // entry table. We can't ask the manager, because at the time of PCH loading 1384 // the main file entry doesn't exist yet. 1385 // The very first entry is the invalid instantiation loc, which takes up 1386 // offsets 0 and 1. 1387 return SourceLocation::getFromRawEncoding(2U); 1388 } 1389 //return F->Loaders[0]->FirstLoc; 1390 return F->ImportedBy[0]->FirstLoc; 1391} 1392 1393/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1394/// specified cursor. Read the abbreviations that are at the top of the block 1395/// and then leave the cursor pointing into the block. 1396bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, 1397 unsigned BlockID) { 1398 if (Cursor.EnterSubBlock(BlockID)) { 1399 Error("malformed block record in AST file"); 1400 return Failure; 1401 } 1402 1403 while (true) { 1404 uint64_t Offset = Cursor.GetCurrentBitNo(); 1405 unsigned Code = Cursor.ReadCode(); 1406 1407 // We expect all abbrevs to be at the start of the block. 1408 if (Code != llvm::bitc::DEFINE_ABBREV) { 1409 Cursor.JumpToBit(Offset); 1410 return false; 1411 } 1412 Cursor.ReadAbbrevRecord(); 1413 } 1414} 1415 1416PreprocessedEntity *ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) { 1417 assert(PP && "Forgot to set Preprocessor ?"); 1418 llvm::BitstreamCursor &Stream = F.MacroCursor; 1419 1420 // Keep track of where we are in the stream, then jump back there 1421 // after reading this macro. 1422 SavedStreamPosition SavedPosition(Stream); 1423 1424 Stream.JumpToBit(Offset); 1425 RecordData Record; 1426 SmallVector<IdentifierInfo*, 16> MacroArgs; 1427 MacroInfo *Macro = 0; 1428 1429 while (true) { 1430 unsigned Code = Stream.ReadCode(); 1431 switch (Code) { 1432 case llvm::bitc::END_BLOCK: 1433 return 0; 1434 1435 case llvm::bitc::ENTER_SUBBLOCK: 1436 // No known subblocks, always skip them. 1437 Stream.ReadSubBlockID(); 1438 if (Stream.SkipBlock()) { 1439 Error("malformed block record in AST file"); 1440 return 0; 1441 } 1442 continue; 1443 1444 case llvm::bitc::DEFINE_ABBREV: 1445 Stream.ReadAbbrevRecord(); 1446 continue; 1447 default: break; 1448 } 1449 1450 // Read a record. 1451 const char *BlobStart = 0; 1452 unsigned BlobLen = 0; 1453 Record.clear(); 1454 PreprocessorRecordTypes RecType = 1455 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart, 1456 BlobLen); 1457 switch (RecType) { 1458 case PP_MACRO_OBJECT_LIKE: 1459 case PP_MACRO_FUNCTION_LIKE: { 1460 // If we already have a macro, that means that we've hit the end 1461 // of the definition of the macro we were looking for. We're 1462 // done. 1463 if (Macro) 1464 return 0; 1465 1466 IdentifierInfo *II = getLocalIdentifier(F, Record[0]); 1467 if (II == 0) { 1468 Error("macro must have a name in AST file"); 1469 return 0; 1470 } 1471 SourceLocation Loc = ReadSourceLocation(F, Record[1]); 1472 bool isUsed = Record[2]; 1473 1474 MacroInfo *MI = PP->AllocateMacroInfo(Loc); 1475 MI->setIsUsed(isUsed); 1476 MI->setIsFromAST(); 1477 1478 unsigned NextIndex = 3; 1479 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1480 // Decode function-like macro info. 1481 bool isC99VarArgs = Record[3]; 1482 bool isGNUVarArgs = Record[4]; 1483 MacroArgs.clear(); 1484 unsigned NumArgs = Record[5]; 1485 NextIndex = 6 + NumArgs; 1486 for (unsigned i = 0; i != NumArgs; ++i) 1487 MacroArgs.push_back(getLocalIdentifier(F, Record[6+i])); 1488 1489 // Install function-like macro info. 1490 MI->setIsFunctionLike(); 1491 if (isC99VarArgs) MI->setIsC99Varargs(); 1492 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1493 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1494 PP->getPreprocessorAllocator()); 1495 } 1496 1497 // Finally, install the macro. 1498 PP->setMacroInfo(II, MI); 1499 1500 // Remember that we saw this macro last so that we add the tokens that 1501 // form its body to it. 1502 Macro = MI; 1503 1504 if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) { 1505 // We have a macro definition. Load it now. 1506 PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro, 1507 getLocalMacroDefinition(F, Record[NextIndex])); 1508 } 1509 1510 ++NumMacrosRead; 1511 break; 1512 } 1513 1514 case PP_TOKEN: { 1515 // If we see a TOKEN before a PP_MACRO_*, then the file is 1516 // erroneous, just pretend we didn't see this. 1517 if (Macro == 0) break; 1518 1519 Token Tok; 1520 Tok.startToken(); 1521 Tok.setLocation(ReadSourceLocation(F, Record[0])); 1522 Tok.setLength(Record[1]); 1523 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2])) 1524 Tok.setIdentifierInfo(II); 1525 Tok.setKind((tok::TokenKind)Record[3]); 1526 Tok.setFlag((Token::TokenFlags)Record[4]); 1527 Macro->AddTokenToBody(Tok); 1528 break; 1529 } 1530 } 1531 } 1532 1533 return 0; 1534} 1535 1536PreprocessedEntity *ASTReader::LoadPreprocessedEntity(Module &F) { 1537 assert(PP && "Forgot to set Preprocessor ?"); 1538 unsigned Code = F.PreprocessorDetailCursor.ReadCode(); 1539 switch (Code) { 1540 case llvm::bitc::END_BLOCK: 1541 return 0; 1542 1543 case llvm::bitc::ENTER_SUBBLOCK: 1544 Error("unexpected subblock record in preprocessor detail block"); 1545 return 0; 1546 1547 case llvm::bitc::DEFINE_ABBREV: 1548 Error("unexpected abbrevation record in preprocessor detail block"); 1549 return 0; 1550 1551 default: 1552 break; 1553 } 1554 1555 if (!PP->getPreprocessingRecord()) { 1556 Error("no preprocessing record"); 1557 return 0; 1558 } 1559 1560 // Read the record. 1561 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord(); 1562 const char *BlobStart = 0; 1563 unsigned BlobLen = 0; 1564 RecordData Record; 1565 PreprocessorDetailRecordTypes RecType = 1566 (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord( 1567 Code, Record, BlobStart, BlobLen); 1568 switch (RecType) { 1569 case PPD_MACRO_EXPANSION: { 1570 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]); 1571 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID)) 1572 return PE; 1573 1574 MacroExpansion *ME = 1575 new (PPRec) MacroExpansion(getLocalIdentifier(F, Record[3]), 1576 SourceRange(ReadSourceLocation(F, Record[1]), 1577 ReadSourceLocation(F, Record[2])), 1578 getLocalMacroDefinition(F, Record[4])); 1579 PPRec.setLoadedPreallocatedEntity(GlobalID, ME); 1580 return ME; 1581 } 1582 1583 case PPD_MACRO_DEFINITION: { 1584 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]); 1585 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID)) 1586 return PE; 1587 1588 unsigned MacroDefID = getGlobalMacroDefinitionID(F, Record[1]); 1589 if (MacroDefID > MacroDefinitionsLoaded.size()) { 1590 Error("out-of-bounds macro definition record"); 1591 return 0; 1592 } 1593 1594 // Decode the identifier info and then check again; if the macro is 1595 // still defined and associated with the identifier, 1596 IdentifierInfo *II = getLocalIdentifier(F, Record[4]); 1597 if (!MacroDefinitionsLoaded[MacroDefID - 1]) { 1598 MacroDefinition *MD 1599 = new (PPRec) MacroDefinition(II, 1600 ReadSourceLocation(F, Record[5]), 1601 SourceRange( 1602 ReadSourceLocation(F, Record[2]), 1603 ReadSourceLocation(F, Record[3]))); 1604 1605 PPRec.setLoadedPreallocatedEntity(GlobalID, MD); 1606 MacroDefinitionsLoaded[MacroDefID - 1] = MD; 1607 1608 if (DeserializationListener) 1609 DeserializationListener->MacroDefinitionRead(MacroDefID, MD); 1610 } 1611 1612 return MacroDefinitionsLoaded[MacroDefID - 1]; 1613 } 1614 1615 case PPD_INCLUSION_DIRECTIVE: { 1616 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]); 1617 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID)) 1618 return PE; 1619 1620 const char *FullFileNameStart = BlobStart + Record[3]; 1621 const FileEntry *File 1622 = PP->getFileManager().getFile(StringRef(FullFileNameStart, 1623 BlobLen - Record[3])); 1624 1625 // FIXME: Stable encoding 1626 InclusionDirective::InclusionKind Kind 1627 = static_cast<InclusionDirective::InclusionKind>(Record[5]); 1628 InclusionDirective *ID 1629 = new (PPRec) InclusionDirective(PPRec, Kind, 1630 StringRef(BlobStart, Record[3]), 1631 Record[4], 1632 File, 1633 SourceRange(ReadSourceLocation(F, Record[1]), 1634 ReadSourceLocation(F, Record[2]))); 1635 PPRec.setLoadedPreallocatedEntity(GlobalID, ID); 1636 return ID; 1637 } 1638 } 1639 1640 Error("invalid offset in preprocessor detail block"); 1641 return 0; 1642} 1643 1644PreprocessedEntityID 1645ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) { 1646 // FIXME: Local-to-global mapping 1647 return LocalID; 1648} 1649 1650namespace { 1651 /// \brief Trait class used to search the on-disk hash table containing all of 1652 /// the header search information. 1653 /// 1654 /// The on-disk hash table contains a mapping from each header path to 1655 /// information about that header (how many times it has been included, its 1656 /// controlling macro, etc.). Note that we actually hash based on the 1657 /// filename, and support "deep" comparisons of file names based on current 1658 /// inode numbers, so that the search can cope with non-normalized path names 1659 /// and symlinks. 1660 class HeaderFileInfoTrait { 1661 ASTReader &Reader; 1662 Module &M; 1663 HeaderSearch *HS; 1664 const char *FrameworkStrings; 1665 const char *SearchPath; 1666 struct stat SearchPathStatBuf; 1667 llvm::Optional<int> SearchPathStatResult; 1668 1669 int StatSimpleCache(const char *Path, struct stat *StatBuf) { 1670 if (Path == SearchPath) { 1671 if (!SearchPathStatResult) 1672 SearchPathStatResult = stat(Path, &SearchPathStatBuf); 1673 1674 *StatBuf = SearchPathStatBuf; 1675 return *SearchPathStatResult; 1676 } 1677 1678 return stat(Path, StatBuf); 1679 } 1680 1681 public: 1682 typedef const char *external_key_type; 1683 typedef const char *internal_key_type; 1684 1685 typedef HeaderFileInfo data_type; 1686 1687 HeaderFileInfoTrait(ASTReader &Reader, Module &M, HeaderSearch *HS, 1688 const char *FrameworkStrings, 1689 const char *SearchPath = 0) 1690 : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings), 1691 SearchPath(SearchPath) { } 1692 1693 static unsigned ComputeHash(const char *path) { 1694 return llvm::HashString(llvm::sys::path::filename(path)); 1695 } 1696 1697 static internal_key_type GetInternalKey(const char *path) { return path; } 1698 1699 bool EqualKey(internal_key_type a, internal_key_type b) { 1700 if (strcmp(a, b) == 0) 1701 return true; 1702 1703 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b)) 1704 return false; 1705 1706 // The file names match, but the path names don't. stat() the files to 1707 // see if they are the same. 1708 struct stat StatBufA, StatBufB; 1709 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB)) 1710 return false; 1711 1712 return StatBufA.st_ino == StatBufB.st_ino; 1713 } 1714 1715 static std::pair<unsigned, unsigned> 1716 ReadKeyDataLength(const unsigned char*& d) { 1717 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1718 unsigned DataLen = (unsigned) *d++; 1719 return std::make_pair(KeyLen + 1, DataLen); 1720 } 1721 1722 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 1723 return (const char *)d; 1724 } 1725 1726 data_type ReadData(const internal_key_type, const unsigned char *d, 1727 unsigned DataLen) { 1728 const unsigned char *End = d + DataLen; 1729 using namespace clang::io; 1730 HeaderFileInfo HFI; 1731 unsigned Flags = *d++; 1732 HFI.isImport = (Flags >> 5) & 0x01; 1733 HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1734 HFI.DirInfo = (Flags >> 2) & 0x03; 1735 HFI.Resolved = (Flags >> 1) & 0x01; 1736 HFI.IndexHeaderMapHeader = Flags & 0x01; 1737 HFI.NumIncludes = ReadUnalignedLE16(d); 1738 HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d)); 1739 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) { 1740 // The framework offset is 1 greater than the actual offset, 1741 // since 0 is used as an indicator for "no framework name". 1742 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1743 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1744 } 1745 1746 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1747 (void)End; 1748 1749 // This HeaderFileInfo was externally loaded. 1750 HFI.External = true; 1751 return HFI; 1752 } 1753 }; 1754} 1755 1756/// \brief The on-disk hash table used for the global method pool. 1757typedef OnDiskChainedHashTable<HeaderFileInfoTrait> 1758 HeaderFileInfoLookupTable; 1759 1760void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F, 1761 uint64_t LocalOffset) { 1762 // Note that this identifier has a macro definition. 1763 II->setHasMacroDefinition(true); 1764 1765 // Adjust the offset to a global offset. 1766 UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset; 1767} 1768 1769void ASTReader::ReadDefinedMacros() { 1770 for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1771 E = ModuleMgr.rend(); I != E; ++I) { 1772 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1773 1774 // If there was no preprocessor block, skip this file. 1775 if (!MacroCursor.getBitStreamReader()) 1776 continue; 1777 1778 llvm::BitstreamCursor Cursor = MacroCursor; 1779 Cursor.JumpToBit((*I)->MacroStartOffset); 1780 1781 RecordData Record; 1782 while (true) { 1783 unsigned Code = Cursor.ReadCode(); 1784 if (Code == llvm::bitc::END_BLOCK) 1785 break; 1786 1787 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1788 // No known subblocks, always skip them. 1789 Cursor.ReadSubBlockID(); 1790 if (Cursor.SkipBlock()) { 1791 Error("malformed block record in AST file"); 1792 return; 1793 } 1794 continue; 1795 } 1796 1797 if (Code == llvm::bitc::DEFINE_ABBREV) { 1798 Cursor.ReadAbbrevRecord(); 1799 continue; 1800 } 1801 1802 // Read a record. 1803 const char *BlobStart; 1804 unsigned BlobLen; 1805 Record.clear(); 1806 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1807 default: // Default behavior: ignore. 1808 break; 1809 1810 case PP_MACRO_OBJECT_LIKE: 1811 case PP_MACRO_FUNCTION_LIKE: 1812 getLocalIdentifier(**I, Record[0]); 1813 break; 1814 1815 case PP_TOKEN: 1816 // Ignore tokens. 1817 break; 1818 } 1819 } 1820 } 1821 1822 // Drain the unread macro-record offsets map. 1823 while (!UnreadMacroRecordOffsets.empty()) 1824 LoadMacroDefinition(UnreadMacroRecordOffsets.begin()); 1825} 1826 1827void ASTReader::LoadMacroDefinition( 1828 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) { 1829 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition"); 1830 uint64_t Offset = Pos->second; 1831 UnreadMacroRecordOffsets.erase(Pos); 1832 1833 RecordLocation Loc = getLocalBitOffset(Offset); 1834 ReadMacroRecord(*Loc.F, Loc.Offset); 1835} 1836 1837void ASTReader::LoadMacroDefinition(IdentifierInfo *II) { 1838 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos 1839 = UnreadMacroRecordOffsets.find(II); 1840 LoadMacroDefinition(Pos); 1841} 1842 1843MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) { 1844 if (ID == 0 || ID > MacroDefinitionsLoaded.size()) 1845 return 0; 1846 1847 if (!MacroDefinitionsLoaded[ID - 1]) { 1848 GlobalMacroDefinitionMapType::iterator I =GlobalMacroDefinitionMap.find(ID); 1849 assert(I != GlobalMacroDefinitionMap.end() && 1850 "Corrupted global macro definition map"); 1851 Module &M = *I->second; 1852 unsigned Index = ID - 1 - M.BaseMacroDefinitionID; 1853 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 1854 M.PreprocessorDetailCursor.JumpToBit(M.MacroDefinitionOffsets[Index]); 1855 LoadPreprocessedEntity(M); 1856 } 1857 1858 return MacroDefinitionsLoaded[ID - 1]; 1859} 1860 1861const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) { 1862 std::string Filename = filenameStrRef; 1863 MaybeAddSystemRootToFilename(Filename); 1864 const FileEntry *File = FileMgr.getFile(Filename); 1865 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1866 OriginalDir != CurrentDir) { 1867 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1868 OriginalDir, 1869 CurrentDir); 1870 if (!resolved.empty()) 1871 File = FileMgr.getFile(resolved); 1872 } 1873 1874 return File; 1875} 1876 1877MacroID ASTReader::getGlobalMacroDefinitionID(Module &M, unsigned LocalID) { 1878 // FIXME: Local-to-global mapping 1879 return LocalID; 1880} 1881 1882/// \brief If we are loading a relocatable PCH file, and the filename is 1883/// not an absolute path, add the system root to the beginning of the file 1884/// name. 1885void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 1886 // If this is not a relocatable PCH file, there's nothing to do. 1887 if (!RelocatablePCH) 1888 return; 1889 1890 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1891 return; 1892 1893 if (isysroot.empty()) { 1894 // If no system root was given, default to '/' 1895 Filename.insert(Filename.begin(), '/'); 1896 return; 1897 } 1898 1899 unsigned Length = isysroot.size(); 1900 if (isysroot[Length - 1] != '/') 1901 Filename.insert(Filename.begin(), '/'); 1902 1903 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end()); 1904} 1905 1906ASTReader::ASTReadResult 1907ASTReader::ReadASTBlock(Module &F) { 1908 llvm::BitstreamCursor &Stream = F.Stream; 1909 1910 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1911 Error("malformed block record in AST file"); 1912 return Failure; 1913 } 1914 1915 // Read all of the records and blocks for the ASt file. 1916 RecordData Record; 1917 bool First = true; 1918 while (!Stream.AtEndOfStream()) { 1919 unsigned Code = Stream.ReadCode(); 1920 if (Code == llvm::bitc::END_BLOCK) { 1921 if (Stream.ReadBlockEnd()) { 1922 Error("error at end of module block in AST file"); 1923 return Failure; 1924 } 1925 1926 return Success; 1927 } 1928 1929 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1930 switch (Stream.ReadSubBlockID()) { 1931 case DECLTYPES_BLOCK_ID: 1932 // We lazily load the decls block, but we want to set up the 1933 // DeclsCursor cursor to point into it. Clone our current bitcode 1934 // cursor to it, enter the block and read the abbrevs in that block. 1935 // With the main cursor, we just skip over it. 1936 F.DeclsCursor = Stream; 1937 if (Stream.SkipBlock() || // Skip with the main cursor. 1938 // Read the abbrevs. 1939 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1940 Error("malformed block record in AST file"); 1941 return Failure; 1942 } 1943 break; 1944 1945 case DECL_UPDATES_BLOCK_ID: 1946 if (Stream.SkipBlock()) { 1947 Error("malformed block record in AST file"); 1948 return Failure; 1949 } 1950 break; 1951 1952 case PREPROCESSOR_BLOCK_ID: 1953 F.MacroCursor = Stream; 1954 if (PP) 1955 PP->setExternalSource(this); 1956 1957 if (Stream.SkipBlock() || 1958 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1959 Error("malformed block record in AST file"); 1960 return Failure; 1961 } 1962 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1963 break; 1964 1965 case PREPROCESSOR_DETAIL_BLOCK_ID: 1966 F.PreprocessorDetailCursor = Stream; 1967 if (Stream.SkipBlock() || 1968 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 1969 PREPROCESSOR_DETAIL_BLOCK_ID)) { 1970 Error("malformed preprocessor detail record in AST file"); 1971 return Failure; 1972 } 1973 F.PreprocessorDetailStartOffset 1974 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 1975 break; 1976 1977 case SOURCE_MANAGER_BLOCK_ID: 1978 switch (ReadSourceManagerBlock(F)) { 1979 case Success: 1980 break; 1981 1982 case Failure: 1983 Error("malformed source manager block in AST file"); 1984 return Failure; 1985 1986 case IgnorePCH: 1987 return IgnorePCH; 1988 } 1989 break; 1990 } 1991 First = false; 1992 continue; 1993 } 1994 1995 if (Code == llvm::bitc::DEFINE_ABBREV) { 1996 Stream.ReadAbbrevRecord(); 1997 continue; 1998 } 1999 2000 // Read and process a record. 2001 Record.clear(); 2002 const char *BlobStart = 0; 2003 unsigned BlobLen = 0; 2004 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 2005 &BlobStart, &BlobLen)) { 2006 default: // Default behavior: ignore. 2007 break; 2008 2009 case METADATA: { 2010 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 2011 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 2012 : diag::warn_pch_version_too_new); 2013 return IgnorePCH; 2014 } 2015 2016 RelocatablePCH = Record[4]; 2017 if (Listener) { 2018 std::string TargetTriple(BlobStart, BlobLen); 2019 if (Listener->ReadTargetTriple(TargetTriple)) 2020 return IgnorePCH; 2021 } 2022 break; 2023 } 2024 2025 case CHAINED_METADATA: { 2026 if (!First) { 2027 Error("CHAINED_METADATA is not first record in block"); 2028 return Failure; 2029 } 2030 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 2031 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 2032 : diag::warn_pch_version_too_new); 2033 return IgnorePCH; 2034 } 2035 2036 // Load the chained file, which is always a PCH file. 2037 // FIXME: This could end up being a module. 2038 switch(ReadASTCore(StringRef(BlobStart, BlobLen), MK_PCH)) { 2039 case Failure: return Failure; 2040 // If we have to ignore the dependency, we'll have to ignore this too. 2041 case IgnorePCH: return IgnorePCH; 2042 case Success: break; 2043 } 2044 break; 2045 } 2046 2047 case TYPE_OFFSET: { 2048 if (F.LocalNumTypes != 0) { 2049 Error("duplicate TYPE_OFFSET record in AST file"); 2050 return Failure; 2051 } 2052 F.TypeOffsets = (const uint32_t *)BlobStart; 2053 F.LocalNumTypes = Record[0]; 2054 unsigned LocalBaseTypeIndex = Record[1]; 2055 F.BaseTypeIndex = getTotalNumTypes(); 2056 2057 if (F.LocalNumTypes > 0) { 2058 // Introduce the global -> local mapping for types within this module. 2059 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 2060 2061 // Introduce the local -> global mapping for types within this module. 2062 F.TypeRemap.insert(std::make_pair(LocalBaseTypeIndex, 2063 F.BaseTypeIndex - LocalBaseTypeIndex)); 2064 2065 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 2066 } 2067 break; 2068 } 2069 2070 case DECL_OFFSET: { 2071 if (F.LocalNumDecls != 0) { 2072 Error("duplicate DECL_OFFSET record in AST file"); 2073 return Failure; 2074 } 2075 F.DeclOffsets = (const uint32_t *)BlobStart; 2076 F.LocalNumDecls = Record[0]; 2077 unsigned LocalBaseDeclID = Record[1]; 2078 F.BaseDeclID = getTotalNumDecls(); 2079 2080 if (F.LocalNumDecls > 0) { 2081 // Introduce the global -> local mapping for declarations within this 2082 // module. 2083 GlobalDeclMap.insert(std::make_pair(getTotalNumDecls() + 1, &F)); 2084 2085 // Introduce the local -> global mapping for declarations within this 2086 // module. 2087 F.DeclRemap.insert(std::make_pair(LocalBaseDeclID, 2088 F.BaseDeclID - LocalBaseDeclID)); 2089 2090 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 2091 } 2092 break; 2093 } 2094 2095 case TU_UPDATE_LEXICAL: { 2096 DeclContextInfo Info = { 2097 &F, 2098 /* No visible information */ 0, 2099 reinterpret_cast<const KindDeclIDPair *>(BlobStart), 2100 static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair)) 2101 }; 2102 DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0] 2103 .push_back(Info); 2104 break; 2105 } 2106 2107 case UPDATE_VISIBLE: { 2108 unsigned Idx = 0; 2109 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 2110 void *Table = ASTDeclContextNameLookupTable::Create( 2111 (const unsigned char *)BlobStart + Record[Idx++], 2112 (const unsigned char *)BlobStart, 2113 ASTDeclContextNameLookupTrait(*this, F)); 2114 // FIXME: Complete hack to check for the TU 2115 if (ID == (*(ModuleMgr.end() - 1))->BaseDeclID + 1 && Context) { // Is it the TU? 2116 DeclContextInfo Info = { 2117 &F, Table, /* No lexical information */ 0, 0 2118 }; 2119 DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info); 2120 } else 2121 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 2122 break; 2123 } 2124 2125 case REDECLS_UPDATE_LATEST: { 2126 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 2127 for (unsigned i = 0, e = Record.size(); i < e; /* in loop */) { 2128 DeclID First = ReadDeclID(F, Record, i); 2129 DeclID Latest = ReadDeclID(F, Record, i); 2130 FirstLatestDeclIDs[First] = Latest; 2131 } 2132 break; 2133 } 2134 2135 case LANGUAGE_OPTIONS: 2136 if (ParseLanguageOptions(Record) && !DisableValidation) 2137 return IgnorePCH; 2138 break; 2139 2140 case IDENTIFIER_TABLE: 2141 F.IdentifierTableData = BlobStart; 2142 if (Record[0]) { 2143 F.IdentifierLookupTable 2144 = ASTIdentifierLookupTable::Create( 2145 (const unsigned char *)F.IdentifierTableData + Record[0], 2146 (const unsigned char *)F.IdentifierTableData, 2147 ASTIdentifierLookupTrait(*this, F)); 2148 if (PP) { 2149 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2150 PP->getHeaderSearchInfo().SetExternalLookup(this); 2151 } 2152 } 2153 break; 2154 2155 case IDENTIFIER_OFFSET: { 2156 if (F.LocalNumIdentifiers != 0) { 2157 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2158 return Failure; 2159 } 2160 F.IdentifierOffsets = (const uint32_t *)BlobStart; 2161 F.LocalNumIdentifiers = Record[0]; 2162 unsigned LocalBaseIdentifierID = Record[1]; 2163 F.BaseIdentifierID = getTotalNumIdentifiers(); 2164 2165 if (F.LocalNumIdentifiers > 0) { 2166 // Introduce the global -> local mapping for identifiers within this 2167 // module. 2168 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 2169 &F)); 2170 2171 // Introduce the local -> global mapping for identifiers within this 2172 // module. 2173 F.IdentifierRemap.insert( 2174 std::make_pair(LocalBaseIdentifierID, 2175 F.BaseIdentifierID - LocalBaseIdentifierID)); 2176 2177 IdentifiersLoaded.resize(IdentifiersLoaded.size() 2178 + F.LocalNumIdentifiers); 2179 } 2180 break; 2181 } 2182 2183 case EXTERNAL_DEFINITIONS: 2184 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2185 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2186 break; 2187 2188 case SPECIAL_TYPES: 2189 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2190 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 2191 break; 2192 2193 case STATISTICS: 2194 TotalNumStatements += Record[0]; 2195 TotalNumMacros += Record[1]; 2196 TotalLexicalDeclContexts += Record[2]; 2197 TotalVisibleDeclContexts += Record[3]; 2198 break; 2199 2200 case UNUSED_FILESCOPED_DECLS: 2201 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2202 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 2203 break; 2204 2205 case DELEGATING_CTORS: 2206 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2207 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 2208 break; 2209 2210 case WEAK_UNDECLARED_IDENTIFIERS: 2211 if (Record.size() % 4 != 0) { 2212 Error("invalid weak identifiers record"); 2213 return Failure; 2214 } 2215 2216 // FIXME: Ignore weak undeclared identifiers from non-original PCH 2217 // files. This isn't the way to do it :) 2218 WeakUndeclaredIdentifiers.clear(); 2219 2220 // Translate the weak, undeclared identifiers into global IDs. 2221 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 2222 WeakUndeclaredIdentifiers.push_back( 2223 getGlobalIdentifierID(F, Record[I++])); 2224 WeakUndeclaredIdentifiers.push_back( 2225 getGlobalIdentifierID(F, Record[I++])); 2226 WeakUndeclaredIdentifiers.push_back( 2227 ReadSourceLocation(F, Record, I).getRawEncoding()); 2228 WeakUndeclaredIdentifiers.push_back(Record[I++]); 2229 } 2230 break; 2231 2232 case LOCALLY_SCOPED_EXTERNAL_DECLS: 2233 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2234 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I])); 2235 break; 2236 2237 case SELECTOR_OFFSETS: { 2238 F.SelectorOffsets = (const uint32_t *)BlobStart; 2239 F.LocalNumSelectors = Record[0]; 2240 unsigned LocalBaseSelectorID = Record[1]; 2241 F.BaseSelectorID = getTotalNumSelectors(); 2242 2243 if (F.LocalNumSelectors > 0) { 2244 // Introduce the global -> local mapping for selectors within this 2245 // module. 2246 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2247 2248 // Introduce the local -> global mapping for selectors within this 2249 // module. 2250 F.SelectorRemap.insert(std::make_pair(LocalBaseSelectorID, 2251 F.BaseSelectorID - LocalBaseSelectorID)); 2252 2253 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2254 } 2255 break; 2256 } 2257 2258 case METHOD_POOL: 2259 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 2260 if (Record[0]) 2261 F.SelectorLookupTable 2262 = ASTSelectorLookupTable::Create( 2263 F.SelectorLookupTableData + Record[0], 2264 F.SelectorLookupTableData, 2265 ASTSelectorLookupTrait(*this, F)); 2266 TotalNumMethodPoolEntries += Record[1]; 2267 break; 2268 2269 case REFERENCED_SELECTOR_POOL: 2270 if (!Record.empty()) { 2271 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2272 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2273 Record[Idx++])); 2274 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2275 getRawEncoding()); 2276 } 2277 } 2278 break; 2279 2280 case PP_COUNTER_VALUE: 2281 if (!Record.empty() && Listener) 2282 Listener->ReadCounter(Record[0]); 2283 break; 2284 2285 case SOURCE_LOCATION_OFFSETS: { 2286 F.SLocEntryOffsets = (const uint32_t *)BlobStart; 2287 F.LocalNumSLocEntries = Record[0]; 2288 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2289 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]); 2290 // Make our entry in the range map. BaseID is negative and growing, so 2291 // we invert it. Because we invert it, though, we need the other end of 2292 // the range. 2293 unsigned RangeStart = 2294 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2295 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2296 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2297 2298 // Initialize the remapping table. 2299 // Invalid stays invalid. 2300 F.SLocRemap.insert(std::make_pair(0U, 0)); 2301 // This module. Base was 2 when being compiled. 2302 F.SLocRemap.insert(std::make_pair(2U, 2303 static_cast<int>(F.SLocEntryBaseOffset - 2))); 2304 2305 TotalNumSLocEntries += F.LocalNumSLocEntries; 2306 break; 2307 } 2308 2309 case MODULE_OFFSET_MAP: { 2310 // Additional remapping information. 2311 const unsigned char *Data = (const unsigned char*)BlobStart; 2312 const unsigned char *DataEnd = Data + BlobLen; 2313 2314 // Continuous range maps we may be updating in our module. 2315 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 2316 ContinuousRangeMap<uint32_t, int, 2>::Builder 2317 IdentifierRemap(F.IdentifierRemap); 2318 ContinuousRangeMap<uint32_t, int, 2>::Builder 2319 SelectorRemap(F.SelectorRemap); 2320 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 2321 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 2322 2323 while(Data < DataEnd) { 2324 uint16_t Len = io::ReadUnalignedLE16(Data); 2325 StringRef Name = StringRef((const char*)Data, Len); 2326 Data += Len; 2327 Module *OM = ModuleMgr.lookup(Name); 2328 if (!OM) { 2329 Error("SourceLocation remap refers to unknown module"); 2330 return Failure; 2331 } 2332 2333 uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 2334 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 2335 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 2336 uint32_t MacroDefinitionIDOffset = io::ReadUnalignedLE32(Data); 2337 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 2338 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 2339 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2340 2341 // Source location offset is mapped to OM->SLocEntryBaseOffset. 2342 SLocRemap.insert(std::make_pair(SLocOffset, 2343 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2344 2345 // FIXME: Map other locations 2346 IdentifierRemap.insert( 2347 std::make_pair(IdentifierIDOffset, 2348 OM->BaseIdentifierID - IdentifierIDOffset)); 2349 (void)PreprocessedEntityIDOffset; 2350 (void)MacroDefinitionIDOffset; 2351 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2352 OM->BaseSelectorID - SelectorIDOffset)); 2353 DeclRemap.insert(std::make_pair(DeclIDOffset, 2354 OM->BaseDeclID - DeclIDOffset)); 2355 2356 TypeRemap.insert(std::make_pair(TypeIndexOffset, 2357 OM->BaseTypeIndex - TypeIndexOffset)); 2358 } 2359 break; 2360 } 2361 2362 case SOURCE_MANAGER_LINE_TABLE: 2363 if (ParseLineTable(F, Record)) 2364 return Failure; 2365 break; 2366 2367 case FILE_SOURCE_LOCATION_OFFSETS: 2368 F.SLocFileOffsets = (const uint32_t *)BlobStart; 2369 F.LocalNumSLocFileEntries = Record[0]; 2370 break; 2371 2372 case SOURCE_LOCATION_PRELOADS: { 2373 // Need to transform from the local view (1-based IDs) to the global view, 2374 // which is based off F.SLocEntryBaseID. 2375 PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size()); 2376 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2377 PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID); 2378 break; 2379 } 2380 2381 case STAT_CACHE: { 2382 if (!DisableStatCache) { 2383 ASTStatCache *MyStatCache = 2384 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2385 (const unsigned char *)BlobStart, 2386 NumStatHits, NumStatMisses); 2387 FileMgr.addStatCache(MyStatCache); 2388 F.StatCache = MyStatCache; 2389 } 2390 break; 2391 } 2392 2393 case EXT_VECTOR_DECLS: 2394 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2395 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2396 break; 2397 2398 case VTABLE_USES: 2399 if (Record.size() % 3 != 0) { 2400 Error("Invalid VTABLE_USES record"); 2401 return Failure; 2402 } 2403 2404 // Later tables overwrite earlier ones. 2405 // FIXME: Modules will have some trouble with this. This is clearly not 2406 // the right way to do this. 2407 VTableUses.clear(); 2408 2409 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2410 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2411 VTableUses.push_back( 2412 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2413 VTableUses.push_back(Record[Idx++]); 2414 } 2415 break; 2416 2417 case DYNAMIC_CLASSES: 2418 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2419 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2420 break; 2421 2422 case PENDING_IMPLICIT_INSTANTIATIONS: 2423 if (PendingInstantiations.size() % 2 != 0) { 2424 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2425 return Failure; 2426 } 2427 2428 // Later lists of pending instantiations overwrite earlier ones. 2429 // FIXME: This is most certainly wrong for modules. 2430 PendingInstantiations.clear(); 2431 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2432 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2433 PendingInstantiations.push_back( 2434 ReadSourceLocation(F, Record, I).getRawEncoding()); 2435 } 2436 break; 2437 2438 case SEMA_DECL_REFS: 2439 // Later tables overwrite earlier ones. 2440 // FIXME: Modules will have some trouble with this. 2441 SemaDeclRefs.clear(); 2442 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2443 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2444 break; 2445 2446 case ORIGINAL_FILE_NAME: 2447 // The primary AST will be the last to get here, so it will be the one 2448 // that's used. 2449 ActualOriginalFileName.assign(BlobStart, BlobLen); 2450 OriginalFileName = ActualOriginalFileName; 2451 MaybeAddSystemRootToFilename(OriginalFileName); 2452 break; 2453 2454 case ORIGINAL_FILE_ID: 2455 OriginalFileID = FileID::get(Record[0]); 2456 break; 2457 2458 case ORIGINAL_PCH_DIR: 2459 // The primary AST will be the last to get here, so it will be the one 2460 // that's used. 2461 OriginalDir.assign(BlobStart, BlobLen); 2462 break; 2463 2464 case VERSION_CONTROL_BRANCH_REVISION: { 2465 const std::string &CurBranch = getClangFullRepositoryVersion(); 2466 StringRef ASTBranch(BlobStart, BlobLen); 2467 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2468 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2469 return IgnorePCH; 2470 } 2471 break; 2472 } 2473 2474 case MACRO_DEFINITION_OFFSETS: { 2475 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart; 2476 F.NumPreallocatedPreprocessingEntities = Record[0]; 2477 F.LocalNumMacroDefinitions = Record[1]; 2478 2479 // Introduce the global -> local mapping for preprocessed entities within 2480 // this AST file. 2481 unsigned StartingID; 2482 if (PP) { 2483 if (!PP->getPreprocessingRecord()) 2484 PP->createPreprocessingRecord(true); 2485 if (!PP->getPreprocessingRecord()->getExternalSource()) 2486 PP->getPreprocessingRecord()->SetExternalSource(*this); 2487 StartingID 2488 = PP->getPreprocessingRecord() 2489 ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities); 2490 } else { 2491 // FIXME: We'll eventually want to kill this path, since it assumes 2492 // a particular allocation strategy in the preprocessing record. 2493 StartingID = getTotalNumPreprocessedEntities(); 2494 } 2495 2496 F.BaseMacroDefinitionID = getTotalNumMacroDefinitions(); 2497 F.BasePreprocessedEntityID = StartingID; 2498 2499 // Introduce the global -> local mapping for macro definitions within 2500 // this AST file. 2501 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2502 GlobalMacroDefinitionMap.insert( 2503 std::make_pair(getTotalNumMacroDefinitions() + 1, &F)); 2504 MacroDefinitionsLoaded.resize( 2505 MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions); 2506 break; 2507 } 2508 2509 case DECL_UPDATE_OFFSETS: { 2510 if (Record.size() % 2 != 0) { 2511 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2512 return Failure; 2513 } 2514 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2515 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2516 .push_back(std::make_pair(&F, Record[I+1])); 2517 break; 2518 } 2519 2520 case DECL_REPLACEMENTS: { 2521 if (Record.size() % 2 != 0) { 2522 Error("invalid DECL_REPLACEMENTS block in AST file"); 2523 return Failure; 2524 } 2525 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2526 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2527 = std::make_pair(&F, Record[I+1]); 2528 break; 2529 } 2530 2531 case CXX_BASE_SPECIFIER_OFFSETS: { 2532 if (F.LocalNumCXXBaseSpecifiers != 0) { 2533 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2534 return Failure; 2535 } 2536 2537 F.LocalNumCXXBaseSpecifiers = Record[0]; 2538 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2539 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2540 break; 2541 } 2542 2543 case DIAG_PRAGMA_MAPPINGS: 2544 if (Record.size() % 2 != 0) { 2545 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2546 return Failure; 2547 } 2548 2549 if (F.PragmaDiagMappings.empty()) 2550 F.PragmaDiagMappings.swap(Record); 2551 else 2552 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2553 Record.begin(), Record.end()); 2554 break; 2555 2556 case CUDA_SPECIAL_DECL_REFS: 2557 // Later tables overwrite earlier ones. 2558 // FIXME: Modules will have trouble with this. 2559 CUDASpecialDeclRefs.clear(); 2560 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2561 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2562 break; 2563 2564 case HEADER_SEARCH_TABLE: { 2565 F.HeaderFileInfoTableData = BlobStart; 2566 F.LocalNumHeaderFileInfos = Record[1]; 2567 F.HeaderFileFrameworkStrings = BlobStart + Record[2]; 2568 if (Record[0]) { 2569 F.HeaderFileInfoTable 2570 = HeaderFileInfoLookupTable::Create( 2571 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2572 (const unsigned char *)F.HeaderFileInfoTableData, 2573 HeaderFileInfoTrait(*this, F, 2574 PP? &PP->getHeaderSearchInfo() : 0, 2575 BlobStart + Record[2])); 2576 if (PP) 2577 PP->getHeaderSearchInfo().SetExternalSource(this); 2578 } 2579 break; 2580 } 2581 2582 case FP_PRAGMA_OPTIONS: 2583 // Later tables overwrite earlier ones. 2584 FPPragmaOptions.swap(Record); 2585 break; 2586 2587 case OPENCL_EXTENSIONS: 2588 // Later tables overwrite earlier ones. 2589 OpenCLExtensions.swap(Record); 2590 break; 2591 2592 case TENTATIVE_DEFINITIONS: 2593 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2594 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2595 break; 2596 2597 case KNOWN_NAMESPACES: 2598 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2599 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2600 break; 2601 } 2602 First = false; 2603 } 2604 Error("premature end of bitstream in AST file"); 2605 return Failure; 2606} 2607 2608ASTReader::ASTReadResult ASTReader::validateFileEntries() { 2609 for (ModuleIterator I = ModuleMgr.begin(), 2610 E = ModuleMgr.end(); I != E; ++I) { 2611 Module *F = *I; 2612 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 2613 2614 for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) { 2615 SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]); 2616 unsigned Code = SLocEntryCursor.ReadCode(); 2617 if (Code == llvm::bitc::END_BLOCK || 2618 Code == llvm::bitc::ENTER_SUBBLOCK || 2619 Code == llvm::bitc::DEFINE_ABBREV) { 2620 Error("incorrectly-formatted source location entry in AST file"); 2621 return Failure; 2622 } 2623 2624 RecordData Record; 2625 const char *BlobStart; 2626 unsigned BlobLen; 2627 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2628 default: 2629 Error("incorrectly-formatted source location entry in AST file"); 2630 return Failure; 2631 2632 case SM_SLOC_FILE_ENTRY: { 2633 StringRef Filename(BlobStart, BlobLen); 2634 const FileEntry *File = getFileEntry(Filename); 2635 2636 if (File == 0) { 2637 std::string ErrorStr = "could not find file '"; 2638 ErrorStr += Filename; 2639 ErrorStr += "' referenced by AST file"; 2640 Error(ErrorStr.c_str()); 2641 return IgnorePCH; 2642 } 2643 2644 if (Record.size() < 6) { 2645 Error("source location entry is incorrect"); 2646 return Failure; 2647 } 2648 2649 // The stat info from the FileEntry came from the cached stat 2650 // info of the PCH, so we cannot trust it. 2651 struct stat StatBuf; 2652 if (::stat(File->getName(), &StatBuf) != 0) { 2653 StatBuf.st_size = File->getSize(); 2654 StatBuf.st_mtime = File->getModificationTime(); 2655 } 2656 2657 if (((off_t)Record[4] != StatBuf.st_size 2658#if !defined(LLVM_ON_WIN32) 2659 // In our regression testing, the Windows file system seems to 2660 // have inconsistent modification times that sometimes 2661 // erroneously trigger this error-handling path. 2662 || (time_t)Record[5] != StatBuf.st_mtime 2663#endif 2664 )) { 2665 Error(diag::err_fe_pch_file_modified, Filename); 2666 return IgnorePCH; 2667 } 2668 2669 break; 2670 } 2671 } 2672 } 2673 } 2674 2675 return Success; 2676} 2677 2678ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2679 ModuleKind Type) { 2680 switch(ReadASTCore(FileName, Type)) { 2681 case Failure: return Failure; 2682 case IgnorePCH: return IgnorePCH; 2683 case Success: break; 2684 } 2685 2686 // Here comes stuff that we only do once the entire chain is loaded. 2687 2688 if (!DisableValidation) { 2689 switch(validateFileEntries()) { 2690 case Failure: return Failure; 2691 case IgnorePCH: return IgnorePCH; 2692 case Success: break; 2693 } 2694 } 2695 2696 // Preload SLocEntries. 2697 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) { 2698 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]); 2699 if (Result != Success) 2700 return Failure; 2701 } 2702 PreloadSLocEntries.clear(); 2703 2704 // Check the predefines buffers. 2705 if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers()) 2706 return IgnorePCH; 2707 2708 if (PP) { 2709 // Initialization of keywords and pragmas occurs before the 2710 // AST file is read, so there may be some identifiers that were 2711 // loaded into the IdentifierTable before we intercepted the 2712 // creation of identifiers. Iterate through the list of known 2713 // identifiers and determine whether we have to establish 2714 // preprocessor definitions or top-level identifier declaration 2715 // chains for those identifiers. 2716 // 2717 // We copy the IdentifierInfo pointers to a small vector first, 2718 // since de-serializing declarations or macro definitions can add 2719 // new entries into the identifier table, invalidating the 2720 // iterators. 2721 // 2722 // FIXME: We need a lazier way to load this information, e.g., by marking 2723 // the identifier data as 'dirty', so that it will be looked up in the 2724 // AST file(s) if it is uttered in the source. This could save us some 2725 // module load time. 2726 SmallVector<IdentifierInfo *, 128> Identifiers; 2727 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 2728 IdEnd = PP->getIdentifierTable().end(); 2729 Id != IdEnd; ++Id) 2730 Identifiers.push_back(Id->second); 2731 // We need to search the tables in all files. 2732 for (ModuleIterator J = ModuleMgr.begin(), 2733 M = ModuleMgr.end(); J != M; ++J) { 2734 ASTIdentifierLookupTable *IdTable 2735 = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable; 2736 // Not all AST files necessarily have identifier tables, only the useful 2737 // ones. 2738 if (!IdTable) 2739 continue; 2740 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2741 IdentifierInfo *II = Identifiers[I]; 2742 // Look in the on-disk hash tables for an entry for this identifier 2743 ASTIdentifierLookupTrait Info(*this, *(*J), II); 2744 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 2745 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 2746 if (Pos == IdTable->end()) 2747 continue; 2748 2749 // Dereferencing the iterator has the effect of populating the 2750 // IdentifierInfo node with the various declarations it needs. 2751 (void)*Pos; 2752 } 2753 } 2754 } 2755 2756 if (Context) 2757 InitializeContext(*Context); 2758 2759 if (DeserializationListener) 2760 DeserializationListener->ReaderInitialized(this); 2761 2762 // If this AST file is a precompiled preamble, then set the main file ID of 2763 // the source manager to the file source file from which the preamble was 2764 // built. This is the only valid way to use a precompiled preamble. 2765 if (Type == MK_Preamble) { 2766 if (OriginalFileID.isInvalid()) { 2767 SourceLocation Loc 2768 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1); 2769 if (Loc.isValid()) 2770 OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first; 2771 } 2772 else { 2773 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2774 + OriginalFileID.getOpaqueValue() - 1); 2775 } 2776 2777 if (!OriginalFileID.isInvalid()) 2778 SourceMgr.SetPreambleFileID(OriginalFileID); 2779 } 2780 2781 return Success; 2782} 2783 2784ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2785 ModuleKind Type) { 2786 Module &F = ModuleMgr.addModule(FileName, Type); 2787 2788 if (FileName != "-") { 2789 CurrentDir = llvm::sys::path::parent_path(FileName); 2790 if (CurrentDir.empty()) CurrentDir = "."; 2791 } 2792 2793 if (llvm::MemoryBuffer *Buffer = ModuleMgr.lookupBuffer(FileName)) { 2794 F.Buffer.reset(Buffer); 2795 assert(F.Buffer && "Passed null buffer"); 2796 } else { 2797 // Open the AST file. 2798 // 2799 // FIXME: This shouldn't be here, we should just take a raw_ostream. 2800 std::string ErrStr; 2801 llvm::error_code ec; 2802 if (FileName == "-") { 2803 ec = llvm::MemoryBuffer::getSTDIN(F.Buffer); 2804 if (ec) 2805 ErrStr = ec.message(); 2806 } else 2807 F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr)); 2808 if (!F.Buffer) { 2809 Error(ErrStr.c_str()); 2810 return IgnorePCH; 2811 } 2812 } 2813 2814 // Initialize the stream 2815 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2816 (const unsigned char *)F.Buffer->getBufferEnd()); 2817 llvm::BitstreamCursor &Stream = F.Stream; 2818 Stream.init(F.StreamFile); 2819 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2820 2821 // Sniff for the signature. 2822 if (Stream.Read(8) != 'C' || 2823 Stream.Read(8) != 'P' || 2824 Stream.Read(8) != 'C' || 2825 Stream.Read(8) != 'H') { 2826 Diag(diag::err_not_a_pch_file) << FileName; 2827 return Failure; 2828 } 2829 2830 while (!Stream.AtEndOfStream()) { 2831 unsigned Code = Stream.ReadCode(); 2832 2833 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2834 Error("invalid record at top-level of AST file"); 2835 return Failure; 2836 } 2837 2838 unsigned BlockID = Stream.ReadSubBlockID(); 2839 2840 // We only know the AST subblock ID. 2841 switch (BlockID) { 2842 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2843 if (Stream.ReadBlockInfoBlock()) { 2844 Error("malformed BlockInfoBlock in AST file"); 2845 return Failure; 2846 } 2847 break; 2848 case AST_BLOCK_ID: 2849 switch (ReadASTBlock(F)) { 2850 case Success: 2851 break; 2852 2853 case Failure: 2854 return Failure; 2855 2856 case IgnorePCH: 2857 // FIXME: We could consider reading through to the end of this 2858 // AST block, skipping subblocks, to see if there are other 2859 // AST blocks elsewhere. 2860 2861 // FIXME: We can't clear loaded slocentries anymore. 2862 //SourceMgr.ClearPreallocatedSLocEntries(); 2863 2864 // Remove the stat cache. 2865 if (F.StatCache) 2866 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2867 2868 return IgnorePCH; 2869 } 2870 break; 2871 default: 2872 if (Stream.SkipBlock()) { 2873 Error("malformed block record in AST file"); 2874 return Failure; 2875 } 2876 break; 2877 } 2878 } 2879 2880 // Once read, set the Module bit base offset and update the size in 2881 // bits of all files we've seen. 2882 F.GlobalBitOffset = TotalModulesSizeInBits; 2883 TotalModulesSizeInBits += F.SizeInBits; 2884 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2885 return Success; 2886} 2887 2888void ASTReader::setPreprocessor(Preprocessor &pp) { 2889 PP = &pp; 2890 2891 if (unsigned N = getTotalNumPreprocessedEntities()) { 2892 if (!PP->getPreprocessingRecord()) 2893 PP->createPreprocessingRecord(true); 2894 PP->getPreprocessingRecord()->SetExternalSource(*this); 2895 PP->getPreprocessingRecord()->allocateLoadedEntities(N); 2896 } 2897 2898 PP->getHeaderSearchInfo().SetExternalLookup(this); 2899 PP->getHeaderSearchInfo().SetExternalSource(this); 2900} 2901 2902void ASTReader::InitializeContext(ASTContext &Ctx) { 2903 Context = &Ctx; 2904 assert(Context && "Passed null context!"); 2905 2906 assert(PP && "Forgot to set Preprocessor ?"); 2907 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2908 PP->setExternalSource(this); 2909 2910 // If we have an update block for the TU waiting, we have to add it before 2911 // deserializing the decl. 2912 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2913 if (DCU != DeclContextOffsets.end()) { 2914 // Insertion could invalidate map, so grab vector. 2915 DeclContextInfos T; 2916 T.swap(DCU->second); 2917 DeclContextOffsets.erase(DCU); 2918 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T); 2919 } 2920 2921 // Load the translation unit declaration 2922 GetTranslationUnitDecl(); 2923 2924 // Load the special types. 2925 Context->setBuiltinVaListType( 2926 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2927 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 2928 Context->setObjCIdType(GetType(Id)); 2929 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 2930 Context->setObjCSelType(GetType(Sel)); 2931 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 2932 Context->setObjCProtoType(GetType(Proto)); 2933 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 2934 Context->setObjCClassType(GetType(Class)); 2935 2936 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 2937 Context->setCFConstantStringType(GetType(String)); 2938 if (unsigned FastEnum 2939 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 2940 Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 2941 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2942 QualType FileType = GetType(File); 2943 if (FileType.isNull()) { 2944 Error("FILE type is NULL"); 2945 return; 2946 } 2947 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2948 Context->setFILEDecl(Typedef->getDecl()); 2949 else { 2950 const TagType *Tag = FileType->getAs<TagType>(); 2951 if (!Tag) { 2952 Error("Invalid FILE type in AST file"); 2953 return; 2954 } 2955 Context->setFILEDecl(Tag->getDecl()); 2956 } 2957 } 2958 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2959 QualType Jmp_bufType = GetType(Jmp_buf); 2960 if (Jmp_bufType.isNull()) { 2961 Error("jmp_buf type is NULL"); 2962 return; 2963 } 2964 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2965 Context->setjmp_bufDecl(Typedef->getDecl()); 2966 else { 2967 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2968 if (!Tag) { 2969 Error("Invalid jmp_buf type in AST file"); 2970 return; 2971 } 2972 Context->setjmp_bufDecl(Tag->getDecl()); 2973 } 2974 } 2975 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2976 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2977 if (Sigjmp_bufType.isNull()) { 2978 Error("sigjmp_buf type is NULL"); 2979 return; 2980 } 2981 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2982 Context->setsigjmp_bufDecl(Typedef->getDecl()); 2983 else { 2984 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2985 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2986 Context->setsigjmp_bufDecl(Tag->getDecl()); 2987 } 2988 } 2989 if (unsigned ObjCIdRedef 2990 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 2991 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2992 if (unsigned ObjCClassRedef 2993 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 2994 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2995 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 2996 Context->setBlockDescriptorType(GetType(String)); 2997 if (unsigned String 2998 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 2999 Context->setBlockDescriptorExtendedType(GetType(String)); 3000 if (unsigned ObjCSelRedef 3001 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 3002 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3003 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 3004 Context->setNSConstantStringType(GetType(String)); 3005 3006 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 3007 Context->setInt128Installed(); 3008 3009 if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT]) 3010 Context->AutoDeductTy = GetType(AutoDeduct); 3011 if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT]) 3012 Context->AutoRRefDeductTy = GetType(AutoRRefDeduct); 3013 3014 ReadPragmaDiagnosticMappings(Context->getDiagnostics()); 3015 3016 // If there were any CUDA special declarations, deserialize them. 3017 if (!CUDASpecialDeclRefs.empty()) { 3018 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3019 Context->setcudaConfigureCallDecl( 3020 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3021 } 3022} 3023 3024/// \brief Retrieve the name of the original source file name 3025/// directly from the AST file, without actually loading the AST 3026/// file. 3027std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3028 FileManager &FileMgr, 3029 Diagnostic &Diags) { 3030 // Open the AST file. 3031 std::string ErrStr; 3032 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 3033 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3034 if (!Buffer) { 3035 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 3036 return std::string(); 3037 } 3038 3039 // Initialize the stream 3040 llvm::BitstreamReader StreamFile; 3041 llvm::BitstreamCursor Stream; 3042 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3043 (const unsigned char *)Buffer->getBufferEnd()); 3044 Stream.init(StreamFile); 3045 3046 // Sniff for the signature. 3047 if (Stream.Read(8) != 'C' || 3048 Stream.Read(8) != 'P' || 3049 Stream.Read(8) != 'C' || 3050 Stream.Read(8) != 'H') { 3051 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3052 return std::string(); 3053 } 3054 3055 RecordData Record; 3056 while (!Stream.AtEndOfStream()) { 3057 unsigned Code = Stream.ReadCode(); 3058 3059 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3060 unsigned BlockID = Stream.ReadSubBlockID(); 3061 3062 // We only know the AST subblock ID. 3063 switch (BlockID) { 3064 case AST_BLOCK_ID: 3065 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 3066 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3067 return std::string(); 3068 } 3069 break; 3070 3071 default: 3072 if (Stream.SkipBlock()) { 3073 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3074 return std::string(); 3075 } 3076 break; 3077 } 3078 continue; 3079 } 3080 3081 if (Code == llvm::bitc::END_BLOCK) { 3082 if (Stream.ReadBlockEnd()) { 3083 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 3084 return std::string(); 3085 } 3086 continue; 3087 } 3088 3089 if (Code == llvm::bitc::DEFINE_ABBREV) { 3090 Stream.ReadAbbrevRecord(); 3091 continue; 3092 } 3093 3094 Record.clear(); 3095 const char *BlobStart = 0; 3096 unsigned BlobLen = 0; 3097 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 3098 == ORIGINAL_FILE_NAME) 3099 return std::string(BlobStart, BlobLen); 3100 } 3101 3102 return std::string(); 3103} 3104 3105/// \brief Parse the record that corresponds to a LangOptions data 3106/// structure. 3107/// 3108/// This routine parses the language options from the AST file and then gives 3109/// them to the AST listener if one is set. 3110/// 3111/// \returns true if the listener deems the file unacceptable, false otherwise. 3112bool ASTReader::ParseLanguageOptions( 3113 const SmallVectorImpl<uint64_t> &Record) { 3114 if (Listener) { 3115 LangOptions LangOpts; 3116 3117 #define PARSE_LANGOPT(Option) \ 3118 LangOpts.Option = Record[Idx]; \ 3119 ++Idx 3120 3121 unsigned Idx = 0; 3122 PARSE_LANGOPT(Trigraphs); 3123 PARSE_LANGOPT(BCPLComment); 3124 PARSE_LANGOPT(DollarIdents); 3125 PARSE_LANGOPT(AsmPreprocessor); 3126 PARSE_LANGOPT(GNUMode); 3127 PARSE_LANGOPT(GNUKeywords); 3128 PARSE_LANGOPT(ImplicitInt); 3129 PARSE_LANGOPT(Digraphs); 3130 PARSE_LANGOPT(HexFloats); 3131 PARSE_LANGOPT(C99); 3132 PARSE_LANGOPT(C1X); 3133 PARSE_LANGOPT(Microsoft); 3134 PARSE_LANGOPT(CPlusPlus); 3135 PARSE_LANGOPT(CPlusPlus0x); 3136 PARSE_LANGOPT(CXXOperatorNames); 3137 PARSE_LANGOPT(ObjC1); 3138 PARSE_LANGOPT(ObjC2); 3139 PARSE_LANGOPT(ObjCNonFragileABI); 3140 PARSE_LANGOPT(ObjCNonFragileABI2); 3141 PARSE_LANGOPT(AppleKext); 3142 PARSE_LANGOPT(ObjCDefaultSynthProperties); 3143 PARSE_LANGOPT(ObjCInferRelatedResultType); 3144 PARSE_LANGOPT(NoConstantCFStrings); 3145 PARSE_LANGOPT(PascalStrings); 3146 PARSE_LANGOPT(WritableStrings); 3147 PARSE_LANGOPT(LaxVectorConversions); 3148 PARSE_LANGOPT(AltiVec); 3149 PARSE_LANGOPT(Exceptions); 3150 PARSE_LANGOPT(ObjCExceptions); 3151 PARSE_LANGOPT(CXXExceptions); 3152 PARSE_LANGOPT(SjLjExceptions); 3153 PARSE_LANGOPT(MSBitfields); 3154 PARSE_LANGOPT(NeXTRuntime); 3155 PARSE_LANGOPT(Freestanding); 3156 PARSE_LANGOPT(NoBuiltin); 3157 PARSE_LANGOPT(ThreadsafeStatics); 3158 PARSE_LANGOPT(POSIXThreads); 3159 PARSE_LANGOPT(Blocks); 3160 PARSE_LANGOPT(EmitAllDecls); 3161 PARSE_LANGOPT(MathErrno); 3162 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 3163 Record[Idx++]); 3164 PARSE_LANGOPT(HeinousExtensions); 3165 PARSE_LANGOPT(Optimize); 3166 PARSE_LANGOPT(OptimizeSize); 3167 PARSE_LANGOPT(Static); 3168 PARSE_LANGOPT(PICLevel); 3169 PARSE_LANGOPT(GNUInline); 3170 PARSE_LANGOPT(NoInline); 3171 PARSE_LANGOPT(Deprecated); 3172 PARSE_LANGOPT(AccessControl); 3173 PARSE_LANGOPT(CharIsSigned); 3174 PARSE_LANGOPT(ShortWChar); 3175 PARSE_LANGOPT(ShortEnums); 3176 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 3177 LangOpts.setVisibilityMode((Visibility)Record[Idx++]); 3178 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 3179 Record[Idx++]); 3180 PARSE_LANGOPT(InstantiationDepth); 3181 PARSE_LANGOPT(OpenCL); 3182 PARSE_LANGOPT(CUDA); 3183 PARSE_LANGOPT(CatchUndefined); 3184 PARSE_LANGOPT(DefaultFPContract); 3185 PARSE_LANGOPT(ElideConstructors); 3186 PARSE_LANGOPT(SpellChecking); 3187 PARSE_LANGOPT(MRTD); 3188 PARSE_LANGOPT(ObjCAutoRefCount); 3189 PARSE_LANGOPT(ObjCInferRelatedReturnType); 3190 #undef PARSE_LANGOPT 3191 3192 return Listener->ReadLanguageOptions(LangOpts); 3193 } 3194 3195 return false; 3196} 3197 3198void ASTReader::ReadPreprocessedEntities() { 3199 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3200 Module &F = *(*I); 3201 if (!F.PreprocessorDetailCursor.getBitStreamReader()) 3202 continue; 3203 3204 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor); 3205 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset); 3206 while (LoadPreprocessedEntity(F)) { } 3207 } 3208} 3209 3210PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) { 3211 RecordLocation Loc = getLocalBitOffset(Offset); 3212 3213 // Keep track of where we are in the stream, then jump back there 3214 // after reading this entity. 3215 SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor); 3216 Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset); 3217 return LoadPreprocessedEntity(*Loc.F); 3218} 3219 3220HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3221 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3222 Module &F = *(*I); 3223 3224 HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(), 3225 F.HeaderFileFrameworkStrings, 3226 FE->getName()); 3227 3228 HeaderFileInfoLookupTable *Table 3229 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable); 3230 if (!Table) 3231 continue; 3232 3233 // Look in the on-disk hash table for an entry for this file name. 3234 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(), 3235 &Trait); 3236 if (Pos == Table->end()) 3237 continue; 3238 3239 HeaderFileInfo HFI = *Pos; 3240 if (Listener) 3241 Listener->ReadHeaderFileInfo(HFI, FE->getUID()); 3242 3243 return HFI; 3244 } 3245 3246 return HeaderFileInfo(); 3247} 3248 3249void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) { 3250 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3251 Module &F = *(*I); 3252 unsigned Idx = 0; 3253 while (Idx < F.PragmaDiagMappings.size()) { 3254 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3255 while (1) { 3256 assert(Idx < F.PragmaDiagMappings.size() && 3257 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3258 if (Idx >= F.PragmaDiagMappings.size()) { 3259 break; // Something is messed up but at least avoid infinite loop in 3260 // release build. 3261 } 3262 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3263 if (DiagID == (unsigned)-1) { 3264 break; // no more diag/map pairs for this location. 3265 } 3266 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3267 Diag.setDiagnosticMapping(DiagID, Map, Loc); 3268 } 3269 } 3270 } 3271} 3272 3273/// \brief Get the correct cursor and offset for loading a type. 3274ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3275 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3276 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3277 Module *M = I->second; 3278 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3279} 3280 3281/// \brief Read and return the type with the given index.. 3282/// 3283/// The index is the type ID, shifted and minus the number of predefs. This 3284/// routine actually reads the record corresponding to the type at the given 3285/// location. It is a helper routine for GetType, which deals with reading type 3286/// IDs. 3287QualType ASTReader::readTypeRecord(unsigned Index) { 3288 RecordLocation Loc = TypeCursorForIndex(Index); 3289 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3290 3291 // Keep track of where we are in the stream, then jump back there 3292 // after reading this type. 3293 SavedStreamPosition SavedPosition(DeclsCursor); 3294 3295 ReadingKindTracker ReadingKind(Read_Type, *this); 3296 3297 // Note that we are loading a type record. 3298 Deserializing AType(this); 3299 3300 unsigned Idx = 0; 3301 DeclsCursor.JumpToBit(Loc.Offset); 3302 RecordData Record; 3303 unsigned Code = DeclsCursor.ReadCode(); 3304 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3305 case TYPE_EXT_QUAL: { 3306 if (Record.size() != 2) { 3307 Error("Incorrect encoding of extended qualifier type"); 3308 return QualType(); 3309 } 3310 QualType Base = readType(*Loc.F, Record, Idx); 3311 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3312 return Context->getQualifiedType(Base, Quals); 3313 } 3314 3315 case TYPE_COMPLEX: { 3316 if (Record.size() != 1) { 3317 Error("Incorrect encoding of complex type"); 3318 return QualType(); 3319 } 3320 QualType ElemType = readType(*Loc.F, Record, Idx); 3321 return Context->getComplexType(ElemType); 3322 } 3323 3324 case TYPE_POINTER: { 3325 if (Record.size() != 1) { 3326 Error("Incorrect encoding of pointer type"); 3327 return QualType(); 3328 } 3329 QualType PointeeType = readType(*Loc.F, Record, Idx); 3330 return Context->getPointerType(PointeeType); 3331 } 3332 3333 case TYPE_BLOCK_POINTER: { 3334 if (Record.size() != 1) { 3335 Error("Incorrect encoding of block pointer type"); 3336 return QualType(); 3337 } 3338 QualType PointeeType = readType(*Loc.F, Record, Idx); 3339 return Context->getBlockPointerType(PointeeType); 3340 } 3341 3342 case TYPE_LVALUE_REFERENCE: { 3343 if (Record.size() != 2) { 3344 Error("Incorrect encoding of lvalue reference type"); 3345 return QualType(); 3346 } 3347 QualType PointeeType = readType(*Loc.F, Record, Idx); 3348 return Context->getLValueReferenceType(PointeeType, Record[1]); 3349 } 3350 3351 case TYPE_RVALUE_REFERENCE: { 3352 if (Record.size() != 1) { 3353 Error("Incorrect encoding of rvalue reference type"); 3354 return QualType(); 3355 } 3356 QualType PointeeType = readType(*Loc.F, Record, Idx); 3357 return Context->getRValueReferenceType(PointeeType); 3358 } 3359 3360 case TYPE_MEMBER_POINTER: { 3361 if (Record.size() != 2) { 3362 Error("Incorrect encoding of member pointer type"); 3363 return QualType(); 3364 } 3365 QualType PointeeType = readType(*Loc.F, Record, Idx); 3366 QualType ClassType = readType(*Loc.F, Record, Idx); 3367 if (PointeeType.isNull() || ClassType.isNull()) 3368 return QualType(); 3369 3370 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3371 } 3372 3373 case TYPE_CONSTANT_ARRAY: { 3374 QualType ElementType = readType(*Loc.F, Record, Idx); 3375 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3376 unsigned IndexTypeQuals = Record[2]; 3377 unsigned Idx = 3; 3378 llvm::APInt Size = ReadAPInt(Record, Idx); 3379 return Context->getConstantArrayType(ElementType, Size, 3380 ASM, IndexTypeQuals); 3381 } 3382 3383 case TYPE_INCOMPLETE_ARRAY: { 3384 QualType ElementType = readType(*Loc.F, Record, Idx); 3385 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3386 unsigned IndexTypeQuals = Record[2]; 3387 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3388 } 3389 3390 case TYPE_VARIABLE_ARRAY: { 3391 QualType ElementType = readType(*Loc.F, Record, Idx); 3392 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3393 unsigned IndexTypeQuals = Record[2]; 3394 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3395 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3396 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3397 ASM, IndexTypeQuals, 3398 SourceRange(LBLoc, RBLoc)); 3399 } 3400 3401 case TYPE_VECTOR: { 3402 if (Record.size() != 3) { 3403 Error("incorrect encoding of vector type in AST file"); 3404 return QualType(); 3405 } 3406 3407 QualType ElementType = readType(*Loc.F, Record, Idx); 3408 unsigned NumElements = Record[1]; 3409 unsigned VecKind = Record[2]; 3410 return Context->getVectorType(ElementType, NumElements, 3411 (VectorType::VectorKind)VecKind); 3412 } 3413 3414 case TYPE_EXT_VECTOR: { 3415 if (Record.size() != 3) { 3416 Error("incorrect encoding of extended vector type in AST file"); 3417 return QualType(); 3418 } 3419 3420 QualType ElementType = readType(*Loc.F, Record, Idx); 3421 unsigned NumElements = Record[1]; 3422 return Context->getExtVectorType(ElementType, NumElements); 3423 } 3424 3425 case TYPE_FUNCTION_NO_PROTO: { 3426 if (Record.size() != 6) { 3427 Error("incorrect encoding of no-proto function type"); 3428 return QualType(); 3429 } 3430 QualType ResultType = readType(*Loc.F, Record, Idx); 3431 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3432 (CallingConv)Record[4], Record[5]); 3433 return Context->getFunctionNoProtoType(ResultType, Info); 3434 } 3435 3436 case TYPE_FUNCTION_PROTO: { 3437 QualType ResultType = readType(*Loc.F, Record, Idx); 3438 3439 FunctionProtoType::ExtProtoInfo EPI; 3440 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3441 /*hasregparm*/ Record[2], 3442 /*regparm*/ Record[3], 3443 static_cast<CallingConv>(Record[4]), 3444 /*produces*/ Record[5]); 3445 3446 unsigned Idx = 6; 3447 unsigned NumParams = Record[Idx++]; 3448 SmallVector<QualType, 16> ParamTypes; 3449 for (unsigned I = 0; I != NumParams; ++I) 3450 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3451 3452 EPI.Variadic = Record[Idx++]; 3453 EPI.TypeQuals = Record[Idx++]; 3454 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3455 ExceptionSpecificationType EST = 3456 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3457 EPI.ExceptionSpecType = EST; 3458 if (EST == EST_Dynamic) { 3459 EPI.NumExceptions = Record[Idx++]; 3460 SmallVector<QualType, 2> Exceptions; 3461 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3462 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3463 EPI.Exceptions = Exceptions.data(); 3464 } else if (EST == EST_ComputedNoexcept) { 3465 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3466 } 3467 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 3468 EPI); 3469 } 3470 3471 case TYPE_UNRESOLVED_USING: { 3472 unsigned Idx = 0; 3473 return Context->getTypeDeclType( 3474 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3475 } 3476 3477 case TYPE_TYPEDEF: { 3478 if (Record.size() != 2) { 3479 Error("incorrect encoding of typedef type"); 3480 return QualType(); 3481 } 3482 unsigned Idx = 0; 3483 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3484 QualType Canonical = readType(*Loc.F, Record, Idx); 3485 if (!Canonical.isNull()) 3486 Canonical = Context->getCanonicalType(Canonical); 3487 return Context->getTypedefType(Decl, Canonical); 3488 } 3489 3490 case TYPE_TYPEOF_EXPR: 3491 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 3492 3493 case TYPE_TYPEOF: { 3494 if (Record.size() != 1) { 3495 Error("incorrect encoding of typeof(type) in AST file"); 3496 return QualType(); 3497 } 3498 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3499 return Context->getTypeOfType(UnderlyingType); 3500 } 3501 3502 case TYPE_DECLTYPE: 3503 return Context->getDecltypeType(ReadExpr(*Loc.F)); 3504 3505 case TYPE_UNARY_TRANSFORM: { 3506 QualType BaseType = readType(*Loc.F, Record, Idx); 3507 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3508 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3509 return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind); 3510 } 3511 3512 case TYPE_AUTO: 3513 return Context->getAutoType(readType(*Loc.F, Record, Idx)); 3514 3515 case TYPE_RECORD: { 3516 if (Record.size() != 2) { 3517 Error("incorrect encoding of record type"); 3518 return QualType(); 3519 } 3520 unsigned Idx = 0; 3521 bool IsDependent = Record[Idx++]; 3522 QualType T 3523 = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3524 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3525 return T; 3526 } 3527 3528 case TYPE_ENUM: { 3529 if (Record.size() != 2) { 3530 Error("incorrect encoding of enum type"); 3531 return QualType(); 3532 } 3533 unsigned Idx = 0; 3534 bool IsDependent = Record[Idx++]; 3535 QualType T 3536 = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3537 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3538 return T; 3539 } 3540 3541 case TYPE_ATTRIBUTED: { 3542 if (Record.size() != 3) { 3543 Error("incorrect encoding of attributed type"); 3544 return QualType(); 3545 } 3546 QualType modifiedType = readType(*Loc.F, Record, Idx); 3547 QualType equivalentType = readType(*Loc.F, Record, Idx); 3548 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3549 return Context->getAttributedType(kind, modifiedType, equivalentType); 3550 } 3551 3552 case TYPE_PAREN: { 3553 if (Record.size() != 1) { 3554 Error("incorrect encoding of paren type"); 3555 return QualType(); 3556 } 3557 QualType InnerType = readType(*Loc.F, Record, Idx); 3558 return Context->getParenType(InnerType); 3559 } 3560 3561 case TYPE_PACK_EXPANSION: { 3562 if (Record.size() != 2) { 3563 Error("incorrect encoding of pack expansion type"); 3564 return QualType(); 3565 } 3566 QualType Pattern = readType(*Loc.F, Record, Idx); 3567 if (Pattern.isNull()) 3568 return QualType(); 3569 llvm::Optional<unsigned> NumExpansions; 3570 if (Record[1]) 3571 NumExpansions = Record[1] - 1; 3572 return Context->getPackExpansionType(Pattern, NumExpansions); 3573 } 3574 3575 case TYPE_ELABORATED: { 3576 unsigned Idx = 0; 3577 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3578 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3579 QualType NamedType = readType(*Loc.F, Record, Idx); 3580 return Context->getElaboratedType(Keyword, NNS, NamedType); 3581 } 3582 3583 case TYPE_OBJC_INTERFACE: { 3584 unsigned Idx = 0; 3585 ObjCInterfaceDecl *ItfD 3586 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3587 return Context->getObjCInterfaceType(ItfD); 3588 } 3589 3590 case TYPE_OBJC_OBJECT: { 3591 unsigned Idx = 0; 3592 QualType Base = readType(*Loc.F, Record, Idx); 3593 unsigned NumProtos = Record[Idx++]; 3594 SmallVector<ObjCProtocolDecl*, 4> Protos; 3595 for (unsigned I = 0; I != NumProtos; ++I) 3596 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3597 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 3598 } 3599 3600 case TYPE_OBJC_OBJECT_POINTER: { 3601 unsigned Idx = 0; 3602 QualType Pointee = readType(*Loc.F, Record, Idx); 3603 return Context->getObjCObjectPointerType(Pointee); 3604 } 3605 3606 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3607 unsigned Idx = 0; 3608 QualType Parm = readType(*Loc.F, Record, Idx); 3609 QualType Replacement = readType(*Loc.F, Record, Idx); 3610 return 3611 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3612 Replacement); 3613 } 3614 3615 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3616 unsigned Idx = 0; 3617 QualType Parm = readType(*Loc.F, Record, Idx); 3618 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3619 return Context->getSubstTemplateTypeParmPackType( 3620 cast<TemplateTypeParmType>(Parm), 3621 ArgPack); 3622 } 3623 3624 case TYPE_INJECTED_CLASS_NAME: { 3625 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3626 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3627 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3628 // for AST reading, too much interdependencies. 3629 return 3630 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3631 } 3632 3633 case TYPE_TEMPLATE_TYPE_PARM: { 3634 unsigned Idx = 0; 3635 unsigned Depth = Record[Idx++]; 3636 unsigned Index = Record[Idx++]; 3637 bool Pack = Record[Idx++]; 3638 TemplateTypeParmDecl *D 3639 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3640 return Context->getTemplateTypeParmType(Depth, Index, Pack, D); 3641 } 3642 3643 case TYPE_DEPENDENT_NAME: { 3644 unsigned Idx = 0; 3645 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3646 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3647 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3648 QualType Canon = readType(*Loc.F, Record, Idx); 3649 if (!Canon.isNull()) 3650 Canon = Context->getCanonicalType(Canon); 3651 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 3652 } 3653 3654 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3655 unsigned Idx = 0; 3656 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3657 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3658 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3659 unsigned NumArgs = Record[Idx++]; 3660 SmallVector<TemplateArgument, 8> Args; 3661 Args.reserve(NumArgs); 3662 while (NumArgs--) 3663 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3664 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 3665 Args.size(), Args.data()); 3666 } 3667 3668 case TYPE_DEPENDENT_SIZED_ARRAY: { 3669 unsigned Idx = 0; 3670 3671 // ArrayType 3672 QualType ElementType = readType(*Loc.F, Record, Idx); 3673 ArrayType::ArraySizeModifier ASM 3674 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3675 unsigned IndexTypeQuals = Record[Idx++]; 3676 3677 // DependentSizedArrayType 3678 Expr *NumElts = ReadExpr(*Loc.F); 3679 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3680 3681 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 3682 IndexTypeQuals, Brackets); 3683 } 3684 3685 case TYPE_TEMPLATE_SPECIALIZATION: { 3686 unsigned Idx = 0; 3687 bool IsDependent = Record[Idx++]; 3688 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3689 SmallVector<TemplateArgument, 8> Args; 3690 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3691 QualType Underlying = readType(*Loc.F, Record, Idx); 3692 QualType T; 3693 if (Underlying.isNull()) 3694 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 3695 Args.size()); 3696 else 3697 T = Context->getTemplateSpecializationType(Name, Args.data(), 3698 Args.size(), Underlying); 3699 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3700 return T; 3701 } 3702 } 3703 // Suppress a GCC warning 3704 return QualType(); 3705} 3706 3707class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3708 ASTReader &Reader; 3709 Module &F; 3710 llvm::BitstreamCursor &DeclsCursor; 3711 const ASTReader::RecordData &Record; 3712 unsigned &Idx; 3713 3714 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3715 unsigned &I) { 3716 return Reader.ReadSourceLocation(F, R, I); 3717 } 3718 3719 template<typename T> 3720 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 3721 return Reader.ReadDeclAs<T>(F, Record, Idx); 3722 } 3723 3724public: 3725 TypeLocReader(ASTReader &Reader, Module &F, 3726 const ASTReader::RecordData &Record, unsigned &Idx) 3727 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3728 { } 3729 3730 // We want compile-time assurance that we've enumerated all of 3731 // these, so unfortunately we have to declare them first, then 3732 // define them out-of-line. 3733#define ABSTRACT_TYPELOC(CLASS, PARENT) 3734#define TYPELOC(CLASS, PARENT) \ 3735 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3736#include "clang/AST/TypeLocNodes.def" 3737 3738 void VisitFunctionTypeLoc(FunctionTypeLoc); 3739 void VisitArrayTypeLoc(ArrayTypeLoc); 3740}; 3741 3742void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3743 // nothing to do 3744} 3745void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3746 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3747 if (TL.needsExtraLocalData()) { 3748 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3749 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3750 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3751 TL.setModeAttr(Record[Idx++]); 3752 } 3753} 3754void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3755 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3756} 3757void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3758 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3759} 3760void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3761 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3762} 3763void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3764 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3765} 3766void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3767 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3768} 3769void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3770 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3771 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3772} 3773void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3774 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3775 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3776 if (Record[Idx++]) 3777 TL.setSizeExpr(Reader.ReadExpr(F)); 3778 else 3779 TL.setSizeExpr(0); 3780} 3781void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3782 VisitArrayTypeLoc(TL); 3783} 3784void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3785 VisitArrayTypeLoc(TL); 3786} 3787void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3788 VisitArrayTypeLoc(TL); 3789} 3790void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3791 DependentSizedArrayTypeLoc TL) { 3792 VisitArrayTypeLoc(TL); 3793} 3794void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3795 DependentSizedExtVectorTypeLoc TL) { 3796 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3797} 3798void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3799 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3800} 3801void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3802 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3803} 3804void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3805 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3806 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3807 TL.setTrailingReturn(Record[Idx++]); 3808 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3809 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 3810 } 3811} 3812void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3813 VisitFunctionTypeLoc(TL); 3814} 3815void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3816 VisitFunctionTypeLoc(TL); 3817} 3818void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3819 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3820} 3821void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3822 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3823} 3824void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3825 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3826 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3827 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3828} 3829void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3830 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3831 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3832 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3833 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3834} 3835void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3836 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3837} 3838void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 3839 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3840 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3841 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3842 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3843} 3844void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3845 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3846} 3847void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3848 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3849} 3850void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3851 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3852} 3853void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3854 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3855 if (TL.hasAttrOperand()) { 3856 SourceRange range; 3857 range.setBegin(ReadSourceLocation(Record, Idx)); 3858 range.setEnd(ReadSourceLocation(Record, Idx)); 3859 TL.setAttrOperandParensRange(range); 3860 } 3861 if (TL.hasAttrExprOperand()) { 3862 if (Record[Idx++]) 3863 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3864 else 3865 TL.setAttrExprOperand(0); 3866 } else if (TL.hasAttrEnumOperand()) 3867 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3868} 3869void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3870 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3871} 3872void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3873 SubstTemplateTypeParmTypeLoc TL) { 3874 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3875} 3876void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3877 SubstTemplateTypeParmPackTypeLoc TL) { 3878 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3879} 3880void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3881 TemplateSpecializationTypeLoc TL) { 3882 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3883 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3884 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3885 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3886 TL.setArgLocInfo(i, 3887 Reader.GetTemplateArgumentLocInfo(F, 3888 TL.getTypePtr()->getArg(i).getKind(), 3889 Record, Idx)); 3890} 3891void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3892 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3893 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3894} 3895void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3896 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3897 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3898} 3899void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3900 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3901} 3902void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3903 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3904 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3905 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3906} 3907void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3908 DependentTemplateSpecializationTypeLoc TL) { 3909 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3910 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3911 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3912 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3913 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3914 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3915 TL.setArgLocInfo(I, 3916 Reader.GetTemplateArgumentLocInfo(F, 3917 TL.getTypePtr()->getArg(I).getKind(), 3918 Record, Idx)); 3919} 3920void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3921 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3922} 3923void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3924 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3925} 3926void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3927 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3928 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3929 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3930 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3931 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3932} 3933void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3934 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3935} 3936 3937TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F, 3938 const RecordData &Record, 3939 unsigned &Idx) { 3940 QualType InfoTy = readType(F, Record, Idx); 3941 if (InfoTy.isNull()) 3942 return 0; 3943 3944 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3945 TypeLocReader TLR(*this, F, Record, Idx); 3946 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3947 TLR.Visit(TL); 3948 return TInfo; 3949} 3950 3951QualType ASTReader::GetType(TypeID ID) { 3952 unsigned FastQuals = ID & Qualifiers::FastMask; 3953 unsigned Index = ID >> Qualifiers::FastWidth; 3954 3955 if (Index < NUM_PREDEF_TYPE_IDS) { 3956 QualType T; 3957 switch ((PredefinedTypeIDs)Index) { 3958 case PREDEF_TYPE_NULL_ID: return QualType(); 3959 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3960 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3961 3962 case PREDEF_TYPE_CHAR_U_ID: 3963 case PREDEF_TYPE_CHAR_S_ID: 3964 // FIXME: Check that the signedness of CharTy is correct! 3965 T = Context->CharTy; 3966 break; 3967 3968 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3969 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3970 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3971 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3972 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3973 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3974 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3975 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3976 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3977 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3978 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3979 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3980 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3981 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3982 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3983 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3984 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3985 case PREDEF_TYPE_BOUND_MEMBER: T = Context->BoundMemberTy; break; 3986 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3987 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break; 3988 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3989 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3990 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3991 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3992 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3993 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 3994 } 3995 3996 assert(!T.isNull() && "Unknown predefined type"); 3997 return T.withFastQualifiers(FastQuals); 3998 } 3999 4000 Index -= NUM_PREDEF_TYPE_IDS; 4001 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4002 if (TypesLoaded[Index].isNull()) { 4003 TypesLoaded[Index] = readTypeRecord(Index); 4004 if (TypesLoaded[Index].isNull()) 4005 return QualType(); 4006 4007 TypesLoaded[Index]->setFromAST(); 4008 if (DeserializationListener) 4009 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4010 TypesLoaded[Index]); 4011 } 4012 4013 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4014} 4015 4016QualType ASTReader::getLocalType(Module &F, unsigned LocalID) { 4017 return GetType(getGlobalTypeID(F, LocalID)); 4018} 4019 4020serialization::TypeID 4021ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const { 4022 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4023 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4024 4025 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4026 return LocalID; 4027 4028 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4029 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4030 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4031 4032 unsigned GlobalIndex = LocalIndex + I->second; 4033 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4034} 4035 4036TemplateArgumentLocInfo 4037ASTReader::GetTemplateArgumentLocInfo(Module &F, 4038 TemplateArgument::ArgKind Kind, 4039 const RecordData &Record, 4040 unsigned &Index) { 4041 switch (Kind) { 4042 case TemplateArgument::Expression: 4043 return ReadExpr(F); 4044 case TemplateArgument::Type: 4045 return GetTypeSourceInfo(F, Record, Index); 4046 case TemplateArgument::Template: { 4047 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4048 Index); 4049 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4050 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4051 SourceLocation()); 4052 } 4053 case TemplateArgument::TemplateExpansion: { 4054 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4055 Index); 4056 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4057 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4058 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4059 EllipsisLoc); 4060 } 4061 case TemplateArgument::Null: 4062 case TemplateArgument::Integral: 4063 case TemplateArgument::Declaration: 4064 case TemplateArgument::Pack: 4065 return TemplateArgumentLocInfo(); 4066 } 4067 llvm_unreachable("unexpected template argument loc"); 4068 return TemplateArgumentLocInfo(); 4069} 4070 4071TemplateArgumentLoc 4072ASTReader::ReadTemplateArgumentLoc(Module &F, 4073 const RecordData &Record, unsigned &Index) { 4074 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4075 4076 if (Arg.getKind() == TemplateArgument::Expression) { 4077 if (Record[Index++]) // bool InfoHasSameExpr. 4078 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4079 } 4080 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4081 Record, Index)); 4082} 4083 4084Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4085 return GetDecl(ID); 4086} 4087 4088uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record, 4089 unsigned &Idx){ 4090 if (Idx >= Record.size()) 4091 return 0; 4092 4093 unsigned LocalID = Record[Idx++]; 4094 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 4095} 4096 4097CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4098 RecordLocation Loc = getLocalBitOffset(Offset); 4099 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4100 SavedStreamPosition SavedPosition(Cursor); 4101 Cursor.JumpToBit(Loc.Offset); 4102 ReadingKindTracker ReadingKind(Read_Decl, *this); 4103 RecordData Record; 4104 unsigned Code = Cursor.ReadCode(); 4105 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4106 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4107 Error("Malformed AST file: missing C++ base specifiers"); 4108 return 0; 4109 } 4110 4111 unsigned Idx = 0; 4112 unsigned NumBases = Record[Idx++]; 4113 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4114 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4115 for (unsigned I = 0; I != NumBases; ++I) 4116 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4117 return Bases; 4118} 4119 4120TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 4121 // FIXME: This routine might not even make sense when we're loading multiple 4122 // unrelated AST files, since we'll have to merge the translation units 4123 // somehow. 4124 unsigned TranslationUnitID = (*(ModuleMgr.end() - 1))->BaseDeclID + 1; 4125 if (!DeclsLoaded[TranslationUnitID - 1]) { 4126 ReadDeclRecord(TranslationUnitID); 4127 if (DeserializationListener) 4128 DeserializationListener->DeclRead(TranslationUnitID, 4129 DeclsLoaded[TranslationUnitID - 1]); 4130 } 4131 4132 return cast<TranslationUnitDecl>(DeclsLoaded[TranslationUnitID - 1]); 4133} 4134 4135serialization::DeclID 4136ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const { 4137 if (LocalID < NUM_PREDEF_DECL_IDS) 4138 return LocalID; 4139 4140 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4141 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4142 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4143 4144 return LocalID + I->second; 4145} 4146 4147Decl *ASTReader::GetDecl(DeclID ID) { 4148 if (ID < NUM_PREDEF_DECL_IDS) { 4149 switch ((PredefinedDeclIDs)ID) { 4150 case serialization::PREDEF_DECL_NULL_ID: 4151 return 0; 4152 } 4153 4154 return 0; 4155 } 4156 4157 if (ID > DeclsLoaded.size()) { 4158 Error("declaration ID out-of-range for AST file"); 4159 return 0; 4160 } 4161 4162 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4163 if (!DeclsLoaded[Index]) { 4164 ReadDeclRecord(ID); 4165 if (DeserializationListener) 4166 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4167 } 4168 4169 return DeclsLoaded[Index]; 4170} 4171 4172serialization::DeclID ASTReader::ReadDeclID(Module &F, 4173 const RecordData &Record, 4174 unsigned &Idx) { 4175 if (Idx >= Record.size()) { 4176 Error("Corrupted AST file"); 4177 return 0; 4178 } 4179 4180 return getGlobalDeclID(F, Record[Idx++]); 4181} 4182 4183/// \brief Resolve the offset of a statement into a statement. 4184/// 4185/// This operation will read a new statement from the external 4186/// source each time it is called, and is meant to be used via a 4187/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4188Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4189 // Switch case IDs are per Decl. 4190 ClearSwitchCaseIDs(); 4191 4192 // Offset here is a global offset across the entire chain. 4193 RecordLocation Loc = getLocalBitOffset(Offset); 4194 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4195 return ReadStmtFromStream(*Loc.F); 4196} 4197 4198ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4199 bool (*isKindWeWant)(Decl::Kind), 4200 SmallVectorImpl<Decl*> &Decls) { 4201 // There might be lexical decls in multiple parts of the chain, for the TU 4202 // at least. 4203 // DeclContextOffsets might reallocate as we load additional decls below, 4204 // so make a copy of the vector. 4205 DeclContextInfos Infos = DeclContextOffsets[DC]; 4206 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4207 I != E; ++I) { 4208 // IDs can be 0 if this context doesn't contain declarations. 4209 if (!I->LexicalDecls) 4210 continue; 4211 4212 // Load all of the declaration IDs 4213 for (const KindDeclIDPair *ID = I->LexicalDecls, 4214 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 4215 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 4216 continue; 4217 4218 Decl *D = GetLocalDecl(*I->F, ID->second); 4219 assert(D && "Null decl in lexical decls"); 4220 Decls.push_back(D); 4221 } 4222 } 4223 4224 ++NumLexicalDeclContextsRead; 4225 return ELR_Success; 4226} 4227 4228DeclContext::lookup_result 4229ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4230 DeclarationName Name) { 4231 assert(DC->hasExternalVisibleStorage() && 4232 "DeclContext has no visible decls in storage"); 4233 if (!Name) 4234 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4235 DeclContext::lookup_iterator(0)); 4236 4237 SmallVector<NamedDecl *, 64> Decls; 4238 // There might be visible decls in multiple parts of the chain, for the TU 4239 // and namespaces. For any given name, the last available results replace 4240 // all earlier ones. For this reason, we walk in reverse. 4241 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4242 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 4243 I != E; ++I) { 4244 if (!I->NameLookupTableData) 4245 continue; 4246 4247 ASTDeclContextNameLookupTable *LookupTable = 4248 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4249 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 4250 if (Pos == LookupTable->end()) 4251 continue; 4252 4253 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4254 for (; Data.first != Data.second; ++Data.first) { 4255 NamedDecl *ND = GetLocalDeclAs<NamedDecl>(*I->F, *Data.first); 4256 if (!ND) 4257 continue; 4258 4259 if (ND->getDeclName() != Name) { 4260 assert(!Name.getCXXNameType().isNull() && 4261 "Name mismatch without a type"); 4262 continue; 4263 } 4264 4265 Decls.push_back(ND); 4266 } 4267 4268 // If we rejected all of the declarations we found, e.g., because the 4269 // name didn't actually match, continue looking through DeclContexts. 4270 if (Decls.empty()) 4271 continue; 4272 4273 break; 4274 } 4275 4276 ++NumVisibleDeclContextsRead; 4277 4278 SetExternalVisibleDeclsForName(DC, Name, Decls); 4279 return const_cast<DeclContext*>(DC)->lookup(Name); 4280} 4281 4282void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 4283 assert(DC->hasExternalVisibleStorage() && 4284 "DeclContext has no visible decls in storage"); 4285 4286 SmallVector<NamedDecl *, 64> Decls; 4287 // There might be visible decls in multiple parts of the chain, for the TU 4288 // and namespaces. 4289 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4290 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4291 I != E; ++I) { 4292 if (!I->NameLookupTableData) 4293 continue; 4294 4295 ASTDeclContextNameLookupTable *LookupTable = 4296 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4297 for (ASTDeclContextNameLookupTable::item_iterator 4298 ItemI = LookupTable->item_begin(), 4299 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 4300 ASTDeclContextNameLookupTable::item_iterator::value_type Val 4301 = *ItemI; 4302 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 4303 Decls.clear(); 4304 for (; Data.first != Data.second; ++Data.first) 4305 Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first)); 4306 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 4307 } 4308 } 4309} 4310 4311void ASTReader::PassInterestingDeclsToConsumer() { 4312 assert(Consumer); 4313 while (!InterestingDecls.empty()) { 4314 DeclGroupRef DG(InterestingDecls.front()); 4315 InterestingDecls.pop_front(); 4316 Consumer->HandleInterestingDecl(DG); 4317 } 4318} 4319 4320void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4321 this->Consumer = Consumer; 4322 4323 if (!Consumer) 4324 return; 4325 4326 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4327 // Force deserialization of this decl, which will cause it to be queued for 4328 // passing to the consumer. 4329 GetDecl(ExternalDefinitions[I]); 4330 } 4331 4332 PassInterestingDeclsToConsumer(); 4333} 4334 4335void ASTReader::PrintStats() { 4336 std::fprintf(stderr, "*** AST File Statistics:\n"); 4337 4338 unsigned NumTypesLoaded 4339 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4340 QualType()); 4341 unsigned NumDeclsLoaded 4342 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4343 (Decl *)0); 4344 unsigned NumIdentifiersLoaded 4345 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4346 IdentifiersLoaded.end(), 4347 (IdentifierInfo *)0); 4348 unsigned NumSelectorsLoaded 4349 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4350 SelectorsLoaded.end(), 4351 Selector()); 4352 4353 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4354 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4355 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4356 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4357 NumSLocEntriesRead, TotalNumSLocEntries, 4358 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4359 if (!TypesLoaded.empty()) 4360 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4361 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4362 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4363 if (!DeclsLoaded.empty()) 4364 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4365 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4366 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4367 if (!IdentifiersLoaded.empty()) 4368 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4369 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4370 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4371 if (!SelectorsLoaded.empty()) 4372 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4373 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4374 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4375 if (TotalNumStatements) 4376 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4377 NumStatementsRead, TotalNumStatements, 4378 ((float)NumStatementsRead/TotalNumStatements * 100)); 4379 if (TotalNumMacros) 4380 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4381 NumMacrosRead, TotalNumMacros, 4382 ((float)NumMacrosRead/TotalNumMacros * 100)); 4383 if (TotalLexicalDeclContexts) 4384 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4385 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4386 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4387 * 100)); 4388 if (TotalVisibleDeclContexts) 4389 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4390 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4391 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4392 * 100)); 4393 if (TotalNumMethodPoolEntries) { 4394 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4395 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4396 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4397 * 100)); 4398 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4399 } 4400 std::fprintf(stderr, "\n"); 4401 dump(); 4402 std::fprintf(stderr, "\n"); 4403} 4404 4405template<typename Key, typename Module, unsigned InitialCapacity> 4406static void 4407dumpModuleIDMap(StringRef Name, 4408 const ContinuousRangeMap<Key, Module *, 4409 InitialCapacity> &Map) { 4410 if (Map.begin() == Map.end()) 4411 return; 4412 4413 typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType; 4414 llvm::errs() << Name << ":\n"; 4415 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4416 I != IEnd; ++I) { 4417 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4418 << "\n"; 4419 } 4420} 4421 4422void ASTReader::dump() { 4423 llvm::errs() << "*** PCH/Module Remappings:\n"; 4424 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4425 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4426 dumpModuleIDMap("Global type map", GlobalTypeMap); 4427 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4428 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4429 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4430 dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap); 4431 dumpModuleIDMap("Global preprocessed entity map", 4432 GlobalPreprocessedEntityMap); 4433 4434 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4435 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4436 MEnd = ModuleMgr.end(); 4437 M != MEnd; ++M) 4438 (*M)->dump(); 4439} 4440 4441/// Return the amount of memory used by memory buffers, breaking down 4442/// by heap-backed versus mmap'ed memory. 4443void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4444 for (ModuleConstIterator I = ModuleMgr.begin(), 4445 E = ModuleMgr.end(); I != E; ++I) { 4446 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4447 size_t bytes = buf->getBufferSize(); 4448 switch (buf->getBufferKind()) { 4449 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4450 sizes.malloc_bytes += bytes; 4451 break; 4452 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4453 sizes.mmap_bytes += bytes; 4454 break; 4455 } 4456 } 4457 } 4458} 4459 4460void ASTReader::InitializeSema(Sema &S) { 4461 SemaObj = &S; 4462 S.ExternalSource = this; 4463 4464 // Makes sure any declarations that were deserialized "too early" 4465 // still get added to the identifier's declaration chains. 4466 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4467 if (SemaObj->TUScope) 4468 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4469 4470 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4471 } 4472 PreloadedDecls.clear(); 4473 4474 // Load the offsets of the declarations that Sema references. 4475 // They will be lazily deserialized when needed. 4476 if (!SemaDeclRefs.empty()) { 4477 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4478 if (!SemaObj->StdNamespace) 4479 SemaObj->StdNamespace = SemaDeclRefs[0]; 4480 if (!SemaObj->StdBadAlloc) 4481 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4482 } 4483 4484 if (!FPPragmaOptions.empty()) { 4485 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4486 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4487 } 4488 4489 if (!OpenCLExtensions.empty()) { 4490 unsigned I = 0; 4491#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4492#include "clang/Basic/OpenCLExtensions.def" 4493 4494 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4495 } 4496} 4497 4498IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4499 // Try to find this name within our on-disk hash tables. We start with the 4500 // most recent one, since that one contains the most up-to-date info. 4501 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4502 ASTIdentifierLookupTable *IdTable 4503 = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable; 4504 if (!IdTable) 4505 continue; 4506 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 4507 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 4508 if (Pos == IdTable->end()) 4509 continue; 4510 4511 // Dereferencing the iterator has the effect of building the 4512 // IdentifierInfo node and populating it with the various 4513 // declarations it needs. 4514 return *Pos; 4515 } 4516 return 0; 4517} 4518 4519namespace clang { 4520 /// \brief An identifier-lookup iterator that enumerates all of the 4521 /// identifiers stored within a set of AST files. 4522 class ASTIdentifierIterator : public IdentifierIterator { 4523 /// \brief The AST reader whose identifiers are being enumerated. 4524 const ASTReader &Reader; 4525 4526 /// \brief The current index into the chain of AST files stored in 4527 /// the AST reader. 4528 unsigned Index; 4529 4530 /// \brief The current position within the identifier lookup table 4531 /// of the current AST file. 4532 ASTIdentifierLookupTable::key_iterator Current; 4533 4534 /// \brief The end position within the identifier lookup table of 4535 /// the current AST file. 4536 ASTIdentifierLookupTable::key_iterator End; 4537 4538 public: 4539 explicit ASTIdentifierIterator(const ASTReader &Reader); 4540 4541 virtual StringRef Next(); 4542 }; 4543} 4544 4545ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4546 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 4547 ASTIdentifierLookupTable *IdTable 4548 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 4549 Current = IdTable->key_begin(); 4550 End = IdTable->key_end(); 4551} 4552 4553StringRef ASTIdentifierIterator::Next() { 4554 while (Current == End) { 4555 // If we have exhausted all of our AST files, we're done. 4556 if (Index == 0) 4557 return StringRef(); 4558 4559 --Index; 4560 ASTIdentifierLookupTable *IdTable 4561 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 4562 IdentifierLookupTable; 4563 Current = IdTable->key_begin(); 4564 End = IdTable->key_end(); 4565 } 4566 4567 // We have any identifiers remaining in the current AST file; return 4568 // the next one. 4569 std::pair<const char*, unsigned> Key = *Current; 4570 ++Current; 4571 return StringRef(Key.first, Key.second); 4572} 4573 4574IdentifierIterator *ASTReader::getIdentifiers() const { 4575 return new ASTIdentifierIterator(*this); 4576} 4577 4578std::pair<ObjCMethodList, ObjCMethodList> 4579ASTReader::ReadMethodPool(Selector Sel) { 4580 // Find this selector in a hash table. We want to find the most recent entry. 4581 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4582 Module &F = *(*I); 4583 if (!F.SelectorLookupTable) 4584 continue; 4585 4586 ASTSelectorLookupTable *PoolTable 4587 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 4588 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 4589 if (Pos != PoolTable->end()) { 4590 ++NumSelectorsRead; 4591 // FIXME: Not quite happy with the statistics here. We probably should 4592 // disable this tracking when called via LoadSelector. 4593 // Also, should entries without methods count as misses? 4594 ++NumMethodPoolEntriesRead; 4595 ASTSelectorLookupTrait::data_type Data = *Pos; 4596 if (DeserializationListener) 4597 DeserializationListener->SelectorRead(Data.ID, Sel); 4598 return std::make_pair(Data.Instance, Data.Factory); 4599 } 4600 } 4601 4602 ++NumMethodPoolMisses; 4603 return std::pair<ObjCMethodList, ObjCMethodList>(); 4604} 4605 4606void ASTReader::ReadKnownNamespaces( 4607 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 4608 Namespaces.clear(); 4609 4610 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 4611 if (NamespaceDecl *Namespace 4612 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 4613 Namespaces.push_back(Namespace); 4614 } 4615} 4616 4617void ASTReader::ReadTentativeDefinitions( 4618 SmallVectorImpl<VarDecl *> &TentativeDefs) { 4619 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4620 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 4621 if (Var) 4622 TentativeDefs.push_back(Var); 4623 } 4624 TentativeDefinitions.clear(); 4625} 4626 4627void ASTReader::ReadUnusedFileScopedDecls( 4628 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 4629 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4630 DeclaratorDecl *D 4631 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4632 if (D) 4633 Decls.push_back(D); 4634 } 4635 UnusedFileScopedDecls.clear(); 4636} 4637 4638void ASTReader::ReadDelegatingConstructors( 4639 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 4640 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 4641 CXXConstructorDecl *D 4642 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 4643 if (D) 4644 Decls.push_back(D); 4645 } 4646 DelegatingCtorDecls.clear(); 4647} 4648 4649void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 4650 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 4651 TypedefNameDecl *D 4652 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 4653 if (D) 4654 Decls.push_back(D); 4655 } 4656 ExtVectorDecls.clear(); 4657} 4658 4659void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 4660 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 4661 CXXRecordDecl *D 4662 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 4663 if (D) 4664 Decls.push_back(D); 4665 } 4666 DynamicClasses.clear(); 4667} 4668 4669void 4670ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 4671 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4672 NamedDecl *D 4673 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4674 if (D) 4675 Decls.push_back(D); 4676 } 4677 LocallyScopedExternalDecls.clear(); 4678} 4679 4680void ASTReader::ReadReferencedSelectors( 4681 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 4682 if (ReferencedSelectorsData.empty()) 4683 return; 4684 4685 // If there are @selector references added them to its pool. This is for 4686 // implementation of -Wselector. 4687 unsigned int DataSize = ReferencedSelectorsData.size()-1; 4688 unsigned I = 0; 4689 while (I < DataSize) { 4690 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 4691 SourceLocation SelLoc 4692 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 4693 Sels.push_back(std::make_pair(Sel, SelLoc)); 4694 } 4695 ReferencedSelectorsData.clear(); 4696} 4697 4698void ASTReader::ReadWeakUndeclaredIdentifiers( 4699 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 4700 if (WeakUndeclaredIdentifiers.empty()) 4701 return; 4702 4703 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 4704 IdentifierInfo *WeakId 4705 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4706 IdentifierInfo *AliasId 4707 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4708 SourceLocation Loc 4709 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 4710 bool Used = WeakUndeclaredIdentifiers[I++]; 4711 WeakInfo WI(AliasId, Loc); 4712 WI.setUsed(Used); 4713 WeakIDs.push_back(std::make_pair(WeakId, WI)); 4714 } 4715 WeakUndeclaredIdentifiers.clear(); 4716} 4717 4718void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 4719 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 4720 ExternalVTableUse VT; 4721 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4722 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 4723 VT.DefinitionRequired = VTableUses[Idx++]; 4724 VTables.push_back(VT); 4725 } 4726 4727 VTableUses.clear(); 4728} 4729 4730void ASTReader::ReadPendingInstantiations( 4731 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 4732 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 4733 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 4734 SourceLocation Loc 4735 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 4736 Pending.push_back(std::make_pair(D, Loc)); 4737 } 4738 PendingInstantiations.clear(); 4739} 4740 4741void ASTReader::LoadSelector(Selector Sel) { 4742 // It would be complicated to avoid reading the methods anyway. So don't. 4743 ReadMethodPool(Sel); 4744} 4745 4746void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 4747 assert(ID && "Non-zero identifier ID required"); 4748 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4749 IdentifiersLoaded[ID - 1] = II; 4750 if (DeserializationListener) 4751 DeserializationListener->IdentifierRead(ID, II); 4752} 4753 4754/// \brief Set the globally-visible declarations associated with the given 4755/// identifier. 4756/// 4757/// If the AST reader is currently in a state where the given declaration IDs 4758/// cannot safely be resolved, they are queued until it is safe to resolve 4759/// them. 4760/// 4761/// \param II an IdentifierInfo that refers to one or more globally-visible 4762/// declarations. 4763/// 4764/// \param DeclIDs the set of declaration IDs with the name @p II that are 4765/// visible at global scope. 4766/// 4767/// \param Nonrecursive should be true to indicate that the caller knows that 4768/// this call is non-recursive, and therefore the globally-visible declarations 4769/// will not be placed onto the pending queue. 4770void 4771ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4772 const SmallVectorImpl<uint32_t> &DeclIDs, 4773 bool Nonrecursive) { 4774 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4775 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4776 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4777 PII.II = II; 4778 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4779 return; 4780 } 4781 4782 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4783 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4784 if (SemaObj) { 4785 if (SemaObj->TUScope) { 4786 // Introduce this declaration into the translation-unit scope 4787 // and add it to the declaration chain for this identifier, so 4788 // that (unqualified) name lookup will find it. 4789 SemaObj->TUScope->AddDecl(D); 4790 } 4791 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4792 } else { 4793 // Queue this declaration so that it will be added to the 4794 // translation unit scope and identifier's declaration chain 4795 // once a Sema object is known. 4796 PreloadedDecls.push_back(D); 4797 } 4798 } 4799} 4800 4801IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 4802 if (ID == 0) 4803 return 0; 4804 4805 if (IdentifiersLoaded.empty()) { 4806 Error("no identifier table in AST file"); 4807 return 0; 4808 } 4809 4810 assert(PP && "Forgot to set Preprocessor ?"); 4811 ID -= 1; 4812 if (!IdentifiersLoaded[ID]) { 4813 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 4814 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 4815 Module *M = I->second; 4816 unsigned Index = ID - M->BaseIdentifierID; 4817 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 4818 4819 // All of the strings in the AST file are preceded by a 16-bit length. 4820 // Extract that 16-bit length to avoid having to execute strlen(). 4821 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4822 // unsigned integers. This is important to avoid integer overflow when 4823 // we cast them to 'unsigned'. 4824 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4825 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4826 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4827 IdentifiersLoaded[ID] 4828 = &PP->getIdentifierTable().get(StringRef(Str, StrLen)); 4829 if (DeserializationListener) 4830 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4831 } 4832 4833 return IdentifiersLoaded[ID]; 4834} 4835 4836IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) { 4837 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 4838} 4839 4840IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) { 4841 if (LocalID < NUM_PREDEF_IDENT_IDS) 4842 return LocalID; 4843 4844 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4845 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 4846 assert(I != M.IdentifierRemap.end() 4847 && "Invalid index into identifier index remap"); 4848 4849 return LocalID + I->second; 4850} 4851 4852bool ASTReader::ReadSLocEntry(int ID) { 4853 return ReadSLocEntryRecord(ID) != Success; 4854} 4855 4856Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) { 4857 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 4858} 4859 4860Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 4861 if (ID == 0) 4862 return Selector(); 4863 4864 if (ID > SelectorsLoaded.size()) { 4865 Error("selector ID out of range in AST file"); 4866 return Selector(); 4867 } 4868 4869 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4870 // Load this selector from the selector table. 4871 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 4872 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 4873 Module &M = *I->second; 4874 ASTSelectorLookupTrait Trait(*this, M); 4875 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 4876 SelectorsLoaded[ID - 1] = 4877 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 4878 if (DeserializationListener) 4879 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4880 } 4881 4882 return SelectorsLoaded[ID - 1]; 4883} 4884 4885Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 4886 return DecodeSelector(ID); 4887} 4888 4889uint32_t ASTReader::GetNumExternalSelectors() { 4890 // ID 0 (the null selector) is considered an external selector. 4891 return getTotalNumSelectors() + 1; 4892} 4893 4894serialization::SelectorID 4895ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const { 4896 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 4897 return LocalID; 4898 4899 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4900 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 4901 assert(I != M.SelectorRemap.end() 4902 && "Invalid index into identifier index remap"); 4903 4904 return LocalID + I->second; 4905} 4906 4907DeclarationName 4908ASTReader::ReadDeclarationName(Module &F, 4909 const RecordData &Record, unsigned &Idx) { 4910 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 4911 switch (Kind) { 4912 case DeclarationName::Identifier: 4913 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 4914 4915 case DeclarationName::ObjCZeroArgSelector: 4916 case DeclarationName::ObjCOneArgSelector: 4917 case DeclarationName::ObjCMultiArgSelector: 4918 return DeclarationName(ReadSelector(F, Record, Idx)); 4919 4920 case DeclarationName::CXXConstructorName: 4921 return Context->DeclarationNames.getCXXConstructorName( 4922 Context->getCanonicalType(readType(F, Record, Idx))); 4923 4924 case DeclarationName::CXXDestructorName: 4925 return Context->DeclarationNames.getCXXDestructorName( 4926 Context->getCanonicalType(readType(F, Record, Idx))); 4927 4928 case DeclarationName::CXXConversionFunctionName: 4929 return Context->DeclarationNames.getCXXConversionFunctionName( 4930 Context->getCanonicalType(readType(F, Record, Idx))); 4931 4932 case DeclarationName::CXXOperatorName: 4933 return Context->DeclarationNames.getCXXOperatorName( 4934 (OverloadedOperatorKind)Record[Idx++]); 4935 4936 case DeclarationName::CXXLiteralOperatorName: 4937 return Context->DeclarationNames.getCXXLiteralOperatorName( 4938 GetIdentifierInfo(F, Record, Idx)); 4939 4940 case DeclarationName::CXXUsingDirective: 4941 return DeclarationName::getUsingDirectiveName(); 4942 } 4943 4944 // Required to silence GCC warning 4945 return DeclarationName(); 4946} 4947 4948void ASTReader::ReadDeclarationNameLoc(Module &F, 4949 DeclarationNameLoc &DNLoc, 4950 DeclarationName Name, 4951 const RecordData &Record, unsigned &Idx) { 4952 switch (Name.getNameKind()) { 4953 case DeclarationName::CXXConstructorName: 4954 case DeclarationName::CXXDestructorName: 4955 case DeclarationName::CXXConversionFunctionName: 4956 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 4957 break; 4958 4959 case DeclarationName::CXXOperatorName: 4960 DNLoc.CXXOperatorName.BeginOpNameLoc 4961 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4962 DNLoc.CXXOperatorName.EndOpNameLoc 4963 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4964 break; 4965 4966 case DeclarationName::CXXLiteralOperatorName: 4967 DNLoc.CXXLiteralOperatorName.OpNameLoc 4968 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4969 break; 4970 4971 case DeclarationName::Identifier: 4972 case DeclarationName::ObjCZeroArgSelector: 4973 case DeclarationName::ObjCOneArgSelector: 4974 case DeclarationName::ObjCMultiArgSelector: 4975 case DeclarationName::CXXUsingDirective: 4976 break; 4977 } 4978} 4979 4980void ASTReader::ReadDeclarationNameInfo(Module &F, 4981 DeclarationNameInfo &NameInfo, 4982 const RecordData &Record, unsigned &Idx) { 4983 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 4984 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4985 DeclarationNameLoc DNLoc; 4986 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 4987 NameInfo.setInfo(DNLoc); 4988} 4989 4990void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info, 4991 const RecordData &Record, unsigned &Idx) { 4992 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 4993 unsigned NumTPLists = Record[Idx++]; 4994 Info.NumTemplParamLists = NumTPLists; 4995 if (NumTPLists) { 4996 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 4997 for (unsigned i=0; i != NumTPLists; ++i) 4998 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 4999 } 5000} 5001 5002TemplateName 5003ASTReader::ReadTemplateName(Module &F, const RecordData &Record, 5004 unsigned &Idx) { 5005 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5006 switch (Kind) { 5007 case TemplateName::Template: 5008 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5009 5010 case TemplateName::OverloadedTemplate: { 5011 unsigned size = Record[Idx++]; 5012 UnresolvedSet<8> Decls; 5013 while (size--) 5014 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5015 5016 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 5017 } 5018 5019 case TemplateName::QualifiedTemplate: { 5020 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5021 bool hasTemplKeyword = Record[Idx++]; 5022 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5023 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5024 } 5025 5026 case TemplateName::DependentTemplate: { 5027 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5028 if (Record[Idx++]) // isIdentifier 5029 return Context->getDependentTemplateName(NNS, 5030 GetIdentifierInfo(F, Record, 5031 Idx)); 5032 return Context->getDependentTemplateName(NNS, 5033 (OverloadedOperatorKind)Record[Idx++]); 5034 } 5035 5036 case TemplateName::SubstTemplateTemplateParm: { 5037 TemplateTemplateParmDecl *param 5038 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5039 if (!param) return TemplateName(); 5040 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5041 return Context->getSubstTemplateTemplateParm(param, replacement); 5042 } 5043 5044 case TemplateName::SubstTemplateTemplateParmPack: { 5045 TemplateTemplateParmDecl *Param 5046 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5047 if (!Param) 5048 return TemplateName(); 5049 5050 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5051 if (ArgPack.getKind() != TemplateArgument::Pack) 5052 return TemplateName(); 5053 5054 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack); 5055 } 5056 } 5057 5058 assert(0 && "Unhandled template name kind!"); 5059 return TemplateName(); 5060} 5061 5062TemplateArgument 5063ASTReader::ReadTemplateArgument(Module &F, 5064 const RecordData &Record, unsigned &Idx) { 5065 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5066 switch (Kind) { 5067 case TemplateArgument::Null: 5068 return TemplateArgument(); 5069 case TemplateArgument::Type: 5070 return TemplateArgument(readType(F, Record, Idx)); 5071 case TemplateArgument::Declaration: 5072 return TemplateArgument(ReadDecl(F, Record, Idx)); 5073 case TemplateArgument::Integral: { 5074 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5075 QualType T = readType(F, Record, Idx); 5076 return TemplateArgument(Value, T); 5077 } 5078 case TemplateArgument::Template: 5079 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5080 case TemplateArgument::TemplateExpansion: { 5081 TemplateName Name = ReadTemplateName(F, Record, Idx); 5082 llvm::Optional<unsigned> NumTemplateExpansions; 5083 if (unsigned NumExpansions = Record[Idx++]) 5084 NumTemplateExpansions = NumExpansions - 1; 5085 return TemplateArgument(Name, NumTemplateExpansions); 5086 } 5087 case TemplateArgument::Expression: 5088 return TemplateArgument(ReadExpr(F)); 5089 case TemplateArgument::Pack: { 5090 unsigned NumArgs = Record[Idx++]; 5091 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs]; 5092 for (unsigned I = 0; I != NumArgs; ++I) 5093 Args[I] = ReadTemplateArgument(F, Record, Idx); 5094 return TemplateArgument(Args, NumArgs); 5095 } 5096 } 5097 5098 assert(0 && "Unhandled template argument kind!"); 5099 return TemplateArgument(); 5100} 5101 5102TemplateParameterList * 5103ASTReader::ReadTemplateParameterList(Module &F, 5104 const RecordData &Record, unsigned &Idx) { 5105 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5106 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5107 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5108 5109 unsigned NumParams = Record[Idx++]; 5110 SmallVector<NamedDecl *, 16> Params; 5111 Params.reserve(NumParams); 5112 while (NumParams--) 5113 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5114 5115 TemplateParameterList* TemplateParams = 5116 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 5117 Params.data(), Params.size(), RAngleLoc); 5118 return TemplateParams; 5119} 5120 5121void 5122ASTReader:: 5123ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5124 Module &F, const RecordData &Record, 5125 unsigned &Idx) { 5126 unsigned NumTemplateArgs = Record[Idx++]; 5127 TemplArgs.reserve(NumTemplateArgs); 5128 while (NumTemplateArgs--) 5129 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5130} 5131 5132/// \brief Read a UnresolvedSet structure. 5133void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set, 5134 const RecordData &Record, unsigned &Idx) { 5135 unsigned NumDecls = Record[Idx++]; 5136 while (NumDecls--) { 5137 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5138 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5139 Set.addDecl(D, AS); 5140 } 5141} 5142 5143CXXBaseSpecifier 5144ASTReader::ReadCXXBaseSpecifier(Module &F, 5145 const RecordData &Record, unsigned &Idx) { 5146 bool isVirtual = static_cast<bool>(Record[Idx++]); 5147 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5148 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5149 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5150 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5151 SourceRange Range = ReadSourceRange(F, Record, Idx); 5152 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5153 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5154 EllipsisLoc); 5155 Result.setInheritConstructors(inheritConstructors); 5156 return Result; 5157} 5158 5159std::pair<CXXCtorInitializer **, unsigned> 5160ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record, 5161 unsigned &Idx) { 5162 CXXCtorInitializer **CtorInitializers = 0; 5163 unsigned NumInitializers = Record[Idx++]; 5164 if (NumInitializers) { 5165 ASTContext &C = *getContext(); 5166 5167 CtorInitializers 5168 = new (C) CXXCtorInitializer*[NumInitializers]; 5169 for (unsigned i=0; i != NumInitializers; ++i) { 5170 TypeSourceInfo *BaseClassInfo = 0; 5171 bool IsBaseVirtual = false; 5172 FieldDecl *Member = 0; 5173 IndirectFieldDecl *IndirectMember = 0; 5174 CXXConstructorDecl *Target = 0; 5175 5176 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5177 switch (Type) { 5178 case CTOR_INITIALIZER_BASE: 5179 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 5180 IsBaseVirtual = Record[Idx++]; 5181 break; 5182 5183 case CTOR_INITIALIZER_DELEGATING: 5184 Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx); 5185 break; 5186 5187 case CTOR_INITIALIZER_MEMBER: 5188 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5189 break; 5190 5191 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5192 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5193 break; 5194 } 5195 5196 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5197 Expr *Init = ReadExpr(F); 5198 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5199 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5200 bool IsWritten = Record[Idx++]; 5201 unsigned SourceOrderOrNumArrayIndices; 5202 SmallVector<VarDecl *, 8> Indices; 5203 if (IsWritten) { 5204 SourceOrderOrNumArrayIndices = Record[Idx++]; 5205 } else { 5206 SourceOrderOrNumArrayIndices = Record[Idx++]; 5207 Indices.reserve(SourceOrderOrNumArrayIndices); 5208 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5209 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5210 } 5211 5212 CXXCtorInitializer *BOMInit; 5213 if (Type == CTOR_INITIALIZER_BASE) { 5214 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual, 5215 LParenLoc, Init, RParenLoc, 5216 MemberOrEllipsisLoc); 5217 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5218 BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc, 5219 Target, Init, RParenLoc); 5220 } else if (IsWritten) { 5221 if (Member) 5222 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc, 5223 LParenLoc, Init, RParenLoc); 5224 else 5225 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember, 5226 MemberOrEllipsisLoc, LParenLoc, 5227 Init, RParenLoc); 5228 } else { 5229 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc, 5230 LParenLoc, Init, RParenLoc, 5231 Indices.data(), Indices.size()); 5232 } 5233 5234 if (IsWritten) 5235 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5236 CtorInitializers[i] = BOMInit; 5237 } 5238 } 5239 5240 return std::make_pair(CtorInitializers, NumInitializers); 5241} 5242 5243NestedNameSpecifier * 5244ASTReader::ReadNestedNameSpecifier(Module &F, 5245 const RecordData &Record, unsigned &Idx) { 5246 unsigned N = Record[Idx++]; 5247 NestedNameSpecifier *NNS = 0, *Prev = 0; 5248 for (unsigned I = 0; I != N; ++I) { 5249 NestedNameSpecifier::SpecifierKind Kind 5250 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5251 switch (Kind) { 5252 case NestedNameSpecifier::Identifier: { 5253 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5254 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 5255 break; 5256 } 5257 5258 case NestedNameSpecifier::Namespace: { 5259 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5260 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 5261 break; 5262 } 5263 5264 case NestedNameSpecifier::NamespaceAlias: { 5265 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5266 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias); 5267 break; 5268 } 5269 5270 case NestedNameSpecifier::TypeSpec: 5271 case NestedNameSpecifier::TypeSpecWithTemplate: { 5272 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5273 if (!T) 5274 return 0; 5275 5276 bool Template = Record[Idx++]; 5277 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 5278 break; 5279 } 5280 5281 case NestedNameSpecifier::Global: { 5282 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 5283 // No associated value, and there can't be a prefix. 5284 break; 5285 } 5286 } 5287 Prev = NNS; 5288 } 5289 return NNS; 5290} 5291 5292NestedNameSpecifierLoc 5293ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record, 5294 unsigned &Idx) { 5295 unsigned N = Record[Idx++]; 5296 NestedNameSpecifierLocBuilder Builder; 5297 for (unsigned I = 0; I != N; ++I) { 5298 NestedNameSpecifier::SpecifierKind Kind 5299 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5300 switch (Kind) { 5301 case NestedNameSpecifier::Identifier: { 5302 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5303 SourceRange Range = ReadSourceRange(F, Record, Idx); 5304 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd()); 5305 break; 5306 } 5307 5308 case NestedNameSpecifier::Namespace: { 5309 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5310 SourceRange Range = ReadSourceRange(F, Record, Idx); 5311 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd()); 5312 break; 5313 } 5314 5315 case NestedNameSpecifier::NamespaceAlias: { 5316 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5317 SourceRange Range = ReadSourceRange(F, Record, Idx); 5318 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd()); 5319 break; 5320 } 5321 5322 case NestedNameSpecifier::TypeSpec: 5323 case NestedNameSpecifier::TypeSpecWithTemplate: { 5324 bool Template = Record[Idx++]; 5325 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5326 if (!T) 5327 return NestedNameSpecifierLoc(); 5328 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5329 5330 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5331 Builder.Extend(*Context, 5332 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5333 T->getTypeLoc(), ColonColonLoc); 5334 break; 5335 } 5336 5337 case NestedNameSpecifier::Global: { 5338 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5339 Builder.MakeGlobal(*Context, ColonColonLoc); 5340 break; 5341 } 5342 } 5343 } 5344 5345 return Builder.getWithLocInContext(*Context); 5346} 5347 5348SourceRange 5349ASTReader::ReadSourceRange(Module &F, const RecordData &Record, 5350 unsigned &Idx) { 5351 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5352 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5353 return SourceRange(beg, end); 5354} 5355 5356/// \brief Read an integral value 5357llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5358 unsigned BitWidth = Record[Idx++]; 5359 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5360 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5361 Idx += NumWords; 5362 return Result; 5363} 5364 5365/// \brief Read a signed integral value 5366llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5367 bool isUnsigned = Record[Idx++]; 5368 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5369} 5370 5371/// \brief Read a floating-point value 5372llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5373 return llvm::APFloat(ReadAPInt(Record, Idx)); 5374} 5375 5376// \brief Read a string 5377std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5378 unsigned Len = Record[Idx++]; 5379 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5380 Idx += Len; 5381 return Result; 5382} 5383 5384VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5385 unsigned &Idx) { 5386 unsigned Major = Record[Idx++]; 5387 unsigned Minor = Record[Idx++]; 5388 unsigned Subminor = Record[Idx++]; 5389 if (Minor == 0) 5390 return VersionTuple(Major); 5391 if (Subminor == 0) 5392 return VersionTuple(Major, Minor - 1); 5393 return VersionTuple(Major, Minor - 1, Subminor - 1); 5394} 5395 5396CXXTemporary *ASTReader::ReadCXXTemporary(Module &F, 5397 const RecordData &Record, 5398 unsigned &Idx) { 5399 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5400 return CXXTemporary::Create(*Context, Decl); 5401} 5402 5403DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5404 return Diag(SourceLocation(), DiagID); 5405} 5406 5407DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5408 return Diags.Report(Loc, DiagID); 5409} 5410 5411/// \brief Retrieve the identifier table associated with the 5412/// preprocessor. 5413IdentifierTable &ASTReader::getIdentifierTable() { 5414 assert(PP && "Forgot to set Preprocessor ?"); 5415 return PP->getIdentifierTable(); 5416} 5417 5418/// \brief Record that the given ID maps to the given switch-case 5419/// statement. 5420void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5421 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5422 SwitchCaseStmts[ID] = SC; 5423} 5424 5425/// \brief Retrieve the switch-case statement with the given ID. 5426SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5427 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5428 return SwitchCaseStmts[ID]; 5429} 5430 5431void ASTReader::ClearSwitchCaseIDs() { 5432 SwitchCaseStmts.clear(); 5433} 5434 5435void ASTReader::FinishedDeserializing() { 5436 assert(NumCurrentElementsDeserializing && 5437 "FinishedDeserializing not paired with StartedDeserializing"); 5438 if (NumCurrentElementsDeserializing == 1) { 5439 // If any identifiers with corresponding top-level declarations have 5440 // been loaded, load those declarations now. 5441 while (!PendingIdentifierInfos.empty()) { 5442 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5443 PendingIdentifierInfos.front().DeclIDs, true); 5444 PendingIdentifierInfos.pop_front(); 5445 } 5446 5447 // Ready to load previous declarations of Decls that were delayed. 5448 while (!PendingPreviousDecls.empty()) { 5449 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5450 PendingPreviousDecls.front().second); 5451 PendingPreviousDecls.pop_front(); 5452 } 5453 5454 // We are not in recursive loading, so it's safe to pass the "interesting" 5455 // decls to the consumer. 5456 if (Consumer) 5457 PassInterestingDeclsToConsumer(); 5458 5459 assert(PendingForwardRefs.size() == 0 && 5460 "Some forward refs did not get linked to the definition!"); 5461 } 5462 --NumCurrentElementsDeserializing; 5463} 5464 5465ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 5466 StringRef isysroot, bool DisableValidation, 5467 bool DisableStatCache) 5468 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 5469 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 5470 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 5471 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5472 RelocatablePCH(false), isysroot(isysroot), 5473 DisableValidation(DisableValidation), 5474 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 5475 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 5476 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 5477 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 5478 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 5479 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 5480 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 5481 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 5482 NumCXXBaseSpecifiersLoaded(0) 5483{ 5484 SourceMgr.setExternalSLocEntrySource(this); 5485} 5486 5487ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 5488 Diagnostic &Diags, StringRef isysroot, 5489 bool DisableValidation, bool DisableStatCache) 5490 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 5491 Diags(Diags), SemaObj(0), PP(0), Context(0), 5492 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5493 RelocatablePCH(false), isysroot(isysroot), 5494 DisableValidation(DisableValidation), DisableStatCache(DisableStatCache), 5495 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 5496 TotalNumSLocEntries(0), NumStatementsRead(0), 5497 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 5498 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 5499 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 5500 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 5501 TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0), 5502 NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0) 5503{ 5504 SourceMgr.setExternalSLocEntrySource(this); 5505} 5506 5507ASTReader::~ASTReader() { 5508 // Delete all visible decl lookup tables 5509 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 5510 E = DeclContextOffsets.end(); 5511 I != E; ++I) { 5512 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 5513 J != F; ++J) { 5514 if (J->NameLookupTableData) 5515 delete static_cast<ASTDeclContextNameLookupTable*>( 5516 J->NameLookupTableData); 5517 } 5518 } 5519 for (DeclContextVisibleUpdatesPending::iterator 5520 I = PendingVisibleUpdates.begin(), 5521 E = PendingVisibleUpdates.end(); 5522 I != E; ++I) { 5523 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5524 F = I->second.end(); 5525 J != F; ++J) 5526 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 5527 } 5528} 5529 5530Module::Module(ModuleKind Kind) 5531 : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0), 5532 SLocEntryBaseOffset(0), SLocEntryOffsets(0), 5533 SLocFileOffsets(0), LocalNumIdentifiers(0), 5534 IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0), 5535 IdentifierLookupTable(0), BasePreprocessedEntityID(0), 5536 LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0), 5537 BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0), 5538 HeaderFileInfoTableData(0), HeaderFileInfoTable(0), 5539 HeaderFileFrameworkStrings(0), 5540 LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0), 5541 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 5542 DeclOffsets(0), BaseDeclID(0), 5543 LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 5544 LocalNumTypes(0), TypeOffsets(0), BaseTypeIndex(0), StatCache(0), 5545 NumPreallocatedPreprocessingEntities(0) 5546{} 5547 5548Module::~Module() { 5549 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 5550 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable); 5551 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 5552} 5553 5554template<typename Key, typename Offset, unsigned InitialCapacity> 5555static void 5556dumpLocalRemap(StringRef Name, 5557 const ContinuousRangeMap<Key, Offset, InitialCapacity> &Map) { 5558 if (Map.begin() == Map.end()) 5559 return; 5560 5561 typedef ContinuousRangeMap<Key, Offset, InitialCapacity> MapType; 5562 llvm::errs() << " " << Name << ":\n"; 5563 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5564 I != IEnd; ++I) { 5565 llvm::errs() << " " << I->first << " -> " << I->second 5566 << "\n"; 5567 } 5568} 5569 5570void Module::dump() { 5571 llvm::errs() << "\nModule: " << FileName << "\n"; 5572 if (!Imports.empty()) { 5573 llvm::errs() << " Imports: "; 5574 for (unsigned I = 0, N = Imports.size(); I != N; ++I) { 5575 if (I) 5576 llvm::errs() << ", "; 5577 llvm::errs() << Imports[I]->FileName; 5578 } 5579 llvm::errs() << "\n"; 5580 } 5581 5582 // Remapping tables. 5583 llvm::errs() << " Base source location offset: " << SLocEntryBaseOffset 5584 << '\n'; 5585 dumpLocalRemap("Source location offset map", SLocRemap); 5586 llvm::errs() << " Base identifier ID: " << BaseIdentifierID << '\n' 5587 << "Number of identifiers: " << LocalNumIdentifiers << '\n'; 5588 dumpLocalRemap("Identifier ID map", IdentifierRemap); 5589 llvm::errs() << " Base type index: " << BaseTypeIndex << '\n' 5590 << " Number of types: " << LocalNumTypes << '\n'; 5591 dumpLocalRemap("Type index map", TypeRemap); 5592 llvm::errs() << " Base decl ID: " << BaseDeclID << '\n' 5593 << " Number of decls: " << LocalNumDecls << '\n'; 5594 dumpLocalRemap("Decl ID map", DeclRemap); 5595} 5596 5597Module *ModuleManager::lookup(StringRef Name) { 5598 const FileEntry *Entry = FileMgr.getFile(Name); 5599 return Modules[Entry]; 5600} 5601 5602llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { 5603 const FileEntry *Entry = FileMgr.getFile(Name); 5604 return InMemoryBuffers[Entry]; 5605} 5606 5607/// \brief Creates a new module and adds it to the list of known modules 5608Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) { 5609 Module *Prev = !size() ? 0 : &getLastModule(); 5610 Module *Current = new Module(Type); 5611 5612 Current->FileName = FileName.str(); 5613 5614 Chain.push_back(Current); 5615 const FileEntry *Entry = FileMgr.getFile(FileName); 5616 Modules[Entry] = Current; 5617 5618 if (Prev) { 5619 Current->ImportedBy.insert(Prev); 5620 Prev->Imports.insert(Current); 5621 } 5622 5623 return *Current; 5624} 5625 5626void ModuleManager::addInMemoryBuffer(StringRef FileName, 5627 llvm::MemoryBuffer *Buffer) { 5628 5629 const FileEntry *Entry = FileMgr.getVirtualFile(FileName, 5630 Buffer->getBufferSize(), 0); 5631 InMemoryBuffers[Entry] = Buffer; 5632} 5633/// \brief Exports the list of loaded modules with their corresponding names 5634void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) { 5635 Target.reserve(size()); 5636 for (ModuleConstIterator I = Chain.begin(), E = Chain.end(); 5637 I != E; ++I) { 5638 Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset, 5639 (*I)->FileName)); 5640 } 5641 std::sort(Target.begin(), Target.end()); 5642} 5643 5644ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { } 5645 5646ModuleManager::~ModuleManager() { 5647 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 5648 delete Chain[e - i - 1]; 5649} 5650