ASTReader.cpp revision b18b1fd33f958264630fbae2602c81275bae8c9a
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 CXXBaseSpecifiersIDOffset = io::ReadUnalignedLE32(Data); 2340 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2341 2342 // Source location offset is mapped to OM->SLocEntryBaseOffset. 2343 SLocRemap.insert(std::make_pair(SLocOffset, 2344 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2345 2346 // FIXME: Map other locations 2347 IdentifierRemap.insert( 2348 std::make_pair(IdentifierIDOffset, 2349 OM->BaseIdentifierID - IdentifierIDOffset)); 2350 (void)PreprocessedEntityIDOffset; 2351 (void)MacroDefinitionIDOffset; 2352 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2353 OM->BaseSelectorID - SelectorIDOffset)); 2354 DeclRemap.insert(std::make_pair(DeclIDOffset, 2355 OM->BaseDeclID - DeclIDOffset)); 2356 2357 (void)CXXBaseSpecifiersIDOffset; 2358 2359 TypeRemap.insert(std::make_pair(TypeIndexOffset, 2360 OM->BaseTypeIndex - TypeIndexOffset)); 2361 } 2362 break; 2363 } 2364 2365 case SOURCE_MANAGER_LINE_TABLE: 2366 if (ParseLineTable(F, Record)) 2367 return Failure; 2368 break; 2369 2370 case FILE_SOURCE_LOCATION_OFFSETS: 2371 F.SLocFileOffsets = (const uint32_t *)BlobStart; 2372 F.LocalNumSLocFileEntries = Record[0]; 2373 break; 2374 2375 case SOURCE_LOCATION_PRELOADS: { 2376 // Need to transform from the local view (1-based IDs) to the global view, 2377 // which is based off F.SLocEntryBaseID. 2378 PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size()); 2379 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2380 PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID); 2381 break; 2382 } 2383 2384 case STAT_CACHE: { 2385 if (!DisableStatCache) { 2386 ASTStatCache *MyStatCache = 2387 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2388 (const unsigned char *)BlobStart, 2389 NumStatHits, NumStatMisses); 2390 FileMgr.addStatCache(MyStatCache); 2391 F.StatCache = MyStatCache; 2392 } 2393 break; 2394 } 2395 2396 case EXT_VECTOR_DECLS: 2397 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2398 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2399 break; 2400 2401 case VTABLE_USES: 2402 if (Record.size() % 3 != 0) { 2403 Error("Invalid VTABLE_USES record"); 2404 return Failure; 2405 } 2406 2407 // Later tables overwrite earlier ones. 2408 // FIXME: Modules will have some trouble with this. This is clearly not 2409 // the right way to do this. 2410 VTableUses.clear(); 2411 2412 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2413 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2414 VTableUses.push_back( 2415 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2416 VTableUses.push_back(Record[Idx++]); 2417 } 2418 break; 2419 2420 case DYNAMIC_CLASSES: 2421 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2422 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2423 break; 2424 2425 case PENDING_IMPLICIT_INSTANTIATIONS: 2426 if (PendingInstantiations.size() % 2 != 0) { 2427 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2428 return Failure; 2429 } 2430 2431 // Later lists of pending instantiations overwrite earlier ones. 2432 // FIXME: This is most certainly wrong for modules. 2433 PendingInstantiations.clear(); 2434 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2435 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2436 PendingInstantiations.push_back( 2437 ReadSourceLocation(F, Record, I).getRawEncoding()); 2438 } 2439 break; 2440 2441 case SEMA_DECL_REFS: 2442 // Later tables overwrite earlier ones. 2443 // FIXME: Modules will have some trouble with this. 2444 SemaDeclRefs.clear(); 2445 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2446 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2447 break; 2448 2449 case ORIGINAL_FILE_NAME: 2450 // The primary AST will be the last to get here, so it will be the one 2451 // that's used. 2452 ActualOriginalFileName.assign(BlobStart, BlobLen); 2453 OriginalFileName = ActualOriginalFileName; 2454 MaybeAddSystemRootToFilename(OriginalFileName); 2455 break; 2456 2457 case ORIGINAL_FILE_ID: 2458 OriginalFileID = FileID::get(Record[0]); 2459 break; 2460 2461 case ORIGINAL_PCH_DIR: 2462 // The primary AST will be the last to get here, so it will be the one 2463 // that's used. 2464 OriginalDir.assign(BlobStart, BlobLen); 2465 break; 2466 2467 case VERSION_CONTROL_BRANCH_REVISION: { 2468 const std::string &CurBranch = getClangFullRepositoryVersion(); 2469 StringRef ASTBranch(BlobStart, BlobLen); 2470 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2471 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2472 return IgnorePCH; 2473 } 2474 break; 2475 } 2476 2477 case MACRO_DEFINITION_OFFSETS: { 2478 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart; 2479 F.NumPreallocatedPreprocessingEntities = Record[0]; 2480 F.LocalNumMacroDefinitions = Record[1]; 2481 2482 // Introduce the global -> local mapping for preprocessed entities within 2483 // this AST file. 2484 unsigned StartingID; 2485 if (PP) { 2486 if (!PP->getPreprocessingRecord()) 2487 PP->createPreprocessingRecord(true); 2488 if (!PP->getPreprocessingRecord()->getExternalSource()) 2489 PP->getPreprocessingRecord()->SetExternalSource(*this); 2490 StartingID 2491 = PP->getPreprocessingRecord() 2492 ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities); 2493 } else { 2494 // FIXME: We'll eventually want to kill this path, since it assumes 2495 // a particular allocation strategy in the preprocessing record. 2496 StartingID = getTotalNumPreprocessedEntities(); 2497 } 2498 2499 F.BaseMacroDefinitionID = getTotalNumMacroDefinitions(); 2500 F.BasePreprocessedEntityID = StartingID; 2501 2502 // Introduce the global -> local mapping for macro definitions within 2503 // this AST file. 2504 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2505 GlobalMacroDefinitionMap.insert( 2506 std::make_pair(getTotalNumMacroDefinitions() + 1, &F)); 2507 MacroDefinitionsLoaded.resize( 2508 MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions); 2509 break; 2510 } 2511 2512 case DECL_UPDATE_OFFSETS: { 2513 if (Record.size() % 2 != 0) { 2514 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2515 return Failure; 2516 } 2517 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2518 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2519 .push_back(std::make_pair(&F, Record[I+1])); 2520 break; 2521 } 2522 2523 case DECL_REPLACEMENTS: { 2524 if (Record.size() % 2 != 0) { 2525 Error("invalid DECL_REPLACEMENTS block in AST file"); 2526 return Failure; 2527 } 2528 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2529 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2530 = std::make_pair(&F, Record[I+1]); 2531 break; 2532 } 2533 2534 case CXX_BASE_SPECIFIER_OFFSETS: { 2535 if (F.LocalNumCXXBaseSpecifiers != 0) { 2536 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2537 return Failure; 2538 } 2539 2540 F.LocalNumCXXBaseSpecifiers = Record[0]; 2541 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2542 F.BaseCXXBaseSpecifiersID = getTotalNumCXXBaseSpecifiers(); 2543 GlobalCXXBaseSpecifiersMap.insert( 2544 std::make_pair(getTotalNumCXXBaseSpecifiers() + 1, &F)); 2545 2546 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2547 break; 2548 } 2549 2550 case DIAG_PRAGMA_MAPPINGS: 2551 if (Record.size() % 2 != 0) { 2552 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2553 return Failure; 2554 } 2555 2556 if (F.PragmaDiagMappings.empty()) 2557 F.PragmaDiagMappings.swap(Record); 2558 else 2559 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2560 Record.begin(), Record.end()); 2561 break; 2562 2563 case CUDA_SPECIAL_DECL_REFS: 2564 // Later tables overwrite earlier ones. 2565 // FIXME: Modules will have trouble with this. 2566 CUDASpecialDeclRefs.clear(); 2567 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2568 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2569 break; 2570 2571 case HEADER_SEARCH_TABLE: { 2572 F.HeaderFileInfoTableData = BlobStart; 2573 F.LocalNumHeaderFileInfos = Record[1]; 2574 F.HeaderFileFrameworkStrings = BlobStart + Record[2]; 2575 if (Record[0]) { 2576 F.HeaderFileInfoTable 2577 = HeaderFileInfoLookupTable::Create( 2578 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2579 (const unsigned char *)F.HeaderFileInfoTableData, 2580 HeaderFileInfoTrait(*this, F, 2581 PP? &PP->getHeaderSearchInfo() : 0, 2582 BlobStart + Record[2])); 2583 if (PP) 2584 PP->getHeaderSearchInfo().SetExternalSource(this); 2585 } 2586 break; 2587 } 2588 2589 case FP_PRAGMA_OPTIONS: 2590 // Later tables overwrite earlier ones. 2591 FPPragmaOptions.swap(Record); 2592 break; 2593 2594 case OPENCL_EXTENSIONS: 2595 // Later tables overwrite earlier ones. 2596 OpenCLExtensions.swap(Record); 2597 break; 2598 2599 case TENTATIVE_DEFINITIONS: 2600 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2601 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2602 break; 2603 2604 case KNOWN_NAMESPACES: 2605 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2606 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2607 break; 2608 } 2609 First = false; 2610 } 2611 Error("premature end of bitstream in AST file"); 2612 return Failure; 2613} 2614 2615ASTReader::ASTReadResult ASTReader::validateFileEntries() { 2616 for (ModuleIterator I = ModuleMgr.begin(), 2617 E = ModuleMgr.end(); I != E; ++I) { 2618 Module *F = *I; 2619 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 2620 2621 for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) { 2622 SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]); 2623 unsigned Code = SLocEntryCursor.ReadCode(); 2624 if (Code == llvm::bitc::END_BLOCK || 2625 Code == llvm::bitc::ENTER_SUBBLOCK || 2626 Code == llvm::bitc::DEFINE_ABBREV) { 2627 Error("incorrectly-formatted source location entry in AST file"); 2628 return Failure; 2629 } 2630 2631 RecordData Record; 2632 const char *BlobStart; 2633 unsigned BlobLen; 2634 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2635 default: 2636 Error("incorrectly-formatted source location entry in AST file"); 2637 return Failure; 2638 2639 case SM_SLOC_FILE_ENTRY: { 2640 StringRef Filename(BlobStart, BlobLen); 2641 const FileEntry *File = getFileEntry(Filename); 2642 2643 if (File == 0) { 2644 std::string ErrorStr = "could not find file '"; 2645 ErrorStr += Filename; 2646 ErrorStr += "' referenced by AST file"; 2647 Error(ErrorStr.c_str()); 2648 return IgnorePCH; 2649 } 2650 2651 if (Record.size() < 6) { 2652 Error("source location entry is incorrect"); 2653 return Failure; 2654 } 2655 2656 // The stat info from the FileEntry came from the cached stat 2657 // info of the PCH, so we cannot trust it. 2658 struct stat StatBuf; 2659 if (::stat(File->getName(), &StatBuf) != 0) { 2660 StatBuf.st_size = File->getSize(); 2661 StatBuf.st_mtime = File->getModificationTime(); 2662 } 2663 2664 if (((off_t)Record[4] != StatBuf.st_size 2665#if !defined(LLVM_ON_WIN32) 2666 // In our regression testing, the Windows file system seems to 2667 // have inconsistent modification times that sometimes 2668 // erroneously trigger this error-handling path. 2669 || (time_t)Record[5] != StatBuf.st_mtime 2670#endif 2671 )) { 2672 Error(diag::err_fe_pch_file_modified, Filename); 2673 return IgnorePCH; 2674 } 2675 2676 break; 2677 } 2678 } 2679 } 2680 } 2681 2682 return Success; 2683} 2684 2685ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2686 ModuleKind Type) { 2687 switch(ReadASTCore(FileName, Type)) { 2688 case Failure: return Failure; 2689 case IgnorePCH: return IgnorePCH; 2690 case Success: break; 2691 } 2692 2693 // Here comes stuff that we only do once the entire chain is loaded. 2694 2695 if (!DisableValidation) { 2696 switch(validateFileEntries()) { 2697 case Failure: return Failure; 2698 case IgnorePCH: return IgnorePCH; 2699 case Success: break; 2700 } 2701 } 2702 2703 // Preload SLocEntries. 2704 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) { 2705 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]); 2706 if (Result != Success) 2707 return Failure; 2708 } 2709 PreloadSLocEntries.clear(); 2710 2711 // Check the predefines buffers. 2712 if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers()) 2713 return IgnorePCH; 2714 2715 if (PP) { 2716 // Initialization of keywords and pragmas occurs before the 2717 // AST file is read, so there may be some identifiers that were 2718 // loaded into the IdentifierTable before we intercepted the 2719 // creation of identifiers. Iterate through the list of known 2720 // identifiers and determine whether we have to establish 2721 // preprocessor definitions or top-level identifier declaration 2722 // chains for those identifiers. 2723 // 2724 // We copy the IdentifierInfo pointers to a small vector first, 2725 // since de-serializing declarations or macro definitions can add 2726 // new entries into the identifier table, invalidating the 2727 // iterators. 2728 // 2729 // FIXME: We need a lazier way to load this information, e.g., by marking 2730 // the identifier data as 'dirty', so that it will be looked up in the 2731 // AST file(s) if it is uttered in the source. This could save us some 2732 // module load time. 2733 SmallVector<IdentifierInfo *, 128> Identifiers; 2734 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(), 2735 IdEnd = PP->getIdentifierTable().end(); 2736 Id != IdEnd; ++Id) 2737 Identifiers.push_back(Id->second); 2738 // We need to search the tables in all files. 2739 for (ModuleIterator J = ModuleMgr.begin(), 2740 M = ModuleMgr.end(); J != M; ++J) { 2741 ASTIdentifierLookupTable *IdTable 2742 = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable; 2743 // Not all AST files necessarily have identifier tables, only the useful 2744 // ones. 2745 if (!IdTable) 2746 continue; 2747 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2748 IdentifierInfo *II = Identifiers[I]; 2749 // Look in the on-disk hash tables for an entry for this identifier 2750 ASTIdentifierLookupTrait Info(*this, *(*J), II); 2751 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength()); 2752 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); 2753 if (Pos == IdTable->end()) 2754 continue; 2755 2756 // Dereferencing the iterator has the effect of populating the 2757 // IdentifierInfo node with the various declarations it needs. 2758 (void)*Pos; 2759 } 2760 } 2761 } 2762 2763 if (Context) 2764 InitializeContext(*Context); 2765 2766 if (DeserializationListener) 2767 DeserializationListener->ReaderInitialized(this); 2768 2769 // If this AST file is a precompiled preamble, then set the main file ID of 2770 // the source manager to the file source file from which the preamble was 2771 // built. This is the only valid way to use a precompiled preamble. 2772 if (Type == MK_Preamble) { 2773 if (OriginalFileID.isInvalid()) { 2774 SourceLocation Loc 2775 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1); 2776 if (Loc.isValid()) 2777 OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first; 2778 } 2779 else { 2780 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2781 + OriginalFileID.getOpaqueValue() - 1); 2782 } 2783 2784 if (!OriginalFileID.isInvalid()) 2785 SourceMgr.SetPreambleFileID(OriginalFileID); 2786 } 2787 2788 return Success; 2789} 2790 2791ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2792 ModuleKind Type) { 2793 Module &F = ModuleMgr.addModule(FileName, Type); 2794 2795 if (FileName != "-") { 2796 CurrentDir = llvm::sys::path::parent_path(FileName); 2797 if (CurrentDir.empty()) CurrentDir = "."; 2798 } 2799 2800 if (llvm::MemoryBuffer *Buffer = ModuleMgr.lookupBuffer(FileName)) { 2801 F.Buffer.reset(Buffer); 2802 assert(F.Buffer && "Passed null buffer"); 2803 } else { 2804 // Open the AST file. 2805 // 2806 // FIXME: This shouldn't be here, we should just take a raw_ostream. 2807 std::string ErrStr; 2808 llvm::error_code ec; 2809 if (FileName == "-") { 2810 ec = llvm::MemoryBuffer::getSTDIN(F.Buffer); 2811 if (ec) 2812 ErrStr = ec.message(); 2813 } else 2814 F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr)); 2815 if (!F.Buffer) { 2816 Error(ErrStr.c_str()); 2817 return IgnorePCH; 2818 } 2819 } 2820 2821 // Initialize the stream 2822 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(), 2823 (const unsigned char *)F.Buffer->getBufferEnd()); 2824 llvm::BitstreamCursor &Stream = F.Stream; 2825 Stream.init(F.StreamFile); 2826 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2827 2828 // Sniff for the signature. 2829 if (Stream.Read(8) != 'C' || 2830 Stream.Read(8) != 'P' || 2831 Stream.Read(8) != 'C' || 2832 Stream.Read(8) != 'H') { 2833 Diag(diag::err_not_a_pch_file) << FileName; 2834 return Failure; 2835 } 2836 2837 while (!Stream.AtEndOfStream()) { 2838 unsigned Code = Stream.ReadCode(); 2839 2840 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2841 Error("invalid record at top-level of AST file"); 2842 return Failure; 2843 } 2844 2845 unsigned BlockID = Stream.ReadSubBlockID(); 2846 2847 // We only know the AST subblock ID. 2848 switch (BlockID) { 2849 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2850 if (Stream.ReadBlockInfoBlock()) { 2851 Error("malformed BlockInfoBlock in AST file"); 2852 return Failure; 2853 } 2854 break; 2855 case AST_BLOCK_ID: 2856 switch (ReadASTBlock(F)) { 2857 case Success: 2858 break; 2859 2860 case Failure: 2861 return Failure; 2862 2863 case IgnorePCH: 2864 // FIXME: We could consider reading through to the end of this 2865 // AST block, skipping subblocks, to see if there are other 2866 // AST blocks elsewhere. 2867 2868 // FIXME: We can't clear loaded slocentries anymore. 2869 //SourceMgr.ClearPreallocatedSLocEntries(); 2870 2871 // Remove the stat cache. 2872 if (F.StatCache) 2873 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2874 2875 return IgnorePCH; 2876 } 2877 break; 2878 default: 2879 if (Stream.SkipBlock()) { 2880 Error("malformed block record in AST file"); 2881 return Failure; 2882 } 2883 break; 2884 } 2885 } 2886 2887 // Once read, set the Module bit base offset and update the size in 2888 // bits of all files we've seen. 2889 F.GlobalBitOffset = TotalModulesSizeInBits; 2890 TotalModulesSizeInBits += F.SizeInBits; 2891 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2892 return Success; 2893} 2894 2895void ASTReader::setPreprocessor(Preprocessor &pp) { 2896 PP = &pp; 2897 2898 if (unsigned N = getTotalNumPreprocessedEntities()) { 2899 if (!PP->getPreprocessingRecord()) 2900 PP->createPreprocessingRecord(true); 2901 PP->getPreprocessingRecord()->SetExternalSource(*this); 2902 PP->getPreprocessingRecord()->allocateLoadedEntities(N); 2903 } 2904 2905 PP->getHeaderSearchInfo().SetExternalLookup(this); 2906 PP->getHeaderSearchInfo().SetExternalSource(this); 2907} 2908 2909void ASTReader::InitializeContext(ASTContext &Ctx) { 2910 Context = &Ctx; 2911 assert(Context && "Passed null context!"); 2912 2913 assert(PP && "Forgot to set Preprocessor ?"); 2914 PP->getIdentifierTable().setExternalIdentifierLookup(this); 2915 PP->setExternalSource(this); 2916 2917 // If we have an update block for the TU waiting, we have to add it before 2918 // deserializing the decl. 2919 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0); 2920 if (DCU != DeclContextOffsets.end()) { 2921 // Insertion could invalidate map, so grab vector. 2922 DeclContextInfos T; 2923 T.swap(DCU->second); 2924 DeclContextOffsets.erase(DCU); 2925 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T); 2926 } 2927 2928 // Load the translation unit declaration 2929 GetTranslationUnitDecl(); 2930 2931 // Load the special types. 2932 Context->setBuiltinVaListType( 2933 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2934 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID]) 2935 Context->setObjCIdType(GetType(Id)); 2936 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR]) 2937 Context->setObjCSelType(GetType(Sel)); 2938 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) 2939 Context->setObjCProtoType(GetType(Proto)); 2940 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS]) 2941 Context->setObjCClassType(GetType(Class)); 2942 2943 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) 2944 Context->setCFConstantStringType(GetType(String)); 2945 if (unsigned FastEnum 2946 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) 2947 Context->setObjCFastEnumerationStateType(GetType(FastEnum)); 2948 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2949 QualType FileType = GetType(File); 2950 if (FileType.isNull()) { 2951 Error("FILE type is NULL"); 2952 return; 2953 } 2954 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2955 Context->setFILEDecl(Typedef->getDecl()); 2956 else { 2957 const TagType *Tag = FileType->getAs<TagType>(); 2958 if (!Tag) { 2959 Error("Invalid FILE type in AST file"); 2960 return; 2961 } 2962 Context->setFILEDecl(Tag->getDecl()); 2963 } 2964 } 2965 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2966 QualType Jmp_bufType = GetType(Jmp_buf); 2967 if (Jmp_bufType.isNull()) { 2968 Error("jmp_buf type is NULL"); 2969 return; 2970 } 2971 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2972 Context->setjmp_bufDecl(Typedef->getDecl()); 2973 else { 2974 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2975 if (!Tag) { 2976 Error("Invalid jmp_buf type in AST file"); 2977 return; 2978 } 2979 Context->setjmp_bufDecl(Tag->getDecl()); 2980 } 2981 } 2982 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2983 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2984 if (Sigjmp_bufType.isNull()) { 2985 Error("sigjmp_buf type is NULL"); 2986 return; 2987 } 2988 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2989 Context->setsigjmp_bufDecl(Typedef->getDecl()); 2990 else { 2991 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2992 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2993 Context->setsigjmp_bufDecl(Tag->getDecl()); 2994 } 2995 } 2996 if (unsigned ObjCIdRedef 2997 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) 2998 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2999 if (unsigned ObjCClassRedef 3000 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) 3001 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); 3002 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR]) 3003 Context->setBlockDescriptorType(GetType(String)); 3004 if (unsigned String 3005 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR]) 3006 Context->setBlockDescriptorExtendedType(GetType(String)); 3007 if (unsigned ObjCSelRedef 3008 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) 3009 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3010 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING]) 3011 Context->setNSConstantStringType(GetType(String)); 3012 3013 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED]) 3014 Context->setInt128Installed(); 3015 3016 if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT]) 3017 Context->AutoDeductTy = GetType(AutoDeduct); 3018 if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT]) 3019 Context->AutoRRefDeductTy = GetType(AutoRRefDeduct); 3020 3021 ReadPragmaDiagnosticMappings(Context->getDiagnostics()); 3022 3023 // If there were any CUDA special declarations, deserialize them. 3024 if (!CUDASpecialDeclRefs.empty()) { 3025 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3026 Context->setcudaConfigureCallDecl( 3027 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3028 } 3029} 3030 3031/// \brief Retrieve the name of the original source file name 3032/// directly from the AST file, without actually loading the AST 3033/// file. 3034std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3035 FileManager &FileMgr, 3036 Diagnostic &Diags) { 3037 // Open the AST file. 3038 std::string ErrStr; 3039 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 3040 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3041 if (!Buffer) { 3042 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 3043 return std::string(); 3044 } 3045 3046 // Initialize the stream 3047 llvm::BitstreamReader StreamFile; 3048 llvm::BitstreamCursor Stream; 3049 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3050 (const unsigned char *)Buffer->getBufferEnd()); 3051 Stream.init(StreamFile); 3052 3053 // Sniff for the signature. 3054 if (Stream.Read(8) != 'C' || 3055 Stream.Read(8) != 'P' || 3056 Stream.Read(8) != 'C' || 3057 Stream.Read(8) != 'H') { 3058 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3059 return std::string(); 3060 } 3061 3062 RecordData Record; 3063 while (!Stream.AtEndOfStream()) { 3064 unsigned Code = Stream.ReadCode(); 3065 3066 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 3067 unsigned BlockID = Stream.ReadSubBlockID(); 3068 3069 // We only know the AST subblock ID. 3070 switch (BlockID) { 3071 case AST_BLOCK_ID: 3072 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 3073 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3074 return std::string(); 3075 } 3076 break; 3077 3078 default: 3079 if (Stream.SkipBlock()) { 3080 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3081 return std::string(); 3082 } 3083 break; 3084 } 3085 continue; 3086 } 3087 3088 if (Code == llvm::bitc::END_BLOCK) { 3089 if (Stream.ReadBlockEnd()) { 3090 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 3091 return std::string(); 3092 } 3093 continue; 3094 } 3095 3096 if (Code == llvm::bitc::DEFINE_ABBREV) { 3097 Stream.ReadAbbrevRecord(); 3098 continue; 3099 } 3100 3101 Record.clear(); 3102 const char *BlobStart = 0; 3103 unsigned BlobLen = 0; 3104 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 3105 == ORIGINAL_FILE_NAME) 3106 return std::string(BlobStart, BlobLen); 3107 } 3108 3109 return std::string(); 3110} 3111 3112/// \brief Parse the record that corresponds to a LangOptions data 3113/// structure. 3114/// 3115/// This routine parses the language options from the AST file and then gives 3116/// them to the AST listener if one is set. 3117/// 3118/// \returns true if the listener deems the file unacceptable, false otherwise. 3119bool ASTReader::ParseLanguageOptions( 3120 const SmallVectorImpl<uint64_t> &Record) { 3121 if (Listener) { 3122 LangOptions LangOpts; 3123 3124 #define PARSE_LANGOPT(Option) \ 3125 LangOpts.Option = Record[Idx]; \ 3126 ++Idx 3127 3128 unsigned Idx = 0; 3129 PARSE_LANGOPT(Trigraphs); 3130 PARSE_LANGOPT(BCPLComment); 3131 PARSE_LANGOPT(DollarIdents); 3132 PARSE_LANGOPT(AsmPreprocessor); 3133 PARSE_LANGOPT(GNUMode); 3134 PARSE_LANGOPT(GNUKeywords); 3135 PARSE_LANGOPT(ImplicitInt); 3136 PARSE_LANGOPT(Digraphs); 3137 PARSE_LANGOPT(HexFloats); 3138 PARSE_LANGOPT(C99); 3139 PARSE_LANGOPT(C1X); 3140 PARSE_LANGOPT(Microsoft); 3141 PARSE_LANGOPT(CPlusPlus); 3142 PARSE_LANGOPT(CPlusPlus0x); 3143 PARSE_LANGOPT(CXXOperatorNames); 3144 PARSE_LANGOPT(ObjC1); 3145 PARSE_LANGOPT(ObjC2); 3146 PARSE_LANGOPT(ObjCNonFragileABI); 3147 PARSE_LANGOPT(ObjCNonFragileABI2); 3148 PARSE_LANGOPT(AppleKext); 3149 PARSE_LANGOPT(ObjCDefaultSynthProperties); 3150 PARSE_LANGOPT(ObjCInferRelatedResultType); 3151 PARSE_LANGOPT(NoConstantCFStrings); 3152 PARSE_LANGOPT(PascalStrings); 3153 PARSE_LANGOPT(WritableStrings); 3154 PARSE_LANGOPT(LaxVectorConversions); 3155 PARSE_LANGOPT(AltiVec); 3156 PARSE_LANGOPT(Exceptions); 3157 PARSE_LANGOPT(ObjCExceptions); 3158 PARSE_LANGOPT(CXXExceptions); 3159 PARSE_LANGOPT(SjLjExceptions); 3160 PARSE_LANGOPT(MSBitfields); 3161 PARSE_LANGOPT(NeXTRuntime); 3162 PARSE_LANGOPT(Freestanding); 3163 PARSE_LANGOPT(NoBuiltin); 3164 PARSE_LANGOPT(ThreadsafeStatics); 3165 PARSE_LANGOPT(POSIXThreads); 3166 PARSE_LANGOPT(Blocks); 3167 PARSE_LANGOPT(EmitAllDecls); 3168 PARSE_LANGOPT(MathErrno); 3169 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy) 3170 Record[Idx++]); 3171 PARSE_LANGOPT(HeinousExtensions); 3172 PARSE_LANGOPT(Optimize); 3173 PARSE_LANGOPT(OptimizeSize); 3174 PARSE_LANGOPT(Static); 3175 PARSE_LANGOPT(PICLevel); 3176 PARSE_LANGOPT(GNUInline); 3177 PARSE_LANGOPT(NoInline); 3178 PARSE_LANGOPT(Deprecated); 3179 PARSE_LANGOPT(AccessControl); 3180 PARSE_LANGOPT(CharIsSigned); 3181 PARSE_LANGOPT(ShortWChar); 3182 PARSE_LANGOPT(ShortEnums); 3183 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]); 3184 LangOpts.setVisibilityMode((Visibility)Record[Idx++]); 3185 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode) 3186 Record[Idx++]); 3187 PARSE_LANGOPT(InstantiationDepth); 3188 PARSE_LANGOPT(OpenCL); 3189 PARSE_LANGOPT(CUDA); 3190 PARSE_LANGOPT(CatchUndefined); 3191 PARSE_LANGOPT(DefaultFPContract); 3192 PARSE_LANGOPT(ElideConstructors); 3193 PARSE_LANGOPT(SpellChecking); 3194 PARSE_LANGOPT(MRTD); 3195 PARSE_LANGOPT(ObjCAutoRefCount); 3196 #undef PARSE_LANGOPT 3197 3198 return Listener->ReadLanguageOptions(LangOpts); 3199 } 3200 3201 return false; 3202} 3203 3204void ASTReader::ReadPreprocessedEntities() { 3205 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3206 Module &F = *(*I); 3207 if (!F.PreprocessorDetailCursor.getBitStreamReader()) 3208 continue; 3209 3210 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor); 3211 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset); 3212 while (LoadPreprocessedEntity(F)) { } 3213 } 3214} 3215 3216PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) { 3217 RecordLocation Loc = getLocalBitOffset(Offset); 3218 3219 // Keep track of where we are in the stream, then jump back there 3220 // after reading this entity. 3221 SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor); 3222 Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset); 3223 return LoadPreprocessedEntity(*Loc.F); 3224} 3225 3226HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3227 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3228 Module &F = *(*I); 3229 3230 HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(), 3231 F.HeaderFileFrameworkStrings, 3232 FE->getName()); 3233 3234 HeaderFileInfoLookupTable *Table 3235 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable); 3236 if (!Table) 3237 continue; 3238 3239 // Look in the on-disk hash table for an entry for this file name. 3240 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(), 3241 &Trait); 3242 if (Pos == Table->end()) 3243 continue; 3244 3245 HeaderFileInfo HFI = *Pos; 3246 if (Listener) 3247 Listener->ReadHeaderFileInfo(HFI, FE->getUID()); 3248 3249 return HFI; 3250 } 3251 3252 return HeaderFileInfo(); 3253} 3254 3255void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) { 3256 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3257 Module &F = *(*I); 3258 unsigned Idx = 0; 3259 while (Idx < F.PragmaDiagMappings.size()) { 3260 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3261 while (1) { 3262 assert(Idx < F.PragmaDiagMappings.size() && 3263 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3264 if (Idx >= F.PragmaDiagMappings.size()) { 3265 break; // Something is messed up but at least avoid infinite loop in 3266 // release build. 3267 } 3268 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3269 if (DiagID == (unsigned)-1) { 3270 break; // no more diag/map pairs for this location. 3271 } 3272 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3273 Diag.setDiagnosticMapping(DiagID, Map, Loc); 3274 } 3275 } 3276 } 3277} 3278 3279/// \brief Get the correct cursor and offset for loading a type. 3280ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3281 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3282 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3283 Module *M = I->second; 3284 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3285} 3286 3287/// \brief Read and return the type with the given index.. 3288/// 3289/// The index is the type ID, shifted and minus the number of predefs. This 3290/// routine actually reads the record corresponding to the type at the given 3291/// location. It is a helper routine for GetType, which deals with reading type 3292/// IDs. 3293QualType ASTReader::readTypeRecord(unsigned Index) { 3294 RecordLocation Loc = TypeCursorForIndex(Index); 3295 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3296 3297 // Keep track of where we are in the stream, then jump back there 3298 // after reading this type. 3299 SavedStreamPosition SavedPosition(DeclsCursor); 3300 3301 ReadingKindTracker ReadingKind(Read_Type, *this); 3302 3303 // Note that we are loading a type record. 3304 Deserializing AType(this); 3305 3306 unsigned Idx = 0; 3307 DeclsCursor.JumpToBit(Loc.Offset); 3308 RecordData Record; 3309 unsigned Code = DeclsCursor.ReadCode(); 3310 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3311 case TYPE_EXT_QUAL: { 3312 if (Record.size() != 2) { 3313 Error("Incorrect encoding of extended qualifier type"); 3314 return QualType(); 3315 } 3316 QualType Base = readType(*Loc.F, Record, Idx); 3317 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3318 return Context->getQualifiedType(Base, Quals); 3319 } 3320 3321 case TYPE_COMPLEX: { 3322 if (Record.size() != 1) { 3323 Error("Incorrect encoding of complex type"); 3324 return QualType(); 3325 } 3326 QualType ElemType = readType(*Loc.F, Record, Idx); 3327 return Context->getComplexType(ElemType); 3328 } 3329 3330 case TYPE_POINTER: { 3331 if (Record.size() != 1) { 3332 Error("Incorrect encoding of pointer type"); 3333 return QualType(); 3334 } 3335 QualType PointeeType = readType(*Loc.F, Record, Idx); 3336 return Context->getPointerType(PointeeType); 3337 } 3338 3339 case TYPE_BLOCK_POINTER: { 3340 if (Record.size() != 1) { 3341 Error("Incorrect encoding of block pointer type"); 3342 return QualType(); 3343 } 3344 QualType PointeeType = readType(*Loc.F, Record, Idx); 3345 return Context->getBlockPointerType(PointeeType); 3346 } 3347 3348 case TYPE_LVALUE_REFERENCE: { 3349 if (Record.size() != 2) { 3350 Error("Incorrect encoding of lvalue reference type"); 3351 return QualType(); 3352 } 3353 QualType PointeeType = readType(*Loc.F, Record, Idx); 3354 return Context->getLValueReferenceType(PointeeType, Record[1]); 3355 } 3356 3357 case TYPE_RVALUE_REFERENCE: { 3358 if (Record.size() != 1) { 3359 Error("Incorrect encoding of rvalue reference type"); 3360 return QualType(); 3361 } 3362 QualType PointeeType = readType(*Loc.F, Record, Idx); 3363 return Context->getRValueReferenceType(PointeeType); 3364 } 3365 3366 case TYPE_MEMBER_POINTER: { 3367 if (Record.size() != 2) { 3368 Error("Incorrect encoding of member pointer type"); 3369 return QualType(); 3370 } 3371 QualType PointeeType = readType(*Loc.F, Record, Idx); 3372 QualType ClassType = readType(*Loc.F, Record, Idx); 3373 if (PointeeType.isNull() || ClassType.isNull()) 3374 return QualType(); 3375 3376 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3377 } 3378 3379 case TYPE_CONSTANT_ARRAY: { 3380 QualType ElementType = readType(*Loc.F, Record, Idx); 3381 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3382 unsigned IndexTypeQuals = Record[2]; 3383 unsigned Idx = 3; 3384 llvm::APInt Size = ReadAPInt(Record, Idx); 3385 return Context->getConstantArrayType(ElementType, Size, 3386 ASM, IndexTypeQuals); 3387 } 3388 3389 case TYPE_INCOMPLETE_ARRAY: { 3390 QualType ElementType = readType(*Loc.F, Record, Idx); 3391 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3392 unsigned IndexTypeQuals = Record[2]; 3393 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3394 } 3395 3396 case TYPE_VARIABLE_ARRAY: { 3397 QualType ElementType = readType(*Loc.F, Record, Idx); 3398 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3399 unsigned IndexTypeQuals = Record[2]; 3400 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3401 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3402 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3403 ASM, IndexTypeQuals, 3404 SourceRange(LBLoc, RBLoc)); 3405 } 3406 3407 case TYPE_VECTOR: { 3408 if (Record.size() != 3) { 3409 Error("incorrect encoding of vector type in AST file"); 3410 return QualType(); 3411 } 3412 3413 QualType ElementType = readType(*Loc.F, Record, Idx); 3414 unsigned NumElements = Record[1]; 3415 unsigned VecKind = Record[2]; 3416 return Context->getVectorType(ElementType, NumElements, 3417 (VectorType::VectorKind)VecKind); 3418 } 3419 3420 case TYPE_EXT_VECTOR: { 3421 if (Record.size() != 3) { 3422 Error("incorrect encoding of extended vector type in AST file"); 3423 return QualType(); 3424 } 3425 3426 QualType ElementType = readType(*Loc.F, Record, Idx); 3427 unsigned NumElements = Record[1]; 3428 return Context->getExtVectorType(ElementType, NumElements); 3429 } 3430 3431 case TYPE_FUNCTION_NO_PROTO: { 3432 if (Record.size() != 6) { 3433 Error("incorrect encoding of no-proto function type"); 3434 return QualType(); 3435 } 3436 QualType ResultType = readType(*Loc.F, Record, Idx); 3437 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3438 (CallingConv)Record[4], Record[5]); 3439 return Context->getFunctionNoProtoType(ResultType, Info); 3440 } 3441 3442 case TYPE_FUNCTION_PROTO: { 3443 QualType ResultType = readType(*Loc.F, Record, Idx); 3444 3445 FunctionProtoType::ExtProtoInfo EPI; 3446 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3447 /*hasregparm*/ Record[2], 3448 /*regparm*/ Record[3], 3449 static_cast<CallingConv>(Record[4]), 3450 /*produces*/ Record[5]); 3451 3452 unsigned Idx = 6; 3453 unsigned NumParams = Record[Idx++]; 3454 SmallVector<QualType, 16> ParamTypes; 3455 for (unsigned I = 0; I != NumParams; ++I) 3456 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3457 3458 EPI.Variadic = Record[Idx++]; 3459 EPI.TypeQuals = Record[Idx++]; 3460 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3461 ExceptionSpecificationType EST = 3462 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3463 EPI.ExceptionSpecType = EST; 3464 if (EST == EST_Dynamic) { 3465 EPI.NumExceptions = Record[Idx++]; 3466 SmallVector<QualType, 2> Exceptions; 3467 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3468 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3469 EPI.Exceptions = Exceptions.data(); 3470 } else if (EST == EST_ComputedNoexcept) { 3471 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3472 } 3473 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams, 3474 EPI); 3475 } 3476 3477 case TYPE_UNRESOLVED_USING: { 3478 unsigned Idx = 0; 3479 return Context->getTypeDeclType( 3480 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3481 } 3482 3483 case TYPE_TYPEDEF: { 3484 if (Record.size() != 2) { 3485 Error("incorrect encoding of typedef type"); 3486 return QualType(); 3487 } 3488 unsigned Idx = 0; 3489 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3490 QualType Canonical = readType(*Loc.F, Record, Idx); 3491 if (!Canonical.isNull()) 3492 Canonical = Context->getCanonicalType(Canonical); 3493 return Context->getTypedefType(Decl, Canonical); 3494 } 3495 3496 case TYPE_TYPEOF_EXPR: 3497 return Context->getTypeOfExprType(ReadExpr(*Loc.F)); 3498 3499 case TYPE_TYPEOF: { 3500 if (Record.size() != 1) { 3501 Error("incorrect encoding of typeof(type) in AST file"); 3502 return QualType(); 3503 } 3504 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3505 return Context->getTypeOfType(UnderlyingType); 3506 } 3507 3508 case TYPE_DECLTYPE: 3509 return Context->getDecltypeType(ReadExpr(*Loc.F)); 3510 3511 case TYPE_UNARY_TRANSFORM: { 3512 QualType BaseType = readType(*Loc.F, Record, Idx); 3513 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3514 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3515 return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind); 3516 } 3517 3518 case TYPE_AUTO: 3519 return Context->getAutoType(readType(*Loc.F, Record, Idx)); 3520 3521 case TYPE_RECORD: { 3522 if (Record.size() != 2) { 3523 Error("incorrect encoding of record type"); 3524 return QualType(); 3525 } 3526 unsigned Idx = 0; 3527 bool IsDependent = Record[Idx++]; 3528 QualType T 3529 = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3530 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3531 return T; 3532 } 3533 3534 case TYPE_ENUM: { 3535 if (Record.size() != 2) { 3536 Error("incorrect encoding of enum type"); 3537 return QualType(); 3538 } 3539 unsigned Idx = 0; 3540 bool IsDependent = Record[Idx++]; 3541 QualType T 3542 = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3543 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3544 return T; 3545 } 3546 3547 case TYPE_ATTRIBUTED: { 3548 if (Record.size() != 3) { 3549 Error("incorrect encoding of attributed type"); 3550 return QualType(); 3551 } 3552 QualType modifiedType = readType(*Loc.F, Record, Idx); 3553 QualType equivalentType = readType(*Loc.F, Record, Idx); 3554 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3555 return Context->getAttributedType(kind, modifiedType, equivalentType); 3556 } 3557 3558 case TYPE_PAREN: { 3559 if (Record.size() != 1) { 3560 Error("incorrect encoding of paren type"); 3561 return QualType(); 3562 } 3563 QualType InnerType = readType(*Loc.F, Record, Idx); 3564 return Context->getParenType(InnerType); 3565 } 3566 3567 case TYPE_PACK_EXPANSION: { 3568 if (Record.size() != 2) { 3569 Error("incorrect encoding of pack expansion type"); 3570 return QualType(); 3571 } 3572 QualType Pattern = readType(*Loc.F, Record, Idx); 3573 if (Pattern.isNull()) 3574 return QualType(); 3575 llvm::Optional<unsigned> NumExpansions; 3576 if (Record[1]) 3577 NumExpansions = Record[1] - 1; 3578 return Context->getPackExpansionType(Pattern, NumExpansions); 3579 } 3580 3581 case TYPE_ELABORATED: { 3582 unsigned Idx = 0; 3583 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3584 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3585 QualType NamedType = readType(*Loc.F, Record, Idx); 3586 return Context->getElaboratedType(Keyword, NNS, NamedType); 3587 } 3588 3589 case TYPE_OBJC_INTERFACE: { 3590 unsigned Idx = 0; 3591 ObjCInterfaceDecl *ItfD 3592 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3593 return Context->getObjCInterfaceType(ItfD); 3594 } 3595 3596 case TYPE_OBJC_OBJECT: { 3597 unsigned Idx = 0; 3598 QualType Base = readType(*Loc.F, Record, Idx); 3599 unsigned NumProtos = Record[Idx++]; 3600 SmallVector<ObjCProtocolDecl*, 4> Protos; 3601 for (unsigned I = 0; I != NumProtos; ++I) 3602 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3603 return Context->getObjCObjectType(Base, Protos.data(), NumProtos); 3604 } 3605 3606 case TYPE_OBJC_OBJECT_POINTER: { 3607 unsigned Idx = 0; 3608 QualType Pointee = readType(*Loc.F, Record, Idx); 3609 return Context->getObjCObjectPointerType(Pointee); 3610 } 3611 3612 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3613 unsigned Idx = 0; 3614 QualType Parm = readType(*Loc.F, Record, Idx); 3615 QualType Replacement = readType(*Loc.F, Record, Idx); 3616 return 3617 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3618 Replacement); 3619 } 3620 3621 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3622 unsigned Idx = 0; 3623 QualType Parm = readType(*Loc.F, Record, Idx); 3624 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3625 return Context->getSubstTemplateTypeParmPackType( 3626 cast<TemplateTypeParmType>(Parm), 3627 ArgPack); 3628 } 3629 3630 case TYPE_INJECTED_CLASS_NAME: { 3631 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3632 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3633 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3634 // for AST reading, too much interdependencies. 3635 return 3636 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3637 } 3638 3639 case TYPE_TEMPLATE_TYPE_PARM: { 3640 unsigned Idx = 0; 3641 unsigned Depth = Record[Idx++]; 3642 unsigned Index = Record[Idx++]; 3643 bool Pack = Record[Idx++]; 3644 TemplateTypeParmDecl *D 3645 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3646 return Context->getTemplateTypeParmType(Depth, Index, Pack, D); 3647 } 3648 3649 case TYPE_DEPENDENT_NAME: { 3650 unsigned Idx = 0; 3651 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3652 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3653 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3654 QualType Canon = readType(*Loc.F, Record, Idx); 3655 if (!Canon.isNull()) 3656 Canon = Context->getCanonicalType(Canon); 3657 return Context->getDependentNameType(Keyword, NNS, Name, Canon); 3658 } 3659 3660 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3661 unsigned Idx = 0; 3662 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3663 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3664 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3665 unsigned NumArgs = Record[Idx++]; 3666 SmallVector<TemplateArgument, 8> Args; 3667 Args.reserve(NumArgs); 3668 while (NumArgs--) 3669 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3670 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name, 3671 Args.size(), Args.data()); 3672 } 3673 3674 case TYPE_DEPENDENT_SIZED_ARRAY: { 3675 unsigned Idx = 0; 3676 3677 // ArrayType 3678 QualType ElementType = readType(*Loc.F, Record, Idx); 3679 ArrayType::ArraySizeModifier ASM 3680 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3681 unsigned IndexTypeQuals = Record[Idx++]; 3682 3683 // DependentSizedArrayType 3684 Expr *NumElts = ReadExpr(*Loc.F); 3685 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3686 3687 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM, 3688 IndexTypeQuals, Brackets); 3689 } 3690 3691 case TYPE_TEMPLATE_SPECIALIZATION: { 3692 unsigned Idx = 0; 3693 bool IsDependent = Record[Idx++]; 3694 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3695 SmallVector<TemplateArgument, 8> Args; 3696 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3697 QualType Underlying = readType(*Loc.F, Record, Idx); 3698 QualType T; 3699 if (Underlying.isNull()) 3700 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(), 3701 Args.size()); 3702 else 3703 T = Context->getTemplateSpecializationType(Name, Args.data(), 3704 Args.size(), Underlying); 3705 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3706 return T; 3707 } 3708 } 3709 // Suppress a GCC warning 3710 return QualType(); 3711} 3712 3713class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3714 ASTReader &Reader; 3715 Module &F; 3716 llvm::BitstreamCursor &DeclsCursor; 3717 const ASTReader::RecordData &Record; 3718 unsigned &Idx; 3719 3720 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3721 unsigned &I) { 3722 return Reader.ReadSourceLocation(F, R, I); 3723 } 3724 3725 template<typename T> 3726 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 3727 return Reader.ReadDeclAs<T>(F, Record, Idx); 3728 } 3729 3730public: 3731 TypeLocReader(ASTReader &Reader, Module &F, 3732 const ASTReader::RecordData &Record, unsigned &Idx) 3733 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3734 { } 3735 3736 // We want compile-time assurance that we've enumerated all of 3737 // these, so unfortunately we have to declare them first, then 3738 // define them out-of-line. 3739#define ABSTRACT_TYPELOC(CLASS, PARENT) 3740#define TYPELOC(CLASS, PARENT) \ 3741 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3742#include "clang/AST/TypeLocNodes.def" 3743 3744 void VisitFunctionTypeLoc(FunctionTypeLoc); 3745 void VisitArrayTypeLoc(ArrayTypeLoc); 3746}; 3747 3748void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3749 // nothing to do 3750} 3751void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3752 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3753 if (TL.needsExtraLocalData()) { 3754 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3755 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3756 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3757 TL.setModeAttr(Record[Idx++]); 3758 } 3759} 3760void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3761 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3762} 3763void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3764 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3765} 3766void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3767 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3768} 3769void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3770 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3771} 3772void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3773 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3774} 3775void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3776 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3777 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3778} 3779void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3780 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3781 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3782 if (Record[Idx++]) 3783 TL.setSizeExpr(Reader.ReadExpr(F)); 3784 else 3785 TL.setSizeExpr(0); 3786} 3787void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3788 VisitArrayTypeLoc(TL); 3789} 3790void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3791 VisitArrayTypeLoc(TL); 3792} 3793void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3794 VisitArrayTypeLoc(TL); 3795} 3796void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3797 DependentSizedArrayTypeLoc TL) { 3798 VisitArrayTypeLoc(TL); 3799} 3800void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3801 DependentSizedExtVectorTypeLoc TL) { 3802 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3803} 3804void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3805 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3806} 3807void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3808 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3809} 3810void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3811 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3812 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3813 TL.setTrailingReturn(Record[Idx++]); 3814 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3815 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 3816 } 3817} 3818void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3819 VisitFunctionTypeLoc(TL); 3820} 3821void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3822 VisitFunctionTypeLoc(TL); 3823} 3824void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3825 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3826} 3827void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3828 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3829} 3830void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3831 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3832 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3833 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3834} 3835void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3836 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3837 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3838 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3839 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3840} 3841void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3842 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3843} 3844void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 3845 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3846 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3847 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3848 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3849} 3850void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3851 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3852} 3853void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3854 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3855} 3856void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3857 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3858} 3859void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3860 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3861 if (TL.hasAttrOperand()) { 3862 SourceRange range; 3863 range.setBegin(ReadSourceLocation(Record, Idx)); 3864 range.setEnd(ReadSourceLocation(Record, Idx)); 3865 TL.setAttrOperandParensRange(range); 3866 } 3867 if (TL.hasAttrExprOperand()) { 3868 if (Record[Idx++]) 3869 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3870 else 3871 TL.setAttrExprOperand(0); 3872 } else if (TL.hasAttrEnumOperand()) 3873 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3874} 3875void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3876 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3877} 3878void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3879 SubstTemplateTypeParmTypeLoc TL) { 3880 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3881} 3882void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3883 SubstTemplateTypeParmPackTypeLoc TL) { 3884 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3885} 3886void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3887 TemplateSpecializationTypeLoc TL) { 3888 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3889 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3890 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3891 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3892 TL.setArgLocInfo(i, 3893 Reader.GetTemplateArgumentLocInfo(F, 3894 TL.getTypePtr()->getArg(i).getKind(), 3895 Record, Idx)); 3896} 3897void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3898 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3899 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3900} 3901void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3902 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3903 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3904} 3905void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3906 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3907} 3908void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3909 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3910 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3911 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3912} 3913void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3914 DependentTemplateSpecializationTypeLoc TL) { 3915 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3916 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3917 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3918 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3919 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3920 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3921 TL.setArgLocInfo(I, 3922 Reader.GetTemplateArgumentLocInfo(F, 3923 TL.getTypePtr()->getArg(I).getKind(), 3924 Record, Idx)); 3925} 3926void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3927 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3928} 3929void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3930 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3931} 3932void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3933 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3934 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3935 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3936 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3937 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3938} 3939void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3940 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3941} 3942 3943TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F, 3944 const RecordData &Record, 3945 unsigned &Idx) { 3946 QualType InfoTy = readType(F, Record, Idx); 3947 if (InfoTy.isNull()) 3948 return 0; 3949 3950 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy); 3951 TypeLocReader TLR(*this, F, Record, Idx); 3952 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3953 TLR.Visit(TL); 3954 return TInfo; 3955} 3956 3957QualType ASTReader::GetType(TypeID ID) { 3958 unsigned FastQuals = ID & Qualifiers::FastMask; 3959 unsigned Index = ID >> Qualifiers::FastWidth; 3960 3961 if (Index < NUM_PREDEF_TYPE_IDS) { 3962 QualType T; 3963 switch ((PredefinedTypeIDs)Index) { 3964 case PREDEF_TYPE_NULL_ID: return QualType(); 3965 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break; 3966 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break; 3967 3968 case PREDEF_TYPE_CHAR_U_ID: 3969 case PREDEF_TYPE_CHAR_S_ID: 3970 // FIXME: Check that the signedness of CharTy is correct! 3971 T = Context->CharTy; 3972 break; 3973 3974 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break; 3975 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break; 3976 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break; 3977 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break; 3978 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break; 3979 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break; 3980 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break; 3981 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break; 3982 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break; 3983 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break; 3984 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break; 3985 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break; 3986 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break; 3987 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break; 3988 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break; 3989 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break; 3990 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break; 3991 case PREDEF_TYPE_BOUND_MEMBER: T = Context->BoundMemberTy; break; 3992 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break; 3993 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break; 3994 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break; 3995 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break; 3996 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break; 3997 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break; 3998 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break; 3999 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break; 4000 } 4001 4002 assert(!T.isNull() && "Unknown predefined type"); 4003 return T.withFastQualifiers(FastQuals); 4004 } 4005 4006 Index -= NUM_PREDEF_TYPE_IDS; 4007 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 4008 if (TypesLoaded[Index].isNull()) { 4009 TypesLoaded[Index] = readTypeRecord(Index); 4010 if (TypesLoaded[Index].isNull()) 4011 return QualType(); 4012 4013 TypesLoaded[Index]->setFromAST(); 4014 if (DeserializationListener) 4015 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 4016 TypesLoaded[Index]); 4017 } 4018 4019 return TypesLoaded[Index].withFastQualifiers(FastQuals); 4020} 4021 4022QualType ASTReader::getLocalType(Module &F, unsigned LocalID) { 4023 return GetType(getGlobalTypeID(F, LocalID)); 4024} 4025 4026serialization::TypeID 4027ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const { 4028 unsigned FastQuals = LocalID & Qualifiers::FastMask; 4029 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 4030 4031 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 4032 return LocalID; 4033 4034 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4035 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 4036 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 4037 4038 unsigned GlobalIndex = LocalIndex + I->second; 4039 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 4040} 4041 4042TemplateArgumentLocInfo 4043ASTReader::GetTemplateArgumentLocInfo(Module &F, 4044 TemplateArgument::ArgKind Kind, 4045 const RecordData &Record, 4046 unsigned &Index) { 4047 switch (Kind) { 4048 case TemplateArgument::Expression: 4049 return ReadExpr(F); 4050 case TemplateArgument::Type: 4051 return GetTypeSourceInfo(F, Record, Index); 4052 case TemplateArgument::Template: { 4053 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4054 Index); 4055 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4056 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4057 SourceLocation()); 4058 } 4059 case TemplateArgument::TemplateExpansion: { 4060 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 4061 Index); 4062 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 4063 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 4064 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 4065 EllipsisLoc); 4066 } 4067 case TemplateArgument::Null: 4068 case TemplateArgument::Integral: 4069 case TemplateArgument::Declaration: 4070 case TemplateArgument::Pack: 4071 return TemplateArgumentLocInfo(); 4072 } 4073 llvm_unreachable("unexpected template argument loc"); 4074 return TemplateArgumentLocInfo(); 4075} 4076 4077TemplateArgumentLoc 4078ASTReader::ReadTemplateArgumentLoc(Module &F, 4079 const RecordData &Record, unsigned &Index) { 4080 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 4081 4082 if (Arg.getKind() == TemplateArgument::Expression) { 4083 if (Record[Index++]) // bool InfoHasSameExpr. 4084 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 4085 } 4086 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 4087 Record, Index)); 4088} 4089 4090Decl *ASTReader::GetExternalDecl(uint32_t ID) { 4091 return GetDecl(ID); 4092} 4093 4094uint64_t 4095ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) { 4096 if (ID == 0) 4097 return 0; 4098 4099 GlobalCXXBaseSpecifiersMapType::iterator I = 4100 GlobalCXXBaseSpecifiersMap.find(ID); 4101 4102 assert (I != GlobalCXXBaseSpecifiersMap.end() && 4103 "Corrupted global CXX base specifiers map"); 4104 4105 Module *M = I->second; 4106 return M->CXXBaseSpecifiersOffsets[ID - 1 - M->BaseCXXBaseSpecifiersID] + 4107 M->GlobalBitOffset; 4108} 4109 4110CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 4111 RecordLocation Loc = getLocalBitOffset(Offset); 4112 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 4113 SavedStreamPosition SavedPosition(Cursor); 4114 Cursor.JumpToBit(Loc.Offset); 4115 ReadingKindTracker ReadingKind(Read_Decl, *this); 4116 RecordData Record; 4117 unsigned Code = Cursor.ReadCode(); 4118 unsigned RecCode = Cursor.ReadRecord(Code, Record); 4119 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 4120 Error("Malformed AST file: missing C++ base specifiers"); 4121 return 0; 4122 } 4123 4124 unsigned Idx = 0; 4125 unsigned NumBases = Record[Idx++]; 4126 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases); 4127 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 4128 for (unsigned I = 0; I != NumBases; ++I) 4129 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 4130 return Bases; 4131} 4132 4133TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() { 4134 // FIXME: This routine might not even make sense when we're loading multiple 4135 // unrelated AST files, since we'll have to merge the translation units 4136 // somehow. 4137 unsigned TranslationUnitID = (*(ModuleMgr.end() - 1))->BaseDeclID + 1; 4138 if (!DeclsLoaded[TranslationUnitID - 1]) { 4139 ReadDeclRecord(TranslationUnitID); 4140 if (DeserializationListener) 4141 DeserializationListener->DeclRead(TranslationUnitID, 4142 DeclsLoaded[TranslationUnitID - 1]); 4143 } 4144 4145 return cast<TranslationUnitDecl>(DeclsLoaded[TranslationUnitID - 1]); 4146} 4147 4148serialization::DeclID 4149ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const { 4150 if (LocalID < NUM_PREDEF_DECL_IDS) 4151 return LocalID; 4152 4153 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4154 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 4155 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 4156 4157 return LocalID + I->second; 4158} 4159 4160Decl *ASTReader::GetDecl(DeclID ID) { 4161 if (ID < NUM_PREDEF_DECL_IDS) { 4162 switch ((PredefinedDeclIDs)ID) { 4163 case serialization::PREDEF_DECL_NULL_ID: 4164 return 0; 4165 } 4166 4167 return 0; 4168 } 4169 4170 if (ID > DeclsLoaded.size()) { 4171 Error("declaration ID out-of-range for AST file"); 4172 return 0; 4173 } 4174 4175 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4176 if (!DeclsLoaded[Index]) { 4177 ReadDeclRecord(ID); 4178 if (DeserializationListener) 4179 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4180 } 4181 4182 return DeclsLoaded[Index]; 4183} 4184 4185serialization::DeclID ASTReader::ReadDeclID(Module &F, 4186 const RecordData &Record, 4187 unsigned &Idx) { 4188 if (Idx >= Record.size()) { 4189 Error("Corrupted AST file"); 4190 return 0; 4191 } 4192 4193 return getGlobalDeclID(F, Record[Idx++]); 4194} 4195 4196/// \brief Resolve the offset of a statement into a statement. 4197/// 4198/// This operation will read a new statement from the external 4199/// source each time it is called, and is meant to be used via a 4200/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4201Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4202 // Switch case IDs are per Decl. 4203 ClearSwitchCaseIDs(); 4204 4205 // Offset here is a global offset across the entire chain. 4206 RecordLocation Loc = getLocalBitOffset(Offset); 4207 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4208 return ReadStmtFromStream(*Loc.F); 4209} 4210 4211ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4212 bool (*isKindWeWant)(Decl::Kind), 4213 SmallVectorImpl<Decl*> &Decls) { 4214 // There might be lexical decls in multiple parts of the chain, for the TU 4215 // at least. 4216 // DeclContextOffsets might reallocate as we load additional decls below, 4217 // so make a copy of the vector. 4218 DeclContextInfos Infos = DeclContextOffsets[DC]; 4219 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4220 I != E; ++I) { 4221 // IDs can be 0 if this context doesn't contain declarations. 4222 if (!I->LexicalDecls) 4223 continue; 4224 4225 // Load all of the declaration IDs 4226 for (const KindDeclIDPair *ID = I->LexicalDecls, 4227 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) { 4228 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first)) 4229 continue; 4230 4231 Decl *D = GetLocalDecl(*I->F, ID->second); 4232 assert(D && "Null decl in lexical decls"); 4233 Decls.push_back(D); 4234 } 4235 } 4236 4237 ++NumLexicalDeclContextsRead; 4238 return ELR_Success; 4239} 4240 4241DeclContext::lookup_result 4242ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4243 DeclarationName Name) { 4244 assert(DC->hasExternalVisibleStorage() && 4245 "DeclContext has no visible decls in storage"); 4246 if (!Name) 4247 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4248 DeclContext::lookup_iterator(0)); 4249 4250 SmallVector<NamedDecl *, 64> Decls; 4251 // There might be visible decls in multiple parts of the chain, for the TU 4252 // and namespaces. For any given name, the last available results replace 4253 // all earlier ones. For this reason, we walk in reverse. 4254 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4255 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend(); 4256 I != E; ++I) { 4257 if (!I->NameLookupTableData) 4258 continue; 4259 4260 ASTDeclContextNameLookupTable *LookupTable = 4261 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4262 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name); 4263 if (Pos == LookupTable->end()) 4264 continue; 4265 4266 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4267 for (; Data.first != Data.second; ++Data.first) { 4268 NamedDecl *ND = GetLocalDeclAs<NamedDecl>(*I->F, *Data.first); 4269 if (!ND) 4270 continue; 4271 4272 if (ND->getDeclName() != Name) { 4273 assert(!Name.getCXXNameType().isNull() && 4274 "Name mismatch without a type"); 4275 continue; 4276 } 4277 4278 Decls.push_back(ND); 4279 } 4280 4281 // If we rejected all of the declarations we found, e.g., because the 4282 // name didn't actually match, continue looking through DeclContexts. 4283 if (Decls.empty()) 4284 continue; 4285 4286 break; 4287 } 4288 4289 ++NumVisibleDeclContextsRead; 4290 4291 SetExternalVisibleDeclsForName(DC, Name, Decls); 4292 return const_cast<DeclContext*>(DC)->lookup(Name); 4293} 4294 4295void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) { 4296 assert(DC->hasExternalVisibleStorage() && 4297 "DeclContext has no visible decls in storage"); 4298 4299 SmallVector<NamedDecl *, 64> Decls; 4300 // There might be visible decls in multiple parts of the chain, for the TU 4301 // and namespaces. 4302 DeclContextInfos &Infos = DeclContextOffsets[DC]; 4303 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end(); 4304 I != E; ++I) { 4305 if (!I->NameLookupTableData) 4306 continue; 4307 4308 ASTDeclContextNameLookupTable *LookupTable = 4309 (ASTDeclContextNameLookupTable*)I->NameLookupTableData; 4310 for (ASTDeclContextNameLookupTable::item_iterator 4311 ItemI = LookupTable->item_begin(), 4312 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) { 4313 ASTDeclContextNameLookupTable::item_iterator::value_type Val 4314 = *ItemI; 4315 ASTDeclContextNameLookupTrait::data_type Data = Val.second; 4316 Decls.clear(); 4317 for (; Data.first != Data.second; ++Data.first) 4318 Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first)); 4319 MaterializeVisibleDeclsForName(DC, Val.first, Decls); 4320 } 4321 } 4322} 4323 4324void ASTReader::PassInterestingDeclsToConsumer() { 4325 assert(Consumer); 4326 while (!InterestingDecls.empty()) { 4327 DeclGroupRef DG(InterestingDecls.front()); 4328 InterestingDecls.pop_front(); 4329 Consumer->HandleInterestingDecl(DG); 4330 } 4331} 4332 4333void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4334 this->Consumer = Consumer; 4335 4336 if (!Consumer) 4337 return; 4338 4339 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4340 // Force deserialization of this decl, which will cause it to be queued for 4341 // passing to the consumer. 4342 GetDecl(ExternalDefinitions[I]); 4343 } 4344 4345 PassInterestingDeclsToConsumer(); 4346} 4347 4348void ASTReader::PrintStats() { 4349 std::fprintf(stderr, "*** AST File Statistics:\n"); 4350 4351 unsigned NumTypesLoaded 4352 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4353 QualType()); 4354 unsigned NumDeclsLoaded 4355 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4356 (Decl *)0); 4357 unsigned NumIdentifiersLoaded 4358 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4359 IdentifiersLoaded.end(), 4360 (IdentifierInfo *)0); 4361 unsigned NumSelectorsLoaded 4362 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4363 SelectorsLoaded.end(), 4364 Selector()); 4365 4366 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4367 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4368 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4369 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4370 NumSLocEntriesRead, TotalNumSLocEntries, 4371 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4372 if (!TypesLoaded.empty()) 4373 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4374 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4375 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4376 if (!DeclsLoaded.empty()) 4377 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4378 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4379 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4380 if (!IdentifiersLoaded.empty()) 4381 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4382 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4383 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4384 if (!SelectorsLoaded.empty()) 4385 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4386 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4387 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4388 if (TotalNumStatements) 4389 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4390 NumStatementsRead, TotalNumStatements, 4391 ((float)NumStatementsRead/TotalNumStatements * 100)); 4392 if (TotalNumMacros) 4393 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4394 NumMacrosRead, TotalNumMacros, 4395 ((float)NumMacrosRead/TotalNumMacros * 100)); 4396 if (TotalLexicalDeclContexts) 4397 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4398 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4399 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4400 * 100)); 4401 if (TotalVisibleDeclContexts) 4402 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4403 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4404 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4405 * 100)); 4406 if (TotalNumMethodPoolEntries) { 4407 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4408 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4409 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4410 * 100)); 4411 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4412 } 4413 std::fprintf(stderr, "\n"); 4414 dump(); 4415 std::fprintf(stderr, "\n"); 4416} 4417 4418template<typename Key, typename Module, unsigned InitialCapacity> 4419static void 4420dumpModuleIDMap(StringRef Name, 4421 const ContinuousRangeMap<Key, Module *, 4422 InitialCapacity> &Map) { 4423 if (Map.begin() == Map.end()) 4424 return; 4425 4426 typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType; 4427 llvm::errs() << Name << ":\n"; 4428 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4429 I != IEnd; ++I) { 4430 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4431 << "\n"; 4432 } 4433} 4434 4435void ASTReader::dump() { 4436 llvm::errs() << "*** PCH/Module Remappings:\n"; 4437 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4438 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4439 dumpModuleIDMap("Global type map", GlobalTypeMap); 4440 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4441 dumpModuleIDMap("Global C++ base specifiers map", GlobalCXXBaseSpecifiersMap); 4442 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4443 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4444 dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap); 4445 dumpModuleIDMap("Global preprocessed entity map", 4446 GlobalPreprocessedEntityMap); 4447 4448 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4449 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4450 MEnd = ModuleMgr.end(); 4451 M != MEnd; ++M) 4452 (*M)->dump(); 4453} 4454 4455/// Return the amount of memory used by memory buffers, breaking down 4456/// by heap-backed versus mmap'ed memory. 4457void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4458 for (ModuleConstIterator I = ModuleMgr.begin(), 4459 E = ModuleMgr.end(); I != E; ++I) { 4460 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4461 size_t bytes = buf->getBufferSize(); 4462 switch (buf->getBufferKind()) { 4463 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4464 sizes.malloc_bytes += bytes; 4465 break; 4466 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4467 sizes.mmap_bytes += bytes; 4468 break; 4469 } 4470 } 4471 } 4472} 4473 4474void ASTReader::InitializeSema(Sema &S) { 4475 SemaObj = &S; 4476 S.ExternalSource = this; 4477 4478 // Makes sure any declarations that were deserialized "too early" 4479 // still get added to the identifier's declaration chains. 4480 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4481 if (SemaObj->TUScope) 4482 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4483 4484 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4485 } 4486 PreloadedDecls.clear(); 4487 4488 // Load the offsets of the declarations that Sema references. 4489 // They will be lazily deserialized when needed. 4490 if (!SemaDeclRefs.empty()) { 4491 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4492 if (!SemaObj->StdNamespace) 4493 SemaObj->StdNamespace = SemaDeclRefs[0]; 4494 if (!SemaObj->StdBadAlloc) 4495 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4496 } 4497 4498 if (!FPPragmaOptions.empty()) { 4499 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4500 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4501 } 4502 4503 if (!OpenCLExtensions.empty()) { 4504 unsigned I = 0; 4505#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4506#include "clang/Basic/OpenCLExtensions.def" 4507 4508 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4509 } 4510} 4511 4512IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4513 // Try to find this name within our on-disk hash tables. We start with the 4514 // most recent one, since that one contains the most up-to-date info. 4515 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4516 ASTIdentifierLookupTable *IdTable 4517 = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable; 4518 if (!IdTable) 4519 continue; 4520 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); 4521 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 4522 if (Pos == IdTable->end()) 4523 continue; 4524 4525 // Dereferencing the iterator has the effect of building the 4526 // IdentifierInfo node and populating it with the various 4527 // declarations it needs. 4528 return *Pos; 4529 } 4530 return 0; 4531} 4532 4533namespace clang { 4534 /// \brief An identifier-lookup iterator that enumerates all of the 4535 /// identifiers stored within a set of AST files. 4536 class ASTIdentifierIterator : public IdentifierIterator { 4537 /// \brief The AST reader whose identifiers are being enumerated. 4538 const ASTReader &Reader; 4539 4540 /// \brief The current index into the chain of AST files stored in 4541 /// the AST reader. 4542 unsigned Index; 4543 4544 /// \brief The current position within the identifier lookup table 4545 /// of the current AST file. 4546 ASTIdentifierLookupTable::key_iterator Current; 4547 4548 /// \brief The end position within the identifier lookup table of 4549 /// the current AST file. 4550 ASTIdentifierLookupTable::key_iterator End; 4551 4552 public: 4553 explicit ASTIdentifierIterator(const ASTReader &Reader); 4554 4555 virtual StringRef Next(); 4556 }; 4557} 4558 4559ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4560 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 4561 ASTIdentifierLookupTable *IdTable 4562 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 4563 Current = IdTable->key_begin(); 4564 End = IdTable->key_end(); 4565} 4566 4567StringRef ASTIdentifierIterator::Next() { 4568 while (Current == End) { 4569 // If we have exhausted all of our AST files, we're done. 4570 if (Index == 0) 4571 return StringRef(); 4572 4573 --Index; 4574 ASTIdentifierLookupTable *IdTable 4575 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 4576 IdentifierLookupTable; 4577 Current = IdTable->key_begin(); 4578 End = IdTable->key_end(); 4579 } 4580 4581 // We have any identifiers remaining in the current AST file; return 4582 // the next one. 4583 std::pair<const char*, unsigned> Key = *Current; 4584 ++Current; 4585 return StringRef(Key.first, Key.second); 4586} 4587 4588IdentifierIterator *ASTReader::getIdentifiers() const { 4589 return new ASTIdentifierIterator(*this); 4590} 4591 4592std::pair<ObjCMethodList, ObjCMethodList> 4593ASTReader::ReadMethodPool(Selector Sel) { 4594 // Find this selector in a hash table. We want to find the most recent entry. 4595 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4596 Module &F = *(*I); 4597 if (!F.SelectorLookupTable) 4598 continue; 4599 4600 ASTSelectorLookupTable *PoolTable 4601 = (ASTSelectorLookupTable*)F.SelectorLookupTable; 4602 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel); 4603 if (Pos != PoolTable->end()) { 4604 ++NumSelectorsRead; 4605 // FIXME: Not quite happy with the statistics here. We probably should 4606 // disable this tracking when called via LoadSelector. 4607 // Also, should entries without methods count as misses? 4608 ++NumMethodPoolEntriesRead; 4609 ASTSelectorLookupTrait::data_type Data = *Pos; 4610 if (DeserializationListener) 4611 DeserializationListener->SelectorRead(Data.ID, Sel); 4612 return std::make_pair(Data.Instance, Data.Factory); 4613 } 4614 } 4615 4616 ++NumMethodPoolMisses; 4617 return std::pair<ObjCMethodList, ObjCMethodList>(); 4618} 4619 4620void ASTReader::ReadKnownNamespaces( 4621 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 4622 Namespaces.clear(); 4623 4624 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 4625 if (NamespaceDecl *Namespace 4626 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 4627 Namespaces.push_back(Namespace); 4628 } 4629} 4630 4631void ASTReader::ReadTentativeDefinitions( 4632 SmallVectorImpl<VarDecl *> &TentativeDefs) { 4633 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4634 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 4635 if (Var) 4636 TentativeDefs.push_back(Var); 4637 } 4638 TentativeDefinitions.clear(); 4639} 4640 4641void ASTReader::ReadUnusedFileScopedDecls( 4642 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 4643 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4644 DeclaratorDecl *D 4645 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4646 if (D) 4647 Decls.push_back(D); 4648 } 4649 UnusedFileScopedDecls.clear(); 4650} 4651 4652void ASTReader::ReadDelegatingConstructors( 4653 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 4654 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 4655 CXXConstructorDecl *D 4656 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 4657 if (D) 4658 Decls.push_back(D); 4659 } 4660 DelegatingCtorDecls.clear(); 4661} 4662 4663void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 4664 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 4665 TypedefNameDecl *D 4666 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 4667 if (D) 4668 Decls.push_back(D); 4669 } 4670 ExtVectorDecls.clear(); 4671} 4672 4673void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 4674 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 4675 CXXRecordDecl *D 4676 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 4677 if (D) 4678 Decls.push_back(D); 4679 } 4680 DynamicClasses.clear(); 4681} 4682 4683void 4684ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 4685 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4686 NamedDecl *D 4687 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4688 if (D) 4689 Decls.push_back(D); 4690 } 4691 LocallyScopedExternalDecls.clear(); 4692} 4693 4694void ASTReader::ReadReferencedSelectors( 4695 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 4696 if (ReferencedSelectorsData.empty()) 4697 return; 4698 4699 // If there are @selector references added them to its pool. This is for 4700 // implementation of -Wselector. 4701 unsigned int DataSize = ReferencedSelectorsData.size()-1; 4702 unsigned I = 0; 4703 while (I < DataSize) { 4704 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 4705 SourceLocation SelLoc 4706 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 4707 Sels.push_back(std::make_pair(Sel, SelLoc)); 4708 } 4709 ReferencedSelectorsData.clear(); 4710} 4711 4712void ASTReader::ReadWeakUndeclaredIdentifiers( 4713 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 4714 if (WeakUndeclaredIdentifiers.empty()) 4715 return; 4716 4717 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 4718 IdentifierInfo *WeakId 4719 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4720 IdentifierInfo *AliasId 4721 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4722 SourceLocation Loc 4723 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 4724 bool Used = WeakUndeclaredIdentifiers[I++]; 4725 WeakInfo WI(AliasId, Loc); 4726 WI.setUsed(Used); 4727 WeakIDs.push_back(std::make_pair(WeakId, WI)); 4728 } 4729 WeakUndeclaredIdentifiers.clear(); 4730} 4731 4732void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 4733 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 4734 ExternalVTableUse VT; 4735 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4736 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 4737 VT.DefinitionRequired = VTableUses[Idx++]; 4738 VTables.push_back(VT); 4739 } 4740 4741 VTableUses.clear(); 4742} 4743 4744void ASTReader::ReadPendingInstantiations( 4745 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 4746 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 4747 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 4748 SourceLocation Loc 4749 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 4750 Pending.push_back(std::make_pair(D, Loc)); 4751 } 4752 PendingInstantiations.clear(); 4753} 4754 4755void ASTReader::LoadSelector(Selector Sel) { 4756 // It would be complicated to avoid reading the methods anyway. So don't. 4757 ReadMethodPool(Sel); 4758} 4759 4760void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 4761 assert(ID && "Non-zero identifier ID required"); 4762 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4763 IdentifiersLoaded[ID - 1] = II; 4764 if (DeserializationListener) 4765 DeserializationListener->IdentifierRead(ID, II); 4766} 4767 4768/// \brief Set the globally-visible declarations associated with the given 4769/// identifier. 4770/// 4771/// If the AST reader is currently in a state where the given declaration IDs 4772/// cannot safely be resolved, they are queued until it is safe to resolve 4773/// them. 4774/// 4775/// \param II an IdentifierInfo that refers to one or more globally-visible 4776/// declarations. 4777/// 4778/// \param DeclIDs the set of declaration IDs with the name @p II that are 4779/// visible at global scope. 4780/// 4781/// \param Nonrecursive should be true to indicate that the caller knows that 4782/// this call is non-recursive, and therefore the globally-visible declarations 4783/// will not be placed onto the pending queue. 4784void 4785ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4786 const SmallVectorImpl<uint32_t> &DeclIDs, 4787 bool Nonrecursive) { 4788 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4789 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4790 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4791 PII.II = II; 4792 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4793 return; 4794 } 4795 4796 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4797 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4798 if (SemaObj) { 4799 if (SemaObj->TUScope) { 4800 // Introduce this declaration into the translation-unit scope 4801 // and add it to the declaration chain for this identifier, so 4802 // that (unqualified) name lookup will find it. 4803 SemaObj->TUScope->AddDecl(D); 4804 } 4805 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4806 } else { 4807 // Queue this declaration so that it will be added to the 4808 // translation unit scope and identifier's declaration chain 4809 // once a Sema object is known. 4810 PreloadedDecls.push_back(D); 4811 } 4812 } 4813} 4814 4815IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 4816 if (ID == 0) 4817 return 0; 4818 4819 if (IdentifiersLoaded.empty()) { 4820 Error("no identifier table in AST file"); 4821 return 0; 4822 } 4823 4824 assert(PP && "Forgot to set Preprocessor ?"); 4825 ID -= 1; 4826 if (!IdentifiersLoaded[ID]) { 4827 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 4828 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 4829 Module *M = I->second; 4830 unsigned Index = ID - M->BaseIdentifierID; 4831 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 4832 4833 // All of the strings in the AST file are preceded by a 16-bit length. 4834 // Extract that 16-bit length to avoid having to execute strlen(). 4835 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4836 // unsigned integers. This is important to avoid integer overflow when 4837 // we cast them to 'unsigned'. 4838 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4839 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4840 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4841 IdentifiersLoaded[ID] 4842 = &PP->getIdentifierTable().get(StringRef(Str, StrLen)); 4843 if (DeserializationListener) 4844 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4845 } 4846 4847 return IdentifiersLoaded[ID]; 4848} 4849 4850IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) { 4851 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 4852} 4853 4854IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) { 4855 if (LocalID < NUM_PREDEF_IDENT_IDS) 4856 return LocalID; 4857 4858 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4859 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 4860 assert(I != M.IdentifierRemap.end() 4861 && "Invalid index into identifier index remap"); 4862 4863 return LocalID + I->second; 4864} 4865 4866bool ASTReader::ReadSLocEntry(int ID) { 4867 return ReadSLocEntryRecord(ID) != Success; 4868} 4869 4870Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) { 4871 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 4872} 4873 4874Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 4875 if (ID == 0) 4876 return Selector(); 4877 4878 if (ID > SelectorsLoaded.size()) { 4879 Error("selector ID out of range in AST file"); 4880 return Selector(); 4881 } 4882 4883 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4884 // Load this selector from the selector table. 4885 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 4886 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 4887 Module &M = *I->second; 4888 ASTSelectorLookupTrait Trait(*this, M); 4889 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 4890 SelectorsLoaded[ID - 1] = 4891 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 4892 if (DeserializationListener) 4893 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4894 } 4895 4896 return SelectorsLoaded[ID - 1]; 4897} 4898 4899Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 4900 return DecodeSelector(ID); 4901} 4902 4903uint32_t ASTReader::GetNumExternalSelectors() { 4904 // ID 0 (the null selector) is considered an external selector. 4905 return getTotalNumSelectors() + 1; 4906} 4907 4908serialization::SelectorID 4909ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const { 4910 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 4911 return LocalID; 4912 4913 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4914 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 4915 assert(I != M.SelectorRemap.end() 4916 && "Invalid index into identifier index remap"); 4917 4918 return LocalID + I->second; 4919} 4920 4921DeclarationName 4922ASTReader::ReadDeclarationName(Module &F, 4923 const RecordData &Record, unsigned &Idx) { 4924 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 4925 switch (Kind) { 4926 case DeclarationName::Identifier: 4927 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 4928 4929 case DeclarationName::ObjCZeroArgSelector: 4930 case DeclarationName::ObjCOneArgSelector: 4931 case DeclarationName::ObjCMultiArgSelector: 4932 return DeclarationName(ReadSelector(F, Record, Idx)); 4933 4934 case DeclarationName::CXXConstructorName: 4935 return Context->DeclarationNames.getCXXConstructorName( 4936 Context->getCanonicalType(readType(F, Record, Idx))); 4937 4938 case DeclarationName::CXXDestructorName: 4939 return Context->DeclarationNames.getCXXDestructorName( 4940 Context->getCanonicalType(readType(F, Record, Idx))); 4941 4942 case DeclarationName::CXXConversionFunctionName: 4943 return Context->DeclarationNames.getCXXConversionFunctionName( 4944 Context->getCanonicalType(readType(F, Record, Idx))); 4945 4946 case DeclarationName::CXXOperatorName: 4947 return Context->DeclarationNames.getCXXOperatorName( 4948 (OverloadedOperatorKind)Record[Idx++]); 4949 4950 case DeclarationName::CXXLiteralOperatorName: 4951 return Context->DeclarationNames.getCXXLiteralOperatorName( 4952 GetIdentifierInfo(F, Record, Idx)); 4953 4954 case DeclarationName::CXXUsingDirective: 4955 return DeclarationName::getUsingDirectiveName(); 4956 } 4957 4958 // Required to silence GCC warning 4959 return DeclarationName(); 4960} 4961 4962void ASTReader::ReadDeclarationNameLoc(Module &F, 4963 DeclarationNameLoc &DNLoc, 4964 DeclarationName Name, 4965 const RecordData &Record, unsigned &Idx) { 4966 switch (Name.getNameKind()) { 4967 case DeclarationName::CXXConstructorName: 4968 case DeclarationName::CXXDestructorName: 4969 case DeclarationName::CXXConversionFunctionName: 4970 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 4971 break; 4972 4973 case DeclarationName::CXXOperatorName: 4974 DNLoc.CXXOperatorName.BeginOpNameLoc 4975 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4976 DNLoc.CXXOperatorName.EndOpNameLoc 4977 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4978 break; 4979 4980 case DeclarationName::CXXLiteralOperatorName: 4981 DNLoc.CXXLiteralOperatorName.OpNameLoc 4982 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4983 break; 4984 4985 case DeclarationName::Identifier: 4986 case DeclarationName::ObjCZeroArgSelector: 4987 case DeclarationName::ObjCOneArgSelector: 4988 case DeclarationName::ObjCMultiArgSelector: 4989 case DeclarationName::CXXUsingDirective: 4990 break; 4991 } 4992} 4993 4994void ASTReader::ReadDeclarationNameInfo(Module &F, 4995 DeclarationNameInfo &NameInfo, 4996 const RecordData &Record, unsigned &Idx) { 4997 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 4998 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4999 DeclarationNameLoc DNLoc; 5000 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 5001 NameInfo.setInfo(DNLoc); 5002} 5003 5004void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info, 5005 const RecordData &Record, unsigned &Idx) { 5006 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 5007 unsigned NumTPLists = Record[Idx++]; 5008 Info.NumTemplParamLists = NumTPLists; 5009 if (NumTPLists) { 5010 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists]; 5011 for (unsigned i=0; i != NumTPLists; ++i) 5012 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 5013 } 5014} 5015 5016TemplateName 5017ASTReader::ReadTemplateName(Module &F, const RecordData &Record, 5018 unsigned &Idx) { 5019 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 5020 switch (Kind) { 5021 case TemplateName::Template: 5022 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 5023 5024 case TemplateName::OverloadedTemplate: { 5025 unsigned size = Record[Idx++]; 5026 UnresolvedSet<8> Decls; 5027 while (size--) 5028 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5029 5030 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end()); 5031 } 5032 5033 case TemplateName::QualifiedTemplate: { 5034 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5035 bool hasTemplKeyword = Record[Idx++]; 5036 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 5037 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 5038 } 5039 5040 case TemplateName::DependentTemplate: { 5041 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 5042 if (Record[Idx++]) // isIdentifier 5043 return Context->getDependentTemplateName(NNS, 5044 GetIdentifierInfo(F, Record, 5045 Idx)); 5046 return Context->getDependentTemplateName(NNS, 5047 (OverloadedOperatorKind)Record[Idx++]); 5048 } 5049 5050 case TemplateName::SubstTemplateTemplateParm: { 5051 TemplateTemplateParmDecl *param 5052 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5053 if (!param) return TemplateName(); 5054 TemplateName replacement = ReadTemplateName(F, Record, Idx); 5055 return Context->getSubstTemplateTemplateParm(param, replacement); 5056 } 5057 5058 case TemplateName::SubstTemplateTemplateParmPack: { 5059 TemplateTemplateParmDecl *Param 5060 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 5061 if (!Param) 5062 return TemplateName(); 5063 5064 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 5065 if (ArgPack.getKind() != TemplateArgument::Pack) 5066 return TemplateName(); 5067 5068 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack); 5069 } 5070 } 5071 5072 assert(0 && "Unhandled template name kind!"); 5073 return TemplateName(); 5074} 5075 5076TemplateArgument 5077ASTReader::ReadTemplateArgument(Module &F, 5078 const RecordData &Record, unsigned &Idx) { 5079 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5080 switch (Kind) { 5081 case TemplateArgument::Null: 5082 return TemplateArgument(); 5083 case TemplateArgument::Type: 5084 return TemplateArgument(readType(F, Record, Idx)); 5085 case TemplateArgument::Declaration: 5086 return TemplateArgument(ReadDecl(F, Record, Idx)); 5087 case TemplateArgument::Integral: { 5088 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5089 QualType T = readType(F, Record, Idx); 5090 return TemplateArgument(Value, T); 5091 } 5092 case TemplateArgument::Template: 5093 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5094 case TemplateArgument::TemplateExpansion: { 5095 TemplateName Name = ReadTemplateName(F, Record, Idx); 5096 llvm::Optional<unsigned> NumTemplateExpansions; 5097 if (unsigned NumExpansions = Record[Idx++]) 5098 NumTemplateExpansions = NumExpansions - 1; 5099 return TemplateArgument(Name, NumTemplateExpansions); 5100 } 5101 case TemplateArgument::Expression: 5102 return TemplateArgument(ReadExpr(F)); 5103 case TemplateArgument::Pack: { 5104 unsigned NumArgs = Record[Idx++]; 5105 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs]; 5106 for (unsigned I = 0; I != NumArgs; ++I) 5107 Args[I] = ReadTemplateArgument(F, Record, Idx); 5108 return TemplateArgument(Args, NumArgs); 5109 } 5110 } 5111 5112 assert(0 && "Unhandled template argument kind!"); 5113 return TemplateArgument(); 5114} 5115 5116TemplateParameterList * 5117ASTReader::ReadTemplateParameterList(Module &F, 5118 const RecordData &Record, unsigned &Idx) { 5119 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5120 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5121 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5122 5123 unsigned NumParams = Record[Idx++]; 5124 SmallVector<NamedDecl *, 16> Params; 5125 Params.reserve(NumParams); 5126 while (NumParams--) 5127 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5128 5129 TemplateParameterList* TemplateParams = 5130 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc, 5131 Params.data(), Params.size(), RAngleLoc); 5132 return TemplateParams; 5133} 5134 5135void 5136ASTReader:: 5137ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5138 Module &F, const RecordData &Record, 5139 unsigned &Idx) { 5140 unsigned NumTemplateArgs = Record[Idx++]; 5141 TemplArgs.reserve(NumTemplateArgs); 5142 while (NumTemplateArgs--) 5143 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5144} 5145 5146/// \brief Read a UnresolvedSet structure. 5147void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set, 5148 const RecordData &Record, unsigned &Idx) { 5149 unsigned NumDecls = Record[Idx++]; 5150 while (NumDecls--) { 5151 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5152 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5153 Set.addDecl(D, AS); 5154 } 5155} 5156 5157CXXBaseSpecifier 5158ASTReader::ReadCXXBaseSpecifier(Module &F, 5159 const RecordData &Record, unsigned &Idx) { 5160 bool isVirtual = static_cast<bool>(Record[Idx++]); 5161 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5162 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5163 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5164 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5165 SourceRange Range = ReadSourceRange(F, Record, Idx); 5166 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5167 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5168 EllipsisLoc); 5169 Result.setInheritConstructors(inheritConstructors); 5170 return Result; 5171} 5172 5173std::pair<CXXCtorInitializer **, unsigned> 5174ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record, 5175 unsigned &Idx) { 5176 CXXCtorInitializer **CtorInitializers = 0; 5177 unsigned NumInitializers = Record[Idx++]; 5178 if (NumInitializers) { 5179 ASTContext &C = *getContext(); 5180 5181 CtorInitializers 5182 = new (C) CXXCtorInitializer*[NumInitializers]; 5183 for (unsigned i=0; i != NumInitializers; ++i) { 5184 TypeSourceInfo *BaseClassInfo = 0; 5185 bool IsBaseVirtual = false; 5186 FieldDecl *Member = 0; 5187 IndirectFieldDecl *IndirectMember = 0; 5188 CXXConstructorDecl *Target = 0; 5189 5190 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5191 switch (Type) { 5192 case CTOR_INITIALIZER_BASE: 5193 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 5194 IsBaseVirtual = Record[Idx++]; 5195 break; 5196 5197 case CTOR_INITIALIZER_DELEGATING: 5198 Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx); 5199 break; 5200 5201 case CTOR_INITIALIZER_MEMBER: 5202 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5203 break; 5204 5205 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5206 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5207 break; 5208 } 5209 5210 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5211 Expr *Init = ReadExpr(F); 5212 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5213 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5214 bool IsWritten = Record[Idx++]; 5215 unsigned SourceOrderOrNumArrayIndices; 5216 SmallVector<VarDecl *, 8> Indices; 5217 if (IsWritten) { 5218 SourceOrderOrNumArrayIndices = Record[Idx++]; 5219 } else { 5220 SourceOrderOrNumArrayIndices = Record[Idx++]; 5221 Indices.reserve(SourceOrderOrNumArrayIndices); 5222 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5223 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5224 } 5225 5226 CXXCtorInitializer *BOMInit; 5227 if (Type == CTOR_INITIALIZER_BASE) { 5228 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual, 5229 LParenLoc, Init, RParenLoc, 5230 MemberOrEllipsisLoc); 5231 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5232 BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc, 5233 Target, Init, RParenLoc); 5234 } else if (IsWritten) { 5235 if (Member) 5236 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc, 5237 LParenLoc, Init, RParenLoc); 5238 else 5239 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember, 5240 MemberOrEllipsisLoc, LParenLoc, 5241 Init, RParenLoc); 5242 } else { 5243 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc, 5244 LParenLoc, Init, RParenLoc, 5245 Indices.data(), Indices.size()); 5246 } 5247 5248 if (IsWritten) 5249 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5250 CtorInitializers[i] = BOMInit; 5251 } 5252 } 5253 5254 return std::make_pair(CtorInitializers, NumInitializers); 5255} 5256 5257NestedNameSpecifier * 5258ASTReader::ReadNestedNameSpecifier(Module &F, 5259 const RecordData &Record, unsigned &Idx) { 5260 unsigned N = Record[Idx++]; 5261 NestedNameSpecifier *NNS = 0, *Prev = 0; 5262 for (unsigned I = 0; I != N; ++I) { 5263 NestedNameSpecifier::SpecifierKind Kind 5264 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5265 switch (Kind) { 5266 case NestedNameSpecifier::Identifier: { 5267 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5268 NNS = NestedNameSpecifier::Create(*Context, Prev, II); 5269 break; 5270 } 5271 5272 case NestedNameSpecifier::Namespace: { 5273 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5274 NNS = NestedNameSpecifier::Create(*Context, Prev, NS); 5275 break; 5276 } 5277 5278 case NestedNameSpecifier::NamespaceAlias: { 5279 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5280 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias); 5281 break; 5282 } 5283 5284 case NestedNameSpecifier::TypeSpec: 5285 case NestedNameSpecifier::TypeSpecWithTemplate: { 5286 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5287 if (!T) 5288 return 0; 5289 5290 bool Template = Record[Idx++]; 5291 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T); 5292 break; 5293 } 5294 5295 case NestedNameSpecifier::Global: { 5296 NNS = NestedNameSpecifier::GlobalSpecifier(*Context); 5297 // No associated value, and there can't be a prefix. 5298 break; 5299 } 5300 } 5301 Prev = NNS; 5302 } 5303 return NNS; 5304} 5305 5306NestedNameSpecifierLoc 5307ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record, 5308 unsigned &Idx) { 5309 unsigned N = Record[Idx++]; 5310 NestedNameSpecifierLocBuilder Builder; 5311 for (unsigned I = 0; I != N; ++I) { 5312 NestedNameSpecifier::SpecifierKind Kind 5313 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5314 switch (Kind) { 5315 case NestedNameSpecifier::Identifier: { 5316 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5317 SourceRange Range = ReadSourceRange(F, Record, Idx); 5318 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd()); 5319 break; 5320 } 5321 5322 case NestedNameSpecifier::Namespace: { 5323 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5324 SourceRange Range = ReadSourceRange(F, Record, Idx); 5325 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd()); 5326 break; 5327 } 5328 5329 case NestedNameSpecifier::NamespaceAlias: { 5330 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5331 SourceRange Range = ReadSourceRange(F, Record, Idx); 5332 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd()); 5333 break; 5334 } 5335 5336 case NestedNameSpecifier::TypeSpec: 5337 case NestedNameSpecifier::TypeSpecWithTemplate: { 5338 bool Template = Record[Idx++]; 5339 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5340 if (!T) 5341 return NestedNameSpecifierLoc(); 5342 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5343 5344 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5345 Builder.Extend(*Context, 5346 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5347 T->getTypeLoc(), ColonColonLoc); 5348 break; 5349 } 5350 5351 case NestedNameSpecifier::Global: { 5352 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5353 Builder.MakeGlobal(*Context, ColonColonLoc); 5354 break; 5355 } 5356 } 5357 } 5358 5359 return Builder.getWithLocInContext(*Context); 5360} 5361 5362SourceRange 5363ASTReader::ReadSourceRange(Module &F, const RecordData &Record, 5364 unsigned &Idx) { 5365 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5366 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5367 return SourceRange(beg, end); 5368} 5369 5370/// \brief Read an integral value 5371llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5372 unsigned BitWidth = Record[Idx++]; 5373 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5374 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5375 Idx += NumWords; 5376 return Result; 5377} 5378 5379/// \brief Read a signed integral value 5380llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5381 bool isUnsigned = Record[Idx++]; 5382 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5383} 5384 5385/// \brief Read a floating-point value 5386llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5387 return llvm::APFloat(ReadAPInt(Record, Idx)); 5388} 5389 5390// \brief Read a string 5391std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5392 unsigned Len = Record[Idx++]; 5393 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5394 Idx += Len; 5395 return Result; 5396} 5397 5398VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5399 unsigned &Idx) { 5400 unsigned Major = Record[Idx++]; 5401 unsigned Minor = Record[Idx++]; 5402 unsigned Subminor = Record[Idx++]; 5403 if (Minor == 0) 5404 return VersionTuple(Major); 5405 if (Subminor == 0) 5406 return VersionTuple(Major, Minor - 1); 5407 return VersionTuple(Major, Minor - 1, Subminor - 1); 5408} 5409 5410CXXTemporary *ASTReader::ReadCXXTemporary(Module &F, 5411 const RecordData &Record, 5412 unsigned &Idx) { 5413 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5414 return CXXTemporary::Create(*Context, Decl); 5415} 5416 5417DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5418 return Diag(SourceLocation(), DiagID); 5419} 5420 5421DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5422 return Diags.Report(Loc, DiagID); 5423} 5424 5425/// \brief Retrieve the identifier table associated with the 5426/// preprocessor. 5427IdentifierTable &ASTReader::getIdentifierTable() { 5428 assert(PP && "Forgot to set Preprocessor ?"); 5429 return PP->getIdentifierTable(); 5430} 5431 5432/// \brief Record that the given ID maps to the given switch-case 5433/// statement. 5434void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5435 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5436 SwitchCaseStmts[ID] = SC; 5437} 5438 5439/// \brief Retrieve the switch-case statement with the given ID. 5440SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5441 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5442 return SwitchCaseStmts[ID]; 5443} 5444 5445void ASTReader::ClearSwitchCaseIDs() { 5446 SwitchCaseStmts.clear(); 5447} 5448 5449void ASTReader::FinishedDeserializing() { 5450 assert(NumCurrentElementsDeserializing && 5451 "FinishedDeserializing not paired with StartedDeserializing"); 5452 if (NumCurrentElementsDeserializing == 1) { 5453 // If any identifiers with corresponding top-level declarations have 5454 // been loaded, load those declarations now. 5455 while (!PendingIdentifierInfos.empty()) { 5456 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5457 PendingIdentifierInfos.front().DeclIDs, true); 5458 PendingIdentifierInfos.pop_front(); 5459 } 5460 5461 // Ready to load previous declarations of Decls that were delayed. 5462 while (!PendingPreviousDecls.empty()) { 5463 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5464 PendingPreviousDecls.front().second); 5465 PendingPreviousDecls.pop_front(); 5466 } 5467 5468 // We are not in recursive loading, so it's safe to pass the "interesting" 5469 // decls to the consumer. 5470 if (Consumer) 5471 PassInterestingDeclsToConsumer(); 5472 5473 assert(PendingForwardRefs.size() == 0 && 5474 "Some forward refs did not get linked to the definition!"); 5475 } 5476 --NumCurrentElementsDeserializing; 5477} 5478 5479ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context, 5480 StringRef isysroot, bool DisableValidation, 5481 bool DisableStatCache) 5482 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 5483 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 5484 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), 5485 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5486 RelocatablePCH(false), isysroot(isysroot), 5487 DisableValidation(DisableValidation), 5488 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 5489 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 5490 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 5491 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 5492 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 5493 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 5494 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 5495 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 5496 NumCXXBaseSpecifiersLoaded(0) 5497{ 5498 SourceMgr.setExternalSLocEntrySource(this); 5499} 5500 5501ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr, 5502 Diagnostic &Diags, StringRef isysroot, 5503 bool DisableValidation, bool DisableStatCache) 5504 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr), 5505 Diags(Diags), SemaObj(0), PP(0), Context(0), 5506 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5507 RelocatablePCH(false), isysroot(isysroot), 5508 DisableValidation(DisableValidation), DisableStatCache(DisableStatCache), 5509 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0), 5510 TotalNumSLocEntries(0), NumStatementsRead(0), 5511 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 5512 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0), 5513 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0), 5514 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0), 5515 TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0), 5516 NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0) 5517{ 5518 SourceMgr.setExternalSLocEntrySource(this); 5519} 5520 5521ASTReader::~ASTReader() { 5522 // Delete all visible decl lookup tables 5523 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(), 5524 E = DeclContextOffsets.end(); 5525 I != E; ++I) { 5526 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end(); 5527 J != F; ++J) { 5528 if (J->NameLookupTableData) 5529 delete static_cast<ASTDeclContextNameLookupTable*>( 5530 J->NameLookupTableData); 5531 } 5532 } 5533 for (DeclContextVisibleUpdatesPending::iterator 5534 I = PendingVisibleUpdates.begin(), 5535 E = PendingVisibleUpdates.end(); 5536 I != E; ++I) { 5537 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5538 F = I->second.end(); 5539 J != F; ++J) 5540 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 5541 } 5542} 5543 5544Module::Module(ModuleKind Kind) 5545 : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0), 5546 SLocEntryBaseOffset(0), SLocEntryOffsets(0), 5547 SLocFileOffsets(0), LocalNumIdentifiers(0), 5548 IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0), 5549 IdentifierLookupTable(0), BasePreprocessedEntityID(0), 5550 LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0), 5551 BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0), 5552 HeaderFileInfoTableData(0), HeaderFileInfoTable(0), 5553 HeaderFileFrameworkStrings(0), 5554 LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0), 5555 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0), 5556 DeclOffsets(0), BaseDeclID(0), 5557 LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0), 5558 BaseCXXBaseSpecifiersID(0), 5559 LocalNumTypes(0), TypeOffsets(0), BaseTypeIndex(0), StatCache(0), 5560 NumPreallocatedPreprocessingEntities(0) 5561{} 5562 5563Module::~Module() { 5564 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable); 5565 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable); 5566 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable); 5567} 5568 5569template<typename Key, typename Offset, unsigned InitialCapacity> 5570static void 5571dumpLocalRemap(StringRef Name, 5572 const ContinuousRangeMap<Key, Offset, InitialCapacity> &Map) { 5573 if (Map.begin() == Map.end()) 5574 return; 5575 5576 typedef ContinuousRangeMap<Key, Offset, InitialCapacity> MapType; 5577 llvm::errs() << " " << Name << ":\n"; 5578 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 5579 I != IEnd; ++I) { 5580 llvm::errs() << " " << I->first << " -> " << I->second 5581 << "\n"; 5582 } 5583} 5584 5585void Module::dump() { 5586 llvm::errs() << "\nModule: " << FileName << "\n"; 5587 if (!Imports.empty()) { 5588 llvm::errs() << " Imports: "; 5589 for (unsigned I = 0, N = Imports.size(); I != N; ++I) { 5590 if (I) 5591 llvm::errs() << ", "; 5592 llvm::errs() << Imports[I]->FileName; 5593 } 5594 llvm::errs() << "\n"; 5595 } 5596 5597 // Remapping tables. 5598 llvm::errs() << " Base source location offset: " << SLocEntryBaseOffset 5599 << '\n'; 5600 dumpLocalRemap("Source location offset map", SLocRemap); 5601 llvm::errs() << " Base identifier ID: " << BaseIdentifierID << '\n' 5602 << "Number of identifiers: " << LocalNumIdentifiers << '\n'; 5603 dumpLocalRemap("Identifier ID map", IdentifierRemap); 5604 llvm::errs() << " Base type index: " << BaseTypeIndex << '\n' 5605 << " Number of types: " << LocalNumTypes << '\n'; 5606 dumpLocalRemap("Type index map", TypeRemap); 5607 llvm::errs() << " Base decl ID: " << BaseDeclID << '\n' 5608 << " Number of decls: " << LocalNumDecls << '\n'; 5609 dumpLocalRemap("Decl ID map", DeclRemap); 5610} 5611 5612Module *ModuleManager::lookup(StringRef Name) { 5613 const FileEntry *Entry = FileMgr.getFile(Name); 5614 return Modules[Entry]; 5615} 5616 5617llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) { 5618 const FileEntry *Entry = FileMgr.getFile(Name); 5619 return InMemoryBuffers[Entry]; 5620} 5621 5622/// \brief Creates a new module and adds it to the list of known modules 5623Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) { 5624 Module *Prev = !size() ? 0 : &getLastModule(); 5625 Module *Current = new Module(Type); 5626 5627 Current->FileName = FileName.str(); 5628 5629 Chain.push_back(Current); 5630 const FileEntry *Entry = FileMgr.getFile(FileName); 5631 Modules[Entry] = Current; 5632 5633 if (Prev) { 5634 Current->ImportedBy.insert(Prev); 5635 Prev->Imports.insert(Current); 5636 } 5637 5638 return *Current; 5639} 5640 5641void ModuleManager::addInMemoryBuffer(StringRef FileName, 5642 llvm::MemoryBuffer *Buffer) { 5643 5644 const FileEntry *Entry = FileMgr.getVirtualFile(FileName, 5645 Buffer->getBufferSize(), 0); 5646 InMemoryBuffers[Entry] = Buffer; 5647} 5648/// \brief Exports the list of loaded modules with their corresponding names 5649void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) { 5650 Target.reserve(size()); 5651 for (ModuleConstIterator I = Chain.begin(), E = Chain.end(); 5652 I != E; ++I) { 5653 Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset, 5654 (*I)->FileName)); 5655 } 5656 std::sort(Target.begin(), Target.end()); 5657} 5658 5659ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { } 5660 5661ModuleManager::~ModuleManager() { 5662 for (unsigned i = 0, e = Chain.size(); i != e; ++i) 5663 delete Chain[e - i - 1]; 5664} 5665