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