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