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