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