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