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,