1 //===-- ASTReader.cpp - AST File Reader ----------------------------------===// 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 "ASTCommon.h" 16 #include "ASTReaderInternals.h" 17 #include "clang/AST/ASTConsumer.h" 18 #include "clang/AST/ASTContext.h" 19 #include "clang/AST/DeclTemplate.h" 20 #include "clang/AST/Expr.h" 21 #include "clang/AST/ExprCXX.h" 22 #include "clang/AST/NestedNameSpecifier.h" 23 #include "clang/AST/Type.h" 24 #include "clang/AST/TypeLocVisitor.h" 25 #include "clang/Basic/DiagnosticOptions.h" 26 #include "clang/Basic/FileManager.h" 27 #include "clang/Basic/SourceManager.h" 28 #include "clang/Basic/SourceManagerInternals.h" 29 #include "clang/Basic/TargetInfo.h" 30 #include "clang/Basic/TargetOptions.h" 31 #include "clang/Basic/Version.h" 32 #include "clang/Basic/VersionTuple.h" 33 #include "clang/Frontend/Utils.h" 34 #include "clang/Lex/HeaderSearch.h" 35 #include "clang/Lex/HeaderSearchOptions.h" 36 #include "clang/Lex/MacroInfo.h" 37 #include "clang/Lex/PreprocessingRecord.h" 38 #include "clang/Lex/Preprocessor.h" 39 #include "clang/Lex/PreprocessorOptions.h" 40 #include "clang/Sema/Scope.h" 41 #include "clang/Sema/Sema.h" 42 #include "clang/Serialization/ASTDeserializationListener.h" 43 #include "clang/Serialization/GlobalModuleIndex.h" 44 #include "clang/Serialization/ModuleManager.h" 45 #include "clang/Serialization/SerializationDiagnostic.h" 46 #include "llvm/ADT/Hashing.h" 47 #include "llvm/ADT/StringExtras.h" 48 #include "llvm/Bitcode/BitstreamReader.h" 49 #include "llvm/Support/ErrorHandling.h" 50 #include "llvm/Support/FileSystem.h" 51 #include "llvm/Support/MemoryBuffer.h" 52 #include "llvm/Support/Path.h" 53 #include "llvm/Support/SaveAndRestore.h" 54 #include "llvm/Support/raw_ostream.h" 55 #include <algorithm> 56 #include <cstdio> 57 #include <iterator> 58 #include <system_error> 59 60 using namespace clang; 61 using namespace clang::serialization; 62 using namespace clang::serialization::reader; 63 using llvm::BitstreamCursor; 64 65 66 //===----------------------------------------------------------------------===// 67 // ChainedASTReaderListener implementation 68 //===----------------------------------------------------------------------===// 69 70 bool 71 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) { 72 return First->ReadFullVersionInformation(FullVersion) || 73 Second->ReadFullVersionInformation(FullVersion); 74 } 75 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) { 76 First->ReadModuleName(ModuleName); 77 Second->ReadModuleName(ModuleName); 78 } 79 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) { 80 First->ReadModuleMapFile(ModuleMapPath); 81 Second->ReadModuleMapFile(ModuleMapPath); 82 } 83 bool 84 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts, 85 bool Complain, 86 bool AllowCompatibleDifferences) { 87 return First->ReadLanguageOptions(LangOpts, Complain, 88 AllowCompatibleDifferences) || 89 Second->ReadLanguageOptions(LangOpts, Complain, 90 AllowCompatibleDifferences); 91 } 92 bool ChainedASTReaderListener::ReadTargetOptions( 93 const TargetOptions &TargetOpts, bool Complain, 94 bool AllowCompatibleDifferences) { 95 return First->ReadTargetOptions(TargetOpts, Complain, 96 AllowCompatibleDifferences) || 97 Second->ReadTargetOptions(TargetOpts, Complain, 98 AllowCompatibleDifferences); 99 } 100 bool ChainedASTReaderListener::ReadDiagnosticOptions( 101 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) { 102 return First->ReadDiagnosticOptions(DiagOpts, Complain) || 103 Second->ReadDiagnosticOptions(DiagOpts, Complain); 104 } 105 bool 106 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts, 107 bool Complain) { 108 return First->ReadFileSystemOptions(FSOpts, Complain) || 109 Second->ReadFileSystemOptions(FSOpts, Complain); 110 } 111 112 bool ChainedASTReaderListener::ReadHeaderSearchOptions( 113 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, 114 bool Complain) { 115 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath, 116 Complain) || 117 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath, 118 Complain); 119 } 120 bool ChainedASTReaderListener::ReadPreprocessorOptions( 121 const PreprocessorOptions &PPOpts, bool Complain, 122 std::string &SuggestedPredefines) { 123 return First->ReadPreprocessorOptions(PPOpts, Complain, 124 SuggestedPredefines) || 125 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines); 126 } 127 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M, 128 unsigned Value) { 129 First->ReadCounter(M, Value); 130 Second->ReadCounter(M, Value); 131 } 132 bool ChainedASTReaderListener::needsInputFileVisitation() { 133 return First->needsInputFileVisitation() || 134 Second->needsInputFileVisitation(); 135 } 136 bool ChainedASTReaderListener::needsSystemInputFileVisitation() { 137 return First->needsSystemInputFileVisitation() || 138 Second->needsSystemInputFileVisitation(); 139 } 140 void ChainedASTReaderListener::visitModuleFile(StringRef Filename) { 141 First->visitModuleFile(Filename); 142 Second->visitModuleFile(Filename); 143 } 144 bool ChainedASTReaderListener::visitInputFile(StringRef Filename, 145 bool isSystem, 146 bool isOverridden) { 147 bool Continue = false; 148 if (First->needsInputFileVisitation() && 149 (!isSystem || First->needsSystemInputFileVisitation())) 150 Continue |= First->visitInputFile(Filename, isSystem, isOverridden); 151 if (Second->needsInputFileVisitation() && 152 (!isSystem || Second->needsSystemInputFileVisitation())) 153 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden); 154 return Continue; 155 } 156 157 //===----------------------------------------------------------------------===// 158 // PCH validator implementation 159 //===----------------------------------------------------------------------===// 160 161 ASTReaderListener::~ASTReaderListener() {} 162 163 /// \brief Compare the given set of language options against an existing set of 164 /// language options. 165 /// 166 /// \param Diags If non-NULL, diagnostics will be emitted via this engine. 167 /// \param AllowCompatibleDifferences If true, differences between compatible 168 /// language options will be permitted. 169 /// 170 /// \returns true if the languagae options mis-match, false otherwise. 171 static bool checkLanguageOptions(const LangOptions &LangOpts, 172 const LangOptions &ExistingLangOpts, 173 DiagnosticsEngine *Diags, 174 bool AllowCompatibleDifferences = true) { 175 #define LANGOPT(Name, Bits, Default, Description) \ 176 if (ExistingLangOpts.Name != LangOpts.Name) { \ 177 if (Diags) \ 178 Diags->Report(diag::err_pch_langopt_mismatch) \ 179 << Description << LangOpts.Name << ExistingLangOpts.Name; \ 180 return true; \ 181 } 182 183 #define VALUE_LANGOPT(Name, Bits, Default, Description) \ 184 if (ExistingLangOpts.Name != LangOpts.Name) { \ 185 if (Diags) \ 186 Diags->Report(diag::err_pch_langopt_value_mismatch) \ 187 << Description; \ 188 return true; \ 189 } 190 191 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 192 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \ 193 if (Diags) \ 194 Diags->Report(diag::err_pch_langopt_value_mismatch) \ 195 << Description; \ 196 return true; \ 197 } 198 199 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \ 200 if (!AllowCompatibleDifferences) \ 201 LANGOPT(Name, Bits, Default, Description) 202 203 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \ 204 if (!AllowCompatibleDifferences) \ 205 ENUM_LANGOPT(Name, Bits, Default, Description) 206 207 #define BENIGN_LANGOPT(Name, Bits, Default, Description) 208 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) 209 #include "clang/Basic/LangOptions.def" 210 211 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) { 212 if (Diags) 213 Diags->Report(diag::err_pch_langopt_value_mismatch) 214 << "target Objective-C runtime"; 215 return true; 216 } 217 218 if (ExistingLangOpts.CommentOpts.BlockCommandNames != 219 LangOpts.CommentOpts.BlockCommandNames) { 220 if (Diags) 221 Diags->Report(diag::err_pch_langopt_value_mismatch) 222 << "block command names"; 223 return true; 224 } 225 226 return false; 227 } 228 229 /// \brief Compare the given set of target options against an existing set of 230 /// target options. 231 /// 232 /// \param Diags If non-NULL, diagnostics will be emitted via this engine. 233 /// 234 /// \returns true if the target options mis-match, false otherwise. 235 static bool checkTargetOptions(const TargetOptions &TargetOpts, 236 const TargetOptions &ExistingTargetOpts, 237 DiagnosticsEngine *Diags, 238 bool AllowCompatibleDifferences = true) { 239 #define CHECK_TARGET_OPT(Field, Name) \ 240 if (TargetOpts.Field != ExistingTargetOpts.Field) { \ 241 if (Diags) \ 242 Diags->Report(diag::err_pch_targetopt_mismatch) \ 243 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \ 244 return true; \ 245 } 246 247 // The triple and ABI must match exactly. 248 CHECK_TARGET_OPT(Triple, "target"); 249 CHECK_TARGET_OPT(ABI, "target ABI"); 250 251 // We can tolerate different CPUs in many cases, notably when one CPU 252 // supports a strict superset of another. When allowing compatible 253 // differences skip this check. 254 if (!AllowCompatibleDifferences) 255 CHECK_TARGET_OPT(CPU, "target CPU"); 256 257 #undef CHECK_TARGET_OPT 258 259 // Compare feature sets. 260 SmallVector<StringRef, 4> ExistingFeatures( 261 ExistingTargetOpts.FeaturesAsWritten.begin(), 262 ExistingTargetOpts.FeaturesAsWritten.end()); 263 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(), 264 TargetOpts.FeaturesAsWritten.end()); 265 std::sort(ExistingFeatures.begin(), ExistingFeatures.end()); 266 std::sort(ReadFeatures.begin(), ReadFeatures.end()); 267 268 // We compute the set difference in both directions explicitly so that we can 269 // diagnose the differences differently. 270 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures; 271 std::set_difference( 272 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(), 273 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures)); 274 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(), 275 ExistingFeatures.begin(), ExistingFeatures.end(), 276 std::back_inserter(UnmatchedReadFeatures)); 277 278 // If we are allowing compatible differences and the read feature set is 279 // a strict subset of the existing feature set, there is nothing to diagnose. 280 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty()) 281 return false; 282 283 if (Diags) { 284 for (StringRef Feature : UnmatchedReadFeatures) 285 Diags->Report(diag::err_pch_targetopt_feature_mismatch) 286 << /* is-existing-feature */ false << Feature; 287 for (StringRef Feature : UnmatchedExistingFeatures) 288 Diags->Report(diag::err_pch_targetopt_feature_mismatch) 289 << /* is-existing-feature */ true << Feature; 290 } 291 292 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty(); 293 } 294 295 bool 296 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts, 297 bool Complain, 298 bool AllowCompatibleDifferences) { 299 const LangOptions &ExistingLangOpts = PP.getLangOpts(); 300 return checkLanguageOptions(LangOpts, ExistingLangOpts, 301 Complain ? &Reader.Diags : nullptr, 302 AllowCompatibleDifferences); 303 } 304 305 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts, 306 bool Complain, 307 bool AllowCompatibleDifferences) { 308 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts(); 309 return checkTargetOptions(TargetOpts, ExistingTargetOpts, 310 Complain ? &Reader.Diags : nullptr, 311 AllowCompatibleDifferences); 312 } 313 314 namespace { 315 typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> > 316 MacroDefinitionsMap; 317 typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > 318 DeclsMap; 319 } 320 321 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags, 322 DiagnosticsEngine &Diags, 323 bool Complain) { 324 typedef DiagnosticsEngine::Level Level; 325 326 // Check current mappings for new -Werror mappings, and the stored mappings 327 // for cases that were explicitly mapped to *not* be errors that are now 328 // errors because of options like -Werror. 329 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags }; 330 331 for (DiagnosticsEngine *MappingSource : MappingSources) { 332 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) { 333 diag::kind DiagID = DiagIDMappingPair.first; 334 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation()); 335 if (CurLevel < DiagnosticsEngine::Error) 336 continue; // not significant 337 Level StoredLevel = 338 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation()); 339 if (StoredLevel < DiagnosticsEngine::Error) { 340 if (Complain) 341 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" + 342 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str(); 343 return true; 344 } 345 } 346 } 347 348 return false; 349 } 350 351 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) { 352 diag::Severity Ext = Diags.getExtensionHandlingBehavior(); 353 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors()) 354 return true; 355 return Ext >= diag::Severity::Error; 356 } 357 358 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags, 359 DiagnosticsEngine &Diags, 360 bool IsSystem, bool Complain) { 361 // Top-level options 362 if (IsSystem) { 363 if (Diags.getSuppressSystemWarnings()) 364 return false; 365 // If -Wsystem-headers was not enabled before, be conservative 366 if (StoredDiags.getSuppressSystemWarnings()) { 367 if (Complain) 368 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers"; 369 return true; 370 } 371 } 372 373 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) { 374 if (Complain) 375 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror"; 376 return true; 377 } 378 379 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() && 380 !StoredDiags.getEnableAllWarnings()) { 381 if (Complain) 382 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror"; 383 return true; 384 } 385 386 if (isExtHandlingFromDiagsError(Diags) && 387 !isExtHandlingFromDiagsError(StoredDiags)) { 388 if (Complain) 389 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors"; 390 return true; 391 } 392 393 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain); 394 } 395 396 bool PCHValidator::ReadDiagnosticOptions( 397 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) { 398 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics(); 399 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs()); 400 IntrusiveRefCntPtr<DiagnosticsEngine> Diags( 401 new DiagnosticsEngine(DiagIDs, DiagOpts.get())); 402 // This should never fail, because we would have processed these options 403 // before writing them to an ASTFile. 404 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false); 405 406 ModuleManager &ModuleMgr = Reader.getModuleManager(); 407 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then"); 408 409 // If the original import came from a file explicitly generated by the user, 410 // don't check the diagnostic mappings. 411 // FIXME: currently this is approximated by checking whether this is not a 412 // module import of an implicitly-loaded module file. 413 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in 414 // the transitive closure of its imports, since unrelated modules cannot be 415 // imported until after this module finishes validation. 416 ModuleFile *TopImport = *ModuleMgr.rbegin(); 417 while (!TopImport->ImportedBy.empty()) 418 TopImport = TopImport->ImportedBy[0]; 419 if (TopImport->Kind != MK_ImplicitModule) 420 return false; 421 422 StringRef ModuleName = TopImport->ModuleName; 423 assert(!ModuleName.empty() && "diagnostic options read before module name"); 424 425 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName); 426 assert(M && "missing module"); 427 428 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that 429 // contains the union of their flags. 430 return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain); 431 } 432 433 /// \brief Collect the macro definitions provided by the given preprocessor 434 /// options. 435 static void 436 collectMacroDefinitions(const PreprocessorOptions &PPOpts, 437 MacroDefinitionsMap &Macros, 438 SmallVectorImpl<StringRef> *MacroNames = nullptr) { 439 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { 440 StringRef Macro = PPOpts.Macros[I].first; 441 bool IsUndef = PPOpts.Macros[I].second; 442 443 std::pair<StringRef, StringRef> MacroPair = Macro.split('='); 444 StringRef MacroName = MacroPair.first; 445 StringRef MacroBody = MacroPair.second; 446 447 // For an #undef'd macro, we only care about the name. 448 if (IsUndef) { 449 if (MacroNames && !Macros.count(MacroName)) 450 MacroNames->push_back(MacroName); 451 452 Macros[MacroName] = std::make_pair("", true); 453 continue; 454 } 455 456 // For a #define'd macro, figure out the actual definition. 457 if (MacroName.size() == Macro.size()) 458 MacroBody = "1"; 459 else { 460 // Note: GCC drops anything following an end-of-line character. 461 StringRef::size_type End = MacroBody.find_first_of("\n\r"); 462 MacroBody = MacroBody.substr(0, End); 463 } 464 465 if (MacroNames && !Macros.count(MacroName)) 466 MacroNames->push_back(MacroName); 467 Macros[MacroName] = std::make_pair(MacroBody, false); 468 } 469 } 470 471 /// \brief Check the preprocessor options deserialized from the control block 472 /// against the preprocessor options in an existing preprocessor. 473 /// 474 /// \param Diags If non-null, produce diagnostics for any mismatches incurred. 475 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts, 476 const PreprocessorOptions &ExistingPPOpts, 477 DiagnosticsEngine *Diags, 478 FileManager &FileMgr, 479 std::string &SuggestedPredefines, 480 const LangOptions &LangOpts) { 481 // Check macro definitions. 482 MacroDefinitionsMap ASTFileMacros; 483 collectMacroDefinitions(PPOpts, ASTFileMacros); 484 MacroDefinitionsMap ExistingMacros; 485 SmallVector<StringRef, 4> ExistingMacroNames; 486 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames); 487 488 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) { 489 // Dig out the macro definition in the existing preprocessor options. 490 StringRef MacroName = ExistingMacroNames[I]; 491 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName]; 492 493 // Check whether we know anything about this macro name or not. 494 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known 495 = ASTFileMacros.find(MacroName); 496 if (Known == ASTFileMacros.end()) { 497 // FIXME: Check whether this identifier was referenced anywhere in the 498 // AST file. If so, we should reject the AST file. Unfortunately, this 499 // information isn't in the control block. What shall we do about it? 500 501 if (Existing.second) { 502 SuggestedPredefines += "#undef "; 503 SuggestedPredefines += MacroName.str(); 504 SuggestedPredefines += '\n'; 505 } else { 506 SuggestedPredefines += "#define "; 507 SuggestedPredefines += MacroName.str(); 508 SuggestedPredefines += ' '; 509 SuggestedPredefines += Existing.first.str(); 510 SuggestedPredefines += '\n'; 511 } 512 continue; 513 } 514 515 // If the macro was defined in one but undef'd in the other, we have a 516 // conflict. 517 if (Existing.second != Known->second.second) { 518 if (Diags) { 519 Diags->Report(diag::err_pch_macro_def_undef) 520 << MacroName << Known->second.second; 521 } 522 return true; 523 } 524 525 // If the macro was #undef'd in both, or if the macro bodies are identical, 526 // it's fine. 527 if (Existing.second || Existing.first == Known->second.first) 528 continue; 529 530 // The macro bodies differ; complain. 531 if (Diags) { 532 Diags->Report(diag::err_pch_macro_def_conflict) 533 << MacroName << Known->second.first << Existing.first; 534 } 535 return true; 536 } 537 538 // Check whether we're using predefines. 539 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) { 540 if (Diags) { 541 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines; 542 } 543 return true; 544 } 545 546 // Detailed record is important since it is used for the module cache hash. 547 if (LangOpts.Modules && 548 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) { 549 if (Diags) { 550 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord; 551 } 552 return true; 553 } 554 555 // Compute the #include and #include_macros lines we need. 556 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) { 557 StringRef File = ExistingPPOpts.Includes[I]; 558 if (File == ExistingPPOpts.ImplicitPCHInclude) 559 continue; 560 561 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File) 562 != PPOpts.Includes.end()) 563 continue; 564 565 SuggestedPredefines += "#include \""; 566 SuggestedPredefines += File; 567 SuggestedPredefines += "\"\n"; 568 } 569 570 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) { 571 StringRef File = ExistingPPOpts.MacroIncludes[I]; 572 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(), 573 File) 574 != PPOpts.MacroIncludes.end()) 575 continue; 576 577 SuggestedPredefines += "#__include_macros \""; 578 SuggestedPredefines += File; 579 SuggestedPredefines += "\"\n##\n"; 580 } 581 582 return false; 583 } 584 585 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 586 bool Complain, 587 std::string &SuggestedPredefines) { 588 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts(); 589 590 return checkPreprocessorOptions(PPOpts, ExistingPPOpts, 591 Complain? &Reader.Diags : nullptr, 592 PP.getFileManager(), 593 SuggestedPredefines, 594 PP.getLangOpts()); 595 } 596 597 /// Check the header search options deserialized from the control block 598 /// against the header search options in an existing preprocessor. 599 /// 600 /// \param Diags If non-null, produce diagnostics for any mismatches incurred. 601 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts, 602 StringRef SpecificModuleCachePath, 603 StringRef ExistingModuleCachePath, 604 DiagnosticsEngine *Diags, 605 const LangOptions &LangOpts) { 606 if (LangOpts.Modules) { 607 if (SpecificModuleCachePath != ExistingModuleCachePath) { 608 if (Diags) 609 Diags->Report(diag::err_pch_modulecache_mismatch) 610 << SpecificModuleCachePath << ExistingModuleCachePath; 611 return true; 612 } 613 } 614 615 return false; 616 } 617 618 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, 619 StringRef SpecificModuleCachePath, 620 bool Complain) { 621 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath, 622 PP.getHeaderSearchInfo().getModuleCachePath(), 623 Complain ? &Reader.Diags : nullptr, 624 PP.getLangOpts()); 625 } 626 627 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) { 628 PP.setCounterValue(Value); 629 } 630 631 //===----------------------------------------------------------------------===// 632 // AST reader implementation 633 //===----------------------------------------------------------------------===// 634 635 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener, 636 bool TakeOwnership) { 637 DeserializationListener = Listener; 638 OwnsDeserializationListener = TakeOwnership; 639 } 640 641 642 643 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) { 644 return serialization::ComputeHash(Sel); 645 } 646 647 648 std::pair<unsigned, unsigned> 649 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 650 using namespace llvm::support; 651 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d); 652 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d); 653 return std::make_pair(KeyLen, DataLen); 654 } 655 656 ASTSelectorLookupTrait::internal_key_type 657 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) { 658 using namespace llvm::support; 659 SelectorTable &SelTable = Reader.getContext().Selectors; 660 unsigned N = endian::readNext<uint16_t, little, unaligned>(d); 661 IdentifierInfo *FirstII = Reader.getLocalIdentifier( 662 F, endian::readNext<uint32_t, little, unaligned>(d)); 663 if (N == 0) 664 return SelTable.getNullarySelector(FirstII); 665 else if (N == 1) 666 return SelTable.getUnarySelector(FirstII); 667 668 SmallVector<IdentifierInfo *, 16> Args; 669 Args.push_back(FirstII); 670 for (unsigned I = 1; I != N; ++I) 671 Args.push_back(Reader.getLocalIdentifier( 672 F, endian::readNext<uint32_t, little, unaligned>(d))); 673 674 return SelTable.getSelector(N, Args.data()); 675 } 676 677 ASTSelectorLookupTrait::data_type 678 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d, 679 unsigned DataLen) { 680 using namespace llvm::support; 681 682 data_type Result; 683 684 Result.ID = Reader.getGlobalSelectorID( 685 F, endian::readNext<uint32_t, little, unaligned>(d)); 686 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d); 687 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d); 688 Result.InstanceBits = FullInstanceBits & 0x3; 689 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1; 690 Result.FactoryBits = FullFactoryBits & 0x3; 691 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1; 692 unsigned NumInstanceMethods = FullInstanceBits >> 3; 693 unsigned NumFactoryMethods = FullFactoryBits >> 3; 694 695 // Load instance methods 696 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 697 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>( 698 F, endian::readNext<uint32_t, little, unaligned>(d))) 699 Result.Instance.push_back(Method); 700 } 701 702 // Load factory methods 703 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 704 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>( 705 F, endian::readNext<uint32_t, little, unaligned>(d))) 706 Result.Factory.push_back(Method); 707 } 708 709 return Result; 710 } 711 712 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) { 713 return llvm::HashString(a); 714 } 715 716 std::pair<unsigned, unsigned> 717 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) { 718 using namespace llvm::support; 719 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d); 720 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d); 721 return std::make_pair(KeyLen, DataLen); 722 } 723 724 ASTIdentifierLookupTraitBase::internal_key_type 725 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) { 726 assert(n >= 2 && d[n-1] == '\0'); 727 return StringRef((const char*) d, n-1); 728 } 729 730 /// \brief Whether the given identifier is "interesting". 731 static bool isInterestingIdentifier(IdentifierInfo &II) { 732 return II.isPoisoned() || 733 II.isExtensionToken() || 734 II.getObjCOrBuiltinID() || 735 II.hasRevertedTokenIDToIdentifier() || 736 II.hadMacroDefinition() || 737 II.getFETokenInfo<void>(); 738 } 739 740 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k, 741 const unsigned char* d, 742 unsigned DataLen) { 743 using namespace llvm::support; 744 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d); 745 bool IsInteresting = RawID & 0x01; 746 747 // Wipe out the "is interesting" bit. 748 RawID = RawID >> 1; 749 750 IdentID ID = Reader.getGlobalIdentifierID(F, RawID); 751 if (!IsInteresting) { 752 // For uninteresting identifiers, just build the IdentifierInfo 753 // and associate it with the persistent ID. 754 IdentifierInfo *II = KnownII; 755 if (!II) { 756 II = &Reader.getIdentifierTable().getOwn(k); 757 KnownII = II; 758 } 759 Reader.SetIdentifierInfo(ID, II); 760 if (!II->isFromAST()) { 761 bool WasInteresting = isInterestingIdentifier(*II); 762 II->setIsFromAST(); 763 if (WasInteresting) 764 II->setChangedSinceDeserialization(); 765 } 766 Reader.markIdentifierUpToDate(II); 767 return II; 768 } 769 770 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d); 771 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d); 772 bool CPlusPlusOperatorKeyword = Bits & 0x01; 773 Bits >>= 1; 774 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 775 Bits >>= 1; 776 bool Poisoned = Bits & 0x01; 777 Bits >>= 1; 778 bool ExtensionToken = Bits & 0x01; 779 Bits >>= 1; 780 bool hasSubmoduleMacros = Bits & 0x01; 781 Bits >>= 1; 782 bool hadMacroDefinition = Bits & 0x01; 783 Bits >>= 1; 784 785 assert(Bits == 0 && "Extra bits in the identifier?"); 786 DataLen -= 8; 787 788 // Build the IdentifierInfo itself and link the identifier ID with 789 // the new IdentifierInfo. 790 IdentifierInfo *II = KnownII; 791 if (!II) { 792 II = &Reader.getIdentifierTable().getOwn(StringRef(k)); 793 KnownII = II; 794 } 795 Reader.markIdentifierUpToDate(II); 796 if (!II->isFromAST()) { 797 bool WasInteresting = isInterestingIdentifier(*II); 798 II->setIsFromAST(); 799 if (WasInteresting) 800 II->setChangedSinceDeserialization(); 801 } 802 803 // Set or check the various bits in the IdentifierInfo structure. 804 // Token IDs are read-only. 805 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier) 806 II->RevertTokenIDToIdentifier(); 807 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 808 assert(II->isExtensionToken() == ExtensionToken && 809 "Incorrect extension token flag"); 810 (void)ExtensionToken; 811 if (Poisoned) 812 II->setIsPoisoned(true); 813 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 814 "Incorrect C++ operator keyword flag"); 815 (void)CPlusPlusOperatorKeyword; 816 817 // If this identifier is a macro, deserialize the macro 818 // definition. 819 if (hadMacroDefinition) { 820 uint32_t MacroDirectivesOffset = 821 endian::readNext<uint32_t, little, unaligned>(d); 822 DataLen -= 4; 823 SmallVector<uint32_t, 8> LocalMacroIDs; 824 if (hasSubmoduleMacros) { 825 while (true) { 826 uint32_t LocalMacroID = 827 endian::readNext<uint32_t, little, unaligned>(d); 828 DataLen -= 4; 829 if (LocalMacroID == (uint32_t)-1) break; 830 LocalMacroIDs.push_back(LocalMacroID); 831 } 832 } 833 834 if (F.Kind == MK_ImplicitModule || F.Kind == MK_ExplicitModule) { 835 // Macro definitions are stored from newest to oldest, so reverse them 836 // before registering them. 837 llvm::SmallVector<unsigned, 8> MacroSizes; 838 for (SmallVectorImpl<uint32_t>::iterator 839 I = LocalMacroIDs.begin(), E = LocalMacroIDs.end(); I != E; /**/) { 840 unsigned Size = 1; 841 842 static const uint32_t HasOverridesFlag = 0x80000000U; 843 if (I + 1 != E && (I[1] & HasOverridesFlag)) 844 Size += 1 + (I[1] & ~HasOverridesFlag); 845 846 MacroSizes.push_back(Size); 847 I += Size; 848 } 849 850 SmallVectorImpl<uint32_t>::iterator I = LocalMacroIDs.end(); 851 for (SmallVectorImpl<unsigned>::reverse_iterator SI = MacroSizes.rbegin(), 852 SE = MacroSizes.rend(); 853 SI != SE; ++SI) { 854 I -= *SI; 855 856 uint32_t LocalMacroID = *I; 857 ArrayRef<uint32_t> Overrides; 858 if (*SI != 1) 859 Overrides = llvm::makeArrayRef(&I[2], *SI - 2); 860 Reader.addPendingMacroFromModule(II, &F, LocalMacroID, Overrides); 861 } 862 assert(I == LocalMacroIDs.begin()); 863 } else { 864 Reader.addPendingMacroFromPCH(II, &F, MacroDirectivesOffset); 865 } 866 } 867 868 Reader.SetIdentifierInfo(ID, II); 869 870 // Read all of the declarations visible at global scope with this 871 // name. 872 if (DataLen > 0) { 873 SmallVector<uint32_t, 4> DeclIDs; 874 for (; DataLen > 0; DataLen -= 4) 875 DeclIDs.push_back(Reader.getGlobalDeclID( 876 F, endian::readNext<uint32_t, little, unaligned>(d))); 877 Reader.SetGloballyVisibleDecls(II, DeclIDs); 878 } 879 880 return II; 881 } 882 883 unsigned 884 ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const { 885 llvm::FoldingSetNodeID ID; 886 ID.AddInteger(Key.Kind); 887 888 switch (Key.Kind) { 889 case DeclarationName::Identifier: 890 case DeclarationName::CXXLiteralOperatorName: 891 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 892 break; 893 case DeclarationName::ObjCZeroArgSelector: 894 case DeclarationName::ObjCOneArgSelector: 895 case DeclarationName::ObjCMultiArgSelector: 896 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 897 break; 898 case DeclarationName::CXXOperatorName: 899 ID.AddInteger((OverloadedOperatorKind)Key.Data); 900 break; 901 case DeclarationName::CXXConstructorName: 902 case DeclarationName::CXXDestructorName: 903 case DeclarationName::CXXConversionFunctionName: 904 case DeclarationName::CXXUsingDirective: 905 break; 906 } 907 908 return ID.ComputeHash(); 909 } 910 911 ASTDeclContextNameLookupTrait::internal_key_type 912 ASTDeclContextNameLookupTrait::GetInternalKey( 913 const external_key_type& Name) const { 914 DeclNameKey Key; 915 Key.Kind = Name.getNameKind(); 916 switch (Name.getNameKind()) { 917 case DeclarationName::Identifier: 918 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 919 break; 920 case DeclarationName::ObjCZeroArgSelector: 921 case DeclarationName::ObjCOneArgSelector: 922 case DeclarationName::ObjCMultiArgSelector: 923 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 924 break; 925 case DeclarationName::CXXOperatorName: 926 Key.Data = Name.getCXXOverloadedOperator(); 927 break; 928 case DeclarationName::CXXLiteralOperatorName: 929 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 930 break; 931 case DeclarationName::CXXConstructorName: 932 case DeclarationName::CXXDestructorName: 933 case DeclarationName::CXXConversionFunctionName: 934 case DeclarationName::CXXUsingDirective: 935 Key.Data = 0; 936 break; 937 } 938 939 return Key; 940 } 941 942 std::pair<unsigned, unsigned> 943 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 944 using namespace llvm::support; 945 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d); 946 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d); 947 return std::make_pair(KeyLen, DataLen); 948 } 949 950 ASTDeclContextNameLookupTrait::internal_key_type 951 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) { 952 using namespace llvm::support; 953 954 DeclNameKey Key; 955 Key.Kind = (DeclarationName::NameKind)*d++; 956 switch (Key.Kind) { 957 case DeclarationName::Identifier: 958 Key.Data = (uint64_t)Reader.getLocalIdentifier( 959 F, endian::readNext<uint32_t, little, unaligned>(d)); 960 break; 961 case DeclarationName::ObjCZeroArgSelector: 962 case DeclarationName::ObjCOneArgSelector: 963 case DeclarationName::ObjCMultiArgSelector: 964 Key.Data = 965 (uint64_t)Reader.getLocalSelector( 966 F, endian::readNext<uint32_t, little, unaligned>( 967 d)).getAsOpaquePtr(); 968 break; 969 case DeclarationName::CXXOperatorName: 970 Key.Data = *d++; // OverloadedOperatorKind 971 break; 972 case DeclarationName::CXXLiteralOperatorName: 973 Key.Data = (uint64_t)Reader.getLocalIdentifier( 974 F, endian::readNext<uint32_t, little, unaligned>(d)); 975 break; 976 case DeclarationName::CXXConstructorName: 977 case DeclarationName::CXXDestructorName: 978 case DeclarationName::CXXConversionFunctionName: 979 case DeclarationName::CXXUsingDirective: 980 Key.Data = 0; 981 break; 982 } 983 984 return Key; 985 } 986 987 ASTDeclContextNameLookupTrait::data_type 988 ASTDeclContextNameLookupTrait::ReadData(internal_key_type, 989 const unsigned char* d, 990 unsigned DataLen) { 991 using namespace llvm::support; 992 unsigned NumDecls = endian::readNext<uint16_t, little, unaligned>(d); 993 LE32DeclID *Start = reinterpret_cast<LE32DeclID *>( 994 const_cast<unsigned char *>(d)); 995 return std::make_pair(Start, Start + NumDecls); 996 } 997 998 bool ASTReader::ReadDeclContextStorage(ModuleFile &M, 999 BitstreamCursor &Cursor, 1000 const std::pair<uint64_t, uint64_t> &Offsets, 1001 DeclContextInfo &Info) { 1002 SavedStreamPosition SavedPosition(Cursor); 1003 // First the lexical decls. 1004 if (Offsets.first != 0) { 1005 Cursor.JumpToBit(Offsets.first); 1006 1007 RecordData Record; 1008 StringRef Blob; 1009 unsigned Code = Cursor.ReadCode(); 1010 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob); 1011 if (RecCode != DECL_CONTEXT_LEXICAL) { 1012 Error("Expected lexical block"); 1013 return true; 1014 } 1015 1016 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob.data()); 1017 Info.NumLexicalDecls = Blob.size() / sizeof(KindDeclIDPair); 1018 } 1019 1020 // Now the lookup table. 1021 if (Offsets.second != 0) { 1022 Cursor.JumpToBit(Offsets.second); 1023 1024 RecordData Record; 1025 StringRef Blob; 1026 unsigned Code = Cursor.ReadCode(); 1027 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob); 1028 if (RecCode != DECL_CONTEXT_VISIBLE) { 1029 Error("Expected visible lookup table block"); 1030 return true; 1031 } 1032 Info.NameLookupTableData = ASTDeclContextNameLookupTable::Create( 1033 (const unsigned char *)Blob.data() + Record[0], 1034 (const unsigned char *)Blob.data() + sizeof(uint32_t), 1035 (const unsigned char *)Blob.data(), 1036 ASTDeclContextNameLookupTrait(*this, M)); 1037 } 1038 1039 return false; 1040 } 1041 1042 void ASTReader::Error(StringRef Msg) { 1043 Error(diag::err_fe_pch_malformed, Msg); 1044 if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight()) { 1045 Diag(diag::note_module_cache_path) 1046 << PP.getHeaderSearchInfo().getModuleCachePath(); 1047 } 1048 } 1049 1050 void ASTReader::Error(unsigned DiagID, 1051 StringRef Arg1, StringRef Arg2) { 1052 if (Diags.isDiagnosticInFlight()) 1053 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2); 1054 else 1055 Diag(DiagID) << Arg1 << Arg2; 1056 } 1057 1058 //===----------------------------------------------------------------------===// 1059 // Source Manager Deserialization 1060 //===----------------------------------------------------------------------===// 1061 1062 /// \brief Read the line table in the source manager block. 1063 /// \returns true if there was an error. 1064 bool ASTReader::ParseLineTable(ModuleFile &F, 1065 const RecordData &Record) { 1066 unsigned Idx = 0; 1067 LineTableInfo &LineTable = SourceMgr.getLineTable(); 1068 1069 // Parse the file names 1070 std::map<int, int> FileIDs; 1071 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 1072 // Extract the file name 1073 auto Filename = ReadPath(F, Record, Idx); 1074 FileIDs[I] = LineTable.getLineTableFilenameID(Filename); 1075 } 1076 1077 // Parse the line entries 1078 std::vector<LineEntry> Entries; 1079 while (Idx < Record.size()) { 1080 int FID = Record[Idx++]; 1081 assert(FID >= 0 && "Serialized line entries for non-local file."); 1082 // Remap FileID from 1-based old view. 1083 FID += F.SLocEntryBaseID - 1; 1084 1085 // Extract the line entries 1086 unsigned NumEntries = Record[Idx++]; 1087 assert(NumEntries && "Numentries is 00000"); 1088 Entries.clear(); 1089 Entries.reserve(NumEntries); 1090 for (unsigned I = 0; I != NumEntries; ++I) { 1091 unsigned FileOffset = Record[Idx++]; 1092 unsigned LineNo = Record[Idx++]; 1093 int FilenameID = FileIDs[Record[Idx++]]; 1094 SrcMgr::CharacteristicKind FileKind 1095 = (SrcMgr::CharacteristicKind)Record[Idx++]; 1096 unsigned IncludeOffset = Record[Idx++]; 1097 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 1098 FileKind, IncludeOffset)); 1099 } 1100 LineTable.AddEntry(FileID::get(FID), Entries); 1101 } 1102 1103 return false; 1104 } 1105 1106 /// \brief Read a source manager block 1107 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) { 1108 using namespace SrcMgr; 1109 1110 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 1111 1112 // Set the source-location entry cursor to the current position in 1113 // the stream. This cursor will be used to read the contents of the 1114 // source manager block initially, and then lazily read 1115 // source-location entries as needed. 1116 SLocEntryCursor = F.Stream; 1117 1118 // The stream itself is going to skip over the source manager block. 1119 if (F.Stream.SkipBlock()) { 1120 Error("malformed block record in AST file"); 1121 return true; 1122 } 1123 1124 // Enter the source manager block. 1125 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 1126 Error("malformed source manager block record in AST file"); 1127 return true; 1128 } 1129 1130 RecordData Record; 1131 while (true) { 1132 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks(); 1133 1134 switch (E.Kind) { 1135 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1136 case llvm::BitstreamEntry::Error: 1137 Error("malformed block record in AST file"); 1138 return true; 1139 case llvm::BitstreamEntry::EndBlock: 1140 return false; 1141 case llvm::BitstreamEntry::Record: 1142 // The interesting case. 1143 break; 1144 } 1145 1146 // Read a record. 1147 Record.clear(); 1148 StringRef Blob; 1149 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) { 1150 default: // Default behavior: ignore. 1151 break; 1152 1153 case SM_SLOC_FILE_ENTRY: 1154 case SM_SLOC_BUFFER_ENTRY: 1155 case SM_SLOC_EXPANSION_ENTRY: 1156 // Once we hit one of the source location entries, we're done. 1157 return false; 1158 } 1159 } 1160 } 1161 1162 /// \brief If a header file is not found at the path that we expect it to be 1163 /// and the PCH file was moved from its original location, try to resolve the 1164 /// file by assuming that header+PCH were moved together and the header is in 1165 /// the same place relative to the PCH. 1166 static std::string 1167 resolveFileRelativeToOriginalDir(const std::string &Filename, 1168 const std::string &OriginalDir, 1169 const std::string &CurrDir) { 1170 assert(OriginalDir != CurrDir && 1171 "No point trying to resolve the file if the PCH dir didn't change"); 1172 using namespace llvm::sys; 1173 SmallString<128> filePath(Filename); 1174 fs::make_absolute(filePath); 1175 assert(path::is_absolute(OriginalDir)); 1176 SmallString<128> currPCHPath(CurrDir); 1177 1178 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 1179 fileDirE = path::end(path::parent_path(filePath)); 1180 path::const_iterator origDirI = path::begin(OriginalDir), 1181 origDirE = path::end(OriginalDir); 1182 // Skip the common path components from filePath and OriginalDir. 1183 while (fileDirI != fileDirE && origDirI != origDirE && 1184 *fileDirI == *origDirI) { 1185 ++fileDirI; 1186 ++origDirI; 1187 } 1188 for (; origDirI != origDirE; ++origDirI) 1189 path::append(currPCHPath, ".."); 1190 path::append(currPCHPath, fileDirI, fileDirE); 1191 path::append(currPCHPath, path::filename(Filename)); 1192 return currPCHPath.str(); 1193 } 1194 1195 bool ASTReader::ReadSLocEntry(int ID) { 1196 if (ID == 0) 1197 return false; 1198 1199 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1200 Error("source location entry ID out-of-range for AST file"); 1201 return true; 1202 } 1203 1204 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second; 1205 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]); 1206 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 1207 unsigned BaseOffset = F->SLocEntryBaseOffset; 1208 1209 ++NumSLocEntriesRead; 1210 llvm::BitstreamEntry Entry = SLocEntryCursor.advance(); 1211 if (Entry.Kind != llvm::BitstreamEntry::Record) { 1212 Error("incorrectly-formatted source location entry in AST file"); 1213 return true; 1214 } 1215 1216 RecordData Record; 1217 StringRef Blob; 1218 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) { 1219 default: 1220 Error("incorrectly-formatted source location entry in AST file"); 1221 return true; 1222 1223 case SM_SLOC_FILE_ENTRY: { 1224 // We will detect whether a file changed and return 'Failure' for it, but 1225 // we will also try to fail gracefully by setting up the SLocEntry. 1226 unsigned InputID = Record[4]; 1227 InputFile IF = getInputFile(*F, InputID); 1228 const FileEntry *File = IF.getFile(); 1229 bool OverriddenBuffer = IF.isOverridden(); 1230 1231 // Note that we only check if a File was returned. If it was out-of-date 1232 // we have complained but we will continue creating a FileID to recover 1233 // gracefully. 1234 if (!File) 1235 return true; 1236 1237 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 1238 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) { 1239 // This is the module's main file. 1240 IncludeLoc = getImportLocation(F); 1241 } 1242 SrcMgr::CharacteristicKind 1243 FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; 1244 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter, 1245 ID, BaseOffset + Record[0]); 1246 SrcMgr::FileInfo &FileInfo = 1247 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()); 1248 FileInfo.NumCreatedFIDs = Record[5]; 1249 if (Record[3]) 1250 FileInfo.setHasLineDirectives(); 1251 1252 const DeclID *FirstDecl = F->FileSortedDecls + Record[6]; 1253 unsigned NumFileDecls = Record[7]; 1254 if (NumFileDecls) { 1255 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?"); 1256 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl, 1257 NumFileDecls)); 1258 } 1259 1260 const SrcMgr::ContentCache *ContentCache 1261 = SourceMgr.getOrCreateContentCache(File, 1262 /*isSystemFile=*/FileCharacter != SrcMgr::C_User); 1263 if (OverriddenBuffer && !ContentCache->BufferOverridden && 1264 ContentCache->ContentsEntry == ContentCache->OrigEntry) { 1265 unsigned Code = SLocEntryCursor.ReadCode(); 1266 Record.clear(); 1267 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob); 1268 1269 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1270 Error("AST record has invalid code"); 1271 return true; 1272 } 1273 1274 std::unique_ptr<llvm::MemoryBuffer> Buffer 1275 = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName()); 1276 SourceMgr.overrideFileContents(File, std::move(Buffer)); 1277 } 1278 1279 break; 1280 } 1281 1282 case SM_SLOC_BUFFER_ENTRY: { 1283 const char *Name = Blob.data(); 1284 unsigned Offset = Record[0]; 1285 SrcMgr::CharacteristicKind 1286 FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; 1287 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 1288 if (IncludeLoc.isInvalid() && 1289 (F->Kind == MK_ImplicitModule || F->Kind == MK_ExplicitModule)) { 1290 IncludeLoc = getImportLocation(F); 1291 } 1292 unsigned Code = SLocEntryCursor.ReadCode(); 1293 Record.clear(); 1294 unsigned RecCode 1295 = SLocEntryCursor.readRecord(Code, Record, &Blob); 1296 1297 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1298 Error("AST record has invalid code"); 1299 return true; 1300 } 1301 1302 std::unique_ptr<llvm::MemoryBuffer> Buffer = 1303 llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name); 1304 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID, 1305 BaseOffset + Offset, IncludeLoc); 1306 break; 1307 } 1308 1309 case SM_SLOC_EXPANSION_ENTRY: { 1310 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1311 SourceMgr.createExpansionLoc(SpellingLoc, 1312 ReadSourceLocation(*F, Record[2]), 1313 ReadSourceLocation(*F, Record[3]), 1314 Record[4], 1315 ID, 1316 BaseOffset + Record[0]); 1317 break; 1318 } 1319 } 1320 1321 return false; 1322 } 1323 1324 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) { 1325 if (ID == 0) 1326 return std::make_pair(SourceLocation(), ""); 1327 1328 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1329 Error("source location entry ID out-of-range for AST file"); 1330 return std::make_pair(SourceLocation(), ""); 1331 } 1332 1333 // Find which module file this entry lands in. 1334 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second; 1335 if (M->Kind != MK_ImplicitModule && M->Kind != MK_ExplicitModule) 1336 return std::make_pair(SourceLocation(), ""); 1337 1338 // FIXME: Can we map this down to a particular submodule? That would be 1339 // ideal. 1340 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName)); 1341 } 1342 1343 /// \brief Find the location where the module F is imported. 1344 SourceLocation ASTReader::getImportLocation(ModuleFile *F) { 1345 if (F->ImportLoc.isValid()) 1346 return F->ImportLoc; 1347 1348 // Otherwise we have a PCH. It's considered to be "imported" at the first 1349 // location of its includer. 1350 if (F->ImportedBy.empty() || !F->ImportedBy[0]) { 1351 // Main file is the importer. 1352 assert(!SourceMgr.getMainFileID().isInvalid() && "missing main file"); 1353 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()); 1354 } 1355 return F->ImportedBy[0]->FirstLoc; 1356 } 1357 1358 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1359 /// specified cursor. Read the abbreviations that are at the top of the block 1360 /// and then leave the cursor pointing into the block. 1361 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) { 1362 if (Cursor.EnterSubBlock(BlockID)) { 1363 Error("malformed block record in AST file"); 1364 return Failure; 1365 } 1366 1367 while (true) { 1368 uint64_t Offset = Cursor.GetCurrentBitNo(); 1369 unsigned Code = Cursor.ReadCode(); 1370 1371 // We expect all abbrevs to be at the start of the block. 1372 if (Code != llvm::bitc::DEFINE_ABBREV) { 1373 Cursor.JumpToBit(Offset); 1374 return false; 1375 } 1376 Cursor.ReadAbbrevRecord(); 1377 } 1378 } 1379 1380 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record, 1381 unsigned &Idx) { 1382 Token Tok; 1383 Tok.startToken(); 1384 Tok.setLocation(ReadSourceLocation(F, Record, Idx)); 1385 Tok.setLength(Record[Idx++]); 1386 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++])) 1387 Tok.setIdentifierInfo(II); 1388 Tok.setKind((tok::TokenKind)Record[Idx++]); 1389 Tok.setFlag((Token::TokenFlags)Record[Idx++]); 1390 return Tok; 1391 } 1392 1393 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) { 1394 BitstreamCursor &Stream = F.MacroCursor; 1395 1396 // Keep track of where we are in the stream, then jump back there 1397 // after reading this macro. 1398 SavedStreamPosition SavedPosition(Stream); 1399 1400 Stream.JumpToBit(Offset); 1401 RecordData Record; 1402 SmallVector<IdentifierInfo*, 16> MacroArgs; 1403 MacroInfo *Macro = nullptr; 1404 1405 while (true) { 1406 // Advance to the next record, but if we get to the end of the block, don't 1407 // pop it (removing all the abbreviations from the cursor) since we want to 1408 // be able to reseek within the block and read entries. 1409 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd; 1410 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags); 1411 1412 switch (Entry.Kind) { 1413 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1414 case llvm::BitstreamEntry::Error: 1415 Error("malformed block record in AST file"); 1416 return Macro; 1417 case llvm::BitstreamEntry::EndBlock: 1418 return Macro; 1419 case llvm::BitstreamEntry::Record: 1420 // The interesting case. 1421 break; 1422 } 1423 1424 // Read a record. 1425 Record.clear(); 1426 PreprocessorRecordTypes RecType = 1427 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record); 1428 switch (RecType) { 1429 case PP_MACRO_DIRECTIVE_HISTORY: 1430 return Macro; 1431 1432 case PP_MACRO_OBJECT_LIKE: 1433 case PP_MACRO_FUNCTION_LIKE: { 1434 // If we already have a macro, that means that we've hit the end 1435 // of the definition of the macro we were looking for. We're 1436 // done. 1437 if (Macro) 1438 return Macro; 1439 1440 unsigned NextIndex = 1; // Skip identifier ID. 1441 SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]); 1442 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex); 1443 MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID); 1444 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex)); 1445 MI->setIsUsed(Record[NextIndex++]); 1446 MI->setUsedForHeaderGuard(Record[NextIndex++]); 1447 1448 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1449 // Decode function-like macro info. 1450 bool isC99VarArgs = Record[NextIndex++]; 1451 bool isGNUVarArgs = Record[NextIndex++]; 1452 bool hasCommaPasting = Record[NextIndex++]; 1453 MacroArgs.clear(); 1454 unsigned NumArgs = Record[NextIndex++]; 1455 for (unsigned i = 0; i != NumArgs; ++i) 1456 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++])); 1457 1458 // Install function-like macro info. 1459 MI->setIsFunctionLike(); 1460 if (isC99VarArgs) MI->setIsC99Varargs(); 1461 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1462 if (hasCommaPasting) MI->setHasCommaPasting(); 1463 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1464 PP.getPreprocessorAllocator()); 1465 } 1466 1467 // Remember that we saw this macro last so that we add the tokens that 1468 // form its body to it. 1469 Macro = MI; 1470 1471 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() && 1472 Record[NextIndex]) { 1473 // We have a macro definition. Register the association 1474 PreprocessedEntityID 1475 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]); 1476 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 1477 PreprocessingRecord::PPEntityID 1478 PPID = PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true); 1479 MacroDefinition *PPDef = 1480 cast_or_null<MacroDefinition>(PPRec.getPreprocessedEntity(PPID)); 1481 if (PPDef) 1482 PPRec.RegisterMacroDefinition(Macro, PPDef); 1483 } 1484 1485 ++NumMacrosRead; 1486 break; 1487 } 1488 1489 case PP_TOKEN: { 1490 // If we see a TOKEN before a PP_MACRO_*, then the file is 1491 // erroneous, just pretend we didn't see this. 1492 if (!Macro) break; 1493 1494 unsigned Idx = 0; 1495 Token Tok = ReadToken(F, Record, Idx); 1496 Macro->AddTokenToBody(Tok); 1497 break; 1498 } 1499 } 1500 } 1501 } 1502 1503 PreprocessedEntityID 1504 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const { 1505 ContinuousRangeMap<uint32_t, int, 2>::const_iterator 1506 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS); 1507 assert(I != M.PreprocessedEntityRemap.end() 1508 && "Invalid index into preprocessed entity index remap"); 1509 1510 return LocalID + I->second; 1511 } 1512 1513 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) { 1514 return llvm::hash_combine(ikey.Size, ikey.ModTime); 1515 } 1516 1517 HeaderFileInfoTrait::internal_key_type 1518 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) { 1519 internal_key_type ikey = { FE->getSize(), FE->getModificationTime(), 1520 FE->getName(), /*Imported*/false }; 1521 return ikey; 1522 } 1523 1524 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) { 1525 if (a.Size != b.Size || a.ModTime != b.ModTime) 1526 return false; 1527 1528 if (llvm::sys::path::is_absolute(a.Filename) && 1529 strcmp(a.Filename, b.Filename) == 0) 1530 return true; 1531 1532 // Determine whether the actual files are equivalent. 1533 FileManager &FileMgr = Reader.getFileManager(); 1534 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* { 1535 if (!Key.Imported) 1536 return FileMgr.getFile(Key.Filename); 1537 1538 std::string Resolved = Key.Filename; 1539 Reader.ResolveImportedPath(M, Resolved); 1540 return FileMgr.getFile(Resolved); 1541 }; 1542 1543 const FileEntry *FEA = GetFile(a); 1544 const FileEntry *FEB = GetFile(b); 1545 return FEA && FEA == FEB; 1546 } 1547 1548 std::pair<unsigned, unsigned> 1549 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) { 1550 using namespace llvm::support; 1551 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d); 1552 unsigned DataLen = (unsigned) *d++; 1553 return std::make_pair(KeyLen, DataLen); 1554 } 1555 1556 HeaderFileInfoTrait::internal_key_type 1557 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) { 1558 using namespace llvm::support; 1559 internal_key_type ikey; 1560 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d)); 1561 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d)); 1562 ikey.Filename = (const char *)d; 1563 ikey.Imported = true; 1564 return ikey; 1565 } 1566 1567 HeaderFileInfoTrait::data_type 1568 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d, 1569 unsigned DataLen) { 1570 const unsigned char *End = d + DataLen; 1571 using namespace llvm::support; 1572 HeaderFileInfo HFI; 1573 unsigned Flags = *d++; 1574 HFI.HeaderRole = static_cast<ModuleMap::ModuleHeaderRole> 1575 ((Flags >> 6) & 0x03); 1576 HFI.isImport = (Flags >> 5) & 0x01; 1577 HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1578 HFI.DirInfo = (Flags >> 2) & 0x03; 1579 HFI.Resolved = (Flags >> 1) & 0x01; 1580 HFI.IndexHeaderMapHeader = Flags & 0x01; 1581 HFI.NumIncludes = endian::readNext<uint16_t, little, unaligned>(d); 1582 HFI.ControllingMacroID = Reader.getGlobalIdentifierID( 1583 M, endian::readNext<uint32_t, little, unaligned>(d)); 1584 if (unsigned FrameworkOffset = 1585 endian::readNext<uint32_t, little, unaligned>(d)) { 1586 // The framework offset is 1 greater than the actual offset, 1587 // since 0 is used as an indicator for "no framework name". 1588 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1589 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1590 } 1591 1592 if (d != End) { 1593 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d); 1594 if (LocalSMID) { 1595 // This header is part of a module. Associate it with the module to enable 1596 // implicit module import. 1597 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID); 1598 Module *Mod = Reader.getSubmodule(GlobalSMID); 1599 HFI.isModuleHeader = true; 1600 FileManager &FileMgr = Reader.getFileManager(); 1601 ModuleMap &ModMap = 1602 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 1603 // FIXME: This information should be propagated through the 1604 // SUBMODULE_HEADER etc records rather than from here. 1605 // FIXME: We don't ever mark excluded headers. 1606 std::string Filename = key.Filename; 1607 if (key.Imported) 1608 Reader.ResolveImportedPath(M, Filename); 1609 Module::Header H = { key.Filename, FileMgr.getFile(Filename) }; 1610 ModMap.addHeader(Mod, H, HFI.getHeaderRole()); 1611 } 1612 } 1613 1614 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1615 (void)End; 1616 1617 // This HeaderFileInfo was externally loaded. 1618 HFI.External = true; 1619 return HFI; 1620 } 1621 1622 void 1623 ASTReader::addPendingMacroFromModule(IdentifierInfo *II, ModuleFile *M, 1624 GlobalMacroID GMacID, 1625 ArrayRef<SubmoduleID> Overrides) { 1626 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); 1627 SubmoduleID *OverrideData = nullptr; 1628 if (!Overrides.empty()) { 1629 OverrideData = new (Context) SubmoduleID[Overrides.size() + 1]; 1630 OverrideData[0] = Overrides.size(); 1631 for (unsigned I = 0; I != Overrides.size(); ++I) 1632 OverrideData[I + 1] = getGlobalSubmoduleID(*M, Overrides[I]); 1633 } 1634 PendingMacroIDs[II].push_back(PendingMacroInfo(M, GMacID, OverrideData)); 1635 } 1636 1637 void ASTReader::addPendingMacroFromPCH(IdentifierInfo *II, 1638 ModuleFile *M, 1639 uint64_t MacroDirectivesOffset) { 1640 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); 1641 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset)); 1642 } 1643 1644 void ASTReader::ReadDefinedMacros() { 1645 // Note that we are loading defined macros. 1646 Deserializing Macros(this); 1647 1648 for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1649 E = ModuleMgr.rend(); I != E; ++I) { 1650 BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1651 1652 // If there was no preprocessor block, skip this file. 1653 if (!MacroCursor.getBitStreamReader()) 1654 continue; 1655 1656 BitstreamCursor Cursor = MacroCursor; 1657 Cursor.JumpToBit((*I)->MacroStartOffset); 1658 1659 RecordData Record; 1660 while (true) { 1661 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks(); 1662 1663 switch (E.Kind) { 1664 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1665 case llvm::BitstreamEntry::Error: 1666 Error("malformed block record in AST file"); 1667 return; 1668 case llvm::BitstreamEntry::EndBlock: 1669 goto NextCursor; 1670 1671 case llvm::BitstreamEntry::Record: 1672 Record.clear(); 1673 switch (Cursor.readRecord(E.ID, Record)) { 1674 default: // Default behavior: ignore. 1675 break; 1676 1677 case PP_MACRO_OBJECT_LIKE: 1678 case PP_MACRO_FUNCTION_LIKE: 1679 getLocalIdentifier(**I, Record[0]); 1680 break; 1681 1682 case PP_TOKEN: 1683 // Ignore tokens. 1684 break; 1685 } 1686 break; 1687 } 1688 } 1689 NextCursor: ; 1690 } 1691 } 1692 1693 namespace { 1694 /// \brief Visitor class used to look up identifirs in an AST file. 1695 class IdentifierLookupVisitor { 1696 StringRef Name; 1697 unsigned PriorGeneration; 1698 unsigned &NumIdentifierLookups; 1699 unsigned &NumIdentifierLookupHits; 1700 IdentifierInfo *Found; 1701 1702 public: 1703 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration, 1704 unsigned &NumIdentifierLookups, 1705 unsigned &NumIdentifierLookupHits) 1706 : Name(Name), PriorGeneration(PriorGeneration), 1707 NumIdentifierLookups(NumIdentifierLookups), 1708 NumIdentifierLookupHits(NumIdentifierLookupHits), 1709 Found() 1710 { 1711 } 1712 1713 static bool visit(ModuleFile &M, void *UserData) { 1714 IdentifierLookupVisitor *This 1715 = static_cast<IdentifierLookupVisitor *>(UserData); 1716 1717 // If we've already searched this module file, skip it now. 1718 if (M.Generation <= This->PriorGeneration) 1719 return true; 1720 1721 ASTIdentifierLookupTable *IdTable 1722 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable; 1723 if (!IdTable) 1724 return false; 1725 1726 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), 1727 M, This->Found); 1728 ++This->NumIdentifierLookups; 1729 ASTIdentifierLookupTable::iterator Pos = IdTable->find(This->Name,&Trait); 1730 if (Pos == IdTable->end()) 1731 return false; 1732 1733 // Dereferencing the iterator has the effect of building the 1734 // IdentifierInfo node and populating it with the various 1735 // declarations it needs. 1736 ++This->NumIdentifierLookupHits; 1737 This->Found = *Pos; 1738 return true; 1739 } 1740 1741 // \brief Retrieve the identifier info found within the module 1742 // files. 1743 IdentifierInfo *getIdentifierInfo() const { return Found; } 1744 }; 1745 } 1746 1747 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) { 1748 // Note that we are loading an identifier. 1749 Deserializing AnIdentifier(this); 1750 1751 unsigned PriorGeneration = 0; 1752 if (getContext().getLangOpts().Modules) 1753 PriorGeneration = IdentifierGeneration[&II]; 1754 1755 // If there is a global index, look there first to determine which modules 1756 // provably do not have any results for this identifier. 1757 GlobalModuleIndex::HitSet Hits; 1758 GlobalModuleIndex::HitSet *HitsPtr = nullptr; 1759 if (!loadGlobalIndex()) { 1760 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) { 1761 HitsPtr = &Hits; 1762 } 1763 } 1764 1765 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration, 1766 NumIdentifierLookups, 1767 NumIdentifierLookupHits); 1768 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 1769 markIdentifierUpToDate(&II); 1770 } 1771 1772 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) { 1773 if (!II) 1774 return; 1775 1776 II->setOutOfDate(false); 1777 1778 // Update the generation for this identifier. 1779 if (getContext().getLangOpts().Modules) 1780 IdentifierGeneration[II] = getGeneration(); 1781 } 1782 1783 struct ASTReader::ModuleMacroInfo { 1784 SubmoduleID SubModID; 1785 MacroInfo *MI; 1786 SubmoduleID *Overrides; 1787 // FIXME: Remove this. 1788 ModuleFile *F; 1789 1790 bool isDefine() const { return MI; } 1791 1792 SubmoduleID getSubmoduleID() const { return SubModID; } 1793 1794 ArrayRef<SubmoduleID> getOverriddenSubmodules() const { 1795 if (!Overrides) 1796 return None; 1797 return llvm::makeArrayRef(Overrides + 1, *Overrides); 1798 } 1799 1800 MacroDirective *import(Preprocessor &PP, SourceLocation ImportLoc) const { 1801 if (!MI) 1802 return PP.AllocateUndefMacroDirective(ImportLoc, SubModID, 1803 getOverriddenSubmodules()); 1804 return PP.AllocateDefMacroDirective(MI, ImportLoc, SubModID, 1805 getOverriddenSubmodules()); 1806 } 1807 }; 1808 1809 ASTReader::ModuleMacroInfo * 1810 ASTReader::getModuleMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo) { 1811 ModuleMacroInfo Info; 1812 1813 uint32_t ID = PMInfo.ModuleMacroData.MacID; 1814 if (ID & 1) { 1815 // Macro undefinition. 1816 Info.SubModID = getGlobalSubmoduleID(*PMInfo.M, ID >> 1); 1817 Info.MI = nullptr; 1818 1819 // If we've already loaded the #undef of this macro from this module, 1820 // don't do so again. 1821 if (!LoadedUndefs.insert(std::make_pair(II, Info.SubModID)).second) 1822 return nullptr; 1823 } else { 1824 // Macro definition. 1825 GlobalMacroID GMacID = getGlobalMacroID(*PMInfo.M, ID >> 1); 1826 assert(GMacID); 1827 1828 // If this macro has already been loaded, don't do so again. 1829 // FIXME: This is highly dubious. Multiple macro definitions can have the 1830 // same MacroInfo (and hence the same GMacID) due to #pragma push_macro etc. 1831 if (MacrosLoaded[GMacID - NUM_PREDEF_MACRO_IDS]) 1832 return nullptr; 1833 1834 Info.MI = getMacro(GMacID); 1835 Info.SubModID = Info.MI->getOwningModuleID(); 1836 } 1837 Info.Overrides = PMInfo.ModuleMacroData.Overrides; 1838 Info.F = PMInfo.M; 1839 1840 return new (Context) ModuleMacroInfo(Info); 1841 } 1842 1843 void ASTReader::resolvePendingMacro(IdentifierInfo *II, 1844 const PendingMacroInfo &PMInfo) { 1845 assert(II); 1846 1847 if (PMInfo.M->Kind != MK_ImplicitModule && 1848 PMInfo.M->Kind != MK_ExplicitModule) { 1849 installPCHMacroDirectives(II, *PMInfo.M, 1850 PMInfo.PCHMacroData.MacroDirectivesOffset); 1851 return; 1852 } 1853 1854 // Module Macro. 1855 1856 ModuleMacroInfo *MMI = getModuleMacro(II, PMInfo); 1857 if (!MMI) 1858 return; 1859 1860 Module *Owner = getSubmodule(MMI->getSubmoduleID()); 1861 if (Owner && Owner->NameVisibility == Module::Hidden) { 1862 // Macros in the owning module are hidden. Just remember this macro to 1863 // install if we make this module visible. 1864 HiddenNamesMap[Owner].HiddenMacros.insert(std::make_pair(II, MMI)); 1865 } else { 1866 installImportedMacro(II, MMI, Owner); 1867 } 1868 } 1869 1870 void ASTReader::installPCHMacroDirectives(IdentifierInfo *II, 1871 ModuleFile &M, uint64_t Offset) { 1872 assert(M.Kind != MK_ImplicitModule && M.Kind != MK_ExplicitModule); 1873 1874 BitstreamCursor &Cursor = M.MacroCursor; 1875 SavedStreamPosition SavedPosition(Cursor); 1876 Cursor.JumpToBit(Offset); 1877 1878 llvm::BitstreamEntry Entry = 1879 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd); 1880 if (Entry.Kind != llvm::BitstreamEntry::Record) { 1881 Error("malformed block record in AST file"); 1882 return; 1883 } 1884 1885 RecordData Record; 1886 PreprocessorRecordTypes RecType = 1887 (PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record); 1888 if (RecType != PP_MACRO_DIRECTIVE_HISTORY) { 1889 Error("malformed block record in AST file"); 1890 return; 1891 } 1892 1893 // Deserialize the macro directives history in reverse source-order. 1894 MacroDirective *Latest = nullptr, *Earliest = nullptr; 1895 unsigned Idx = 0, N = Record.size(); 1896 while (Idx < N) { 1897 MacroDirective *MD = nullptr; 1898 SourceLocation Loc = ReadSourceLocation(M, Record, Idx); 1899 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++]; 1900 switch (K) { 1901 case MacroDirective::MD_Define: { 1902 GlobalMacroID GMacID = getGlobalMacroID(M, Record[Idx++]); 1903 MacroInfo *MI = getMacro(GMacID); 1904 SubmoduleID ImportedFrom = Record[Idx++]; 1905 bool IsAmbiguous = Record[Idx++]; 1906 llvm::SmallVector<unsigned, 4> Overrides; 1907 if (ImportedFrom) { 1908 Overrides.insert(Overrides.end(), 1909 &Record[Idx] + 1, &Record[Idx] + 1 + Record[Idx]); 1910 Idx += Overrides.size() + 1; 1911 } 1912 DefMacroDirective *DefMD = 1913 PP.AllocateDefMacroDirective(MI, Loc, ImportedFrom, Overrides); 1914 DefMD->setAmbiguous(IsAmbiguous); 1915 MD = DefMD; 1916 break; 1917 } 1918 case MacroDirective::MD_Undefine: { 1919 SubmoduleID ImportedFrom = Record[Idx++]; 1920 llvm::SmallVector<unsigned, 4> Overrides; 1921 if (ImportedFrom) { 1922 Overrides.insert(Overrides.end(), 1923 &Record[Idx] + 1, &Record[Idx] + 1 + Record[Idx]); 1924 Idx += Overrides.size() + 1; 1925 } 1926 MD = PP.AllocateUndefMacroDirective(Loc, ImportedFrom, Overrides); 1927 break; 1928 } 1929 case MacroDirective::MD_Visibility: 1930 bool isPublic = Record[Idx++]; 1931 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic); 1932 break; 1933 } 1934 1935 if (!Latest) 1936 Latest = MD; 1937 if (Earliest) 1938 Earliest->setPrevious(MD); 1939 Earliest = MD; 1940 } 1941 1942 PP.setLoadedMacroDirective(II, Latest); 1943 } 1944 1945 /// \brief For the given macro definitions, check if they are both in system 1946 /// modules. 1947 static bool areDefinedInSystemModules(MacroInfo *PrevMI, MacroInfo *NewMI, 1948 Module *NewOwner, ASTReader &Reader) { 1949 assert(PrevMI && NewMI); 1950 Module *PrevOwner = nullptr; 1951 if (SubmoduleID PrevModID = PrevMI->getOwningModuleID()) 1952 PrevOwner = Reader.getSubmodule(PrevModID); 1953 if (PrevOwner && PrevOwner == NewOwner) 1954 return false; 1955 SourceManager &SrcMgr = Reader.getSourceManager(); 1956 bool PrevInSystem = (PrevOwner && PrevOwner->IsSystem) || 1957 SrcMgr.isInSystemHeader(PrevMI->getDefinitionLoc()); 1958 bool NewInSystem = (NewOwner && NewOwner->IsSystem) || 1959 SrcMgr.isInSystemHeader(NewMI->getDefinitionLoc()); 1960 return PrevInSystem && NewInSystem; 1961 } 1962 1963 void ASTReader::removeOverriddenMacros(IdentifierInfo *II, 1964 SourceLocation ImportLoc, 1965 AmbiguousMacros &Ambig, 1966 ArrayRef<SubmoduleID> Overrides) { 1967 for (unsigned OI = 0, ON = Overrides.size(); OI != ON; ++OI) { 1968 SubmoduleID OwnerID = Overrides[OI]; 1969 1970 // If this macro is not yet visible, remove it from the hidden names list. 1971 // It won't be there if we're in the middle of making the owner visible. 1972 Module *Owner = getSubmodule(OwnerID); 1973 auto HiddenIt = HiddenNamesMap.find(Owner); 1974 if (HiddenIt != HiddenNamesMap.end()) { 1975 HiddenNames &Hidden = HiddenIt->second; 1976 HiddenMacrosMap::iterator HI = Hidden.HiddenMacros.find(II); 1977 if (HI != Hidden.HiddenMacros.end()) { 1978 // Register the macro now so we don't lose it when we re-export. 1979 PP.appendMacroDirective(II, HI->second->import(PP, ImportLoc)); 1980 1981 auto SubOverrides = HI->second->getOverriddenSubmodules(); 1982 Hidden.HiddenMacros.erase(HI); 1983 removeOverriddenMacros(II, ImportLoc, Ambig, SubOverrides); 1984 } 1985 } 1986 1987 // If this macro is already in our list of conflicts, remove it from there. 1988 Ambig.erase( 1989 std::remove_if(Ambig.begin(), Ambig.end(), [&](DefMacroDirective *MD) { 1990 return MD->getInfo()->getOwningModuleID() == OwnerID; 1991 }), 1992 Ambig.end()); 1993 } 1994 } 1995 1996 ASTReader::AmbiguousMacros * 1997 ASTReader::removeOverriddenMacros(IdentifierInfo *II, 1998 SourceLocation ImportLoc, 1999 ArrayRef<SubmoduleID> Overrides) { 2000 MacroDirective *Prev = PP.getMacroDirective(II); 2001 if (!Prev && Overrides.empty()) 2002 return nullptr; 2003 2004 DefMacroDirective *PrevDef = Prev ? Prev->getDefinition().getDirective() 2005 : nullptr; 2006 if (PrevDef && PrevDef->isAmbiguous()) { 2007 // We had a prior ambiguity. Check whether we resolve it (or make it worse). 2008 AmbiguousMacros &Ambig = AmbiguousMacroDefs[II]; 2009 Ambig.push_back(PrevDef); 2010 2011 removeOverriddenMacros(II, ImportLoc, Ambig, Overrides); 2012 2013 if (!Ambig.empty()) 2014 return &Ambig; 2015 2016 AmbiguousMacroDefs.erase(II); 2017 } else { 2018 // There's no ambiguity yet. Maybe we're introducing one. 2019 AmbiguousMacros Ambig; 2020 if (PrevDef) 2021 Ambig.push_back(PrevDef); 2022 2023 removeOverriddenMacros(II, ImportLoc, Ambig, Overrides); 2024 2025 if (!Ambig.empty()) { 2026 AmbiguousMacros &Result = AmbiguousMacroDefs[II]; 2027 std::swap(Result, Ambig); 2028 return &Result; 2029 } 2030 } 2031 2032 // We ended up with no ambiguity. 2033 return nullptr; 2034 } 2035 2036 void ASTReader::installImportedMacro(IdentifierInfo *II, ModuleMacroInfo *MMI, 2037 Module *Owner) { 2038 assert(II && Owner); 2039 2040 SourceLocation ImportLoc = Owner->MacroVisibilityLoc; 2041 if (ImportLoc.isInvalid()) { 2042 // FIXME: If we made macros from this module visible but didn't provide a 2043 // source location for the import, we don't have a location for the macro. 2044 // Use the location at which the containing module file was first imported 2045 // for now. 2046 ImportLoc = MMI->F->DirectImportLoc; 2047 assert(ImportLoc.isValid() && "no import location for a visible macro?"); 2048 } 2049 2050 AmbiguousMacros *Prev = 2051 removeOverriddenMacros(II, ImportLoc, MMI->getOverriddenSubmodules()); 2052 2053 // Create a synthetic macro definition corresponding to the import (or null 2054 // if this was an undefinition of the macro). 2055 MacroDirective *Imported = MMI->import(PP, ImportLoc); 2056 DefMacroDirective *MD = dyn_cast<DefMacroDirective>(Imported); 2057 2058 // If there's no ambiguity, just install the macro. 2059 if (!Prev) { 2060 PP.appendMacroDirective(II, Imported); 2061 return; 2062 } 2063 assert(!Prev->empty()); 2064 2065 if (!MD) { 2066 // We imported a #undef that didn't remove all prior definitions. The most 2067 // recent prior definition remains, and we install it in the place of the 2068 // imported directive, as if by a local #pragma pop_macro. 2069 MacroInfo *NewMI = Prev->back()->getInfo(); 2070 Prev->pop_back(); 2071 MD = PP.AllocateDefMacroDirective(NewMI, ImportLoc); 2072 2073 // Install our #undef first so that we don't lose track of it. We'll replace 2074 // this with whichever macro definition ends up winning. 2075 PP.appendMacroDirective(II, Imported); 2076 } 2077 2078 // We're introducing a macro definition that creates or adds to an ambiguity. 2079 // We can resolve that ambiguity if this macro is token-for-token identical to 2080 // all of the existing definitions. 2081 MacroInfo *NewMI = MD->getInfo(); 2082 assert(NewMI && "macro definition with no MacroInfo?"); 2083 while (!Prev->empty()) { 2084 MacroInfo *PrevMI = Prev->back()->getInfo(); 2085 assert(PrevMI && "macro definition with no MacroInfo?"); 2086 2087 // Before marking the macros as ambiguous, check if this is a case where 2088 // both macros are in system headers. If so, we trust that the system 2089 // did not get it wrong. This also handles cases where Clang's own 2090 // headers have a different spelling of certain system macros: 2091 // #define LONG_MAX __LONG_MAX__ (clang's limits.h) 2092 // #define LONG_MAX 0x7fffffffffffffffL (system's limits.h) 2093 // 2094 // FIXME: Remove the defined-in-system-headers check. clang's limits.h 2095 // overrides the system limits.h's macros, so there's no conflict here. 2096 if (NewMI != PrevMI && 2097 !PrevMI->isIdenticalTo(*NewMI, PP, /*Syntactically=*/true) && 2098 !areDefinedInSystemModules(PrevMI, NewMI, Owner, *this)) 2099 break; 2100 2101 // The previous definition is the same as this one (or both are defined in 2102 // system modules so we can assume they're equivalent); we don't need to 2103 // track it any more. 2104 Prev->pop_back(); 2105 } 2106 2107 if (!Prev->empty()) 2108 MD->setAmbiguous(true); 2109 2110 PP.appendMacroDirective(II, MD); 2111 } 2112 2113 ASTReader::InputFileInfo 2114 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) { 2115 // Go find this input file. 2116 BitstreamCursor &Cursor = F.InputFilesCursor; 2117 SavedStreamPosition SavedPosition(Cursor); 2118 Cursor.JumpToBit(F.InputFileOffsets[ID-1]); 2119 2120 unsigned Code = Cursor.ReadCode(); 2121 RecordData Record; 2122 StringRef Blob; 2123 2124 unsigned Result = Cursor.readRecord(Code, Record, &Blob); 2125 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE && 2126 "invalid record type for input file"); 2127 (void)Result; 2128 2129 std::string Filename; 2130 off_t StoredSize; 2131 time_t StoredTime; 2132 bool Overridden; 2133 2134 assert(Record[0] == ID && "Bogus stored ID or offset"); 2135 StoredSize = static_cast<off_t>(Record[1]); 2136 StoredTime = static_cast<time_t>(Record[2]); 2137 Overridden = static_cast<bool>(Record[3]); 2138 Filename = Blob; 2139 ResolveImportedPath(F, Filename); 2140 2141 InputFileInfo R = { std::move(Filename), StoredSize, StoredTime, Overridden }; 2142 return R; 2143 } 2144 2145 std::string ASTReader::getInputFileName(ModuleFile &F, unsigned int ID) { 2146 return readInputFileInfo(F, ID).Filename; 2147 } 2148 2149 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) { 2150 // If this ID is bogus, just return an empty input file. 2151 if (ID == 0 || ID > F.InputFilesLoaded.size()) 2152 return InputFile(); 2153 2154 // If we've already loaded this input file, return it. 2155 if (F.InputFilesLoaded[ID-1].getFile()) 2156 return F.InputFilesLoaded[ID-1]; 2157 2158 if (F.InputFilesLoaded[ID-1].isNotFound()) 2159 return InputFile(); 2160 2161 // Go find this input file. 2162 BitstreamCursor &Cursor = F.InputFilesCursor; 2163 SavedStreamPosition SavedPosition(Cursor); 2164 Cursor.JumpToBit(F.InputFileOffsets[ID-1]); 2165 2166 InputFileInfo FI = readInputFileInfo(F, ID); 2167 off_t StoredSize = FI.StoredSize; 2168 time_t StoredTime = FI.StoredTime; 2169 bool Overridden = FI.Overridden; 2170 StringRef Filename = FI.Filename; 2171 2172 const FileEntry *File 2173 = Overridden? FileMgr.getVirtualFile(Filename, StoredSize, StoredTime) 2174 : FileMgr.getFile(Filename, /*OpenFile=*/false); 2175 2176 // If we didn't find the file, resolve it relative to the 2177 // original directory from which this AST file was created. 2178 if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() && 2179 F.OriginalDir != CurrentDir) { 2180 std::string Resolved = resolveFileRelativeToOriginalDir(Filename, 2181 F.OriginalDir, 2182 CurrentDir); 2183 if (!Resolved.empty()) 2184 File = FileMgr.getFile(Resolved); 2185 } 2186 2187 // For an overridden file, create a virtual file with the stored 2188 // size/timestamp. 2189 if (Overridden && File == nullptr) { 2190 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime); 2191 } 2192 2193 if (File == nullptr) { 2194 if (Complain) { 2195 std::string ErrorStr = "could not find file '"; 2196 ErrorStr += Filename; 2197 ErrorStr += "' referenced by AST file"; 2198 Error(ErrorStr.c_str()); 2199 } 2200 // Record that we didn't find the file. 2201 F.InputFilesLoaded[ID-1] = InputFile::getNotFound(); 2202 return InputFile(); 2203 } 2204 2205 // Check if there was a request to override the contents of the file 2206 // that was part of the precompiled header. Overridding such a file 2207 // can lead to problems when lexing using the source locations from the 2208 // PCH. 2209 SourceManager &SM = getSourceManager(); 2210 if (!Overridden && SM.isFileOverridden(File)) { 2211 if (Complain) 2212 Error(diag::err_fe_pch_file_overridden, Filename); 2213 // After emitting the diagnostic, recover by disabling the override so 2214 // that the original file will be used. 2215 SM.disableFileContentsOverride(File); 2216 // The FileEntry is a virtual file entry with the size of the contents 2217 // that would override the original contents. Set it to the original's 2218 // size/time. 2219 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File), 2220 StoredSize, StoredTime); 2221 } 2222 2223 bool IsOutOfDate = false; 2224 2225 // For an overridden file, there is nothing to validate. 2226 if (!Overridden && // 2227 (StoredSize != File->getSize() || 2228 #if defined(LLVM_ON_WIN32) 2229 false 2230 #else 2231 // In our regression testing, the Windows file system seems to 2232 // have inconsistent modification times that sometimes 2233 // erroneously trigger this error-handling path. 2234 // 2235 // This also happens in networked file systems, so disable this 2236 // check if validation is disabled or if we have an explicitly 2237 // built PCM file. 2238 // 2239 // FIXME: Should we also do this for PCH files? They could also 2240 // reasonably get shared across a network during a distributed build. 2241 (StoredTime != File->getModificationTime() && !DisableValidation && 2242 F.Kind != MK_ExplicitModule) 2243 #endif 2244 )) { 2245 if (Complain) { 2246 // Build a list of the PCH imports that got us here (in reverse). 2247 SmallVector<ModuleFile *, 4> ImportStack(1, &F); 2248 while (ImportStack.back()->ImportedBy.size() > 0) 2249 ImportStack.push_back(ImportStack.back()->ImportedBy[0]); 2250 2251 // The top-level PCH is stale. 2252 StringRef TopLevelPCHName(ImportStack.back()->FileName); 2253 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName); 2254 2255 // Print the import stack. 2256 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) { 2257 Diag(diag::note_pch_required_by) 2258 << Filename << ImportStack[0]->FileName; 2259 for (unsigned I = 1; I < ImportStack.size(); ++I) 2260 Diag(diag::note_pch_required_by) 2261 << ImportStack[I-1]->FileName << ImportStack[I]->FileName; 2262 } 2263 2264 if (!Diags.isDiagnosticInFlight()) 2265 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName; 2266 } 2267 2268 IsOutOfDate = true; 2269 } 2270 2271 InputFile IF = InputFile(File, Overridden, IsOutOfDate); 2272 2273 // Note that we've loaded this input file. 2274 F.InputFilesLoaded[ID-1] = IF; 2275 return IF; 2276 } 2277 2278 /// \brief If we are loading a relocatable PCH or module file, and the filename 2279 /// is not an absolute path, add the system or module root to the beginning of 2280 /// the file name. 2281 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) { 2282 // Resolve relative to the base directory, if we have one. 2283 if (!M.BaseDirectory.empty()) 2284 return ResolveImportedPath(Filename, M.BaseDirectory); 2285 } 2286 2287 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) { 2288 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 2289 return; 2290 2291 SmallString<128> Buffer; 2292 llvm::sys::path::append(Buffer, Prefix, Filename); 2293 Filename.assign(Buffer.begin(), Buffer.end()); 2294 } 2295 2296 ASTReader::ASTReadResult 2297 ASTReader::ReadControlBlock(ModuleFile &F, 2298 SmallVectorImpl<ImportedModule> &Loaded, 2299 const ModuleFile *ImportedBy, 2300 unsigned ClientLoadCapabilities) { 2301 BitstreamCursor &Stream = F.Stream; 2302 2303 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) { 2304 Error("malformed block record in AST file"); 2305 return Failure; 2306 } 2307 2308 // Should we allow the configuration of the module file to differ from the 2309 // configuration of the current translation unit in a compatible way? 2310 // 2311 // FIXME: Allow this for files explicitly specified with -include-pch too. 2312 bool AllowCompatibleConfigurationMismatch = F.Kind == MK_ExplicitModule; 2313 2314 // Read all of the records and blocks in the control block. 2315 RecordData Record; 2316 unsigned NumInputs = 0; 2317 unsigned NumUserInputs = 0; 2318 while (1) { 2319 llvm::BitstreamEntry Entry = Stream.advance(); 2320 2321 switch (Entry.Kind) { 2322 case llvm::BitstreamEntry::Error: 2323 Error("malformed block record in AST file"); 2324 return Failure; 2325 case llvm::BitstreamEntry::EndBlock: { 2326 // Validate input files. 2327 const HeaderSearchOptions &HSOpts = 2328 PP.getHeaderSearchInfo().getHeaderSearchOpts(); 2329 2330 // All user input files reside at the index range [0, NumUserInputs), and 2331 // system input files reside at [NumUserInputs, NumInputs). 2332 if (!DisableValidation) { 2333 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0; 2334 2335 // If we are reading a module, we will create a verification timestamp, 2336 // so we verify all input files. Otherwise, verify only user input 2337 // files. 2338 2339 unsigned N = NumUserInputs; 2340 if (ValidateSystemInputs || 2341 (HSOpts.ModulesValidateOncePerBuildSession && 2342 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp && 2343 F.Kind == MK_ImplicitModule)) 2344 N = NumInputs; 2345 2346 for (unsigned I = 0; I < N; ++I) { 2347 InputFile IF = getInputFile(F, I+1, Complain); 2348 if (!IF.getFile() || IF.isOutOfDate()) 2349 return OutOfDate; 2350 } 2351 } 2352 2353 if (Listener) 2354 Listener->visitModuleFile(F.FileName); 2355 2356 if (Listener && Listener->needsInputFileVisitation()) { 2357 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs 2358 : NumUserInputs; 2359 for (unsigned I = 0; I < N; ++I) { 2360 bool IsSystem = I >= NumUserInputs; 2361 InputFileInfo FI = readInputFileInfo(F, I+1); 2362 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden); 2363 } 2364 } 2365 2366 return Success; 2367 } 2368 2369 case llvm::BitstreamEntry::SubBlock: 2370 switch (Entry.ID) { 2371 case INPUT_FILES_BLOCK_ID: 2372 F.InputFilesCursor = Stream; 2373 if (Stream.SkipBlock() || // Skip with the main cursor 2374 // Read the abbreviations 2375 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) { 2376 Error("malformed block record in AST file"); 2377 return Failure; 2378 } 2379 continue; 2380 2381 default: 2382 if (Stream.SkipBlock()) { 2383 Error("malformed block record in AST file"); 2384 return Failure; 2385 } 2386 continue; 2387 } 2388 2389 case llvm::BitstreamEntry::Record: 2390 // The interesting case. 2391 break; 2392 } 2393 2394 // Read and process a record. 2395 Record.clear(); 2396 StringRef Blob; 2397 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) { 2398 case METADATA: { 2399 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 2400 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 2401 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old 2402 : diag::err_pch_version_too_new); 2403 return VersionMismatch; 2404 } 2405 2406 bool hasErrors = Record[5]; 2407 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) { 2408 Diag(diag::err_pch_with_compiler_errors); 2409 return HadErrors; 2410 } 2411 2412 F.RelocatablePCH = Record[4]; 2413 // Relative paths in a relocatable PCH are relative to our sysroot. 2414 if (F.RelocatablePCH) 2415 F.BaseDirectory = isysroot.empty() ? "/" : isysroot; 2416 2417 const std::string &CurBranch = getClangFullRepositoryVersion(); 2418 StringRef ASTBranch = Blob; 2419 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2420 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 2421 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch; 2422 return VersionMismatch; 2423 } 2424 break; 2425 } 2426 2427 case SIGNATURE: 2428 assert((!F.Signature || F.Signature == Record[0]) && "signature changed"); 2429 F.Signature = Record[0]; 2430 break; 2431 2432 case IMPORTS: { 2433 // Load each of the imported PCH files. 2434 unsigned Idx = 0, N = Record.size(); 2435 while (Idx < N) { 2436 // Read information about the AST file. 2437 ModuleKind ImportedKind = (ModuleKind)Record[Idx++]; 2438 // The import location will be the local one for now; we will adjust 2439 // all import locations of module imports after the global source 2440 // location info are setup. 2441 SourceLocation ImportLoc = 2442 SourceLocation::getFromRawEncoding(Record[Idx++]); 2443 off_t StoredSize = (off_t)Record[Idx++]; 2444 time_t StoredModTime = (time_t)Record[Idx++]; 2445 ASTFileSignature StoredSignature = Record[Idx++]; 2446 auto ImportedFile = ReadPath(F, Record, Idx); 2447 2448 // Load the AST file. 2449 switch(ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F, Loaded, 2450 StoredSize, StoredModTime, StoredSignature, 2451 ClientLoadCapabilities)) { 2452 case Failure: return Failure; 2453 // If we have to ignore the dependency, we'll have to ignore this too. 2454 case Missing: 2455 case OutOfDate: return OutOfDate; 2456 case VersionMismatch: return VersionMismatch; 2457 case ConfigurationMismatch: return ConfigurationMismatch; 2458 case HadErrors: return HadErrors; 2459 case Success: break; 2460 } 2461 } 2462 break; 2463 } 2464 2465 case KNOWN_MODULE_FILES: 2466 break; 2467 2468 case LANGUAGE_OPTIONS: { 2469 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0; 2470 // FIXME: The &F == *ModuleMgr.begin() check is wrong for modules. 2471 if (Listener && &F == *ModuleMgr.begin() && 2472 ParseLanguageOptions(Record, Complain, *Listener, 2473 AllowCompatibleConfigurationMismatch) && 2474 !DisableValidation && !AllowConfigurationMismatch) 2475 return ConfigurationMismatch; 2476 break; 2477 } 2478 2479 case TARGET_OPTIONS: { 2480 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2481 if (Listener && &F == *ModuleMgr.begin() && 2482 ParseTargetOptions(Record, Complain, *Listener, 2483 AllowCompatibleConfigurationMismatch) && 2484 !DisableValidation && !AllowConfigurationMismatch) 2485 return ConfigurationMismatch; 2486 break; 2487 } 2488 2489 case DIAGNOSTIC_OPTIONS: { 2490 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate)==0; 2491 if (Listener && &F == *ModuleMgr.begin() && 2492 !AllowCompatibleConfigurationMismatch && 2493 ParseDiagnosticOptions(Record, Complain, *Listener) && 2494 !DisableValidation) 2495 return OutOfDate; 2496 break; 2497 } 2498 2499 case FILE_SYSTEM_OPTIONS: { 2500 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2501 if (Listener && &F == *ModuleMgr.begin() && 2502 !AllowCompatibleConfigurationMismatch && 2503 ParseFileSystemOptions(Record, Complain, *Listener) && 2504 !DisableValidation && !AllowConfigurationMismatch) 2505 return ConfigurationMismatch; 2506 break; 2507 } 2508 2509 case HEADER_SEARCH_OPTIONS: { 2510 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2511 if (Listener && &F == *ModuleMgr.begin() && 2512 !AllowCompatibleConfigurationMismatch && 2513 ParseHeaderSearchOptions(Record, Complain, *Listener) && 2514 !DisableValidation && !AllowConfigurationMismatch) 2515 return ConfigurationMismatch; 2516 break; 2517 } 2518 2519 case PREPROCESSOR_OPTIONS: { 2520 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 2521 if (Listener && &F == *ModuleMgr.begin() && 2522 !AllowCompatibleConfigurationMismatch && 2523 ParsePreprocessorOptions(Record, Complain, *Listener, 2524 SuggestedPredefines) && 2525 !DisableValidation && !AllowConfigurationMismatch) 2526 return ConfigurationMismatch; 2527 break; 2528 } 2529 2530 case ORIGINAL_FILE: 2531 F.OriginalSourceFileID = FileID::get(Record[0]); 2532 F.ActualOriginalSourceFileName = Blob; 2533 F.OriginalSourceFileName = F.ActualOriginalSourceFileName; 2534 ResolveImportedPath(F, F.OriginalSourceFileName); 2535 break; 2536 2537 case ORIGINAL_FILE_ID: 2538 F.OriginalSourceFileID = FileID::get(Record[0]); 2539 break; 2540 2541 case ORIGINAL_PCH_DIR: 2542 F.OriginalDir = Blob; 2543 break; 2544 2545 case MODULE_NAME: 2546 F.ModuleName = Blob; 2547 if (Listener) 2548 Listener->ReadModuleName(F.ModuleName); 2549 break; 2550 2551 case MODULE_DIRECTORY: { 2552 assert(!F.ModuleName.empty() && 2553 "MODULE_DIRECTORY found before MODULE_NAME"); 2554 // If we've already loaded a module map file covering this module, we may 2555 // have a better path for it (relative to the current build). 2556 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName); 2557 if (M && M->Directory) { 2558 // If we're implicitly loading a module, the base directory can't 2559 // change between the build and use. 2560 if (F.Kind != MK_ExplicitModule) { 2561 const DirectoryEntry *BuildDir = 2562 PP.getFileManager().getDirectory(Blob); 2563 if (!BuildDir || BuildDir != M->Directory) { 2564 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) 2565 Diag(diag::err_imported_module_relocated) 2566 << F.ModuleName << Blob << M->Directory->getName(); 2567 return OutOfDate; 2568 } 2569 } 2570 F.BaseDirectory = M->Directory->getName(); 2571 } else { 2572 F.BaseDirectory = Blob; 2573 } 2574 break; 2575 } 2576 2577 case MODULE_MAP_FILE: 2578 if (ASTReadResult Result = 2579 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities)) 2580 return Result; 2581 break; 2582 2583 case INPUT_FILE_OFFSETS: 2584 NumInputs = Record[0]; 2585 NumUserInputs = Record[1]; 2586 F.InputFileOffsets = (const uint64_t *)Blob.data(); 2587 F.InputFilesLoaded.resize(NumInputs); 2588 break; 2589 } 2590 } 2591 } 2592 2593 ASTReader::ASTReadResult 2594 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) { 2595 BitstreamCursor &Stream = F.Stream; 2596 2597 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2598 Error("malformed block record in AST file"); 2599 return Failure; 2600 } 2601 2602 // Read all of the records and blocks for the AST file. 2603 RecordData Record; 2604 while (1) { 2605 llvm::BitstreamEntry Entry = Stream.advance(); 2606 2607 switch (Entry.Kind) { 2608 case llvm::BitstreamEntry::Error: 2609 Error("error at end of module block in AST file"); 2610 return Failure; 2611 case llvm::BitstreamEntry::EndBlock: { 2612 // Outside of C++, we do not store a lookup map for the translation unit. 2613 // Instead, mark it as needing a lookup map to be built if this module 2614 // contains any declarations lexically within it (which it always does!). 2615 // This usually has no cost, since we very rarely need the lookup map for 2616 // the translation unit outside C++. 2617 DeclContext *DC = Context.getTranslationUnitDecl(); 2618 if (DC->hasExternalLexicalStorage() && 2619 !getContext().getLangOpts().CPlusPlus) 2620 DC->setMustBuildLookupTable(); 2621 2622 return Success; 2623 } 2624 case llvm::BitstreamEntry::SubBlock: 2625 switch (Entry.ID) { 2626 case DECLTYPES_BLOCK_ID: 2627 // We lazily load the decls block, but we want to set up the 2628 // DeclsCursor cursor to point into it. Clone our current bitcode 2629 // cursor to it, enter the block and read the abbrevs in that block. 2630 // With the main cursor, we just skip over it. 2631 F.DeclsCursor = Stream; 2632 if (Stream.SkipBlock() || // Skip with the main cursor. 2633 // Read the abbrevs. 2634 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 2635 Error("malformed block record in AST file"); 2636 return Failure; 2637 } 2638 break; 2639 2640 case PREPROCESSOR_BLOCK_ID: 2641 F.MacroCursor = Stream; 2642 if (!PP.getExternalSource()) 2643 PP.setExternalSource(this); 2644 2645 if (Stream.SkipBlock() || 2646 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 2647 Error("malformed block record in AST file"); 2648 return Failure; 2649 } 2650 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 2651 break; 2652 2653 case PREPROCESSOR_DETAIL_BLOCK_ID: 2654 F.PreprocessorDetailCursor = Stream; 2655 if (Stream.SkipBlock() || 2656 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 2657 PREPROCESSOR_DETAIL_BLOCK_ID)) { 2658 Error("malformed preprocessor detail record in AST file"); 2659 return Failure; 2660 } 2661 F.PreprocessorDetailStartOffset 2662 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 2663 2664 if (!PP.getPreprocessingRecord()) 2665 PP.createPreprocessingRecord(); 2666 if (!PP.getPreprocessingRecord()->getExternalSource()) 2667 PP.getPreprocessingRecord()->SetExternalSource(*this); 2668 break; 2669 2670 case SOURCE_MANAGER_BLOCK_ID: 2671 if (ReadSourceManagerBlock(F)) 2672 return Failure; 2673 break; 2674 2675 case SUBMODULE_BLOCK_ID: 2676 if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities)) 2677 return Result; 2678 break; 2679 2680 case COMMENTS_BLOCK_ID: { 2681 BitstreamCursor C = Stream; 2682 if (Stream.SkipBlock() || 2683 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) { 2684 Error("malformed comments block in AST file"); 2685 return Failure; 2686 } 2687 CommentsCursors.push_back(std::make_pair(C, &F)); 2688 break; 2689 } 2690 2691 default: 2692 if (Stream.SkipBlock()) { 2693 Error("malformed block record in AST file"); 2694 return Failure; 2695 } 2696 break; 2697 } 2698 continue; 2699 2700 case llvm::BitstreamEntry::Record: 2701 // The interesting case. 2702 break; 2703 } 2704 2705 // Read and process a record. 2706 Record.clear(); 2707 StringRef Blob; 2708 switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) { 2709 default: // Default behavior: ignore. 2710 break; 2711 2712 case TYPE_OFFSET: { 2713 if (F.LocalNumTypes != 0) { 2714 Error("duplicate TYPE_OFFSET record in AST file"); 2715 return Failure; 2716 } 2717 F.TypeOffsets = (const uint32_t *)Blob.data(); 2718 F.LocalNumTypes = Record[0]; 2719 unsigned LocalBaseTypeIndex = Record[1]; 2720 F.BaseTypeIndex = getTotalNumTypes(); 2721 2722 if (F.LocalNumTypes > 0) { 2723 // Introduce the global -> local mapping for types within this module. 2724 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 2725 2726 // Introduce the local -> global mapping for types within this module. 2727 F.TypeRemap.insertOrReplace( 2728 std::make_pair(LocalBaseTypeIndex, 2729 F.BaseTypeIndex - LocalBaseTypeIndex)); 2730 2731 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 2732 } 2733 break; 2734 } 2735 2736 case DECL_OFFSET: { 2737 if (F.LocalNumDecls != 0) { 2738 Error("duplicate DECL_OFFSET record in AST file"); 2739 return Failure; 2740 } 2741 F.DeclOffsets = (const DeclOffset *)Blob.data(); 2742 F.LocalNumDecls = Record[0]; 2743 unsigned LocalBaseDeclID = Record[1]; 2744 F.BaseDeclID = getTotalNumDecls(); 2745 2746 if (F.LocalNumDecls > 0) { 2747 // Introduce the global -> local mapping for declarations within this 2748 // module. 2749 GlobalDeclMap.insert( 2750 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 2751 2752 // Introduce the local -> global mapping for declarations within this 2753 // module. 2754 F.DeclRemap.insertOrReplace( 2755 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID)); 2756 2757 // Introduce the global -> local mapping for declarations within this 2758 // module. 2759 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID; 2760 2761 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 2762 } 2763 break; 2764 } 2765 2766 case TU_UPDATE_LEXICAL: { 2767 DeclContext *TU = Context.getTranslationUnitDecl(); 2768 DeclContextInfo &Info = F.DeclContextInfos[TU]; 2769 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(Blob.data()); 2770 Info.NumLexicalDecls 2771 = static_cast<unsigned int>(Blob.size() / sizeof(KindDeclIDPair)); 2772 TU->setHasExternalLexicalStorage(true); 2773 break; 2774 } 2775 2776 case UPDATE_VISIBLE: { 2777 unsigned Idx = 0; 2778 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 2779 ASTDeclContextNameLookupTable *Table = 2780 ASTDeclContextNameLookupTable::Create( 2781 (const unsigned char *)Blob.data() + Record[Idx++], 2782 (const unsigned char *)Blob.data() + sizeof(uint32_t), 2783 (const unsigned char *)Blob.data(), 2784 ASTDeclContextNameLookupTrait(*this, F)); 2785 if (Decl *D = GetExistingDecl(ID)) { 2786 auto *DC = cast<DeclContext>(D); 2787 DC->getPrimaryContext()->setHasExternalVisibleStorage(true); 2788 auto *&LookupTable = F.DeclContextInfos[DC].NameLookupTableData; 2789 delete LookupTable; 2790 LookupTable = Table; 2791 } else 2792 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 2793 break; 2794 } 2795 2796 case IDENTIFIER_TABLE: 2797 F.IdentifierTableData = Blob.data(); 2798 if (Record[0]) { 2799 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create( 2800 (const unsigned char *)F.IdentifierTableData + Record[0], 2801 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t), 2802 (const unsigned char *)F.IdentifierTableData, 2803 ASTIdentifierLookupTrait(*this, F)); 2804 2805 PP.getIdentifierTable().setExternalIdentifierLookup(this); 2806 } 2807 break; 2808 2809 case IDENTIFIER_OFFSET: { 2810 if (F.LocalNumIdentifiers != 0) { 2811 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2812 return Failure; 2813 } 2814 F.IdentifierOffsets = (const uint32_t *)Blob.data(); 2815 F.LocalNumIdentifiers = Record[0]; 2816 unsigned LocalBaseIdentifierID = Record[1]; 2817 F.BaseIdentifierID = getTotalNumIdentifiers(); 2818 2819 if (F.LocalNumIdentifiers > 0) { 2820 // Introduce the global -> local mapping for identifiers within this 2821 // module. 2822 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 2823 &F)); 2824 2825 // Introduce the local -> global mapping for identifiers within this 2826 // module. 2827 F.IdentifierRemap.insertOrReplace( 2828 std::make_pair(LocalBaseIdentifierID, 2829 F.BaseIdentifierID - LocalBaseIdentifierID)); 2830 2831 IdentifiersLoaded.resize(IdentifiersLoaded.size() 2832 + F.LocalNumIdentifiers); 2833 } 2834 break; 2835 } 2836 2837 case EAGERLY_DESERIALIZED_DECLS: 2838 // FIXME: Skip reading this record if our ASTConsumer doesn't care 2839 // about "interesting" decls (for instance, if we're building a module). 2840 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2841 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I])); 2842 break; 2843 2844 case SPECIAL_TYPES: 2845 if (SpecialTypes.empty()) { 2846 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2847 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 2848 break; 2849 } 2850 2851 if (SpecialTypes.size() != Record.size()) { 2852 Error("invalid special-types record"); 2853 return Failure; 2854 } 2855 2856 for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2857 serialization::TypeID ID = getGlobalTypeID(F, Record[I]); 2858 if (!SpecialTypes[I]) 2859 SpecialTypes[I] = ID; 2860 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate 2861 // merge step? 2862 } 2863 break; 2864 2865 case STATISTICS: 2866 TotalNumStatements += Record[0]; 2867 TotalNumMacros += Record[1]; 2868 TotalLexicalDeclContexts += Record[2]; 2869 TotalVisibleDeclContexts += Record[3]; 2870 break; 2871 2872 case UNUSED_FILESCOPED_DECLS: 2873 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2874 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 2875 break; 2876 2877 case DELEGATING_CTORS: 2878 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2879 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 2880 break; 2881 2882 case WEAK_UNDECLARED_IDENTIFIERS: 2883 if (Record.size() % 4 != 0) { 2884 Error("invalid weak identifiers record"); 2885 return Failure; 2886 } 2887 2888 // FIXME: Ignore weak undeclared identifiers from non-original PCH 2889 // files. This isn't the way to do it :) 2890 WeakUndeclaredIdentifiers.clear(); 2891 2892 // Translate the weak, undeclared identifiers into global IDs. 2893 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 2894 WeakUndeclaredIdentifiers.push_back( 2895 getGlobalIdentifierID(F, Record[I++])); 2896 WeakUndeclaredIdentifiers.push_back( 2897 getGlobalIdentifierID(F, Record[I++])); 2898 WeakUndeclaredIdentifiers.push_back( 2899 ReadSourceLocation(F, Record, I).getRawEncoding()); 2900 WeakUndeclaredIdentifiers.push_back(Record[I++]); 2901 } 2902 break; 2903 2904 case SELECTOR_OFFSETS: { 2905 F.SelectorOffsets = (const uint32_t *)Blob.data(); 2906 F.LocalNumSelectors = Record[0]; 2907 unsigned LocalBaseSelectorID = Record[1]; 2908 F.BaseSelectorID = getTotalNumSelectors(); 2909 2910 if (F.LocalNumSelectors > 0) { 2911 // Introduce the global -> local mapping for selectors within this 2912 // module. 2913 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2914 2915 // Introduce the local -> global mapping for selectors within this 2916 // module. 2917 F.SelectorRemap.insertOrReplace( 2918 std::make_pair(LocalBaseSelectorID, 2919 F.BaseSelectorID - LocalBaseSelectorID)); 2920 2921 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2922 } 2923 break; 2924 } 2925 2926 case METHOD_POOL: 2927 F.SelectorLookupTableData = (const unsigned char *)Blob.data(); 2928 if (Record[0]) 2929 F.SelectorLookupTable 2930 = ASTSelectorLookupTable::Create( 2931 F.SelectorLookupTableData + Record[0], 2932 F.SelectorLookupTableData, 2933 ASTSelectorLookupTrait(*this, F)); 2934 TotalNumMethodPoolEntries += Record[1]; 2935 break; 2936 2937 case REFERENCED_SELECTOR_POOL: 2938 if (!Record.empty()) { 2939 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2940 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2941 Record[Idx++])); 2942 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2943 getRawEncoding()); 2944 } 2945 } 2946 break; 2947 2948 case PP_COUNTER_VALUE: 2949 if (!Record.empty() && Listener) 2950 Listener->ReadCounter(F, Record[0]); 2951 break; 2952 2953 case FILE_SORTED_DECLS: 2954 F.FileSortedDecls = (const DeclID *)Blob.data(); 2955 F.NumFileSortedDecls = Record[0]; 2956 break; 2957 2958 case SOURCE_LOCATION_OFFSETS: { 2959 F.SLocEntryOffsets = (const uint32_t *)Blob.data(); 2960 F.LocalNumSLocEntries = Record[0]; 2961 unsigned SLocSpaceSize = Record[1]; 2962 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2963 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, 2964 SLocSpaceSize); 2965 // Make our entry in the range map. BaseID is negative and growing, so 2966 // we invert it. Because we invert it, though, we need the other end of 2967 // the range. 2968 unsigned RangeStart = 2969 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2970 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2971 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2972 2973 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing. 2974 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0); 2975 GlobalSLocOffsetMap.insert( 2976 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset 2977 - SLocSpaceSize,&F)); 2978 2979 // Initialize the remapping table. 2980 // Invalid stays invalid. 2981 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0)); 2982 // This module. Base was 2 when being compiled. 2983 F.SLocRemap.insertOrReplace(std::make_pair(2U, 2984 static_cast<int>(F.SLocEntryBaseOffset - 2))); 2985 2986 TotalNumSLocEntries += F.LocalNumSLocEntries; 2987 break; 2988 } 2989 2990 case MODULE_OFFSET_MAP: { 2991 // Additional remapping information. 2992 const unsigned char *Data = (const unsigned char*)Blob.data(); 2993 const unsigned char *DataEnd = Data + Blob.size(); 2994 2995 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders. 2996 if (F.SLocRemap.find(0) == F.SLocRemap.end()) { 2997 F.SLocRemap.insert(std::make_pair(0U, 0)); 2998 F.SLocRemap.insert(std::make_pair(2U, 1)); 2999 } 3000 3001 // Continuous range maps we may be updating in our module. 3002 typedef ContinuousRangeMap<uint32_t, int, 2>::Builder 3003 RemapBuilder; 3004 RemapBuilder SLocRemap(F.SLocRemap); 3005 RemapBuilder IdentifierRemap(F.IdentifierRemap); 3006 RemapBuilder MacroRemap(F.MacroRemap); 3007 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap); 3008 RemapBuilder SubmoduleRemap(F.SubmoduleRemap); 3009 RemapBuilder SelectorRemap(F.SelectorRemap); 3010 RemapBuilder DeclRemap(F.DeclRemap); 3011 RemapBuilder TypeRemap(F.TypeRemap); 3012 3013 while(Data < DataEnd) { 3014 using namespace llvm::support; 3015 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data); 3016 StringRef Name = StringRef((const char*)Data, Len); 3017 Data += Len; 3018 ModuleFile *OM = ModuleMgr.lookup(Name); 3019 if (!OM) { 3020 Error("SourceLocation remap refers to unknown module"); 3021 return Failure; 3022 } 3023 3024 uint32_t SLocOffset = 3025 endian::readNext<uint32_t, little, unaligned>(Data); 3026 uint32_t IdentifierIDOffset = 3027 endian::readNext<uint32_t, little, unaligned>(Data); 3028 uint32_t MacroIDOffset = 3029 endian::readNext<uint32_t, little, unaligned>(Data); 3030 uint32_t PreprocessedEntityIDOffset = 3031 endian::readNext<uint32_t, little, unaligned>(Data); 3032 uint32_t SubmoduleIDOffset = 3033 endian::readNext<uint32_t, little, unaligned>(Data); 3034 uint32_t SelectorIDOffset = 3035 endian::readNext<uint32_t, little, unaligned>(Data); 3036 uint32_t DeclIDOffset = 3037 endian::readNext<uint32_t, little, unaligned>(Data); 3038 uint32_t TypeIndexOffset = 3039 endian::readNext<uint32_t, little, unaligned>(Data); 3040 3041 uint32_t None = std::numeric_limits<uint32_t>::max(); 3042 3043 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset, 3044 RemapBuilder &Remap) { 3045 if (Offset != None) 3046 Remap.insert(std::make_pair(Offset, 3047 static_cast<int>(BaseOffset - Offset))); 3048 }; 3049 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap); 3050 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap); 3051 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap); 3052 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID, 3053 PreprocessedEntityRemap); 3054 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap); 3055 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap); 3056 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap); 3057 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap); 3058 3059 // Global -> local mappings. 3060 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset; 3061 } 3062 break; 3063 } 3064 3065 case SOURCE_MANAGER_LINE_TABLE: 3066 if (ParseLineTable(F, Record)) 3067 return Failure; 3068 break; 3069 3070 case SOURCE_LOCATION_PRELOADS: { 3071 // Need to transform from the local view (1-based IDs) to the global view, 3072 // which is based off F.SLocEntryBaseID. 3073 if (!F.PreloadSLocEntries.empty()) { 3074 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file"); 3075 return Failure; 3076 } 3077 3078 F.PreloadSLocEntries.swap(Record); 3079 break; 3080 } 3081 3082 case EXT_VECTOR_DECLS: 3083 for (unsigned I = 0, N = Record.size(); I != N; ++I) 3084 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 3085 break; 3086 3087 case VTABLE_USES: 3088 if (Record.size() % 3 != 0) { 3089 Error("Invalid VTABLE_USES record"); 3090 return Failure; 3091 } 3092 3093 // Later tables overwrite earlier ones. 3094 // FIXME: Modules will have some trouble with this. This is clearly not 3095 // the right way to do this. 3096 VTableUses.clear(); 3097 3098 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 3099 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 3100 VTableUses.push_back( 3101 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 3102 VTableUses.push_back(Record[Idx++]); 3103 } 3104 break; 3105 3106 case PENDING_IMPLICIT_INSTANTIATIONS: 3107 if (PendingInstantiations.size() % 2 != 0) { 3108 Error("Invalid existing PendingInstantiations"); 3109 return Failure; 3110 } 3111 3112 if (Record.size() % 2 != 0) { 3113 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 3114 return Failure; 3115 } 3116 3117 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 3118 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 3119 PendingInstantiations.push_back( 3120 ReadSourceLocation(F, Record, I).getRawEncoding()); 3121 } 3122 break; 3123 3124 case SEMA_DECL_REFS: 3125 if (Record.size() != 2) { 3126 Error("Invalid SEMA_DECL_REFS block"); 3127 return Failure; 3128 } 3129 for (unsigned I = 0, N = Record.size(); I != N; ++I) 3130 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 3131 break; 3132 3133 case PPD_ENTITIES_OFFSETS: { 3134 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data(); 3135 assert(Blob.size() % sizeof(PPEntityOffset) == 0); 3136 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset); 3137 3138 unsigned LocalBasePreprocessedEntityID = Record[0]; 3139 3140 unsigned StartingID; 3141 if (!PP.getPreprocessingRecord()) 3142 PP.createPreprocessingRecord(); 3143 if (!PP.getPreprocessingRecord()->getExternalSource()) 3144 PP.getPreprocessingRecord()->SetExternalSource(*this); 3145 StartingID 3146 = PP.getPreprocessingRecord() 3147 ->allocateLoadedEntities(F.NumPreprocessedEntities); 3148 F.BasePreprocessedEntityID = StartingID; 3149 3150 if (F.NumPreprocessedEntities > 0) { 3151 // Introduce the global -> local mapping for preprocessed entities in 3152 // this module. 3153 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 3154 3155 // Introduce the local -> global mapping for preprocessed entities in 3156 // this module. 3157 F.PreprocessedEntityRemap.insertOrReplace( 3158 std::make_pair(LocalBasePreprocessedEntityID, 3159 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 3160 } 3161 3162 break; 3163 } 3164 3165 case DECL_UPDATE_OFFSETS: { 3166 if (Record.size() % 2 != 0) { 3167 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 3168 return Failure; 3169 } 3170 for (unsigned I = 0, N = Record.size(); I != N; I += 2) { 3171 GlobalDeclID ID = getGlobalDeclID(F, Record[I]); 3172 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1])); 3173 3174 // If we've already loaded the decl, perform the updates when we finish 3175 // loading this block. 3176 if (Decl *D = GetExistingDecl(ID)) 3177 PendingUpdateRecords.push_back(std::make_pair(ID, D)); 3178 } 3179 break; 3180 } 3181 3182 case DECL_REPLACEMENTS: { 3183 if (Record.size() % 3 != 0) { 3184 Error("invalid DECL_REPLACEMENTS block in AST file"); 3185 return Failure; 3186 } 3187 for (unsigned I = 0, N = Record.size(); I != N; I += 3) 3188 ReplacedDecls[getGlobalDeclID(F, Record[I])] 3189 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]); 3190 break; 3191 } 3192 3193 case OBJC_CATEGORIES_MAP: { 3194 if (F.LocalNumObjCCategoriesInMap != 0) { 3195 Error("duplicate OBJC_CATEGORIES_MAP record in AST file"); 3196 return Failure; 3197 } 3198 3199 F.LocalNumObjCCategoriesInMap = Record[0]; 3200 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data(); 3201 break; 3202 } 3203 3204 case OBJC_CATEGORIES: 3205 F.ObjCCategories.swap(Record); 3206 break; 3207 3208 case CXX_BASE_SPECIFIER_OFFSETS: { 3209 if (F.LocalNumCXXBaseSpecifiers != 0) { 3210 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 3211 return Failure; 3212 } 3213 3214 F.LocalNumCXXBaseSpecifiers = Record[0]; 3215 F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data(); 3216 break; 3217 } 3218 3219 case CXX_CTOR_INITIALIZERS_OFFSETS: { 3220 if (F.LocalNumCXXCtorInitializers != 0) { 3221 Error("duplicate CXX_CTOR_INITIALIZERS_OFFSETS record in AST file"); 3222 return Failure; 3223 } 3224 3225 F.LocalNumCXXCtorInitializers = Record[0]; 3226 F.CXXCtorInitializersOffsets = (const uint32_t *)Blob.data(); 3227 break; 3228 } 3229 3230 case DIAG_PRAGMA_MAPPINGS: 3231 if (F.PragmaDiagMappings.empty()) 3232 F.PragmaDiagMappings.swap(Record); 3233 else 3234 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 3235 Record.begin(), Record.end()); 3236 break; 3237 3238 case CUDA_SPECIAL_DECL_REFS: 3239 // Later tables overwrite earlier ones. 3240 // FIXME: Modules will have trouble with this. 3241 CUDASpecialDeclRefs.clear(); 3242 for (unsigned I = 0, N = Record.size(); I != N; ++I) 3243 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 3244 break; 3245 3246 case HEADER_SEARCH_TABLE: { 3247 F.HeaderFileInfoTableData = Blob.data(); 3248 F.LocalNumHeaderFileInfos = Record[1]; 3249 if (Record[0]) { 3250 F.HeaderFileInfoTable 3251 = HeaderFileInfoLookupTable::Create( 3252 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 3253 (const unsigned char *)F.HeaderFileInfoTableData, 3254 HeaderFileInfoTrait(*this, F, 3255 &PP.getHeaderSearchInfo(), 3256 Blob.data() + Record[2])); 3257 3258 PP.getHeaderSearchInfo().SetExternalSource(this); 3259 if (!PP.getHeaderSearchInfo().getExternalLookup()) 3260 PP.getHeaderSearchInfo().SetExternalLookup(this); 3261 } 3262 break; 3263 } 3264 3265 case FP_PRAGMA_OPTIONS: 3266 // Later tables overwrite earlier ones. 3267 FPPragmaOptions.swap(Record); 3268 break; 3269 3270 case OPENCL_EXTENSIONS: 3271 // Later tables overwrite earlier ones. 3272 OpenCLExtensions.swap(Record); 3273 break; 3274 3275 case TENTATIVE_DEFINITIONS: 3276 for (unsigned I = 0, N = Record.size(); I != N; ++I) 3277 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 3278 break; 3279 3280 case KNOWN_NAMESPACES: 3281 for (unsigned I = 0, N = Record.size(); I != N; ++I) 3282 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 3283 break; 3284 3285 case UNDEFINED_BUT_USED: 3286 if (UndefinedButUsed.size() % 2 != 0) { 3287 Error("Invalid existing UndefinedButUsed"); 3288 return Failure; 3289 } 3290 3291 if (Record.size() % 2 != 0) { 3292 Error("invalid undefined-but-used record"); 3293 return Failure; 3294 } 3295 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 3296 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++])); 3297 UndefinedButUsed.push_back( 3298 ReadSourceLocation(F, Record, I).getRawEncoding()); 3299 } 3300 break; 3301 3302 case IMPORTED_MODULES: { 3303 if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) { 3304 // If we aren't loading a module (which has its own exports), make 3305 // all of the imported modules visible. 3306 // FIXME: Deal with macros-only imports. 3307 for (unsigned I = 0, N = Record.size(); I != N; /**/) { 3308 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]); 3309 SourceLocation Loc = ReadSourceLocation(F, Record, I); 3310 if (GlobalID) 3311 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc)); 3312 } 3313 } 3314 break; 3315 } 3316 3317 case LOCAL_REDECLARATIONS: { 3318 F.RedeclarationChains.swap(Record); 3319 break; 3320 } 3321 3322 case LOCAL_REDECLARATIONS_MAP: { 3323 if (F.LocalNumRedeclarationsInMap != 0) { 3324 Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file"); 3325 return Failure; 3326 } 3327 3328 F.LocalNumRedeclarationsInMap = Record[0]; 3329 F.RedeclarationsMap = (const LocalRedeclarationsInfo *)Blob.data(); 3330 break; 3331 } 3332 3333 case MACRO_OFFSET: { 3334 if (F.LocalNumMacros != 0) { 3335 Error("duplicate MACRO_OFFSET record in AST file"); 3336 return Failure; 3337 } 3338 F.MacroOffsets = (const uint32_t *)Blob.data(); 3339 F.LocalNumMacros = Record[0]; 3340 unsigned LocalBaseMacroID = Record[1]; 3341 F.BaseMacroID = getTotalNumMacros(); 3342 3343 if (F.LocalNumMacros > 0) { 3344 // Introduce the global -> local mapping for macros within this module. 3345 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F)); 3346 3347 // Introduce the local -> global mapping for macros within this module. 3348 F.MacroRemap.insertOrReplace( 3349 std::make_pair(LocalBaseMacroID, 3350 F.BaseMacroID - LocalBaseMacroID)); 3351 3352 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros); 3353 } 3354 break; 3355 } 3356 3357 case LATE_PARSED_TEMPLATE: { 3358 LateParsedTemplates.append(Record.begin(), Record.end()); 3359 break; 3360 } 3361 3362 case OPTIMIZE_PRAGMA_OPTIONS: 3363 if (Record.size() != 1) { 3364 Error("invalid pragma optimize record"); 3365 return Failure; 3366 } 3367 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]); 3368 break; 3369 3370 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES: 3371 for (unsigned I = 0, N = Record.size(); I != N; ++I) 3372 UnusedLocalTypedefNameCandidates.push_back( 3373 getGlobalDeclID(F, Record[I])); 3374 break; 3375 } 3376 } 3377 } 3378 3379 ASTReader::ASTReadResult 3380 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F, 3381 const ModuleFile *ImportedBy, 3382 unsigned ClientLoadCapabilities) { 3383 unsigned Idx = 0; 3384 F.ModuleMapPath = ReadPath(F, Record, Idx); 3385 3386 if (F.Kind == MK_ExplicitModule) { 3387 // For an explicitly-loaded module, we don't care whether the original 3388 // module map file exists or matches. 3389 return Success; 3390 } 3391 3392 // Try to resolve ModuleName in the current header search context and 3393 // verify that it is found in the same module map file as we saved. If the 3394 // top-level AST file is a main file, skip this check because there is no 3395 // usable header search context. 3396 assert(!F.ModuleName.empty() && 3397 "MODULE_NAME should come before MODULE_MAP_FILE"); 3398 if (F.Kind == MK_ImplicitModule && 3399 (*ModuleMgr.begin())->Kind != MK_MainFile) { 3400 // An implicitly-loaded module file should have its module listed in some 3401 // module map file that we've already loaded. 3402 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName); 3403 auto &Map = PP.getHeaderSearchInfo().getModuleMap(); 3404 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr; 3405 if (!ModMap) { 3406 assert(ImportedBy && "top-level import should be verified"); 3407 if ((ClientLoadCapabilities & ARR_Missing) == 0) 3408 Diag(diag::err_imported_module_not_found) << F.ModuleName << F.FileName 3409 << ImportedBy->FileName 3410 << F.ModuleMapPath; 3411 return Missing; 3412 } 3413 3414 assert(M->Name == F.ModuleName && "found module with different name"); 3415 3416 // Check the primary module map file. 3417 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath); 3418 if (StoredModMap == nullptr || StoredModMap != ModMap) { 3419 assert(ModMap && "found module is missing module map file"); 3420 assert(ImportedBy && "top-level import should be verified"); 3421 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) 3422 Diag(diag::err_imported_module_modmap_changed) 3423 << F.ModuleName << ImportedBy->FileName 3424 << ModMap->getName() << F.ModuleMapPath; 3425 return OutOfDate; 3426 } 3427 3428 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps; 3429 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) { 3430 // FIXME: we should use input files rather than storing names. 3431 std::string Filename = ReadPath(F, Record, Idx); 3432 const FileEntry *F = 3433 FileMgr.getFile(Filename, false, false); 3434 if (F == nullptr) { 3435 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) 3436 Error("could not find file '" + Filename +"' referenced by AST file"); 3437 return OutOfDate; 3438 } 3439 AdditionalStoredMaps.insert(F); 3440 } 3441 3442 // Check any additional module map files (e.g. module.private.modulemap) 3443 // that are not in the pcm. 3444 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) { 3445 for (const FileEntry *ModMap : *AdditionalModuleMaps) { 3446 // Remove files that match 3447 // Note: SmallPtrSet::erase is really remove 3448 if (!AdditionalStoredMaps.erase(ModMap)) { 3449 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) 3450 Diag(diag::err_module_different_modmap) 3451 << F.ModuleName << /*new*/0 << ModMap->getName(); 3452 return OutOfDate; 3453 } 3454 } 3455 } 3456 3457 // Check any additional module map files that are in the pcm, but not 3458 // found in header search. Cases that match are already removed. 3459 for (const FileEntry *ModMap : AdditionalStoredMaps) { 3460 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) 3461 Diag(diag::err_module_different_modmap) 3462 << F.ModuleName << /*not new*/1 << ModMap->getName(); 3463 return OutOfDate; 3464 } 3465 } 3466 3467 if (Listener) 3468 Listener->ReadModuleMapFile(F.ModuleMapPath); 3469 return Success; 3470 } 3471 3472 3473 /// \brief Move the given method to the back of the global list of methods. 3474 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) { 3475 // Find the entry for this selector in the method pool. 3476 Sema::GlobalMethodPool::iterator Known 3477 = S.MethodPool.find(Method->getSelector()); 3478 if (Known == S.MethodPool.end()) 3479 return; 3480 3481 // Retrieve the appropriate method list. 3482 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first 3483 : Known->second.second; 3484 bool Found = false; 3485 for (ObjCMethodList *List = &Start; List; List = List->getNext()) { 3486 if (!Found) { 3487 if (List->getMethod() == Method) { 3488 Found = true; 3489 } else { 3490 // Keep searching. 3491 continue; 3492 } 3493 } 3494 3495 if (List->getNext()) 3496 List->setMethod(List->getNext()->getMethod()); 3497 else 3498 List->setMethod(Method); 3499 } 3500 } 3501 3502 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner, 3503 bool FromFinalization) { 3504 // FIXME: Only do this if Owner->NameVisibility == AllVisible. 3505 for (Decl *D : Names.HiddenDecls) { 3506 bool wasHidden = D->Hidden; 3507 D->Hidden = false; 3508 3509 if (wasHidden && SemaObj) { 3510 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) { 3511 moveMethodToBackOfGlobalList(*SemaObj, Method); 3512 } 3513 } 3514 } 3515 3516 assert((FromFinalization || Owner->NameVisibility >= Module::MacrosVisible) && 3517 "nothing to make visible?"); 3518 for (const auto &Macro : Names.HiddenMacros) { 3519 if (FromFinalization) 3520 PP.appendMacroDirective(Macro.first, 3521 Macro.second->import(PP, SourceLocation())); 3522 else 3523 installImportedMacro(Macro.first, Macro.second, Owner); 3524 } 3525 } 3526 3527 void ASTReader::makeModuleVisible(Module *Mod, 3528 Module::NameVisibilityKind NameVisibility, 3529 SourceLocation ImportLoc, 3530 bool Complain) { 3531 llvm::SmallPtrSet<Module *, 4> Visited; 3532 SmallVector<Module *, 4> Stack; 3533 Stack.push_back(Mod); 3534 while (!Stack.empty()) { 3535 Mod = Stack.pop_back_val(); 3536 3537 if (NameVisibility <= Mod->NameVisibility) { 3538 // This module already has this level of visibility (or greater), so 3539 // there is nothing more to do. 3540 continue; 3541 } 3542 3543 if (!Mod->isAvailable()) { 3544 // Modules that aren't available cannot be made visible. 3545 continue; 3546 } 3547 3548 // Update the module's name visibility. 3549 if (NameVisibility >= Module::MacrosVisible && 3550 Mod->NameVisibility < Module::MacrosVisible) 3551 Mod->MacroVisibilityLoc = ImportLoc; 3552 Mod->NameVisibility = NameVisibility; 3553 3554 // If we've already deserialized any names from this module, 3555 // mark them as visible. 3556 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 3557 if (Hidden != HiddenNamesMap.end()) { 3558 auto HiddenNames = std::move(*Hidden); 3559 HiddenNamesMap.erase(Hidden); 3560 makeNamesVisible(HiddenNames.second, HiddenNames.first, 3561 /*FromFinalization*/false); 3562 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() && 3563 "making names visible added hidden names"); 3564 } 3565 3566 // Push any exported modules onto the stack to be marked as visible. 3567 SmallVector<Module *, 16> Exports; 3568 Mod->getExportedModules(Exports); 3569 for (SmallVectorImpl<Module *>::iterator 3570 I = Exports.begin(), E = Exports.end(); I != E; ++I) { 3571 Module *Exported = *I; 3572 if (Visited.insert(Exported).second) 3573 Stack.push_back(Exported); 3574 } 3575 3576 // Detect any conflicts. 3577 if (Complain) { 3578 assert(ImportLoc.isValid() && "Missing import location"); 3579 for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { 3580 if (Mod->Conflicts[I].Other->NameVisibility >= NameVisibility) { 3581 Diag(ImportLoc, diag::warn_module_conflict) 3582 << Mod->getFullModuleName() 3583 << Mod->Conflicts[I].Other->getFullModuleName() 3584 << Mod->Conflicts[I].Message; 3585 // FIXME: Need note where the other module was imported. 3586 } 3587 } 3588 } 3589 } 3590 } 3591 3592 bool ASTReader::loadGlobalIndex() { 3593 if (GlobalIndex) 3594 return false; 3595 3596 if (TriedLoadingGlobalIndex || !UseGlobalIndex || 3597 !Context.getLangOpts().Modules) 3598 return true; 3599 3600 // Try to load the global index. 3601 TriedLoadingGlobalIndex = true; 3602 StringRef ModuleCachePath 3603 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath(); 3604 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result 3605 = GlobalModuleIndex::readIndex(ModuleCachePath); 3606 if (!Result.first) 3607 return true; 3608 3609 GlobalIndex.reset(Result.first); 3610 ModuleMgr.setGlobalIndex(GlobalIndex.get()); 3611 return false; 3612 } 3613 3614 bool ASTReader::isGlobalIndexUnavailable() const { 3615 return Context.getLangOpts().Modules && UseGlobalIndex && 3616 !hasGlobalIndex() && TriedLoadingGlobalIndex; 3617 } 3618 3619 static void updateModuleTimestamp(ModuleFile &MF) { 3620 // Overwrite the timestamp file contents so that file's mtime changes. 3621 std::string TimestampFilename = MF.getTimestampFilename(); 3622 std::error_code EC; 3623 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text); 3624 if (EC) 3625 return; 3626 OS << "Timestamp file\n"; 3627 } 3628 3629 ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 3630 ModuleKind Type, 3631 SourceLocation ImportLoc, 3632 unsigned ClientLoadCapabilities) { 3633 llvm::SaveAndRestore<SourceLocation> 3634 SetCurImportLocRAII(CurrentImportLoc, ImportLoc); 3635 3636 // Defer any pending actions until we get to the end of reading the AST file. 3637 Deserializing AnASTFile(this); 3638 3639 // Bump the generation number. 3640 unsigned PreviousGeneration = incrementGeneration(Context); 3641 3642 unsigned NumModules = ModuleMgr.size(); 3643 SmallVector<ImportedModule, 4> Loaded; 3644 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc, 3645 /*ImportedBy=*/nullptr, Loaded, 3646 0, 0, 0, 3647 ClientLoadCapabilities)) { 3648 case Failure: 3649 case Missing: 3650 case OutOfDate: 3651 case VersionMismatch: 3652 case ConfigurationMismatch: 3653 case HadErrors: { 3654 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet; 3655 for (const ImportedModule &IM : Loaded) 3656 LoadedSet.insert(IM.Mod); 3657 3658 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(), 3659 LoadedSet, 3660 Context.getLangOpts().Modules 3661 ? &PP.getHeaderSearchInfo().getModuleMap() 3662 : nullptr); 3663 3664 // If we find that any modules are unusable, the global index is going 3665 // to be out-of-date. Just remove it. 3666 GlobalIndex.reset(); 3667 ModuleMgr.setGlobalIndex(nullptr); 3668 return ReadResult; 3669 } 3670 case Success: 3671 break; 3672 } 3673 3674 // Here comes stuff that we only do once the entire chain is loaded. 3675 3676 // Load the AST blocks of all of the modules that we loaded. 3677 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 3678 MEnd = Loaded.end(); 3679 M != MEnd; ++M) { 3680 ModuleFile &F = *M->Mod; 3681 3682 // Read the AST block. 3683 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities)) 3684 return Result; 3685 3686 // Once read, set the ModuleFile bit base offset and update the size in 3687 // bits of all files we've seen. 3688 F.GlobalBitOffset = TotalModulesSizeInBits; 3689 TotalModulesSizeInBits += F.SizeInBits; 3690 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 3691 3692 // Preload SLocEntries. 3693 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) { 3694 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 3695 // Load it through the SourceManager and don't call ReadSLocEntry() 3696 // directly because the entry may have already been loaded in which case 3697 // calling ReadSLocEntry() directly would trigger an assertion in 3698 // SourceManager. 3699 SourceMgr.getLoadedSLocEntryByID(Index); 3700 } 3701 } 3702 3703 // Setup the import locations and notify the module manager that we've 3704 // committed to these module files. 3705 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 3706 MEnd = Loaded.end(); 3707 M != MEnd; ++M) { 3708 ModuleFile &F = *M->Mod; 3709 3710 ModuleMgr.moduleFileAccepted(&F); 3711 3712 // Set the import location. 3713 F.DirectImportLoc = ImportLoc; 3714 if (!M->ImportedBy) 3715 F.ImportLoc = M->ImportLoc; 3716 else 3717 F.ImportLoc = ReadSourceLocation(*M->ImportedBy, 3718 M->ImportLoc.getRawEncoding()); 3719 } 3720 3721 // Mark all of the identifiers in the identifier table as being out of date, 3722 // so that various accessors know to check the loaded modules when the 3723 // identifier is used. 3724 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 3725 IdEnd = PP.getIdentifierTable().end(); 3726 Id != IdEnd; ++Id) 3727 Id->second->setOutOfDate(true); 3728 3729 // Resolve any unresolved module exports. 3730 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) { 3731 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I]; 3732 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 3733 Module *ResolvedMod = getSubmodule(GlobalID); 3734 3735 switch (Unresolved.Kind) { 3736 case UnresolvedModuleRef::Conflict: 3737 if (ResolvedMod) { 3738 Module::Conflict Conflict; 3739 Conflict.Other = ResolvedMod; 3740 Conflict.Message = Unresolved.String.str(); 3741 Unresolved.Mod->Conflicts.push_back(Conflict); 3742 } 3743 continue; 3744 3745 case UnresolvedModuleRef::Import: 3746 if (ResolvedMod) 3747 Unresolved.Mod->Imports.push_back(ResolvedMod); 3748 continue; 3749 3750 case UnresolvedModuleRef::Export: 3751 if (ResolvedMod || Unresolved.IsWildcard) 3752 Unresolved.Mod->Exports.push_back( 3753 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 3754 continue; 3755 } 3756 } 3757 UnresolvedModuleRefs.clear(); 3758 3759 // FIXME: How do we load the 'use'd modules? They may not be submodules. 3760 // Might be unnecessary as use declarations are only used to build the 3761 // module itself. 3762 3763 InitializeContext(); 3764 3765 if (SemaObj) 3766 UpdateSema(); 3767 3768 if (DeserializationListener) 3769 DeserializationListener->ReaderInitialized(this); 3770 3771 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule(); 3772 if (!PrimaryModule.OriginalSourceFileID.isInvalid()) { 3773 PrimaryModule.OriginalSourceFileID 3774 = FileID::get(PrimaryModule.SLocEntryBaseID 3775 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1); 3776 3777 // If this AST file is a precompiled preamble, then set the 3778 // preamble file ID of the source manager to the file source file 3779 // from which the preamble was built. 3780 if (Type == MK_Preamble) { 3781 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID); 3782 } else if (Type == MK_MainFile) { 3783 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID); 3784 } 3785 } 3786 3787 // For any Objective-C class definitions we have already loaded, make sure 3788 // that we load any additional categories. 3789 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) { 3790 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(), 3791 ObjCClassesLoaded[I], 3792 PreviousGeneration); 3793 } 3794 3795 if (PP.getHeaderSearchInfo() 3796 .getHeaderSearchOpts() 3797 .ModulesValidateOncePerBuildSession) { 3798 // Now we are certain that the module and all modules it depends on are 3799 // up to date. Create or update timestamp files for modules that are 3800 // located in the module cache (not for PCH files that could be anywhere 3801 // in the filesystem). 3802 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) { 3803 ImportedModule &M = Loaded[I]; 3804 if (M.Mod->Kind == MK_ImplicitModule) { 3805 updateModuleTimestamp(*M.Mod); 3806 } 3807 } 3808 } 3809 3810 return Success; 3811 } 3812 3813 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile); 3814 3815 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'. 3816 static bool startsWithASTFileMagic(BitstreamCursor &Stream) { 3817 return Stream.Read(8) == 'C' && 3818 Stream.Read(8) == 'P' && 3819 Stream.Read(8) == 'C' && 3820 Stream.Read(8) == 'H'; 3821 } 3822 3823 ASTReader::ASTReadResult 3824 ASTReader::ReadASTCore(StringRef FileName, 3825 ModuleKind Type, 3826 SourceLocation ImportLoc, 3827 ModuleFile *ImportedBy, 3828 SmallVectorImpl<ImportedModule> &Loaded, 3829 off_t ExpectedSize, time_t ExpectedModTime, 3830 ASTFileSignature ExpectedSignature, 3831 unsigned ClientLoadCapabilities) { 3832 ModuleFile *M; 3833 std::string ErrorStr; 3834 ModuleManager::AddModuleResult AddResult 3835 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy, 3836 getGeneration(), ExpectedSize, ExpectedModTime, 3837 ExpectedSignature, readASTFileSignature, 3838 M, ErrorStr); 3839 3840 switch (AddResult) { 3841 case ModuleManager::AlreadyLoaded: 3842 return Success; 3843 3844 case ModuleManager::NewlyLoaded: 3845 // Load module file below. 3846 break; 3847 3848 case ModuleManager::Missing: 3849 // The module file was missing; if the client can handle that, return 3850 // it. 3851 if (ClientLoadCapabilities & ARR_Missing) 3852 return Missing; 3853 3854 // Otherwise, return an error. 3855 { 3856 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 3857 + ErrorStr; 3858 Error(Msg); 3859 } 3860 return Failure; 3861 3862 case ModuleManager::OutOfDate: 3863 // We couldn't load the module file because it is out-of-date. If the 3864 // client can handle out-of-date, return it. 3865 if (ClientLoadCapabilities & ARR_OutOfDate) 3866 return OutOfDate; 3867 3868 // Otherwise, return an error. 3869 { 3870 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 3871 + ErrorStr; 3872 Error(Msg); 3873 } 3874 return Failure; 3875 } 3876 3877 assert(M && "Missing module file"); 3878 3879 // FIXME: This seems rather a hack. Should CurrentDir be part of the 3880 // module? 3881 if (FileName != "-") { 3882 CurrentDir = llvm::sys::path::parent_path(FileName); 3883 if (CurrentDir.empty()) CurrentDir = "."; 3884 } 3885 3886 ModuleFile &F = *M; 3887 BitstreamCursor &Stream = F.Stream; 3888 Stream.init(&F.StreamFile); 3889 F.SizeInBits = F.Buffer->getBufferSize() * 8; 3890 3891 // Sniff for the signature. 3892 if (!startsWithASTFileMagic(Stream)) { 3893 Diag(diag::err_not_a_pch_file) << FileName; 3894 return Failure; 3895 } 3896 3897 // This is used for compatibility with older PCH formats. 3898 bool HaveReadControlBlock = false; 3899 3900 while (1) { 3901 llvm::BitstreamEntry Entry = Stream.advance(); 3902 3903 switch (Entry.Kind) { 3904 case llvm::BitstreamEntry::Error: 3905 case llvm::BitstreamEntry::EndBlock: 3906 case llvm::BitstreamEntry::Record: 3907 Error("invalid record at top-level of AST file"); 3908 return Failure; 3909 3910 case llvm::BitstreamEntry::SubBlock: 3911 break; 3912 } 3913 3914 // We only know the control subblock ID. 3915 switch (Entry.ID) { 3916 case llvm::bitc::BLOCKINFO_BLOCK_ID: 3917 if (Stream.ReadBlockInfoBlock()) { 3918 Error("malformed BlockInfoBlock in AST file"); 3919 return Failure; 3920 } 3921 break; 3922 case CONTROL_BLOCK_ID: 3923 HaveReadControlBlock = true; 3924 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) { 3925 case Success: 3926 break; 3927 3928 case Failure: return Failure; 3929 case Missing: return Missing; 3930 case OutOfDate: return OutOfDate; 3931 case VersionMismatch: return VersionMismatch; 3932 case ConfigurationMismatch: return ConfigurationMismatch; 3933 case HadErrors: return HadErrors; 3934 } 3935 break; 3936 case AST_BLOCK_ID: 3937 if (!HaveReadControlBlock) { 3938 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 3939 Diag(diag::err_pch_version_too_old); 3940 return VersionMismatch; 3941 } 3942 3943 // Record that we've loaded this module. 3944 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc)); 3945 return Success; 3946 3947 default: 3948 if (Stream.SkipBlock()) { 3949 Error("malformed block record in AST file"); 3950 return Failure; 3951 } 3952 break; 3953 } 3954 } 3955 3956 return Success; 3957 } 3958 3959 void ASTReader::InitializeContext() { 3960 // If there's a listener, notify them that we "read" the translation unit. 3961 if (DeserializationListener) 3962 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 3963 Context.getTranslationUnitDecl()); 3964 3965 // FIXME: Find a better way to deal with collisions between these 3966 // built-in types. Right now, we just ignore the problem. 3967 3968 // Load the special types. 3969 if (SpecialTypes.size() >= NumSpecialTypeIDs) { 3970 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 3971 if (!Context.CFConstantStringTypeDecl) 3972 Context.setCFConstantStringType(GetType(String)); 3973 } 3974 3975 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 3976 QualType FileType = GetType(File); 3977 if (FileType.isNull()) { 3978 Error("FILE type is NULL"); 3979 return; 3980 } 3981 3982 if (!Context.FILEDecl) { 3983 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 3984 Context.setFILEDecl(Typedef->getDecl()); 3985 else { 3986 const TagType *Tag = FileType->getAs<TagType>(); 3987 if (!Tag) { 3988 Error("Invalid FILE type in AST file"); 3989 return; 3990 } 3991 Context.setFILEDecl(Tag->getDecl()); 3992 } 3993 } 3994 } 3995 3996 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 3997 QualType Jmp_bufType = GetType(Jmp_buf); 3998 if (Jmp_bufType.isNull()) { 3999 Error("jmp_buf type is NULL"); 4000 return; 4001 } 4002 4003 if (!Context.jmp_bufDecl) { 4004 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 4005 Context.setjmp_bufDecl(Typedef->getDecl()); 4006 else { 4007 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 4008 if (!Tag) { 4009 Error("Invalid jmp_buf type in AST file"); 4010 return; 4011 } 4012 Context.setjmp_bufDecl(Tag->getDecl()); 4013 } 4014 } 4015 } 4016 4017 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 4018 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 4019 if (Sigjmp_bufType.isNull()) { 4020 Error("sigjmp_buf type is NULL"); 4021 return; 4022 } 4023 4024 if (!Context.sigjmp_bufDecl) { 4025 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 4026 Context.setsigjmp_bufDecl(Typedef->getDecl()); 4027 else { 4028 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 4029 assert(Tag && "Invalid sigjmp_buf type in AST file"); 4030 Context.setsigjmp_bufDecl(Tag->getDecl()); 4031 } 4032 } 4033 } 4034 4035 if (unsigned ObjCIdRedef 4036 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 4037 if (Context.ObjCIdRedefinitionType.isNull()) 4038 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 4039 } 4040 4041 if (unsigned ObjCClassRedef 4042 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 4043 if (Context.ObjCClassRedefinitionType.isNull()) 4044 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 4045 } 4046 4047 if (unsigned ObjCSelRedef 4048 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 4049 if (Context.ObjCSelRedefinitionType.isNull()) 4050 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 4051 } 4052 4053 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 4054 QualType Ucontext_tType = GetType(Ucontext_t); 4055 if (Ucontext_tType.isNull()) { 4056 Error("ucontext_t type is NULL"); 4057 return; 4058 } 4059 4060 if (!Context.ucontext_tDecl) { 4061 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 4062 Context.setucontext_tDecl(Typedef->getDecl()); 4063 else { 4064 const TagType *Tag = Ucontext_tType->getAs<TagType>(); 4065 assert(Tag && "Invalid ucontext_t type in AST file"); 4066 Context.setucontext_tDecl(Tag->getDecl()); 4067 } 4068 } 4069 } 4070 } 4071 4072 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 4073 4074 // If there were any CUDA special declarations, deserialize them. 4075 if (!CUDASpecialDeclRefs.empty()) { 4076 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 4077 Context.setcudaConfigureCallDecl( 4078 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 4079 } 4080 4081 // Re-export any modules that were imported by a non-module AST file. 4082 // FIXME: This does not make macro-only imports visible again. It also doesn't 4083 // make #includes mapped to module imports visible. 4084 for (auto &Import : ImportedModules) { 4085 if (Module *Imported = getSubmodule(Import.ID)) 4086 makeModuleVisible(Imported, Module::AllVisible, 4087 /*ImportLoc=*/Import.ImportLoc, 4088 /*Complain=*/false); 4089 } 4090 ImportedModules.clear(); 4091 } 4092 4093 void ASTReader::finalizeForWriting() { 4094 while (!HiddenNamesMap.empty()) { 4095 auto HiddenNames = std::move(*HiddenNamesMap.begin()); 4096 HiddenNamesMap.erase(HiddenNamesMap.begin()); 4097 makeNamesVisible(HiddenNames.second, HiddenNames.first, 4098 /*FromFinalization*/true); 4099 } 4100 } 4101 4102 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the 4103 /// cursor into the start of the given block ID, returning false on success and 4104 /// true on failure. 4105 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) { 4106 while (1) { 4107 llvm::BitstreamEntry Entry = Cursor.advance(); 4108 switch (Entry.Kind) { 4109 case llvm::BitstreamEntry::Error: 4110 case llvm::BitstreamEntry::EndBlock: 4111 return true; 4112 4113 case llvm::BitstreamEntry::Record: 4114 // Ignore top-level records. 4115 Cursor.skipRecord(Entry.ID); 4116 break; 4117 4118 case llvm::BitstreamEntry::SubBlock: 4119 if (Entry.ID == BlockID) { 4120 if (Cursor.EnterSubBlock(BlockID)) 4121 return true; 4122 // Found it! 4123 return false; 4124 } 4125 4126 if (Cursor.SkipBlock()) 4127 return true; 4128 } 4129 } 4130 } 4131 4132 /// \brief Reads and return the signature record from \p StreamFile's control 4133 /// block, or else returns 0. 4134 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){ 4135 BitstreamCursor Stream(StreamFile); 4136 if (!startsWithASTFileMagic(Stream)) 4137 return 0; 4138 4139 // Scan for the CONTROL_BLOCK_ID block. 4140 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) 4141 return 0; 4142 4143 // Scan for SIGNATURE inside the control block. 4144 ASTReader::RecordData Record; 4145 while (1) { 4146 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 4147 if (Entry.Kind == llvm::BitstreamEntry::EndBlock || 4148 Entry.Kind != llvm::BitstreamEntry::Record) 4149 return 0; 4150 4151 Record.clear(); 4152 StringRef Blob; 4153 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob)) 4154 return Record[0]; 4155 } 4156 } 4157 4158 /// \brief Retrieve the name of the original source file name 4159 /// directly from the AST file, without actually loading the AST 4160 /// file. 4161 std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 4162 FileManager &FileMgr, 4163 DiagnosticsEngine &Diags) { 4164 // Open the AST file. 4165 auto Buffer = FileMgr.getBufferForFile(ASTFileName); 4166 if (!Buffer) { 4167 Diags.Report(diag::err_fe_unable_to_read_pch_file) 4168 << ASTFileName << Buffer.getError().message(); 4169 return std::string(); 4170 } 4171 4172 // Initialize the stream 4173 llvm::BitstreamReader StreamFile; 4174 StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(), 4175 (const unsigned char *)(*Buffer)->getBufferEnd()); 4176 BitstreamCursor Stream(StreamFile); 4177 4178 // Sniff for the signature. 4179 if (!startsWithASTFileMagic(Stream)) { 4180 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 4181 return std::string(); 4182 } 4183 4184 // Scan for the CONTROL_BLOCK_ID block. 4185 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) { 4186 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 4187 return std::string(); 4188 } 4189 4190 // Scan for ORIGINAL_FILE inside the control block. 4191 RecordData Record; 4192 while (1) { 4193 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 4194 if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 4195 return std::string(); 4196 4197 if (Entry.Kind != llvm::BitstreamEntry::Record) { 4198 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 4199 return std::string(); 4200 } 4201 4202 Record.clear(); 4203 StringRef Blob; 4204 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE) 4205 return Blob.str(); 4206 } 4207 } 4208 4209 namespace { 4210 class SimplePCHValidator : public ASTReaderListener { 4211 const LangOptions &ExistingLangOpts; 4212 const TargetOptions &ExistingTargetOpts; 4213 const PreprocessorOptions &ExistingPPOpts; 4214 std::string ExistingModuleCachePath; 4215 FileManager &FileMgr; 4216 4217 public: 4218 SimplePCHValidator(const LangOptions &ExistingLangOpts, 4219 const TargetOptions &ExistingTargetOpts, 4220 const PreprocessorOptions &ExistingPPOpts, 4221 StringRef ExistingModuleCachePath, 4222 FileManager &FileMgr) 4223 : ExistingLangOpts(ExistingLangOpts), 4224 ExistingTargetOpts(ExistingTargetOpts), 4225 ExistingPPOpts(ExistingPPOpts), 4226 ExistingModuleCachePath(ExistingModuleCachePath), 4227 FileMgr(FileMgr) 4228 { 4229 } 4230 4231 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, 4232 bool AllowCompatibleDifferences) override { 4233 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr, 4234 AllowCompatibleDifferences); 4235 } 4236 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, 4237 bool AllowCompatibleDifferences) override { 4238 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr, 4239 AllowCompatibleDifferences); 4240 } 4241 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, 4242 StringRef SpecificModuleCachePath, 4243 bool Complain) override { 4244 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath, 4245 ExistingModuleCachePath, 4246 nullptr, ExistingLangOpts); 4247 } 4248 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 4249 bool Complain, 4250 std::string &SuggestedPredefines) override { 4251 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr, 4252 SuggestedPredefines, ExistingLangOpts); 4253 } 4254 }; 4255 } 4256 4257 bool ASTReader::readASTFileControlBlock(StringRef Filename, 4258 FileManager &FileMgr, 4259 ASTReaderListener &Listener) { 4260 // Open the AST file. 4261 // FIXME: This allows use of the VFS; we do not allow use of the 4262 // VFS when actually loading a module. 4263 auto Buffer = FileMgr.getBufferForFile(Filename); 4264 if (!Buffer) { 4265 return true; 4266 } 4267 4268 // Initialize the stream 4269 llvm::BitstreamReader StreamFile; 4270 StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(), 4271 (const unsigned char *)(*Buffer)->getBufferEnd()); 4272 BitstreamCursor Stream(StreamFile); 4273 4274 // Sniff for the signature. 4275 if (!startsWithASTFileMagic(Stream)) 4276 return true; 4277 4278 // Scan for the CONTROL_BLOCK_ID block. 4279 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) 4280 return true; 4281 4282 bool NeedsInputFiles = Listener.needsInputFileVisitation(); 4283 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation(); 4284 bool NeedsImports = Listener.needsImportVisitation(); 4285 BitstreamCursor InputFilesCursor; 4286 if (NeedsInputFiles) { 4287 InputFilesCursor = Stream; 4288 if (SkipCursorToBlock(InputFilesCursor, INPUT_FILES_BLOCK_ID)) 4289 return true; 4290 4291 // Read the abbreviations 4292 while (true) { 4293 uint64_t Offset = InputFilesCursor.GetCurrentBitNo(); 4294 unsigned Code = InputFilesCursor.ReadCode(); 4295 4296 // We expect all abbrevs to be at the start of the block. 4297 if (Code != llvm::bitc::DEFINE_ABBREV) { 4298 InputFilesCursor.JumpToBit(Offset); 4299 break; 4300 } 4301 InputFilesCursor.ReadAbbrevRecord(); 4302 } 4303 } 4304 4305 // Scan for ORIGINAL_FILE inside the control block. 4306 RecordData Record; 4307 std::string ModuleDir; 4308 while (1) { 4309 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 4310 if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 4311 return false; 4312 4313 if (Entry.Kind != llvm::BitstreamEntry::Record) 4314 return true; 4315 4316 Record.clear(); 4317 StringRef Blob; 4318 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob); 4319 switch ((ControlRecordTypes)RecCode) { 4320 case METADATA: { 4321 if (Record[0] != VERSION_MAJOR) 4322 return true; 4323 4324 if (Listener.ReadFullVersionInformation(Blob)) 4325 return true; 4326 4327 break; 4328 } 4329 case MODULE_NAME: 4330 Listener.ReadModuleName(Blob); 4331 break; 4332 case MODULE_DIRECTORY: 4333 ModuleDir = Blob; 4334 break; 4335 case MODULE_MAP_FILE: { 4336 unsigned Idx = 0; 4337 auto Path = ReadString(Record, Idx); 4338 ResolveImportedPath(Path, ModuleDir); 4339 Listener.ReadModuleMapFile(Path); 4340 break; 4341 } 4342 case LANGUAGE_OPTIONS: 4343 if (ParseLanguageOptions(Record, false, Listener, 4344 /*AllowCompatibleConfigurationMismatch*/false)) 4345 return true; 4346 break; 4347 4348 case TARGET_OPTIONS: 4349 if (ParseTargetOptions(Record, false, Listener, 4350 /*AllowCompatibleConfigurationMismatch*/ false)) 4351 return true; 4352 break; 4353 4354 case DIAGNOSTIC_OPTIONS: 4355 if (ParseDiagnosticOptions(Record, false, Listener)) 4356 return true; 4357 break; 4358 4359 case FILE_SYSTEM_OPTIONS: 4360 if (ParseFileSystemOptions(Record, false, Listener)) 4361 return true; 4362 break; 4363 4364 case HEADER_SEARCH_OPTIONS: 4365 if (ParseHeaderSearchOptions(Record, false, Listener)) 4366 return true; 4367 break; 4368 4369 case PREPROCESSOR_OPTIONS: { 4370 std::string IgnoredSuggestedPredefines; 4371 if (ParsePreprocessorOptions(Record, false, Listener, 4372 IgnoredSuggestedPredefines)) 4373 return true; 4374 break; 4375 } 4376 4377 case INPUT_FILE_OFFSETS: { 4378 if (!NeedsInputFiles) 4379 break; 4380 4381 unsigned NumInputFiles = Record[0]; 4382 unsigned NumUserFiles = Record[1]; 4383 const uint64_t *InputFileOffs = (const uint64_t *)Blob.data(); 4384 for (unsigned I = 0; I != NumInputFiles; ++I) { 4385 // Go find this input file. 4386 bool isSystemFile = I >= NumUserFiles; 4387 4388 if (isSystemFile && !NeedsSystemInputFiles) 4389 break; // the rest are system input files 4390 4391 BitstreamCursor &Cursor = InputFilesCursor; 4392 SavedStreamPosition SavedPosition(Cursor); 4393 Cursor.JumpToBit(InputFileOffs[I]); 4394 4395 unsigned Code = Cursor.ReadCode(); 4396 RecordData Record; 4397 StringRef Blob; 4398 bool shouldContinue = false; 4399 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) { 4400 case INPUT_FILE: 4401 bool Overridden = static_cast<bool>(Record[3]); 4402 std::string Filename = Blob; 4403 ResolveImportedPath(Filename, ModuleDir); 4404 shouldContinue = 4405 Listener.visitInputFile(Filename, isSystemFile, Overridden); 4406 break; 4407 } 4408 if (!shouldContinue) 4409 break; 4410 } 4411 break; 4412 } 4413 4414 case IMPORTS: { 4415 if (!NeedsImports) 4416 break; 4417 4418 unsigned Idx = 0, N = Record.size(); 4419 while (Idx < N) { 4420 // Read information about the AST file. 4421 Idx += 5; // ImportLoc, Size, ModTime, Signature 4422 std::string Filename = ReadString(Record, Idx); 4423 ResolveImportedPath(Filename, ModuleDir); 4424 Listener.visitImport(Filename); 4425 } 4426 break; 4427 } 4428 4429 case KNOWN_MODULE_FILES: { 4430 // Known-but-not-technically-used module files are treated as imports. 4431 if (!NeedsImports) 4432 break; 4433 4434 unsigned Idx = 0, N = Record.size(); 4435 while (Idx < N) { 4436 std::string Filename = ReadString(Record, Idx); 4437 ResolveImportedPath(Filename, ModuleDir); 4438 Listener.visitImport(Filename); 4439 } 4440 break; 4441 } 4442 4443 default: 4444 // No other validation to perform. 4445 break; 4446 } 4447 } 4448 } 4449 4450 4451 bool ASTReader::isAcceptableASTFile(StringRef Filename, 4452 FileManager &FileMgr, 4453 const LangOptions &LangOpts, 4454 const TargetOptions &TargetOpts, 4455 const PreprocessorOptions &PPOpts, 4456 std::string ExistingModuleCachePath) { 4457 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, 4458 ExistingModuleCachePath, FileMgr); 4459 return !readASTFileControlBlock(Filename, FileMgr, validator); 4460 } 4461 4462 ASTReader::ASTReadResult 4463 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) { 4464 // Enter the submodule block. 4465 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 4466 Error("malformed submodule block record in AST file"); 4467 return Failure; 4468 } 4469 4470 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 4471 bool First = true; 4472 Module *CurrentModule = nullptr; 4473 RecordData Record; 4474 while (true) { 4475 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks(); 4476 4477 switch (Entry.Kind) { 4478 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 4479 case llvm::BitstreamEntry::Error: 4480 Error("malformed block record in AST file"); 4481 return Failure; 4482 case llvm::BitstreamEntry::EndBlock: 4483 return Success; 4484 case llvm::BitstreamEntry::Record: 4485 // The interesting case. 4486 break; 4487 } 4488 4489 // Read a record. 4490 StringRef Blob; 4491 Record.clear(); 4492 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob); 4493 4494 if ((Kind == SUBMODULE_METADATA) != First) { 4495 Error("submodule metadata record should be at beginning of block"); 4496 return Failure; 4497 } 4498 First = false; 4499 4500 // Submodule information is only valid if we have a current module. 4501 // FIXME: Should we error on these cases? 4502 if (!CurrentModule && Kind != SUBMODULE_METADATA && 4503 Kind != SUBMODULE_DEFINITION) 4504 continue; 4505 4506 switch (Kind) { 4507 default: // Default behavior: ignore. 4508 break; 4509 4510 case SUBMODULE_DEFINITION: { 4511 if (Record.size() < 8) { 4512 Error("malformed module definition"); 4513 return Failure; 4514 } 4515 4516 StringRef Name = Blob; 4517 unsigned Idx = 0; 4518 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]); 4519 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]); 4520 bool IsFramework = Record[Idx++]; 4521 bool IsExplicit = Record[Idx++]; 4522 bool IsSystem = Record[Idx++]; 4523 bool IsExternC = Record[Idx++]; 4524 bool InferSubmodules = Record[Idx++]; 4525 bool InferExplicitSubmodules = Record[Idx++]; 4526 bool InferExportWildcard = Record[Idx++]; 4527 bool ConfigMacrosExhaustive = Record[Idx++]; 4528 4529 Module *ParentModule = nullptr; 4530 if (Parent) 4531 ParentModule = getSubmodule(Parent); 4532 4533 // Retrieve this (sub)module from the module map, creating it if 4534 // necessary. 4535 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework, 4536 IsExplicit).first; 4537 4538 // FIXME: set the definition loc for CurrentModule, or call 4539 // ModMap.setInferredModuleAllowedBy() 4540 4541 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 4542 if (GlobalIndex >= SubmodulesLoaded.size() || 4543 SubmodulesLoaded[GlobalIndex]) { 4544 Error("too many submodules"); 4545 return Failure; 4546 } 4547 4548 if (!ParentModule) { 4549 if (const FileEntry *CurFile = CurrentModule->getASTFile()) { 4550 if (CurFile != F.File) { 4551 if (!Diags.isDiagnosticInFlight()) { 4552 Diag(diag::err_module_file_conflict) 4553 << CurrentModule->getTopLevelModuleName() 4554 << CurFile->getName() 4555 << F.File->getName(); 4556 } 4557 return Failure; 4558 } 4559 } 4560 4561 CurrentModule->setASTFile(F.File); 4562 } 4563 4564 CurrentModule->IsFromModuleFile = true; 4565 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem; 4566 CurrentModule->IsExternC = IsExternC; 4567 CurrentModule->InferSubmodules = InferSubmodules; 4568 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 4569 CurrentModule->InferExportWildcard = InferExportWildcard; 4570 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive; 4571 if (DeserializationListener) 4572 DeserializationListener->ModuleRead(GlobalID, CurrentModule); 4573 4574 SubmodulesLoaded[GlobalIndex] = CurrentModule; 4575 4576 // Clear out data that will be replaced by what is the module file. 4577 CurrentModule->LinkLibraries.clear(); 4578 CurrentModule->ConfigMacros.clear(); 4579 CurrentModule->UnresolvedConflicts.clear(); 4580 CurrentModule->Conflicts.clear(); 4581 break; 4582 } 4583 4584 case SUBMODULE_UMBRELLA_HEADER: { 4585 if (const FileEntry *Umbrella = PP.getFileManager().getFile(Blob)) { 4586 if (!CurrentModule->getUmbrellaHeader()) 4587 ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 4588 else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 4589 // This can be a spurious difference caused by changing the VFS to 4590 // point to a different copy of the file, and it is too late to 4591 // to rebuild safely. 4592 // FIXME: If we wrote the virtual paths instead of the 'real' paths, 4593 // after input file validation only real problems would remain and we 4594 // could just error. For now, assume it's okay. 4595 break; 4596 } 4597 } 4598 break; 4599 } 4600 4601 case SUBMODULE_HEADER: 4602 case SUBMODULE_EXCLUDED_HEADER: 4603 case SUBMODULE_PRIVATE_HEADER: 4604 // We lazily associate headers with their modules via the HeaderInfo table. 4605 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 4606 // of complete filenames or remove it entirely. 4607 break; 4608 4609 case SUBMODULE_TEXTUAL_HEADER: 4610 case SUBMODULE_PRIVATE_TEXTUAL_HEADER: 4611 // FIXME: Textual headers are not marked in the HeaderInfo table. Load 4612 // them here. 4613 break; 4614 4615 case SUBMODULE_TOPHEADER: { 4616 CurrentModule->addTopHeaderFilename(Blob); 4617 break; 4618 } 4619 4620 case SUBMODULE_UMBRELLA_DIR: { 4621 if (const DirectoryEntry *Umbrella 4622 = PP.getFileManager().getDirectory(Blob)) { 4623 if (!CurrentModule->getUmbrellaDir()) 4624 ModMap.setUmbrellaDir(CurrentModule, Umbrella); 4625 else if (CurrentModule->getUmbrellaDir() != Umbrella) { 4626 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) 4627 Error("mismatched umbrella directories in submodule"); 4628 return OutOfDate; 4629 } 4630 } 4631 break; 4632 } 4633 4634 case SUBMODULE_METADATA: { 4635 F.BaseSubmoduleID = getTotalNumSubmodules(); 4636 F.LocalNumSubmodules = Record[0]; 4637 unsigned LocalBaseSubmoduleID = Record[1]; 4638 if (F.LocalNumSubmodules > 0) { 4639 // Introduce the global -> local mapping for submodules within this 4640 // module. 4641 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 4642 4643 // Introduce the local -> global mapping for submodules within this 4644 // module. 4645 F.SubmoduleRemap.insertOrReplace( 4646 std::make_pair(LocalBaseSubmoduleID, 4647 F.BaseSubmoduleID - LocalBaseSubmoduleID)); 4648 4649 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 4650 } 4651 break; 4652 } 4653 4654 case SUBMODULE_IMPORTS: { 4655 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 4656 UnresolvedModuleRef Unresolved; 4657 Unresolved.File = &F; 4658 Unresolved.Mod = CurrentModule; 4659 Unresolved.ID = Record[Idx]; 4660 Unresolved.Kind = UnresolvedModuleRef::Import; 4661 Unresolved.IsWildcard = false; 4662 UnresolvedModuleRefs.push_back(Unresolved); 4663 } 4664 break; 4665 } 4666 4667 case SUBMODULE_EXPORTS: { 4668 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 4669 UnresolvedModuleRef Unresolved; 4670 Unresolved.File = &F; 4671 Unresolved.Mod = CurrentModule; 4672 Unresolved.ID = Record[Idx]; 4673 Unresolved.Kind = UnresolvedModuleRef::Export; 4674 Unresolved.IsWildcard = Record[Idx + 1]; 4675 UnresolvedModuleRefs.push_back(Unresolved); 4676 } 4677 4678 // Once we've loaded the set of exports, there's no reason to keep 4679 // the parsed, unresolved exports around. 4680 CurrentModule->UnresolvedExports.clear(); 4681 break; 4682 } 4683 case SUBMODULE_REQUIRES: { 4684 CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(), 4685 Context.getTargetInfo()); 4686 break; 4687 } 4688 4689 case SUBMODULE_LINK_LIBRARY: 4690 CurrentModule->LinkLibraries.push_back( 4691 Module::LinkLibrary(Blob, Record[0])); 4692 break; 4693 4694 case SUBMODULE_CONFIG_MACRO: 4695 CurrentModule->ConfigMacros.push_back(Blob.str()); 4696 break; 4697 4698 case SUBMODULE_CONFLICT: { 4699 UnresolvedModuleRef Unresolved; 4700 Unresolved.File = &F; 4701 Unresolved.Mod = CurrentModule; 4702 Unresolved.ID = Record[0]; 4703 Unresolved.Kind = UnresolvedModuleRef::Conflict; 4704 Unresolved.IsWildcard = false; 4705 Unresolved.String = Blob; 4706 UnresolvedModuleRefs.push_back(Unresolved); 4707 break; 4708 } 4709 } 4710 } 4711 } 4712 4713 /// \brief Parse the record that corresponds to a LangOptions data 4714 /// structure. 4715 /// 4716 /// This routine parses the language options from the AST file and then gives 4717 /// them to the AST listener if one is set. 4718 /// 4719 /// \returns true if the listener deems the file unacceptable, false otherwise. 4720 bool ASTReader::ParseLanguageOptions(const RecordData &Record, 4721 bool Complain, 4722 ASTReaderListener &Listener, 4723 bool AllowCompatibleDifferences) { 4724 LangOptions LangOpts; 4725 unsigned Idx = 0; 4726 #define LANGOPT(Name, Bits, Default, Description) \ 4727 LangOpts.Name = Record[Idx++]; 4728 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 4729 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 4730 #include "clang/Basic/LangOptions.def" 4731 #define SANITIZER(NAME, ID) \ 4732 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]); 4733 #include "clang/Basic/Sanitizers.def" 4734 4735 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++]; 4736 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx); 4737 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion); 4738 4739 unsigned Length = Record[Idx++]; 4740 LangOpts.CurrentModule.assign(Record.begin() + Idx, 4741 Record.begin() + Idx + Length); 4742 4743 Idx += Length; 4744 4745 // Comment options. 4746 for (unsigned N = Record[Idx++]; N; --N) { 4747 LangOpts.CommentOpts.BlockCommandNames.push_back( 4748 ReadString(Record, Idx)); 4749 } 4750 LangOpts.CommentOpts.ParseAllComments = Record[Idx++]; 4751 4752 return Listener.ReadLanguageOptions(LangOpts, Complain, 4753 AllowCompatibleDifferences); 4754 } 4755 4756 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain, 4757 ASTReaderListener &Listener, 4758 bool AllowCompatibleDifferences) { 4759 unsigned Idx = 0; 4760 TargetOptions TargetOpts; 4761 TargetOpts.Triple = ReadString(Record, Idx); 4762 TargetOpts.CPU = ReadString(Record, Idx); 4763 TargetOpts.ABI = ReadString(Record, Idx); 4764 for (unsigned N = Record[Idx++]; N; --N) { 4765 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx)); 4766 } 4767 for (unsigned N = Record[Idx++]; N; --N) { 4768 TargetOpts.Features.push_back(ReadString(Record, Idx)); 4769 } 4770 4771 return Listener.ReadTargetOptions(TargetOpts, Complain, 4772 AllowCompatibleDifferences); 4773 } 4774 4775 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain, 4776 ASTReaderListener &Listener) { 4777 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions); 4778 unsigned Idx = 0; 4779 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++]; 4780 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 4781 DiagOpts->set##Name(static_cast<Type>(Record[Idx++])); 4782 #include "clang/Basic/DiagnosticOptions.def" 4783 4784 for (unsigned N = Record[Idx++]; N; --N) 4785 DiagOpts->Warnings.push_back(ReadString(Record, Idx)); 4786 for (unsigned N = Record[Idx++]; N; --N) 4787 DiagOpts->Remarks.push_back(ReadString(Record, Idx)); 4788 4789 return Listener.ReadDiagnosticOptions(DiagOpts, Complain); 4790 } 4791 4792 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain, 4793 ASTReaderListener &Listener) { 4794 FileSystemOptions FSOpts; 4795 unsigned Idx = 0; 4796 FSOpts.WorkingDir = ReadString(Record, Idx); 4797 return Listener.ReadFileSystemOptions(FSOpts, Complain); 4798 } 4799 4800 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record, 4801 bool Complain, 4802 ASTReaderListener &Listener) { 4803 HeaderSearchOptions HSOpts; 4804 unsigned Idx = 0; 4805 HSOpts.Sysroot = ReadString(Record, Idx); 4806 4807 // Include entries. 4808 for (unsigned N = Record[Idx++]; N; --N) { 4809 std::string Path = ReadString(Record, Idx); 4810 frontend::IncludeDirGroup Group 4811 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]); 4812 bool IsFramework = Record[Idx++]; 4813 bool IgnoreSysRoot = Record[Idx++]; 4814 HSOpts.UserEntries.push_back( 4815 HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot)); 4816 } 4817 4818 // System header prefixes. 4819 for (unsigned N = Record[Idx++]; N; --N) { 4820 std::string Prefix = ReadString(Record, Idx); 4821 bool IsSystemHeader = Record[Idx++]; 4822 HSOpts.SystemHeaderPrefixes.push_back( 4823 HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader)); 4824 } 4825 4826 HSOpts.ResourceDir = ReadString(Record, Idx); 4827 HSOpts.ModuleCachePath = ReadString(Record, Idx); 4828 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx); 4829 HSOpts.DisableModuleHash = Record[Idx++]; 4830 HSOpts.UseBuiltinIncludes = Record[Idx++]; 4831 HSOpts.UseStandardSystemIncludes = Record[Idx++]; 4832 HSOpts.UseStandardCXXIncludes = Record[Idx++]; 4833 HSOpts.UseLibcxx = Record[Idx++]; 4834 std::string SpecificModuleCachePath = ReadString(Record, Idx); 4835 4836 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath, 4837 Complain); 4838 } 4839 4840 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record, 4841 bool Complain, 4842 ASTReaderListener &Listener, 4843 std::string &SuggestedPredefines) { 4844 PreprocessorOptions PPOpts; 4845 unsigned Idx = 0; 4846 4847 // Macro definitions/undefs 4848 for (unsigned N = Record[Idx++]; N; --N) { 4849 std::string Macro = ReadString(Record, Idx); 4850 bool IsUndef = Record[Idx++]; 4851 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef)); 4852 } 4853 4854 // Includes 4855 for (unsigned N = Record[Idx++]; N; --N) { 4856 PPOpts.Includes.push_back(ReadString(Record, Idx)); 4857 } 4858 4859 // Macro Includes 4860 for (unsigned N = Record[Idx++]; N; --N) { 4861 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx)); 4862 } 4863 4864 PPOpts.UsePredefines = Record[Idx++]; 4865 PPOpts.DetailedRecord = Record[Idx++]; 4866 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx); 4867 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx); 4868 PPOpts.ObjCXXARCStandardLibrary = 4869 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]); 4870 SuggestedPredefines.clear(); 4871 return Listener.ReadPreprocessorOptions(PPOpts, Complain, 4872 SuggestedPredefines); 4873 } 4874 4875 std::pair<ModuleFile *, unsigned> 4876 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 4877 GlobalPreprocessedEntityMapType::iterator 4878 I = GlobalPreprocessedEntityMap.find(GlobalIndex); 4879 assert(I != GlobalPreprocessedEntityMap.end() && 4880 "Corrupted global preprocessed entity map"); 4881 ModuleFile *M = I->second; 4882 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 4883 return std::make_pair(M, LocalIndex); 4884 } 4885 4886 llvm::iterator_range<PreprocessingRecord::iterator> 4887 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const { 4888 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord()) 4889 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID, 4890 Mod.NumPreprocessedEntities); 4891 4892 return llvm::make_range(PreprocessingRecord::iterator(), 4893 PreprocessingRecord::iterator()); 4894 } 4895 4896 llvm::iterator_range<ASTReader::ModuleDeclIterator> 4897 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) { 4898 return llvm::make_range( 4899 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls), 4900 ModuleDeclIterator(this, &Mod, 4901 Mod.FileSortedDecls + Mod.NumFileSortedDecls)); 4902 } 4903 4904 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 4905 PreprocessedEntityID PPID = Index+1; 4906 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 4907 ModuleFile &M = *PPInfo.first; 4908 unsigned LocalIndex = PPInfo.second; 4909 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 4910 4911 if (!PP.getPreprocessingRecord()) { 4912 Error("no preprocessing record"); 4913 return nullptr; 4914 } 4915 4916 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 4917 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 4918 4919 llvm::BitstreamEntry Entry = 4920 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd); 4921 if (Entry.Kind != llvm::BitstreamEntry::Record) 4922 return nullptr; 4923 4924 // Read the record. 4925 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 4926 ReadSourceLocation(M, PPOffs.End)); 4927 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 4928 StringRef Blob; 4929 RecordData Record; 4930 PreprocessorDetailRecordTypes RecType = 4931 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord( 4932 Entry.ID, Record, &Blob); 4933 switch (RecType) { 4934 case PPD_MACRO_EXPANSION: { 4935 bool isBuiltin = Record[0]; 4936 IdentifierInfo *Name = nullptr; 4937 MacroDefinition *Def = nullptr; 4938 if (isBuiltin) 4939 Name = getLocalIdentifier(M, Record[1]); 4940 else { 4941 PreprocessedEntityID 4942 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 4943 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 4944 } 4945 4946 MacroExpansion *ME; 4947 if (isBuiltin) 4948 ME = new (PPRec) MacroExpansion(Name, Range); 4949 else 4950 ME = new (PPRec) MacroExpansion(Def, Range); 4951 4952 return ME; 4953 } 4954 4955 case PPD_MACRO_DEFINITION: { 4956 // Decode the identifier info and then check again; if the macro is 4957 // still defined and associated with the identifier, 4958 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 4959 MacroDefinition *MD 4960 = new (PPRec) MacroDefinition(II, Range); 4961 4962 if (DeserializationListener) 4963 DeserializationListener->MacroDefinitionRead(PPID, MD); 4964 4965 return MD; 4966 } 4967 4968 case PPD_INCLUSION_DIRECTIVE: { 4969 const char *FullFileNameStart = Blob.data() + Record[0]; 4970 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]); 4971 const FileEntry *File = nullptr; 4972 if (!FullFileName.empty()) 4973 File = PP.getFileManager().getFile(FullFileName); 4974 4975 // FIXME: Stable encoding 4976 InclusionDirective::InclusionKind Kind 4977 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 4978 InclusionDirective *ID 4979 = new (PPRec) InclusionDirective(PPRec, Kind, 4980 StringRef(Blob.data(), Record[0]), 4981 Record[1], Record[3], 4982 File, 4983 Range); 4984 return ID; 4985 } 4986 } 4987 4988 llvm_unreachable("Invalid PreprocessorDetailRecordTypes"); 4989 } 4990 4991 /// \brief \arg SLocMapI points at a chunk of a module that contains no 4992 /// preprocessed entities or the entities it contains are not the ones we are 4993 /// looking for. Find the next module that contains entities and return the ID 4994 /// of the first entry. 4995 PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 4996 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 4997 ++SLocMapI; 4998 for (GlobalSLocOffsetMapType::const_iterator 4999 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 5000 ModuleFile &M = *SLocMapI->second; 5001 if (M.NumPreprocessedEntities) 5002 return M.BasePreprocessedEntityID; 5003 } 5004 5005 return getTotalNumPreprocessedEntities(); 5006 } 5007 5008 namespace { 5009 5010 template <unsigned PPEntityOffset::*PPLoc> 5011 struct PPEntityComp { 5012 const ASTReader &Reader; 5013 ModuleFile &M; 5014 5015 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 5016 5017 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 5018 SourceLocation LHS = getLoc(L); 5019 SourceLocation RHS = getLoc(R); 5020 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5021 } 5022 5023 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 5024 SourceLocation LHS = getLoc(L); 5025 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5026 } 5027 5028 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 5029 SourceLocation RHS = getLoc(R); 5030 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5031 } 5032 5033 SourceLocation getLoc(const PPEntityOffset &PPE) const { 5034 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 5035 } 5036 }; 5037 5038 } 5039 5040 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc, 5041 bool EndsAfter) const { 5042 if (SourceMgr.isLocalSourceLocation(Loc)) 5043 return getTotalNumPreprocessedEntities(); 5044 5045 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find( 5046 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1); 5047 assert(SLocMapI != GlobalSLocOffsetMap.end() && 5048 "Corrupted global sloc offset map"); 5049 5050 if (SLocMapI->second->NumPreprocessedEntities == 0) 5051 return findNextPreprocessedEntity(SLocMapI); 5052 5053 ModuleFile &M = *SLocMapI->second; 5054 typedef const PPEntityOffset *pp_iterator; 5055 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 5056 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 5057 5058 size_t Count = M.NumPreprocessedEntities; 5059 size_t Half; 5060 pp_iterator First = pp_begin; 5061 pp_iterator PPI; 5062 5063 if (EndsAfter) { 5064 PPI = std::upper_bound(pp_begin, pp_end, Loc, 5065 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 5066 } else { 5067 // Do a binary search manually instead of using std::lower_bound because 5068 // The end locations of entities may be unordered (when a macro expansion 5069 // is inside another macro argument), but for this case it is not important 5070 // whether we get the first macro expansion or its containing macro. 5071 while (Count > 0) { 5072 Half = Count / 2; 5073 PPI = First; 5074 std::advance(PPI, Half); 5075 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 5076 Loc)) { 5077 First = PPI; 5078 ++First; 5079 Count = Count - Half - 1; 5080 } else 5081 Count = Half; 5082 } 5083 } 5084 5085 if (PPI == pp_end) 5086 return findNextPreprocessedEntity(SLocMapI); 5087 5088 return M.BasePreprocessedEntityID + (PPI - pp_begin); 5089 } 5090 5091 /// \brief Returns a pair of [Begin, End) indices of preallocated 5092 /// preprocessed entities that \arg Range encompasses. 5093 std::pair<unsigned, unsigned> 5094 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 5095 if (Range.isInvalid()) 5096 return std::make_pair(0,0); 5097 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 5098 5099 PreprocessedEntityID BeginID = 5100 findPreprocessedEntity(Range.getBegin(), false); 5101 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true); 5102 return std::make_pair(BeginID, EndID); 5103 } 5104 5105 /// \brief Optionally returns true or false if the preallocated preprocessed 5106 /// entity with index \arg Index came from file \arg FID. 5107 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 5108 FileID FID) { 5109 if (FID.isInvalid()) 5110 return false; 5111 5112 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 5113 ModuleFile &M = *PPInfo.first; 5114 unsigned LocalIndex = PPInfo.second; 5115 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 5116 5117 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 5118 if (Loc.isInvalid()) 5119 return false; 5120 5121 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 5122 return true; 5123 else 5124 return false; 5125 } 5126 5127 namespace { 5128 /// \brief Visitor used to search for information about a header file. 5129 class HeaderFileInfoVisitor { 5130 const FileEntry *FE; 5131 5132 Optional<HeaderFileInfo> HFI; 5133 5134 public: 5135 explicit HeaderFileInfoVisitor(const FileEntry *FE) 5136 : FE(FE) { } 5137 5138 static bool visit(ModuleFile &M, void *UserData) { 5139 HeaderFileInfoVisitor *This 5140 = static_cast<HeaderFileInfoVisitor *>(UserData); 5141 5142 HeaderFileInfoLookupTable *Table 5143 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 5144 if (!Table) 5145 return false; 5146 5147 // Look in the on-disk hash table for an entry for this file name. 5148 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE); 5149 if (Pos == Table->end()) 5150 return false; 5151 5152 This->HFI = *Pos; 5153 return true; 5154 } 5155 5156 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 5157 }; 5158 } 5159 5160 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 5161 HeaderFileInfoVisitor Visitor(FE); 5162 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 5163 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) 5164 return *HFI; 5165 5166 return HeaderFileInfo(); 5167 } 5168 5169 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 5170 // FIXME: Make it work properly with modules. 5171 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates; 5172 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 5173 ModuleFile &F = *(*I); 5174 unsigned Idx = 0; 5175 DiagStates.clear(); 5176 assert(!Diag.DiagStates.empty()); 5177 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one. 5178 while (Idx < F.PragmaDiagMappings.size()) { 5179 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 5180 unsigned DiagStateID = F.PragmaDiagMappings[Idx++]; 5181 if (DiagStateID != 0) { 5182 Diag.DiagStatePoints.push_back( 5183 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1], 5184 FullSourceLoc(Loc, SourceMgr))); 5185 continue; 5186 } 5187 5188 assert(DiagStateID == 0); 5189 // A new DiagState was created here. 5190 Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 5191 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back(); 5192 DiagStates.push_back(NewState); 5193 Diag.DiagStatePoints.push_back( 5194 DiagnosticsEngine::DiagStatePoint(NewState, 5195 FullSourceLoc(Loc, SourceMgr))); 5196 while (1) { 5197 assert(Idx < F.PragmaDiagMappings.size() && 5198 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 5199 if (Idx >= F.PragmaDiagMappings.size()) { 5200 break; // Something is messed up but at least avoid infinite loop in 5201 // release build. 5202 } 5203 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 5204 if (DiagID == (unsigned)-1) { 5205 break; // no more diag/map pairs for this location. 5206 } 5207 diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++]; 5208 DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc); 5209 Diag.GetCurDiagState()->setMapping(DiagID, Mapping); 5210 } 5211 } 5212 } 5213 } 5214 5215 /// \brief Get the correct cursor and offset for loading a type. 5216 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 5217 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 5218 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 5219 ModuleFile *M = I->second; 5220 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 5221 } 5222 5223 /// \brief Read and return the type with the given index.. 5224 /// 5225 /// The index is the type ID, shifted and minus the number of predefs. This 5226 /// routine actually reads the record corresponding to the type at the given 5227 /// location. It is a helper routine for GetType, which deals with reading type 5228 /// IDs. 5229 QualType ASTReader::readTypeRecord(unsigned Index) { 5230 RecordLocation Loc = TypeCursorForIndex(Index); 5231 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 5232 5233 // Keep track of where we are in the stream, then jump back there 5234 // after reading this type. 5235 SavedStreamPosition SavedPosition(DeclsCursor); 5236 5237 ReadingKindTracker ReadingKind(Read_Type, *this); 5238 5239 // Note that we are loading a type record. 5240 Deserializing AType(this); 5241 5242 unsigned Idx = 0; 5243 DeclsCursor.JumpToBit(Loc.Offset); 5244 RecordData Record; 5245 unsigned Code = DeclsCursor.ReadCode(); 5246 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) { 5247 case TYPE_EXT_QUAL: { 5248 if (Record.size() != 2) { 5249 Error("Incorrect encoding of extended qualifier type"); 5250 return QualType(); 5251 } 5252 QualType Base = readType(*Loc.F, Record, Idx); 5253 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 5254 return Context.getQualifiedType(Base, Quals); 5255 } 5256 5257 case TYPE_COMPLEX: { 5258 if (Record.size() != 1) { 5259 Error("Incorrect encoding of complex type"); 5260 return QualType(); 5261 } 5262 QualType ElemType = readType(*Loc.F, Record, Idx); 5263 return Context.getComplexType(ElemType); 5264 } 5265 5266 case TYPE_POINTER: { 5267 if (Record.size() != 1) { 5268 Error("Incorrect encoding of pointer type"); 5269 return QualType(); 5270 } 5271 QualType PointeeType = readType(*Loc.F, Record, Idx); 5272 return Context.getPointerType(PointeeType); 5273 } 5274 5275 case TYPE_DECAYED: { 5276 if (Record.size() != 1) { 5277 Error("Incorrect encoding of decayed type"); 5278 return QualType(); 5279 } 5280 QualType OriginalType = readType(*Loc.F, Record, Idx); 5281 QualType DT = Context.getAdjustedParameterType(OriginalType); 5282 if (!isa<DecayedType>(DT)) 5283 Error("Decayed type does not decay"); 5284 return DT; 5285 } 5286 5287 case TYPE_ADJUSTED: { 5288 if (Record.size() != 2) { 5289 Error("Incorrect encoding of adjusted type"); 5290 return QualType(); 5291 } 5292 QualType OriginalTy = readType(*Loc.F, Record, Idx); 5293 QualType AdjustedTy = readType(*Loc.F, Record, Idx); 5294 return Context.getAdjustedType(OriginalTy, AdjustedTy); 5295 } 5296 5297 case TYPE_BLOCK_POINTER: { 5298 if (Record.size() != 1) { 5299 Error("Incorrect encoding of block pointer type"); 5300 return QualType(); 5301 } 5302 QualType PointeeType = readType(*Loc.F, Record, Idx); 5303 return Context.getBlockPointerType(PointeeType); 5304 } 5305 5306 case TYPE_LVALUE_REFERENCE: { 5307 if (Record.size() != 2) { 5308 Error("Incorrect encoding of lvalue reference type"); 5309 return QualType(); 5310 } 5311 QualType PointeeType = readType(*Loc.F, Record, Idx); 5312 return Context.getLValueReferenceType(PointeeType, Record[1]); 5313 } 5314 5315 case TYPE_RVALUE_REFERENCE: { 5316 if (Record.size() != 1) { 5317 Error("Incorrect encoding of rvalue reference type"); 5318 return QualType(); 5319 } 5320 QualType PointeeType = readType(*Loc.F, Record, Idx); 5321 return Context.getRValueReferenceType(PointeeType); 5322 } 5323 5324 case TYPE_MEMBER_POINTER: { 5325 if (Record.size() != 2) { 5326 Error("Incorrect encoding of member pointer type"); 5327 return QualType(); 5328 } 5329 QualType PointeeType = readType(*Loc.F, Record, Idx); 5330 QualType ClassType = readType(*Loc.F, Record, Idx); 5331 if (PointeeType.isNull() || ClassType.isNull()) 5332 return QualType(); 5333 5334 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 5335 } 5336 5337 case TYPE_CONSTANT_ARRAY: { 5338 QualType ElementType = readType(*Loc.F, Record, Idx); 5339 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 5340 unsigned IndexTypeQuals = Record[2]; 5341 unsigned Idx = 3; 5342 llvm::APInt Size = ReadAPInt(Record, Idx); 5343 return Context.getConstantArrayType(ElementType, Size, 5344 ASM, IndexTypeQuals); 5345 } 5346 5347 case TYPE_INCOMPLETE_ARRAY: { 5348 QualType ElementType = readType(*Loc.F, Record, Idx); 5349 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 5350 unsigned IndexTypeQuals = Record[2]; 5351 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 5352 } 5353 5354 case TYPE_VARIABLE_ARRAY: { 5355 QualType ElementType = readType(*Loc.F, Record, Idx); 5356 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 5357 unsigned IndexTypeQuals = Record[2]; 5358 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 5359 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 5360 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 5361 ASM, IndexTypeQuals, 5362 SourceRange(LBLoc, RBLoc)); 5363 } 5364 5365 case TYPE_VECTOR: { 5366 if (Record.size() != 3) { 5367 Error("incorrect encoding of vector type in AST file"); 5368 return QualType(); 5369 } 5370 5371 QualType ElementType = readType(*Loc.F, Record, Idx); 5372 unsigned NumElements = Record[1]; 5373 unsigned VecKind = Record[2]; 5374 return Context.getVectorType(ElementType, NumElements, 5375 (VectorType::VectorKind)VecKind); 5376 } 5377 5378 case TYPE_EXT_VECTOR: { 5379 if (Record.size() != 3) { 5380 Error("incorrect encoding of extended vector type in AST file"); 5381 return QualType(); 5382 } 5383 5384 QualType ElementType = readType(*Loc.F, Record, Idx); 5385 unsigned NumElements = Record[1]; 5386 return Context.getExtVectorType(ElementType, NumElements); 5387 } 5388 5389 case TYPE_FUNCTION_NO_PROTO: { 5390 if (Record.size() != 6) { 5391 Error("incorrect encoding of no-proto function type"); 5392 return QualType(); 5393 } 5394 QualType ResultType = readType(*Loc.F, Record, Idx); 5395 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 5396 (CallingConv)Record[4], Record[5]); 5397 return Context.getFunctionNoProtoType(ResultType, Info); 5398 } 5399 5400 case TYPE_FUNCTION_PROTO: { 5401 QualType ResultType = readType(*Loc.F, Record, Idx); 5402 5403 FunctionProtoType::ExtProtoInfo EPI; 5404 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 5405 /*hasregparm*/ Record[2], 5406 /*regparm*/ Record[3], 5407 static_cast<CallingConv>(Record[4]), 5408 /*produces*/ Record[5]); 5409 5410 unsigned Idx = 6; 5411 5412 EPI.Variadic = Record[Idx++]; 5413 EPI.HasTrailingReturn = Record[Idx++]; 5414 EPI.TypeQuals = Record[Idx++]; 5415 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 5416 SmallVector<QualType, 8> ExceptionStorage; 5417 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx); 5418 5419 unsigned NumParams = Record[Idx++]; 5420 SmallVector<QualType, 16> ParamTypes; 5421 for (unsigned I = 0; I != NumParams; ++I) 5422 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 5423 5424 return Context.getFunctionType(ResultType, ParamTypes, EPI); 5425 } 5426 5427 case TYPE_UNRESOLVED_USING: { 5428 unsigned Idx = 0; 5429 return Context.getTypeDeclType( 5430 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 5431 } 5432 5433 case TYPE_TYPEDEF: { 5434 if (Record.size() != 2) { 5435 Error("incorrect encoding of typedef type"); 5436 return QualType(); 5437 } 5438 unsigned Idx = 0; 5439 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 5440 QualType Canonical = readType(*Loc.F, Record, Idx); 5441 if (!Canonical.isNull()) 5442 Canonical = Context.getCanonicalType(Canonical); 5443 return Context.getTypedefType(Decl, Canonical); 5444 } 5445 5446 case TYPE_TYPEOF_EXPR: 5447 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 5448 5449 case TYPE_TYPEOF: { 5450 if (Record.size() != 1) { 5451 Error("incorrect encoding of typeof(type) in AST file"); 5452 return QualType(); 5453 } 5454 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 5455 return Context.getTypeOfType(UnderlyingType); 5456 } 5457 5458 case TYPE_DECLTYPE: { 5459 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 5460 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType); 5461 } 5462 5463 case TYPE_UNARY_TRANSFORM: { 5464 QualType BaseType = readType(*Loc.F, Record, Idx); 5465 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 5466 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 5467 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 5468 } 5469 5470 case TYPE_AUTO: { 5471 QualType Deduced = readType(*Loc.F, Record, Idx); 5472 bool IsDecltypeAuto = Record[Idx++]; 5473 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false; 5474 return Context.getAutoType(Deduced, IsDecltypeAuto, IsDependent); 5475 } 5476 5477 case TYPE_RECORD: { 5478 if (Record.size() != 2) { 5479 Error("incorrect encoding of record type"); 5480 return QualType(); 5481 } 5482 unsigned Idx = 0; 5483 bool IsDependent = Record[Idx++]; 5484 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx); 5485 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl()); 5486 QualType T = Context.getRecordType(RD); 5487 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 5488 return T; 5489 } 5490 5491 case TYPE_ENUM: { 5492 if (Record.size() != 2) { 5493 Error("incorrect encoding of enum type"); 5494 return QualType(); 5495 } 5496 unsigned Idx = 0; 5497 bool IsDependent = Record[Idx++]; 5498 QualType T 5499 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 5500 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 5501 return T; 5502 } 5503 5504 case TYPE_ATTRIBUTED: { 5505 if (Record.size() != 3) { 5506 Error("incorrect encoding of attributed type"); 5507 return QualType(); 5508 } 5509 QualType modifiedType = readType(*Loc.F, Record, Idx); 5510 QualType equivalentType = readType(*Loc.F, Record, Idx); 5511 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 5512 return Context.getAttributedType(kind, modifiedType, equivalentType); 5513 } 5514 5515 case TYPE_PAREN: { 5516 if (Record.size() != 1) { 5517 Error("incorrect encoding of paren type"); 5518 return QualType(); 5519 } 5520 QualType InnerType = readType(*Loc.F, Record, Idx); 5521 return Context.getParenType(InnerType); 5522 } 5523 5524 case TYPE_PACK_EXPANSION: { 5525 if (Record.size() != 2) { 5526 Error("incorrect encoding of pack expansion type"); 5527 return QualType(); 5528 } 5529 QualType Pattern = readType(*Loc.F, Record, Idx); 5530 if (Pattern.isNull()) 5531 return QualType(); 5532 Optional<unsigned> NumExpansions; 5533 if (Record[1]) 5534 NumExpansions = Record[1] - 1; 5535 return Context.getPackExpansionType(Pattern, NumExpansions); 5536 } 5537 5538 case TYPE_ELABORATED: { 5539 unsigned Idx = 0; 5540 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 5541 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 5542 QualType NamedType = readType(*Loc.F, Record, Idx); 5543 return Context.getElaboratedType(Keyword, NNS, NamedType); 5544 } 5545 5546 case TYPE_OBJC_INTERFACE: { 5547 unsigned Idx = 0; 5548 ObjCInterfaceDecl *ItfD 5549 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 5550 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl()); 5551 } 5552 5553 case TYPE_OBJC_OBJECT: { 5554 unsigned Idx = 0; 5555 QualType Base = readType(*Loc.F, Record, Idx); 5556 unsigned NumProtos = Record[Idx++]; 5557 SmallVector<ObjCProtocolDecl*, 4> Protos; 5558 for (unsigned I = 0; I != NumProtos; ++I) 5559 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 5560 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 5561 } 5562 5563 case TYPE_OBJC_OBJECT_POINTER: { 5564 unsigned Idx = 0; 5565 QualType Pointee = readType(*Loc.F, Record, Idx); 5566 return Context.getObjCObjectPointerType(Pointee); 5567 } 5568 5569 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 5570 unsigned Idx = 0; 5571 QualType Parm = readType(*Loc.F, Record, Idx); 5572 QualType Replacement = readType(*Loc.F, Record, Idx); 5573 return Context.getSubstTemplateTypeParmType( 5574 cast<TemplateTypeParmType>(Parm), 5575 Context.getCanonicalType(Replacement)); 5576 } 5577 5578 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 5579 unsigned Idx = 0; 5580 QualType Parm = readType(*Loc.F, Record, Idx); 5581 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 5582 return Context.getSubstTemplateTypeParmPackType( 5583 cast<TemplateTypeParmType>(Parm), 5584 ArgPack); 5585 } 5586 5587 case TYPE_INJECTED_CLASS_NAME: { 5588 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 5589 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 5590 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 5591 // for AST reading, too much interdependencies. 5592 const Type *T = nullptr; 5593 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) { 5594 if (const Type *Existing = DI->getTypeForDecl()) { 5595 T = Existing; 5596 break; 5597 } 5598 } 5599 if (!T) { 5600 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST); 5601 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) 5602 DI->setTypeForDecl(T); 5603 } 5604 return QualType(T, 0); 5605 } 5606 5607 case TYPE_TEMPLATE_TYPE_PARM: { 5608 unsigned Idx = 0; 5609 unsigned Depth = Record[Idx++]; 5610 unsigned Index = Record[Idx++]; 5611 bool Pack = Record[Idx++]; 5612 TemplateTypeParmDecl *D 5613 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 5614 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 5615 } 5616 5617 case TYPE_DEPENDENT_NAME: { 5618 unsigned Idx = 0; 5619 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 5620 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 5621 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 5622 QualType Canon = readType(*Loc.F, Record, Idx); 5623 if (!Canon.isNull()) 5624 Canon = Context.getCanonicalType(Canon); 5625 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 5626 } 5627 5628 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 5629 unsigned Idx = 0; 5630 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 5631 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 5632 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 5633 unsigned NumArgs = Record[Idx++]; 5634 SmallVector<TemplateArgument, 8> Args; 5635 Args.reserve(NumArgs); 5636 while (NumArgs--) 5637 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 5638 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 5639 Args.size(), Args.data()); 5640 } 5641 5642 case TYPE_DEPENDENT_SIZED_ARRAY: { 5643 unsigned Idx = 0; 5644 5645 // ArrayType 5646 QualType ElementType = readType(*Loc.F, Record, Idx); 5647 ArrayType::ArraySizeModifier ASM 5648 = (ArrayType::ArraySizeModifier)Record[Idx++]; 5649 unsigned IndexTypeQuals = Record[Idx++]; 5650 5651 // DependentSizedArrayType 5652 Expr *NumElts = ReadExpr(*Loc.F); 5653 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 5654 5655 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 5656 IndexTypeQuals, Brackets); 5657 } 5658 5659 case TYPE_TEMPLATE_SPECIALIZATION: { 5660 unsigned Idx = 0; 5661 bool IsDependent = Record[Idx++]; 5662 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 5663 SmallVector<TemplateArgument, 8> Args; 5664 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 5665 QualType Underlying = readType(*Loc.F, Record, Idx); 5666 QualType T; 5667 if (Underlying.isNull()) 5668 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 5669 Args.size()); 5670 else 5671 T = Context.getTemplateSpecializationType(Name, Args.data(), 5672 Args.size(), Underlying); 5673 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 5674 return T; 5675 } 5676 5677 case TYPE_ATOMIC: { 5678 if (Record.size() != 1) { 5679 Error("Incorrect encoding of atomic type"); 5680 return QualType(); 5681 } 5682 QualType ValueType = readType(*Loc.F, Record, Idx); 5683 return Context.getAtomicType(ValueType); 5684 } 5685 } 5686 llvm_unreachable("Invalid TypeCode!"); 5687 } 5688 5689 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile, 5690 SmallVectorImpl<QualType> &Exceptions, 5691 FunctionProtoType::ExceptionSpecInfo &ESI, 5692 const RecordData &Record, unsigned &Idx) { 5693 ExceptionSpecificationType EST = 5694 static_cast<ExceptionSpecificationType>(Record[Idx++]); 5695 ESI.Type = EST; 5696 if (EST == EST_Dynamic) { 5697 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I) 5698 Exceptions.push_back(readType(ModuleFile, Record, Idx)); 5699 ESI.Exceptions = Exceptions; 5700 } else if (EST == EST_ComputedNoexcept) { 5701 ESI.NoexceptExpr = ReadExpr(ModuleFile); 5702 } else if (EST == EST_Uninstantiated) { 5703 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx); 5704 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx); 5705 } else if (EST == EST_Unevaluated) { 5706 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx); 5707 } 5708 } 5709 5710 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 5711 ASTReader &Reader; 5712 ModuleFile &F; 5713 const ASTReader::RecordData &Record; 5714 unsigned &Idx; 5715 5716 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 5717 unsigned &I) { 5718 return Reader.ReadSourceLocation(F, R, I); 5719 } 5720 5721 template<typename T> 5722 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 5723 return Reader.ReadDeclAs<T>(F, Record, Idx); 5724 } 5725 5726 public: 5727 TypeLocReader(ASTReader &Reader, ModuleFile &F, 5728 const ASTReader::RecordData &Record, unsigned &Idx) 5729 : Reader(Reader), F(F), Record(Record), Idx(Idx) 5730 { } 5731 5732 // We want compile-time assurance that we've enumerated all of 5733 // these, so unfortunately we have to declare them first, then 5734 // define them out-of-line. 5735 #define ABSTRACT_TYPELOC(CLASS, PARENT) 5736 #define TYPELOC(CLASS, PARENT) \ 5737 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 5738 #include "clang/AST/TypeLocNodes.def" 5739 5740 void VisitFunctionTypeLoc(FunctionTypeLoc); 5741 void VisitArrayTypeLoc(ArrayTypeLoc); 5742 }; 5743 5744 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 5745 // nothing to do 5746 } 5747 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 5748 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 5749 if (TL.needsExtraLocalData()) { 5750 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 5751 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 5752 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 5753 TL.setModeAttr(Record[Idx++]); 5754 } 5755 } 5756 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 5757 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5758 } 5759 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 5760 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 5761 } 5762 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) { 5763 // nothing to do 5764 } 5765 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { 5766 // nothing to do 5767 } 5768 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 5769 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 5770 } 5771 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 5772 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 5773 } 5774 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 5775 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 5776 } 5777 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 5778 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 5779 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 5780 } 5781 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 5782 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 5783 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 5784 if (Record[Idx++]) 5785 TL.setSizeExpr(Reader.ReadExpr(F)); 5786 else 5787 TL.setSizeExpr(nullptr); 5788 } 5789 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 5790 VisitArrayTypeLoc(TL); 5791 } 5792 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 5793 VisitArrayTypeLoc(TL); 5794 } 5795 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 5796 VisitArrayTypeLoc(TL); 5797 } 5798 void TypeLocReader::VisitDependentSizedArrayTypeLoc( 5799 DependentSizedArrayTypeLoc TL) { 5800 VisitArrayTypeLoc(TL); 5801 } 5802 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 5803 DependentSizedExtVectorTypeLoc TL) { 5804 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5805 } 5806 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 5807 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5808 } 5809 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 5810 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5811 } 5812 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 5813 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 5814 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5815 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5816 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 5817 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) { 5818 TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 5819 } 5820 } 5821 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 5822 VisitFunctionTypeLoc(TL); 5823 } 5824 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 5825 VisitFunctionTypeLoc(TL); 5826 } 5827 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 5828 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5829 } 5830 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 5831 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5832 } 5833 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 5834 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 5835 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5836 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5837 } 5838 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 5839 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 5840 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5841 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5842 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 5843 } 5844 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 5845 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5846 } 5847 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 5848 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 5849 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5850 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5851 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 5852 } 5853 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 5854 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5855 } 5856 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 5857 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5858 } 5859 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 5860 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5861 } 5862 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 5863 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 5864 if (TL.hasAttrOperand()) { 5865 SourceRange range; 5866 range.setBegin(ReadSourceLocation(Record, Idx)); 5867 range.setEnd(ReadSourceLocation(Record, Idx)); 5868 TL.setAttrOperandParensRange(range); 5869 } 5870 if (TL.hasAttrExprOperand()) { 5871 if (Record[Idx++]) 5872 TL.setAttrExprOperand(Reader.ReadExpr(F)); 5873 else 5874 TL.setAttrExprOperand(nullptr); 5875 } else if (TL.hasAttrEnumOperand()) 5876 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 5877 } 5878 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 5879 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5880 } 5881 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 5882 SubstTemplateTypeParmTypeLoc TL) { 5883 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5884 } 5885 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 5886 SubstTemplateTypeParmPackTypeLoc TL) { 5887 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5888 } 5889 void TypeLocReader::VisitTemplateSpecializationTypeLoc( 5890 TemplateSpecializationTypeLoc TL) { 5891 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 5892 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 5893 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 5894 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 5895 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 5896 TL.setArgLocInfo(i, 5897 Reader.GetTemplateArgumentLocInfo(F, 5898 TL.getTypePtr()->getArg(i).getKind(), 5899 Record, Idx)); 5900 } 5901 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 5902 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5903 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5904 } 5905 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 5906 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 5907 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 5908 } 5909 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 5910 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5911 } 5912 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 5913 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 5914 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 5915 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5916 } 5917 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 5918 DependentTemplateSpecializationTypeLoc TL) { 5919 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 5920 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 5921 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 5922 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 5923 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 5924 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 5925 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 5926 TL.setArgLocInfo(I, 5927 Reader.GetTemplateArgumentLocInfo(F, 5928 TL.getTypePtr()->getArg(I).getKind(), 5929 Record, Idx)); 5930 } 5931 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 5932 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 5933 } 5934 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 5935 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5936 } 5937 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 5938 TL.setHasBaseTypeAsWritten(Record[Idx++]); 5939 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 5940 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 5941 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 5942 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 5943 } 5944 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 5945 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 5946 } 5947 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 5948 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 5949 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5950 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5951 } 5952 5953 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 5954 const RecordData &Record, 5955 unsigned &Idx) { 5956 QualType InfoTy = readType(F, Record, Idx); 5957 if (InfoTy.isNull()) 5958 return nullptr; 5959 5960 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 5961 TypeLocReader TLR(*this, F, Record, Idx); 5962 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 5963 TLR.Visit(TL); 5964 return TInfo; 5965 } 5966 5967 QualType ASTReader::GetType(TypeID ID) { 5968 unsigned FastQuals = ID & Qualifiers::FastMask; 5969 unsigned Index = ID >> Qualifiers::FastWidth; 5970 5971 if (Index < NUM_PREDEF_TYPE_IDS) { 5972 QualType T; 5973 switch ((PredefinedTypeIDs)Index) { 5974 case PREDEF_TYPE_NULL_ID: return QualType(); 5975 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 5976 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 5977 5978 case PREDEF_TYPE_CHAR_U_ID: 5979 case PREDEF_TYPE_CHAR_S_ID: 5980 // FIXME: Check that the signedness of CharTy is correct! 5981 T = Context.CharTy; 5982 break; 5983 5984 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 5985 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 5986 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 5987 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 5988 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 5989 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 5990 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 5991 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 5992 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 5993 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 5994 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 5995 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 5996 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 5997 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 5998 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 5999 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 6000 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 6001 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 6002 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 6003 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 6004 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 6005 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 6006 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 6007 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 6008 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 6009 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 6010 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 6011 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 6012 case PREDEF_TYPE_IMAGE1D_ID: T = Context.OCLImage1dTy; break; 6013 case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break; 6014 case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break; 6015 case PREDEF_TYPE_IMAGE2D_ID: T = Context.OCLImage2dTy; break; 6016 case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break; 6017 case PREDEF_TYPE_IMAGE3D_ID: T = Context.OCLImage3dTy; break; 6018 case PREDEF_TYPE_SAMPLER_ID: T = Context.OCLSamplerTy; break; 6019 case PREDEF_TYPE_EVENT_ID: T = Context.OCLEventTy; break; 6020 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 6021 6022 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 6023 T = Context.getAutoRRefDeductType(); 6024 break; 6025 6026 case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 6027 T = Context.ARCUnbridgedCastTy; 6028 break; 6029 6030 case PREDEF_TYPE_VA_LIST_TAG: 6031 T = Context.getVaListTagType(); 6032 break; 6033 6034 case PREDEF_TYPE_BUILTIN_FN: 6035 T = Context.BuiltinFnTy; 6036 break; 6037 } 6038 6039 assert(!T.isNull() && "Unknown predefined type"); 6040 return T.withFastQualifiers(FastQuals); 6041 } 6042 6043 Index -= NUM_PREDEF_TYPE_IDS; 6044 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 6045 if (TypesLoaded[Index].isNull()) { 6046 TypesLoaded[Index] = readTypeRecord(Index); 6047 if (TypesLoaded[Index].isNull()) 6048 return QualType(); 6049 6050 TypesLoaded[Index]->setFromAST(); 6051 if (DeserializationListener) 6052 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 6053 TypesLoaded[Index]); 6054 } 6055 6056 return TypesLoaded[Index].withFastQualifiers(FastQuals); 6057 } 6058 6059 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 6060 return GetType(getGlobalTypeID(F, LocalID)); 6061 } 6062 6063 serialization::TypeID 6064 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 6065 unsigned FastQuals = LocalID & Qualifiers::FastMask; 6066 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 6067 6068 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 6069 return LocalID; 6070 6071 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6072 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 6073 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 6074 6075 unsigned GlobalIndex = LocalIndex + I->second; 6076 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 6077 } 6078 6079 TemplateArgumentLocInfo 6080 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 6081 TemplateArgument::ArgKind Kind, 6082 const RecordData &Record, 6083 unsigned &Index) { 6084 switch (Kind) { 6085 case TemplateArgument::Expression: 6086 return ReadExpr(F); 6087 case TemplateArgument::Type: 6088 return GetTypeSourceInfo(F, Record, Index); 6089 case TemplateArgument::Template: { 6090 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 6091 Index); 6092 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 6093 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 6094 SourceLocation()); 6095 } 6096 case TemplateArgument::TemplateExpansion: { 6097 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 6098 Index); 6099 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 6100 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 6101 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 6102 EllipsisLoc); 6103 } 6104 case TemplateArgument::Null: 6105 case TemplateArgument::Integral: 6106 case TemplateArgument::Declaration: 6107 case TemplateArgument::NullPtr: 6108 case TemplateArgument::Pack: 6109 // FIXME: Is this right? 6110 return TemplateArgumentLocInfo(); 6111 } 6112 llvm_unreachable("unexpected template argument loc"); 6113 } 6114 6115 TemplateArgumentLoc 6116 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 6117 const RecordData &Record, unsigned &Index) { 6118 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 6119 6120 if (Arg.getKind() == TemplateArgument::Expression) { 6121 if (Record[Index++]) // bool InfoHasSameExpr. 6122 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 6123 } 6124 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 6125 Record, Index)); 6126 } 6127 6128 const ASTTemplateArgumentListInfo* 6129 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F, 6130 const RecordData &Record, 6131 unsigned &Index) { 6132 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index); 6133 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index); 6134 unsigned NumArgsAsWritten = Record[Index++]; 6135 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc); 6136 for (unsigned i = 0; i != NumArgsAsWritten; ++i) 6137 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index)); 6138 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo); 6139 } 6140 6141 Decl *ASTReader::GetExternalDecl(uint32_t ID) { 6142 return GetDecl(ID); 6143 } 6144 6145 template<typename TemplateSpecializationDecl> 6146 static void completeRedeclChainForTemplateSpecialization(Decl *D) { 6147 if (auto *TSD = dyn_cast<TemplateSpecializationDecl>(D)) 6148 TSD->getSpecializedTemplate()->LoadLazySpecializations(); 6149 } 6150 6151 void ASTReader::CompleteRedeclChain(const Decl *D) { 6152 if (NumCurrentElementsDeserializing) { 6153 // We arrange to not care about the complete redeclaration chain while we're 6154 // deserializing. Just remember that the AST has marked this one as complete 6155 // but that it's not actually complete yet, so we know we still need to 6156 // complete it later. 6157 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D)); 6158 return; 6159 } 6160 6161 const DeclContext *DC = D->getDeclContext()->getRedeclContext(); 6162 6163 // If this is a named declaration, complete it by looking it up 6164 // within its context. 6165 // 6166 // FIXME: Merging a function definition should merge 6167 // all mergeable entities within it. 6168 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) || 6169 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) { 6170 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) { 6171 auto *II = Name.getAsIdentifierInfo(); 6172 if (isa<TranslationUnitDecl>(DC) && II) { 6173 // Outside of C++, we don't have a lookup table for the TU, so update 6174 // the identifier instead. In C++, either way should work fine. 6175 if (II->isOutOfDate()) 6176 updateOutOfDateIdentifier(*II); 6177 } else 6178 DC->lookup(Name); 6179 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) { 6180 // FIXME: It'd be nice to do something a bit more targeted here. 6181 D->getDeclContext()->decls_begin(); 6182 } 6183 } 6184 6185 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) 6186 CTSD->getSpecializedTemplate()->LoadLazySpecializations(); 6187 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D)) 6188 VTSD->getSpecializedTemplate()->LoadLazySpecializations(); 6189 if (auto *FD = dyn_cast<FunctionDecl>(D)) { 6190 if (auto *Template = FD->getPrimaryTemplate()) 6191 Template->LoadLazySpecializations(); 6192 } 6193 } 6194 6195 uint64_t ASTReader::ReadCXXCtorInitializersRef(ModuleFile &M, 6196 const RecordData &Record, 6197 unsigned &Idx) { 6198 if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXCtorInitializers) { 6199 Error("malformed AST file: missing C++ ctor initializers"); 6200 return 0; 6201 } 6202 6203 unsigned LocalID = Record[Idx++]; 6204 return getGlobalBitOffset(M, M.CXXCtorInitializersOffsets[LocalID - 1]); 6205 } 6206 6207 CXXCtorInitializer ** 6208 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) { 6209 RecordLocation Loc = getLocalBitOffset(Offset); 6210 BitstreamCursor &Cursor = Loc.F->DeclsCursor; 6211 SavedStreamPosition SavedPosition(Cursor); 6212 Cursor.JumpToBit(Loc.Offset); 6213 ReadingKindTracker ReadingKind(Read_Decl, *this); 6214 6215 RecordData Record; 6216 unsigned Code = Cursor.ReadCode(); 6217 unsigned RecCode = Cursor.readRecord(Code, Record); 6218 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) { 6219 Error("malformed AST file: missing C++ ctor initializers"); 6220 return nullptr; 6221 } 6222 6223 unsigned Idx = 0; 6224 return ReadCXXCtorInitializers(*Loc.F, Record, Idx); 6225 } 6226 6227 uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, 6228 const RecordData &Record, 6229 unsigned &Idx) { 6230 if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXBaseSpecifiers) { 6231 Error("malformed AST file: missing C++ base specifier"); 6232 return 0; 6233 } 6234 6235 unsigned LocalID = Record[Idx++]; 6236 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 6237 } 6238 6239 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 6240 RecordLocation Loc = getLocalBitOffset(Offset); 6241 BitstreamCursor &Cursor = Loc.F->DeclsCursor; 6242 SavedStreamPosition SavedPosition(Cursor); 6243 Cursor.JumpToBit(Loc.Offset); 6244 ReadingKindTracker ReadingKind(Read_Decl, *this); 6245 RecordData Record; 6246 unsigned Code = Cursor.ReadCode(); 6247 unsigned RecCode = Cursor.readRecord(Code, Record); 6248 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 6249 Error("malformed AST file: missing C++ base specifiers"); 6250 return nullptr; 6251 } 6252 6253 unsigned Idx = 0; 6254 unsigned NumBases = Record[Idx++]; 6255 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 6256 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 6257 for (unsigned I = 0; I != NumBases; ++I) 6258 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 6259 return Bases; 6260 } 6261 6262 serialization::DeclID 6263 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const { 6264 if (LocalID < NUM_PREDEF_DECL_IDS) 6265 return LocalID; 6266 6267 ContinuousRangeMap<uint32_t, int, 2>::iterator I 6268 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 6269 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 6270 6271 return LocalID + I->second; 6272 } 6273 6274 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 6275 ModuleFile &M) const { 6276 // Predefined decls aren't from any module. 6277 if (ID < NUM_PREDEF_DECL_IDS) 6278 return false; 6279 6280 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 6281 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 6282 return &M == I->second; 6283 } 6284 6285 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) { 6286 if (!D->isFromASTFile()) 6287 return nullptr; 6288 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID()); 6289 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 6290 return I->second; 6291 } 6292 6293 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 6294 if (ID < NUM_PREDEF_DECL_IDS) 6295 return SourceLocation(); 6296 6297 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 6298 6299 if (Index > DeclsLoaded.size()) { 6300 Error("declaration ID out-of-range for AST file"); 6301 return SourceLocation(); 6302 } 6303 6304 if (Decl *D = DeclsLoaded[Index]) 6305 return D->getLocation(); 6306 6307 unsigned RawLocation = 0; 6308 RecordLocation Rec = DeclCursorForID(ID, RawLocation); 6309 return ReadSourceLocation(*Rec.F, RawLocation); 6310 } 6311 6312 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) { 6313 switch (ID) { 6314 case PREDEF_DECL_NULL_ID: 6315 return nullptr; 6316 6317 case PREDEF_DECL_TRANSLATION_UNIT_ID: 6318 return Context.getTranslationUnitDecl(); 6319 6320 case PREDEF_DECL_OBJC_ID_ID: 6321 return Context.getObjCIdDecl(); 6322 6323 case PREDEF_DECL_OBJC_SEL_ID: 6324 return Context.getObjCSelDecl(); 6325 6326 case PREDEF_DECL_OBJC_CLASS_ID: 6327 return Context.getObjCClassDecl(); 6328 6329 case PREDEF_DECL_OBJC_PROTOCOL_ID: 6330 return Context.getObjCProtocolDecl(); 6331 6332 case PREDEF_DECL_INT_128_ID: 6333 return Context.getInt128Decl(); 6334 6335 case PREDEF_DECL_UNSIGNED_INT_128_ID: 6336 return Context.getUInt128Decl(); 6337 6338 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 6339 return Context.getObjCInstanceTypeDecl(); 6340 6341 case PREDEF_DECL_BUILTIN_VA_LIST_ID: 6342 return Context.getBuiltinVaListDecl(); 6343 6344 case PREDEF_DECL_EXTERN_C_CONTEXT_ID: 6345 return Context.getExternCContextDecl(); 6346 } 6347 llvm_unreachable("PredefinedDeclIDs unknown enum value"); 6348 } 6349 6350 Decl *ASTReader::GetExistingDecl(DeclID ID) { 6351 if (ID < NUM_PREDEF_DECL_IDS) { 6352 Decl *D = getPredefinedDecl(Context, (PredefinedDeclIDs)ID); 6353 if (D) { 6354 // Track that we have merged the declaration with ID \p ID into the 6355 // pre-existing predefined declaration \p D. 6356 auto &Merged = MergedDecls[D->getCanonicalDecl()]; 6357 if (Merged.empty()) 6358 Merged.push_back(ID); 6359 } 6360 return D; 6361 } 6362 6363 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 6364 6365 if (Index >= DeclsLoaded.size()) { 6366 assert(0 && "declaration ID out-of-range for AST file"); 6367 Error("declaration ID out-of-range for AST file"); 6368 return nullptr; 6369 } 6370 6371 return DeclsLoaded[Index]; 6372 } 6373 6374 Decl *ASTReader::GetDecl(DeclID ID) { 6375 if (ID < NUM_PREDEF_DECL_IDS) 6376 return GetExistingDecl(ID); 6377 6378 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 6379 6380 if (Index >= DeclsLoaded.size()) { 6381 assert(0 && "declaration ID out-of-range for AST file"); 6382 Error("declaration ID out-of-range for AST file"); 6383 return nullptr; 6384 } 6385 6386 if (!DeclsLoaded[Index]) { 6387 ReadDeclRecord(ID); 6388 if (DeserializationListener) 6389 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 6390 } 6391 6392 return DeclsLoaded[Index]; 6393 } 6394 6395 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 6396 DeclID GlobalID) { 6397 if (GlobalID < NUM_PREDEF_DECL_IDS) 6398 return GlobalID; 6399 6400 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 6401 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 6402 ModuleFile *Owner = I->second; 6403 6404 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 6405 = M.GlobalToLocalDeclIDs.find(Owner); 6406 if (Pos == M.GlobalToLocalDeclIDs.end()) 6407 return 0; 6408 6409 return GlobalID - Owner->BaseDeclID + Pos->second; 6410 } 6411 6412 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 6413 const RecordData &Record, 6414 unsigned &Idx) { 6415 if (Idx >= Record.size()) { 6416 Error("Corrupted AST file"); 6417 return 0; 6418 } 6419 6420 return getGlobalDeclID(F, Record[Idx++]); 6421 } 6422 6423 /// \brief Resolve the offset of a statement into a statement. 6424 /// 6425 /// This operation will read a new statement from the external 6426 /// source each time it is called, and is meant to be used via a 6427 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 6428 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 6429 // Switch case IDs are per Decl. 6430 ClearSwitchCaseIDs(); 6431 6432 // Offset here is a global offset across the entire chain. 6433 RecordLocation Loc = getLocalBitOffset(Offset); 6434 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 6435 return ReadStmtFromStream(*Loc.F); 6436 } 6437 6438 namespace { 6439 class FindExternalLexicalDeclsVisitor { 6440 ASTReader &Reader; 6441 const DeclContext *DC; 6442 bool (*isKindWeWant)(Decl::Kind); 6443 6444 SmallVectorImpl<Decl*> &Decls; 6445 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 6446 6447 public: 6448 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 6449 bool (*isKindWeWant)(Decl::Kind), 6450 SmallVectorImpl<Decl*> &Decls) 6451 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 6452 { 6453 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 6454 PredefsVisited[I] = false; 6455 } 6456 6457 static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 6458 if (Preorder) 6459 return false; 6460 6461 FindExternalLexicalDeclsVisitor *This 6462 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 6463 6464 ModuleFile::DeclContextInfosMap::iterator Info 6465 = M.DeclContextInfos.find(This->DC); 6466 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 6467 return false; 6468 6469 // Load all of the declaration IDs 6470 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 6471 *IDE = ID + Info->second.NumLexicalDecls; 6472 ID != IDE; ++ID) { 6473 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 6474 continue; 6475 6476 // Don't add predefined declarations to the lexical context more 6477 // than once. 6478 if (ID->second < NUM_PREDEF_DECL_IDS) { 6479 if (This->PredefsVisited[ID->second]) 6480 continue; 6481 6482 This->PredefsVisited[ID->second] = true; 6483 } 6484 6485 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 6486 if (!This->DC->isDeclInLexicalTraversal(D)) 6487 This->Decls.push_back(D); 6488 } 6489 } 6490 6491 return false; 6492 } 6493 }; 6494 } 6495 6496 ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 6497 bool (*isKindWeWant)(Decl::Kind), 6498 SmallVectorImpl<Decl*> &Decls) { 6499 // There might be lexical decls in multiple modules, for the TU at 6500 // least. Walk all of the modules in the order they were loaded. 6501 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 6502 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 6503 ++NumLexicalDeclContextsRead; 6504 return ELR_Success; 6505 } 6506 6507 namespace { 6508 6509 class DeclIDComp { 6510 ASTReader &Reader; 6511 ModuleFile &Mod; 6512 6513 public: 6514 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 6515 6516 bool operator()(LocalDeclID L, LocalDeclID R) const { 6517 SourceLocation LHS = getLocation(L); 6518 SourceLocation RHS = getLocation(R); 6519 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 6520 } 6521 6522 bool operator()(SourceLocation LHS, LocalDeclID R) const { 6523 SourceLocation RHS = getLocation(R); 6524 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 6525 } 6526 6527 bool operator()(LocalDeclID L, SourceLocation RHS) const { 6528 SourceLocation LHS = getLocation(L); 6529 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 6530 } 6531 6532 SourceLocation getLocation(LocalDeclID ID) const { 6533 return Reader.getSourceManager().getFileLoc( 6534 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 6535 } 6536 }; 6537 6538 } 6539 6540 void ASTReader::FindFileRegionDecls(FileID File, 6541 unsigned Offset, unsigned Length, 6542 SmallVectorImpl<Decl *> &Decls) { 6543 SourceManager &SM = getSourceManager(); 6544 6545 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 6546 if (I == FileDeclIDs.end()) 6547 return; 6548 6549 FileDeclsInfo &DInfo = I->second; 6550 if (DInfo.Decls.empty()) 6551 return; 6552 6553 SourceLocation 6554 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 6555 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 6556 6557 DeclIDComp DIDComp(*this, *DInfo.Mod); 6558 ArrayRef<serialization::LocalDeclID>::iterator 6559 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 6560 BeginLoc, DIDComp); 6561 if (BeginIt != DInfo.Decls.begin()) 6562 --BeginIt; 6563 6564 // If we are pointing at a top-level decl inside an objc container, we need 6565 // to backtrack until we find it otherwise we will fail to report that the 6566 // region overlaps with an objc container. 6567 while (BeginIt != DInfo.Decls.begin() && 6568 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 6569 ->isTopLevelDeclInObjCContainer()) 6570 --BeginIt; 6571 6572 ArrayRef<serialization::LocalDeclID>::iterator 6573 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 6574 EndLoc, DIDComp); 6575 if (EndIt != DInfo.Decls.end()) 6576 ++EndIt; 6577 6578 for (ArrayRef<serialization::LocalDeclID>::iterator 6579 DIt = BeginIt; DIt != EndIt; ++DIt) 6580 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 6581 } 6582 6583 namespace { 6584 /// \brief ModuleFile visitor used to perform name lookup into a 6585 /// declaration context. 6586 class DeclContextNameLookupVisitor { 6587 ASTReader &Reader; 6588 ArrayRef<const DeclContext *> Contexts; 6589 DeclarationName Name; 6590 SmallVectorImpl<NamedDecl *> &Decls; 6591 llvm::SmallPtrSetImpl<NamedDecl *> &DeclSet; 6592 6593 public: 6594 DeclContextNameLookupVisitor(ASTReader &Reader, 6595 ArrayRef<const DeclContext *> Contexts, 6596 DeclarationName Name, 6597 SmallVectorImpl<NamedDecl *> &Decls, 6598 llvm::SmallPtrSetImpl<NamedDecl *> &DeclSet) 6599 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls), 6600 DeclSet(DeclSet) { } 6601 6602 static bool visit(ModuleFile &M, void *UserData) { 6603 DeclContextNameLookupVisitor *This 6604 = static_cast<DeclContextNameLookupVisitor *>(UserData); 6605 6606 // Check whether we have any visible declaration information for 6607 // this context in this module. 6608 ModuleFile::DeclContextInfosMap::iterator Info; 6609 bool FoundInfo = false; 6610 for (auto *DC : This->Contexts) { 6611 Info = M.DeclContextInfos.find(DC); 6612 if (Info != M.DeclContextInfos.end() && 6613 Info->second.NameLookupTableData) { 6614 FoundInfo = true; 6615 break; 6616 } 6617 } 6618 6619 if (!FoundInfo) 6620 return false; 6621 6622 // Look for this name within this module. 6623 ASTDeclContextNameLookupTable *LookupTable = 6624 Info->second.NameLookupTableData; 6625 ASTDeclContextNameLookupTable::iterator Pos 6626 = LookupTable->find(This->Name); 6627 if (Pos == LookupTable->end()) 6628 return false; 6629 6630 bool FoundAnything = false; 6631 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 6632 for (; Data.first != Data.second; ++Data.first) { 6633 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 6634 if (!ND) 6635 continue; 6636 6637 if (ND->getDeclName() != This->Name) { 6638 // A name might be null because the decl's redeclarable part is 6639 // currently read before reading its name. The lookup is triggered by 6640 // building that decl (likely indirectly), and so it is later in the 6641 // sense of "already existing" and can be ignored here. 6642 // FIXME: This should not happen; deserializing declarations should 6643 // not perform lookups since that can lead to deserialization cycles. 6644 continue; 6645 } 6646 6647 // Record this declaration. 6648 FoundAnything = true; 6649 if (This->DeclSet.insert(ND).second) 6650 This->Decls.push_back(ND); 6651 } 6652 6653 return FoundAnything; 6654 } 6655 }; 6656 } 6657 6658 /// \brief Retrieve the "definitive" module file for the definition of the 6659 /// given declaration context, if there is one. 6660 /// 6661 /// The "definitive" module file is the only place where we need to look to 6662 /// find information about the declarations within the given declaration 6663 /// context. For example, C++ and Objective-C classes, C structs/unions, and 6664 /// Objective-C protocols, categories, and extensions are all defined in a 6665 /// single place in the source code, so they have definitive module files 6666 /// associated with them. C++ namespaces, on the other hand, can have 6667 /// definitions in multiple different module files. 6668 /// 6669 /// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's 6670 /// NDEBUG checking. 6671 static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC, 6672 ASTReader &Reader) { 6673 if (const DeclContext *DefDC = getDefinitiveDeclContext(DC)) 6674 return Reader.getOwningModuleFile(cast<Decl>(DefDC)); 6675 6676 return nullptr; 6677 } 6678 6679 bool 6680 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 6681 DeclarationName Name) { 6682 assert(DC->hasExternalVisibleStorage() && 6683 "DeclContext has no visible decls in storage"); 6684 if (!Name) 6685 return false; 6686 6687 Deserializing LookupResults(this); 6688 6689 SmallVector<NamedDecl *, 64> Decls; 6690 llvm::SmallPtrSet<NamedDecl*, 64> DeclSet; 6691 6692 // Compute the declaration contexts we need to look into. Multiple such 6693 // declaration contexts occur when two declaration contexts from disjoint 6694 // modules get merged, e.g., when two namespaces with the same name are 6695 // independently defined in separate modules. 6696 SmallVector<const DeclContext *, 2> Contexts; 6697 Contexts.push_back(DC); 6698 6699 if (DC->isNamespace()) { 6700 auto Merged = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 6701 if (Merged != MergedDecls.end()) { 6702 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 6703 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 6704 } 6705 } 6706 6707 auto LookUpInContexts = [&](ArrayRef<const DeclContext*> Contexts) { 6708 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls, DeclSet); 6709 6710 // If we can definitively determine which module file to look into, 6711 // only look there. Otherwise, look in all module files. 6712 ModuleFile *Definitive; 6713 if (Contexts.size() == 1 && 6714 (Definitive = getDefinitiveModuleFileFor(Contexts[0], *this))) { 6715 DeclContextNameLookupVisitor::visit(*Definitive, &Visitor); 6716 } else { 6717 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 6718 } 6719 }; 6720 6721 LookUpInContexts(Contexts); 6722 6723 // If this might be an implicit special member function, then also search 6724 // all merged definitions of the surrounding class. We need to search them 6725 // individually, because finding an entity in one of them doesn't imply that 6726 // we can't find a different entity in another one. 6727 if (isa<CXXRecordDecl>(DC)) { 6728 auto Merged = MergedLookups.find(DC); 6729 if (Merged != MergedLookups.end()) { 6730 for (unsigned I = 0; I != Merged->second.size(); ++I) { 6731 const DeclContext *Context = Merged->second[I]; 6732 LookUpInContexts(Context); 6733 // We might have just added some more merged lookups. If so, our 6734 // iterator is now invalid, so grab a fresh one before continuing. 6735 Merged = MergedLookups.find(DC); 6736 } 6737 } 6738 } 6739 6740 ++NumVisibleDeclContextsRead; 6741 SetExternalVisibleDeclsForName(DC, Name, Decls); 6742 return !Decls.empty(); 6743 } 6744 6745 namespace { 6746 /// \brief ModuleFile visitor used to retrieve all visible names in a 6747 /// declaration context. 6748 class DeclContextAllNamesVisitor { 6749 ASTReader &Reader; 6750 SmallVectorImpl<const DeclContext *> &Contexts; 6751 DeclsMap &Decls; 6752 llvm::SmallPtrSet<NamedDecl *, 256> DeclSet; 6753 bool VisitAll; 6754 6755 public: 6756 DeclContextAllNamesVisitor(ASTReader &Reader, 6757 SmallVectorImpl<const DeclContext *> &Contexts, 6758 DeclsMap &Decls, bool VisitAll) 6759 : Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { } 6760 6761 static bool visit(ModuleFile &M, void *UserData) { 6762 DeclContextAllNamesVisitor *This 6763 = static_cast<DeclContextAllNamesVisitor *>(UserData); 6764 6765 // Check whether we have any visible declaration information for 6766 // this context in this module. 6767 ModuleFile::DeclContextInfosMap::iterator Info; 6768 bool FoundInfo = false; 6769 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 6770 Info = M.DeclContextInfos.find(This->Contexts[I]); 6771 if (Info != M.DeclContextInfos.end() && 6772 Info->second.NameLookupTableData) { 6773 FoundInfo = true; 6774 break; 6775 } 6776 } 6777 6778 if (!FoundInfo) 6779 return false; 6780 6781 ASTDeclContextNameLookupTable *LookupTable = 6782 Info->second.NameLookupTableData; 6783 bool FoundAnything = false; 6784 for (ASTDeclContextNameLookupTable::data_iterator 6785 I = LookupTable->data_begin(), E = LookupTable->data_end(); 6786 I != E; 6787 ++I) { 6788 ASTDeclContextNameLookupTrait::data_type Data = *I; 6789 for (; Data.first != Data.second; ++Data.first) { 6790 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, 6791 *Data.first); 6792 if (!ND) 6793 continue; 6794 6795 // Record this declaration. 6796 FoundAnything = true; 6797 if (This->DeclSet.insert(ND).second) 6798 This->Decls[ND->getDeclName()].push_back(ND); 6799 } 6800 } 6801 6802 return FoundAnything && !This->VisitAll; 6803 } 6804 }; 6805 } 6806 6807 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) { 6808 if (!DC->hasExternalVisibleStorage()) 6809 return; 6810 DeclsMap Decls; 6811 6812 // Compute the declaration contexts we need to look into. Multiple such 6813 // declaration contexts occur when two declaration contexts from disjoint 6814 // modules get merged, e.g., when two namespaces with the same name are 6815 // independently defined in separate modules. 6816 SmallVector<const DeclContext *, 2> Contexts; 6817 Contexts.push_back(DC); 6818 6819 if (DC->isNamespace()) { 6820 MergedDeclsMap::iterator Merged 6821 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 6822 if (Merged != MergedDecls.end()) { 6823 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 6824 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 6825 } 6826 } 6827 6828 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls, 6829 /*VisitAll=*/DC->isFileContext()); 6830 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor); 6831 ++NumVisibleDeclContextsRead; 6832 6833 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) { 6834 SetExternalVisibleDeclsForName(DC, I->first, I->second); 6835 } 6836 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false); 6837 } 6838 6839 /// \brief Under non-PCH compilation the consumer receives the objc methods 6840 /// before receiving the implementation, and codegen depends on this. 6841 /// We simulate this by deserializing and passing to consumer the methods of the 6842 /// implementation before passing the deserialized implementation decl. 6843 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 6844 ASTConsumer *Consumer) { 6845 assert(ImplD && Consumer); 6846 6847 for (auto *I : ImplD->methods()) 6848 Consumer->HandleInterestingDecl(DeclGroupRef(I)); 6849 6850 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 6851 } 6852 6853 void ASTReader::PassInterestingDeclsToConsumer() { 6854 assert(Consumer); 6855 6856 if (PassingDeclsToConsumer) 6857 return; 6858 6859 // Guard variable to avoid recursively redoing the process of passing 6860 // decls to consumer. 6861 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer, 6862 true); 6863 6864 // Ensure that we've loaded all potentially-interesting declarations 6865 // that need to be eagerly loaded. 6866 for (auto ID : EagerlyDeserializedDecls) 6867 GetDecl(ID); 6868 EagerlyDeserializedDecls.clear(); 6869 6870 while (!InterestingDecls.empty()) { 6871 Decl *D = InterestingDecls.front(); 6872 InterestingDecls.pop_front(); 6873 6874 PassInterestingDeclToConsumer(D); 6875 } 6876 } 6877 6878 void ASTReader::PassInterestingDeclToConsumer(Decl *D) { 6879 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 6880 PassObjCImplDeclToConsumer(ImplD, Consumer); 6881 else 6882 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 6883 } 6884 6885 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 6886 this->Consumer = Consumer; 6887 6888 if (Consumer) 6889 PassInterestingDeclsToConsumer(); 6890 6891 if (DeserializationListener) 6892 DeserializationListener->ReaderInitialized(this); 6893 } 6894 6895 void ASTReader::PrintStats() { 6896 std::fprintf(stderr, "*** AST File Statistics:\n"); 6897 6898 unsigned NumTypesLoaded 6899 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 6900 QualType()); 6901 unsigned NumDeclsLoaded 6902 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 6903 (Decl *)nullptr); 6904 unsigned NumIdentifiersLoaded 6905 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 6906 IdentifiersLoaded.end(), 6907 (IdentifierInfo *)nullptr); 6908 unsigned NumMacrosLoaded 6909 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(), 6910 MacrosLoaded.end(), 6911 (MacroInfo *)nullptr); 6912 unsigned NumSelectorsLoaded 6913 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 6914 SelectorsLoaded.end(), 6915 Selector()); 6916 6917 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 6918 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 6919 NumSLocEntriesRead, TotalNumSLocEntries, 6920 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 6921 if (!TypesLoaded.empty()) 6922 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 6923 NumTypesLoaded, (unsigned)TypesLoaded.size(), 6924 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 6925 if (!DeclsLoaded.empty()) 6926 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 6927 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 6928 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 6929 if (!IdentifiersLoaded.empty()) 6930 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 6931 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 6932 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 6933 if (!MacrosLoaded.empty()) 6934 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 6935 NumMacrosLoaded, (unsigned)MacrosLoaded.size(), 6936 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100)); 6937 if (!SelectorsLoaded.empty()) 6938 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 6939 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 6940 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 6941 if (TotalNumStatements) 6942 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 6943 NumStatementsRead, TotalNumStatements, 6944 ((float)NumStatementsRead/TotalNumStatements * 100)); 6945 if (TotalNumMacros) 6946 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 6947 NumMacrosRead, TotalNumMacros, 6948 ((float)NumMacrosRead/TotalNumMacros * 100)); 6949 if (TotalLexicalDeclContexts) 6950 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 6951 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 6952 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 6953 * 100)); 6954 if (TotalVisibleDeclContexts) 6955 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 6956 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 6957 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 6958 * 100)); 6959 if (TotalNumMethodPoolEntries) { 6960 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 6961 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 6962 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 6963 * 100)); 6964 } 6965 if (NumMethodPoolLookups) { 6966 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n", 6967 NumMethodPoolHits, NumMethodPoolLookups, 6968 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0)); 6969 } 6970 if (NumMethodPoolTableLookups) { 6971 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n", 6972 NumMethodPoolTableHits, NumMethodPoolTableLookups, 6973 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups 6974 * 100.0)); 6975 } 6976 6977 if (NumIdentifierLookupHits) { 6978 std::fprintf(stderr, 6979 " %u / %u identifier table lookups succeeded (%f%%)\n", 6980 NumIdentifierLookupHits, NumIdentifierLookups, 6981 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups); 6982 } 6983 6984 if (GlobalIndex) { 6985 std::fprintf(stderr, "\n"); 6986 GlobalIndex->printStats(); 6987 } 6988 6989 std::fprintf(stderr, "\n"); 6990 dump(); 6991 std::fprintf(stderr, "\n"); 6992 } 6993 6994 template<typename Key, typename ModuleFile, unsigned InitialCapacity> 6995 static void 6996 dumpModuleIDMap(StringRef Name, 6997 const ContinuousRangeMap<Key, ModuleFile *, 6998 InitialCapacity> &Map) { 6999 if (Map.begin() == Map.end()) 7000 return; 7001 7002 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 7003 llvm::errs() << Name << ":\n"; 7004 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 7005 I != IEnd; ++I) { 7006 llvm::errs() << " " << I->first << " -> " << I->second->FileName 7007 << "\n"; 7008 } 7009 } 7010 7011 void ASTReader::dump() { 7012 llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 7013 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 7014 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 7015 dumpModuleIDMap("Global type map", GlobalTypeMap); 7016 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 7017 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 7018 dumpModuleIDMap("Global macro map", GlobalMacroMap); 7019 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 7020 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 7021 dumpModuleIDMap("Global preprocessed entity map", 7022 GlobalPreprocessedEntityMap); 7023 7024 llvm::errs() << "\n*** PCH/Modules Loaded:"; 7025 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 7026 MEnd = ModuleMgr.end(); 7027 M != MEnd; ++M) 7028 (*M)->dump(); 7029 } 7030 7031 /// Return the amount of memory used by memory buffers, breaking down 7032 /// by heap-backed versus mmap'ed memory. 7033 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 7034 for (ModuleConstIterator I = ModuleMgr.begin(), 7035 E = ModuleMgr.end(); I != E; ++I) { 7036 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 7037 size_t bytes = buf->getBufferSize(); 7038 switch (buf->getBufferKind()) { 7039 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 7040 sizes.malloc_bytes += bytes; 7041 break; 7042 case llvm::MemoryBuffer::MemoryBuffer_MMap: 7043 sizes.mmap_bytes += bytes; 7044 break; 7045 } 7046 } 7047 } 7048 } 7049 7050 void ASTReader::InitializeSema(Sema &S) { 7051 SemaObj = &S; 7052 S.addExternalSource(this); 7053 7054 // Makes sure any declarations that were deserialized "too early" 7055 // still get added to the identifier's declaration chains. 7056 for (uint64_t ID : PreloadedDeclIDs) { 7057 NamedDecl *D = cast<NamedDecl>(GetDecl(ID)); 7058 pushExternalDeclIntoScope(D, D->getDeclName()); 7059 } 7060 PreloadedDeclIDs.clear(); 7061 7062 // FIXME: What happens if these are changed by a module import? 7063 if (!FPPragmaOptions.empty()) { 7064 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 7065 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 7066 } 7067 7068 // FIXME: What happens if these are changed by a module import? 7069 if (!OpenCLExtensions.empty()) { 7070 unsigned I = 0; 7071 #define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 7072 #include "clang/Basic/OpenCLExtensions.def" 7073 7074 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 7075 } 7076 7077 UpdateSema(); 7078 } 7079 7080 void ASTReader::UpdateSema() { 7081 assert(SemaObj && "no Sema to update"); 7082 7083 // Load the offsets of the declarations that Sema references. 7084 // They will be lazily deserialized when needed. 7085 if (!SemaDeclRefs.empty()) { 7086 assert(SemaDeclRefs.size() % 2 == 0); 7087 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) { 7088 if (!SemaObj->StdNamespace) 7089 SemaObj->StdNamespace = SemaDeclRefs[I]; 7090 if (!SemaObj->StdBadAlloc) 7091 SemaObj->StdBadAlloc = SemaDeclRefs[I+1]; 7092 } 7093 SemaDeclRefs.clear(); 7094 } 7095 7096 // Update the state of 'pragma clang optimize'. Use the same API as if we had 7097 // encountered the pragma in the source. 7098 if(OptimizeOffPragmaLocation.isValid()) 7099 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation); 7100 } 7101 7102 IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 7103 // Note that we are loading an identifier. 7104 Deserializing AnIdentifier(this); 7105 StringRef Name(NameStart, NameEnd - NameStart); 7106 7107 // If there is a global index, look there first to determine which modules 7108 // provably do not have any results for this identifier. 7109 GlobalModuleIndex::HitSet Hits; 7110 GlobalModuleIndex::HitSet *HitsPtr = nullptr; 7111 if (!loadGlobalIndex()) { 7112 if (GlobalIndex->lookupIdentifier(Name, Hits)) { 7113 HitsPtr = &Hits; 7114 } 7115 } 7116 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0, 7117 NumIdentifierLookups, 7118 NumIdentifierLookupHits); 7119 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 7120 IdentifierInfo *II = Visitor.getIdentifierInfo(); 7121 markIdentifierUpToDate(II); 7122 return II; 7123 } 7124 7125 namespace clang { 7126 /// \brief An identifier-lookup iterator that enumerates all of the 7127 /// identifiers stored within a set of AST files. 7128 class ASTIdentifierIterator : public IdentifierIterator { 7129 /// \brief The AST reader whose identifiers are being enumerated. 7130 const ASTReader &Reader; 7131 7132 /// \brief The current index into the chain of AST files stored in 7133 /// the AST reader. 7134 unsigned Index; 7135 7136 /// \brief The current position within the identifier lookup table 7137 /// of the current AST file. 7138 ASTIdentifierLookupTable::key_iterator Current; 7139 7140 /// \brief The end position within the identifier lookup table of 7141 /// the current AST file. 7142 ASTIdentifierLookupTable::key_iterator End; 7143 7144 public: 7145 explicit ASTIdentifierIterator(const ASTReader &Reader); 7146 7147 StringRef Next() override; 7148 }; 7149 } 7150 7151 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 7152 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 7153 ASTIdentifierLookupTable *IdTable 7154 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 7155 Current = IdTable->key_begin(); 7156 End = IdTable->key_end(); 7157 } 7158 7159 StringRef ASTIdentifierIterator::Next() { 7160 while (Current == End) { 7161 // If we have exhausted all of our AST files, we're done. 7162 if (Index == 0) 7163 return StringRef(); 7164 7165 --Index; 7166 ASTIdentifierLookupTable *IdTable 7167 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 7168 IdentifierLookupTable; 7169 Current = IdTable->key_begin(); 7170 End = IdTable->key_end(); 7171 } 7172 7173 // We have any identifiers remaining in the current AST file; return 7174 // the next one. 7175 StringRef Result = *Current; 7176 ++Current; 7177 return Result; 7178 } 7179 7180 IdentifierIterator *ASTReader::getIdentifiers() { 7181 if (!loadGlobalIndex()) 7182 return GlobalIndex->createIdentifierIterator(); 7183 7184 return new ASTIdentifierIterator(*this); 7185 } 7186 7187 namespace clang { namespace serialization { 7188 class ReadMethodPoolVisitor { 7189 ASTReader &Reader; 7190 Selector Sel; 7191 unsigned PriorGeneration; 7192 unsigned InstanceBits; 7193 unsigned FactoryBits; 7194 bool InstanceHasMoreThanOneDecl; 7195 bool FactoryHasMoreThanOneDecl; 7196 SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 7197 SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 7198 7199 public: 7200 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, 7201 unsigned PriorGeneration) 7202 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration), 7203 InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false), 7204 FactoryHasMoreThanOneDecl(false) {} 7205 7206 static bool visit(ModuleFile &M, void *UserData) { 7207 ReadMethodPoolVisitor *This 7208 = static_cast<ReadMethodPoolVisitor *>(UserData); 7209 7210 if (!M.SelectorLookupTable) 7211 return false; 7212 7213 // If we've already searched this module file, skip it now. 7214 if (M.Generation <= This->PriorGeneration) 7215 return true; 7216 7217 ++This->Reader.NumMethodPoolTableLookups; 7218 ASTSelectorLookupTable *PoolTable 7219 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 7220 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 7221 if (Pos == PoolTable->end()) 7222 return false; 7223 7224 ++This->Reader.NumMethodPoolTableHits; 7225 ++This->Reader.NumSelectorsRead; 7226 // FIXME: Not quite happy with the statistics here. We probably should 7227 // disable this tracking when called via LoadSelector. 7228 // Also, should entries without methods count as misses? 7229 ++This->Reader.NumMethodPoolEntriesRead; 7230 ASTSelectorLookupTrait::data_type Data = *Pos; 7231 if (This->Reader.DeserializationListener) 7232 This->Reader.DeserializationListener->SelectorRead(Data.ID, 7233 This->Sel); 7234 7235 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 7236 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 7237 This->InstanceBits = Data.InstanceBits; 7238 This->FactoryBits = Data.FactoryBits; 7239 This->InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl; 7240 This->FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl; 7241 return true; 7242 } 7243 7244 /// \brief Retrieve the instance methods found by this visitor. 7245 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const { 7246 return InstanceMethods; 7247 } 7248 7249 /// \brief Retrieve the instance methods found by this visitor. 7250 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const { 7251 return FactoryMethods; 7252 } 7253 7254 unsigned getInstanceBits() const { return InstanceBits; } 7255 unsigned getFactoryBits() const { return FactoryBits; } 7256 bool instanceHasMoreThanOneDecl() const { 7257 return InstanceHasMoreThanOneDecl; 7258 } 7259 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; } 7260 }; 7261 } } // end namespace clang::serialization 7262 7263 /// \brief Add the given set of methods to the method list. 7264 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods, 7265 ObjCMethodList &List) { 7266 for (unsigned I = 0, N = Methods.size(); I != N; ++I) { 7267 S.addMethodToGlobalList(&List, Methods[I]); 7268 } 7269 } 7270 7271 void ASTReader::ReadMethodPool(Selector Sel) { 7272 // Get the selector generation and update it to the current generation. 7273 unsigned &Generation = SelectorGeneration[Sel]; 7274 unsigned PriorGeneration = Generation; 7275 Generation = getGeneration(); 7276 7277 // Search for methods defined with this selector. 7278 ++NumMethodPoolLookups; 7279 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration); 7280 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 7281 7282 if (Visitor.getInstanceMethods().empty() && 7283 Visitor.getFactoryMethods().empty()) 7284 return; 7285 7286 ++NumMethodPoolHits; 7287 7288 if (!getSema()) 7289 return; 7290 7291 Sema &S = *getSema(); 7292 Sema::GlobalMethodPool::iterator Pos 7293 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first; 7294 7295 Pos->second.first.setBits(Visitor.getInstanceBits()); 7296 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl()); 7297 Pos->second.second.setBits(Visitor.getFactoryBits()); 7298 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl()); 7299 7300 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since 7301 // when building a module we keep every method individually and may need to 7302 // update hasMoreThanOneDecl as we add the methods. 7303 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first); 7304 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second); 7305 } 7306 7307 void ASTReader::ReadKnownNamespaces( 7308 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 7309 Namespaces.clear(); 7310 7311 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 7312 if (NamespaceDecl *Namespace 7313 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 7314 Namespaces.push_back(Namespace); 7315 } 7316 } 7317 7318 void ASTReader::ReadUndefinedButUsed( 7319 llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) { 7320 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) { 7321 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++])); 7322 SourceLocation Loc = 7323 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]); 7324 Undefined.insert(std::make_pair(D, Loc)); 7325 } 7326 } 7327 7328 void ASTReader::ReadTentativeDefinitions( 7329 SmallVectorImpl<VarDecl *> &TentativeDefs) { 7330 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 7331 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 7332 if (Var) 7333 TentativeDefs.push_back(Var); 7334 } 7335 TentativeDefinitions.clear(); 7336 } 7337 7338 void ASTReader::ReadUnusedFileScopedDecls( 7339 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 7340 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 7341 DeclaratorDecl *D 7342 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 7343 if (D) 7344 Decls.push_back(D); 7345 } 7346 UnusedFileScopedDecls.clear(); 7347 } 7348 7349 void ASTReader::ReadDelegatingConstructors( 7350 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 7351 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 7352 CXXConstructorDecl *D 7353 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 7354 if (D) 7355 Decls.push_back(D); 7356 } 7357 DelegatingCtorDecls.clear(); 7358 } 7359 7360 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 7361 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 7362 TypedefNameDecl *D 7363 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 7364 if (D) 7365 Decls.push_back(D); 7366 } 7367 ExtVectorDecls.clear(); 7368 } 7369 7370 void ASTReader::ReadUnusedLocalTypedefNameCandidates( 7371 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) { 7372 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N; 7373 ++I) { 7374 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>( 7375 GetDecl(UnusedLocalTypedefNameCandidates[I])); 7376 if (D) 7377 Decls.insert(D); 7378 } 7379 UnusedLocalTypedefNameCandidates.clear(); 7380 } 7381 7382 void ASTReader::ReadReferencedSelectors( 7383 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 7384 if (ReferencedSelectorsData.empty()) 7385 return; 7386 7387 // If there are @selector references added them to its pool. This is for 7388 // implementation of -Wselector. 7389 unsigned int DataSize = ReferencedSelectorsData.size()-1; 7390 unsigned I = 0; 7391 while (I < DataSize) { 7392 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 7393 SourceLocation SelLoc 7394 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 7395 Sels.push_back(std::make_pair(Sel, SelLoc)); 7396 } 7397 ReferencedSelectorsData.clear(); 7398 } 7399 7400 void ASTReader::ReadWeakUndeclaredIdentifiers( 7401 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 7402 if (WeakUndeclaredIdentifiers.empty()) 7403 return; 7404 7405 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 7406 IdentifierInfo *WeakId 7407 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 7408 IdentifierInfo *AliasId 7409 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 7410 SourceLocation Loc 7411 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 7412 bool Used = WeakUndeclaredIdentifiers[I++]; 7413 WeakInfo WI(AliasId, Loc); 7414 WI.setUsed(Used); 7415 WeakIDs.push_back(std::make_pair(WeakId, WI)); 7416 } 7417 WeakUndeclaredIdentifiers.clear(); 7418 } 7419 7420 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 7421 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 7422 ExternalVTableUse VT; 7423 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 7424 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 7425 VT.DefinitionRequired = VTableUses[Idx++]; 7426 VTables.push_back(VT); 7427 } 7428 7429 VTableUses.clear(); 7430 } 7431 7432 void ASTReader::ReadPendingInstantiations( 7433 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 7434 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 7435 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 7436 SourceLocation Loc 7437 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 7438 7439 Pending.push_back(std::make_pair(D, Loc)); 7440 } 7441 PendingInstantiations.clear(); 7442 } 7443 7444 void ASTReader::ReadLateParsedTemplates( 7445 llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &LPTMap) { 7446 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N; 7447 /* In loop */) { 7448 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++])); 7449 7450 LateParsedTemplate *LT = new LateParsedTemplate; 7451 LT->D = GetDecl(LateParsedTemplates[Idx++]); 7452 7453 ModuleFile *F = getOwningModuleFile(LT->D); 7454 assert(F && "No module"); 7455 7456 unsigned TokN = LateParsedTemplates[Idx++]; 7457 LT->Toks.reserve(TokN); 7458 for (unsigned T = 0; T < TokN; ++T) 7459 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx)); 7460 7461 LPTMap.insert(std::make_pair(FD, LT)); 7462 } 7463 7464 LateParsedTemplates.clear(); 7465 } 7466 7467 void ASTReader::LoadSelector(Selector Sel) { 7468 // It would be complicated to avoid reading the methods anyway. So don't. 7469 ReadMethodPool(Sel); 7470 } 7471 7472 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 7473 assert(ID && "Non-zero identifier ID required"); 7474 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 7475 IdentifiersLoaded[ID - 1] = II; 7476 if (DeserializationListener) 7477 DeserializationListener->IdentifierRead(ID, II); 7478 } 7479 7480 /// \brief Set the globally-visible declarations associated with the given 7481 /// identifier. 7482 /// 7483 /// If the AST reader is currently in a state where the given declaration IDs 7484 /// cannot safely be resolved, they are queued until it is safe to resolve 7485 /// them. 7486 /// 7487 /// \param II an IdentifierInfo that refers to one or more globally-visible 7488 /// declarations. 7489 /// 7490 /// \param DeclIDs the set of declaration IDs with the name @p II that are 7491 /// visible at global scope. 7492 /// 7493 /// \param Decls if non-null, this vector will be populated with the set of 7494 /// deserialized declarations. These declarations will not be pushed into 7495 /// scope. 7496 void 7497 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 7498 const SmallVectorImpl<uint32_t> &DeclIDs, 7499 SmallVectorImpl<Decl *> *Decls) { 7500 if (NumCurrentElementsDeserializing && !Decls) { 7501 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end()); 7502 return; 7503 } 7504 7505 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 7506 if (!SemaObj) { 7507 // Queue this declaration so that it will be added to the 7508 // translation unit scope and identifier's declaration chain 7509 // once a Sema object is known. 7510 PreloadedDeclIDs.push_back(DeclIDs[I]); 7511 continue; 7512 } 7513 7514 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 7515 7516 // If we're simply supposed to record the declarations, do so now. 7517 if (Decls) { 7518 Decls->push_back(D); 7519 continue; 7520 } 7521 7522 // Introduce this declaration into the translation-unit scope 7523 // and add it to the declaration chain for this identifier, so 7524 // that (unqualified) name lookup will find it. 7525 pushExternalDeclIntoScope(D, II); 7526 } 7527 } 7528 7529 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 7530 if (ID == 0) 7531 return nullptr; 7532 7533 if (IdentifiersLoaded.empty()) { 7534 Error("no identifier table in AST file"); 7535 return nullptr; 7536 } 7537 7538 ID -= 1; 7539 if (!IdentifiersLoaded[ID]) { 7540 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 7541 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 7542 ModuleFile *M = I->second; 7543 unsigned Index = ID - M->BaseIdentifierID; 7544 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 7545 7546 // All of the strings in the AST file are preceded by a 16-bit length. 7547 // Extract that 16-bit length to avoid having to execute strlen(). 7548 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 7549 // unsigned integers. This is important to avoid integer overflow when 7550 // we cast them to 'unsigned'. 7551 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 7552 unsigned StrLen = (((unsigned) StrLenPtr[0]) 7553 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 7554 IdentifiersLoaded[ID] 7555 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 7556 if (DeserializationListener) 7557 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 7558 } 7559 7560 return IdentifiersLoaded[ID]; 7561 } 7562 7563 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 7564 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 7565 } 7566 7567 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 7568 if (LocalID < NUM_PREDEF_IDENT_IDS) 7569 return LocalID; 7570 7571 ContinuousRangeMap<uint32_t, int, 2>::iterator I 7572 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 7573 assert(I != M.IdentifierRemap.end() 7574 && "Invalid index into identifier index remap"); 7575 7576 return LocalID + I->second; 7577 } 7578 7579 MacroInfo *ASTReader::getMacro(MacroID ID) { 7580 if (ID == 0) 7581 return nullptr; 7582 7583 if (MacrosLoaded.empty()) { 7584 Error("no macro table in AST file"); 7585 return nullptr; 7586 } 7587 7588 ID -= NUM_PREDEF_MACRO_IDS; 7589 if (!MacrosLoaded[ID]) { 7590 GlobalMacroMapType::iterator I 7591 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS); 7592 assert(I != GlobalMacroMap.end() && "Corrupted global macro map"); 7593 ModuleFile *M = I->second; 7594 unsigned Index = ID - M->BaseMacroID; 7595 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]); 7596 7597 if (DeserializationListener) 7598 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS, 7599 MacrosLoaded[ID]); 7600 } 7601 7602 return MacrosLoaded[ID]; 7603 } 7604 7605 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) { 7606 if (LocalID < NUM_PREDEF_MACRO_IDS) 7607 return LocalID; 7608 7609 ContinuousRangeMap<uint32_t, int, 2>::iterator I 7610 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS); 7611 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap"); 7612 7613 return LocalID + I->second; 7614 } 7615 7616 serialization::SubmoduleID 7617 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 7618 if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 7619 return LocalID; 7620 7621 ContinuousRangeMap<uint32_t, int, 2>::iterator I 7622 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 7623 assert(I != M.SubmoduleRemap.end() 7624 && "Invalid index into submodule index remap"); 7625 7626 return LocalID + I->second; 7627 } 7628 7629 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) { 7630 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 7631 assert(GlobalID == 0 && "Unhandled global submodule ID"); 7632 return nullptr; 7633 } 7634 7635 if (GlobalID > SubmodulesLoaded.size()) { 7636 Error("submodule ID out of range in AST file"); 7637 return nullptr; 7638 } 7639 7640 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 7641 } 7642 7643 Module *ASTReader::getModule(unsigned ID) { 7644 return getSubmodule(ID); 7645 } 7646 7647 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 7648 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 7649 } 7650 7651 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 7652 if (ID == 0) 7653 return Selector(); 7654 7655 if (ID > SelectorsLoaded.size()) { 7656 Error("selector ID out of range in AST file"); 7657 return Selector(); 7658 } 7659 7660 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) { 7661 // Load this selector from the selector table. 7662 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 7663 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 7664 ModuleFile &M = *I->second; 7665 ASTSelectorLookupTrait Trait(*this, M); 7666 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 7667 SelectorsLoaded[ID - 1] = 7668 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 7669 if (DeserializationListener) 7670 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 7671 } 7672 7673 return SelectorsLoaded[ID - 1]; 7674 } 7675 7676 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 7677 return DecodeSelector(ID); 7678 } 7679 7680 uint32_t ASTReader::GetNumExternalSelectors() { 7681 // ID 0 (the null selector) is considered an external selector. 7682 return getTotalNumSelectors() + 1; 7683 } 7684 7685 serialization::SelectorID 7686 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 7687 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 7688 return LocalID; 7689 7690 ContinuousRangeMap<uint32_t, int, 2>::iterator I 7691 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 7692 assert(I != M.SelectorRemap.end() 7693 && "Invalid index into selector index remap"); 7694 7695 return LocalID + I->second; 7696 } 7697 7698 DeclarationName 7699 ASTReader::ReadDeclarationName(ModuleFile &F, 7700 const RecordData &Record, unsigned &Idx) { 7701 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 7702 switch (Kind) { 7703 case DeclarationName::Identifier: 7704 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 7705 7706 case DeclarationName::ObjCZeroArgSelector: 7707 case DeclarationName::ObjCOneArgSelector: 7708 case DeclarationName::ObjCMultiArgSelector: 7709 return DeclarationName(ReadSelector(F, Record, Idx)); 7710 7711 case DeclarationName::CXXConstructorName: 7712 return Context.DeclarationNames.getCXXConstructorName( 7713 Context.getCanonicalType(readType(F, Record, Idx))); 7714 7715 case DeclarationName::CXXDestructorName: 7716 return Context.DeclarationNames.getCXXDestructorName( 7717 Context.getCanonicalType(readType(F, Record, Idx))); 7718 7719 case DeclarationName::CXXConversionFunctionName: 7720 return Context.DeclarationNames.getCXXConversionFunctionName( 7721 Context.getCanonicalType(readType(F, Record, Idx))); 7722 7723 case DeclarationName::CXXOperatorName: 7724 return Context.DeclarationNames.getCXXOperatorName( 7725 (OverloadedOperatorKind)Record[Idx++]); 7726 7727 case DeclarationName::CXXLiteralOperatorName: 7728 return Context.DeclarationNames.getCXXLiteralOperatorName( 7729 GetIdentifierInfo(F, Record, Idx)); 7730 7731 case DeclarationName::CXXUsingDirective: 7732 return DeclarationName::getUsingDirectiveName(); 7733 } 7734 7735 llvm_unreachable("Invalid NameKind!"); 7736 } 7737 7738 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 7739 DeclarationNameLoc &DNLoc, 7740 DeclarationName Name, 7741 const RecordData &Record, unsigned &Idx) { 7742 switch (Name.getNameKind()) { 7743 case DeclarationName::CXXConstructorName: 7744 case DeclarationName::CXXDestructorName: 7745 case DeclarationName::CXXConversionFunctionName: 7746 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 7747 break; 7748 7749 case DeclarationName::CXXOperatorName: 7750 DNLoc.CXXOperatorName.BeginOpNameLoc 7751 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 7752 DNLoc.CXXOperatorName.EndOpNameLoc 7753 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 7754 break; 7755 7756 case DeclarationName::CXXLiteralOperatorName: 7757 DNLoc.CXXLiteralOperatorName.OpNameLoc 7758 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 7759 break; 7760 7761 case DeclarationName::Identifier: 7762 case DeclarationName::ObjCZeroArgSelector: 7763 case DeclarationName::ObjCOneArgSelector: 7764 case DeclarationName::ObjCMultiArgSelector: 7765 case DeclarationName::CXXUsingDirective: 7766 break; 7767 } 7768 } 7769 7770 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 7771 DeclarationNameInfo &NameInfo, 7772 const RecordData &Record, unsigned &Idx) { 7773 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 7774 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 7775 DeclarationNameLoc DNLoc; 7776 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 7777 NameInfo.setInfo(DNLoc); 7778 } 7779 7780 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 7781 const RecordData &Record, unsigned &Idx) { 7782 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 7783 unsigned NumTPLists = Record[Idx++]; 7784 Info.NumTemplParamLists = NumTPLists; 7785 if (NumTPLists) { 7786 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 7787 for (unsigned i=0; i != NumTPLists; ++i) 7788 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 7789 } 7790 } 7791 7792 TemplateName 7793 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 7794 unsigned &Idx) { 7795 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 7796 switch (Kind) { 7797 case TemplateName::Template: 7798 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 7799 7800 case TemplateName::OverloadedTemplate: { 7801 unsigned size = Record[Idx++]; 7802 UnresolvedSet<8> Decls; 7803 while (size--) 7804 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 7805 7806 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 7807 } 7808 7809 case TemplateName::QualifiedTemplate: { 7810 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 7811 bool hasTemplKeyword = Record[Idx++]; 7812 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 7813 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 7814 } 7815 7816 case TemplateName::DependentTemplate: { 7817 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 7818 if (Record[Idx++]) // isIdentifier 7819 return Context.getDependentTemplateName(NNS, 7820 GetIdentifierInfo(F, Record, 7821 Idx)); 7822 return Context.getDependentTemplateName(NNS, 7823 (OverloadedOperatorKind)Record[Idx++]); 7824 } 7825 7826 case TemplateName::SubstTemplateTemplateParm: { 7827 TemplateTemplateParmDecl *param 7828 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 7829 if (!param) return TemplateName(); 7830 TemplateName replacement = ReadTemplateName(F, Record, Idx); 7831 return Context.getSubstTemplateTemplateParm(param, replacement); 7832 } 7833 7834 case TemplateName::SubstTemplateTemplateParmPack: { 7835 TemplateTemplateParmDecl *Param 7836 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 7837 if (!Param) 7838 return TemplateName(); 7839 7840 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 7841 if (ArgPack.getKind() != TemplateArgument::Pack) 7842 return TemplateName(); 7843 7844 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 7845 } 7846 } 7847 7848 llvm_unreachable("Unhandled template name kind!"); 7849 } 7850 7851 TemplateArgument 7852 ASTReader::ReadTemplateArgument(ModuleFile &F, 7853 const RecordData &Record, unsigned &Idx) { 7854 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 7855 switch (Kind) { 7856 case TemplateArgument::Null: 7857 return TemplateArgument(); 7858 case TemplateArgument::Type: 7859 return TemplateArgument(readType(F, Record, Idx)); 7860 case TemplateArgument::Declaration: { 7861 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx); 7862 return TemplateArgument(D, readType(F, Record, Idx)); 7863 } 7864 case TemplateArgument::NullPtr: 7865 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true); 7866 case TemplateArgument::Integral: { 7867 llvm::APSInt Value = ReadAPSInt(Record, Idx); 7868 QualType T = readType(F, Record, Idx); 7869 return TemplateArgument(Context, Value, T); 7870 } 7871 case TemplateArgument::Template: 7872 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 7873 case TemplateArgument::TemplateExpansion: { 7874 TemplateName Name = ReadTemplateName(F, Record, Idx); 7875 Optional<unsigned> NumTemplateExpansions; 7876 if (unsigned NumExpansions = Record[Idx++]) 7877 NumTemplateExpansions = NumExpansions - 1; 7878 return TemplateArgument(Name, NumTemplateExpansions); 7879 } 7880 case TemplateArgument::Expression: 7881 return TemplateArgument(ReadExpr(F)); 7882 case TemplateArgument::Pack: { 7883 unsigned NumArgs = Record[Idx++]; 7884 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 7885 for (unsigned I = 0; I != NumArgs; ++I) 7886 Args[I] = ReadTemplateArgument(F, Record, Idx); 7887 return TemplateArgument(Args, NumArgs); 7888 } 7889 } 7890 7891 llvm_unreachable("Unhandled template argument kind!"); 7892 } 7893 7894 TemplateParameterList * 7895 ASTReader::ReadTemplateParameterList(ModuleFile &F, 7896 const RecordData &Record, unsigned &Idx) { 7897 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 7898 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 7899 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 7900 7901 unsigned NumParams = Record[Idx++]; 7902 SmallVector<NamedDecl *, 16> Params; 7903 Params.reserve(NumParams); 7904 while (NumParams--) 7905 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 7906 7907 TemplateParameterList* TemplateParams = 7908 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 7909 Params.data(), Params.size(), RAngleLoc); 7910 return TemplateParams; 7911 } 7912 7913 void 7914 ASTReader:: 7915 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs, 7916 ModuleFile &F, const RecordData &Record, 7917 unsigned &Idx) { 7918 unsigned NumTemplateArgs = Record[Idx++]; 7919 TemplArgs.reserve(NumTemplateArgs); 7920 while (NumTemplateArgs--) 7921 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 7922 } 7923 7924 /// \brief Read a UnresolvedSet structure. 7925 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set, 7926 const RecordData &Record, unsigned &Idx) { 7927 unsigned NumDecls = Record[Idx++]; 7928 Set.reserve(Context, NumDecls); 7929 while (NumDecls--) { 7930 DeclID ID = ReadDeclID(F, Record, Idx); 7931 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 7932 Set.addLazyDecl(Context, ID, AS); 7933 } 7934 } 7935 7936 CXXBaseSpecifier 7937 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 7938 const RecordData &Record, unsigned &Idx) { 7939 bool isVirtual = static_cast<bool>(Record[Idx++]); 7940 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 7941 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 7942 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 7943 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 7944 SourceRange Range = ReadSourceRange(F, Record, Idx); 7945 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 7946 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 7947 EllipsisLoc); 7948 Result.setInheritConstructors(inheritConstructors); 7949 return Result; 7950 } 7951 7952 CXXCtorInitializer ** 7953 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 7954 unsigned &Idx) { 7955 unsigned NumInitializers = Record[Idx++]; 7956 assert(NumInitializers && "wrote ctor initializers but have no inits"); 7957 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers]; 7958 for (unsigned i = 0; i != NumInitializers; ++i) { 7959 TypeSourceInfo *TInfo = nullptr; 7960 bool IsBaseVirtual = false; 7961 FieldDecl *Member = nullptr; 7962 IndirectFieldDecl *IndirectMember = nullptr; 7963 7964 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 7965 switch (Type) { 7966 case CTOR_INITIALIZER_BASE: 7967 TInfo = GetTypeSourceInfo(F, Record, Idx); 7968 IsBaseVirtual = Record[Idx++]; 7969 break; 7970 7971 case CTOR_INITIALIZER_DELEGATING: 7972 TInfo = GetTypeSourceInfo(F, Record, Idx); 7973 break; 7974 7975 case CTOR_INITIALIZER_MEMBER: 7976 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 7977 break; 7978 7979 case CTOR_INITIALIZER_INDIRECT_MEMBER: 7980 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 7981 break; 7982 } 7983 7984 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 7985 Expr *Init = ReadExpr(F); 7986 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 7987 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 7988 bool IsWritten = Record[Idx++]; 7989 unsigned SourceOrderOrNumArrayIndices; 7990 SmallVector<VarDecl *, 8> Indices; 7991 if (IsWritten) { 7992 SourceOrderOrNumArrayIndices = Record[Idx++]; 7993 } else { 7994 SourceOrderOrNumArrayIndices = Record[Idx++]; 7995 Indices.reserve(SourceOrderOrNumArrayIndices); 7996 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 7997 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 7998 } 7999 8000 CXXCtorInitializer *BOMInit; 8001 if (Type == CTOR_INITIALIZER_BASE) { 8002 BOMInit = new (Context) 8003 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init, 8004 RParenLoc, MemberOrEllipsisLoc); 8005 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 8006 BOMInit = new (Context) 8007 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc); 8008 } else if (IsWritten) { 8009 if (Member) 8010 BOMInit = new (Context) CXXCtorInitializer( 8011 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc); 8012 else 8013 BOMInit = new (Context) 8014 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc, 8015 LParenLoc, Init, RParenLoc); 8016 } else { 8017 if (IndirectMember) { 8018 assert(Indices.empty() && "Indirect field improperly initialized"); 8019 BOMInit = new (Context) 8020 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc, 8021 LParenLoc, Init, RParenLoc); 8022 } else { 8023 BOMInit = CXXCtorInitializer::Create( 8024 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc, 8025 Indices.data(), Indices.size()); 8026 } 8027 } 8028 8029 if (IsWritten) 8030 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 8031 CtorInitializers[i] = BOMInit; 8032 } 8033 8034 return CtorInitializers; 8035 } 8036 8037 NestedNameSpecifier * 8038 ASTReader::ReadNestedNameSpecifier(ModuleFile &F, 8039 const RecordData &Record, unsigned &Idx) { 8040 unsigned N = Record[Idx++]; 8041 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr; 8042 for (unsigned I = 0; I != N; ++I) { 8043 NestedNameSpecifier::SpecifierKind Kind 8044 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 8045 switch (Kind) { 8046 case NestedNameSpecifier::Identifier: { 8047 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 8048 NNS = NestedNameSpecifier::Create(Context, Prev, II); 8049 break; 8050 } 8051 8052 case NestedNameSpecifier::Namespace: { 8053 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 8054 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 8055 break; 8056 } 8057 8058 case NestedNameSpecifier::NamespaceAlias: { 8059 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 8060 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 8061 break; 8062 } 8063 8064 case NestedNameSpecifier::TypeSpec: 8065 case NestedNameSpecifier::TypeSpecWithTemplate: { 8066 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 8067 if (!T) 8068 return nullptr; 8069 8070 bool Template = Record[Idx++]; 8071 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 8072 break; 8073 } 8074 8075 case NestedNameSpecifier::Global: { 8076 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 8077 // No associated value, and there can't be a prefix. 8078 break; 8079 } 8080 8081 case NestedNameSpecifier::Super: { 8082 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx); 8083 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD); 8084 break; 8085 } 8086 } 8087 Prev = NNS; 8088 } 8089 return NNS; 8090 } 8091 8092 NestedNameSpecifierLoc 8093 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 8094 unsigned &Idx) { 8095 unsigned N = Record[Idx++]; 8096 NestedNameSpecifierLocBuilder Builder; 8097 for (unsigned I = 0; I != N; ++I) { 8098 NestedNameSpecifier::SpecifierKind Kind 8099 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 8100 switch (Kind) { 8101 case NestedNameSpecifier::Identifier: { 8102 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 8103 SourceRange Range = ReadSourceRange(F, Record, Idx); 8104 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 8105 break; 8106 } 8107 8108 case NestedNameSpecifier::Namespace: { 8109 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 8110 SourceRange Range = ReadSourceRange(F, Record, Idx); 8111 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 8112 break; 8113 } 8114 8115 case NestedNameSpecifier::NamespaceAlias: { 8116 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 8117 SourceRange Range = ReadSourceRange(F, Record, Idx); 8118 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 8119 break; 8120 } 8121 8122 case NestedNameSpecifier::TypeSpec: 8123 case NestedNameSpecifier::TypeSpecWithTemplate: { 8124 bool Template = Record[Idx++]; 8125 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 8126 if (!T) 8127 return NestedNameSpecifierLoc(); 8128 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 8129 8130 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 8131 Builder.Extend(Context, 8132 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 8133 T->getTypeLoc(), ColonColonLoc); 8134 break; 8135 } 8136 8137 case NestedNameSpecifier::Global: { 8138 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 8139 Builder.MakeGlobal(Context, ColonColonLoc); 8140 break; 8141 } 8142 8143 case NestedNameSpecifier::Super: { 8144 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx); 8145 SourceRange Range = ReadSourceRange(F, Record, Idx); 8146 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd()); 8147 break; 8148 } 8149 } 8150 } 8151 8152 return Builder.getWithLocInContext(Context); 8153 } 8154 8155 SourceRange 8156 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 8157 unsigned &Idx) { 8158 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 8159 SourceLocation end = ReadSourceLocation(F, Record, Idx); 8160 return SourceRange(beg, end); 8161 } 8162 8163 /// \brief Read an integral value 8164 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 8165 unsigned BitWidth = Record[Idx++]; 8166 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 8167 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 8168 Idx += NumWords; 8169 return Result; 8170 } 8171 8172 /// \brief Read a signed integral value 8173 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 8174 bool isUnsigned = Record[Idx++]; 8175 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 8176 } 8177 8178 /// \brief Read a floating-point value 8179 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, 8180 const llvm::fltSemantics &Sem, 8181 unsigned &Idx) { 8182 return llvm::APFloat(Sem, ReadAPInt(Record, Idx)); 8183 } 8184 8185 // \brief Read a string 8186 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 8187 unsigned Len = Record[Idx++]; 8188 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 8189 Idx += Len; 8190 return Result; 8191 } 8192 8193 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record, 8194 unsigned &Idx) { 8195 std::string Filename = ReadString(Record, Idx); 8196 ResolveImportedPath(F, Filename); 8197 return Filename; 8198 } 8199 8200 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 8201 unsigned &Idx) { 8202 unsigned Major = Record[Idx++]; 8203 unsigned Minor = Record[Idx++]; 8204 unsigned Subminor = Record[Idx++]; 8205 if (Minor == 0) 8206 return VersionTuple(Major); 8207 if (Subminor == 0) 8208 return VersionTuple(Major, Minor - 1); 8209 return VersionTuple(Major, Minor - 1, Subminor - 1); 8210 } 8211 8212 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 8213 const RecordData &Record, 8214 unsigned &Idx) { 8215 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 8216 return CXXTemporary::Create(Context, Decl); 8217 } 8218 8219 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 8220 return Diag(CurrentImportLoc, DiagID); 8221 } 8222 8223 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 8224 return Diags.Report(Loc, DiagID); 8225 } 8226 8227 /// \brief Retrieve the identifier table associated with the 8228 /// preprocessor. 8229 IdentifierTable &ASTReader::getIdentifierTable() { 8230 return PP.getIdentifierTable(); 8231 } 8232 8233 /// \brief Record that the given ID maps to the given switch-case 8234 /// statement. 8235 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 8236 assert((*CurrSwitchCaseStmts)[ID] == nullptr && 8237 "Already have a SwitchCase with this ID"); 8238 (*CurrSwitchCaseStmts)[ID] = SC; 8239 } 8240 8241 /// \brief Retrieve the switch-case statement with the given ID. 8242 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 8243 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID"); 8244 return (*CurrSwitchCaseStmts)[ID]; 8245 } 8246 8247 void ASTReader::ClearSwitchCaseIDs() { 8248 CurrSwitchCaseStmts->clear(); 8249 } 8250 8251 void ASTReader::ReadComments() { 8252 std::vector<RawComment *> Comments; 8253 for (SmallVectorImpl<std::pair<BitstreamCursor, 8254 serialization::ModuleFile *> >::iterator 8255 I = CommentsCursors.begin(), 8256 E = CommentsCursors.end(); 8257 I != E; ++I) { 8258 Comments.clear(); 8259 BitstreamCursor &Cursor = I->first; 8260 serialization::ModuleFile &F = *I->second; 8261 SavedStreamPosition SavedPosition(Cursor); 8262 8263 RecordData Record; 8264 while (true) { 8265 llvm::BitstreamEntry Entry = 8266 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd); 8267 8268 switch (Entry.Kind) { 8269 case llvm::BitstreamEntry::SubBlock: // Handled for us already. 8270 case llvm::BitstreamEntry::Error: 8271 Error("malformed block record in AST file"); 8272 return; 8273 case llvm::BitstreamEntry::EndBlock: 8274 goto NextCursor; 8275 case llvm::BitstreamEntry::Record: 8276 // The interesting case. 8277 break; 8278 } 8279 8280 // Read a record. 8281 Record.clear(); 8282 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) { 8283 case COMMENTS_RAW_COMMENT: { 8284 unsigned Idx = 0; 8285 SourceRange SR = ReadSourceRange(F, Record, Idx); 8286 RawComment::CommentKind Kind = 8287 (RawComment::CommentKind) Record[Idx++]; 8288 bool IsTrailingComment = Record[Idx++]; 8289 bool IsAlmostTrailingComment = Record[Idx++]; 8290 Comments.push_back(new (Context) RawComment( 8291 SR, Kind, IsTrailingComment, IsAlmostTrailingComment, 8292 Context.getLangOpts().CommentOpts.ParseAllComments)); 8293 break; 8294 } 8295 } 8296 } 8297 NextCursor: 8298 Context.Comments.addDeserializedComments(Comments); 8299 } 8300 } 8301 8302 void ASTReader::getInputFiles(ModuleFile &F, 8303 SmallVectorImpl<serialization::InputFile> &Files) { 8304 for (unsigned I = 0, E = F.InputFilesLoaded.size(); I != E; ++I) { 8305 unsigned ID = I+1; 8306 Files.push_back(getInputFile(F, ID)); 8307 } 8308 } 8309 8310 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) { 8311 // If we know the owning module, use it. 8312 if (Module *M = D->getOwningModule()) 8313 return M->getFullModuleName(); 8314 8315 // Otherwise, use the name of the top-level module the decl is within. 8316 if (ModuleFile *M = getOwningModuleFile(D)) 8317 return M->ModuleName; 8318 8319 // Not from a module. 8320 return ""; 8321 } 8322 8323 void ASTReader::finishPendingActions() { 8324 while (!PendingIdentifierInfos.empty() || 8325 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() || 8326 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() || 8327 !PendingUpdateRecords.empty()) { 8328 // If any identifiers with corresponding top-level declarations have 8329 // been loaded, load those declarations now. 8330 typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> > 8331 TopLevelDeclsMap; 8332 TopLevelDeclsMap TopLevelDecls; 8333 8334 while (!PendingIdentifierInfos.empty()) { 8335 IdentifierInfo *II = PendingIdentifierInfos.back().first; 8336 SmallVector<uint32_t, 4> DeclIDs = 8337 std::move(PendingIdentifierInfos.back().second); 8338 PendingIdentifierInfos.pop_back(); 8339 8340 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]); 8341 } 8342 8343 // For each decl chain that we wanted to complete while deserializing, mark 8344 // it as "still needs to be completed". 8345 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) { 8346 markIncompleteDeclChain(PendingIncompleteDeclChains[I]); 8347 } 8348 PendingIncompleteDeclChains.clear(); 8349 8350 // Load pending declaration chains. 8351 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 8352 PendingDeclChainsKnown.erase(PendingDeclChains[I]); 8353 loadPendingDeclChain(PendingDeclChains[I]); 8354 } 8355 assert(PendingDeclChainsKnown.empty()); 8356 PendingDeclChains.clear(); 8357 8358 // Make the most recent of the top-level declarations visible. 8359 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(), 8360 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) { 8361 IdentifierInfo *II = TLD->first; 8362 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) { 8363 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II); 8364 } 8365 } 8366 8367 // Load any pending macro definitions. 8368 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) { 8369 IdentifierInfo *II = PendingMacroIDs.begin()[I].first; 8370 SmallVector<PendingMacroInfo, 2> GlobalIDs; 8371 GlobalIDs.swap(PendingMacroIDs.begin()[I].second); 8372 // Initialize the macro history from chained-PCHs ahead of module imports. 8373 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 8374 ++IDIdx) { 8375 const PendingMacroInfo &Info = GlobalIDs[IDIdx]; 8376 if (Info.M->Kind != MK_ImplicitModule && 8377 Info.M->Kind != MK_ExplicitModule) 8378 resolvePendingMacro(II, Info); 8379 } 8380 // Handle module imports. 8381 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 8382 ++IDIdx) { 8383 const PendingMacroInfo &Info = GlobalIDs[IDIdx]; 8384 if (Info.M->Kind == MK_ImplicitModule || 8385 Info.M->Kind == MK_ExplicitModule) 8386 resolvePendingMacro(II, Info); 8387 } 8388 } 8389 PendingMacroIDs.clear(); 8390 8391 // Wire up the DeclContexts for Decls that we delayed setting until 8392 // recursive loading is completed. 8393 while (!PendingDeclContextInfos.empty()) { 8394 PendingDeclContextInfo Info = PendingDeclContextInfos.front(); 8395 PendingDeclContextInfos.pop_front(); 8396 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC)); 8397 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC)); 8398 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext()); 8399 } 8400 8401 // Perform any pending declaration updates. 8402 while (!PendingUpdateRecords.empty()) { 8403 auto Update = PendingUpdateRecords.pop_back_val(); 8404 ReadingKindTracker ReadingKind(Read_Decl, *this); 8405 loadDeclUpdateRecords(Update.first, Update.second); 8406 } 8407 } 8408 8409 // At this point, all update records for loaded decls are in place, so any 8410 // fake class definitions should have become real. 8411 assert(PendingFakeDefinitionData.empty() && 8412 "faked up a class definition but never saw the real one"); 8413 8414 // If we deserialized any C++ or Objective-C class definitions, any 8415 // Objective-C protocol definitions, or any redeclarable templates, make sure 8416 // that all redeclarations point to the definitions. Note that this can only 8417 // happen now, after the redeclaration chains have been fully wired. 8418 for (Decl *D : PendingDefinitions) { 8419 if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 8420 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) { 8421 // Make sure that the TagType points at the definition. 8422 const_cast<TagType*>(TagT)->decl = TD; 8423 } 8424 8425 if (auto RD = dyn_cast<CXXRecordDecl>(D)) { 8426 for (auto *R = getMostRecentExistingDecl(RD); R; 8427 R = R->getPreviousDecl()) { 8428 assert((R == D) == 8429 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() && 8430 "declaration thinks it's the definition but it isn't"); 8431 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData; 8432 } 8433 } 8434 8435 continue; 8436 } 8437 8438 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) { 8439 // Make sure that the ObjCInterfaceType points at the definition. 8440 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl)) 8441 ->Decl = ID; 8442 8443 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl()) 8444 cast<ObjCInterfaceDecl>(R)->Data = ID->Data; 8445 8446 continue; 8447 } 8448 8449 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) { 8450 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl()) 8451 cast<ObjCProtocolDecl>(R)->Data = PD->Data; 8452 8453 continue; 8454 } 8455 8456 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl(); 8457 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl()) 8458 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common; 8459 } 8460 PendingDefinitions.clear(); 8461 8462 // Load the bodies of any functions or methods we've encountered. We do 8463 // this now (delayed) so that we can be sure that the declaration chains 8464 // have been fully wired up. 8465 // FIXME: There seems to be no point in delaying this, it does not depend 8466 // on the redecl chains having been wired up. 8467 for (PendingBodiesMap::iterator PB = PendingBodies.begin(), 8468 PBEnd = PendingBodies.end(); 8469 PB != PBEnd; ++PB) { 8470 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) { 8471 // FIXME: Check for =delete/=default? 8472 // FIXME: Complain about ODR violations here? 8473 if (!getContext().getLangOpts().Modules || !FD->hasBody()) 8474 FD->setLazyBody(PB->second); 8475 continue; 8476 } 8477 8478 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first); 8479 if (!getContext().getLangOpts().Modules || !MD->hasBody()) 8480 MD->setLazyBody(PB->second); 8481 } 8482 PendingBodies.clear(); 8483 } 8484 8485 void ASTReader::diagnoseOdrViolations() { 8486 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty()) 8487 return; 8488 8489 // Trigger the import of the full definition of each class that had any 8490 // odr-merging problems, so we can produce better diagnostics for them. 8491 // These updates may in turn find and diagnose some ODR failures, so take 8492 // ownership of the set first. 8493 auto OdrMergeFailures = std::move(PendingOdrMergeFailures); 8494 PendingOdrMergeFailures.clear(); 8495 for (auto &Merge : OdrMergeFailures) { 8496 Merge.first->buildLookup(); 8497 Merge.first->decls_begin(); 8498 Merge.first->bases_begin(); 8499 Merge.first->vbases_begin(); 8500 for (auto *RD : Merge.second) { 8501 RD->decls_begin(); 8502 RD->bases_begin(); 8503 RD->vbases_begin(); 8504 } 8505 } 8506 8507 // For each declaration from a merged context, check that the canonical 8508 // definition of that context also contains a declaration of the same 8509 // entity. 8510 // 8511 // Caution: this loop does things that might invalidate iterators into 8512 // PendingOdrMergeChecks. Don't turn this into a range-based for loop! 8513 while (!PendingOdrMergeChecks.empty()) { 8514 NamedDecl *D = PendingOdrMergeChecks.pop_back_val(); 8515 8516 // FIXME: Skip over implicit declarations for now. This matters for things 8517 // like implicitly-declared special member functions. This isn't entirely 8518 // correct; we can end up with multiple unmerged declarations of the same 8519 // implicit entity. 8520 if (D->isImplicit()) 8521 continue; 8522 8523 DeclContext *CanonDef = D->getDeclContext(); 8524 8525 bool Found = false; 8526 const Decl *DCanon = D->getCanonicalDecl(); 8527 8528 for (auto RI : D->redecls()) { 8529 if (RI->getLexicalDeclContext() == CanonDef) { 8530 Found = true; 8531 break; 8532 } 8533 } 8534 if (Found) 8535 continue; 8536 8537 llvm::SmallVector<const NamedDecl*, 4> Candidates; 8538 DeclContext::lookup_result R = CanonDef->lookup(D->getDeclName()); 8539 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); 8540 !Found && I != E; ++I) { 8541 for (auto RI : (*I)->redecls()) { 8542 if (RI->getLexicalDeclContext() == CanonDef) { 8543 // This declaration is present in the canonical definition. If it's 8544 // in the same redecl chain, it's the one we're looking for. 8545 if (RI->getCanonicalDecl() == DCanon) 8546 Found = true; 8547 else 8548 Candidates.push_back(cast<NamedDecl>(RI)); 8549 break; 8550 } 8551 } 8552 } 8553 8554 if (!Found) { 8555 // The AST doesn't like TagDecls becoming invalid after they've been 8556 // completed. We only really need to mark FieldDecls as invalid here. 8557 if (!isa<TagDecl>(D)) 8558 D->setInvalidDecl(); 8559 8560 // Ensure we don't accidentally recursively enter deserialization while 8561 // we're producing our diagnostic. 8562 Deserializing RecursionGuard(this); 8563 8564 std::string CanonDefModule = 8565 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef)); 8566 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl) 8567 << D << getOwningModuleNameForDiagnostic(D) 8568 << CanonDef << CanonDefModule.empty() << CanonDefModule; 8569 8570 if (Candidates.empty()) 8571 Diag(cast<Decl>(CanonDef)->getLocation(), 8572 diag::note_module_odr_violation_no_possible_decls) << D; 8573 else { 8574 for (unsigned I = 0, N = Candidates.size(); I != N; ++I) 8575 Diag(Candidates[I]->getLocation(), 8576 diag::note_module_odr_violation_possible_decl) 8577 << Candidates[I]; 8578 } 8579 8580 DiagnosedOdrMergeFailures.insert(CanonDef); 8581 } 8582 } 8583 8584 if (OdrMergeFailures.empty()) 8585 return; 8586 8587 // Ensure we don't accidentally recursively enter deserialization while 8588 // we're producing our diagnostics. 8589 Deserializing RecursionGuard(this); 8590 8591 // Issue any pending ODR-failure diagnostics. 8592 for (auto &Merge : OdrMergeFailures) { 8593 // If we've already pointed out a specific problem with this class, don't 8594 // bother issuing a general "something's different" diagnostic. 8595 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second) 8596 continue; 8597 8598 bool Diagnosed = false; 8599 for (auto *RD : Merge.second) { 8600 // Multiple different declarations got merged together; tell the user 8601 // where they came from. 8602 if (Merge.first != RD) { 8603 // FIXME: Walk the definition, figure out what's different, 8604 // and diagnose that. 8605 if (!Diagnosed) { 8606 std::string Module = getOwningModuleNameForDiagnostic(Merge.first); 8607 Diag(Merge.first->getLocation(), 8608 diag::err_module_odr_violation_different_definitions) 8609 << Merge.first << Module.empty() << Module; 8610 Diagnosed = true; 8611 } 8612 8613 Diag(RD->getLocation(), 8614 diag::note_module_odr_violation_different_definitions) 8615 << getOwningModuleNameForDiagnostic(RD); 8616 } 8617 } 8618 8619 if (!Diagnosed) { 8620 // All definitions are updates to the same declaration. This happens if a 8621 // module instantiates the declaration of a class template specialization 8622 // and two or more other modules instantiate its definition. 8623 // 8624 // FIXME: Indicate which modules had instantiations of this definition. 8625 // FIXME: How can this even happen? 8626 Diag(Merge.first->getLocation(), 8627 diag::err_module_odr_violation_different_instantiations) 8628 << Merge.first; 8629 } 8630 } 8631 } 8632 8633 void ASTReader::FinishedDeserializing() { 8634 assert(NumCurrentElementsDeserializing && 8635 "FinishedDeserializing not paired with StartedDeserializing"); 8636 if (NumCurrentElementsDeserializing == 1) { 8637 // We decrease NumCurrentElementsDeserializing only after pending actions 8638 // are finished, to avoid recursively re-calling finishPendingActions(). 8639 finishPendingActions(); 8640 } 8641 --NumCurrentElementsDeserializing; 8642 8643 if (NumCurrentElementsDeserializing == 0) { 8644 // Propagate exception specification updates along redeclaration chains. 8645 while (!PendingExceptionSpecUpdates.empty()) { 8646 auto Updates = std::move(PendingExceptionSpecUpdates); 8647 PendingExceptionSpecUpdates.clear(); 8648 for (auto Update : Updates) { 8649 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>(); 8650 SemaObj->UpdateExceptionSpec(Update.second, 8651 FPT->getExtProtoInfo().ExceptionSpec); 8652 } 8653 } 8654 8655 diagnoseOdrViolations(); 8656 8657 // We are not in recursive loading, so it's safe to pass the "interesting" 8658 // decls to the consumer. 8659 if (Consumer) 8660 PassInterestingDeclsToConsumer(); 8661 } 8662 } 8663 8664 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 8665 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) { 8666 // Remove any fake results before adding any real ones. 8667 auto It = PendingFakeLookupResults.find(II); 8668 if (It != PendingFakeLookupResults.end()) { 8669 for (auto *ND : PendingFakeLookupResults[II]) 8670 SemaObj->IdResolver.RemoveDecl(ND); 8671 // FIXME: this works around module+PCH performance issue. 8672 // Rather than erase the result from the map, which is O(n), just clear 8673 // the vector of NamedDecls. 8674 It->second.clear(); 8675 } 8676 } 8677 8678 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) { 8679 SemaObj->TUScope->AddDecl(D); 8680 } else if (SemaObj->TUScope) { 8681 // Adding the decl to IdResolver may have failed because it was already in 8682 // (even though it was not added in scope). If it is already in, make sure 8683 // it gets in the scope as well. 8684 if (std::find(SemaObj->IdResolver.begin(Name), 8685 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end()) 8686 SemaObj->TUScope->AddDecl(D); 8687 } 8688 } 8689 8690 ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, StringRef isysroot, 8691 bool DisableValidation, bool AllowASTWithCompilerErrors, 8692 bool AllowConfigurationMismatch, bool ValidateSystemInputs, 8693 bool UseGlobalIndex) 8694 : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr), 8695 OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()), 8696 FileMgr(PP.getFileManager()), Diags(PP.getDiagnostics()), 8697 SemaObj(nullptr), PP(PP), Context(Context), Consumer(nullptr), 8698 ModuleMgr(PP.getFileManager()), isysroot(isysroot), 8699 DisableValidation(DisableValidation), 8700 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), 8701 AllowConfigurationMismatch(AllowConfigurationMismatch), 8702 ValidateSystemInputs(ValidateSystemInputs), 8703 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false), 8704 CurrSwitchCaseStmts(&SwitchCaseStmts), 8705 NumSLocEntriesRead(0), TotalNumSLocEntries(0), NumStatementsRead(0), 8706 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0), 8707 NumIdentifierLookups(0), NumIdentifierLookupHits(0), NumSelectorsRead(0), 8708 NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0), 8709 NumMethodPoolHits(0), NumMethodPoolTableLookups(0), 8710 NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0), 8711 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 8712 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 8713 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 8714 PassingDeclsToConsumer(false), ReadingKind(Read_None) { 8715 SourceMgr.setExternalSLocEntrySource(this); 8716 } 8717 8718 ASTReader::~ASTReader() { 8719 if (OwnsDeserializationListener) 8720 delete DeserializationListener; 8721 8722 for (DeclContextVisibleUpdatesPending::iterator 8723 I = PendingVisibleUpdates.begin(), 8724 E = PendingVisibleUpdates.end(); 8725 I != E; ++I) { 8726 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 8727 F = I->second.end(); 8728 J != F; ++J) 8729 delete J->first; 8730 } 8731 } 8732