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